dify_plugin 0.3.0__tar.gz → 0.3.2__tar.gz

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dify_plugin
-Version: 0.3.0
+Version: 0.3.2
 Summary: Dify Plugin SDK
 Keywords: dify,plugin,sdk
 Author-Email: langgenius <hello@dify.ai>
@@ -14,7 +14,6 @@ Requires-Dist: gevent~=24.11.1
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: pydantic_settings<3.0.0,>=2.5.0
 Requires-Dist: pydantic>=2.8.2
-Requires-Dist: pydub~=0.25.1
 Requires-Dist: pyyaml~=6.0.1
 Requires-Dist: requests~=2.32.3
 Requires-Dist: socksio==1.0.0

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/dify_plugin/core/entities/plugin/request.py

@@ -1,4 +1,5 @@
-from enum import Enum
+from collections.abc import Mapping
+from enum import StrEnum
 from typing import Any, Optional
 
 from pydantic import BaseModel, ConfigDict, field_validator
@@ -15,24 +16,25 @@ from dify_plugin.entities.model.message import (
 )
 
 
-class PluginInvokeType(Enum):
+class PluginInvokeType(StrEnum):
     Tool = "tool"
     Model = "model"
     Endpoint = "endpoint"
     Agent = "agent_strategy"
+    OAuth = "oauth"
 
 
-class AgentActions(Enum):
+class AgentActions(StrEnum):
     InvokeAgentStrategy = "invoke_agent_strategy"
 
 
-class ToolActions(Enum):
+class ToolActions(StrEnum):
     ValidateCredentials = "validate_tool_credentials"
     InvokeTool = "invoke_tool"
     GetToolRuntimeParameters = "get_tool_runtime_parameters"
 
 
-class ModelActions(Enum):
+class ModelActions(StrEnum):
     ValidateProviderCredentials = "validate_provider_credentials"
     ValidateModelCredentials = "validate_model_credentials"
     InvokeLLM = "invoke_llm"
@@ -47,10 +49,15 @@ class ModelActions(Enum):
     GetAIModelSchemas = "get_ai_model_schemas"
 
 
-class EndpointActions(Enum):
+class EndpointActions(StrEnum):
     InvokeEndpoint = "invoke_endpoint"
 
 
+class OAuthActions(StrEnum):
+    GetAuthorizationUrl = "get_authorization_url"
+    GetCredentials = "get_credentials"
+
+
 # merge all the access actions
 PluginAccessAction = AgentActions | ToolActions | ModelActions | EndpointActions
 
@@ -227,3 +234,18 @@ class EndpointInvokeRequest(BaseModel):
     action: EndpointActions = EndpointActions.InvokeEndpoint
     settings: dict
     raw_http_request: str
+
+
+class OAuthGetAuthorizationUrlRequest(BaseModel):
+    type: PluginInvokeType = PluginInvokeType.OAuth
+    action: OAuthActions = OAuthActions.GetAuthorizationUrl
+    provider: str
+    system_credentials: Mapping[str, Any]
+
+
+class OAuthGetCredentialsRequest(BaseModel):
+    type: PluginInvokeType = PluginInvokeType.OAuth
+    action: OAuthActions = OAuthActions.GetCredentials
+    provider: str
+    system_credentials: Mapping[str, Any]
+    raw_http_request: str

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/dify_plugin/core/plugin_executor.py

@@ -20,6 +20,8 @@ from dify_plugin.core.entities.plugin.request import (
     ModelInvokeTTSRequest,
     ModelValidateModelCredentialsRequest,
     ModelValidateProviderCredentialsRequest,
+    OAuthGetAuthorizationUrlRequest,
+    OAuthGetCredentialsRequest,
     ToolGetRuntimeParametersRequest,
     ToolInvokeRequest,
     ToolValidateCredentialsRequest,
@@ -37,6 +39,8 @@ from dify_plugin.interfaces.model.rerank_model import RerankModel
 from dify_plugin.interfaces.model.speech2text_model import Speech2TextModel
 from dify_plugin.interfaces.model.text_embedding_model import TextEmbeddingModel
 from dify_plugin.interfaces.model.tts_model import TTSModel
+from dify_plugin.interfaces.tool import ToolProvider
+from dify_plugin.protocol.oauth import OAuthProviderProtocol
 
 
 class PluginExecutor:
@@ -321,3 +325,29 @@ class PluginExecutor:
                         result["result"] += binascii.hexlify(chunk.encode("utf-8")).decode()
 
             yield result
+
+    def _get_oauth_provider_instance(self, provider: str) -> OAuthProviderProtocol:
+        provider_cls = self.registration.get_supported_oauth_provider_cls(provider)
+        if provider_cls is None:
+            raise ValueError(f"Provider `{provider}` does not support OAuth")
+
+        if provider_cls == ToolProvider:
+            return provider_cls()
+
+        raise ValueError(f"Provider `{provider}` does not support OAuth")
+
+    def get_oauth_authorization_url(self, session: Session, data: OAuthGetAuthorizationUrlRequest):
+        provider_instance = self._get_oauth_provider_instance(data.provider)
+
+        return {
+            "authorization_url": provider_instance.oauth_get_authorization_url(data.system_credentials),
+        }
+
+    def get_oauth_credentials(self, session: Session, data: OAuthGetCredentialsRequest):
+        provider_instance = self._get_oauth_provider_instance(data.provider)
+        bytes_data = binascii.unhexlify(data.raw_http_request)
+        request = parse_raw_request(bytes_data)
+
+        return {
+            "credentials": provider_instance.oauth_get_credentials(data.system_credentials, request),
+        }

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/dify_plugin/core/plugin_registration.py

@@ -28,6 +28,7 @@ from dify_plugin.interfaces.model.speech2text_model import Speech2TextModel
 from dify_plugin.interfaces.model.text_embedding_model import TextEmbeddingModel
 from dify_plugin.interfaces.model.tts_model import TTSModel
 from dify_plugin.interfaces.tool import Tool, ToolProvider
+from dify_plugin.protocol.oauth import OAuthProviderProtocol
 
 T = TypeVar("T")
 
@@ -63,6 +64,15 @@ class PluginRegistration:
     ]
     endpoints_configuration: list[EndpointProviderConfiguration]
     endpoints: Map
+    datasource_configuration: list[None]  # TBD
+    datasource_mapping: dict[  # provider -> (provider_cls, datasource_mapping)
+        str,
+        tuple[
+            None,
+            dict[str, tuple[None, type[None]]],  # datasource_name -> (datasource_configuration, datasource_cls)
+        ],
+    ]  # TBD
+
     files: list[PluginAsset]
 
     def __init__(self, config: DifyPluginEnv) -> None:
@@ -338,6 +348,18 @@ class PluginRegistration:
                 if registration:
                     return registration
 
+    def get_supported_oauth_provider_cls(self, provider: str) -> type[OAuthProviderProtocol] | None:
+        """
+        get provider which supports oauth
+        :param provider: provider name
+        :return: supported oauth providers
+        """
+        for provider_registration in self.tools_mapping:
+            if provider_registration == provider and self.tools_mapping[provider_registration][0].oauth_schema:
+                return self.tools_mapping[provider_registration][1]
+
+        return None
+
     def dispatch_endpoint_request(self, request: Request) -> tuple[type[Endpoint], Mapping]:
         """
         dispatch endpoint request, match the request to the registered endpoints

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/dify_plugin/entities/tool.py

@@ -17,33 +17,8 @@ from dify_plugin.core.documentation.schema_doc import docs
 from dify_plugin.core.utils.yaml_loader import load_yaml_file
 from dify_plugin.entities import I18nObject
 from dify_plugin.entities.model.message import PromptMessageTool
-from dify_plugin.entities.provider_config import ProviderConfig
-
-
-class LogMetadata(str, Enum):
-    STARTED_AT = "started_at"
-    FINISHED_AT = "finished_at"
-    ELAPSED_TIME = "elapsed_time"
-    TOTAL_PRICE = "total_price"
-    TOTAL_TOKENS = "total_tokens"
-    PROVIDER = "provider"
-    CURRENCY = "currency"
-
-
-class CommonParameterType(Enum):
-    SECRET_INPUT = "secret-input"
-    TEXT_INPUT = "text-input"
-    SELECT = "select"
-    STRING = "string"
-    NUMBER = "number"
-    FILE = "file"
-    FILES = "files"
-    BOOLEAN = "boolean"
-    APP_SELECTOR = "app-selector"
-    MODEL_SELECTOR = "model-selector"
-    # TOOL_SELECTOR = "tool-selector"
-    TOOLS_SELECTOR = "array[tools]"
-    ANY = "any"
+from dify_plugin.entities.oauth import OAuthSchema
+from dify_plugin.entities.provider_config import CommonParameterType, LogMetadata, ProviderConfig
 
 
 class ToolRuntime(BaseModel):
@@ -360,6 +335,10 @@ class ToolProviderConfiguration(BaseModel):
         alias="credentials_for_provider",
         description="The credentials schema of the tool provider",
     )
+    oauth_schema: Optional[OAuthSchema] = Field(
+        default=None,
+        description="The OAuth schema of the tool provider if OAuth is supported",
+    )
     tools: list[ToolConfiguration] = Field(default=[], description="The tools of the tool provider")
     extra: ToolProviderConfigurationExtra
 
@@ -415,6 +394,7 @@ class ToolProviderType(Enum):
     API = "api"
     APP = "app"
     DATASET_RETRIEVAL = "dataset-retrieval"
+    MCP = "mcp"
 
     @classmethod
     def value_of(cls, value: str) -> "ToolProviderType":

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/dify_plugin/integration/run.py

@@ -1,7 +1,9 @@
 import logging
 import os
+import shutil
 import signal
 import subprocess
+import tempfile
 import threading
 import uuid
 from collections.abc import Generator
@@ -56,6 +58,7 @@ class PluginRunner:
         self.config = config
         self.plugin_package_path = plugin_package_path
         self.extra_args = extra_args or []
+        self.resources_need_to_be_cleaned = []
 
         # create pipe to communicate with the plugin
         self.stdout_pipe_read, self.stdout_pipe_write = os.pipe()
@@ -71,8 +74,26 @@ class PluginRunner:
 
         logger.info(f"Running plugin from {plugin_package_path}")
 
+        # check if plugin is a directory
+        if os.path.isdir(plugin_package_path):
+            logger.info("plugin source directory detected, building plugin")
+            with tempfile.TemporaryDirectory(delete=False) as temp_dir:
+                output_path = os.path.join(temp_dir, "plugin.difypkg")
+                self._build_plugin(plugin_package_path, output_path)
+                self.plugin_package_path = output_path
+                logger.info(f"Plugin built in {self.plugin_package_path}")
+                self.resources_need_to_be_cleaned.append(temp_dir)
+
         self.process = subprocess.Popen(  # noqa: S603
-            [config.dify_cli_path, "plugin", "run", plugin_package_path, "--response-format", "json", *self.extra_args],
+            [
+                self.config.dify_cli_path,
+                "plugin",
+                "run",
+                self.plugin_package_path,
+                "--response-format",
+                "json",
+                *self.extra_args,
+            ],
             stdout=self.stdout_pipe_write,
             stderr=self.stderr_pipe_write,
             stdin=self.stdin_pipe_read,
@@ -98,6 +119,13 @@ class PluginRunner:
 
         logger.info("Plugin ready")
 
+    def _build_plugin(self, package_path: str, output_path: str):
+        # build plugin
+        output = subprocess.check_output(  # noqa: S603
+            [self.config.dify_cli_path, "plugin", "package", package_path, "-o", output_path],
+        )
+        logger.info(output.decode("utf-8"))
+
     def _close(self):
         with self.stop_flag_lock:
             if self.stop_flag:
@@ -240,3 +268,6 @@ class PluginRunner:
 
     def __exit__(self, exc_type, exc_value, traceback):
         self._close()
+
+        for resource in self.resources_need_to_be_cleaned:
+            shutil.rmtree(resource)

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/dify_plugin/interfaces/tool/__init__.py

@@ -2,6 +2,8 @@ from abc import ABC, abstractmethod
 from collections.abc import Generator, Mapping
 from typing import Any, Generic, Optional, TypeVar, final
 
+from werkzeug import Request
+
 from dify_plugin.core.runtime import Session
 from dify_plugin.entities.agent import AgentInvokeMessage
 from dify_plugin.entities.tool import LogMetadata, ToolInvokeMessage, ToolParameter, ToolRuntime, ToolSelector
@@ -222,13 +224,24 @@ class ToolLike(ABC, Generic[T]):
         return tool_parameters
 
 
-class ToolProvider(ABC):
+class ToolProvider:
     def validate_credentials(self, credentials: dict):
         return self._validate_credentials(credentials)
 
-    @abstractmethod
     def _validate_credentials(self, credentials: dict):
-        pass
+        raise NotImplementedError("This method should be implemented by a subclass")
+
+    def oauth_get_authorization_url(self, system_credentials: Mapping[str, Any]) -> str:
+        return self._oauth_get_authorization_url(system_credentials)
+
+    def _oauth_get_authorization_url(self, system_credentials: Mapping[str, Any]) -> str:
+        raise NotImplementedError("This method should be implemented by a subclass")
+
+    def oauth_get_credentials(self, system_credentials: Mapping[str, Any], request: Request) -> Mapping[str, Any]:
+        return self._oauth_get_credentials(system_credentials, request)
+
+    def _oauth_get_credentials(self, system_credentials: Mapping[str, Any], request: Request) -> Mapping[str, Any]:
+        raise NotImplementedError("This method should be implemented by a subclass")
 
 
 class Tool(ToolLike[ToolInvokeMessage]):

dify_plugin-0.3.2/dify_plugin/protocol/oauth.py

@@ -0,0 +1,27 @@
+from collections.abc import Mapping
+from typing import Any, Protocol
+
+from werkzeug import Request
+
+
+class OAuthProviderProtocol(Protocol):
+    def oauth_get_authorization_url(self, system_credentials: Mapping[str, Any]) -> str:
+        """
+        Get the authorization url
+        :param system_credentials: system credentials
+        :return: authorization url
+        """
+        ...
+
+    def oauth_get_credentials(
+        self,
+        system_credentials: Mapping[str, Any],
+        request: Request,
+    ) -> Mapping[str, Any]:
+        """
+        Get the credentials
+        :param request: request
+        :param system_credentials: system credentials
+        :return: credentials
+        """
+        ...

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dify_plugin"
-version = "0.3.0"
+version = "0.3.2"
 description = "Dify Plugin SDK"
 authors = [
     { name = "langgenius", email = "hello@dify.ai" },
@@ -13,7 +13,6 @@ dependencies = [
     "httpx~=0.28.1",
     "pydantic_settings>=2.5.0,<3.0.0",
     "pydantic>=2.8.2",
-    "pydub~=0.25.1",
     "pyyaml~=6.0.1",
     "requests~=2.32.3",
     "socksio==1.0.0",

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/tests/__mock_server/openai.py

@@ -3,9 +3,9 @@ import json
 import flask.cli
 from flask import Flask, Response, jsonify, request
 
-flask.cli.show_server_banner = lambda *args: None
+from tests.consts.mockserver import OPENAI_MOCK_SERVER_PORT
 
-OPENAI_MOCK_SERVER_PORT = 11451
+flask.cli.show_server_banner = lambda *args: None
 
 
 def openai_server_mock():
@@ -40,4 +40,4 @@ def openai_server_mock():
                 }
             )
 
-    app.run(port=11451)
+    app.run(port=OPENAI_MOCK_SERVER_PORT)

dify_plugin-0.3.2/tests/consts/mockserver.py

@@ -0,0 +1 @@
+OPENAI_MOCK_SERVER_PORT = 11451

{dify_plugin-0.3.0 → dify_plugin-0.3.2}/tests/integration/test_invoke_llm.py

@@ -6,7 +6,7 @@ from dify_plugin.entities.model import ModelType
 from dify_plugin.entities.model.llm import LLMResultChunk
 from dify_plugin.entities.model.message import UserPromptMessage
 from dify_plugin.integration.run import PluginRunner
-from tests.__mock_server.openai import OPENAI_MOCK_SERVER_PORT
+from tests.consts.mockserver import OPENAI_MOCK_SERVER_PORT
 
 _MARKETPLACE_API_URL = "https://marketplace.dify.ai"
 

dify_plugin-0.3.2/tests/interfaces/tool/test_construct_tool_provider.py

@@ -0,0 +1,20 @@
+import pytest
+
+from dify_plugin.interfaces.tool import ToolProvider
+
+
+def test_construct_tool_provider():
+    """
+    Test that the ToolProvider can be constructed without implementing any methods
+    """
+    provider = ToolProvider()
+    assert provider is not None
+
+
+def test_oauth_get_authorization_url():
+    """
+    Test that the ToolProvider can get the authorization url
+    """
+    provider = ToolProvider()
+    with pytest.raises(NotImplementedError):
+        provider.oauth_get_authorization_url({})