dify-player 0.3.1__tar.gz → 0.3.2__tar.gz

dify_player-0.3.2/MANIFEST.in

@@ -0,0 +1,2 @@
+prune workflows
+prune tests

{dify_player-0.3.1 → dify_player-0.3.2}/PKG-INFO

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

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/__init__.py

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

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/dify_importer/node_converters/if_else.py

@@ -86,4 +86,6 @@ def _convert_comparison_operator(raw_value: Any, *, node_id: str) -> str:
         return "contains"
     if raw_value == "=":
         return "equals"
-    raise PlanValidationError(f"Dify if-else node {node_id!r} only supports comparison_operator=contains or '='")
+    if raw_value == "empty":
+        return "empty"
+    raise PlanValidationError(f"Dify if-else node {node_id!r} only supports comparison_operator=contains, '=', or empty")

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/dify_importer/node_converters/llm.py

@@ -8,6 +8,13 @@ from dify_player.exceptions import PlanValidationError
 from dify_player.models import Node
 
 _AZURE_PROVIDER = "langgenius/azure_openai/azure_openai"
+_XAI_PROVIDER = "langgenius/x/x"
+_GROQ_PROVIDER = "langgenius/groq/groq"
+_PROVIDER_NODE_KINDS = {
+    _AZURE_PROVIDER: "llm_azure_chat",
+    _XAI_PROVIDER: "llm_xai_chat",
+    _GROQ_PROVIDER: "llm_groq_chat",
+}
 
 
 def convert_llm_node(
@@ -23,8 +30,12 @@ def convert_llm_node(
     if not isinstance(model, dict):
         raise PlanValidationError(f"Dify llm node {node_id!r} must define model")
     provider = model.get("provider")
-    if provider != _AZURE_PROVIDER:
-        raise PlanValidationError(f"Dify llm node {node_id!r} only supports model.provider={_AZURE_PROVIDER}")
+    node_kind = _PROVIDER_NODE_KINDS.get(provider)
+    if node_kind is None:
+        supported_providers = " or ".join(_PROVIDER_NODE_KINDS)
+        raise PlanValidationError(
+            f"Dify llm node {node_id!r} only supports model.provider={supported_providers}"
+        )
     if model.get("mode") != "chat":
         raise PlanValidationError(f"Dify llm node {node_id!r} only supports model.mode=chat")
     model_name = model.get("name")
@@ -38,6 +49,8 @@ def convert_llm_node(
         raise PlanValidationError(f"Dify llm node {node_id!r} model.completion_params must be an object")
 
     structured_output_enabled = data.get("structured_output_enabled", False)
+    if structured_output_enabled is None:
+        structured_output_enabled = False
     if not isinstance(structured_output_enabled, bool):
         raise PlanValidationError(f"Dify llm node {node_id!r} structured_output_enabled must be a boolean")
 
@@ -54,7 +67,7 @@ def convert_llm_node(
         config["response_format"] = "json_schema"
         config["json_schema"] = _extract_json_schema(node_id=node_id, data=data, completion_params=completion_params)
 
-    return Node(id=node_id, kind="llm_azure_chat", name=node_name, config=config)
+    return Node(id=node_id, kind=node_kind, name=node_name, config=config)
 
 
 def _convert_prompt_template(*, node_id: str, data: dict[str, Any], node_specs: dict[str, dict[str, Any]]) -> list[dict[str, str]]:

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/exceptions.py

@@ -42,3 +42,45 @@ class AzureLLMStructuredOutputError(RuntimeError):
     def __init__(self, message: str, *, attempts: list[dict[str, str]]) -> None:
         super().__init__(message)
         self.attempts = attempts
+
+
+class XAILLMRequestFailedError(RuntimeError):
+    """Raised when an xAI LLM request fails before receiving a response."""
+
+
+class XAILLMBadStatusError(RuntimeError):
+    """Raised when an xAI 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 XAILLMStructuredOutputError(RuntimeError):
+    """Raised when xAI structured output remains invalid after repair retries."""
+
+    def __init__(self, message: str, *, attempts: list[dict[str, str]]) -> None:
+        super().__init__(message)
+        self.attempts = attempts
+
+
+class GroqLLMRequestFailedError(RuntimeError):
+    """Raised when a Groq LLM request fails before receiving a response."""
+
+
+class GroqLLMBadStatusError(RuntimeError):
+    """Raised when a Groq 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 GroqLLMStructuredOutputError(RuntimeError):
+    """Raised when Groq 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.1 → dify_player-0.3.2}/dify_player/input_resolver.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from dify_player.exceptions import PlanValidationError
 from dify_player.models import Node
-from dify_player.value_renderer import render_value
+from dify_player.value_renderer import EMPTY_RENDERED_VALUE, render_value
 
 
 def resolve_node_inputs(
@@ -12,15 +12,21 @@ def resolve_node_inputs(
     *,
     workflow_inputs: dict[str, Any],
     node_outputs: dict[str, dict[str, Any]],
+    skipped_node_ids: set[str] | None = None,
 ) -> dict[str, Any]:
     if node.kind == "start":
         return {}
 
+    render_node_outputs: dict[str, Any] = dict(node_outputs)
+    if skipped_node_ids:
+        for node_id in skipped_node_ids:
+            render_node_outputs.setdefault(node_id, EMPTY_RENDERED_VALUE)
+
     resolved = render_value(
         node.inputs,
         {
             "inputs": workflow_inputs,
-            "nodes": node_outputs,
+            "nodes": render_node_outputs,
         },
         location=f"node {node.label!r} inputs",
     )

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/models.py

@@ -3,7 +3,19 @@ from __future__ import annotations
 from dataclasses import asdict, dataclass, field, is_dataclass
 from typing import Any
 
-ALLOWED_NODE_KINDS = {"start", "template", "http", "llm_azure_chat", "if_else", "variable_aggregator", "code", "loop", "end"}
+ALLOWED_NODE_KINDS = {
+    "start",
+    "template",
+    "http",
+    "llm_azure_chat",
+    "llm_xai_chat",
+    "llm_groq_chat",
+    "if_else",
+    "variable_aggregator",
+    "code",
+    "loop",
+    "end",
+}
 
 
 def format_node_label(node_id: str, name: str | None = None) -> str:

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/nodes/__init__.py

@@ -13,6 +13,8 @@ from dify_player.nodes.end import run as run_end
 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_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
 from dify_player.nodes.variable_aggregator import run as run_variable_aggregator
@@ -24,6 +26,8 @@ _EXECUTORS: dict[str, NodeExecutor] = {
     "template": run_template,
     "http": run_http,
     "llm_azure_chat": run_llm_azure_chat,
+    "llm_xai_chat": run_llm_xai_chat,
+    "llm_groq_chat": run_llm_groq_chat,
     "if_else": run_if_else,
     "variable_aggregator": run_variable_aggregator,
     "code": run_code,

{dify_player-0.3.1 → dify_player-0.3.2}/dify_player/nodes/if_else.py

@@ -39,6 +39,16 @@ def _matches_condition(*, condition: dict[str, Any], resolved_inputs: dict[str,
     left_value = resolved_inputs[condition["input_name"]]
     if condition["operator"] == "contains":
         return str(condition["value"]) in str(left_value)
+    if condition["operator"] == "empty":
+        return _is_empty(left_value)
     if condition["operator"] == "equals":
         return str(left_value) == str(condition["value"])
     raise ValueError(f"unsupported if_else operator {condition['operator']!r}")
+
+
+def _is_empty(value: Any) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, (str, list, tuple, dict, set)):
+        return len(value) == 0
+    return False

dify_player-0.3.2/dify_player/nodes/llm_groq_chat.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import os
+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_azure_chat import (
+    _build_bad_status_message,
+    _build_repair_message,
+    _extract_response_metadata,
+    _extract_response_text,
+    _merge_usage,
+    _parse_response_json,
+    _parse_structured_output,
+    _validate_schema,
+    _zero_usage,
+)
+from dify_player.value_renderer import render_value
+
+_DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
+_STRUCTURED_OUTPUT_REPAIR_RETRIES = 1
+
+
+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,
+) -> dict[str, Any]:
+    _ = resolved_inputs
+    api_key = _require_env("GROQ_API_KEY", node=node)
+    base_url = os.environ.get("GROQ_API_BASE_URL", _DEFAULT_BASE_URL)
+
+    messages = render_value(
+        node.config["messages"],
+        {"inputs": workflow_inputs, "nodes": node_outputs},
+        location=f"llm node {node.label!r} config.messages",
+    )
+    if node.config["response_format"] == "json_schema":
+        return await _run_structured_output_with_repair(
+            node=node,
+            base_url=base_url,
+            api_key=api_key,
+            messages=messages,
+            http_client=http_client,
+        )
+
+    raw_text, metadata = await _request_raw_text(
+        node=node,
+        base_url=base_url,
+        api_key=api_key,
+        messages=messages,
+        http_client=http_client,
+    )
+    return _build_llm_output(
+        text=raw_text,
+        structured_output=None,
+        usage=metadata["usage"],
+        finish_reason=metadata["finish_reason"],
+        attempt_count=1,
+    )
+
+
+def _require_env(name: str, *, node: Node) -> str:
+    value = os.environ.get(name)
+    if value:
+        return value
+    raise ValueError(f"llm node {node.label!r} requires environment variable {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")
+
+    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")
+        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")
+        if not isinstance(content, str):
+            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] = {
+        "model": node.config["model"],
+        "messages": request_messages,
+    }
+    for key in ("temperature", "top_p", "max_tokens"):
+        if key in node.config:
+            body[key] = node.config[key]
+
+    if node.config["response_format"] == "json_schema":
+        body["response_format"] = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": "structured_output",
+                "schema": node.config["json_schema"],
+            },
+        }
+
+    return body
+
+
+async def _request_raw_text(
+    *,
+    node: Node,
+    base_url: str,
+    api_key: str,
+    messages: list[dict[str, str]],
+    http_client: httpx.AsyncClient | None,
+) -> tuple[str, dict[str, Any]]:
+    request_body = _build_request_body(node=node, messages=messages)
+    url = f"{base_url.rstrip('/')}/chat/completions"
+
+    if http_client is None:
+        raise ValueError(f"llm node {node.label!r} requires an async HTTP client")
+
+    try:
+        response = await http_client.post(
+            url,
+            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
+
+    if response.status_code >= 400:
+        raise GroqLLMBadStatusError(
+            _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)
+
+
+async def _run_structured_output_with_repair(
+    *,
+    node: Node,
+    base_url: str,
+    api_key: str,
+    messages: list[dict[str, str]],
+    http_client: httpx.AsyncClient | None,
+) -> dict[str, Any]:
+    current_messages = list(messages)
+    attempts: list[dict[str, str]] = []
+    aggregated_usage = _zero_usage()
+    latest_metadata = {"usage": _zero_usage(), "finish_reason": None}
+
+    for attempt_index in range(_STRUCTURED_OUTPUT_REPAIR_RETRIES + 1):
+        raw_text, metadata = await _request_raw_text(
+            node=node,
+            base_url=base_url,
+            api_key=api_key,
+            messages=current_messages,
+            http_client=http_client,
+        )
+        aggregated_usage = _merge_usage(aggregated_usage, metadata["usage"])
+        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="$")
+            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,
+            )
+        except ValueError as exc:
+            attempts.append(
+                {
+                    "attempt": str(attempt_index + 1),
+                    "error": str(exc),
+                    "raw_text": raw_text,
+                }
+            )
+            if attempt_index >= _STRUCTURED_OUTPUT_REPAIR_RETRIES:
+                raise GroqLLMStructuredOutputError(
+                    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)]
+
+    raise AssertionError("structured output repair loop must return or raise")
+
+
+def _build_llm_output(
+    *,
+    text: str,
+    structured_output: Any,
+    usage: dict[str, int],
+    finish_reason: str | None,
+    attempt_count: int,
+) -> dict[str, Any]:
+    output = {
+        "text": text,
+        "usage": usage,
+        "finish_reason": finish_reason,
+        "attempt_count": attempt_count,
+        "safety": None,
+        "provider_details": {"provider": "groq"},
+    }
+    if structured_output is not None:
+        output["structured_output"] = structured_output
+    return output

dify_player-0.3.2/dify_player/nodes/llm_xai_chat.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from dify_player.exceptions import XAILLMBadStatusError, XAILLMRequestFailedError, XAILLMStructuredOutputError
+from dify_player.models import Node
+from dify_player.nodes.llm_azure_chat import (
+    _build_bad_status_message,
+    _build_repair_message,
+    _extract_response_metadata,
+    _extract_response_text,
+    _merge_usage,
+    _parse_response_json,
+    _parse_structured_output,
+    _validate_schema,
+    _zero_usage,
+)
+from dify_player.value_renderer import render_value
+
+_DEFAULT_BASE_URL = "https://api.x.ai/v1"
+_STRUCTURED_OUTPUT_REPAIR_RETRIES = 1
+
+
+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,
+) -> dict[str, Any]:
+    _ = resolved_inputs
+    api_key = _require_env("XAI_API_KEY", node=node)
+    base_url = os.environ.get("XAI_API_BASE_URL", _DEFAULT_BASE_URL)
+
+    messages = render_value(
+        node.config["messages"],
+        {"inputs": workflow_inputs, "nodes": node_outputs},
+        location=f"llm node {node.label!r} config.messages",
+    )
+    if node.config["response_format"] == "json_schema":
+        return await _run_structured_output_with_repair(
+            node=node,
+            base_url=base_url,
+            api_key=api_key,
+            messages=messages,
+            http_client=http_client,
+        )
+
+    raw_text, metadata = await _request_raw_text(
+        node=node,
+        base_url=base_url,
+        api_key=api_key,
+        messages=messages,
+        http_client=http_client,
+    )
+    return _build_llm_output(
+        text=raw_text,
+        structured_output=None,
+        usage=metadata["usage"],
+        finish_reason=metadata["finish_reason"],
+        attempt_count=1,
+    )
+
+
+def _require_env(name: str, *, node: Node) -> str:
+    value = os.environ.get(name)
+    if value:
+        return value
+    raise ValueError(f"llm node {node.label!r} requires environment variable {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")
+
+    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")
+        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")
+        if not isinstance(content, str):
+            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] = {
+        "model": node.config["model"],
+        "messages": request_messages,
+    }
+    for key in ("temperature", "top_p", "max_tokens"):
+        if key in node.config:
+            body[key] = node.config[key]
+
+    if node.config["response_format"] == "json_schema":
+        body["response_format"] = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": "structured_output",
+                "schema": node.config["json_schema"],
+            },
+        }
+
+    return body
+
+
+async def _request_raw_text(
+    *,
+    node: Node,
+    base_url: str,
+    api_key: str,
+    messages: list[dict[str, str]],
+    http_client: httpx.AsyncClient | None,
+) -> tuple[str, dict[str, Any]]:
+    request_body = _build_request_body(node=node, messages=messages)
+    url = f"{base_url.rstrip('/')}/chat/completions"
+
+    if http_client is None:
+        raise ValueError(f"llm node {node.label!r} requires an async HTTP client")
+
+    try:
+        response = await http_client.post(
+            url,
+            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 XAILLMRequestFailedError(f"llm node {node.label!r} request failed: {exc}") from exc
+
+    if response.status_code >= 400:
+        raise XAILLMBadStatusError(
+            _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)
+
+
+async def _run_structured_output_with_repair(
+    *,
+    node: Node,
+    base_url: str,
+    api_key: str,
+    messages: list[dict[str, str]],
+    http_client: httpx.AsyncClient | None,
+) -> dict[str, Any]:
+    current_messages = list(messages)
+    attempts: list[dict[str, str]] = []
+    aggregated_usage = _zero_usage()
+    latest_metadata = {"usage": _zero_usage(), "finish_reason": None}
+
+    for attempt_index in range(_STRUCTURED_OUTPUT_REPAIR_RETRIES + 1):
+        raw_text, metadata = await _request_raw_text(
+            node=node,
+            base_url=base_url,
+            api_key=api_key,
+            messages=current_messages,
+            http_client=http_client,
+        )
+        aggregated_usage = _merge_usage(aggregated_usage, metadata["usage"])
+        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="$")
+            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,
+            )
+        except ValueError as exc:
+            attempts.append(
+                {
+                    "attempt": str(attempt_index + 1),
+                    "error": str(exc),
+                    "raw_text": raw_text,
+                }
+            )
+            if attempt_index >= _STRUCTURED_OUTPUT_REPAIR_RETRIES:
+                raise XAILLMStructuredOutputError(
+                    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)]
+
+    raise AssertionError("structured output repair loop must return or raise")
+
+
+def _build_llm_output(
+    *,
+    text: str,
+    structured_output: Any,
+    usage: dict[str, int],
+    finish_reason: str | None,
+    attempt_count: int,
+) -> dict[str, Any]:
+    output = {
+        "text": text,
+        "usage": usage,
+        "finish_reason": finish_reason,
+        "attempt_count": attempt_count,
+        "safety": None,
+        "provider_details": {"provider": "xai"},
+    }
+    if structured_output is not None:
+        output["structured_output"] = structured_output
+    return output