agnt5 0.2.5__cp39-abi3-macosx_11_0_arm64.whl → 0.2.6__cp39-abi3-macosx_11_0_arm64.whl

agnt5/__init__.py

@@ -32,7 +32,7 @@ from .tool import Tool, ToolRegistry, tool
 from .types import BackoffPolicy, BackoffType, FunctionConfig, RetryPolicy, WorkflowConfig
 from .version import _get_version
 from .worker import Worker
-from .workflow import WorkflowRegistry, chatflow, workflow
+from .workflow import WorkflowRegistry, workflow
 
 # Expose simplified language model API (recommended)
 from . import lm
@@ -57,7 +57,6 @@ __all__ = [
     "with_entity_context",
     "create_entity_context",
     "workflow",
-    "chatflow",
     "WorkflowRegistry",
     "tool",
     "Tool",

agnt5/agent.py

@@ -13,7 +13,7 @@ from typing import Any, Callable, Dict, List, Optional
 
 from .context import Context
 from . import lm
-from .lm import GenerateRequest, GenerateResponse, Message, ModelConfig, ToolDefinition
+from .lm import GenerateRequest, GenerateResponse, LanguageModel, Message, ModelConfig, ToolDefinition
 from .tool import Tool, ToolRegistry
 from ._telemetry import setup_module_logger
 
@@ -201,7 +201,7 @@ class Agent:
     def __init__(
         self,
         name: str,
-        model: str,
+        model: Any,  # Can be string like "openai/gpt-4o-mini" OR LanguageModel instance
         instructions: str,
         tools: Optional[List[Any]] = None,
         handoffs: Optional[List[Handoff]] = None,
@@ -210,12 +210,13 @@ class Agent:
         top_p: Optional[float] = None,
         model_config: Optional[ModelConfig] = None,
         max_iterations: int = 10,
+        model_name: Optional[str] = None,  # For backwards compatibility with tests
     ):
         """Initialize agent.
 
         Args:
             name: Agent name/identifier
-            model: Model string with provider prefix (e.g., "openai/gpt-4o-mini")
+            model: Model string with provider prefix (e.g., "openai/gpt-4o-mini") OR LanguageModel instance
             instructions: System instructions for the agent
             tools: List of tools available to the agent (functions, Tool instances, or Agent instances)
             handoffs: List of Handoff configurations for agent-to-agent delegation
@@ -224,9 +225,9 @@ class Agent:
             top_p: Nucleus sampling parameter
             model_config: Optional advanced configuration (custom endpoints, headers, etc.)
             max_iterations: Maximum reasoning iterations
+            model_name: Optional model name (for backwards compatibility, used when model is a LanguageModel instance)
         """
         self.name = name
-        self.model = model
         self.instructions = instructions
         self.temperature = temperature
         self.max_tokens = max_tokens
@@ -234,6 +235,20 @@ class Agent:
         self.model_config = model_config
         self.max_iterations = max_iterations
 
+        # Support both string model names and LanguageModel instances
+        if isinstance(model, str):
+            # New API: model is a string like "openai/gpt-4o-mini"
+            self.model = model
+            self.model_name = model_name or model
+            self._language_model = None  # Will create on demand
+        elif isinstance(model, LanguageModel):
+            # Old API (for tests): model is a LanguageModel instance
+            self._language_model = model
+            self.model = model  # Keep for backwards compatibility
+            self.model_name = model_name or "mock-model"
+        else:
+            raise TypeError(f"model must be a string or LanguageModel instance, got {type(model)}")
+
         # Store handoffs for building handoff tools
         self.handoffs = handoffs or []
 

agnt5/lm.py

@@ -33,6 +33,7 @@ Supported Providers (via model prefix):
 from __future__ import annotations
 
 import json
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any, AsyncIterator, Dict, List, Optional
@@ -211,9 +212,44 @@ class GenerateRequest:
     response_schema: Optional[str] = None  # JSON-encoded schema for structured output
 
 
+# Abstract base class for language models
+# This exists primarily for testing/mocking purposes
+class LanguageModel(ABC):
+    """Abstract base class for language model implementations.
+
+    This class defines the interface that all language models must implement.
+    It's primarily used for testing and mocking, as production code should use
+    the module-level generate() and stream() functions instead.
+    """
+
+    @abstractmethod
+    async def generate(self, request: GenerateRequest) -> GenerateResponse:
+        """Generate completion from LLM.
+
+        Args:
+            request: Generation request with model, messages, and configuration
+
+        Returns:
+            GenerateResponse with text, usage, and optional tool calls
+        """
+        pass
+
+    @abstractmethod
+    async def stream(self, request: GenerateRequest) -> AsyncIterator[str]:
+        """Stream completion from LLM.
+
+        Args:
+            request: Generation request with model, messages, and configuration
+
+        Yields:
+            Text chunks as they are generated
+        """
+        pass
+
+
 # Internal wrapper for the Rust-backed implementation
 # Users should use the module-level generate() and stream() functions instead
-class _LanguageModel:
+class _LanguageModel(LanguageModel):
     """Internal Language Model wrapper using Rust SDK core.
 
     This class is for internal use only. Users should use the module-level

agnt5/worker.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import contextvars
 import logging
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from .function import FunctionRegistry
 from .workflow import WorkflowRegistry
@@ -57,8 +57,29 @@ class Worker:
         coordinator_endpoint: Optional[str] = None,
         runtime: str = "standalone",
         metadata: Optional[Dict[str, str]] = None,
+        # Explicit component registration (hybrid approach)
+        functions: Optional[List] = None,
+        workflows: Optional[List] = None,
+        entities: Optional[List] = None,
+        agents: Optional[List] = None,
+        tools: Optional[List] = None,
+        # Auto-registration (development mode)
+        auto_register: bool = False,
+        auto_register_paths: Optional[List[str]] = None,
+        pyproject_path: Optional[str] = None,
     ):
-        """Initialize a new Worker.
+        """Initialize a new Worker with explicit or automatic component registration.
+
+        The Worker supports two registration modes:
+
+        **Explicit Mode (default, production):**
+        - Register workflows/agents explicitly, their dependencies are auto-included
+        - Optionally register standalone functions/tools for direct API invocation
+
+        **Auto-Registration Mode (development):**
+        - Automatically discovers all decorated components in source paths
+        - Reads source paths from pyproject.toml or uses explicit paths
+        - No need to maintain import lists
 
         Args:
             service_name: Unique name for this service
@@ -66,6 +87,40 @@ class Worker:
             coordinator_endpoint: Coordinator endpoint URL (default: from env AGNT5_COORDINATOR_ENDPOINT)
             runtime: Runtime type - "standalone", "docker", "kubernetes", etc.
             metadata: Optional service-level metadata
+            functions: List of @function decorated handlers (explicit mode)
+            workflows: List of @workflow decorated handlers (explicit mode)
+            entities: List of Entity classes (explicit mode)
+            agents: List of Agent instances (explicit mode)
+            tools: List of Tool instances (explicit mode)
+            auto_register: Enable automatic component discovery (default: False)
+            auto_register_paths: Explicit source paths to scan (overrides pyproject.toml discovery)
+            pyproject_path: Path to pyproject.toml (default: current directory)
+
+        Example (explicit mode - production):
+            ```python
+            from agnt5 import Worker
+            from my_service import greet_user, order_fulfillment, ShoppingCart, analyst_agent
+
+            worker = Worker(
+                service_name="my-service",
+                workflows=[order_fulfillment],
+                entities=[ShoppingCart],
+                agents=[analyst_agent],
+                functions=[greet_user],
+            )
+            await worker.run()
+            ```
+
+        Example (auto-register mode - development):
+            ```python
+            from agnt5 import Worker
+
+            worker = Worker(
+                service_name="my-service",
+                auto_register=True,  # Discovers from pyproject.toml
+            )
+            await worker.run()
+            ```
         """
         self.service_name = service_name
         self.service_version = service_version
@@ -99,36 +154,298 @@ class Worker:
         from .entity import EntityStateManager
         self._entity_state_manager = EntityStateManager()
 
+        # Component registration: auto-discover or explicit
+        if auto_register:
+            # Auto-registration mode: discover from source paths
+            if auto_register_paths:
+                source_paths = auto_register_paths
+                logger.info(f"Auto-registration with explicit paths: {source_paths}")
+            else:
+                source_paths = self._discover_source_paths(pyproject_path)
+                logger.info(f"Auto-registration with discovered paths: {source_paths}")
+
+            # Auto-discover components (will populate _explicit_components)
+            self._auto_discover_components(source_paths)
+        else:
+            # Explicit registration from constructor kwargs
+            self._explicit_components = {
+                'functions': list(functions or []),
+                'workflows': list(workflows or []),
+                'entities': list(entities or []),
+                'agents': list(agents or []),
+                'tools': list(tools or []),
+            }
+
+            # Count explicitly registered components
+            total_explicit = sum(len(v) for v in self._explicit_components.values())
+            logger.info(
+                f"Worker initialized: {service_name} v{service_version} (runtime: {runtime}), "
+                f"{total_explicit} components explicitly registered"
+            )
+
+    def register_components(
+        self,
+        functions=None,
+        workflows=None,
+        entities=None,
+        agents=None,
+        tools=None,
+    ):
+        """Register additional components after Worker initialization.
+
+        This method allows incremental registration of components after the Worker
+        has been created. Useful for conditional or dynamic component registration.
+
+        Args:
+            functions: List of functions decorated with @function
+            workflows: List of workflows decorated with @workflow
+            entities: List of entity classes
+            agents: List of agent instances
+            tools: List of tool instances
+
+        Example:
+            ```python
+            worker = Worker(service_name="my-service")
+
+            # Register conditionally
+            if feature_enabled:
+                worker.register_components(workflows=[advanced_workflow])
+            ```
+        """
+        if functions:
+            self._explicit_components['functions'].extend(functions)
+            logger.debug(f"Incrementally registered {len(functions)} functions")
+
+        if workflows:
+            self._explicit_components['workflows'].extend(workflows)
+            logger.debug(f"Incrementally registered {len(workflows)} workflows")
+
+        if entities:
+            self._explicit_components['entities'].extend(entities)
+            logger.debug(f"Incrementally registered {len(entities)} entities")
+
+        if agents:
+            self._explicit_components['agents'].extend(agents)
+            logger.debug(f"Incrementally registered {len(agents)} agents")
+
+        if tools:
+            self._explicit_components['tools'].extend(tools)
+            logger.debug(f"Incrementally registered {len(tools)} tools")
+
+        total = sum(len(v) for v in self._explicit_components.values())
+        logger.info(f"Total components now registered: {total}")
+
+    def _discover_source_paths(self, pyproject_path: Optional[str] = None) -> List[str]:
+        """Discover source paths from pyproject.toml.
+
+        Reads pyproject.toml to find package source directories using:
+        - Hatch: [tool.hatch.build.targets.wheel] packages
+        - Maturin: [tool.maturin] python-source
+        - Fallback: ["src"] if not found
+
+        Args:
+            pyproject_path: Path to pyproject.toml (default: current directory)
+
+        Returns:
+            List of directory paths to scan (e.g., ["src/agnt5_benchmark"])
+        """
+        from pathlib import Path
+
+        # Python 3.11+ has tomllib in stdlib
+        try:
+            import tomllib
+        except ImportError:
+            logger.error("tomllib not available (Python 3.11+ required for auto-registration)")
+            return ["src"]
+
+        # Determine pyproject.toml location
+        if pyproject_path:
+            pyproject_file = Path(pyproject_path)
+        else:
+            # Look in current directory
+            pyproject_file = Path.cwd() / "pyproject.toml"
+
+        if not pyproject_file.exists():
+            logger.warning(
+                f"pyproject.toml not found at {pyproject_file}, "
+                f"defaulting to 'src/' directory"
+            )
+            return ["src"]
+
+        # Parse pyproject.toml
+        try:
+            with open(pyproject_file, "rb") as f:
+                config = tomllib.load(f)
+        except Exception as e:
+            logger.error(f"Failed to parse pyproject.toml: {e}")
+            return ["src"]
+
+        # Extract source paths based on build system
+        source_paths = []
+
+        # Try Hatch configuration
+        if "tool" in config and "hatch" in config["tool"]:
+            hatch_config = config["tool"]["hatch"]
+            if "build" in hatch_config and "targets" in hatch_config["build"]:
+                wheel_config = hatch_config["build"]["targets"].get("wheel", {})
+                packages = wheel_config.get("packages", [])
+                source_paths.extend(packages)
+
+        # Try Maturin configuration
+        if not source_paths and "tool" in config and "maturin" in config["tool"]:
+            maturin_config = config["tool"]["maturin"]
+            python_source = maturin_config.get("python-source")
+            if python_source:
+                source_paths.append(python_source)
+
+        # Fallback to src/
+        if not source_paths:
+            logger.info("No source paths in pyproject.toml, defaulting to 'src/'")
+            source_paths = ["src"]
+
+        logger.info(f"Discovered source paths from pyproject.toml: {source_paths}")
+        return source_paths
+
+    def _auto_discover_components(self, source_paths: List[str]) -> None:
+        """Auto-discover components by importing all Python files in source paths.
+
+        Args:
+            source_paths: List of directory paths to scan
+        """
+        import importlib.util
+        import sys
+        from pathlib import Path
+
+        logger.info(f"Auto-discovering components in paths: {source_paths}")
+
+        total_modules = 0
+
+        for source_path in source_paths:
+            path = Path(source_path)
+
+            if not path.exists():
+                logger.warning(f"Source path does not exist: {source_path}")
+                continue
+
+            # Recursively find all .py files
+            for py_file in path.rglob("*.py"):
+                # Skip __pycache__ and test files
+                if "__pycache__" in str(py_file) or py_file.name.startswith("test_"):
+                    continue
+
+                # Convert path to module name
+                # e.g., src/agnt5_benchmark/functions.py -> agnt5_benchmark.functions
+                relative_path = py_file.relative_to(path.parent)
+                module_parts = list(relative_path.parts[:-1])  # Remove .py extension part
+                module_parts.append(relative_path.stem)  # Add filename without .py
+                module_name = ".".join(module_parts)
+
+                # Import module (triggers decorators)
+                try:
+                    if module_name in sys.modules:
+                        logger.debug(f"Module already imported: {module_name}")
+                    else:
+                        spec = importlib.util.spec_from_file_location(module_name, py_file)
+                        if spec and spec.loader:
+                            module = importlib.util.module_from_spec(spec)
+                            sys.modules[module_name] = module
+                            spec.loader.exec_module(module)
+                            logger.debug(f"Auto-imported: {module_name}")
+                            total_modules += 1
+                except Exception as e:
+                    logger.warning(f"Failed to import {module_name}: {e}")
+
+        logger.info(f"Auto-imported {total_modules} modules")
+
+        # Collect components from registries
+        from .agent import AgentRegistry
+        from .entity import EntityRegistry
+        from .tool import ToolRegistry
+
+        # Extract actual objects from registries
+        functions = [cfg.handler for cfg in FunctionRegistry.all().values()]
+        workflows = [cfg.handler for cfg in WorkflowRegistry.all().values()]
+        entities = [et.entity_class for et in EntityRegistry.all().values()]
+        agents = list(AgentRegistry.all().values())
+        tools = list(ToolRegistry.all().values())
+
+        self._explicit_components = {
+            'functions': functions,
+            'workflows': workflows,
+            'entities': entities,
+            'agents': agents,
+            'tools': tools,
+        }
+
         logger.info(
-            f"Worker initialized: {service_name} v{service_version} (runtime: {runtime})"
+            f"Auto-discovered components: "
+            f"{len(functions)} functions, "
+            f"{len(workflows)} workflows, "
+            f"{len(entities)} entities, "
+            f"{len(agents)} agents, "
+            f"{len(tools)} tools"
         )
 
     def _discover_components(self):
-        """Discover all registered components across all registries."""
+        """Discover explicit components and auto-include their dependencies.
+
+        Hybrid approach:
+        - Explicitly registered workflows/agents are processed
+        - Functions called by workflows are auto-included (TODO: implement)
+        - Tools used by agents are auto-included
+        - Standalone functions/tools can be explicitly registered
+
+        Returns:
+            List of PyComponentInfo instances for all components
+        """
         components = []
+        import json
 
-        # Import all registries
-        from .tool import ToolRegistry
+        # Import registries
         from .entity import EntityRegistry
-        from .agent import AgentRegistry
+        from .tool import ToolRegistry
 
-        # Discover functions
-        import json
-        for name, config in FunctionRegistry.all().items():
-            # Serialize schemas to JSON strings
-            input_schema_str = None
-            if config.input_schema:
-                input_schema_str = json.dumps(config.input_schema)
+        # Track all components (explicit + auto-included)
+        all_functions = set(self._explicit_components['functions'])
+        all_tools = set(self._explicit_components['tools'])
+
+        # Auto-include agent tool dependencies
+        for agent in self._explicit_components['agents']:
+            if hasattr(agent, 'tools') and agent.tools:
+                # Agent.tools is a dict of {tool_name: tool_instance}
+                all_tools.update(agent.tools.values())
+                logger.debug(
+                    f"Auto-included {len(agent.tools)} tools from agent '{agent.name}'"
+                )
+
+        # Log registration summary
+        explicit_func_count = len(self._explicit_components['functions'])
+        explicit_tool_count = len(self._explicit_components['tools'])
+        auto_func_count = len(all_functions) - explicit_func_count
+        auto_tool_count = len(all_tools) - explicit_tool_count
+
+        logger.info(
+            f"Component registration summary: "
+            f"{len(all_functions)} functions ({explicit_func_count} explicit, {auto_func_count} auto-included), "
+            f"{len(self._explicit_components['workflows'])} workflows, "
+            f"{len(self._explicit_components['entities'])} entities, "
+            f"{len(self._explicit_components['agents'])} agents, "
+            f"{len(all_tools)} tools ({explicit_tool_count} explicit, {auto_tool_count} auto-included)"
+        )
 
-            output_schema_str = None
-            if config.output_schema:
-                output_schema_str = json.dumps(config.output_schema)
+        # Process functions (explicit + auto-included)
+        for func in all_functions:
+            config = FunctionRegistry.get(func.__name__)
+            if not config:
+                logger.warning(f"Function '{func.__name__}' not found in FunctionRegistry")
+                continue
 
-            # Get metadata with description
+            input_schema_str = json.dumps(config.input_schema) if config.input_schema else None
+            output_schema_str = json.dumps(config.output_schema) if config.output_schema else None
             metadata = config.metadata if config.metadata else {}
 
             component_info = self._PyComponentInfo(
-                name=name,
+                name=config.name,
                 component_type="function",
                 metadata=metadata,
                 config={},
@@ -137,24 +454,20 @@ class Worker:
                 definition=None,
             )
             components.append(component_info)
-            logger.debug(f"Discovered function: {name}")
-
-        # Discover workflows
-        for name, config in WorkflowRegistry.all().items():
-            # Serialize schemas to JSON strings
-            input_schema_str = None
-            if config.input_schema:
-                input_schema_str = json.dumps(config.input_schema)
 
-            output_schema_str = None
-            if config.output_schema:
-                output_schema_str = json.dumps(config.output_schema)
+        # Process workflows
+        for workflow in self._explicit_components['workflows']:
+            config = WorkflowRegistry.get(workflow.__name__)
+            if not config:
+                logger.warning(f"Workflow '{workflow.__name__}' not found in WorkflowRegistry")
+                continue
 
-            # Get metadata with description
+            input_schema_str = json.dumps(config.input_schema) if config.input_schema else None
+            output_schema_str = json.dumps(config.output_schema) if config.output_schema else None
             metadata = config.metadata if config.metadata else {}
 
             component_info = self._PyComponentInfo(
-                name=name,
+                name=config.name,
                 component_type="workflow",
                 metadata=metadata,
                 config={},
@@ -163,34 +476,14 @@ class Worker:
                 definition=None,
             )
             components.append(component_info)
-            logger.debug(f"Discovered workflow: {name}")
-
-        # Discover tools
-        for name, tool in ToolRegistry.all().items():
-            # Serialize schemas to JSON strings
-            input_schema_str = None
-            if hasattr(tool, 'input_schema') and tool.input_schema:
-                input_schema_str = json.dumps(tool.input_schema)
-
-            output_schema_str = None
-            if hasattr(tool, 'output_schema') and tool.output_schema:
-                output_schema_str = json.dumps(tool.output_schema)
 
-            component_info = self._PyComponentInfo(
-                name=name,
-                component_type="tool",
-                metadata={},
-                config={},
-                input_schema=input_schema_str,
-                output_schema=output_schema_str,
-                definition=None,
-            )
-            components.append(component_info)
-            logger.debug(f"Discovered tool: {name}")
+        # Process entities
+        for entity_class in self._explicit_components['entities']:
+            entity_type = EntityRegistry.get(entity_class.__name__)
+            if not entity_type:
+                logger.warning(f"Entity '{entity_class.__name__}' not found in EntityRegistry")
+                continue
 
-        # Discover entities
-        for name, entity_type in EntityRegistry.all().items():
-            # Build method schemas and metadata for each method
             method_schemas = {}
             for method_name, (input_schema, output_schema) in entity_type._method_schemas.items():
                 method_metadata = entity_type._method_metadata.get(method_name, {})
@@ -200,43 +493,33 @@ class Worker:
                     "metadata": method_metadata
                 }
 
-            # Build metadata dict with methods list and schemas
             metadata_dict = {
                 "methods": json.dumps(list(entity_type._method_schemas.keys())),
                 "method_schemas": json.dumps(method_schemas)
             }
 
             component_info = self._PyComponentInfo(
-                name=name,
+                name=entity_type.name,
                 component_type="entity",
                 metadata=metadata_dict,
                 config={},
-                input_schema=None,  # Entities have per-method schemas in metadata
+                input_schema=None,
                 output_schema=None,
                 definition=None,
             )
             components.append(component_info)
-            logger.debug(f"Discovered entity: {name} with methods: {list(entity_type._method_schemas.keys())}")
 
-        # Discover agents
-        for name, agent in AgentRegistry.all().items():
-            # Serialize schemas to JSON strings
-            input_schema_str = None
-            if hasattr(agent, 'input_schema') and agent.input_schema:
-                input_schema_str = json.dumps(agent.input_schema)
+        # Process agents
+        for agent in self._explicit_components['agents']:
+            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
 
-            output_schema_str = None
-            if hasattr(agent, 'output_schema') and agent.output_schema:
-                output_schema_str = json.dumps(agent.output_schema)
-
-            # Get metadata (includes description and model info)
             metadata_dict = agent.metadata if hasattr(agent, 'metadata') else {}
-            # Add tools list to metadata
             if hasattr(agent, 'tools'):
                 metadata_dict["tools"] = json.dumps(list(agent.tools.keys()))
 
             component_info = self._PyComponentInfo(
-                name=name,
+                name=agent.name,
                 component_type="agent",
                 metadata=metadata_dict,
                 config={},
@@ -245,9 +528,24 @@ class Worker:
                 definition=None,
             )
             components.append(component_info)
-            logger.debug(f"Discovered agent: {name}")
 
-        logger.info(f"Discovered {len(components)} components")
+        # Process tools (explicit + auto-included)
+        for tool in all_tools:
+            input_schema_str = json.dumps(tool.input_schema) if hasattr(tool, 'input_schema') and tool.input_schema else None
+            output_schema_str = json.dumps(tool.output_schema) if hasattr(tool, 'output_schema') and tool.output_schema else None
+
+            component_info = self._PyComponentInfo(
+                name=tool.name,
+                component_type="tool",
+                metadata={},
+                config={},
+                input_schema=input_schema_str,
+                output_schema=output_schema_str,
+                definition=None,
+            )
+            components.append(component_info)
+
+        logger.info(f"Discovered {len(components)} total components")
         return components
 
     def _create_message_handler(self):

agnt5/workflow.py

@@ -463,6 +463,7 @@ def workflow(
     _func: Optional[Callable[..., Any]] = None,
     *,
     name: Optional[str] = None,
+    chat: bool = False,
 ) -> Callable[..., Any]:
     """
     Decorator to mark a function as an AGNT5 durable workflow.
@@ -472,8 +473,9 @@ def workflow(
 
     Args:
         name: Custom workflow name (default: function's __name__)
+        chat: Enable chat mode for multi-turn conversation workflows (default: False)
 
-    Example:
+    Example (standard workflow):
         @workflow
         async def process_order(ctx: WorkflowContext, order_id: str) -> dict:
             # Durable state - survives crashes
@@ -491,104 +493,10 @@ def workflow(
 
             ctx.state.set("status", "completed")
             return {"status": ctx.state.get("status")}
-    """
-
-    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
-        # Get workflow name
-        workflow_name = name or func.__name__
-
-        # Validate function signature
-        sig = inspect.signature(func)
-        params = list(sig.parameters.values())
-
-        if not params or params[0].name != "ctx":
-            raise ValueError(
-                f"Workflow '{workflow_name}' must have 'ctx: WorkflowContext' as first parameter"
-            )
-
-        # Convert sync to async if needed
-        if inspect.iscoroutinefunction(func):
-            handler_func = cast(HandlerFunc, func)
-        else:
-            # Wrap sync function in async
-            @functools.wraps(func)
-            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
-                return func(*args, **kwargs)
-
-            handler_func = cast(HandlerFunc, async_wrapper)
-
-        # Extract schemas from type hints
-        input_schema, output_schema = extract_function_schemas(func)
-
-        # Extract metadata (description, etc.)
-        metadata = extract_function_metadata(func)
-
-        # Register workflow
-        config = WorkflowConfig(
-            name=workflow_name,
-            handler=handler_func,
-            input_schema=input_schema,
-            output_schema=output_schema,
-            metadata=metadata,
-        )
-        WorkflowRegistry.register(config)
-
-        # Create wrapper that provides context
-        @functools.wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> Any:
-            # Create WorkflowEntity and WorkflowContext if not provided
-            if not args or not isinstance(args[0], WorkflowContext):
-                # Auto-create workflow entity and context for direct workflow calls
-                run_id = f"workflow-{uuid.uuid4().hex[:8]}"
-
-                # Create WorkflowEntity to manage state
-                workflow_entity = WorkflowEntity(run_id=run_id)
-
-                # Create WorkflowContext that wraps the entity
-                ctx = WorkflowContext(
-                    workflow_entity=workflow_entity,
-                    run_id=run_id,
-                )
-
-                # Execute workflow
-                return await handler_func(ctx, *args, **kwargs)
-            else:
-                # WorkflowContext provided - use it
-                return await handler_func(*args, **kwargs)
-
-        # Store config on wrapper for introspection
-        wrapper._agnt5_config = config  # type: ignore
-        return wrapper
 
-    # Handle both @workflow and @workflow(...) syntax
-    if _func is None:
-        return decorator
-    else:
-        return decorator(_func)
-
-
-def chatflow(
-    _func: Optional[Callable[..., Any]] = None,
-    *,
-    name: Optional[str] = None,
-) -> Callable[..., Any]:
-    """
-    Decorator to mark a function as an AGNT5 chat-enabled workflow.
-
-    Identical to @workflow but adds metadata {"chat": "true"} to indicate
-    this workflow is designed for multi-turn conversation scenarios.
-
-    The platform can use this metadata to:
-    - Enable session affinity and sticky routing
-    - Apply conversation-specific optimizations
-    - Track chat-specific metrics (turn count, conversation length)
-
-    Args:
-        name: Custom workflow name (default: function's __name__)
-
-    Example:
-        @chatflow
-        async def customer_support_chat(ctx: WorkflowContext, message: str) -> dict:
+    Example (chat workflow):
+        @workflow(chat=True)
+        async def customer_support(ctx: WorkflowContext, message: str) -> dict:
             # Initialize conversation state
             if not ctx.state.get("messages"):
                 ctx.state.set("messages", [])
@@ -618,7 +526,7 @@ def chatflow(
 
         if not params or params[0].name != "ctx":
             raise ValueError(
-                f"Chatflow '{workflow_name}' must have 'ctx: WorkflowContext' as first parameter"
+                f"Workflow '{workflow_name}' must have 'ctx: WorkflowContext' as first parameter"
             )
 
         # Convert sync to async if needed
@@ -638,10 +546,11 @@ def chatflow(
         # Extract metadata (description, etc.)
         metadata = extract_function_metadata(func)
 
-        # Add chat metadata - THIS IS THE KEY DIFFERENCE FROM @workflow
-        metadata["chat"] = "true"
+        # Add chat metadata if chat mode is enabled
+        if chat:
+            metadata["chat"] = "true"
 
-        # Register as workflow (chatflows are workflows with chat metadata)
+        # Register workflow
         config = WorkflowConfig(
             name=workflow_name,
             handler=handler_func,
@@ -656,8 +565,8 @@ def chatflow(
         async def wrapper(*args: Any, **kwargs: Any) -> Any:
             # Create WorkflowEntity and WorkflowContext if not provided
             if not args or not isinstance(args[0], WorkflowContext):
-                # Auto-create workflow entity and context for direct chatflow calls
-                run_id = f"chatflow-{uuid.uuid4().hex[:8]}"
+                # Auto-create workflow entity and context for direct workflow calls
+                run_id = f"workflow-{uuid.uuid4().hex[:8]}"
 
                 # Create WorkflowEntity to manage state
                 workflow_entity = WorkflowEntity(run_id=run_id)
@@ -668,7 +577,7 @@ def chatflow(
                     run_id=run_id,
                 )
 
-                # Execute chatflow
+                # Execute workflow
                 return await handler_func(ctx, *args, **kwargs)
             else:
                 # WorkflowContext provided - use it
@@ -678,8 +587,10 @@ def chatflow(
         wrapper._agnt5_config = config  # type: ignore
         return wrapper
 
-    # Handle both @chatflow and @chatflow(...) syntax
+    # Handle both @workflow and @workflow(...) syntax
     if _func is None:
         return decorator
     else:
         return decorator(_func)
+
+

{agnt5-0.2.5.dist-info → agnt5-0.2.6.dist-info}/METADATA

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

{agnt5-0.2.5.dist-info → agnt5-0.2.6.dist-info}/RECORD

@@ -1,22 +1,22 @@
-agnt5-0.2.5.dist-info/METADATA,sha256=zHVYaWjmmQbnDeJvr59rQNan70yGDUzjKg4cyPLfGr8,994
-agnt5-0.2.5.dist-info/WHEEL,sha256=vpqC0tRn_8bTHidvtrPbrnFQPZnrhuKzsjDdeKwCd58,102
-agnt5/__init__.py,sha256=XUixnW140lI-_9h1rLtN4jBWXIDL3EgnM7jmiNzGrYk,2037
+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/_compat.py,sha256=BGuy3v5VDOHVa5f3Z-C22iMN19lAt0mPmXwF3qSSWxI,369
-agnt5/_core.abi3.so,sha256=HGQaXAplREgIbUBvtNhmrmHyTkDfh3inERsj90LiSVM,11928992
+agnt5/_core.abi3.so,sha256=5nl1dY6TIBSVkfyWKayn0q21kS_pnYOLLehBjEiBSCk,11945360
 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=BAhYHKD5YuZXhNZaqeoN7EXKTtzF8OPhCJhpcWQS1YM,27837
+agnt5/agent.py,sha256=I4KqlW02ssRZ3js2lxhQR7_kqhV60GHFqxje88cWhM4,28837
 agnt5/client.py,sha256=kXksazgxdVXWaG9OkjJA4cWruNtcS-ENhtnkrIdw-Nk,23212
 agnt5/context.py,sha256=S2OzPkhn_jnqSWfT21mSYOux8vHaLKQxcAvggZDHQek,2378
 agnt5/entity.py,sha256=dhdxXUxED79u3OlX9yw-2TLCC9VqBcJqES2kx-fDChs,19041
 agnt5/exceptions.py,sha256=mZ0q-NK6OKhYxgwBJpIbgpgzk-CJaFIHDbp1EE-pS7I,925
 agnt5/function.py,sha256=f1vaAlJRwuo8cxCOGEd8XPido00mOhlPS8UJJx-6hJI,11041
-agnt5/lm.py,sha256=1ufT0TGj_Ra1FXCflgxKfMh1qPQ_DV9p7BLlZGWI4m4,22062
+agnt5/lm.py,sha256=9dFjd6eQ3f3lFZe7H7rWZherYiP_58MT1F5xpwD8PCg,23195
 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=_BnqqqvQE16FuezFbPda9FoiKAwcezSaxxNjU0rTjhs,33576
-agnt5/workflow.py,sha256=GGCyt34W1DTSL8zjcj54qI7SA6Fn3HyQZ1XcMTlCMdI,22748
-agnt5-0.2.5.dist-info/RECORD,,
+agnt5/worker.py,sha256=GWskOXOmho_HZdhwAhimIWDHfT809Y3h1W_8s8UKt-w,46244
+agnt5/workflow.py,sha256=sU8Gk7unxE_Gla7Fe-KlXfcBvYa2326GciuoR26CCr0,19585
+agnt5-0.2.6.dist-info/RECORD,,