agnt5 0.2.6__cp39-abi3-macosx_11_0_arm64.whl → 0.2.8a1__cp39-abi3-macosx_11_0_arm64.whl

agnt5/__init__.py

@@ -6,7 +6,7 @@ with built-in durability guarantees and state management.
 """
 
 from ._compat import _import_error, _rust_available
-from .agent import Agent, AgentRegistry, AgentResult, Handoff, agent, handoff
+from .agent import Agent, AgentContext, AgentRegistry, AgentResult, Handoff, agent, handoff
 from .client import Client, RunError
 from .context import Context
 from .function import FunctionContext
@@ -46,6 +46,7 @@ __all__ = [
     "Context",
     "FunctionContext",
     "WorkflowContext",
+    "AgentContext",
     "Client",
     "Worker",
     "function",

agnt5/agent.py

@@ -23,6 +23,175 @@ logger = setup_module_logger(__name__)
 _AGENT_REGISTRY: Dict[str, "Agent"] = {}
 
 
+class AgentContext(Context):
+    """
+    Context for agent execution with conversation state management.
+
+    Extends base Context with:
+    - State management via EntityStateManager
+    - Conversation history persistence
+    - Context inheritance (child agents share parent's state)
+
+    Three initialization modes:
+    1. Standalone: Creates own state manager (playground testing)
+    2. Inherit WorkflowContext: Shares parent's state manager
+    3. Inherit parent AgentContext: Shares parent's state manager
+
+    Example:
+        ```python
+        # Standalone agent with conversation history
+        ctx = AgentContext(run_id="session-1", agent_name="tutor")
+        result = await agent.run("Hello", context=ctx)
+        result = await agent.run("Continue", context=ctx)  # Remembers previous message
+
+        # Agent in workflow - shares workflow state
+        @workflow
+        async def research_workflow(ctx: WorkflowContext):
+            agent_result = await research_agent.run("Find AI trends", context=ctx)
+            # Agent has access to workflow state via inherited context
+        ```
+    """
+
+    def __init__(
+        self,
+        run_id: str,
+        agent_name: str,
+        session_id: Optional[str] = None,
+        state_manager: Optional[Any] = None,
+        parent_context: Optional[Context] = None,
+        attempt: int = 0,
+        runtime_context: Optional[Any] = None,
+    ):
+        """
+        Initialize agent context.
+
+        Args:
+            run_id: Unique execution identifier
+            agent_name: Name of the agent
+            session_id: Session identifier for conversation history (default: run_id)
+            state_manager: Optional state manager (for context inheritance)
+            parent_context: Parent context to inherit state from
+            attempt: Retry attempt number
+            runtime_context: RuntimeContext for trace correlation
+        """
+        super().__init__(run_id, attempt, runtime_context)
+
+        self._agent_name = agent_name
+        self._session_id = session_id or run_id
+
+        # Determine state manager based on parent context
+        from .entity import EntityStateManager, _get_state_manager
+
+        if state_manager:
+            # Explicit state manager provided
+            self._state_manager = state_manager
+            logger.debug(f"AgentContext using provided state manager")
+        elif parent_context:
+            # Try to inherit state manager from parent
+            try:
+                # Check if parent is WorkflowContext or AgentContext
+                if hasattr(parent_context, '_workflow_entity'):
+                    # WorkflowContext - get state manager from worker context
+                    self._state_manager = _get_state_manager()
+                    logger.debug(f"AgentContext inheriting state from WorkflowContext")
+                elif hasattr(parent_context, '_state_manager'):
+                    # Parent AgentContext - share state manager
+                    self._state_manager = parent_context._state_manager
+                    logger.debug(f"AgentContext inheriting state from parent AgentContext")
+                else:
+                    # FunctionContext or base Context - create new state manager
+                    self._state_manager = EntityStateManager()
+                    logger.debug(f"AgentContext created new state manager (parent has no state)")
+            except RuntimeError:
+                # _get_state_manager() failed (not in worker context) - create standalone
+                self._state_manager = EntityStateManager()
+                logger.debug(f"AgentContext created standalone state manager")
+        else:
+            # Standalone - create new state manager
+            self._state_manager = EntityStateManager()
+            logger.debug(f"AgentContext created standalone state manager")
+
+        # Conversation key for state storage
+        self._conversation_key = f"agent:{agent_name}:{self._session_id}:messages"
+
+    @property
+    def state(self):
+        """
+        Get state interface for agent state management.
+
+        Returns:
+            EntityState instance for state operations
+
+        Example:
+            # Store conversation history
+            messages = ctx.state.get(f"agent:{agent_name}:{session_id}:messages", [])
+            messages.append({"role": "user", "content": "Hello"})
+            ctx.state.set(f"agent:{agent_name}:{session_id}:messages", messages)
+
+            # Store agent-specific data
+            ctx.state.set("research_results", data)
+        """
+        from .entity import EntityState
+
+        # Use agent's conversation key as the state key
+        state_key = ("agent", self._conversation_key)
+        state_dict = self._state_manager.get_or_create_state(state_key)
+        return EntityState(state_dict)
+
+    @property
+    def session_id(self) -> str:
+        """Get session identifier for this agent context."""
+        return self._session_id
+
+    def get_conversation_history(self) -> List[Message]:
+        """
+        Retrieve conversation history from state.
+
+        Returns:
+            List of Message objects from conversation history
+        """
+        messages_data = self.state.get(self._conversation_key, [])
+
+        # Convert dict representations back to Message objects
+        messages = []
+        for msg_dict in messages_data:
+            if isinstance(msg_dict, dict):
+                role = msg_dict.get("role", "user")
+                content = msg_dict.get("content", "")
+                if role == "user":
+                    messages.append(Message.user(content))
+                elif role == "assistant":
+                    messages.append(Message.assistant(content))
+                else:
+                    # Generic message - create with MessageRole enum
+                    from .lm import MessageRole
+                    msg_role = MessageRole(role) if role in ("user", "assistant", "system") else MessageRole.USER
+                    msg = Message(role=msg_role, content=content)
+                    messages.append(msg)
+            else:
+                # Already a Message object
+                messages.append(msg_dict)
+
+        return messages
+
+    def save_conversation_history(self, messages: List[Message]) -> None:
+        """
+        Save conversation history to state.
+
+        Args:
+            messages: List of Message objects to persist
+        """
+        # Convert Message objects to dict for JSON serialization
+        messages_data = []
+        for msg in messages:
+            messages_data.append({
+                "role": msg.role.value if hasattr(msg.role, 'value') else str(msg.role),
+                "content": msg.content
+            })
+
+        self.state.set(self._conversation_key, messages_data)
+
+
 class Handoff:
     """Configuration for agent-to-agent handoff.
 
@@ -463,13 +632,47 @@ class Agent:
             print(result.output)
             ```
         """
-        # Create context if not provided
+        # Create or adapt context
         if context is None:
+            # Standalone execution - create AgentContext
             import uuid
-
-            context = Context(
-                run_id=f"agent-{self.name}-{uuid.uuid4().hex[:8]}",
+            run_id = f"agent-{self.name}-{uuid.uuid4().hex[:8]}"
+            context = AgentContext(
+                run_id=run_id,
+                agent_name=self.name,
+            )
+        elif isinstance(context, AgentContext):
+            # Already AgentContext - use as-is
+            pass
+        elif hasattr(context, '_workflow_entity'):
+            # WorkflowContext - create AgentContext that inherits state
+            import uuid
+            run_id = f"{context.run_id}:agent:{self.name}"
+            context = AgentContext(
+                run_id=run_id,
+                agent_name=self.name,
+                session_id=context.run_id,  # Share workflow's session
+                parent_context=context,
             )
+        else:
+            # FunctionContext or other - create new AgentContext
+            import uuid
+            run_id = f"{context.run_id}:agent:{self.name}"
+            context = AgentContext(
+                run_id=run_id,
+                agent_name=self.name,
+            )
+
+        # Load conversation history from state (if AgentContext)
+        if isinstance(context, AgentContext):
+            messages: List[Message] = context.get_conversation_history()
+            # Add new user message
+            messages.append(Message.user(user_message))
+            # Save updated conversation
+            context.save_conversation_history(messages)
+        else:
+            # Fallback for non-AgentContext (shouldn't happen with code above)
+            messages = [Message.user(user_message)]
 
         # Create span for agent execution with trace linking
         from ._core import create_span
@@ -480,12 +683,10 @@ class Agent:
             context._runtime_context if hasattr(context, "_runtime_context") else None,
             {
                 "agent.name": self.name,
-                "agent.model": self.model,
+                "agent.model": self.model_name,  # Use model_name (always a string)
                 "agent.max_iterations": str(self.max_iterations),
             },
         ) as span:
-            # Initialize conversation
-            messages: List[Message] = [Message.user(user_message)]
             all_tool_calls: List[Dict[str, Any]] = []
 
             # Reasoning loop
@@ -508,26 +709,42 @@ class Agent:
                         "content": msg.content
                     })
 
-                # Call LLM using simplified API
-                # TODO: Support tools in lm.generate() - for now using GenerateRequest internally
-                request = GenerateRequest(
-                    model=self.model,
-                    system_prompt=self.instructions,
-                    messages=messages,
-                    tools=tool_defs if tool_defs else [],
-                )
-                request.config.temperature = self.temperature
-                if self.max_tokens:
-                    request.config.max_tokens = self.max_tokens
-                if self.top_p:
-                    request.config.top_p = self.top_p
-
-                # Create internal LM instance for generation
-                # TODO: Use model_config when provided
-                from .lm import _LanguageModel
-                provider, model_name = self.model.split('/', 1)
-                internal_lm = _LanguageModel(provider=provider.lower(), default_model=None)
-                response = await internal_lm.generate(request)
+                # Call LLM
+                # Check if we have a legacy LanguageModel instance or need to create one
+                if self._language_model is not None:
+                    # Legacy API: use provided LanguageModel instance
+                    request = GenerateRequest(
+                        model="mock-model",  # Not used by MockLanguageModel
+                        system_prompt=self.instructions,
+                        messages=messages,
+                        tools=tool_defs if tool_defs else [],
+                    )
+                    request.config.temperature = self.temperature
+                    if self.max_tokens:
+                        request.config.max_tokens = self.max_tokens
+                    if self.top_p:
+                        request.config.top_p = self.top_p
+                    response = await self._language_model.generate(request)
+                else:
+                    # New API: model is a string, create internal LM instance
+                    request = GenerateRequest(
+                        model=self.model,
+                        system_prompt=self.instructions,
+                        messages=messages,
+                        tools=tool_defs if tool_defs else [],
+                    )
+                    request.config.temperature = self.temperature
+                    if self.max_tokens:
+                        request.config.max_tokens = self.max_tokens
+                    if self.top_p:
+                        request.config.top_p = self.top_p
+
+                    # Create internal LM instance for generation
+                    # TODO: Use model_config when provided
+                    from .lm import _LanguageModel
+                    provider, model_name = self.model.split('/', 1)
+                    internal_lm = _LanguageModel(provider=provider.lower(), default_model=None)
+                    response = await internal_lm.generate(request)
 
                 # Add assistant response to messages
                 messages.append(Message.assistant(response.text))
@@ -576,6 +793,9 @@ class Agent:
                                         f"Handoff detected to '{result['to_agent']}', "
                                         f"terminating current agent"
                                     )
+                                    # Save conversation before returning
+                                    if isinstance(context, AgentContext):
+                                        context.save_conversation_history(messages)
                                     # Return immediately with handoff result
                                     return AgentResult(
                                         output=result["output"],
@@ -613,6 +833,9 @@ class Agent:
                 else:
                     # No tool calls - agent is done
                     self.logger.debug(f"Agent completed after {iteration + 1} iterations")
+                    # Save conversation before returning
+                    if isinstance(context, AgentContext):
+                        context.save_conversation_history(messages)
                     return AgentResult(
                         output=response.text,
                         tool_calls=all_tool_calls,
@@ -622,68 +845,15 @@ class Agent:
             # Max iterations reached
             self.logger.warning(f"Agent reached max iterations ({self.max_iterations})")
             final_output = messages[-1].content if messages else "No output generated"
+            # Save conversation before returning
+            if isinstance(context, AgentContext):
+                context.save_conversation_history(messages)
             return AgentResult(
                 output=final_output,
                 tool_calls=all_tool_calls,
                 context=context,
             )
 
-    async def chat(
-        self,
-        user_message: str,
-        messages: List[Message],
-        context: Optional[Context] = None,
-    ) -> tuple[str, List[Message]]:
-        """Continue multi-turn conversation.
-
-        Args:
-            user_message: New user message
-            messages: Previous conversation messages
-            context: Optional context
-
-        Returns:
-            Tuple of (assistant_response, updated_messages)
-
-        Example:
-            ```python
-            messages = []
-            response, messages = await agent.chat("Hello", messages)
-            response, messages = await agent.chat("Tell me more", messages)
-            ```
-        """
-        if context is None:
-            import uuid
-
-            context = Context(
-                run_id=f"agent-chat-{self.name}-{uuid.uuid4().hex[:8]}",
-            )
-
-        # Add user message
-        conversation = messages + [Message.user(user_message)]
-
-        # Build request (no tools for simple chat)
-        request = GenerateRequest(
-            model=self.model,
-            system_prompt=self.instructions,
-            messages=conversation,
-        )
-        request.config.temperature = self.temperature
-        if self.max_tokens:
-            request.config.max_tokens = self.max_tokens
-        if self.top_p:
-            request.config.top_p = self.top_p
-
-        # Create internal LM instance for generation
-        from .lm import _LanguageModel
-        provider, model_name = self.model.split('/', 1)
-        internal_lm = _LanguageModel(provider=provider.lower(), default_model=None)
-        response = await internal_lm.generate(request)
-
-        # Add assistant response
-        conversation.append(Message.assistant(response.text))
-
-        return response.text, conversation
-
 
 def agent(
     _func: Optional[Callable] = None,

agnt5/entity.py

@@ -6,7 +6,8 @@ import asyncio
 import contextvars
 import functools
 import inspect
-from typing import Any, Dict, Optional, Tuple
+import json
+from typing import Any, Dict, Optional, Tuple, get_type_hints
 
 from ._schema_utils import extract_function_metadata, extract_function_schemas
 from .exceptions import ExecutionError
@@ -230,6 +231,108 @@ def create_entity_context():
     return manager, token
 
 
+def extract_state_schema(entity_class: type) -> Optional[Dict[str, Any]]:
+    """
+    Extract JSON schema from entity class for state structure documentation.
+
+    The schema can be provided in multiple ways (in order of preference):
+    1. Explicit _state_schema class attribute (most explicit)
+    2. Docstring with state description
+    3. Type annotations on __init__ method (least explicit, basic types only)
+
+    Args:
+        entity_class: The Entity subclass to extract schema from
+
+    Returns:
+        JSON schema dict or None if no schema could be extracted
+
+    Examples:
+        # Option 1: Explicit schema (recommended)
+        class ShoppingCart(Entity):
+            _state_schema = {
+                "type": "object",
+                "properties": {
+                    "items": {"type": "array", "description": "Cart items"},
+                    "total": {"type": "number", "description": "Cart total"}
+                },
+                "description": "Shopping cart state"
+            }
+
+        # Option 2: Docstring
+        class ShoppingCart(Entity):
+            '''
+            Shopping cart entity.
+
+            State:
+                items (list): List of cart items
+                total (float): Total cart value
+            '''
+
+        # Option 3: Type hints (basic extraction)
+        class ShoppingCart(Entity):
+            def __init__(self, key: str):
+                super().__init__(key)
+                self.items: list = []
+                self.total: float = 0.0
+    """
+    # Option 1: Check for explicit _state_schema attribute
+    if hasattr(entity_class, '_state_schema'):
+        schema = entity_class._state_schema
+        logger.debug(f"Found explicit _state_schema for {entity_class.__name__}")
+        return schema
+
+    # Option 2: Extract from docstring (basic parsing)
+    if entity_class.__doc__:
+        doc = entity_class.__doc__.strip()
+        if "State:" in doc or "state:" in doc.lower():
+            # Found state documentation - create basic schema
+            logger.debug(f"Found state documentation in docstring for {entity_class.__name__}")
+            return {
+                "type": "object",
+                "description": f"State structure for {entity_class.__name__} (see docstring for details)"
+            }
+
+    # Option 3: Try to extract from __init__ type hints (very basic)
+    try:
+        init_method = entity_class.__init__
+        type_hints = get_type_hints(init_method)
+        # Remove 'key' and 'return' from hints
+        state_hints = {k: v for k, v in type_hints.items() if k not in ('key', 'return')}
+
+        if state_hints:
+            logger.debug(f"Extracted type hints from __init__ for {entity_class.__name__}")
+            properties = {}
+            for name, type_hint in state_hints.items():
+                # Basic type mapping
+                if type_hint == str:
+                    properties[name] = {"type": "string"}
+                elif type_hint == int:
+                    properties[name] = {"type": "integer"}
+                elif type_hint == float:
+                    properties[name] = {"type": "number"}
+                elif type_hint == bool:
+                    properties[name] = {"type": "boolean"}
+                elif type_hint == list or str(type_hint).startswith('list'):
+                    properties[name] = {"type": "array"}
+                elif type_hint == dict or str(type_hint).startswith('dict'):
+                    properties[name] = {"type": "object"}
+                else:
+                    properties[name] = {"type": "object", "description": str(type_hint)}
+
+            if properties:
+                return {
+                    "type": "object",
+                    "properties": properties,
+                    "description": f"State structure inferred from type hints for {entity_class.__name__}"
+                }
+    except Exception as e:
+        logger.debug(f"Could not extract type hints from {entity_class.__name__}: {e}")
+
+    # No schema could be extracted
+    logger.debug(f"No state schema found for {entity_class.__name__}")
+    return None
+
+
 class EntityRegistry:
     """Registry for entity types."""
 
@@ -262,7 +365,7 @@ class EntityType:
     """
     Metadata about an Entity class.
 
-    Stores entity name, method schemas, and metadata for Worker auto-discovery
+    Stores entity name, method schemas, state schema, and metadata for Worker auto-discovery
     and platform integration. Created automatically when Entity subclasses are defined.
     """
 
@@ -278,8 +381,50 @@ class EntityType:
         self.entity_class = entity_class
         self._method_schemas: Dict[str, Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]] = {}
         self._method_metadata: Dict[str, Dict[str, str]] = {}
+        self._state_schema: Optional[Dict[str, Any]] = None
         logger.debug("Created entity type: %s", name)
 
+    def set_state_schema(self, schema: Optional[Dict[str, Any]]) -> None:
+        """
+        Set the state schema for this entity type.
+
+        Args:
+            schema: JSON schema describing the entity's state structure
+        """
+        self._state_schema = schema
+        if schema:
+            logger.debug(f"Set state schema for {self.name}")
+
+    def build_entity_definition(self) -> Dict[str, Any]:
+        """
+        Build complete entity definition for platform registration.
+
+        Returns:
+            Dictionary with entity name, state schema, and method schemas
+        """
+        # Build method schemas dict
+        method_schemas = {}
+        for method_name, (input_schema, output_schema) in self._method_schemas.items():
+            method_metadata = self._method_metadata.get(method_name, {})
+            method_schemas[method_name] = {
+                "input_schema": input_schema,
+                "output_schema": output_schema,
+                "description": method_metadata.get("description", ""),
+                "metadata": method_metadata
+            }
+
+        # Build complete definition
+        definition = {
+            "entity_name": self.name,
+            "methods": method_schemas
+        }
+
+        # Add state schema if available
+        if self._state_schema:
+            definition["state_schema"] = self._state_schema
+
+        return definition
+
 
 # ============================================================================
 # Class-Based Entity API (Cloudflare Durable Objects style)
@@ -507,9 +652,10 @@ class Entity:
         Auto-register Entity subclasses and wrap methods.
 
         This is called automatically when a class inherits from Entity.
-        It performs two tasks:
-        1. Wraps all public async methods with single-writer consistency
-        2. Registers the entity type with metadata for platform discovery
+        It performs three tasks:
+        1. Extracts state schema from the class
+        2. Wraps all public async methods with single-writer consistency
+        3. Registers the entity type with metadata for platform discovery
         """
         super().__init_subclass__(**kwargs)
 
@@ -524,6 +670,12 @@ class Entity:
         # Create an EntityType for this class, storing the class reference
         entity_type = EntityType(cls.__name__, entity_class=cls)
 
+        # Extract and set state schema
+        state_schema = extract_state_schema(cls)
+        if state_schema:
+            entity_type.set_state_schema(state_schema)
+            logger.debug(f"Extracted state schema for {cls.__name__}")
+
         # Wrap all public async methods and register them
         for name, method in inspect.getmembers(cls, predicate=inspect.iscoroutinefunction):
             if not name.startswith('_'):

agnt5/worker.py

@@ -484,18 +484,13 @@ class Worker:
                 logger.warning(f"Entity '{entity_class.__name__}' not found in EntityRegistry")
                 continue
 
-            method_schemas = {}
-            for method_name, (input_schema, output_schema) in entity_type._method_schemas.items():
-                method_metadata = entity_type._method_metadata.get(method_name, {})
-                method_schemas[method_name] = {
-                    "input_schema": input_schema,
-                    "output_schema": output_schema,
-                    "metadata": method_metadata
-                }
+            # Build complete entity definition with state schema and method schemas
+            entity_definition = entity_type.build_entity_definition()
+            definition_str = json.dumps(entity_definition)
 
+            # Keep minimal metadata for backward compatibility
             metadata_dict = {
                 "methods": json.dumps(list(entity_type._method_schemas.keys())),
-                "method_schemas": json.dumps(method_schemas)
             }
 
             component_info = self._PyComponentInfo(
@@ -503,14 +498,21 @@ class Worker:
                 component_type="entity",
                 metadata=metadata_dict,
                 config={},
-                input_schema=None,
+                input_schema=None,  # Entities don't have single input/output schemas
                 output_schema=None,
-                definition=None,
+                definition=definition_str,  # Complete entity definition with state and methods
             )
             components.append(component_info)
+            logger.debug(f"Registered entity '{entity_type.name}' with definition")
 
         # Process agents
+        from .agent import AgentRegistry
+
         for agent in self._explicit_components['agents']:
+            # Register agent in AgentRegistry for execution lookup
+            AgentRegistry.register(agent)
+            logger.debug(f"Registered agent '{agent.name}' in AgentRegistry for execution")
+
             input_schema_str = json.dumps(agent.input_schema) if hasattr(agent, 'input_schema') and agent.input_schema else None
             output_schema_str = json.dumps(agent.output_schema) if hasattr(agent, 'output_schema') and agent.output_schema else None
 

{agnt5-0.2.6.dist-info → agnt5-0.2.8a1.dist-info}/METADATA

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

{agnt5-0.2.6.dist-info → agnt5-0.2.8a1.dist-info}/RECORD

@@ -1,15 +1,15 @@
-agnt5-0.2.6.dist-info/METADATA,sha256=VoL7dDFb9P5ojrU2jUC4r3_qFDea7idhZEJNOUKVdyY,994
-agnt5-0.2.6.dist-info/WHEEL,sha256=vpqC0tRn_8bTHidvtrPbrnFQPZnrhuKzsjDdeKwCd58,102
-agnt5/__init__.py,sha256=NAziyM0ZKahdzqAP2edFHTbVHYVdIjEGXm0oEHdmiuo,2011
+agnt5-0.2.8a1.dist-info/METADATA,sha256=Qfmo_iWziCmMnenHYNKS9y6kPZE1xrAsXMUHQFzDvo4,996
+agnt5-0.2.8a1.dist-info/WHEEL,sha256=vpqC0tRn_8bTHidvtrPbrnFQPZnrhuKzsjDdeKwCd58,102
+agnt5/__init__.py,sha256=Cscbhye6pA8Jp-sKBGfP4kYXElUdF6aOSHVf-7ph4Dg,2045
 agnt5/_compat.py,sha256=BGuy3v5VDOHVa5f3Z-C22iMN19lAt0mPmXwF3qSSWxI,369
-agnt5/_core.abi3.so,sha256=5nl1dY6TIBSVkfyWKayn0q21kS_pnYOLLehBjEiBSCk,11945360
+agnt5/_core.abi3.so,sha256=rHU0ct25UO6rVguUM79qPt60O_r3P_6qLzz9ADZhYMI,11970304
 agnt5/_retry_utils.py,sha256=loHsWY5BR4wZy57IzcDEjQAy88DHVwVIr25Cn1d9GPA,5801
 agnt5/_schema_utils.py,sha256=MR67RW757T4Oq2Jqf4kB61H_b51zwaf3CLWELnkngRo,9572
 agnt5/_telemetry.py,sha256=bIY9AvBRjJBTHoBPbfR6X1OgaiUf-T0vCoi0_snsWXA,5957
-agnt5/agent.py,sha256=I4KqlW02ssRZ3js2lxhQR7_kqhV60GHFqxje88cWhM4,28837
+agnt5/agent.py,sha256=cz9gDB6c-eRJhBihEIuvTnNBwonpH6G8lbm44j_DKgA,36704
 agnt5/client.py,sha256=kXksazgxdVXWaG9OkjJA4cWruNtcS-ENhtnkrIdw-Nk,23212
 agnt5/context.py,sha256=S2OzPkhn_jnqSWfT21mSYOux8vHaLKQxcAvggZDHQek,2378
-agnt5/entity.py,sha256=dhdxXUxED79u3OlX9yw-2TLCC9VqBcJqES2kx-fDChs,19041
+agnt5/entity.py,sha256=jMnSRTv6MNlK05cJ0FWYQR89ZTz_ywtVuwv-Sjr2Jfc,24925
 agnt5/exceptions.py,sha256=mZ0q-NK6OKhYxgwBJpIbgpgzk-CJaFIHDbp1EE-pS7I,925
 agnt5/function.py,sha256=f1vaAlJRwuo8cxCOGEd8XPido00mOhlPS8UJJx-6hJI,11041
 agnt5/lm.py,sha256=9dFjd6eQ3f3lFZe7H7rWZherYiP_58MT1F5xpwD8PCg,23195
@@ -17,6 +17,6 @@ agnt5/tool.py,sha256=uc4L-Q9QyLzQDe-MZKk2Wo3o5e-mK8tfaQwVDgQdouQ,13133
 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=GWskOXOmho_HZdhwAhimIWDHfT809Y3h1W_8s8UKt-w,46244
+agnt5/worker.py,sha256=fWC_N2yP5BlE0W7p0MXFfnQH5OBMU94lyEuImOhBwQI,46470
 agnt5/workflow.py,sha256=sU8Gk7unxE_Gla7Fe-KlXfcBvYa2326GciuoR26CCr0,19585
-agnt5-0.2.6.dist-info/RECORD,,
+agnt5-0.2.8a1.dist-info/RECORD,,