dify-player 0.3.8__tar.gz → 0.3.9__tar.gz

{dify_player-0.3.8 → dify_player-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dify-player
-Version: 0.3.8
+Version: 0.3.9
 Summary: Minimal workflow runner for hand-authored Dify-like plans.
 Requires-Python: >=3.11
 Requires-Dist: Jinja2<4,>=3.1

{dify_player-0.3.8 → dify_player-0.3.9}/README.md

@@ -99,7 +99,7 @@ async def run_workflow(payload: dict) -> dict:
 
 ### Provider Config
 
-Azure OpenAI と Groq の接続設定は、実行単位で `provider_config` として渡せます。  
+Azure OpenAI、OpenAI-compatible endpoint、Groq の接続設定は、実行単位で `provider_config` として渡せます。
 優先順位は `provider_config`、`DIFY_PLAYER_*` 環境変数、既存互換の環境変数の順です。
 
 ```python
@@ -110,6 +110,8 @@ result = await engine.run_compiled_plan(
         "azure_openai_endpoint": "https://example.openai.azure.com",
         "azure_openai_api_key": "...",
         "azure_openai_api_version": "2024-10-21",
+        "openai_compatible_api_key": "...",
+        "openai_compatible_api_base_url": "http://localhost:8000/v1",
         "groq_api_key": "...",
         "groq_api_base_url": "https://api.groq.com/openai/v1",
     },
@@ -120,9 +122,13 @@ result = await engine.run_compiled_plan(
 
 - Azure OpenAI: `DIFY_PLAYER_AZURE_OPENAI_ENDPOINT`, `DIFY_PLAYER_AZURE_OPENAI_API_KEY`, `DIFY_PLAYER_AZURE_OPENAI_API_VERSION`
 - Azure OpenAI 既存互換: `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_API_VERSION`
+- OpenAI-compatible: `DIFY_PLAYER_OPENAI_COMPATIBLE_API_KEY`, `DIFY_PLAYER_OPENAI_COMPATIBLE_API_BASE_URL`
+- OpenAI-compatible 既存互換: `OPENAI_COMPATIBLE_API_KEY`, `OPENAI_COMPATIBLE_API_BASE_URL`
 - Groq: `DIFY_PLAYER_GROQ_API_KEY`, `DIFY_PLAYER_GROQ_API_BASE_URL`
 - Groq 既存互換: `GROQ_API_KEY`, `GROQ_API_BASE_URL`
 
+新規の OpenAI-compatible plan では `llm_openai_compatible_chat` を使ってください。`llm_groq_chat` は既存 plan 互換の alias として残しており、Groq の既定 base URL を引き続き使います。
+
 ### LLM Cache Mode
 
 workflow 改善中だけ LLM 応答を再利用したい場合は、`llm_cache=True` と cache store を渡します。  

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player/__init__.py

@@ -5,4 +5,4 @@ from dify_player.workflow_engine import WorkflowEngine
 
 __all__ = ["__version__", "LLMCacheStore", "NullLLMCacheStore", "WorkflowEngine"]
 
-__version__ = "0.3.7"
+__version__ = "0.3.9"

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player/exceptions.py

@@ -84,3 +84,24 @@ class GroqLLMStructuredOutputError(RuntimeError):
     def __init__(self, message: str, *, attempts: list[dict[str, str]]) -> None:
         super().__init__(message)
         self.attempts = attempts
+
+
+class OpenAICompatibleLLMRequestFailedError(RuntimeError):
+    """Raised when an OpenAI-compatible LLM request fails before receiving a response."""
+
+
+class OpenAICompatibleLLMBadStatusError(RuntimeError):
+    """Raised when an OpenAI-compatible LLM request returns a 4xx/5xx response."""
+
+    def __init__(self, message: str, *, status_code: int, response_body: str | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body
+
+
+class OpenAICompatibleLLMStructuredOutputError(RuntimeError):
+    """Raised when OpenAI-compatible structured output remains invalid after repair retries."""
+
+    def __init__(self, message: str, *, attempts: list[dict[str, str]]) -> None:
+        super().__init__(message)
+        self.attempts = attempts

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player/models.py

@@ -3,13 +3,18 @@ from __future__ import annotations
 from dataclasses import asdict, dataclass, field, is_dataclass
 from typing import Any
 
+LLM_CHAT_NODE_KINDS = {
+    "llm_azure_chat",
+    "llm_xai_chat",
+    "llm_groq_chat",
+    "llm_openai_compatible_chat",
+}
+
 ALLOWED_NODE_KINDS = {
     "start",
     "template",
     "http",
-    "llm_azure_chat",
-    "llm_xai_chat",
-    "llm_groq_chat",
+    *LLM_CHAT_NODE_KINDS,
     "if_else",
     "variable_aggregator",
     "code",

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player/nodes/__init__.py

@@ -15,6 +15,7 @@ from dify_player.nodes.http import run as run_http
 from dify_player.nodes.if_else import run as run_if_else
 from dify_player.nodes.llm_azure_chat import run as run_llm_azure_chat
 from dify_player.nodes.llm_groq_chat import run as run_llm_groq_chat
+from dify_player.nodes.llm_openai_compatible_chat import run as run_llm_openai_compatible_chat
 from dify_player.nodes.llm_xai_chat import run as run_llm_xai_chat
 from dify_player.nodes.start import run as run_start
 from dify_player.nodes.template import run as run_template
@@ -29,6 +30,7 @@ _EXECUTORS: dict[str, NodeExecutor] = {
     "llm_azure_chat": run_llm_azure_chat,
     "llm_xai_chat": run_llm_xai_chat,
     "llm_groq_chat": run_llm_groq_chat,
+    "llm_openai_compatible_chat": run_llm_openai_compatible_chat,
     "if_else": run_if_else,
     "variable_aggregator": run_variable_aggregator,
     "code": run_code,
@@ -56,6 +58,6 @@ async def run_node(
         "resolved_inputs": resolved_inputs,
         "http_client": http_client,
     }
-    if node.kind in {"llm_azure_chat", "llm_groq_chat"}:
+    if node.kind in {"llm_azure_chat", "llm_groq_chat", "llm_openai_compatible_chat"}:
         kwargs["provider_config"] = provider_config
     return await executor(**kwargs)

dify_player-0.3.9/dify_player/nodes/llm_groq_chat.py

@@ -0,0 +1,52 @@
+"""LLM node for Groq and other OpenAI-compatible Chat Completions endpoints.
+
+Although named ``llm_groq_chat`` for historical reasons, this node speaks the
+plain OpenAI ``/chat/completions`` protocol, so it can target any
+OpenAI-compatible server (Groq, on-prem vLLM / TGI, etc.) simply by overriding
+``groq_api_base_url`` / ``DIFY_PLAYER_GROQ_API_BASE_URL``. Structured output is
+requested with the OpenAI-standard ``response_format: {"type": "json_schema",
+...}`` shape, which recent vLLM builds accept, so OSS / on-prem deployments
+reuse this node unchanged.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from dify_player.exceptions import GroqLLMBadStatusError, GroqLLMRequestFailedError, GroqLLMStructuredOutputError
+from dify_player.models import Node
+from dify_player.nodes.llm_openai_compatible_chat import run_openai_compatible_chat
+from dify_player.provider_config import ProviderConfig
+
+_DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
+
+
+async def run(
+    *,
+    node: Node,
+    workflow_inputs: dict[str, Any],
+    node_outputs: dict[str, dict[str, Any]],
+    resolved_inputs: dict[str, Any],
+    http_client: httpx.AsyncClient | None = None,
+    provider_config: ProviderConfig | None = None,
+) -> dict[str, Any]:
+    return await run_openai_compatible_chat(
+        node=node,
+        workflow_inputs=workflow_inputs,
+        node_outputs=node_outputs,
+        resolved_inputs=resolved_inputs,
+        http_client=http_client,
+        provider_config=provider_config,
+        api_key_config_key="groq_api_key",
+        api_key_env_names=("DIFY_PLAYER_GROQ_API_KEY", "GROQ_API_KEY"),
+        base_url_config_key="groq_api_base_url",
+        base_url_env_names=("DIFY_PLAYER_GROQ_API_BASE_URL", "GROQ_API_BASE_URL"),
+        base_url_default=_DEFAULT_BASE_URL,
+        provider_name="groq",
+        bad_status_error_cls=GroqLLMBadStatusError,
+        request_failed_error_cls=GroqLLMRequestFailedError,
+        structured_output_error_cls=GroqLLMStructuredOutputError,
+        json_validate_failed_default_message="Groq json_validate_failed",
+    )

dify_player-0.3.8/dify_player/nodes/llm_groq_chat.py → dify_player-0.3.9/dify_player/nodes/llm_openai_compatible_chat.py

@@ -1,14 +1,3 @@
-"""LLM node for Groq and other OpenAI-compatible Chat Completions endpoints.
-
-Although named ``llm_groq_chat`` for historical reasons, this node speaks the
-plain OpenAI ``/chat/completions`` protocol, so it can target any
-OpenAI-compatible server (Groq, on-prem vLLM / TGI, etc.) simply by overriding
-``groq_api_base_url`` / ``DIFY_PLAYER_GROQ_API_BASE_URL``. Structured output is
-requested with the OpenAI-standard ``response_format: {"type": "json_schema",
-...}`` shape, which recent vLLM builds accept, so OSS / on-prem deployments
-reuse this node unchanged.
-"""
-
 from __future__ import annotations
 
 import json
@@ -16,7 +5,11 @@ from typing import Any
 
 import httpx
 
-from dify_player.exceptions import GroqLLMBadStatusError, GroqLLMRequestFailedError, GroqLLMStructuredOutputError
+from dify_player.exceptions import (
+    OpenAICompatibleLLMBadStatusError,
+    OpenAICompatibleLLMRequestFailedError,
+    OpenAICompatibleLLMStructuredOutputError,
+)
 from dify_player.models import Node
 from dify_player.nodes.llm_azure_chat import (
     _build_bad_status_message,
@@ -32,7 +25,6 @@ from dify_player.nodes.llm_azure_chat import (
 from dify_player.provider_config import ProviderConfig, resolve_provider_config_value
 from dify_player.value_renderer import render_value
 
-_DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
 _STRUCTURED_OUTPUT_REPAIR_RETRIES = 1
 
 
@@ -44,22 +36,69 @@ async def run(
     resolved_inputs: dict[str, Any],
     http_client: httpx.AsyncClient | None = None,
     provider_config: ProviderConfig | None = None,
+) -> dict[str, Any]:
+    return await run_openai_compatible_chat(
+        node=node,
+        workflow_inputs=workflow_inputs,
+        node_outputs=node_outputs,
+        resolved_inputs=resolved_inputs,
+        http_client=http_client,
+        provider_config=provider_config,
+        api_key_config_key="openai_compatible_api_key",
+        api_key_env_names=(
+            "DIFY_PLAYER_OPENAI_COMPATIBLE_API_KEY",
+            "OPENAI_COMPATIBLE_API_KEY",
+        ),
+        base_url_config_key="openai_compatible_api_base_url",
+        base_url_env_names=(
+            "DIFY_PLAYER_OPENAI_COMPATIBLE_API_BASE_URL",
+            "OPENAI_COMPATIBLE_API_BASE_URL",
+        ),
+        base_url_default=None,
+        provider_name="openai_compatible",
+        bad_status_error_cls=OpenAICompatibleLLMBadStatusError,
+        request_failed_error_cls=OpenAICompatibleLLMRequestFailedError,
+        structured_output_error_cls=OpenAICompatibleLLMStructuredOutputError,
+        json_validate_failed_default_message=(
+            "OpenAI-compatible json_validate_failed"
+        ),
+    )
+
+
+async def run_openai_compatible_chat(
+    *,
+    node: Node,
+    workflow_inputs: dict[str, Any],
+    node_outputs: dict[str, dict[str, Any]],
+    resolved_inputs: dict[str, Any],
+    http_client: httpx.AsyncClient | None,
+    provider_config: ProviderConfig | None,
+    api_key_config_key: str,
+    api_key_env_names: tuple[str, ...],
+    base_url_config_key: str,
+    base_url_env_names: tuple[str, ...],
+    base_url_default: str | None,
+    provider_name: str,
+    bad_status_error_cls: type[OpenAICompatibleLLMBadStatusError],
+    request_failed_error_cls: type[OpenAICompatibleLLMRequestFailedError],
+    structured_output_error_cls: type[OpenAICompatibleLLMStructuredOutputError],
+    json_validate_failed_default_message: str,
 ) -> dict[str, Any]:
     _ = resolved_inputs
     api_key = resolve_provider_config_value(
         provider_config=provider_config,
-        config_key="groq_api_key",
-        env_names=("DIFY_PLAYER_GROQ_API_KEY", "GROQ_API_KEY"),
+        config_key=api_key_config_key,
+        env_names=api_key_env_names,
         node=node,
         required=True,
     )
     base_url = resolve_provider_config_value(
         provider_config=provider_config,
-        config_key="groq_api_base_url",
-        env_names=("DIFY_PLAYER_GROQ_API_BASE_URL", "GROQ_API_BASE_URL"),
+        config_key=base_url_config_key,
+        env_names=base_url_env_names,
         node=node,
-        required=False,
-        default=_DEFAULT_BASE_URL,
+        required=base_url_default is None,
+        default=base_url_default,
     )
 
     messages = render_value(
@@ -74,6 +113,11 @@ async def run(
             api_key=api_key,
             messages=messages,
             http_client=http_client,
+            provider_name=provider_name,
+            bad_status_error_cls=bad_status_error_cls,
+            request_failed_error_cls=request_failed_error_cls,
+            structured_output_error_cls=structured_output_error_cls,
+            json_validate_failed_default_message=json_validate_failed_default_message,
         )
 
     raw_text, metadata = await _request_raw_text(
@@ -82,6 +126,8 @@ async def run(
         api_key=api_key,
         messages=messages,
         http_client=http_client,
+        bad_status_error_cls=bad_status_error_cls,
+        request_failed_error_cls=request_failed_error_cls,
     )
     return _build_llm_output(
         text=raw_text,
@@ -89,23 +135,32 @@ async def run(
         usage=metadata["usage"],
         finish_reason=metadata["finish_reason"],
         attempt_count=1,
+        provider_name=provider_name,
     )
 
 
 def _build_request_body(*, node: Node, messages: Any) -> dict[str, Any]:
     if not isinstance(messages, list):
-        raise ValueError(f"llm node {node.label!r} config.messages must render to an array")
+        raise ValueError(
+            f"llm node {node.label!r} config.messages must render to an array"
+        )
 
     request_messages: list[dict[str, str]] = []
     for index, message in enumerate(messages):
         if not isinstance(message, dict):
-            raise ValueError(f"llm node {node.label!r} config.messages[{index}] must be an object")
+            raise ValueError(
+                f"llm node {node.label!r} config.messages[{index}] must be an object"
+            )
         role = message.get("role")
         content = message.get("content")
         if not isinstance(role, str) or not role:
-            raise ValueError(f"llm node {node.label!r} config.messages[{index}].role must be a non-empty string")
+            raise ValueError(
+                f"llm node {node.label!r} config.messages[{index}].role must be a non-empty string"
+            )
         if not isinstance(content, str):
-            raise ValueError(f"llm node {node.label!r} config.messages[{index}].content must be a string")
+            raise ValueError(
+                f"llm node {node.label!r} config.messages[{index}].content must be a string"
+            )
         request_messages.append({"role": role, "content": content})
 
     body: dict[str, Any] = {
@@ -135,6 +190,8 @@ async def _request_raw_text(
     api_key: str,
     messages: list[dict[str, str]],
     http_client: httpx.AsyncClient | None,
+    bad_status_error_cls: type[OpenAICompatibleLLMBadStatusError],
+    request_failed_error_cls: type[OpenAICompatibleLLMRequestFailedError],
 ) -> tuple[str, dict[str, Any]]:
     request_body = _build_request_body(node=node, messages=messages)
     url = f"{base_url.rstrip('/')}/chat/completions"
@@ -145,22 +202,33 @@ async def _request_raw_text(
     try:
         response = await http_client.post(
             url,
-            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
             json=request_body,
             timeout=node.config.get("timeout_sec", 60),
         )
     except httpx.RequestError as exc:
-        raise GroqLLMRequestFailedError(f"llm node {node.label!r} request failed: {exc}") from exc
+        raise request_failed_error_cls(
+            f"llm node {node.label!r} request failed: {exc}"
+        ) from exc
 
     if response.status_code >= 400:
-        raise GroqLLMBadStatusError(
-            _build_bad_status_message(node=node, status_code=response.status_code, response_body=response.text),
+        raise bad_status_error_cls(
+            _build_bad_status_message(
+                node=node,
+                status_code=response.status_code,
+                response_body=response.text,
+            ),
             status_code=response.status_code,
             response_body=response.text,
         )
 
     payload = _parse_response_json(node=node, body=response.text)
-    return _extract_response_text(node=node, payload=payload), _extract_response_metadata(payload)
+    return _extract_response_text(
+        node=node, payload=payload
+    ), _extract_response_metadata(payload)
 
 
 async def _run_structured_output_with_repair(
@@ -170,6 +238,11 @@ async def _run_structured_output_with_repair(
     api_key: str,
     messages: list[dict[str, str]],
     http_client: httpx.AsyncClient | None,
+    provider_name: str,
+    bad_status_error_cls: type[OpenAICompatibleLLMBadStatusError],
+    request_failed_error_cls: type[OpenAICompatibleLLMRequestFailedError],
+    structured_output_error_cls: type[OpenAICompatibleLLMStructuredOutputError],
+    json_validate_failed_default_message: str,
 ) -> dict[str, Any]:
     current_messages = list(messages)
     attempts: list[dict[str, str]] = []
@@ -184,9 +257,14 @@ async def _run_structured_output_with_repair(
                 api_key=api_key,
                 messages=current_messages,
                 http_client=http_client,
+                bad_status_error_cls=bad_status_error_cls,
+                request_failed_error_cls=request_failed_error_cls,
+            )
+        except bad_status_error_cls as exc:
+            failed_generation = _extract_json_validate_failed_generation(
+                exc,
+                default_message=json_validate_failed_default_message,
             )
-        except GroqLLMBadStatusError as exc:
-            failed_generation = _extract_groq_failed_generation(exc)
             if failed_generation is None:
                 raise
 
@@ -200,12 +278,15 @@ async def _run_structured_output_with_repair(
                 }
             )
             if attempt_index >= _STRUCTURED_OUTPUT_REPAIR_RETRIES:
-                raise GroqLLMStructuredOutputError(
+                raise structured_output_error_cls(
                     f"{validation_error} after {attempt_index + 1} attempts",
                     attempts=attempts,
                 ) from exc
             current_messages = current_messages + [
-                _build_repair_message(validation_error=validation_error, previous_output=raw_text)
+                _build_repair_message(
+                    validation_error=validation_error,
+                    previous_output=raw_text,
+                )
             ]
             continue
 
@@ -213,13 +294,19 @@ async def _run_structured_output_with_repair(
         latest_metadata = metadata
         try:
             structured_output = _parse_structured_output(node=node, raw_text=raw_text)
-            _validate_schema(node=node, schema=node.config["json_schema"], value=structured_output, path="$")
+            _validate_schema(
+                node=node,
+                schema=node.config["json_schema"],
+                value=structured_output,
+                path="$",
+            )
             return _build_llm_output(
                 text=raw_text,
                 structured_output=structured_output,
                 usage=aggregated_usage,
                 finish_reason=latest_metadata["finish_reason"],
                 attempt_count=attempt_index + 1,
+                provider_name=provider_name,
             )
         except ValueError as exc:
             attempts.append(
@@ -230,20 +317,25 @@ async def _run_structured_output_with_repair(
                 }
             )
             if attempt_index >= _STRUCTURED_OUTPUT_REPAIR_RETRIES:
-                raise GroqLLMStructuredOutputError(
+                raise structured_output_error_cls(
                     f"{str(exc)} after {attempt_index + 1} attempts",
                     attempts=attempts,
                 ) from exc
-            current_messages = current_messages + [_build_repair_message(validation_error=str(exc), previous_output=raw_text)]
+            current_messages = current_messages + [
+                _build_repair_message(
+                    validation_error=str(exc),
+                    previous_output=raw_text,
+                )
+            ]
 
     raise AssertionError("structured output repair loop must return or raise")
 
 
-# Groq may return json_validate_failed as HTTP 400 even when the failure is the
-# model's generated JSON, not a permanent request/schema error. Retry through the
-# existing repair prompt even when Groq omits failed_generation, because the next
-# attempt can still recover from provider-side structured-output validation.
-def _extract_groq_failed_generation(exc: GroqLLMBadStatusError) -> tuple[str, str] | None:
+def _extract_json_validate_failed_generation(
+    exc: OpenAICompatibleLLMBadStatusError,
+    *,
+    default_message: str,
+) -> tuple[str, str] | None:
     if exc.status_code != 400 or exc.response_body is None:
         return None
 
@@ -266,7 +358,7 @@ def _extract_groq_failed_generation(exc: GroqLLMBadStatusError) -> tuple[str, st
 
     message = error.get("message")
     if not isinstance(message, str) or not message:
-        message = "Groq json_validate_failed"
+        message = default_message
     return message, failed_generation
 
 
@@ -277,6 +369,7 @@ def _build_llm_output(
     usage: dict[str, int],
     finish_reason: str | None,
     attempt_count: int,
+    provider_name: str,
 ) -> dict[str, Any]:
     output = {
         "text": text,
@@ -284,7 +377,7 @@ def _build_llm_output(
         "finish_reason": finish_reason,
         "attempt_count": attempt_count,
         "safety": None,
-        "provider_details": {"provider": "groq"},
+        "provider_details": {"provider": provider_name},
     }
     if structured_output is not None:
         output["structured_output"] = structured_output

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player/plan_loader.py

@@ -8,10 +8,10 @@ from typing import Any
 from jinja2 import meta
 
 from dify_player.exceptions import PlanValidationError
-from dify_player.models import ALLOWED_NODE_KINDS, CompiledLoop, CompiledPlan, Edge, Node, Plan, format_node_label
+from dify_player.models import ALLOWED_NODE_KINDS, LLM_CHAT_NODE_KINDS, CompiledLoop, CompiledPlan, Edge, Node, Plan, format_node_label
 from dify_player.value_renderer import get_native_environment
 
-LOOP_BODY_ALLOWED_NODE_KINDS = {"llm_azure_chat", "llm_xai_chat", "llm_groq_chat", "code", "if_else", "template", "assigner"}
+LOOP_BODY_ALLOWED_NODE_KINDS = {*LLM_CHAT_NODE_KINDS, "code", "if_else", "template", "assigner"}
 
 
 def _load_json(path: Path) -> Any:
@@ -92,7 +92,7 @@ def parse_plan(data: Any) -> Plan:
             _validate_code_config(node_id=node_id, node_name=name, config=normalized_config)
         if kind == "loop":
             _validate_loop_config(node_id=node_id, node_name=name, config=normalized_config)
-        if kind in {"llm_azure_chat", "llm_xai_chat", "llm_groq_chat"}:
+        if kind in LLM_CHAT_NODE_KINDS:
             _validate_llm_chat_config(node_id=node_id, node_name=name, kind=kind, config=normalized_config)
         if kind == "end" and not isinstance(normalized_config.get("outputs"), dict):
             raise PlanValidationError(f"end node {node_label!r} must define config.outputs as an object")
@@ -265,7 +265,7 @@ def _validate_node_definition(node: Node) -> None:
     elif node.kind == "loop":
         if node.inputs:
             raise PlanValidationError(f"loop node {node.label!r} must not define inputs")
-    elif node.kind in {"llm_azure_chat", "llm_xai_chat", "llm_groq_chat"}:
+    elif node.kind in LLM_CHAT_NODE_KINDS:
         _validate_allowed_roots(
             node.config["messages"],
             allowed_roots={"inputs", "nodes"},
@@ -619,7 +619,7 @@ def _parse_loop_body_nodes(raw_body_nodes: list[Any], *, node_label: str) -> lis
             _validate_if_else_config(node_id=node_id, node_name=name, config=normalized_config)
         if kind == "code":
             _validate_code_config(node_id=node_id, node_name=name, config=normalized_config)
-        if kind in {"llm_azure_chat", "llm_xai_chat", "llm_groq_chat"}:
+        if kind in LLM_CHAT_NODE_KINDS:
             _validate_llm_chat_config(node_id=node_id, node_name=name, kind=kind, config=normalized_config)
         if kind == "assigner":
             _validate_assigner_config(node_id=node_id, node_name=name, config=normalized_config)
@@ -677,7 +677,7 @@ def _validate_loop_body_node_definition(node: Node) -> None:
     elif node.kind == "code":
         if not isinstance(node.config.get("source"), str):
             raise PlanValidationError(f"loop body code node {node.label!r} must define config.source as a string")
-    elif node.kind in {"llm_azure_chat", "llm_xai_chat", "llm_groq_chat"}:
+    elif node.kind in LLM_CHAT_NODE_KINDS:
         _validate_allowed_roots(
             node.config["messages"],
             allowed_roots={"inputs", "nodes"},

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player/runtime.py

@@ -17,6 +17,9 @@ from dify_player.exceptions import (
     GroqLLMStructuredOutputError,
     HTTPBadStatusError,
     HTTPRequestFailedError,
+    OpenAICompatibleLLMBadStatusError,
+    OpenAICompatibleLLMRequestFailedError,
+    OpenAICompatibleLLMStructuredOutputError,
     PlanValidationError,
     UnsupportedNodeError,
     XAILLMBadStatusError,
@@ -477,7 +480,7 @@ class WorkflowRuntime:
         return cached_output
 
     def _should_use_llm_cache(self, *, node: Node) -> bool:
-        return self.llm_cache_enabled and node.kind == "llm_azure_chat"
+        return self.llm_cache_enabled and node.kind in {"llm_azure_chat", "llm_openai_compatible_chat"}
 
     def _load_cached_llm_output(
         self,
@@ -536,6 +539,15 @@ class WorkflowRuntime:
                 ),
                 "provider_config": _cacheable_provider_config(self.provider_config),
             }
+        elif node.kind == "llm_openai_compatible_chat":
+            extra = {
+                "rendered_messages": render_value(
+                    node.config["messages"],
+                    {"inputs": workflow_inputs, "nodes": node_outputs},
+                    location=f"llm cache key for node {node.label!r} config.messages",
+                ),
+                "provider_config": _cacheable_provider_config(self.provider_config),
+            }
         return build_llm_cache_key(
             node_kind=node.kind,
             node_config=node.config,
@@ -674,7 +686,7 @@ class WorkflowRuntime:
                     **({"response_body": exc.response_body} if exc.response_body is not None else {}),
                 },
             )
-        if isinstance(exc, (AzureLLMRequestFailedError, XAILLMRequestFailedError, GroqLLMRequestFailedError)):
+        if isinstance(exc, (AzureLLMRequestFailedError, XAILLMRequestFailedError, GroqLLMRequestFailedError, OpenAICompatibleLLMRequestFailedError)):
             return WorkflowError(
                 code="LLM_REQUEST_FAILED",
                 message=str(exc),
@@ -683,7 +695,7 @@ class WorkflowRuntime:
                 node_name=node.name,
                 retryable=True,
             )
-        if isinstance(exc, (AzureLLMBadStatusError, XAILLMBadStatusError, GroqLLMBadStatusError)):
+        if isinstance(exc, (AzureLLMBadStatusError, XAILLMBadStatusError, GroqLLMBadStatusError, OpenAICompatibleLLMBadStatusError)):
             return WorkflowError(
                 code="LLM_BAD_STATUS",
                 message=str(exc),
@@ -696,7 +708,7 @@ class WorkflowRuntime:
                     **({"response_body": exc.response_body} if exc.response_body is not None else {}),
                 },
             )
-        if isinstance(exc, (AzureLLMStructuredOutputError, XAILLMStructuredOutputError, GroqLLMStructuredOutputError)):
+        if isinstance(exc, (AzureLLMStructuredOutputError, XAILLMStructuredOutputError, GroqLLMStructuredOutputError, OpenAICompatibleLLMStructuredOutputError)):
             return WorkflowError(
                 code="NODE_EXECUTION_FAILED",
                 message=str(exc),
@@ -790,6 +802,14 @@ def _cacheable_provider_config(provider_config: ProviderConfig | None) -> dict[s
             config_key="azure_openai_api_version",
             env_names=("DIFY_PLAYER_AZURE_OPENAI_API_VERSION", "AZURE_OPENAI_API_VERSION"),
         ),
+        "openai_compatible_api_base_url": _cacheable_provider_config_value(
+            provider_config=provider_config,
+            config_key="openai_compatible_api_base_url",
+            env_names=(
+                "DIFY_PLAYER_OPENAI_COMPATIBLE_API_BASE_URL",
+                "OPENAI_COMPATIBLE_API_BASE_URL",
+            ),
+        ),
     }
     return {key: value for key, value in values.items() if value}
 

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dify-player
-Version: 0.3.8
+Version: 0.3.9
 Summary: Minimal workflow runner for hand-authored Dify-like plans.
 Requires-Python: >=3.11
 Requires-Dist: Jinja2<4,>=3.1

{dify_player-0.3.8 → dify_player-0.3.9}/dify_player.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ dify_player/nodes/http.py
 dify_player/nodes/if_else.py
 dify_player/nodes/llm_azure_chat.py
 dify_player/nodes/llm_groq_chat.py
+dify_player/nodes/llm_openai_compatible_chat.py
 dify_player/nodes/llm_xai_chat.py
 dify_player/nodes/start.py
 dify_player/nodes/template.py

{dify_player-0.3.8 → dify_player-0.3.9}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dify-player"
-version = "0.3.8"
+version = "0.3.9"
 description = "Minimal workflow runner for hand-authored Dify-like plans."
 requires-python = ">=3.11"
 dependencies = [