agnt5 0.2.8a7__cp310-abi3-macosx_11_0_arm64.whl → 0.2.8a9__cp310-abi3-macosx_11_0_arm64.whl

agnt5/workflow.py

@@ -7,10 +7,10 @@ import functools
 import inspect
 import logging
 import uuid
-from typing import Any, Callable, Dict, List, Optional, TypeVar, cast
+from typing import Any, Awaitable, Callable, Dict, List, Optional, TypeVar, Union, cast
 
 from ._schema_utils import extract_function_metadata, extract_function_schemas
-from .context import Context
+from .context import Context, set_current_context
 from .entity import Entity, EntityState, _get_state_adapter
 from .function import FunctionContext
 from .types import HandlerFunc, WorkflowConfig
@@ -23,6 +23,7 @@ T = TypeVar("T")
 # Global workflow registry
 _WORKFLOW_REGISTRY: Dict[str, WorkflowConfig] = {}
 
+
 class WorkflowContext(Context):
     """
     Context for durable workflows.
@@ -32,17 +33,28 @@ class WorkflowContext(Context):
     - Step tracking and replay
     - Orchestration (task, parallel, gather)
     - Checkpointing (step)
+    - Memory scoping (session_id, user_id for multi-level memory)
 
     WorkflowContext delegates state to the underlying WorkflowEntity,
     which provides durability and state change tracking for AI workflows.
+
+    Memory Scoping:
+    - run_id: Unique workflow run identifier
+    - session_id: For multi-turn conversations (optional)
+    - user_id: For user-scoped long-term memory (optional)
+    These identifiers enable agents to automatically select the appropriate
+    memory scope (run/session/user) via context propagation.
     """
 
     def __init__(
         self,
         workflow_entity: "WorkflowEntity",  # Forward reference
         run_id: str,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
         attempt: int = 0,
         runtime_context: Optional[Any] = None,
+        checkpoint_callback: Optional[Callable[[dict], None]] = None,
     ) -> None:
         """
         Initialize workflow context.
@@ -50,15 +62,41 @@ class WorkflowContext(Context):
         Args:
             workflow_entity: WorkflowEntity instance managing workflow state
             run_id: Unique workflow run identifier
+            session_id: Session identifier for multi-turn conversations (default: run_id)
+            user_id: User identifier for user-scoped memory (optional)
             attempt: Retry attempt number (0-indexed)
             runtime_context: RuntimeContext for trace correlation
+            checkpoint_callback: Optional callback for sending real-time checkpoints
         """
         super().__init__(run_id, attempt, runtime_context)
         self._workflow_entity = workflow_entity
         self._step_counter: int = 0  # Track step sequence
+        self._sequence_number: int = 0  # Global sequence for checkpoints
+        self._checkpoint_callback = checkpoint_callback
+
+        # Memory scoping identifiers
+        self.session_id = session_id or run_id  # Default: session = run (ephemeral)
+        self.user_id = user_id  # Optional: user-scoped memory
 
     # === State Management ===
 
+    def _send_checkpoint(self, checkpoint_type: str, checkpoint_data: dict) -> None:
+        """
+        Send a checkpoint via the checkpoint callback.
+
+        Args:
+            checkpoint_type: Type of checkpoint (e.g., "workflow.state.changed")
+            checkpoint_data: Checkpoint payload
+        """
+        if self._checkpoint_callback:
+            self._sequence_number += 1
+            checkpoint = {
+                "checkpoint_type": checkpoint_type,
+                "checkpoint_data": checkpoint_data,
+                "sequence_number": self._sequence_number,
+            }
+            self._checkpoint_callback(checkpoint)
+
     @property
     def state(self):
         """
@@ -71,7 +109,11 @@ class WorkflowContext(Context):
             ctx.state.set("status", "processing")
             status = ctx.state.get("status")
         """
-        return self._workflow_entity.state
+        state = self._workflow_entity.state
+        # Pass checkpoint callback to state for real-time streaming
+        if hasattr(state, "_set_checkpoint_callback"):
+            state._set_checkpoint_callback(self._send_checkpoint)
+        return state
 
     # === Orchestration ===
 
@@ -129,7 +171,7 @@ class WorkflowContext(Context):
         # Extract handler name from function reference or use string
         if callable(handler):
             handler_name = handler.__name__
-            if not hasattr(handler, '_agnt5_config'):
+            if not hasattr(handler, "_agnt5_config"):
                 raise ValueError(
                     f"Function '{handler_name}' is not a registered @function. "
                     f"Did you forget to add the @function decorator?"
@@ -147,32 +189,104 @@ class WorkflowContext(Context):
             self._logger.info(f"🔄 Replaying cached step: {step_name}")
             return result
 
-        # Execute function
+        # Emit workflow.step.started checkpoint
+        self._send_checkpoint(
+            "workflow.step.started",
+            {
+                "step_name": step_name,
+                "handler_name": handler_name,
+                "input": args or kwargs,
+            },
+        )
+
+        # Execute function with OpenTelemetry span
         self._logger.info(f"▶️  Executing new step: {step_name}")
         func_config = FunctionRegistry.get(handler_name)
         if func_config is None:
             raise ValueError(f"Function '{handler_name}' not found in registry")
 
-        # Create FunctionContext for the function execution
-        func_ctx = FunctionContext(
-            run_id=f"{self.run_id}:task:{handler_name}",
-            runtime_context=self._runtime_context,
-        )
+        # Import span creation utility and JSON serialization
+        from ._core import create_span
+        import json
+
+        # Serialize input data for span attributes
+        input_repr = json.dumps({"args": args, "kwargs": kwargs}) if args or kwargs else "{}"
+
+        # Create span for task execution
+        with create_span(
+            f"workflow.task.{handler_name}",
+            "function",
+            self._runtime_context,
+            {
+                "step_name": step_name,
+                "handler_name": handler_name,
+                "run_id": self.run_id,
+                "input.data": input_repr,
+            },
+        ) as span:
+            # Create FunctionContext for the function execution
+            func_ctx = FunctionContext(
+                run_id=f"{self.run_id}:task:{handler_name}",
+                runtime_context=self._runtime_context,
+            )
 
-        # Execute function with arguments
-        # Support legacy pattern: ctx.task("func_name", input=data) or ctx.task(func_ref, input=data)
-        if len(args) == 0 and "input" in kwargs:
-            # Legacy pattern - single input parameter
-            input_data = kwargs.pop("input")  # Remove from kwargs
-            result = await func_config.handler(func_ctx, input_data, **kwargs)
-        else:
-            # Type-safe pattern - pass all args/kwargs
-            result = await func_config.handler(func_ctx, *args, **kwargs)
+            try:
+                # Execute function with arguments
+                # Support legacy pattern: ctx.task("func_name", input=data) or ctx.task(func_ref, input=data)
+                if len(args) == 0 and "input" in kwargs:
+                    # Legacy pattern - single input parameter
+                    input_data = kwargs.pop("input")  # Remove from kwargs
+                    result = await func_config.handler(func_ctx, input_data, **kwargs)
+                else:
+                    # Type-safe pattern - pass all args/kwargs
+                    result = await func_config.handler(func_ctx, *args, **kwargs)
+
+                # Add output data to span
+                try:
+                    output_repr = json.dumps(result)
+                    span.set_attribute("output.data", output_repr)
+                except (TypeError, ValueError):
+                    # If result is not JSON serializable, use repr
+                    span.set_attribute("output.data", repr(result))
+
+                # Record step completion in WorkflowEntity
+                self._workflow_entity.record_step_completion(
+                    step_name, handler_name, args or kwargs, result
+                )
 
-        # Record step completion in WorkflowEntity
-        self._workflow_entity.record_step_completion(step_name, handler_name, args or kwargs, result)
+                # Emit workflow.step.completed checkpoint
+                self._send_checkpoint(
+                    "workflow.step.completed",
+                    {
+                        "step_name": step_name,
+                        "handler_name": handler_name,
+                        "input": args or kwargs,
+                        "result": result,
+                    },
+                )
 
-        return result
+                return result
+
+            except Exception as e:
+                # Emit workflow.step.error checkpoint
+                self._send_checkpoint(
+                    "workflow.step.error",
+                    {
+                        "step_name": step_name,
+                        "handler_name": handler_name,
+                        "input": args or kwargs,
+                        "error": str(e),
+                        "error_type": type(e).__name__,
+                    },
+                )
+
+                # Record error in span
+                span.set_attribute("error", "true")
+                span.set_attribute("error.message", str(e))
+                span.set_attribute("error.type", type(e).__name__)
+
+                # Re-raise to propagate failure
+                raise
 
     async def parallel(self, *tasks: Awaitable[T]) -> List[T]:
         """
@@ -191,6 +305,7 @@ class WorkflowContext(Context):
             )
         """
         import asyncio
+
         return list(await asyncio.gather(*tasks))
 
     async def gather(self, **tasks: Awaitable[T]) -> Dict[str, T]:
@@ -210,15 +325,14 @@ class WorkflowContext(Context):
             )
         """
         import asyncio
+
         keys = list(tasks.keys())
         values = list(tasks.values())
         results = await asyncio.gather(*values)
         return dict(zip(keys, results))
 
     async def step(
-        self,
-        name: str,
-        func_or_awaitable: Union[Callable[[], Awaitable[T]], Awaitable[T]]
+        self, name: str, func_or_awaitable: Union[Callable[[], Awaitable[T]], Awaitable[T]]
     ) -> T:
         """
         Checkpoint expensive operations for durability.
@@ -255,10 +369,7 @@ class WorkflowContext(Context):
         return result
 
     async def wait_for_user(
-        self,
-        question: str,
-        input_type: str = "text",
-        options: Optional[List[Dict]] = None
+        self, question: str, input_type: str = "text", options: Optional[List[Dict]] = None
     ) -> str:
         """
         Pause workflow execution and wait for user input.
@@ -322,7 +433,7 @@ class WorkflowContext(Context):
         # No response yet - pause execution
         # Collect current workflow state for checkpoint
         checkpoint_state = {}
-        if hasattr(self._workflow_entity, '_state') and self._workflow_entity._state is not None:
+        if hasattr(self._workflow_entity, "_state") and self._workflow_entity._state is not None:
             checkpoint_state = self._workflow_entity._state.get_state_snapshot()
 
         self._logger.info(f"⏸️  Pausing workflow for user input: {question}")
@@ -331,7 +442,7 @@ class WorkflowContext(Context):
             question=question,
             input_type=input_type,
             options=options,
-            checkpoint_state=checkpoint_state
+            checkpoint_state=checkpoint_state,
         )
 
 
@@ -339,6 +450,7 @@ class WorkflowContext(Context):
 # WorkflowEntity: Entity specialized for workflow execution state
 # ============================================================================
 
+
 class WorkflowEntity(Entity):
     """
     Entity specialized for workflow execution state.
@@ -347,20 +459,50 @@ class WorkflowEntity(Entity):
     - Step tracking for replay and crash recovery
     - State change tracking for debugging and audit (AI workflows)
     - Completed step cache for efficient replay
+    - Automatic state persistence after workflow execution
 
-    Workflows are temporary entities - they exist for the duration of
-    execution and their state is used for coordination between steps.
+    Workflow state is persisted to the database after successful execution,
+    enabling crash recovery, replay, and cross-invocation state management.
+    The workflow decorator automatically calls _persist_state() to ensure
+    durability.
     """
 
-    def __init__(self, run_id: str):
+    def __init__(
+        self,
+        run_id: str,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ):
         """
-        Initialize workflow entity.
+        Initialize workflow entity with memory scope.
 
         Args:
             run_id: Unique workflow run identifier
+            session_id: Session identifier for multi-turn conversations (optional)
+            user_id: User identifier for user-scoped memory (optional)
+
+        Memory Scope Priority:
+            - user_id present → key: user:{user_id}
+            - session_id present (and != run_id) → key: session:{session_id}
+            - else → key: run:{run_id}
         """
-        # Initialize as entity with workflow key pattern
-        super().__init__(key=f"workflow:{run_id}")
+        # Determine entity key based on memory scope priority
+        if user_id:
+            entity_key = f"user:{user_id}"
+            memory_scope = "user"
+        elif session_id and session_id != run_id:
+            entity_key = f"session:{session_id}"
+            memory_scope = "session"
+        else:
+            entity_key = f"run:{run_id}"
+            memory_scope = "run"
+
+        # Initialize as entity with scoped key pattern
+        super().__init__(key=entity_key)
+
+        # Store run_id separately for tracking (even if key is session/user scoped)
+        self._run_id = run_id
+        self._memory_scope = memory_scope
 
         # Step tracking for replay and recovery
         self._step_events: list[Dict[str, Any]] = []
@@ -369,19 +511,15 @@ class WorkflowEntity(Entity):
         # State change tracking for debugging/audit (AI workflows)
         self._state_changes: list[Dict[str, Any]] = []
 
-        logger.debug(f"Created WorkflowEntity: {run_id}")
+        logger.debug(f"Created WorkflowEntity: run={run_id}, scope={memory_scope}, key={entity_key}")
 
     @property
     def run_id(self) -> str:
-        """Extract run_id from workflow key."""
-        return self._key.split(":", 1)[1]
+        """Get run_id for this workflow execution."""
+        return self._run_id
 
     def record_step_completion(
-        self,
-        step_name: str,
-        handler_name: str,
-        input_data: Any,
-        result: Any
+        self, step_name: str, handler_name: str, input_data: Any, result: Any
     ) -> None:
         """
         Record completed step for replay and recovery.
@@ -392,12 +530,14 @@ class WorkflowEntity(Entity):
             input_data: Input data passed to function
             result: Function result
         """
-        self._step_events.append({
-            "step_name": step_name,
-            "handler_name": handler_name,
-            "input": input_data,
-            "result": result
-        })
+        self._step_events.append(
+            {
+                "step_name": step_name,
+                "handler_name": handler_name,
+                "input": input_data,
+                "result": result,
+            }
+        )
         self._completed_steps[step_name] = result
         logger.debug(f"Recorded step completion: {step_name}")
 
@@ -437,6 +577,109 @@ class WorkflowEntity(Entity):
         self._completed_steps[response_key] = response
         logger.info(f"Injected user response for {self.run_id}: {response}")
 
+    def get_agent_data(self, agent_name: str) -> Dict[str, Any]:
+        """
+        Get agent conversation data from workflow state.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            Dictionary containing agent conversation data (messages, metadata)
+            or empty dict if agent has no data yet
+
+        Example:
+            ```python
+            agent_data = workflow_entity.get_agent_data("ResearchAgent")
+            messages = agent_data.get("messages", [])
+            ```
+        """
+        return self.state.get(f"agent.{agent_name}", {})
+
+    def get_agent_messages(self, agent_name: str) -> list[Dict[str, Any]]:
+        """
+        Get agent messages from workflow state.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            List of message dictionaries
+
+        Example:
+            ```python
+            messages = workflow_entity.get_agent_messages("ResearchAgent")
+            for msg in messages:
+                print(f"{msg['role']}: {msg['content']}")
+            ```
+        """
+        agent_data = self.get_agent_data(agent_name)
+        return agent_data.get("messages", [])
+
+    def list_agents(self) -> list[str]:
+        """
+        List all agents with data in this workflow.
+
+        Returns:
+            List of agent names that have stored conversation data
+
+        Example:
+            ```python
+            agents = workflow_entity.list_agents()
+            # ['ResearchAgent', 'AnalysisAgent', 'SynthesisAgent']
+            ```
+        """
+        agents = []
+        for key in self.state._state.keys():
+            if key.startswith("agent."):
+                agents.append(key.replace("agent.", "", 1))
+        return agents
+
+    async def _persist_state(self) -> None:
+        """
+        Internal method to persist workflow state to entity storage.
+
+        This is prefixed with _ so it won't be wrapped by the entity method wrapper.
+        Called after workflow execution completes to ensure state is durable.
+        """
+        logger.info(f"🔍 DEBUG: _persist_state() CALLED for workflow {self.run_id}")
+
+        try:
+            from .entity import _get_state_adapter
+
+            logger.info(f"🔍 DEBUG: Getting state adapter...")
+            # Get the state adapter (must be in Worker context)
+            adapter = _get_state_adapter()
+            logger.info(f"🔍 DEBUG: Got state adapter: {type(adapter).__name__}")
+
+            logger.info(f"🔍 DEBUG: Getting state snapshot...")
+            # Get current state snapshot
+            state_dict = self.state.get_state_snapshot()
+            logger.info(f"🔍 DEBUG: State snapshot has {len(state_dict)} keys: {list(state_dict.keys())}")
+
+            logger.info(f"🔍 DEBUG: Loading current version for optimistic locking...")
+            # Load current version (for optimistic locking)
+            _, current_version = await adapter.load_with_version(self._entity_type, self._key)
+            logger.info(f"🔍 DEBUG: Current version: {current_version}")
+
+            logger.info(f"🔍 DEBUG: Saving state to database...")
+            # Save state with version check
+            new_version = await adapter.save_state(
+                self._entity_type, self._key, state_dict, current_version
+            )
+
+            logger.info(
+                f"✅ SUCCESS: Persisted WorkflowEntity state for {self.run_id} "
+                f"(version {current_version} -> {new_version}, {len(state_dict)} keys)"
+            )
+        except Exception as e:
+            logger.error(
+                f"❌ ERROR: Failed to persist workflow state for {self.run_id}: {e}",
+                exc_info=True
+            )
+            # Re-raise to let caller handle
+            raise
+
     @property
     def state(self) -> "WorkflowState":
         """
@@ -471,42 +714,62 @@ class WorkflowState(EntityState):
         """
         super().__init__(state_dict)
         self._workflow_entity = workflow_entity
+        self._checkpoint_callback: Optional[Callable[[str, dict], None]] = None
+
+    def _set_checkpoint_callback(self, callback: Callable[[str, dict], None]) -> None:
+        """
+        Set the checkpoint callback for real-time state change streaming.
+
+        Args:
+            callback: Function to call when state changes
+        """
+        self._checkpoint_callback = callback
 
     def set(self, key: str, value: Any) -> None:
         """Set value and track change."""
         super().set(key, value)
         # Track change for debugging/audit
         import time
-        self._workflow_entity._state_changes.append({
-            "key": key,
-            "value": value,
-            "timestamp": time.time(),
-            "deleted": False
-        })
+
+        change_record = {"key": key, "value": value, "timestamp": time.time(), "deleted": False}
+        self._workflow_entity._state_changes.append(change_record)
+
+        # Emit checkpoint for real-time state streaming
+        if self._checkpoint_callback:
+            self._checkpoint_callback(
+                "workflow.state.changed", {"key": key, "value": value, "operation": "set"}
+            )
 
     def delete(self, key: str) -> None:
         """Delete key and track change."""
         super().delete(key)
         # Track deletion
         import time
-        self._workflow_entity._state_changes.append({
-            "key": key,
-            "value": None,
-            "timestamp": time.time(),
-            "deleted": True
-        })
+
+        change_record = {"key": key, "value": None, "timestamp": time.time(), "deleted": True}
+        self._workflow_entity._state_changes.append(change_record)
+
+        # Emit checkpoint for real-time state streaming
+        if self._checkpoint_callback:
+            self._checkpoint_callback("workflow.state.changed", {"key": key, "operation": "delete"})
 
     def clear(self) -> None:
         """Clear all state and track change."""
         super().clear()
         # Track clear operation
         import time
-        self._workflow_entity._state_changes.append({
+
+        change_record = {
             "key": "__clear__",
             "value": None,
             "timestamp": time.time(),
-            "deleted": True
-        })
+            "deleted": True,
+        }
+        self._workflow_entity._state_changes.append(change_record)
+
+        # Emit checkpoint for real-time state streaming
+        if self._checkpoint_callback:
+            self._checkpoint_callback("workflow.state.changed", {"operation": "clear"})
 
     def has_changes(self) -> bool:
         """Check if any state changes have been tracked."""
@@ -683,11 +946,45 @@ def workflow(
                     run_id=run_id,
                 )
 
-                # Execute workflow
-                return await handler_func(ctx, *args, **kwargs)
+                # Set context in task-local storage for automatic propagation
+                token = set_current_context(ctx)
+                try:
+                    # Execute workflow
+                    result = await handler_func(ctx, *args, **kwargs)
+
+                    # Persist workflow state after successful execution
+                    try:
+                        await workflow_entity._persist_state()
+                    except Exception as e:
+                        logger.error(f"Failed to persist workflow state (non-fatal): {e}", exc_info=True)
+                        # Don't fail the workflow - persistence failure shouldn't break execution
+
+                    return result
+                finally:
+                    # Always reset context to prevent leakage
+                    from .context import _current_context
+
+                    _current_context.reset(token)
             else:
-                # WorkflowContext provided - use it
-                return await handler_func(*args, **kwargs)
+                # WorkflowContext provided - use it and set in contextvar
+                ctx = args[0]
+                token = set_current_context(ctx)
+                try:
+                    result = await handler_func(*args, **kwargs)
+
+                    # Persist workflow state after successful execution
+                    try:
+                        await ctx._workflow_entity._persist_state()
+                    except Exception as e:
+                        logger.error(f"Failed to persist workflow state (non-fatal): {e}", exc_info=True)
+                        # Don't fail the workflow - persistence failure shouldn't break execution
+
+                    return result
+                finally:
+                    # Always reset context to prevent leakage
+                    from .context import _current_context
+
+                    _current_context.reset(token)
 
         # Store config on wrapper for introspection
         wrapper._agnt5_config = config  # type: ignore
@@ -698,5 +995,3 @@ def workflow(
         return decorator
     else:
         return decorator(_func)
-
-

{agnt5-0.2.8a7.dist-info → agnt5-0.2.8a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agnt5
-Version: 0.2.8a7
+Version: 0.2.8a9
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

agnt5-0.2.8a9.dist-info/RECORD

@@ -0,0 +1,22 @@
+agnt5-0.2.8a9.dist-info/METADATA,sha256=fCSo0PhnFkA9J1zcqNdmLiMYfTPHpYVVtwQLRGdhDDw,996
+agnt5-0.2.8a9.dist-info/WHEEL,sha256=-lwEpi49KOTCcgx48T3fLSP8Dxynwa-iRMZNo-JZaqc,103
+agnt5/__init__.py,sha256=liMb9egh56qvgY4Xvs9s7grOzF3lXSE8-nIksJLNAy4,2195
+agnt5/_compat.py,sha256=BGuy3v5VDOHVa5f3Z-C22iMN19lAt0mPmXwF3qSSWxI,369
+agnt5/_core.abi3.so,sha256=jvQNwEx-YaPcHYz6pmn8ETlN9n0ZCvLqq2MSYjPe-JQ,12645584
+agnt5/_retry_utils.py,sha256=loHsWY5BR4wZy57IzcDEjQAy88DHVwVIr25Cn1d9GPA,5801
+agnt5/_schema_utils.py,sha256=MR67RW757T4Oq2Jqf4kB61H_b51zwaf3CLWELnkngRo,9572
+agnt5/_telemetry.py,sha256=Oafa1uC4IXIf12mhj5kBLwmVtVcLQweay5Nrr7-xRDg,6781
+agnt5/agent.py,sha256=b8xOxmtBxdzbK-2G1oWiRZRtetjDaAc3CWCx_zW0ep4,70600
+agnt5/client.py,sha256=aHQvxlH4_CP93YkS9lSKUrIwPS1maCiuYNwhuFqRElE,23928
+agnt5/context.py,sha256=qbJUtZE7LpU1VJx2I2DJO6OCZHoYWkEJBGIfycBawfU,5695
+agnt5/entity.py,sha256=AlHmSHVxQD5EYBvkmERKUkwv0ERrKaT8rvRK611hv_I,28941
+agnt5/exceptions.py,sha256=Nqg7CeKRu-oIj34A-2Y-QZ4YQ_TLPuin-yg8Mw7-76o,3277
+agnt5/function.py,sha256=vPNKhFCgFz4mIPVJqt0WvIWJoDgC7jXE3miEHT4LVKI,11417
+agnt5/lm.py,sha256=UKAnBTTYvJEkjqu23GEtdZ4RZiKNjDgGX5YiaOVfbq4,27348
+agnt5/tool.py,sha256=EG9ZvFbRKnJvSVcgVxtOliDMmPmUeCsdm4hiLewuvr8,21629
+agnt5/tracing.py,sha256=Mh2-OfnQM61lM_P8gxJstafdsUA8Gxoo1lP-Joxhub8,5980
+agnt5/types.py,sha256=Zb71ZMwvrt1p4SH18cAKunp2y5tao_W5_jGYaPDejQo,2840
+agnt5/version.py,sha256=rOq1mObLihnnKgKqBrwZA0zwOPudEKVFcW1a48ynkqc,573
+agnt5/worker.py,sha256=Qd71KveMyFIFVI8tpF2_8CKPXG7WwJSYNnKeNPUkn94,70555
+agnt5/workflow.py,sha256=SKsdP8fhljJq-zdwS0Q63Fmo2TEEFZduYsssXugVgiU,35632
+agnt5-0.2.8a9.dist-info/RECORD,,