stroma 0.3.0__tar.gz → 0.3.2__tar.gz

{stroma-0.3.0/src/stroma.egg-info → stroma-0.3.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: stroma
-Version: 0.3.0
-Summary: Reliability primitives for agent pipelines.
+Version: 0.3.2
+Summary: The framework handles the graph. Stroma handles the guarantees.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/jengroff/stroma
 Project-URL: Repository, https://github.com/jengroff/stroma
@@ -18,11 +18,14 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: crewai>=1.13.0
 Requires-Dist: pydantic>=2.0
 Provides-Extra: redis
 Requires-Dist: redis>=5.0; extra == "redis"
 Provides-Extra: langgraph
 Requires-Dist: langgraph>=0.2; extra == "langgraph"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.70; extra == "crewai"
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.4.0; extra == "deepagents"
 Requires-Dist: langgraph>=0.2; extra == "deepagents"
@@ -42,44 +45,103 @@ Dynamic: license-file
 
 **dbt didn't replace your data warehouse. Stroma doesn't replace your agent framework.**
 
-Typed node contracts, formal failure classification, and cost-aware execution — portable across whatever orchestration framework you're building on. The framework handles the graph. Stroma handles the guarantees.
+dbt gave you typed models, tested transformations, and documented lineage — a software engineering layer that worked regardless of which warehouse you were running. Stroma does the same thing for agent execution graphs: typed node contracts, formal failure classification, and cost-aware execution — portable across whatever orchestration framework you're building on.
+
+The framework handles the graph. Stroma handles the guarantees.
+
+## The problem it solves
+
+LLM pipelines fail in ways that traditional software doesn't. A node returns malformed data and the error surfaces three steps later. A transient timeout kills a 20-minute run and you start over from scratch. Costs spiral past budget with no enforcement mechanism. Failures are silent until they're catastrophic.
+
+Stroma gives you the building blocks to handle this — without locking you into a framework.
+
+## See it in action
+
+The scenario below is the kind that breaks raw LangGraph pipelines: a multi-step run that crashes midway, resumes from checkpoint, and gives you a diff of what changed between the failed and successful run.
 
 ```python
+import asyncio
 from pydantic import BaseModel
-from stroma import StromaRunner
+from stroma import (
+    AsyncInMemoryStore,
+    CheckpointManager,
+    ContractRegistry,
+    NodeContract,
+    RunConfig,
+    StromaRunner,
+    stroma_node,
+)
 
-class Input(BaseModel):
-    value: int
 
-class Output(BaseModel):
-    result: int
+class Document(BaseModel):
+    text: str
 
-runner = StromaRunner.quick()
 
-@runner.node("double", input=Input, output=Output)
-async def double(state: Input) -> dict:
-    return {"result": state.value * 2}
+class Extracted(BaseModel):
+    entities: list[str]
 
-result = await runner.run([double], Input(value=5))
-print(result.final_state)  # result=10
-```
 
-## Install
+class Summary(BaseModel):
+    entities: list[str]
+    count: int
 
-Requires **Python 3.12+**.
 
-```bash
-uv add stroma
-```
+registry = ContractRegistry()
+store = AsyncInMemoryStore()
+manager = CheckpointManager(store)
 
-Optional extras:
+c1 = NodeContract(node_id="extract", input_schema=Document, output_schema=Extracted)
+c2 = NodeContract(node_id="summarize", input_schema=Extracted, output_schema=Summary)
+registry.register(c1)
+registry.register(c2)
 
-```bash
-uv add stroma[redis]       # Redis-backed checkpointing
-uv add stroma[langgraph]   # LangGraph adapter
-uv add stroma[deepagents]  # DeepAgents adapter
+
+@stroma_node("extract", c1)
+async def extract(state: Document) -> dict:
+    return {"entities": state.text.split()}
+
+
+@stroma_node("summarize", c2)
+async def summarize_failing(state: Extracted) -> dict:
+    raise TimeoutError("downstream API unavailable")  # (1)!
+
+
+@stroma_node("summarize", c2)
+async def summarize_fixed(state: Extracted) -> dict:
+    return {"entities": state.entities, "count": len(state.entities)}
+
+
+async def main():
+    config1 = RunConfig(run_id="doc-run-1")
+    runner1 = StromaRunner(registry, manager, config1)
+    result1 = await runner1.run(
+        [extract, summarize_failing],
+        Document(text="Stroma adds reliability to agent pipelines"),
+    )
+    print(result1.status)  # PARTIAL — extract checkpointed, summarize exhausted retries
+
+    config2 = RunConfig(run_id="doc-run-1", resume_from="summarize")  # (2)!
+    runner2 = StromaRunner(registry, manager, config2)
+    result2 = await runner2.run(
+        [extract, summarize_fixed],
+        Document(text="Stroma adds reliability to agent pipelines"),
+    )
+    print(result2.status)       # RESUMED — extract skipped, loaded from checkpoint
+    print(result2.final_state)  # entities=[...] count=6
+
+    diffs = result1.trace.diff(result2.trace)  # (3)!
+    for d in diffs:
+        print(d)
+
+
+asyncio.run(main())
+# In a Jupyter notebook, replace the line above with: await main()
 ```
 
+1. `TimeoutError` is classified as `RECOVERABLE`. Stroma retries with jittered backoff. After exhausting retries, the run fails — but `extract`'s output is already checkpointed.
+2. Same `run_id`, `resume_from="summarize"`. The runner loads `extract`'s checkpoint and skips re-running it entirely.
+3. `diff()` compares both traces — node IDs, attempts, inputs, outputs, failure states — so you can see exactly what changed between the failed run and the successful one.
+
 ## What You Get
 
 - **Contracts** — Pydantic-based input/output validation at every node boundary
@@ -95,9 +157,28 @@ uv add stroma[deepagents]  # DeepAgents adapter
 - **Per-run logging** — structured `LoggerAdapter` with `run_id` in every log line
 - **Fluent builder API** — configure runners with chained `.with_budget()`, `.with_hooks()`, `.with_redis()`, etc.
 - **LangGraph adapter** — apply contracts to existing LangGraph graphs
+- **CrewAI adapter** — contract validation for CrewAI Flow methods
 - **DeepAgents adapter** — contract validation and cost tracking for deepagents graphs
+- **Universal reliability middleware** — `execute_step()` and `StromaStep` apply contracts, retries, cost tracking, and checkpointing to any async callable, independent of any framework
 - **Framework-agnostic** — works with any async Python code, no framework lock-in
 
+## Install
+
+Requires **Python 3.12+**.
+
+```bash
+uv add stroma
+```
+
+Optional extras:
+
+```bash
+uv add stroma[redis]       # Redis-backed checkpointing
+uv add stroma[langgraph]   # LangGraph adapter
+uv add stroma[crewai]      # CrewAI adapter
+uv add stroma[deepagents]  # DeepAgents adapter
+```
+
 ## Quick Examples
 
 ### Cost estimation

{stroma-0.3.0 → stroma-0.3.2}/README.md

@@ -2,44 +2,103 @@
 
 **dbt didn't replace your data warehouse. Stroma doesn't replace your agent framework.**
 
-Typed node contracts, formal failure classification, and cost-aware execution — portable across whatever orchestration framework you're building on. The framework handles the graph. Stroma handles the guarantees.
+dbt gave you typed models, tested transformations, and documented lineage — a software engineering layer that worked regardless of which warehouse you were running. Stroma does the same thing for agent execution graphs: typed node contracts, formal failure classification, and cost-aware execution — portable across whatever orchestration framework you're building on.
+
+The framework handles the graph. Stroma handles the guarantees.
+
+## The problem it solves
+
+LLM pipelines fail in ways that traditional software doesn't. A node returns malformed data and the error surfaces three steps later. A transient timeout kills a 20-minute run and you start over from scratch. Costs spiral past budget with no enforcement mechanism. Failures are silent until they're catastrophic.
+
+Stroma gives you the building blocks to handle this — without locking you into a framework.
+
+## See it in action
+
+The scenario below is the kind that breaks raw LangGraph pipelines: a multi-step run that crashes midway, resumes from checkpoint, and gives you a diff of what changed between the failed and successful run.
 
 ```python
+import asyncio
 from pydantic import BaseModel
-from stroma import StromaRunner
+from stroma import (
+    AsyncInMemoryStore,
+    CheckpointManager,
+    ContractRegistry,
+    NodeContract,
+    RunConfig,
+    StromaRunner,
+    stroma_node,
+)
 
-class Input(BaseModel):
-    value: int
 
-class Output(BaseModel):
-    result: int
+class Document(BaseModel):
+    text: str
 
-runner = StromaRunner.quick()
 
-@runner.node("double", input=Input, output=Output)
-async def double(state: Input) -> dict:
-    return {"result": state.value * 2}
+class Extracted(BaseModel):
+    entities: list[str]
 
-result = await runner.run([double], Input(value=5))
-print(result.final_state)  # result=10
-```
 
-## Install
+class Summary(BaseModel):
+    entities: list[str]
+    count: int
 
-Requires **Python 3.12+**.
 
-```bash
-uv add stroma
-```
+registry = ContractRegistry()
+store = AsyncInMemoryStore()
+manager = CheckpointManager(store)
 
-Optional extras:
+c1 = NodeContract(node_id="extract", input_schema=Document, output_schema=Extracted)
+c2 = NodeContract(node_id="summarize", input_schema=Extracted, output_schema=Summary)
+registry.register(c1)
+registry.register(c2)
 
-```bash
-uv add stroma[redis]       # Redis-backed checkpointing
-uv add stroma[langgraph]   # LangGraph adapter
-uv add stroma[deepagents]  # DeepAgents adapter
+
+@stroma_node("extract", c1)
+async def extract(state: Document) -> dict:
+    return {"entities": state.text.split()}
+
+
+@stroma_node("summarize", c2)
+async def summarize_failing(state: Extracted) -> dict:
+    raise TimeoutError("downstream API unavailable")  # (1)!
+
+
+@stroma_node("summarize", c2)
+async def summarize_fixed(state: Extracted) -> dict:
+    return {"entities": state.entities, "count": len(state.entities)}
+
+
+async def main():
+    config1 = RunConfig(run_id="doc-run-1")
+    runner1 = StromaRunner(registry, manager, config1)
+    result1 = await runner1.run(
+        [extract, summarize_failing],
+        Document(text="Stroma adds reliability to agent pipelines"),
+    )
+    print(result1.status)  # PARTIAL — extract checkpointed, summarize exhausted retries
+
+    config2 = RunConfig(run_id="doc-run-1", resume_from="summarize")  # (2)!
+    runner2 = StromaRunner(registry, manager, config2)
+    result2 = await runner2.run(
+        [extract, summarize_fixed],
+        Document(text="Stroma adds reliability to agent pipelines"),
+    )
+    print(result2.status)       # RESUMED — extract skipped, loaded from checkpoint
+    print(result2.final_state)  # entities=[...] count=6
+
+    diffs = result1.trace.diff(result2.trace)  # (3)!
+    for d in diffs:
+        print(d)
+
+
+asyncio.run(main())
+# In a Jupyter notebook, replace the line above with: await main()
 ```
 
+1. `TimeoutError` is classified as `RECOVERABLE`. Stroma retries with jittered backoff. After exhausting retries, the run fails — but `extract`'s output is already checkpointed.
+2. Same `run_id`, `resume_from="summarize"`. The runner loads `extract`'s checkpoint and skips re-running it entirely.
+3. `diff()` compares both traces — node IDs, attempts, inputs, outputs, failure states — so you can see exactly what changed between the failed run and the successful one.
+
 ## What You Get
 
 - **Contracts** — Pydantic-based input/output validation at every node boundary
@@ -55,9 +114,28 @@ uv add stroma[deepagents]  # DeepAgents adapter
 - **Per-run logging** — structured `LoggerAdapter` with `run_id` in every log line
 - **Fluent builder API** — configure runners with chained `.with_budget()`, `.with_hooks()`, `.with_redis()`, etc.
 - **LangGraph adapter** — apply contracts to existing LangGraph graphs
+- **CrewAI adapter** — contract validation for CrewAI Flow methods
 - **DeepAgents adapter** — contract validation and cost tracking for deepagents graphs
+- **Universal reliability middleware** — `execute_step()` and `StromaStep` apply contracts, retries, cost tracking, and checkpointing to any async callable, independent of any framework
 - **Framework-agnostic** — works with any async Python code, no framework lock-in
 
+## Install
+
+Requires **Python 3.12+**.
+
+```bash
+uv add stroma
+```
+
+Optional extras:
+
+```bash
+uv add stroma[redis]       # Redis-backed checkpointing
+uv add stroma[langgraph]   # LangGraph adapter
+uv add stroma[crewai]      # CrewAI adapter
+uv add stroma[deepagents]  # DeepAgents adapter
+```
+
 ## Quick Examples
 
 ### Cost estimation

{stroma-0.3.0 → stroma-0.3.2}/pyproject.toml

@@ -4,11 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stroma"
-version = "0.3.0"
-description = "Reliability primitives for agent pipelines."
+version = "0.3.2"
+description = "The framework handles the graph. Stroma handles the guarantees."
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "crewai>=1.13.0",
     "pydantic>=2.0",
 ]
 license = "MIT"
@@ -33,6 +34,7 @@ Issues = "https://github.com/jengroff/stroma/issues"
 [project.optional-dependencies]
 redis = ["redis>=5.0"]
 langgraph = ["langgraph>=0.2"]
+crewai = ["crewai>=0.70"]
 deepagents = ["deepagents>=0.4.0", "langgraph>=0.2"]
 dev = ["pytest", "pytest-asyncio>=0.23", "pytest-cov", "ruff", "ty"]
 docs = ["mkdocs>=1.6.1", "mkdocs-material", "mkdocstrings[python]"]

{stroma-0.3.0 → stroma-0.3.2}/src/stroma/__init__.py

@@ -7,15 +7,25 @@ from stroma.checkpoint import (
     RedisStore,
     SyncRedisStore,
 )
-from stroma.contracts import BoundaryValidator, ContractRegistry, ContractViolation, NodeContract
+from stroma.contracts import (
+    BoundaryValidator,
+    ContractRegistry,
+    ContractViolation,
+    NodeContract,
+    StepContract,
+    StepViolation,
+)
 from stroma.cost import (
     KNOWN_MODELS,
     BudgetExceeded,
     CostTracker,
     ExecutionBudget,
+    FallbackPolicy,
     ModelHint,
     NodeUsage,
+    StepUsage,
     estimate_cost_usd,
+    resolve_model,
 )
 from stroma.failures import (
     Classifier,
@@ -23,13 +33,15 @@ from stroma.failures import (
     FailurePolicy,
     NodeContext,
     RetryBudget,
+    StepContext,
     classify,
     default_policy_map,
 )
-from stroma.runner import NodeHooks, RunConfig, StromaRunner, parallel, stroma_node
+from stroma.middleware import ReliabilityContext, StromaStep, execute_step
+from stroma.runner import NodeHooks, RunConfig, StepHooks, StromaRunner, parallel, stroma_node, stroma_step
 from stroma.trace import ExecutionResult, ExecutionTrace, RunStatus, TraceEvent
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 __all__ = [
     "KNOWN_MODELS",
@@ -48,6 +60,7 @@ __all__ = [
     "ExecutionTrace",
     "FailureClass",
     "FailurePolicy",
+    "FallbackPolicy",
     "InMemoryStore",
     "ModelHint",
     "NodeContext",
@@ -55,15 +68,25 @@ __all__ = [
     "NodeHooks",
     "NodeUsage",
     "RedisStore",
+    "ReliabilityContext",
     "RetryBudget",
     "RunConfig",
     "RunStatus",
+    "StepContext",
+    "StepContract",
+    "StepHooks",
+    "StepUsage",
+    "StepViolation",
     "StromaRunner",
+    "StromaStep",
     "SyncRedisStore",
     "TraceEvent",
     "classify",
     "default_policy_map",
     "estimate_cost_usd",
+    "execute_step",
     "parallel",
+    "resolve_model",
     "stroma_node",
+    "stroma_step",
 ]

{stroma-0.3.0 → stroma-0.3.2}/src/stroma/adapters/__init__.py

@@ -7,3 +7,7 @@ with contextlib.suppress(ImportError):
 with contextlib.suppress(ImportError):
     from stroma.adapters.deepagents import DeepAgentsAdapter as DeepAgentsAdapter
     from stroma.adapters.deepagents import stroma_deepagents_node as stroma_deepagents_node
+
+with contextlib.suppress(ImportError):
+    from stroma.adapters.crewai import CrewAIAdapter as CrewAIAdapter
+    from stroma.adapters.crewai import stroma_crewai_step as stroma_crewai_step

stroma-0.3.2/src/stroma/adapters/base.py

@@ -0,0 +1,100 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+from pydantic import BaseModel
+
+from stroma.contracts import NodeContract
+
+if TYPE_CHECKING:
+    from stroma.middleware import ReliabilityContext
+
+
+@runtime_checkable
+class FrameworkAdapter(Protocol):
+    """Protocol for graph-based framework adapters (LangGraph, CrewAI Flows).
+
+    Implementations provide two capabilities: wrapping an entire framework
+    graph with contract validation, and producing a decorator that attaches
+    stroma metadata to individual node functions.
+    """
+
+    def wrap(self, graph: Any) -> Any:
+        """Attach contract validation to a framework graph or flow instance."""
+        ...
+
+    def node_decorator(self, node_id: str, contract: NodeContract) -> Callable[..., Any]:
+        """Return a decorator that attaches stroma metadata to a framework node function."""
+        ...
+
+
+@runtime_checkable
+class StepInterceptor(Protocol):
+    """Protocol for adapters that wrap individual step functions with reliability middleware.
+
+    Unlike `FrameworkAdapter` (which discovers and wraps nodes on a graph
+    object), a `StepInterceptor` wraps one function at a time. This is the
+    right shape for paradigms where there is no single graph object to wrap
+    — e.g. composing steps in a notebook, a custom orchestrator, or a
+    framework that doesn't expose an inspectable graph.
+    """
+
+    def wrap_step(
+        self, step_id: str, func: Callable[..., Any], contract: NodeContract | None = None
+    ) -> Callable[..., Any]:
+        """Wrap *func* with reliability instrumentation for the given *step_id*."""
+        ...
+
+
+@runtime_checkable
+class LoopAdapter(Protocol):
+    """Protocol for agentic-loop paradigms (Claude Agent SDK, OpenAI Agents SDK).
+
+    In an agentic loop the model decides what to do next via tool calls.
+    The adapter intercepts tool call boundaries to apply contract validation,
+    cost tracking, and failure handling.
+    """
+
+    def on_tool_call(self, tool_name: str, args: dict[str, Any], ctx: "ReliabilityContext") -> dict[str, Any]:
+        """Intercept an outbound tool call before execution."""
+        ...
+
+    def on_tool_result(self, tool_name: str, result: Any, ctx: "ReliabilityContext") -> Any:
+        """Intercept a tool result after execution."""
+        ...
+
+
+@runtime_checkable
+class TurnAdapter(Protocol):
+    """Protocol for conversation-driven paradigms (AutoGen).
+
+    In a conversation-driven system, agents exchange messages in turns.
+    The adapter intercepts turn boundaries to apply reliability primitives.
+    """
+
+    def on_turn_start(self, turn_id: str, message: Any, ctx: "ReliabilityContext") -> Any:
+        """Intercept the start of a conversation turn."""
+        ...
+
+    def on_turn_end(self, turn_id: str, result: Any, ctx: "ReliabilityContext") -> Any:
+        """Intercept the end of a conversation turn."""
+        ...
+
+
+def extract_state_dict(state: Any) -> dict[str, Any]:
+    """Convert a framework state object to a plain dict.
+
+    Supports dicts, Pydantic models, objects with a `.dict()` method,
+    and plain objects with `__dict__`. Raises `TypeError` if the state
+    cannot be converted.
+    """
+    if isinstance(state, dict):
+        return dict(state)
+    if isinstance(state, BaseModel):
+        return state.model_dump()
+    if hasattr(state, "dict"):
+        result = state.dict()
+        if isinstance(result, dict):
+            return result
+    if hasattr(state, "__dict__"):
+        return {k: v for k, v in vars(state).items() if not k.startswith("_")}
+    raise TypeError("Unable to extract state dict from state object")

stroma-0.3.2/src/stroma/adapters/crewai.py

@@ -0,0 +1,95 @@
+import asyncio
+import logging
+from collections.abc import Callable
+from typing import Any
+
+try:
+    import crewai  # noqa: F401
+except ImportError as exc:
+    raise ImportError("CrewAI is required for CrewAIAdapter; install with uv add stroma[crewai]") from exc
+
+from stroma.adapters.base import extract_state_dict
+from stroma.contracts import BoundaryValidator, ContractRegistry, NodeContract
+
+logger = logging.getLogger(__name__)
+
+
+def stroma_crewai_step(node_id: str, contract: NodeContract) -> Callable[..., Any]:
+    """Decorator that attaches stroma contract metadata to a CrewAI Flow method.
+
+    Binds *node_id* and *contract* as attributes on the decorated method so
+    `CrewAIAdapter` can discover and validate it.
+    """
+
+    def decorator(fn: Any) -> Any:
+        fn._stroma_node_id = node_id  # type: ignore[attr-defined]
+        fn._stroma_contract = contract  # type: ignore[attr-defined]
+        return fn
+
+    return decorator
+
+
+class CrewAIAdapter:
+    """Wraps a CrewAI Flow instance to apply stroma contract validation on decorated steps.
+
+    Takes a `ContractRegistry` for validation. Call `.wrap(flow_instance)` to
+    discover decorated methods and replace them with validating wrappers.
+    State lives on `flow_instance.state` and is extracted/merged automatically.
+    """
+
+    def __init__(self, registry: ContractRegistry) -> None:
+        self.registry = registry
+        self._validator = BoundaryValidator()
+
+    def wrap(self, flow: Any) -> Any:
+        """Discover stroma-decorated methods on *flow* and replace them with validating wrappers."""
+        for name in self._discover_decorated_methods(flow):
+            method = getattr(flow, name)
+            wrapped = self._wrap_step(flow, method)
+            setattr(flow, name, wrapped)
+        return flow
+
+    def _discover_decorated_methods(self, flow: Any) -> list[str]:
+        """Find all method names on *flow* that carry stroma metadata."""
+        names: list[str] = []
+        for attr_name in dir(flow):
+            if attr_name.startswith("_"):
+                continue
+            attr = getattr(flow, attr_name, None)
+            if callable(attr) and hasattr(attr, "_stroma_node_id"):
+                names.append(attr_name)
+        return names
+
+    def _wrap_step(self, flow: Any, method: Any) -> Callable[..., Any]:
+        """Create a validating wrapper around a Flow step method."""
+        contract: NodeContract = method._stroma_contract
+        validator = self._validator
+
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            state_dict = extract_state_dict(flow.state)
+            validator(contract, "input", state_dict)
+
+            result = method(*args, **kwargs)
+            if asyncio.iscoroutine(result):
+                result = await result
+
+            if result is not None:
+                output_dict = extract_state_dict(result) if not isinstance(result, dict) else result
+            else:
+                output_dict = extract_state_dict(flow.state)
+
+            validated = validator(contract, "output", output_dict)
+            validated_dict = validated.model_dump()
+
+            if isinstance(flow.state, dict):
+                flow.state.update(validated_dict)
+            else:
+                for key, value in validated_dict.items():
+                    if hasattr(flow.state, key):
+                        setattr(flow.state, key, value)
+
+            return result
+
+        wrapper._stroma_node_id = contract.node_id  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+        wrapper._stroma_contract = contract  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+        return wrapper

{stroma-0.3.0 → stroma-0.3.2}/src/stroma/adapters/langgraph.py

@@ -3,31 +3,10 @@ import importlib
 from collections.abc import Callable
 from typing import Any
 
-from pydantic import BaseModel
-
+from stroma.adapters.base import extract_state_dict as extract_state_dict
 from stroma.contracts import BoundaryValidator, ContractRegistry, NodeContract
 
 
-def extract_state_dict(state: Any) -> dict[str, Any]:
-    """Convert a LangGraph state object to a plain dict.
-
-    Supports dicts, Pydantic models, objects with a `.dict()` method,
-    and plain objects with `__dict__`. Raises `TypeError` if the state
-    cannot be converted.
-    """
-    if isinstance(state, dict):
-        return dict(state)
-    if isinstance(state, BaseModel):
-        return state.model_dump()
-    if hasattr(state, "dict"):
-        result = state.dict()
-        if isinstance(result, dict):
-            return result
-    if hasattr(state, "__dict__"):
-        return {k: v for k, v in vars(state).items() if not k.startswith("_")}
-    raise TypeError("Unable to extract state dict from LangGraph state")
-
-
 def stroma_langgraph_node(node_id: str, contract: NodeContract) -> Callable[..., Any]:
     """Decorator that attaches stroma contract metadata to a LangGraph node function.