agentstate-lib 0.1.0__py3-none-any.whl

agentstate/__init__.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from agentstate.core.events import (
+    AgentErrored,
+    BaseStateEvent,
+    CheckpointSaved,
+    ConflictDetected,
+    PatchApplied,
+    StateEvent,
+    WorkflowCompleted,
+    WorkflowStarted,
+    event_adapter,
+)
+from agentstate.core.patch import (
+    StatePatch,
+    apply_patch,
+    get_nested,
+    set_nested,
+)
+from agentstate.core.state import (
+    Artifact,
+    Decision,
+    Goal,
+    SharedState,
+    Task,
+    WorkflowStatus,
+)
+from agentstate.memory.store import InMemoryStore, SQLiteStore, StateStore
+from agentstate.router.context import slice_state
+from agentstate.router.graph import AgentGraph
+from agentstate.router.types import AgentFn, EdgeCondition
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "SharedState",
+    "Task",
+    "Goal",
+    "Artifact",
+    "Decision",
+    "WorkflowStatus",
+    "StatePatch",
+    "apply_patch",
+    "set_nested",
+    "get_nested",
+    "StateEvent",
+    "BaseStateEvent",
+    "WorkflowStarted",
+    "WorkflowCompleted",
+    "PatchApplied",
+    "ConflictDetected",
+    "CheckpointSaved",
+    "AgentErrored",
+    "event_adapter",
+    "AgentGraph",
+    "AgentFn",
+    "EdgeCondition",
+    "slice_state",
+    "StateStore",
+    "InMemoryStore",
+    "SQLiteStore",
+    "__version__",
+]

agentstate/core/__init__.py

@@ -0,0 +1,30 @@
+from .events import (
+    AgentErrored,
+    BaseStateEvent,
+    CheckpointSaved,
+    ConflictDetected,
+    PatchApplied,
+    StateEvent,
+    WorkflowCompleted,
+    WorkflowStarted,
+    event_adapter,
+)
+from .state import Artifact, Decision, Goal, SharedState, Task, WorkflowStatus
+
+__all__ = [
+    "SharedState",
+    "Task",
+    "Goal",
+    "Artifact",
+    "Decision",
+    "WorkflowStatus",
+    "StateEvent",
+    "BaseStateEvent",
+    "WorkflowStarted",
+    "WorkflowCompleted",
+    "PatchApplied",
+    "ConflictDetected",
+    "CheckpointSaved",
+    "AgentErrored",
+    "event_adapter",
+]

agentstate/core/events.py

@@ -0,0 +1,74 @@
+import time
+import uuid
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field, TypeAdapter
+
+
+# This is the parent all events share
+class BaseStateEvent(BaseModel):
+    event_id : str = Field(default_factory=lambda: str(uuid.uuid4()))
+    workflow_id : str
+    agent_id : str
+    timestamp : float = Field(default_factory=time.time)
+
+
+# six subclasses inherting from BaseStateEvent, 
+# with each one, having a 'type' field typed as a literal with 
+# a single string value, and set its default to that string.
+
+class WorkflowStarted(BaseStateEvent):
+    type : Literal["workflow_started"]
+    workflow_type : str
+    goal : str
+
+
+class WorkflowCompleted(BaseStateEvent):
+    type : Literal["workflow_completed"]
+    final_status : Any
+
+
+class PatchApplied(BaseStateEvent):
+    type : Literal["patch_applied"]
+    patch_id : str
+    target : str
+    old_value : Any
+    new_value : Any
+    reason : str
+
+
+class ConflictDetected(BaseStateEvent):
+    type : Literal["conflict_detected"]
+    conflict_id : str
+    path : str
+    winner_agent_id : str
+    loser_agent_id : str
+    resolution_strategy : str
+
+
+class CheckpointSaved(BaseStateEvent):
+    type : Literal["checkpoint_saved"]
+    checkpoint_id : str
+    event_count : int
+
+class AgentErrored(BaseStateEvent):
+    type : Literal["agent_errored"]
+    error_type : str
+    error_message : str
+    retry_count : int
+
+# Pydantic will use the type field to decide which model to instantiate 
+# when deserializing
+StateEvent = Annotated[
+        WorkflowStarted
+    |    WorkflowCompleted
+    |    PatchApplied
+    |   ConflictDetected
+    |    CheckpointSaved
+    |   AgentErrored,
+    Field(discriminator="type")
+]
+
+# at module level, writing a typeadapter for statevent
+# this is how you deserialize a JSON string into the correct event subtype
+event_adapter: TypeAdapter[StateEvent] = TypeAdapter(StateEvent)

agentstate/core/patch.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from agentstate.core.state import SharedState
+
+
+# represents "one change an agent wants to make" to the shared state
+class StatePatch(BaseModel):
+    patch_id:str = Field(default_factory=lambda: str(uuid.uuid4()))
+    agent_id: str
+    target : str # dotted path, eg: tasks.task_1.status
+    value : Any
+    reason : str
+    timestamp : float = Field(default_factory=time.time)
+    priority : int = 0
+
+def set_nested(obj: dict[str, Any], path: str, value : Any) -> dict[str, Any]:
+    """
+    Set value at a dotted path inside a nested dict, creating dicts as needed.
+    """
+    parts = path.split(".") # turns "a.b.c" into ["a","b","c"]
+    current : dict[str, Any] = obj
+
+    for key in parts[:-1]:
+        if key not in current or not isinstance(current[key], dict):
+            current[key] = {}
+        current = current[key]
+    
+    current[parts[-1]] = value
+    return obj
+
+def get_nested(obj: dict[str, Any], path: str) -> Any:
+    """
+    Get value at a dotted path from a nested dict, or None if missing.
+    """
+
+    parts = path.split(".")
+    current : Any = obj
+
+    for key in parts:
+        if not isinstance(current, dict):
+            return None
+        if key not in current:
+            return None
+        current = current[key]
+    
+    return current
+
+# creates a dict view of SharedState with model_dump()
+def apply_patch(state: SharedState, patch: StatePatch) -> SharedState:
+    """Return a new SharedState with the patch applied at patch.target"""
+    state_dict = state.model_dump()
+    set_nested(state_dict, patch.target, patch.value)
+    return SharedState.model_validate(state_dict)

agentstate/core/state.py

@@ -0,0 +1,49 @@
+import time
+import uuid
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+WorkflowStatus = Literal["running", "complete", "failed", "paused"]
+
+class Task(BaseModel):
+    id : str = Field(default_factory=lambda: str(uuid.uuid4()))
+    description : str
+    status : Literal["pending", "running", "done", "failed"] = 'pending'
+    result : Any | None = None
+    created_at : float = Field(default_factory=time.time)
+    updated_as: float = Field(default_factory=time.time)
+
+
+class Goal(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    description : str
+    status : Literal["pending", "active", "complete", "failed"] = 'pending'
+    created_at : float = Field(default_factory=time.time)
+
+class Artifact(BaseModel):
+    id : str = Field(default_factory=lambda : str(uuid.uuid4()))
+    produced_by : str
+    artifact_type : str
+    content : Any
+    created_at : float = Field(default_factory=time.time)
+
+class Decision(BaseModel):
+    id : str = Field(default_factory=lambda : str(uuid.uuid4()))
+    made_by : str
+    description : str
+    rationale : str
+    timestamp : float = Field(default_factory=time.time)
+
+class SharedState(BaseModel):
+    workflow_id : str = Field(default_factory=lambda: str(uuid.uuid4()))
+    workflow_type : str = "general"
+    goal : str
+    goals : dict[str, Goal] = Field(default_factory=dict)
+    tasks : dict[str, Task] = Field(default_factory=dict)
+    artifacts : dict[str, Artifact] = Field(default_factory=dict)
+    decisions : list[Decision] = Field(default_factory=list)
+    facts : dict[str, Any] = Field(default_factory=dict)
+    status : WorkflowStatus = 'running' 
+    created_at : float = Field(default_factory=time.time)
+    updated_at : float = Field(default_factory=time.time)

agentstate/memory/__init__.py

@@ -0,0 +1,11 @@
+from .store import (
+    InMemoryStore,
+    SQLiteStore,
+    StateStore,
+)
+
+__all__ = [
+    "StateStore",
+    "InMemoryStore",
+    "SQLiteStore",
+]

agentstate/memory/store.py

@@ -0,0 +1,134 @@
+from typing import Protocol, runtime_checkable
+
+import aiosqlite
+
+from agentstate.core.events import StateEvent, event_adapter
+
+
+# Protocol : a rule sheet for what a store must be able to do
+@runtime_checkable
+class StateStore(Protocol):
+    async def append(self, event: StateEvent) -> None:
+        ...
+
+    async def get_workflow(self, workflow_id: str) -> list[StateEvent]:
+        ...
+
+    async def since(self, workflow_id: str, index: int) -> list[StateEvent]:
+        ...
+
+    async def count(self, workflow_id: str) -> int:
+        ...
+
+class InMemoryStore:
+    def __init__(self) -> None:
+        self._events: dict[str, list[StateEvent]] = {}
+
+    async def append(self, event: StateEvent) -> None:
+        if event.workflow_id not in self._events:
+            self._events[event.workflow_id] = []
+        self._events[event.workflow_id].append(event)
+    
+    async def get_workflow(self, workflow_id: str) -> list[StateEvent]:
+        return list(self._events.get(workflow_id, []))
+    
+    async def since(self, workflow_id : str, index: int) -> list[StateEvent]:
+        return list(self._events.get(workflow_id, [])[index:])
+    
+    async def count(self, workflow_id: str) -> int:
+        return len(self._events.get(workflow_id, []))
+
+# this method should create the events table if it does not already exists
+# create an index on workflow_id
+# commit the changes 
+class SQLiteStore:
+    def __init__(self, path: str) -> None:
+        self.path = path
+    
+    async def _init_db(self, db:aiosqlite.Connection) -> None:
+        await db.execute(
+            """
+            CREATE TABLE IF NOT EXISTS events(
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                event_id TEXT NOT NULL,
+                workflow_id TEXT NOT NULL,
+                type TEXT NOT NULL,
+                data TEXT NOT NULL,
+                timestamp REAL NOT NULL
+            )
+            """
+        )
+
+        await db.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_wf_id
+            ON events(workflow_id)
+            """
+        )
+
+        await db.commit()
+
+    async def append(self, event: StateEvent) -> None:
+        async with aiosqlite.connect(self.path) as db:
+            await self._init_db(db)
+            await db.execute(
+                """
+                INSERT INTO events(event_id, workflow_id, type, data, timestamp)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    event.event_id,
+                    event.workflow_id,
+                    event.type,
+                    event.model_dump_json(),
+                    event.timestamp,
+                ),
+            )
+            await db.commit()
+    
+    async def get_workflow(self, workflow_id : str) -> list[StateEvent]:
+        async with aiosqlite.connect(self.path) as db:
+            await self._init_db(db)
+            cursor = await db.execute(
+                """
+                SELECT data
+                FROM events
+                WHERE workflow_id=?
+                ORDER BY id ASC
+                """,
+                (workflow_id,),
+            )
+            rows = await cursor.fetchall()
+            return [event_adapter.validate_json(row[0]) for row in rows]
+    
+    async def since(self, workflow_id: str, index: int) -> list[StateEvent]:
+        async with aiosqlite.connect(self.path) as db:
+            await self._init_db(db)
+            cursor = await db.execute(
+                """
+                SELECT data
+                FROM events
+                WHERE workflow_id=?
+                ORDER BY id ASC
+                LIMIT -1 OFFSET ?
+                """,
+                (workflow_id, index),
+            )
+            rows = await cursor.fetchall()
+            return [event_adapter.validate_json(row[0]) for row in rows]
+        
+    
+    async def count(self, workflow_id: str) -> int:
+        async with aiosqlite.connect(self.path) as db:
+            await self._init_db(db)
+            cursor = await db.execute(
+                """
+                SELECT COUNT(*)
+                FROM events
+                WHERE workflow_id=?
+                """,
+                (workflow_id,),
+            )
+            row = await cursor.fetchone()
+            return int(row[0]) if row else 0
+        

agentstate/router/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from agentstate.router.context import slice_state
+from agentstate.router.graph import AgentGraph
+from agentstate.router.types import AgentFn, EdgeCondition
+
+__all__ = [
+    "AgentGraph",
+    "AgentFn",
+    "EdgeCondition",
+    "slice_state",
+]

agentstate/router/context.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+from agentstate.core.patch import get_nested, set_nested
+from agentstate.core.state import SharedState
+
+
+def slice_state(state: SharedState, include_paths: list[str]) -> dict[str, Any]:
+    """
+    Returns a dict view of just the requested paths from SharedState.
+    if include_paths is empty, return the full state dict
+    """
+    full_dict = state.model_dump()
+    # no slice requested mean "full context"
+    if not include_paths:
+        return full_dict
+    
+    result : dict[str, Any]  = {}
+    for path in include_paths:
+        value = get_nested(full_dict, path)
+        if value is not None:
+            set_nested(result, path, value)
+    return result

agentstate/router/graph.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from agentstate.core.events import (
+    PatchApplied,
+    WorkflowCompleted,
+    WorkflowStarted,
+)
+from agentstate.core.patch import apply_patch
+from agentstate.core.state import SharedState
+from agentstate.memory.store import InMemoryStore, StateStore
+from agentstate.router.context import slice_state
+from agentstate.router.types import AgentFn, EdgeCondition
+
+
+@dataclass(frozen=True)
+class _Node:
+    agent_id: str
+    fn : AgentFn
+    context_keys : list[str]
+
+@dataclass(frozen=True)
+class _Edge:
+    from_agent : str
+    to_agent: str
+    condition: EdgeCondition
+
+class AgentGraph:
+    """A simple directed graph of agents with conditional edges."""
+
+    def __init__(
+            self,
+            store: StateStore | None = None,
+            max_concurrent: int = 3,
+    ) ->None:
+        self._store: StateStore = store or InMemoryStore()
+        self._nodes: dict[str, _Node] = {}
+        self._edges: list[_Edge] = []
+        self._sem = asyncio.Semaphore(max_concurrent)
+
+    def node(
+            self,
+            agent_id: str,
+            context: list[str] | None = None,
+    ) -> Callable[[AgentFn], AgentFn]:
+        """Decorator to register an agent function under a given agent_id"""
+
+        def decorator(fn:AgentFn) -> AgentFn:
+            node = _Node(
+                agent_id=agent_id,
+                fn=fn,
+                context_keys=context or [],
+            )
+            self._nodes[agent_id] = node
+            return fn
+        return decorator
+    
+    def edge(
+            self,
+            from_agent: str,
+            to_agent: str,
+            condition: EdgeCondition | None = None,
+    ) -> None:
+        """Add a directed edge between two agents."""
+        cond = condition or (lambda s: True)
+        self._edges.append(
+            _Edge(
+                from_agent=from_agent,
+                to_agent=to_agent,
+                condition=cond,
+            ),
+        )
+    
+    def _next_agent(self, current_id:str, state:SharedState) -> str | None:
+        """Return the next agent_id to run current_id, or None if done."""
+        state_dict = state.model_dump()
+
+        for edge in self._edges:
+            if edge.from_agent != current_id:
+                continue
+            if edge.condition(state_dict):
+                return edge.to_agent
+        
+        return None
+    
+    async def run(
+            self,
+            state: SharedState,
+            start: str,
+            event_queue: asyncio.Queue[PatchApplied | WorkflowStarted 
+                                       | WorkflowCompleted] | None = None,
+    ) -> SharedState:
+        """Run the agent graph starting from the given agent_id"""
+        if start not in self._nodes:
+            msg = f"Start agent '{start}' is not registered in this AgentGraph."
+            raise ValueError(msg)
+        
+        # for now, use the state's workflow_id as the workflow identifier
+        workflow_id = state.workflow_id
+
+        # Record workflow start
+        workflow_started = WorkflowStarted(
+            workflow_id=workflow_id,
+            agent_id="system",
+            workflow_type=state.workflow_type,
+            goal=state.goal,
+            type="workflow_started",
+        )
+        await self._store.append(workflow_started)
+        if event_queue is not None:
+            event_queue.put_nowait(workflow_started)
+        
+        current_id: str | None = start
+        current_state = state
+
+        while current_id is not None:
+            if current_id not in self._nodes:
+                msg = f"Agent '{current_id}' is not registered in this AgentGraph."
+                raise ValueError(msg)
+            
+            node = self._nodes[current_id]
+            context = slice_state(current_state, node.context_keys)
+            
+            async with self._sem:
+                patch = await node.fn(context)
+            
+            old_value = current_state.model_dump()
+            current_state = apply_patch(current_state, patch)
+            new_value = current_state.model_dump()
+
+            patch_event = PatchApplied(
+                workflow_id=workflow_id,
+                agent_id=patch.agent_id,
+                type="patch_applied",
+                patch_id=patch.patch_id,
+                target=patch.target,
+                old_value=old_value,
+                new_value=new_value,
+                reason=patch.reason,
+                timestamp=patch.timestamp,
+            )
+            await self._store.append(patch_event)
+            if event_queue is not None:
+                event_queue.put_nowait(patch_event)
+            
+            current_id = self._next_agent(node.agent_id, current_state)
+
+        workflow_completed = WorkflowCompleted(
+            workflow_id=workflow_id,
+            agent_id="system",
+            type="workflow_completed",
+            final_status=current_state.status,
+        )
+        await self._store.append(workflow_completed)
+        if event_queue is not None:
+            event_queue.put_nowait(workflow_completed)
+
+        return current_state
+        

agentstate/router/types.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from agentstate.core.patch import StatePatch
+
+# Any async function that takes a context dict and returns a StatePatch
+# is a valid agent. No inheritance required.
+AgentFn = Callable[[dict[str,Any]], Awaitable["StatePatch"]]
+
+# A function that takes the current state as a dict and returns True
+# if this edge should be followed.
+EdgeCondition = Callable[[dict[str, Any]], bool]

agentstate_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: agentstate_lib
+Version: 0.1.0
+Summary: Stateful coordination layer for multi-agent AI systems
+Author-email: Tanveer Kaur <tanveerkaur1292@outlook.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,llm,multi-agent,orchestration,state
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.19
+Requires-Dist: pydantic>=2.0
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100; extra == 'api'
+Requires-Dist: uvicorn[standard]>=0.20; extra == 'api'
+Provides-Extra: contrib
+Provides-Extra: dashboard
+Requires-Dist: rich>=13.0; extra == 'dashboard'
+Provides-Extra: dev
+Requires-Dist: httpx>=0.24; extra == 'dev'
+Requires-Dist: hypothesis>=6.0; extra == 'dev'
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api; extra == 'otel'
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc; extra == 'otel'
+Requires-Dist: opentelemetry-sdk; extra == 'otel'
+Description-Content-Type: text/markdown
+
+# agentstate
+Building a stateful coordination layer for multi-agent AI systems.
+

agentstate_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+agentstate/__init__.py,sha256=3YZ6uWZUa7E1L8xC4OrBUFJ2ndiRfGDUSEqIPra3D9c,1325
+agentstate/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/api/app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/api/auth.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/api/cache.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/api/routes.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/api/streaming.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/contrib/base_agent.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/coordination/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/coordination/conflicts.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/coordination/invariants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/core/__init__.py,sha256=MzflZdUoctDKhZzpJbyZbjM9JLhQmQKpBFuXE8p2Mm4,617
+agentstate/core/events.py,sha256=5dKXoS5CYd_PXWrZ65pwZfbPBg-VbtiGJQEsMJEkWHQ,1960
+agentstate/core/patch.py,sha256=4d27aIdnekcmSY7MpMgVTMbqLpC_JK4A7qO5xT866Yw,1799
+agentstate/core/state.py,sha256=FkafgxnVDJ2P2XtkUNjAPKkE9BZwM1pOn7ukTCY1VVs,1821
+agentstate/memory/__init__.py,sha256=21GRbnmwoNmV--n9LJxti-weTo1mrBhuAwgR0qJBF6g,159
+agentstate/memory/checkpoint.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/memory/replay.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/memory/store.py,sha256=omOIWwdccotsqFQTbMY1crfOBJQJX-ijY6MdE2EIZHo,4425
+agentstate/observability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/observability/analysis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/observability/dashboard.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/observability/tracing.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentstate/router/__init__.py,sha256=qROHk83A6XTM88J6EEWiSPwr6czaWGNuVMXOC0Mc-zo,290
+agentstate/router/context.py,sha256=7XSPOPqpZgytyBIhsbLPHYLvYSaxzd2eHJUDoAAob7Y,751
+agentstate/router/graph.py,sha256=S_m96lUwwuw2H30v8mH7Ja4CPYUkHpJL7ZkYboqk8fE,5342
+agentstate/router/types.py,sha256=SkuV6l1kpjSn4QpdVD5gH1Ojp-Hsn7NKysF3Asp7ljM,536
+agentstate_lib-0.1.0.dist-info/METADATA,sha256=qKTj7tG29p5A15FOnzz90AD1om02LeqqmiLN7aQESbs,1171
+agentstate_lib-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentstate_lib-0.1.0.dist-info/licenses/LICENSE,sha256=zUb9KlZdCdZd8E5fO4a-ySskntrRYVApJRiDhk9J54w,1090
+agentstate_lib-0.1.0.dist-info/RECORD,,

agentstate_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentstate_lib-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tanveer kaur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.