agentpool 2.2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool/delegation/pool.py

@@ -7,11 +7,10 @@ from asyncio import Lock
 from contextlib import AsyncExitStack, asynccontextmanager, suppress
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Self, Unpack, overload
+from typing import TYPE_CHECKING, Any, Self, Unpack, overload
 
 from anyenv import ProcessManager
 import anyio
-from llmling_models.configs.model_configs import BaseModelConfig
 from upathtools import UPath
 
 from agentpool.agents import Agent
@@ -51,21 +50,14 @@ if TYPE_CHECKING:
         AgentName,
         BuiltinEventHandlerType,
         IndividualEventHandler,
-        SessionIdType,
-        SupportsStructuredOutput,
     )
     from agentpool.delegation.base_team import BaseTeam
     from agentpool.mcp_server.tool_bridge import ToolManagerBridge
+    from agentpool.messaging import ChatMessage
     from agentpool.messaging.compaction import CompactionPipeline
-    from agentpool.models import (
-        AGUIAgentConfig,
-        AnyAgentConfig,
-        BaseACPAgentConfig,
-        ClaudeCodeAgentConfig,
-    )
+    from agentpool.models import AnyAgentConfig
     from agentpool.models.manifest import AgentsManifest
     from agentpool.ui.base import InputProvider
-    from agentpool_config.session import SessionQuery
     from agentpool_config.task import Job
 
 
@@ -111,7 +103,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             ValueError: If manifest contains invalid node configurations
             RuntimeError: If node initialization fails
         """
-        super().__init__()
         from agentpool.mcp_server.manager import MCPManager
         from agentpool.models.manifest import AgentsManifest
         from agentpool.observability import registry
@@ -119,6 +110,9 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         from agentpool.skills.manager import SkillsManager
         from agentpool.storage import StorageManager
         from agentpool.utils.streams import FileOpsTracker, TodoTracker
+        from agentpool_toolsets.builtin.debug import install_memory_handler
+
+        super().__init__()
 
         match manifest:
             case None:
@@ -132,12 +126,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
                 raise ValueError(msg)
 
         registry.configure_observability(self.manifest.observability)
-
-        # Install memory log handler early so all logs are captured
-        from agentpool_toolsets.builtin.debug import install_memory_handler
-
         self._memory_log_handler = install_memory_handler()
-
         self.shared_deps_type = shared_deps_type
         self._input_provider = input_provider
         self.exit_stack = AsyncExitStack()
@@ -156,7 +145,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         for name, task in self.manifest.jobs.items():
             self._tasks.register(name, task)
         self.process_manager = ProcessManager()
-        self.pool_talk = TeamTalk[Any].from_nodes(list(self.nodes.values()))
         self.file_ops = FileOpsTracker()
         # Todo/plan tracker for task management
         self.todos = TodoTracker()
@@ -169,7 +157,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         self._create_teams()
         if connect_nodes:
             self._connect_nodes()
-
+        self.pool_talk = TeamTalk[Any].from_nodes(list(self.nodes.values()))
         self._enter_lock = Lock()  # Initialize async safety fields
         self._running_count = 0
 
@@ -236,7 +224,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str = "pool_tools",
         host: str = "127.0.0.1",
         port: int = 0,
-        transport: Literal["sse", "streamable-http"] = "sse",
     ) -> ToolManagerBridge:
         """Create and start a tool bridge for exposing tools to external agents.
 
@@ -249,7 +236,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             name: Unique name for this bridge
             host: Host to bind the HTTP server to
             port: Port to bind to (0 = auto-select)
-            transport: Transport protocol ('sse' or 'streamable-http')
 
         Returns:
             Started ToolManagerBridge instance
@@ -277,7 +263,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         config = BridgeConfig(
             host=host,
             port=port,
-            transport=transport,
             server_name=f"agentpool-{name}",
         )
         bridge = ToolManagerBridge(node=node, config=config)
@@ -323,9 +308,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> TeamRun[TPoolDeps, TResult]: ...
 
     @overload
@@ -337,9 +319,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> TeamRun[TDeps, TResult]: ...
 
     @overload
@@ -351,9 +330,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> TeamRun[Any, TResult]: ...
 
     def create_team_run[TResult](
@@ -364,9 +340,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> TeamRun[Any, TResult]:
         """Create a a sequential TeamRun from a list of Agents.
 
@@ -376,9 +349,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             name: Optional name for the team
             description: Optional description for the team
             shared_prompt: Optional prompt for all agents
-            picker: Agent to use for picking agents
-            num_picks: Number of agents to pick
-            pick_prompt: Prompt to use for picking agents
         """
         from agentpool.delegation.teamrun import TeamRun
 
@@ -390,9 +360,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             description=description,
             validator=validator,
             shared_prompt=shared_prompt,
-            picker=picker,
-            num_picks=num_picks,
-            pick_prompt=pick_prompt,
         )
         if name:
             self[name] = team
@@ -409,9 +376,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> Team[TDeps]: ...
 
     @overload
@@ -422,9 +386,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> Team[Any]: ...
 
     def create_team(
@@ -434,9 +395,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         name: str | None = None,
         description: str | None = None,
         shared_prompt: str | None = None,
-        picker: SupportsStructuredOutput | None = None,
-        num_picks: int | None = None,
-        pick_prompt: str | None = None,
     ) -> Team[Any]:
         """Create a group from agent names or instances.
 
@@ -445,9 +403,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             name: Optional name for the team
             description: Optional description for the team
             shared_prompt: Optional prompt for all agents
-            picker: Agent to use for picking agents
-            num_picks: Number of agents to pick
-            pick_prompt: Prompt to use for picking agents
         """
         from agentpool.delegation.team import Team
 
@@ -459,9 +414,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             description=description,
             agents=[self.get_agent(i) if isinstance(i, str) else i for i in agents],
             shared_prompt=shared_prompt,
-            picker=picker,
-            num_picks=num_picks,
-            pick_prompt=pick_prompt,
         )
         if name:
             self[name] = team
@@ -633,18 +585,14 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
                     stop_condition=target.stop_condition.check if target.stop_condition else None,
                     exit_condition=target.exit_condition.check if target.exit_condition else None,
                 )
-                source.connections.set_wait_state(
-                    target_node,
-                    wait=target.wait_for_completion,
-                )
+                source.connections.set_wait_state(target_node, wait=target.wait_for_completion)
 
     @overload
     def get_agent[TResult = str](
         self,
         agent: AgentName | Agent[Any, str],
         *,
-        return_type: type[TResult] = str,  # type: ignore
-        session: SessionIdType | SessionQuery = None,
+        output_type: type[TResult] = str,  # type: ignore
     ) -> Agent[TPoolDeps, TResult]: ...
 
     @overload
@@ -653,8 +601,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         agent: AgentName | Agent[Any, str],
         *,
         deps_type: type[TCustomDeps],
-        return_type: type[TResult] = str,  # type: ignore
-        session: SessionIdType | SessionQuery = None,
+        output_type: type[TResult] = str,  # type: ignore
     ) -> Agent[TCustomDeps, TResult]: ...
 
     def get_agent(
@@ -662,8 +609,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         agent: AgentName | Agent[Any, str],
         *,
         deps_type: Any | None = None,
-        return_type: Any = str,
-        session: SessionIdType | SessionQuery = None,
+        output_type: Any = str,
     ) -> Agent[Any, Any]:
         """Get or configure an agent from the pool.
 
@@ -674,8 +620,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         Args:
             agent: Either agent name or instance
             deps_type: Optional custom dependencies type (overrides shared deps)
-            return_type: Optional type for structured responses
-            session: Optional session ID or query to recover conversation
+            output_type: Optional type for structured responses
 
         Returns:
             Either:
@@ -697,11 +642,8 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         # base.context.data = deps if deps is not None else self.shared_deps
         base.deps_type = deps_type
         base.agent_pool = self
-        if session:
-            base.conversation.load_history_from_database(session=session)
-        if return_type not in {str, None}:
-            base.to_structured(return_type)
-
+        if output_type not in {str, None}:
+            base.to_structured(output_type)
         return base
 
     def get_job(self, name: str) -> Job[Any, Any]:
@@ -780,6 +722,55 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
 
         return "\n".join(lines)
 
+    def get_message_chain(self, message: ChatMessage[Any]) -> list[str]:
+        """Get the chain of agent names that processed a message.
+
+        Reconstructs the forwarding chain by walking parent_id references
+        across all agents' conversations in the pool.
+
+        Args:
+            message: The message to trace back
+
+        Returns:
+            List of agent names in order from origin to current message's agent.
+            Empty list if message has no parent or parent not found.
+        """
+        # Build index of all messages by ID across all agents
+        message_index: dict[str, tuple[ChatMessage[Any], str]] = {}
+        for agent in self.agents.values():
+            for msg in agent.conversation.chat_messages:
+                message_index[msg.message_id] = (msg, agent.name)
+
+        # Walk back through parent_id chain
+        chain: list[str] = []
+        current_id = message.parent_id
+
+        while current_id and current_id in message_index:
+            parent_msg, agent_name = message_index[current_id]
+            # Only add agent name if it's different from previous (avoid duplicates)
+            if not chain or chain[-1] != agent_name:
+                chain.append(agent_name)
+            current_id = parent_msg.parent_id
+
+        # Reverse to get origin -> current order
+        chain.reverse()
+        return chain
+
+    def find_message_by_id(self, message_id: str) -> ChatMessage[Any] | None:
+        """Find a message by ID across all agents in the pool.
+
+        Args:
+            message_id: The message ID to search for
+
+        Returns:
+            The ChatMessage if found, None otherwise
+        """
+        for agent in self.agents.values():
+            for msg in agent.conversation.chat_messages:
+                if msg.message_id == message_id:
+                    return msg
+        return None
+
     def _create_agent_from_config[TAgentDeps](
         self,
         name: str,
@@ -807,99 +798,56 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
 
         match config:
             case NativeAgentConfig():
-                return self.create_agent(
-                    name,
-                    deps_type=deps_type,
-                    input_provider=self._input_provider,
-                    pool=self,
+                from agentpool import Agent
+
+                return Agent.from_config(
+                    config,
+                    name=name,  # Pass dict key for manifest lookups
+                    manifest=self.manifest,
                     event_handlers=self.event_handlers,
+                    input_provider=self._input_provider,
+                    agent_pool=self,
+                    deps_type=deps_type,
                 )
             case AGUIAgentConfig():
-                return self._create_agui_agent_from_config(config, deps_type)
+                from agentpool.agents.agui_agent import AGUIAgent
+
+                return AGUIAgent.from_config(
+                    config,
+                    event_handlers=self.event_handlers,
+                    agent_pool=self,
+                )
             case ClaudeCodeAgentConfig():
-                return self._create_claude_code_agent_from_config(config, deps_type)
+                from agentpool.agents.claude_code_agent import ClaudeCodeAgent
+                from agentpool.utils.result_utils import to_type
+
+                output_type: type | None = None
+                if config.output_type:
+                    output_type = to_type(config.output_type, self.manifest.responses)
+                return ClaudeCodeAgent.from_config(
+                    config,
+                    event_handlers=self.event_handlers,
+                    input_provider=self._input_provider,
+                    agent_pool=self,
+                    output_type=output_type,
+                )
             case BaseACPAgentConfig():
-                return self._create_acp_agent_from_config(config, deps_type)
+                from agentpool.agents.acp_agent import ACPAgent
+
+                return ACPAgent.from_config(
+                    config,
+                    event_handlers=self.event_handlers,
+                    agent_pool=self,
+                )
             case _:
                 msg = f"Unknown agent config type: {type(config)}"
                 raise TypeError(msg)
 
-    def _create_acp_agent_from_config[TDeps](
-        self,
-        config: BaseACPAgentConfig,
-        deps_type: type[TDeps] | None = None,
-    ) -> ACPAgent[TDeps]:
-        """Create an ACPAgent from config object."""
-        from agentpool.agents.acp_agent import ACPAgent
-
-        config_handlers = config.get_event_handlers()
-        merged_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] = [
-            *config_handlers,
-            *self.event_handlers,
-        ]
-        return ACPAgent(config=config, event_handlers=merged_handlers or None)
-
-    def _create_agui_agent_from_config[TDeps](
-        self,
-        config: AGUIAgentConfig,
-        deps_type: type[TDeps] | None = None,
-    ) -> AGUIAgent[TDeps]:
-        """Create an AGUIAgent from config object."""
-        from agentpool.agents.agui_agent import AGUIAgent
-
-        config_handlers = config.get_event_handlers()
-        merged_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] = [
-            *config_handlers,
-            *self.event_handlers,
-        ]
-        return AGUIAgent(
-            endpoint=config.endpoint,
-            name=config.name or "agui-agent",
-            description=config.description,
-            display_name=config.display_name,
-            event_handlers=merged_handlers or None,
-            timeout=config.timeout,
-            headers=config.headers,
-            startup_command=config.startup_command,
-            startup_delay=config.startup_delay,
-            tools=[tool_config.get_tool() for tool_config in config.tools],
-            mcp_servers=config.mcp_servers,
-            tool_confirmation_mode=config.requires_tool_confirmation,
-        )
-
-    def _create_claude_code_agent_from_config[TDeps, TResult](
-        self,
-        config: ClaudeCodeAgentConfig,
-        deps_type: type[TDeps] | None = None,
-    ) -> ClaudeCodeAgent[TDeps, TResult]:
-        """Create a ClaudeCodeAgent from config object."""
-        from agentpool.agents.claude_code_agent import ClaudeCodeAgent
-        from agentpool.utils.result_utils import to_type
-
-        config_handlers = config.get_event_handlers()
-        merged_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] = [
-            *config_handlers,
-            *self.event_handlers,
-        ]
-        # Resolve output type if configured
-        output_type: type | None = None
-        if config.output_type:
-            output_type = to_type(config.output_type, self.manifest.responses)
-        return ClaudeCodeAgent(
-            config=config,
-            event_handlers=merged_handlers or None,
-            input_provider=self._input_provider,
-            tool_confirmation_mode=config.requires_tool_confirmation,
-            output_type=output_type,
-            agent_pool=self,
-        )
-
     def create_agent[TAgentDeps](  # noqa: PLR0915
         self,
         name: str,
         deps_type: type[TAgentDeps] | None = None,
         input_provider: InputProvider | None = None,
-        pool: AgentPool[Any] | None = None,
         event_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] | None = None,
     ) -> Agent[TAgentDeps, Any]:
         from agentpool import Agent
@@ -980,16 +928,10 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             *config_handlers,
             *(event_handlers or []),
         ]
-        match config.model:
-            case str():
-                model: Model | str | None = config.model
-                model_settings: ModelSettings | None = None
-            case BaseModelConfig():
-                model = config.model.get_model()
-                model_settings = config.model.get_model_settings()
-            case _:
-                model = None
-                model_settings = None
+        # Resolve model (handles variants and wraps strings)
+        resolved_model = self.manifest.resolve_model(config.model)
+        model: Model | str = resolved_model.get_model()
+        model_settings: ModelSettings | None = resolved_model.get_model_settings()
         # Extract pydantic-ai builtin tools from config
         builtin_tools = config.get_builtin_tools()
 
@@ -1011,7 +953,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             input_provider=input_provider,
             output_type=resolved_output_type,
             event_handlers=merged_handlers or None,
-            agent_pool=pool,
+            agent_pool=self,
             tool_mode=config.tool_mode,
             knowledge=config.knowledge,
             toolsets=toolsets_list,
@@ -1022,109 +964,6 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
             providers=config.model_providers,
         )
 
-    def create_acp_agent[TDeps](
-        self,
-        name: str,
-        deps_type: type[TDeps] | None = None,
-    ) -> ACPAgent[TDeps]:
-        """Create an ACPAgent from configuration.
-
-        Args:
-            name: Name of the ACP agent in the manifest
-            deps_type: Optional dependency type (not used by ACP agents currently)
-
-        Returns:
-            Configured ACPAgent instance
-        """
-        from agentpool.agents.acp_agent import ACPAgent
-
-        config = self.manifest.acp_agents[name]
-        # Ensure name is set on config
-        if config.name is None:
-            config = config.model_copy(update={"name": name})
-        # Merge pool-level handlers with config-level handlers
-        config_handlers = config.get_event_handlers()
-        merged_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] = [
-            *config_handlers,
-            *self.event_handlers,
-        ]
-        return ACPAgent(config=config, event_handlers=merged_handlers or None)
-
-    def create_agui_agent[TDeps](
-        self,
-        name: str,
-        deps_type: type[TDeps] | None = None,
-    ) -> AGUIAgent[TDeps]:
-        """Create an AGUIAgent from configuration.
-
-        Args:
-            name: Name of the AG-UI agent in the manifest
-            deps_type: Optional dependency type (not used by AG-UI agents currently)
-
-        Returns:
-            Configured AGUIAgent instance
-        """
-        from agentpool.agents.agui_agent import AGUIAgent
-
-        config = self.manifest.agui_agents[name]
-        # Ensure name is set on config
-        if config.name is None:
-            config = config.model_copy(update={"name": name})
-        # Merge pool-level handlers with config-level handlers
-        config_handlers = config.get_event_handlers()
-        merged_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] = [
-            *config_handlers,
-            *self.event_handlers,
-        ]
-        return AGUIAgent(
-            endpoint=config.endpoint,
-            name=config.name or "agui-agent",
-            description=config.description,
-            display_name=config.display_name,
-            event_handlers=merged_handlers or None,
-            timeout=config.timeout,
-            headers=config.headers,
-            startup_command=config.startup_command,
-            startup_delay=config.startup_delay,
-            tools=[tool_config.get_tool() for tool_config in config.tools],
-            mcp_servers=config.mcp_servers,
-            tool_confirmation_mode=config.requires_tool_confirmation,
-        )
-
-    def create_claude_code_agent[TDeps](
-        self,
-        name: str,
-        deps_type: type[TDeps] | None = None,
-    ) -> ClaudeCodeAgent[TDeps, str]:
-        """Create a ClaudeCodeAgent from configuration.
-
-        Args:
-            name: Name of the Claude Code agent in the manifest
-            deps_type: Optional dependency type (not used by Claude Code agents currently)
-
-        Returns:
-            Configured ClaudeCodeAgent instance
-        """
-        from agentpool.agents.claude_code_agent import ClaudeCodeAgent
-
-        config = self.manifest.claude_code_agents[name]
-        # Ensure name is set on config
-        if config.name is None:
-            config = config.model_copy(update={"name": name})
-        # Merge pool-level handlers with config-level handlers
-        config_handlers = config.get_event_handlers()
-        merged_handlers: list[IndividualEventHandler | BuiltinEventHandlerType] = [
-            *config_handlers,
-            *self.event_handlers,
-        ]
-        return ClaudeCodeAgent(
-            config=config,
-            event_handlers=merged_handlers or None,
-            input_provider=self._input_provider,
-            tool_confirmation_mode=config.requires_tool_confirmation,
-            agent_pool=self,
-        )
-
 
 if __name__ == "__main__":