agnt5 0.2.8a9__cp310-abi3-manylinux_2_34_aarch64.whl → 0.3.7a4__cp310-abi3-manylinux_2_34_aarch64.whl

agnt5/__init__.py

@@ -1,91 +1,181 @@
 """
 AGNT5 Python SDK - Build durable, resilient agent-first applications.
 
-This SDK provides high-level components for building agents, tools, and workflows
-with built-in durability guarantees and state management.
+Supports functions, entities, workflows, agents, and LLM integration.
 """
 
-from ._compat import _import_error, _rust_available
-from .agent import Agent, AgentContext, AgentRegistry, AgentResult, Handoff, agent, handoff
-from .client import Client, RunError
+from . import events
+from . import lm
+from .agent import (
+    Agent,
+    AgentCompleted,
+    AgentContext,
+    AgentFailed,
+    AgentIterationCompleted,
+    AgentIterationStarted,
+    AgentRegistry,
+    AgentResult,
+    AgentStarted,
+    Handoff,
+    ToolCallCompleted,
+    ToolCallFailed,
+    ToolCallStarted,
+    agent,
+    handoff,
+)
+from .client import AsyncClient, Client, ReceivedEvent, RunError
 from .context import Context
-from .function import FunctionContext
-from .workflow import WorkflowContext
 from .entity import (
     Entity,
     EntityRegistry,
     EntityStateAdapter,
     EntityType,
+    StateType,
     create_entity_context,
+    query,
     with_entity_context,
 )
+from .events import (
+    Cancelled,
+    Completed,
+    ComponentType,
+    Delta,
+    Event,
+    EventEmitter,
+    EventEnvelope,
+    Failed,
+    LifecycleEvent,
+    OperationType,
+    OutputDelta,
+    OutputStart,
+    OutputStop,
+    Paused,
+    ProgressUpdate,
+    Resumed,
+    Started,
+    StateChanged,
+    Timeout,
+)
 from .exceptions import (
     AGNT5Error,
-    CheckpointError,
     ConfigurationError,
     ExecutionError,
     RetryError,
-    StateError,
     WaitingForUserInputException,
 )
-from .function import FunctionRegistry, function
-from .tool import AskUserTool, RequestApprovalTool, Tool, ToolRegistry, tool
-from .types import BackoffPolicy, BackoffType, FunctionConfig, RetryPolicy, WorkflowConfig
+from .function import FunctionContext, FunctionRegistry, function
+from .lm import (
+    LMCompleted,
+    LMContentBlockCompleted,
+    LMContentBlockDelta,
+    LMContentBlockStarted,
+    LMFailed,
+    LMStarted,
+)
+from .types import BackoffPolicy, BackoffType, RetryPolicy, WorkflowConfig
 from .version import _get_version
 from .worker import Worker
-from .workflow import WorkflowRegistry, workflow
+from .workflow import WorkflowContext, WorkflowRegistry, workflow
 
-# Expose simplified language model API (recommended)
-from . import lm
+from .tool import Tool, ToolRegistry, tool
+
+# Not yet enabled:
+# from .checkpoint import CheckpointClient
+# from .exceptions import CheckpointError, StateError
+# from .memory import ConversationMemory, MemoryMessage, MemoryMetadata, MemoryResult, MemoryScope, SemanticMemory
+# from .tool import AskUserTool, RequestApprovalTool
+# from .types import FunctionConfig
+# from . import _sentry as sentry
 
 __version__ = _get_version()
 
 __all__ = [
     # Version
     "__version__",
+    # Modules
+    "events",
+    "lm",
     # Core components
     "Context",
     "FunctionContext",
-    "WorkflowContext",
-    "AgentContext",
-    "Client",
     "Worker",
     "function",
     "FunctionRegistry",
+    # Entity components
     "Entity",
-    "EntityType",
     "EntityRegistry",
     "EntityStateAdapter",
-    "with_entity_context",
+    "EntityType",
+    "StateType",
     "create_entity_context",
-    "workflow",
+    "query",
+    "with_entity_context",
+    # Workflow components
+    "WorkflowContext",
     "WorkflowRegistry",
-    "tool",
-    "Tool",
-    "ToolRegistry",
-    "AskUserTool",
-    "RequestApprovalTool",
-    "agent",
+    "workflow",
+    "WorkflowConfig",
+    # Agent components
     "Agent",
+    "AgentContext",
     "AgentRegistry",
     "AgentResult",
     "Handoff",
+    "agent",
     "handoff",
+    # Tool components
+    "Tool",
+    "ToolRegistry",
+    "tool",
+    # Agent events
+    "AgentCompleted",
+    "AgentFailed",
+    "AgentIterationCompleted",
+    "AgentIterationStarted",
+    "AgentStarted",
+    "ToolCallCompleted",
+    "ToolCallFailed",
+    "ToolCallStarted",
+    # LM events
+    "LMCompleted",
+    "LMContentBlockCompleted",
+    "LMContentBlockDelta",
+    "LMContentBlockStarted",
+    "LMFailed",
+    "LMStarted",
+    # Base events
+    "Cancelled",
+    "Completed",
+    "ComponentType",
+    "Delta",
+    "Event",
+    "EventEmitter",
+    "EventEnvelope",
+    "Failed",
+    "LifecycleEvent",
+    "OperationType",
+    "OutputDelta",
+    "OutputStart",
+    "OutputStop",
+    "Paused",
+    "ProgressUpdate",
+    "Resumed",
+    "Started",
+    "StateChanged",
+    "Timeout",
+    # Client
+    "AsyncClient",
+    "Client",
+    "ReceivedEvent",
+    "RunError",
     # Types
-    "RetryPolicy",
     "BackoffPolicy",
     "BackoffType",
-    "FunctionConfig",
-    "WorkflowConfig",
+    "RetryPolicy",
     # Exceptions
     "AGNT5Error",
     "ConfigurationError",
     "ExecutionError",
     "RetryError",
-    "StateError",
-    "CheckpointError",
     "WaitingForUserInputException",
-    "RunError",
-    # Language Model (Simplified API)
-    "lm",
 ]

agnt5/_retry_utils.py

@@ -7,6 +7,7 @@ and executing functions with retry logic.
 from __future__ import annotations
 
 import asyncio
+import inspect
 from typing import Any, Dict, Optional, Union
 
 from .exceptions import RetryError
@@ -100,10 +101,11 @@ async def execute_with_retry(
     retry_policy: RetryPolicy,
     backoff_policy: BackoffPolicy,
     needs_context: bool,
+    timeout_ms: Optional[int],
     *args: Any,
     **kwargs: Any,
 ) -> Any:
-    """Execute handler with retry logic.
+    """Execute handler with retry logic and optional timeout.
 
     Args:
         handler: The function handler to execute
@@ -111,6 +113,7 @@ async def execute_with_retry(
         retry_policy: Retry configuration
         backoff_policy: Backoff configuration
         needs_context: Whether handler accepts ctx parameter
+        timeout_ms: Maximum execution time in milliseconds (None for no timeout)
         *args: Arguments to pass to handler (excluding ctx if needs_context=False)
         **kwargs: Keyword arguments to pass to handler
 
@@ -119,6 +122,7 @@ async def execute_with_retry(
 
     Raises:
         RetryError: If all retry attempts fail
+        asyncio.TimeoutError: If function execution exceeds timeout_ms
     """
     # Import here to avoid circular dependency
     from .function import FunctionContext
@@ -128,17 +132,41 @@ async def execute_with_retry(
     for attempt in range(retry_policy.max_attempts):
         try:
             # Create context for this attempt (FunctionContext is immutable)
+            # Propagate streaming context from parent for real-time SSE log delivery
             attempt_ctx = FunctionContext(
                 run_id=ctx.run_id,
+                correlation_id=getattr(ctx, 'correlation_id', f"retry-{attempt}"),
+                parent_correlation_id=getattr(ctx, 'parent_correlation_id', ctx.run_id),
                 attempt=attempt,
-                retry_policy=retry_policy
+                retry_policy=retry_policy,
+                worker=getattr(ctx, '_worker', None),
             )
 
             # Execute handler (pass context only if needed)
             if needs_context:
-                result = await handler(attempt_ctx, *args, **kwargs)
+                result = handler(attempt_ctx, *args, **kwargs)
             else:
-                result = await handler(*args, **kwargs)
+                result = handler(*args, **kwargs)
+
+            # Check if result is an async generator (streaming function)
+            # Async generators cannot be retried - return immediately for streaming consumption
+            if inspect.isasyncgen(result):
+                return result
+
+            # For coroutines, apply timeout and await
+            if inspect.iscoroutine(result):
+                if timeout_ms is not None:
+                    timeout_seconds = timeout_ms / 1000.0
+                    try:
+                        result = await asyncio.wait_for(result, timeout=timeout_seconds)
+                    except asyncio.TimeoutError:
+                        # Re-raise with more context
+                        raise asyncio.TimeoutError(
+                            f"Function execution timed out after {timeout_ms}ms"
+                        )
+                else:
+                    result = await result
+
             return result
 
         except Exception as e:

agnt5/_schema_utils.py

@@ -168,19 +168,19 @@ def _type_to_schema(python_type: Any) -> Dict[str, Any]:
         }
 
     # Handle basic types
-    if python_type == str:
+    if python_type is str:
         return {"type": "string"}
-    elif python_type == int:
+    elif python_type is int:
         return {"type": "integer"}
-    elif python_type == float:
+    elif python_type is float:
         return {"type": "number"}
-    elif python_type == bool:
+    elif python_type is bool:
         return {"type": "boolean"}
-    elif python_type == dict:
+    elif python_type is dict:
         return {"type": "object"}
-    elif python_type == list:
+    elif python_type is list:
         return {"type": "array"}
-    elif python_type == Any:
+    elif python_type is Any:
         return {}  # Any type - no restrictions
 
     # Fallback for unknown types