dify_plugin 0.6.2__tar.gz → 0.7.0__tar.gz

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dify_plugin
-Version: 0.6.2
+Version: 0.7.0
 Summary: Dify Plugin SDK
 Keywords: dify,plugin,sdk
 Author-Email: langgenius <hello@dify.ai>
@@ -8,7 +8,7 @@ License: Apache2.0
 Project-URL: Homepage, https://github.com/langgenius/dify-plugin-sdks.git
 Requires-Python: >=3.11
 Requires-Dist: Flask~=3.0.3
-Requires-Dist: Werkzeug~=3.0.3
+Requires-Dist: Werkzeug~=3.1.4
 Requires-Dist: dpkt~=1.9.8
 Requires-Dist: gevent~=25.5.1
 Requires-Dist: httpx~=0.28.1

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/core/entities/invocation.py

@@ -6,7 +6,9 @@ class InvokeType(Enum):
     LLM = "llm"
     LLMStructuredOutput = "llm_structured_output"
     TextEmbedding = "text_embedding"
+    MultimodalEmbedding = "multimodal_embedding"
     Rerank = "rerank"
+    MultimodalRerank = "multimodal_rerank"
     TTS = "tts"
     Speech2Text = "speech2text"
     Moderation = "moderation"

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/core/entities/plugin/request.py

@@ -1,4 +1,4 @@
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from enum import StrEnum
 from typing import Any
 
@@ -9,7 +9,7 @@ from dify_plugin.entities.datasource import (
     OnlineDriveBrowseFilesRequest,
     OnlineDriveDownloadFileRequest,
 )
-from dify_plugin.entities.model import ModelType
+from dify_plugin.entities.model import EmbeddingInputType, ModelType
 from dify_plugin.entities.model.message import (
     AssistantPromptMessage,
     PromptMessage,
@@ -19,6 +19,7 @@ from dify_plugin.entities.model.message import (
     ToolPromptMessage,
     UserPromptMessage,
 )
+from dify_plugin.entities.model.text_embedding import MultiModalContent
 from dify_plugin.entities.provider_config import CredentialType
 from dify_plugin.entities.trigger import Subscription
 
@@ -59,8 +60,10 @@ class ModelActions(StrEnum):
     InvokeLLM = "invoke_llm"
     GetLLMNumTokens = "get_llm_num_tokens"
     InvokeTextEmbedding = "invoke_text_embedding"
+    InvokeMultimodalEmbedding = "invoke_multimodal_embedding"
     GetTextEmbeddingNumTokens = "get_text_embedding_num_tokens"
     InvokeRerank = "invoke_rerank"
+    InvokeMultimodalRerank = "invoke_multimodal_rerank"
     InvokeTTS = "invoke_tts"
     GetTTSVoices = "get_tts_model_voices"
     InvokeSpeech2Text = "invoke_speech2text"
@@ -202,6 +205,14 @@ class ModelInvokeTextEmbeddingRequest(PluginAccessModelRequest):
     texts: list[str]
 
 
+class ModelInvokeMultimodalEmbeddingRequest(PluginAccessModelRequest):
+    action: ModelActions = ModelActions.InvokeMultimodalEmbedding
+    model_type: ModelType = ModelType.TEXT_EMBEDDING
+
+    documents: list[MultiModalContent]
+    input_type: EmbeddingInputType = EmbeddingInputType.DOCUMENT
+
+
 class ModelGetTextEmbeddingNumTokens(PluginAccessModelRequest):
     action: ModelActions = ModelActions.GetTextEmbeddingNumTokens
 
@@ -217,6 +228,16 @@ class ModelInvokeRerankRequest(PluginAccessModelRequest):
     top_n: int | None
 
 
+class ModelInvokeMultimodalRerankRequest(PluginAccessModelRequest):
+    action: ModelActions = ModelActions.InvokeMultimodalRerank
+    model_type: ModelType = ModelType.RERANK
+
+    query: MultiModalContent
+    docs: Sequence[MultiModalContent]
+    score_threshold: float | None
+    top_n: int | None
+
+
 class ModelInvokeTTSRequest(PluginAccessModelRequest):
     action: ModelActions = ModelActions.InvokeTTS
 

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/core/plugin_executor.py

@@ -22,6 +22,8 @@ from dify_plugin.core.entities.plugin.request import (
     ModelGetTTSVoices,
     ModelInvokeLLMRequest,
     ModelInvokeModerationRequest,
+    ModelInvokeMultimodalEmbeddingRequest,
+    ModelInvokeMultimodalRerankRequest,
     ModelInvokeRerankRequest,
     ModelInvokeSpeech2TextRequest,
     ModelInvokeTextEmbeddingRequest,
@@ -219,6 +221,18 @@ class PluginExecutor:
         else:
             raise ValueError(f"Model `{data.model_type}` not found for provider `{data.provider}`")
 
+    def invoke_multimodal_embedding(self, session: Session, data: ModelInvokeMultimodalEmbeddingRequest):
+        model_instance = self.registration.get_model_instance(data.provider, data.model_type)
+        if isinstance(model_instance, TextEmbeddingModel):
+            return model_instance.invoke_multimodal(
+                data.model,
+                data.credentials,
+                data.documents,
+                user=data.user_id,
+                input_type=data.input_type,
+            )
+        raise ValueError(f"Model `{data.model_type}` not found for provider `{data.provider}`")
+
     def get_text_embedding_num_tokens(self, session: Session, data: ModelGetTextEmbeddingNumTokens):
         model_instance = self.registration.get_model_instance(data.provider, data.model_type)
         if isinstance(model_instance, TextEmbeddingModel):
@@ -247,6 +261,20 @@ class PluginExecutor:
         else:
             raise ValueError(f"Model `{data.model_type}` not found for provider `{data.provider}`")
 
+    def invoke_multimodal_rerank(self, session: Session, data: ModelInvokeMultimodalRerankRequest):
+        model_instance = self.registration.get_model_instance(data.provider, data.model_type)
+        if isinstance(model_instance, RerankModel):
+            return model_instance.invoke_multimodal(
+                data.model,
+                data.credentials,
+                data.query,
+                data.docs,
+                score_threshold=data.score_threshold,
+                top_n=data.top_n,
+                user=data.user_id,
+            )
+        raise ValueError(f"Model `{data.model_type}` not found for provider `{data.provider}`")
+
     def invoke_tts(self, session: Session, data: ModelInvokeTTSRequest):
         model_instance = self.registration.get_model_instance(data.provider, data.model_type)
         if isinstance(model_instance, TTSModel):

dify_plugin-0.7.0/dify_plugin/entities/model/rerank.py

@@ -0,0 +1,57 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+from dify_plugin.entities.model import BaseModelConfig, ModelType
+
+
+class RerankDocument(BaseModel):
+    """
+    Model class for rerank document.
+    """
+
+    index: int
+    text: str
+    score: float
+
+
+class RerankResult(BaseModel):
+    """
+    Model class for rerank result.
+    """
+
+    model: str
+    docs: list[RerankDocument]
+
+
+class RerankModelConfig(BaseModelConfig):
+    """
+    Model class for rerank model config.
+    """
+
+    model_type: ModelType = ModelType.RERANK
+    score_threshold: float
+    top_n: int
+
+    model_config = ConfigDict(protected_namespaces=())
+
+
+class MultiModalRerankResult(BaseModel):
+    """Rerank response produced by a multimodal rerank model."""
+
+    model: str = Field(..., description="Identifier of the model producing the reranked documents.")
+    docs: list[RerankDocument] = Field(..., description="Reranked documents with scores.")
+
+
+class MultiModalRerankModelConfig(BaseModelConfig):
+    """Configuration payload for invoking a multimodal rerank model."""
+
+    model_type: ModelType = ModelType.RERANK
+    score_threshold: float | None = Field(
+        default=None,
+        description="Optional threshold for filtering documents based on score.",
+    )
+    top_n: int | None = Field(
+        default=None,
+        description="Optional limit on the number of documents returned.",
+    )
+
+    model_config = ConfigDict(protected_namespaces=())

dify_plugin-0.7.0/dify_plugin/entities/model/text_embedding.py

@@ -0,0 +1,71 @@
+from decimal import Decimal
+from enum import StrEnum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from dify_plugin.entities.model import BaseModelConfig, ModelType, ModelUsage
+
+
+class EmbeddingUsage(ModelUsage):
+    """
+    Model class for embedding usage.
+    """
+
+    tokens: int
+    total_tokens: int
+    unit_price: Decimal
+    price_unit: Decimal
+    total_price: Decimal
+    currency: str
+    latency: float
+
+
+class TextEmbeddingResult(BaseModel):
+    """
+    Model class for text embedding result.
+    """
+
+    model: str
+    embeddings: list[list[float]]
+    usage: EmbeddingUsage
+
+
+class TextEmbeddingModelConfig(BaseModelConfig):
+    """
+    Model class for text embedding model config.
+    """
+
+    model_type: ModelType = ModelType.TEXT_EMBEDDING
+
+    model_config = ConfigDict(protected_namespaces=())
+
+
+class MultiModalContentType(StrEnum):
+    """Supported content types for multimodal inputs."""
+
+    TEXT = "text"
+    IMAGE = "image"
+
+
+class MultiModalContent(BaseModel):
+    """A multimodal content payload provided by the caller."""
+
+    content: str = Field(..., description="The payload content, plain text or base64 encoded file data.")
+    content_type: MultiModalContentType = Field(..., description="The modality of the provided content.")
+
+
+class MultiModalEmbeddingResult(BaseModel):
+    """Embedding response produced by a multimodal embedding model."""
+
+    model: str = Field(..., description="Identifier of the model generating embeddings.")
+    embeddings: list[list[float]] = Field(..., description="Embedding vectors for provided contents.")
+    usage: EmbeddingUsage = Field(..., description="Usage metrics associated with the inference.")
+
+
+class MultiModalEmbeddingModelConfig(BaseModelConfig):
+    """Configuration payload for invoking a multimodal embedding model."""
+
+    model_type: ModelType = ModelType.TEXT_EMBEDDING
+    tenant_id: str = Field(..., description="Vendor tenant identifier associated with the dataset.")
+
+    model_config = ConfigDict(protected_namespaces=())

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/entities/tool.py

@@ -20,15 +20,6 @@ from dify_plugin.entities.provider_config import (
     CredentialType,
     ProviderConfig,
 )
-from dify_plugin.entities.provider_config import (
-    LogMetadata as CommonLogMetadata,
-)
-
-# TODO: this is a temporary solution to avoid breaking changes from agent imports
-# ImportError: cannot import name "LogMetadata" from "dify_plugin.entities.tool"
-# which will be removed in 0.5.0
-# ISSUE: https://github.com/langgenius/dify-plugin-sdks/issues/181
-LogMetadata = CommonLogMetadata
 
 
 class ToolRuntime(BaseModel):

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/interfaces/model/openai_compatible/llm.py

@@ -47,6 +47,8 @@ from dify_plugin.interfaces.model.openai_compatible.common import _CommonOaiApiC
 
 logger = logging.getLogger(__name__)
 
+_plugin_config = DifyPluginEnv()
+
 
 def _gen_tool_call_id() -> str:
     return f"chatcmpl-tool-{uuid.uuid4().hex!s}"
@@ -473,7 +475,7 @@ class OAICompatLargeLanguageModel(_CommonOaiApiCompat, LargeLanguageModel):
             endpoint_url,
             headers=headers,
             json=data,
-            timeout=(10, DifyPluginEnv.MAX_REQUEST_TIMEOUT),
+            timeout=(10, _plugin_config.MAX_REQUEST_TIMEOUT),
             stream=stream,
         )
 

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/interfaces/model/rerank_model.py

@@ -1,7 +1,9 @@
 from abc import abstractmethod
+from collections.abc import Sequence
 
 from dify_plugin.entities.model import ModelType
-from dify_plugin.entities.model.rerank import RerankResult
+from dify_plugin.entities.model.rerank import MultiModalRerankResult, RerankResult
+from dify_plugin.entities.model.text_embedding import MultiModalContent
 from dify_plugin.interfaces.model.ai_model import AIModel
 
 
@@ -41,6 +43,23 @@ class RerankModel(AIModel):
         """
         raise NotImplementedError
 
+    def _invoke_multimodal(
+        self,
+        model: str,
+        credentials: dict,
+        query: MultiModalContent,
+        docs: Sequence[MultiModalContent],
+        score_threshold: float | None = None,
+        top_n: int | None = None,
+        user: str | None = None,
+    ) -> MultiModalRerankResult:
+        """Invoke a multimodal rerank model."""
+
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not implement `_invoke_multimodal`. "
+            "Implement this method to support multimodal rerank invocations."
+        )
+
     ############################################################
     #                 For executor use only                    #
     ############################################################
@@ -73,3 +92,31 @@ class RerankModel(AIModel):
                 return self._invoke(model, credentials, query, docs, score_threshold, top_n, user)
             except Exception as e:
                 raise self._transform_invoke_error(e) from e
+
+    def invoke_multimodal(
+        self,
+        model: str,
+        credentials: dict,
+        query: MultiModalContent,
+        docs: Sequence[MultiModalContent],
+        score_threshold: float | None = None,
+        top_n: int | None = None,
+        user: str | None = None,
+    ) -> MultiModalRerankResult:
+        """Invoke a multimodal rerank model."""
+
+        with self.timing_context():
+            try:
+                return self._invoke_multimodal(
+                    model,
+                    credentials,
+                    query,
+                    docs,
+                    score_threshold,
+                    top_n,
+                    user,
+                )
+            except NotImplementedError:
+                raise
+            except Exception as e:
+                raise self._transform_invoke_error(e) from e

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/interfaces/model/text_embedding_model.py

@@ -3,7 +3,11 @@ from abc import abstractmethod
 from pydantic import ConfigDict
 
 from dify_plugin.entities.model import EmbeddingInputType, ModelPropertyKey, ModelType
-from dify_plugin.entities.model.text_embedding import TextEmbeddingResult
+from dify_plugin.entities.model.text_embedding import (
+    MultiModalContent,
+    MultiModalEmbeddingResult,
+    TextEmbeddingResult,
+)
 from dify_plugin.interfaces.model.ai_model import AIModel
 
 
@@ -42,6 +46,21 @@ class TextEmbeddingModel(AIModel):
         """
         raise NotImplementedError
 
+    def _invoke_multimodal(
+        self,
+        model: str,
+        credentials: dict,
+        documents: list[MultiModalContent],
+        user: str | None = None,
+        input_type: EmbeddingInputType = EmbeddingInputType.DOCUMENT,
+    ) -> MultiModalEmbeddingResult:
+        """Invoke a multimodal embedding model."""
+
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not implement `_invoke_multimodal`. "
+            "Implement this method to support multimodal embeddings."
+        )
+
     @abstractmethod
     def get_num_tokens(self, model: str, credentials: dict, texts: list[str]) -> list[int]:
         """
@@ -115,3 +134,27 @@ class TextEmbeddingModel(AIModel):
                 return self._invoke(model, credentials, texts, user, input_type)
             except Exception as e:
                 raise self._transform_invoke_error(e) from e
+
+    def invoke_multimodal(
+        self,
+        model: str,
+        credentials: dict,
+        documents: list[MultiModalContent],
+        user: str | None = None,
+        input_type: EmbeddingInputType = EmbeddingInputType.DOCUMENT,
+    ) -> MultiModalEmbeddingResult:
+        """Invoke a multimodal embedding model."""
+
+        with self.timing_context():
+            try:
+                return self._invoke_multimodal(
+                    model,
+                    credentials,
+                    documents,
+                    user,
+                    input_type,
+                )
+            except NotImplementedError:
+                raise
+            except Exception as e:
+                raise self._transform_invoke_error(e) from e

dify_plugin-0.7.0/dify_plugin/invocations/model/rerank.py

@@ -0,0 +1,49 @@
+from dify_plugin.core.entities.invocation import InvokeType
+from dify_plugin.core.runtime import BackwardsInvocation
+from dify_plugin.entities.model.rerank import (
+    MultiModalRerankModelConfig,
+    MultiModalRerankResult,
+    RerankModelConfig,
+    RerankResult,
+)
+from dify_plugin.entities.model.text_embedding import MultiModalContent
+
+
+class RerankInvocation(BackwardsInvocation[RerankResult]):
+    def invoke(self, model_config: RerankModelConfig, docs: list[str], query: str) -> RerankResult:
+        """
+        Invoke rerank
+        """
+        for data in self._backwards_invoke(
+            InvokeType.Rerank,
+            RerankResult,
+            {
+                **model_config.model_dump(),
+                "docs": docs,
+                "query": query,
+            },
+        ):
+            return data
+
+        raise Exception("No response from rerank")
+
+    def invoke_multimodal(
+        self,
+        model_config: MultiModalRerankModelConfig,
+        query: MultiModalContent,
+        docs: list[MultiModalContent],
+    ) -> MultiModalRerankResult:
+        payload = {
+            **model_config.model_dump(),
+            "query": query.model_dump() if isinstance(query, MultiModalContent) else query,
+            "docs": [doc.model_dump() if isinstance(doc, MultiModalContent) else doc for doc in docs],
+        }
+
+        for data in self._backwards_invoke(
+            InvokeType.MultimodalRerank,
+            MultiModalRerankResult,
+            payload,
+        ):
+            return data
+
+        raise Exception("No response from multimodal rerank")

dify_plugin-0.7.0/dify_plugin/invocations/model/text_embedding.py

@@ -0,0 +1,57 @@
+from dify_plugin.core.entities.invocation import InvokeType
+from dify_plugin.core.runtime import BackwardsInvocation
+from dify_plugin.entities.model import EmbeddingInputType
+from dify_plugin.entities.model.text_embedding import (
+    MultiModalContent,
+    MultiModalEmbeddingModelConfig,
+    MultiModalEmbeddingResult,
+    TextEmbeddingModelConfig,
+    TextEmbeddingResult,
+)
+
+
+class TextEmbeddingInvocation(BackwardsInvocation[TextEmbeddingResult]):
+    def invoke(
+        self,
+        model_config: TextEmbeddingModelConfig,
+        texts: list[str],
+        input_type: EmbeddingInputType = EmbeddingInputType.QUERY,
+    ) -> TextEmbeddingResult:
+        """
+        Invoke text embedding
+        """
+        for data in self._backwards_invoke(
+            InvokeType.TextEmbedding,
+            TextEmbeddingResult,
+            {
+                **model_config.model_dump(),
+                "texts": texts,
+                "input_type": input_type.value,
+            },
+        ):
+            return data
+
+        raise Exception("No response from text embedding")
+
+    def invoke_multimodal(
+        self,
+        model_config: MultiModalEmbeddingModelConfig,
+        documents: list[MultiModalContent],
+        input_type: EmbeddingInputType = EmbeddingInputType.QUERY,
+    ) -> MultiModalEmbeddingResult:
+        payload = {
+            **model_config.model_dump(),
+            "documents": [
+                document.model_dump() if isinstance(document, MultiModalContent) else document for document in documents
+            ],
+            "input_type": input_type.value,
+        }
+
+        for data in self._backwards_invoke(
+            InvokeType.MultimodalEmbedding,
+            MultiModalEmbeddingResult,
+            payload,
+        ):
+            return data
+
+        raise Exception("No response from multimodal embedding")

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/dify_plugin/plugin.py

@@ -266,6 +266,12 @@ class Plugin(IOServer, Router):
             and data.get("action") == ModelActions.InvokeTextEmbedding.value,
         )
 
+        self.register_route(
+            self.plugin_executer.invoke_multimodal_embedding,
+            lambda data: data.get("type") == PluginInvokeType.Model.value
+            and data.get("action") == ModelActions.InvokeMultimodalEmbedding.value,
+        )
+
         self.register_route(
             self.plugin_executer.get_text_embedding_num_tokens,
             lambda data: data.get("type") == PluginInvokeType.Model.value
@@ -278,6 +284,12 @@ class Plugin(IOServer, Router):
             and data.get("action") == ModelActions.InvokeRerank.value,
         )
 
+        self.register_route(
+            self.plugin_executer.invoke_multimodal_rerank,
+            lambda data: data.get("type") == PluginInvokeType.Model.value
+            and data.get("action") == ModelActions.InvokeMultimodalRerank.value,
+        )
+
         self.register_route(
             self.plugin_executer.invoke_tts,
             lambda data: data.get("type") == PluginInvokeType.Model.value

{dify_plugin-0.6.2 → dify_plugin-0.7.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "dify_plugin"
-version = "0.6.2"
+version = "0.7.0"
 description = "Dify Plugin SDK"
 authors = [
     { name = "langgenius", email = "hello@dify.ai" },
 ]
 dependencies = [
     "Flask~=3.0.3",
-    "Werkzeug~=3.0.3",
+    "Werkzeug~=3.1.4",
     "dpkt~=1.9.8",
     "gevent~=25.5.1",
     "httpx~=0.28.1",

dify_plugin-0.7.0/tests/interfaces/model/openai_compatible/test_plugin_config.py

@@ -0,0 +1,70 @@
+"""
+Tests for _plugin_config configuration object in openai_compatible/llm.py
+
+These tests verify:
+1. Configuration object is properly instantiated at module level
+2. Configuration object is a singleton (only one instance at module level)
+3. Configuration object has correct default values
+4. Configuration object has correct types
+"""
+
+from dify_plugin.config.config import DifyPluginEnv
+from dify_plugin.interfaces.model.openai_compatible import llm
+
+
+def test_plugin_config_exists():
+    """Test that _plugin_config object exists"""
+    assert hasattr(llm, "_plugin_config")
+    assert llm._plugin_config is not None
+
+
+def test_plugin_config_type():
+    """Test that _plugin_config is an instance of DifyPluginEnv"""
+    assert isinstance(llm._plugin_config, DifyPluginEnv)
+
+
+def test_plugin_config_has_max_request_timeout():
+    """Test that _plugin_config has MAX_REQUEST_TIMEOUT attribute"""
+    assert hasattr(llm._plugin_config, "MAX_REQUEST_TIMEOUT")
+    assert isinstance(llm._plugin_config.MAX_REQUEST_TIMEOUT, int)
+    # Default value should be 300 seconds (unless overridden by environment variable)
+    assert llm._plugin_config.MAX_REQUEST_TIMEOUT > 0
+
+
+def test_plugin_config_has_max_invocation_timeout():
+    """Test that _plugin_config has MAX_INVOCATION_TIMEOUT attribute"""
+    assert hasattr(llm._plugin_config, "MAX_INVOCATION_TIMEOUT")
+    assert isinstance(llm._plugin_config.MAX_INVOCATION_TIMEOUT, int)
+    # Default value should be 250 seconds (unless overridden by environment variable)
+    assert llm._plugin_config.MAX_INVOCATION_TIMEOUT > 0
+
+
+def test_plugin_config_singleton():
+    """Test that configuration object is instantiated only once at module level"""
+    # Get the id of the config object
+    config_id_1 = id(llm._plugin_config)
+
+    # Import again, should be the same object
+    from dify_plugin.interfaces.model.openai_compatible import llm as llm2
+
+    config_id_2 = id(llm2._plugin_config)
+
+    # Verify it's the same object
+    assert config_id_1 == config_id_2
+
+
+def test_plugin_config_timeout_values_reasonable():
+    """Test that timeout configuration values are within reasonable range"""
+    # MAX_REQUEST_TIMEOUT should be between 1 and 3600 seconds
+    assert 1 <= llm._plugin_config.MAX_REQUEST_TIMEOUT <= 3600
+
+    # MAX_INVOCATION_TIMEOUT should be between 1 and 3600 seconds
+    assert 1 <= llm._plugin_config.MAX_INVOCATION_TIMEOUT <= 3600
+
+
+def test_plugin_config_can_create_new_instance():
+    """Test that new DifyPluginEnv instances can be created (verify the config class itself works)"""
+    new_config = DifyPluginEnv()
+    assert isinstance(new_config, DifyPluginEnv)
+    assert hasattr(new_config, "MAX_REQUEST_TIMEOUT")
+    assert hasattr(new_config, "MAX_INVOCATION_TIMEOUT")