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

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

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

{dify_player-0.2.0 → dify_player-0.3.1}/README.md

@@ -19,14 +19,17 @@ pip install -e .
 `run_plan_data(...)` は strict plan JSON 相当の dict をそのまま受け取れます。
 
 ```python
-from dify_player import WorkflowEngine
+from dify_player import NullLLMCacheStore, WorkflowEngine
 from dify_player.models import to_data
 
 engine = WorkflowEngine()
+cache_store = NullLLMCacheStore()
 
 result = await engine.run_plan_data(
     plan_data=plan_data,
     inputs=inputs,
+    llm_cache=False,
+    llm_cache_store=cache_store,
 )
 
 if result.status == "succeeded":
@@ -84,9 +87,9 @@ async def run_workflow(payload: dict) -> dict:
 
 `WorkflowEngine` には次の async API があります。
 
-- `await engine.run_plan_data(plan_data=..., inputs=..., run_id=None, logger=None, http_client=None)`
-- `await engine.run_plan(plan=..., inputs=..., run_id=None, logger=None, http_client=None)`
-- `await engine.run_compiled_plan(compiled_plan=..., inputs=..., run_id=None, logger=None, http_client=None)`
+- `await engine.run_plan_data(plan_data=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None)`
+- `await engine.run_plan(plan=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None)`
+- `await engine.run_compiled_plan(compiled_plan=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None)`
 
 使い分けは次のとおりです。
 
@@ -94,6 +97,37 @@ async def run_workflow(payload: dict) -> dict:
 - `run_plan`: すでに `Plan` オブジェクトを組み立てている内部利用向け
 - `run_compiled_plan`: 同じ plan を何度も実行する用途向け
 
+### LLM Cache Mode
+
+workflow 改善中だけ LLM 応答を再利用したい場合は、`llm_cache=True` と cache store を渡します。  
+cache key は `node.kind`、`node.config`、`resolved_inputs`、実際に送る `messages` のレンダリング結果を正規化した内容から作られます。
+
+```python
+from dify_player import WorkflowEngine
+
+
+class MyLLMCacheStore:
+    def get(self, key: str) -> dict | None:
+        ...
+
+    def put(self, key: str, value: dict) -> None:
+        ...
+
+
+engine = WorkflowEngine()
+cache_store = MyLLMCacheStore()
+
+result = await engine.run_plan_data(
+    plan_data=plan_data,
+    inputs=inputs,
+    llm_cache=True,
+    llm_cache_store=cache_store,
+)
+```
+
+現在 cache 対象は `llm_azure_chat` ノードだけです。  
+Azure Blob などの実ストアはこのパッケージには含めず、呼び出し側から差し込む前提です。
+
 ### Logger And HTTP Client
 
 `logger` を渡さない場合、ライブラリ利用時はファイルログを書きません。  

dify_player-0.3.1/dify_player/__init__.py

@@ -0,0 +1,8 @@
+"""Minimal workflow runner package."""
+
+from dify_player.llm_cache import LLMCacheStore, NullLLMCacheStore
+from dify_player.workflow_engine import WorkflowEngine
+
+__all__ = ["__version__", "LLMCacheStore", "NullLLMCacheStore", "WorkflowEngine"]
+
+__version__ = "0.3.1"

dify_player-0.3.1/dify_player/llm_cache.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Protocol
+
+
+class LLMCacheStore(Protocol):
+    def get(self, key: str) -> dict[str, Any] | None: ...
+
+    def put(self, key: str, value: dict[str, Any]) -> None: ...
+
+
+class NullLLMCacheStore:
+    def get(self, key: str) -> dict[str, Any] | None:
+        _ = key
+        return None
+
+    def put(self, key: str, value: dict[str, Any]) -> None:
+        _ = key
+        _ = value
+
+
+def build_llm_cache_key(
+    *,
+    node_kind: str,
+    node_config: dict[str, Any],
+    resolved_inputs: dict[str, Any],
+    extra: dict[str, Any] | None = None,
+) -> str:
+    payload = {
+        "node_kind": node_kind,
+        "node_config": node_config,
+        "resolved_inputs": resolved_inputs,
+    }
+    if extra:
+        payload["extra"] = extra
+
+    normalized = json.dumps(
+        payload,
+        sort_keys=True,
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()

{dify_player-0.2.0 → dify_player-0.3.1}/dify_player/runtime.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import time
+from copy import deepcopy
 from datetime import datetime, timezone
 from typing import Any
 
@@ -16,13 +17,23 @@ from dify_player.exceptions import (
     UnsupportedNodeError,
 )
 from dify_player.input_resolver import resolve_node_inputs
+from dify_player.llm_cache import LLMCacheStore, NullLLMCacheStore, build_llm_cache_key
 from dify_player.models import CompiledLoop, CompiledPlan, Edge, Node, NodeResult, RunResult, RunState, WorkflowError
 from dify_player.nodes import run_node
+from dify_player.value_renderer import render_value
 
 
 class WorkflowRuntime:
-    def __init__(self, logger: WorkflowLogger) -> None:
+    def __init__(
+        self,
+        logger: WorkflowLogger,
+        *,
+        llm_cache_enabled: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
+    ) -> None:
         self.logger = logger
+        self.llm_cache_enabled = llm_cache_enabled
+        self.llm_cache_store = llm_cache_store if llm_cache_store is not None else NullLLMCacheStore()
 
     async def run(
         self,
@@ -153,7 +164,7 @@ class WorkflowRuntime:
                     http_client=http_client,
                 )
             else:
-                output = await run_node(
+                output = await self._execute_node(
                     node=node,
                     workflow_inputs=state.inputs,
                     node_outputs=state.node_outputs,
@@ -363,7 +374,7 @@ class WorkflowRuntime:
         )
 
         try:
-            output = await run_node(
+            output = await self._execute_node(
                 node=body_node,
                 workflow_inputs=state.inputs,
                 node_outputs=merged_node_outputs,
@@ -410,6 +421,114 @@ class WorkflowRuntime:
         )
         return None
 
+    async def _execute_node(
+        self,
+        *,
+        node: Node,
+        workflow_inputs: dict[str, Any],
+        node_outputs: dict[str, dict[str, Any]],
+        resolved_inputs: dict[str, Any],
+        http_client: httpx.AsyncClient,
+    ) -> dict[str, Any]:
+        if self._should_use_llm_cache(node=node):
+            cached_output = self._load_cached_llm_output(
+                node=node,
+                workflow_inputs=workflow_inputs,
+                node_outputs=node_outputs,
+                resolved_inputs=resolved_inputs,
+            )
+            if cached_output is not None:
+                cached_output["cache_hit"] = True
+                return cached_output
+
+        output = await run_node(
+            node=node,
+            workflow_inputs=workflow_inputs,
+            node_outputs=node_outputs,
+            resolved_inputs=resolved_inputs,
+            http_client=http_client,
+        )
+
+        if not self._should_use_llm_cache(node=node):
+            return output
+
+        cached_output = deepcopy(output)
+        cached_output["cache_hit"] = False
+        self._store_cached_llm_output(
+            node=node,
+            workflow_inputs=workflow_inputs,
+            node_outputs=node_outputs,
+            resolved_inputs=resolved_inputs,
+            output=cached_output,
+        )
+        return cached_output
+
+    def _should_use_llm_cache(self, *, node: Node) -> bool:
+        return self.llm_cache_enabled and node.kind == "llm_azure_chat"
+
+    def _load_cached_llm_output(
+        self,
+        *,
+        node: Node,
+        workflow_inputs: dict[str, Any],
+        node_outputs: dict[str, dict[str, Any]],
+        resolved_inputs: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        cached = self.llm_cache_store.get(
+            self._build_llm_cache_key(
+                node=node,
+                workflow_inputs=workflow_inputs,
+                node_outputs=node_outputs,
+                resolved_inputs=resolved_inputs,
+            )
+        )
+        if cached is None:
+            return None
+        return deepcopy(cached)
+
+    def _store_cached_llm_output(
+        self,
+        *,
+        node: Node,
+        workflow_inputs: dict[str, Any],
+        node_outputs: dict[str, dict[str, Any]],
+        resolved_inputs: dict[str, Any],
+        output: dict[str, Any],
+    ) -> None:
+        self.llm_cache_store.put(
+            self._build_llm_cache_key(
+                node=node,
+                workflow_inputs=workflow_inputs,
+                node_outputs=node_outputs,
+                resolved_inputs=resolved_inputs,
+            ),
+            deepcopy(output),
+        )
+
+    def _build_llm_cache_key(
+        self,
+        *,
+        node: Node,
+        workflow_inputs: dict[str, Any],
+        node_outputs: dict[str, dict[str, Any]],
+        resolved_inputs: dict[str, Any],
+    ) -> str:
+        extra: dict[str, Any] | None = None
+        if node.kind == "llm_azure_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",
+                )
+            }
+        return build_llm_cache_key(
+            node_kind=node.kind,
+            node_config=node.config,
+            resolved_inputs=resolved_inputs,
+            extra=extra,
+        )
+
     def _build_loop_body_node_outputs(
         self,
         *,

{dify_player-0.2.0 → dify_player-0.3.1}/dify_player/workflow_engine.py

@@ -6,6 +6,7 @@ from typing import Any
 import httpx
 
 from dify_player.event_logger import NullEventLogger, WorkflowLogger
+from dify_player.llm_cache import LLMCacheStore
 from dify_player.models import CompiledPlan, Plan, RunResult
 from dify_player.plan_loader import parse_plan
 from dify_player.workflow_executor import WorkflowExecutor
@@ -23,6 +24,8 @@ class WorkflowEngine:
         run_id: str | None = None,
         logger: WorkflowLogger | None = None,
         http_client: httpx.AsyncClient | None = None,
+        llm_cache: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
     ) -> RunResult:
         effective_logger, owns_logger = _resolve_logger(run_id=run_id, logger=logger)
         try:
@@ -31,6 +34,8 @@ class WorkflowEngine:
                 inputs=inputs,
                 logger=effective_logger,
                 http_client=http_client,
+                llm_cache=llm_cache,
+                llm_cache_store=llm_cache_store,
             )
         finally:
             if owns_logger:
@@ -44,6 +49,8 @@ class WorkflowEngine:
         run_id: str | None = None,
         logger: WorkflowLogger | None = None,
         http_client: httpx.AsyncClient | None = None,
+        llm_cache: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
     ) -> RunResult:
         effective_logger, owns_logger = _resolve_logger(run_id=run_id, logger=logger)
         try:
@@ -52,6 +59,8 @@ class WorkflowEngine:
                 inputs=inputs,
                 logger=effective_logger,
                 http_client=http_client,
+                llm_cache=llm_cache,
+                llm_cache_store=llm_cache_store,
             )
         finally:
             if owns_logger:
@@ -65,6 +74,8 @@ class WorkflowEngine:
         run_id: str | None = None,
         logger: WorkflowLogger | None = None,
         http_client: httpx.AsyncClient | None = None,
+        llm_cache: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
     ) -> RunResult:
         plan = parse_plan(plan_data)
         return await self.run_plan(
@@ -73,6 +84,8 @@ class WorkflowEngine:
             run_id=run_id,
             logger=logger,
             http_client=http_client,
+            llm_cache=llm_cache,
+            llm_cache_store=llm_cache_store,
         )
 
 

{dify_player-0.2.0 → dify_player-0.3.1}/dify_player/workflow_executor.py

@@ -10,6 +10,7 @@ from pathlib import Path
 import httpx
 from dify_player.event_logger import EventLogger, WorkflowLogger
 from dify_player.exceptions import PlanValidationError
+from dify_player.llm_cache import LLMCacheStore
 from dify_player.models import CompiledPlan, Plan, RunResult, WorkflowError
 from dify_player.plan_loader import compile_plan, load_input_data, load_plan_definition
 from dify_player.runtime import WorkflowRuntime
@@ -30,8 +31,14 @@ class WorkflowExecutor:
         started_at: str | None = None,
         started_monotonic: float | None = None,
         http_client: httpx.AsyncClient | None = None,
+        llm_cache: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
     ) -> RunResult:
-        runtime = WorkflowRuntime(logger=logger)
+        runtime = WorkflowRuntime(
+            logger=logger,
+            llm_cache_enabled=llm_cache,
+            llm_cache_store=llm_cache_store,
+        )
         return await runtime.run(
             compiled_plan=compiled_plan,
             inputs=inputs,
@@ -49,6 +56,8 @@ class WorkflowExecutor:
         started_at: str | None = None,
         started_monotonic: float | None = None,
         http_client: httpx.AsyncClient | None = None,
+        llm_cache: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
     ) -> RunResult:
         try:
             compiled_plan = compile_plan(plan)
@@ -68,6 +77,8 @@ class WorkflowExecutor:
             started_at=started_at,
             started_monotonic=started_monotonic,
             http_client=http_client,
+            llm_cache=llm_cache,
+            llm_cache_store=llm_cache_store,
         )
 
     async def run_plan_path(
@@ -77,6 +88,8 @@ class WorkflowExecutor:
         input_path: Path,
         log_path: Path | None = None,
         http_client: httpx.AsyncClient | None = None,
+        llm_cache: bool = False,
+        llm_cache_store: LLMCacheStore | None = None,
     ) -> RunResult:
         run_id = uuid.uuid4().hex
         resolved_log_path = log_path if log_path is not None else build_default_log_path(run_id)
@@ -127,6 +140,8 @@ class WorkflowExecutor:
                 started_at=started_at,
                 started_monotonic=started_monotonic,
                 http_client=http_client,
+                llm_cache=llm_cache,
+                llm_cache_store=llm_cache_store,
             )
 
             if result.status == "failed":

{dify_player-0.2.0 → dify_player-0.3.1}/dify_player.egg-info/PKG-INFO

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

{dify_player-0.2.0 → dify_player-0.3.1}/dify_player.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ dify_player/dify_workflow_importer.py
 dify_player/event_logger.py
 dify_player/exceptions.py
 dify_player/input_resolver.py
+dify_player/llm_cache.py
 dify_player/models.py
 dify_player/plan_loader.py
 dify_player/runtime.py
@@ -49,5 +50,6 @@ dify_player/nodes/variable_aggregator.py
 tests/test_assigner.py
 tests/test_cli.py
 tests/test_dify_workflow_importer.py
+tests/test_llm_cache.py
 tests/test_runtime.py
 tests/test_workflow_engine.py

{dify_player-0.2.0 → dify_player-0.3.1}/pyproject.toml

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

dify_player-0.3.1/tests/test_llm_cache.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import unittest
+
+from dify_player.llm_cache import NullLLMCacheStore, build_llm_cache_key
+
+
+class LLMCacheTestCase(unittest.TestCase):
+    def test_build_llm_cache_key_is_stable_for_equivalent_dict_order(self) -> None:
+        first = build_llm_cache_key(
+            node_kind="llm_azure_chat",
+            node_config={"model": "gpt-4o", "response_format": "text"},
+            resolved_inputs={"source_text": "hello", "language": "ja"},
+        )
+        second = build_llm_cache_key(
+            node_kind="llm_azure_chat",
+            node_config={"response_format": "text", "model": "gpt-4o"},
+            resolved_inputs={"language": "ja", "source_text": "hello"},
+        )
+
+        self.assertEqual(first, second)
+
+    def test_null_llm_cache_store_is_noop(self) -> None:
+        store = NullLLMCacheStore()
+
+        self.assertIsNone(store.get("missing"))
+        store.put("key", {"text": "hello"})
+        self.assertIsNone(store.get("key"))

{dify_player-0.2.0 → dify_player-0.3.1}/tests/test_runtime.py

@@ -21,6 +21,17 @@ def _run_runtime(runtime: WorkflowRuntime, *, compiled_plan, inputs):
     return asyncio.run(runtime.run(compiled_plan=compiled_plan, inputs=inputs))
 
 
+class MemoryLLMCacheStore:
+    def __init__(self) -> None:
+        self.values: dict[str, dict] = {}
+
+    def get(self, key: str) -> dict | None:
+        return self.values.get(key)
+
+    def put(self, key: str, value: dict) -> None:
+        self.values[key] = value
+
+
 class RuntimeTestCase(unittest.TestCase):
     def test_code_node_executes_python_and_returns_declared_outputs(self) -> None:
         with tempfile.TemporaryDirectory() as tmpdir:
@@ -706,6 +717,383 @@ class RuntimeTestCase(unittest.TestCase):
                 },
             )
 
+    def test_llm_cache_reuses_identical_llm_response(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            plan_path = Path(tmpdir) / "plan.json"
+            plan_path.write_text(
+                json.dumps(
+                    {
+                        "nodes": [
+                            {"id": "start", "kind": "start"},
+                            {
+                                "id": "classify",
+                                "kind": "llm_azure_chat",
+                                "config": {
+                                    "model": "gpt-4o",
+                                    "messages": [{"role": "user", "content": "Classify {{ inputs.source_text }}"}],
+                                    "response_format": "text",
+                                },
+                            },
+                            {
+                                "id": "end",
+                                "kind": "end",
+                                "inputs": {"text": "{{ nodes.classify.text }}"},
+                                "config": {"outputs": {"text": "{{ inputs.text }}"}},
+                            },
+                        ],
+                        "edges": [
+                            {"from": "start", "to": "classify"},
+                            {"from": "classify", "to": "end"},
+                        ],
+                    }
+                ),
+                encoding="utf-8",
+            )
+            compiled_plan = load_plan(plan_path)
+            response = Mock(status_code=200)
+            response.text = json.dumps({"choices": [{"message": {"content": "SNS"}}]})
+            cache_store = MemoryLLMCacheStore()
+
+            with patch.dict(
+                os.environ,
+                {
+                    "AZURE_OPENAI_ENDPOINT": "https://example.openai.azure.com",
+                    "AZURE_OPENAI_API_KEY": "secret",
+                    "AZURE_OPENAI_API_VERSION": "2024-10-21",
+                },
+                clear=False,
+            ):
+                with patch(
+                    "dify_player.nodes.llm_azure_chat.httpx.AsyncClient.post",
+                    new_callable=AsyncMock,
+                    return_value=response,
+                ) as mock_post:
+                    for index, expected_cache_hit in enumerate((False, True), start=1):
+                        logger = EventLogger(log_path=Path(tmpdir) / f"run-{index}.jsonl", run_id=f"llm-cache-{index}")
+                        runtime = WorkflowRuntime(
+                            logger=logger,
+                            llm_cache_enabled=True,
+                            llm_cache_store=cache_store,
+                        )
+                        try:
+                            result = _run_runtime(runtime, compiled_plan=compiled_plan, inputs={"source_text": "hello"})
+                        finally:
+                            logger.close()
+
+                        self.assertEqual(result.status, "succeeded")
+                        self.assertEqual(result.outputs, {"text": "SNS"})
+                        self.assertEqual(result.nodes["classify"].outputs["cache_hit"], expected_cache_hit)
+
+            self.assertEqual(mock_post.call_count, 1)
+            self.assertEqual(len(cache_store.values), 1)
+
+    def test_llm_cache_disabled_calls_llm_every_time(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            plan_path = Path(tmpdir) / "plan.json"
+            plan_path.write_text(
+                json.dumps(
+                    {
+                        "nodes": [
+                            {"id": "start", "kind": "start"},
+                            {
+                                "id": "classify",
+                                "kind": "llm_azure_chat",
+                                "config": {
+                                    "model": "gpt-4o",
+                                    "messages": [{"role": "user", "content": "Classify {{ inputs.source_text }}"}],
+                                    "response_format": "text",
+                                },
+                            },
+                            {
+                                "id": "end",
+                                "kind": "end",
+                                "inputs": {"text": "{{ nodes.classify.text }}"},
+                                "config": {"outputs": {"text": "{{ inputs.text }}"}},
+                            },
+                        ],
+                        "edges": [
+                            {"from": "start", "to": "classify"},
+                            {"from": "classify", "to": "end"},
+                        ],
+                    }
+                ),
+                encoding="utf-8",
+            )
+            compiled_plan = load_plan(plan_path)
+            first_response = Mock(status_code=200)
+            first_response.text = json.dumps({"choices": [{"message": {"content": "First"}}]})
+            second_response = Mock(status_code=200)
+            second_response.text = json.dumps({"choices": [{"message": {"content": "Second"}}]})
+            cache_store = MemoryLLMCacheStore()
+
+            with patch.dict(
+                os.environ,
+                {
+                    "AZURE_OPENAI_ENDPOINT": "https://example.openai.azure.com",
+                    "AZURE_OPENAI_API_KEY": "secret",
+                    "AZURE_OPENAI_API_VERSION": "2024-10-21",
+                },
+                clear=False,
+            ):
+                with patch(
+                    "dify_player.nodes.llm_azure_chat.httpx.AsyncClient.post",
+                    new_callable=AsyncMock,
+                    side_effect=[first_response, second_response],
+                ) as mock_post:
+                    for index in range(2):
+                        logger = EventLogger(log_path=Path(tmpdir) / f"disabled-{index}.jsonl", run_id=f"llm-disabled-{index}")
+                        runtime = WorkflowRuntime(
+                            logger=logger,
+                            llm_cache_enabled=False,
+                            llm_cache_store=cache_store,
+                        )
+                        try:
+                            result = _run_runtime(runtime, compiled_plan=compiled_plan, inputs={"source_text": "hello"})
+                        finally:
+                            logger.close()
+
+                        self.assertEqual(result.status, "succeeded")
+                        self.assertNotIn("cache_hit", result.nodes["classify"].outputs)
+
+            self.assertEqual(mock_post.call_count, 2)
+            self.assertEqual(cache_store.values, {})
+
+    def test_llm_cache_misses_when_resolved_inputs_change(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            plan_path = Path(tmpdir) / "plan.json"
+            plan_path.write_text(
+                json.dumps(
+                    {
+                        "nodes": [
+                            {"id": "start", "kind": "start"},
+                            {
+                                "id": "classify",
+                                "kind": "llm_azure_chat",
+                                "config": {
+                                    "model": "gpt-4o",
+                                    "messages": [{"role": "user", "content": "Classify {{ inputs.source_text }}"}],
+                                    "response_format": "text",
+                                },
+                            },
+                            {
+                                "id": "end",
+                                "kind": "end",
+                                "inputs": {"text": "{{ nodes.classify.text }}"},
+                                "config": {"outputs": {"text": "{{ inputs.text }}"}},
+                            },
+                        ],
+                        "edges": [
+                            {"from": "start", "to": "classify"},
+                            {"from": "classify", "to": "end"},
+                        ],
+                    }
+                ),
+                encoding="utf-8",
+            )
+            compiled_plan = load_plan(plan_path)
+            first_response = Mock(status_code=200)
+            first_response.text = json.dumps({"choices": [{"message": {"content": "SNS"}}]})
+            second_response = Mock(status_code=200)
+            second_response.text = json.dumps({"choices": [{"message": {"content": "Email"}}]})
+            cache_store = MemoryLLMCacheStore()
+
+            with patch.dict(
+                os.environ,
+                {
+                    "AZURE_OPENAI_ENDPOINT": "https://example.openai.azure.com",
+                    "AZURE_OPENAI_API_KEY": "secret",
+                    "AZURE_OPENAI_API_VERSION": "2024-10-21",
+                },
+                clear=False,
+            ):
+                with patch(
+                    "dify_player.nodes.llm_azure_chat.httpx.AsyncClient.post",
+                    new_callable=AsyncMock,
+                    side_effect=[first_response, second_response],
+                ) as mock_post:
+                    seen_texts: list[str] = []
+                    for index, source_text in enumerate(("hello", "bye"), start=1):
+                        logger = EventLogger(log_path=Path(tmpdir) / f"vary-{index}.jsonl", run_id=f"llm-vary-{index}")
+                        runtime = WorkflowRuntime(
+                            logger=logger,
+                            llm_cache_enabled=True,
+                            llm_cache_store=cache_store,
+                        )
+                        try:
+                            result = _run_runtime(runtime, compiled_plan=compiled_plan, inputs={"source_text": source_text})
+                        finally:
+                            logger.close()
+
+                        seen_texts.append(result.outputs["text"])
+                        self.assertFalse(result.nodes["classify"].outputs["cache_hit"])
+
+            self.assertEqual(seen_texts, ["SNS", "Email"])
+            self.assertEqual(mock_post.call_count, 2)
+            self.assertEqual(len(cache_store.values), 2)
+
+    def test_llm_cache_reuses_structured_output_repair_result(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            plan_path = Path(tmpdir) / "plan.json"
+            plan_path.write_text(
+                json.dumps(
+                    {
+                        "nodes": [
+                            {"id": "start", "kind": "start"},
+                            {
+                                "id": "detect",
+                                "kind": "llm_azure_chat",
+                                "config": {
+                                    "model": "gpt-4o",
+                                    "messages": [{"role": "user", "content": "Detect"}],
+                                    "response_format": "json_schema",
+                                    "json_schema": {
+                                        "type": "object",
+                                        "properties": {"language": {"type": "string"}},
+                                        "required": ["language"],
+                                        "additionalProperties": False,
+                                    },
+                                },
+                            },
+                            {
+                                "id": "end",
+                                "kind": "end",
+                                "inputs": {"language": "{{ nodes.detect.structured_output.language }}"},
+                                "config": {"outputs": {"language": "{{ inputs.language }}"}},
+                            },
+                        ],
+                        "edges": [
+                            {"from": "start", "to": "detect"},
+                            {"from": "detect", "to": "end"},
+                        ],
+                    }
+                ),
+                encoding="utf-8",
+            )
+            compiled_plan = load_plan(plan_path)
+            first_response = Mock(status_code=200)
+            first_response.text = json.dumps({"choices": [{"message": {"content": "{}"}}]})
+            second_response = Mock(status_code=200)
+            second_response.text = json.dumps({"choices": [{"message": {"content": '{"language":"Japanese"}'}}]})
+            cache_store = MemoryLLMCacheStore()
+
+            with patch.dict(
+                os.environ,
+                {
+                    "AZURE_OPENAI_ENDPOINT": "https://example.openai.azure.com",
+                    "AZURE_OPENAI_API_KEY": "secret",
+                    "AZURE_OPENAI_API_VERSION": "2024-10-21",
+                },
+                clear=False,
+            ):
+                with patch(
+                    "dify_player.nodes.llm_azure_chat.httpx.AsyncClient.post",
+                    new_callable=AsyncMock,
+                    side_effect=[first_response, second_response],
+                ) as mock_post:
+                    for index, expected_cache_hit in enumerate((False, True), start=1):
+                        logger = EventLogger(log_path=Path(tmpdir) / f"repair-{index}.jsonl", run_id=f"llm-repair-cache-{index}")
+                        runtime = WorkflowRuntime(
+                            logger=logger,
+                            llm_cache_enabled=True,
+                            llm_cache_store=cache_store,
+                        )
+                        try:
+                            result = _run_runtime(runtime, compiled_plan=compiled_plan, inputs={})
+                        finally:
+                            logger.close()
+
+                        self.assertEqual(result.status, "succeeded")
+                        self.assertEqual(result.outputs, {"language": "Japanese"})
+                        self.assertEqual(result.nodes["detect"].outputs["attempt_count"], 2)
+                        self.assertEqual(result.nodes["detect"].outputs["cache_hit"], expected_cache_hit)
+
+            self.assertEqual(mock_post.call_count, 2)
+            self.assertEqual(len(cache_store.values), 1)
+
+    def test_llm_cache_does_not_store_failed_run(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            plan_path = Path(tmpdir) / "plan.json"
+            plan_path.write_text(
+                json.dumps(
+                    {
+                        "nodes": [
+                            {"id": "start", "kind": "start"},
+                            {
+                                "id": "classify",
+                                "kind": "llm_azure_chat",
+                                "config": {
+                                    "model": "gpt-4o",
+                                    "messages": [{"role": "user", "content": "Classify"}],
+                                    "response_format": "text",
+                                },
+                            },
+                            {
+                                "id": "end",
+                                "kind": "end",
+                                "inputs": {"text": "{{ nodes.classify.text }}"},
+                                "config": {"outputs": {"text": "{{ inputs.text }}"}},
+                            },
+                        ],
+                        "edges": [
+                            {"from": "start", "to": "classify"},
+                            {"from": "classify", "to": "end"},
+                        ],
+                    }
+                ),
+                encoding="utf-8",
+            )
+            compiled_plan = load_plan(plan_path)
+            bad_response = Mock(status_code=500)
+            bad_response.text = json.dumps({"error": {"message": "server error"}})
+            good_response = Mock(status_code=200)
+            good_response.text = json.dumps({"choices": [{"message": {"content": "SNS"}}]})
+            cache_store = MemoryLLMCacheStore()
+
+            with patch.dict(
+                os.environ,
+                {
+                    "AZURE_OPENAI_ENDPOINT": "https://example.openai.azure.com",
+                    "AZURE_OPENAI_API_KEY": "secret",
+                    "AZURE_OPENAI_API_VERSION": "2024-10-21",
+                },
+                clear=False,
+            ):
+                with patch(
+                    "dify_player.nodes.llm_azure_chat.httpx.AsyncClient.post",
+                    new_callable=AsyncMock,
+                    side_effect=[bad_response, good_response],
+                ) as mock_post:
+                    logger = EventLogger(log_path=Path(tmpdir) / "failed-run.jsonl", run_id="llm-cache-failed")
+                    failed_runtime = WorkflowRuntime(
+                        logger=logger,
+                        llm_cache_enabled=True,
+                        llm_cache_store=cache_store,
+                    )
+                    try:
+                        failed_result = _run_runtime(failed_runtime, compiled_plan=compiled_plan, inputs={})
+                    finally:
+                        logger.close()
+
+                    self.assertEqual(failed_result.status, "failed")
+                    self.assertEqual(cache_store.values, {})
+
+                    logger = EventLogger(log_path=Path(tmpdir) / "success-run.jsonl", run_id="llm-cache-success")
+                    success_runtime = WorkflowRuntime(
+                        logger=logger,
+                        llm_cache_enabled=True,
+                        llm_cache_store=cache_store,
+                    )
+                    try:
+                        success_result = _run_runtime(success_runtime, compiled_plan=compiled_plan, inputs={})
+                    finally:
+                        logger.close()
+
+                    self.assertEqual(success_result.status, "succeeded")
+                    self.assertFalse(success_result.nodes["classify"].outputs["cache_hit"])
+
+            self.assertEqual(mock_post.call_count, 2)
+            self.assertEqual(len(cache_store.values), 1)
+
     def test_llm_azure_chat_includes_http_error_details(self) -> None:
         with tempfile.TemporaryDirectory() as tmpdir:
             plan_path = Path(tmpdir) / "plan.json"

{dify_player-0.2.0 → dify_player-0.3.1}/tests/test_workflow_engine.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 import json
 import unittest
 from pathlib import Path
+from unittest.mock import AsyncMock
 
 import httpx
 
 from dify_player import WorkflowEngine
+from dify_player.llm_cache import NullLLMCacheStore
 from dify_player.models import to_data
 from tests.workflow_http_server import HTTPServerContext
 
@@ -43,3 +45,21 @@ class WorkflowEngineTestCase(unittest.IsolatedAsyncioTestCase):
                 self.assertFalse(http_client.is_closed)
                 self.assertEqual(requests_log[0]["method"], "POST")
                 self.assertEqual(requests_log[0]["query"], {"q": ["hello"]})
+
+    async def test_run_plan_data_passes_llm_cache_options_to_executor(self) -> None:
+        engine = WorkflowEngine()
+        cache_store = NullLLMCacheStore()
+        plan_data = json.loads((ROOT / "examples" / "hello" / "plan.json").read_text(encoding="utf-8"))
+        expected_result = object()
+        engine._executor.run_plan = AsyncMock(return_value=expected_result)
+
+        result = await engine.run_plan_data(
+            plan_data=plan_data,
+            inputs={"name": "World"},
+            llm_cache=True,
+            llm_cache_store=cache_store,
+        )
+
+        self.assertIs(result, expected_result)
+        self.assertTrue(engine._executor.run_plan.await_args.kwargs["llm_cache"])
+        self.assertIs(engine._executor.run_plan.await_args.kwargs["llm_cache_store"], cache_store)

dify_player-0.2.0/dify_player/__init__.py

@@ -1,7 +0,0 @@
-"""Minimal workflow runner package."""
-
-from dify_player.workflow_engine import WorkflowEngine
-
-__all__ = ["__version__", "WorkflowEngine"]
-
-__version__ = "0.2.0"