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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dify-player
-Version: 0.3.2
+Version: 0.3.3
 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.3}/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.3"

dify_player-0.3.3/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.3}/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.3}/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.3}/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.3}/dify_player.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dify-player
-Version: 0.3.2
+Version: 0.3.3
 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.3}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dify-player"
-version = "0.3.2"
+version = "0.3.3"
 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)