python-durable 0.2.0__tar.gz → 0.2.2__tar.gz

{python_durable-0.2.0 → python_durable-0.2.2}/.github/workflows/publish.yml

@@ -4,6 +4,9 @@ on:
   release:
     types: [published]
 
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
 jobs:
   publish:
     runs-on: ubuntu-latest

{python_durable-0.2.0 → python_durable-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-durable
-Version: 0.2.0
+Version: 0.2.2
 Summary: Lightweight workflow durability for Python — make any async workflow resumable after crashes with just a decorator.
 Project-URL: Repository, https://github.com/WillemDeGroef/python-durable
 Author: Willem

{python_durable-0.2.0 → python_durable-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-durable"
-version = "0.2.0"
+version = "0.2.2"
 description = "Lightweight workflow durability for Python — make any async workflow resumable after crashes with just a decorator."
 readme = "README.md"
 license = "MIT"

{python_durable-0.2.0 → python_durable-0.2.2}/src/durable/pydantic_ai.py

@@ -69,6 +69,20 @@ def _deserialize_messages(data: list[dict]) -> list[Any]:
     return result
 
 
+def _serialize_run_result(result: Any) -> dict:
+    """Convert an agent RunResult to a JSON-serializable dict."""
+    output = result.output
+    # If output is a pydantic model, convert to dict
+    if hasattr(output, "model_dump"):
+        output = output.model_dump(mode="json")
+    data: dict[str, Any] = {"output": output}
+    try:
+        data["all_messages"] = _serialize_messages(result.all_messages())
+    except Exception:
+        data["all_messages"] = []
+    return data
+
+
 def _run_id_for_agent(agent_name: str, prompt: str, run_id: str | None) -> str:
     """Generate a deterministic run ID from the agent name and prompt."""
     if run_id:
@@ -207,7 +221,8 @@ class DurableAgent(Generic[AgentDepsT, OutputT]):
             step_id="agent-run",
             **kwargs,
         )
-        return result
+        output_type = getattr(self.agent, "_output_type", None)
+        return _AgentRunResult(result, output_type=output_type)
 
     async def _do_model_request(
         self,
@@ -225,7 +240,7 @@ class DurableAgent(Generic[AgentDepsT, OutputT]):
         run_kwargs.update(kwargs)
 
         result = await self.agent.run(prompt, **run_kwargs)
-        return _AgentRunResult(result)
+        return _serialize_run_result(result)
 
     async def _do_tool_call(
         self,
@@ -268,15 +283,19 @@ class _AgentRunResult:
     """Wrapper that holds an agent RunResult and handles both live and
     deserialized (dict) results transparently."""
 
-    def __init__(self, result: Any) -> None:
+    def __init__(self, result: Any, output_type: type | None = None) -> None:
         self._result = result
+        self._output_type = output_type
 
     @property
     def output(self) -> Any:
         if hasattr(self._result, "output"):
             return self._result.output
         if isinstance(self._result, dict):
-            return self._result.get("output")
+            raw = self._result.get("output")
+            if isinstance(raw, dict) and self._output_type and hasattr(self._output_type, "model_validate"):
+                return self._output_type.model_validate(raw)
+            return raw
         return self._result
 
     @property

{python_durable-0.2.0 → python_durable-0.2.2}/tests/test_pydantic_ai.py

@@ -326,3 +326,89 @@ class TestIntegration:
         r2 = await durable.run("What is 6*7?", run_id="calc-1")
         assert r2.output == "42"
         assert agent.run.call_count == 1
+
+    async def test_durable_agent_with_sqlite_store(self, tmp_path):
+        """Ensure agent results are JSON-serializable for SQLiteStore."""
+        db_path = str(tmp_path / "test.db")
+        wf = Workflow("test-sqlite", db=db_path)
+
+        agent, _ = _mock_agent(output="serialized ok")
+        durable = DurableAgent(agent, wf, name="sqlite-agent")
+
+        r1 = await durable.run("Test prompt", run_id="sqlite-1")
+        assert r1.output == "serialized ok"
+        assert agent.run.call_count == 1
+
+        r2 = await durable.run("Test prompt", run_id="sqlite-1")
+        assert r2.output == "serialized ok"
+        assert agent.run.call_count == 1
+
+    async def test_pydantic_model_output_preserved_on_replay(self, wf):
+        """Pydantic model output should be re-hydrated on replay, not returned as dict."""
+        from pydantic import BaseModel
+
+        class CityInfo(BaseModel):
+            name: str
+            population: int
+
+        city = CityInfo(name="Paris", population=2_161_000)
+
+        agent, run_result = _mock_agent()
+        run_result.output = city
+        agent._output_type = CityInfo
+
+        durable = DurableAgent(agent, wf, name="city-agent")
+
+        r1 = await durable.run("Tell me about Paris", run_id="pydantic-1")
+        assert isinstance(r1.output, CityInfo)
+        assert r1.output.name == "Paris"
+        assert agent.run.call_count == 1
+
+        # Replay — should still return a CityInfo, not a dict
+        r2 = await durable.run("Tell me about Paris", run_id="pydantic-1")
+        assert isinstance(r2.output, CityInfo)
+        assert r2.output.name == "Paris"
+        assert r2.output.population == 2_161_000
+        assert agent.run.call_count == 1
+
+    async def test_plain_string_output_no_regression(self, wf):
+        """Plain string outputs should still work after the output_type change."""
+        agent, _ = _mock_agent(output="just a string")
+        agent._output_type = None
+
+        durable = DurableAgent(agent, wf, name="string-agent")
+
+        r1 = await durable.run("Say hello", run_id="string-1")
+        assert r1.output == "just a string"
+
+        r2 = await durable.run("Say hello", run_id="string-1")
+        assert r2.output == "just a string"
+
+
+class TestAgentRunResultRehydration:
+    def test_rehydrate_dict_with_output_type(self):
+        from pydantic import BaseModel
+
+        class Item(BaseModel):
+            id: int
+            label: str
+
+        wrapper = _AgentRunResult({"output": {"id": 1, "label": "test"}}, output_type=Item)
+        result = wrapper.output
+        assert isinstance(result, Item)
+        assert result.id == 1
+        assert result.label == "test"
+
+    def test_no_rehydrate_without_output_type(self):
+        wrapper = _AgentRunResult({"output": {"id": 1, "label": "test"}})
+        result = wrapper.output
+        assert isinstance(result, dict)
+
+    def test_no_rehydrate_non_dict_output(self):
+        from pydantic import BaseModel
+
+        class Item(BaseModel):
+            id: int
+
+        wrapper = _AgentRunResult({"output": "plain string"}, output_type=Item)
+        assert wrapper.output == "plain string"