Update AzureDALL-E and ZhipuaiVision providers

api/core/tools/provider/_model_providers.yaml

@@ -10,8 +10,8 @@ providers:
           zh_Hans: Gemini Pro 图像理解
   - provider: zhipuai
     alias:
-      en_US: ZhipuaiModel
-      zh_Hans: 智谱AI模型能力
+      en_US: ZhipuaiVision
+      zh_Hans: 智谱AI 图像理解
     models:
       - name: glm-4v
         alias:
@@ -19,8 +19,8 @@ providers:
           zh_Hans: GLM-4V 图像理解
   - provider: openai
     alias:
-      en_US: OpenAIModel
-      zh_Hans: OpenAI模型能力
+      en_US: OpenAIVision
+      zh_Hans: OpenAI 图像理解
     models:
       - name: gpt-4-vision-preview
         alias:

api/core/tools/provider/builtin/azuredalle/azuredalle.yaml

@@ -2,9 +2,9 @@ identity:
   author: Leslie
   name: azuredalle
   label:
-    en_US: AZURE DALL-E
-    zh_Hans: AZURE DALL-E 绘画
-    pt_BR: AZURE DALL-E
+    en_US: AzureDALL-E
+    zh_Hans: AzureDALL-E 绘画
+    pt_BR: AzureDALL-E
   description:
     en_US: AZURE DALL-E art
     zh_Hans: AZURE DALL-E 绘画

api/core/tools/tool_manager.py

@@ -3,6 +3,7 @@ from os import listdir, path
 
 from core.tools.entities.tool_entities import ToolInvokeMessage, ApiProviderAuthType, ToolProviderCredentials
 from core.tools.provider.tool_provider import ToolProviderController
+from core.tools.provider.model_tool_provider import ModelToolProviderController
 from core.tools.tool.builtin_tool import BuiltinTool
 from core.tools.tool.api_tool import ApiTool
 from core.tools.provider.builtin_tool_provider import BuiltinToolProviderController
@@ -15,6 +16,7 @@ from core.tools.entities.user_entities import UserToolProvider
 from core.tools.utils.configration import ToolConfiguration
 from core.tools.utils.encoder import serialize_base_model_dict
 from core.tools.provider.builtin._positions import BuiltinToolProviderSort
+from core.provider_manager import ProviderManager
 
 from core.model_runtime.entities.message_entities import PromptMessage
 from core.callback_handler.agent_tool_callback_handler import DifyAgentCallbackHandler
@@ -139,7 +141,7 @@ class ToolManager:
             raise ToolProviderNotFoundError(f'provider type {provider_type} not found')
         
     @staticmethod
-    def get_tool_runtime(provider_type: str, provider_name: str, tool_name: str, tanent_id, 
+    def get_tool_runtime(provider_type: str, provider_name: str, tool_name: str, tenant_id, 
                          agent_callback: DifyAgentCallbackHandler = None) \
         -> Union[BuiltinTool, ApiTool]:
         """
@@ -158,13 +160,13 @@ class ToolManager:
             provider_controller = ToolManager.get_builtin_provider(provider_name)
             if not provider_controller.need_credentials:
                 return builtin_tool.fork_tool_runtime(meta={
-                    'tenant_id': tanent_id,
+                    'tenant_id': tenant_id,
                     'credentials': {},
                 }, agent_callback=agent_callback)
 
             # get credentials
             builtin_provider: BuiltinToolProvider = db.session.query(BuiltinToolProvider).filter(
-                BuiltinToolProvider.tenant_id == tanent_id,
+                BuiltinToolProvider.tenant_id == tenant_id,
                 BuiltinToolProvider.provider == provider_name,
             ).first()
 
@@ -174,30 +176,43 @@ class ToolManager:
             # decrypt the credentials
             credentials = builtin_provider.credentials
             controller = ToolManager.get_builtin_provider(provider_name)
-            tool_configuration = ToolConfiguration(tenant_id=tanent_id, provider_controller=controller)
+            tool_configuration = ToolConfiguration(tenant_id=tenant_id, provider_controller=controller)
 
             decrypted_credentials = tool_configuration.decrypt_tool_credentials(credentials)
 
             return builtin_tool.fork_tool_runtime(meta={
-                'tenant_id': tanent_id,
+                'tenant_id': tenant_id,
                 'credentials': decrypted_credentials,
                 'runtime_parameters': {}
             }, agent_callback=agent_callback)
         
         elif provider_type == 'api':
-            if tanent_id is None:
+            if tenant_id is None:
                 raise ValueError('tanent id is required for api provider')
             
-            api_provider, credentials = ToolManager.get_api_provider_controller(tanent_id, provider_name)
+            api_provider, credentials = ToolManager.get_api_provider_controller(tenant_id, provider_name)
 
             # decrypt the credentials
-            tool_configuration = ToolConfiguration(tenant_id=tanent_id, provider_controller=api_provider)
+            tool_configuration = ToolConfiguration(tenant_id=tenant_id, provider_controller=api_provider)
             decrypted_credentials = tool_configuration.decrypt_tool_credentials(credentials)
 
             return api_provider.get_tool(tool_name).fork_tool_runtime(meta={
-                'tenant_id': tanent_id,
+                'tenant_id': tenant_id,
                 'credentials': decrypted_credentials,
             })
+        elif provider_type == 'model':
+            if tenant_id is None:
+                raise ValueError('tanent id is required for model provider')
+            # get model provider
+            model_provider = ToolManager.get_model_provider(tenant_id, provider_name)
+
+            # get tool
+            model_tool = model_provider.get_tool(tool_name)
+
+            return model_tool.fork_tool_runtime(meta={
+                'tenant_id': tenant_id,
+                'credentials': model_tool._model_instance.credentials
+            })
         elif provider_type == 'app':
             raise NotImplementedError('app provider not implemented')
         else:
@@ -270,6 +285,44 @@ class ToolManager:
 
         return builtin_providers
     
+    @staticmethod
+    def list_model_providers(tenant_id: str = None) -> List[ModelToolProviderController]:
+        """
+            list all the model providers
+
+            :return: the list of the model providers
+        """
+        tenant_id = tenant_id or 'ffffffff-ffff-ffff-ffff-ffffffffffff'
+        # get configurations
+        provider_manager = ProviderManager()
+        configurations = provider_manager.get_configurations(tenant_id).values()
+        # get model providers
+        model_providers: List[ModelToolProviderController] = []
+        for configuration in configurations:
+            if not ModelToolProviderController.is_configuration_valid(configuration):
+                continue
+            model_providers.append(ModelToolProviderController.from_db(configuration))
+
+        return model_providers
+    
+    @staticmethod
+    def get_model_provider(tenant_id: str, provider_name: str) -> ModelToolProviderController:
+        """
+            get the model provider
+
+            :param provider_name: the name of the provider
+
+            :return: the provider
+        """
+        # get configurations
+        provider_manager = ProviderManager()
+        configurations = provider_manager.get_configurations(tenant_id)
+        configuration = configurations.get(provider_name)
+        if configuration is None:
+            raise ToolProviderNotFoundError(f'model provider {provider_name} not found')
+        
+        return ModelToolProviderController.from_db(configuration)
+    
     @staticmethod
     def get_tool_label(tool_name: str) -> Union[I18nObject, None]:
         """
@@ -336,6 +389,9 @@ class ToolManager:
             # add provider into providers
             credentials = db_builtin_provider.credentials
             provider_name = db_builtin_provider.provider
+            if provider_name not in result_providers:
+                continue
+            
             result_providers[provider_name].is_team_authorization = True
 
             # package builtin tool provider controller
@@ -349,6 +405,28 @@ class ToolManager:
 
             result_providers[provider_name].team_credentials = masked_credentials
 
+        # get model tool providers
+        model_providers = ToolManager.list_model_providers(tenant_id=tenant_id)
+        # append model providers
+        for provider in model_providers:
+            result_providers[f'model_provider.{provider.identity.name}'] = UserToolProvider(
+                id=provider.identity.name,
+                author=provider.identity.author,
+                name=provider.identity.name,
+                description=I18nObject(
+                    en_US=provider.identity.description.en_US,
+                    zh_Hans=provider.identity.description.zh_Hans,
+                ),
+                icon=provider.identity.icon,
+                label=I18nObject(
+                    en_US=provider.identity.label.en_US,
+                    zh_Hans=provider.identity.label.zh_Hans,
+                ),
+                type=UserToolProvider.ProviderType.MODEL,
+                team_credentials={},
+                is_team_authorization=provider.is_active,
+            )
+
         # get db api providers
         db_api_providers: List[ApiToolProvider] = db.session.query(ApiToolProvider). \
             filter(ApiToolProvider.tenant_id == tenant_id).all()
@@ -468,4 +546,5 @@ class ToolManager:
             'description': provider.description,
             'credentials': masked_credentials,
             'privacy_policy': provider.privacy_policy
-        }))
+        }))
\ No newline at end of file
+    
\ No newline at end of file