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

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

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

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

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

dify_player-0.3.4/dify_player/dify_importer/node_converters/start.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Any
+
+from dify_player.exceptions import PlanValidationError
+from dify_player.models import Node
+
+
+def convert_start_node(*, node_id: str, node_name: str | None, data: dict[str, Any] | None = None) -> Node:
+    input_schema = _convert_input_schema(node_id=node_id, data=data or {})
+    config = {"input_schema": input_schema} if input_schema else {}
+    return Node(id=node_id, kind="start", name=node_name, config=config)
+
+
+def _convert_input_schema(*, node_id: str, data: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    raw_variables = data.get("variables", [])
+    if raw_variables is None:
+        raw_variables = []
+    if not isinstance(raw_variables, list):
+        raise PlanValidationError(f"Dify start node {node_id!r} variables must be an array")
+
+    input_schema: dict[str, dict[str, Any]] = {}
+    for index, raw_variable in enumerate(raw_variables):
+        if not isinstance(raw_variable, dict):
+            raise PlanValidationError(f"Dify start node {node_id!r} variables[{index}] must be an object")
+        variable = raw_variable.get("variable")
+        if not isinstance(variable, str) or not variable:
+            raise PlanValidationError(f"Dify start node {node_id!r} variables[{index}].variable must be a non-empty string")
+        if variable in input_schema:
+            raise PlanValidationError(f"Dify start node {node_id!r} defines duplicate variable {variable!r}")
+
+        required = raw_variable.get("required", True)
+        if not isinstance(required, bool):
+            raise PlanValidationError(f"Dify start node {node_id!r} variables[{index}].required must be a boolean when provided")
+
+        field_schema: dict[str, Any] = {"required": required}
+        if _has_meaningful_default(raw_variable=raw_variable, required=required):
+            field_schema["default"] = raw_variable["default"]
+        input_schema[variable] = field_schema
+    return input_schema
+
+
+def _has_meaningful_default(*, raw_variable: dict[str, Any], required: bool) -> bool:
+    if "default" not in raw_variable:
+        return False
+    default = raw_variable["default"]
+    if required and default == "":
+        return False
+    return True

{dify_player-0.3.2 → dify_player-0.3.4}/dify_player/dify_importer/workflow_loader.py

@@ -42,7 +42,7 @@ def _convert_node(*, node_id: str, data: dict[str, Any], parsed_graph: ParsedDif
     node_type = data["type"]
     node_name = _extract_node_name(node_id=node_id, data=data)
     if node_type == "start":
-        return convert_start_node(node_id=node_id, node_name=node_name)
+        return convert_start_node(node_id=node_id, node_name=node_name, data=data)
     if node_type == "http-request":
         return convert_http_request_node(node_id=node_id, node_name=node_name, data=data, node_specs=parsed_graph.node_specs)
     if node_type == "llm":

{dify_player-0.3.2 → dify_player-0.3.4}/dify_player/nodes/llm_groq_chat.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 from typing import Any
 
@@ -158,13 +159,38 @@ async def _run_structured_output_with_repair(
     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,
-        )
+        try:
+            raw_text, metadata = await _request_raw_text(
+                node=node,
+                base_url=base_url,
+                api_key=api_key,
+                messages=current_messages,
+                http_client=http_client,
+            )
+        except GroqLLMBadStatusError as exc:
+            failed_generation = _extract_groq_failed_generation(exc)
+            if failed_generation is None:
+                raise
+
+            validation_error, raw_text = failed_generation
+            attempts.append(
+                {
+                    "attempt": str(attempt_index + 1),
+                    "error": validation_error,
+                    "raw_text": raw_text,
+                    "provider_status_code": str(exc.status_code),
+                }
+            )
+            if attempt_index >= _STRUCTURED_OUTPUT_REPAIR_RETRIES:
+                raise GroqLLMStructuredOutputError(
+                    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)
+            ]
+            continue
+
         aggregated_usage = _merge_usage(aggregated_usage, metadata["usage"])
         latest_metadata = metadata
         try:
@@ -195,6 +221,36 @@ async def _run_structured_output_with_repair(
     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. Preserve that
+# failed output so the existing structured-output repair prompt can fix it.
+def _extract_groq_failed_generation(exc: GroqLLMBadStatusError) -> tuple[str, str] | None:
+    if exc.status_code != 400 or exc.response_body is None:
+        return None
+
+    try:
+        payload = json.loads(exc.response_body)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(payload, dict):
+        return None
+
+    error = payload.get("error")
+    if not isinstance(error, dict):
+        return None
+    if error.get("code") != "json_validate_failed":
+        return None
+
+    failed_generation = error.get("failed_generation")
+    if not isinstance(failed_generation, str) or not failed_generation.strip():
+        return None
+
+    message = error.get("message")
+    if not isinstance(message, str) or not message:
+        message = "Groq json_validate_failed"
+    return message, failed_generation
+
+
 def _build_llm_output(
     *,
     text: str,

{dify_player-0.3.2 → dify_player-0.3.4}/dify_player/plan_loader.py

@@ -78,6 +78,8 @@ def parse_plan(data: Any) -> Plan:
         if not isinstance(config, dict):
             raise PlanValidationError(f"node.config must be an object for node {node_label!r}")
         normalized_config = dict(config)
+        if kind == "start":
+            _validate_start_config(node_id=node_id, node_name=name, config=normalized_config)
         if kind == "template" and not isinstance(normalized_config.get("template"), str):
             raise PlanValidationError(f"template node {node_label!r} must define config.template as a string")
         if kind == "http":
@@ -305,6 +307,36 @@ def _collect_roots(value: Any) -> set[str]:
     return set()
 
 
+def _validate_start_config(*, node_id: str, node_name: str | None, config: dict[str, Any]) -> None:
+    node_label = format_node_label(node_id, node_name)
+    allowed_keys = {"input_schema"}
+    extra_keys = sorted(set(config) - allowed_keys)
+    if extra_keys:
+        raise PlanValidationError(f"start node {node_label!r} config has unsupported keys: {', '.join(extra_keys)}")
+    if "input_schema" not in config:
+        return
+
+    input_schema = config["input_schema"]
+    if not isinstance(input_schema, dict):
+        raise PlanValidationError(f"start node {node_label!r} config.input_schema must be an object")
+
+    normalized_schema: dict[str, dict[str, Any]] = {}
+    for variable, field_schema in input_schema.items():
+        if not isinstance(variable, str) or not variable:
+            raise PlanValidationError(f"start node {node_label!r} config.input_schema keys must be non-empty strings")
+        if not isinstance(field_schema, dict):
+            raise PlanValidationError(f"start node {node_label!r} config.input_schema.{variable} must be an object")
+        required = field_schema.get("required", True)
+        if not isinstance(required, bool):
+            raise PlanValidationError(
+                f"start node {node_label!r} config.input_schema.{variable}.required must be a boolean when provided"
+            )
+        normalized_field_schema = dict(field_schema)
+        normalized_field_schema["required"] = required
+        normalized_schema[variable] = normalized_field_schema
+    config["input_schema"] = normalized_schema
+
+
 def _validate_http_config(*, node_id: str, node_name: str | None, config: dict[str, Any]) -> None:
     node_label = format_node_label(node_id, node_name)
     allowed_keys = {"method", "timeout_sec"}

{dify_player-0.3.2 → dify_player-0.3.4}/dify_player/runtime.py

@@ -52,7 +52,7 @@ class WorkflowRuntime:
     ) -> RunResult:
         effective_started_at = started_at or _utc_now()
         effective_started_monotonic = started_monotonic if started_monotonic is not None else time.monotonic()
-        state = RunState(run_id=self.logger.run_id, inputs=inputs)
+        state = RunState(run_id=self.logger.run_id, inputs=_normalize_workflow_inputs(compiled_plan=compiled_plan, inputs=inputs))
         effective_http_client = http_client if http_client is not None else httpx.AsyncClient()
         owns_http_client = http_client is None
         try:
@@ -755,6 +755,23 @@ def _utc_now() -> str:
     return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 
 
+def _normalize_workflow_inputs(*, compiled_plan: CompiledPlan, inputs: dict[str, Any]) -> dict[str, Any]:
+    normalized_inputs = dict(inputs)
+    start_node = compiled_plan.node_by_id[compiled_plan.start_node_id]
+    input_schema = start_node.config.get("input_schema", {})
+    if not isinstance(input_schema, dict):
+        return normalized_inputs
+
+    for variable, field_schema in input_schema.items():
+        if variable in normalized_inputs or not isinstance(field_schema, dict):
+            continue
+        if "default" in field_schema:
+            normalized_inputs[variable] = deepcopy(field_schema["default"])
+        elif field_schema.get("required", True) is False:
+            normalized_inputs[variable] = ""
+    return normalized_inputs
+
+
 class _LoopRuntimeError(ValueError):
     def __init__(self, error: WorkflowError) -> None:
         super().__init__(error.message)

{dify_player-0.3.2 → dify_player-0.3.4}/dify_player.egg-info/PKG-INFO

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

{dify_player-0.3.2 → dify_player-0.3.4}/pyproject.toml

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

dify_player-0.3.2/dify_player/dify_importer/node_converters/start.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-
-from dify_player.models import Node
-
-
-def convert_start_node(*, node_id: str, node_name: str | None) -> Node:
-    return Node(id=node_id, kind="start", name=node_name)