agentpool 2.1.9__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
@@ -40,7 +39,6 @@ if TYPE_CHECKING:
     from pydantic_ai import ModelSettings
     from pydantic_ai.models import Model
     from pydantic_ai.output import OutputSpec
-    from tokonomics.model_names import ModelId
     from upathtools import JoinablePathLike
 
     from agentpool.agents.acp_agent import ACPAgent
@@ -52,20 +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.models import (
-        AGUIAgentConfig,
-        AnyAgentConfig,
-        BaseACPAgentConfig,
-        ClaudeCodeAgentConfig,
-    )
+    from agentpool.messaging import ChatMessage
+    from agentpool.messaging.compaction import CompactionPipeline
+    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,13 +103,16 @@ 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
         from agentpool.sessions import SessionManager
         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:
@@ -131,6 +126,7 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
                 raise ValueError(msg)
 
         registry.configure_observability(self.manifest.observability)
+        self._memory_log_handler = install_memory_handler()
         self.shared_deps_type = shared_deps_type
         self._input_provider = input_provider
         self.exit_stack = AsyncExitStack()
@@ -149,22 +145,19 @@ 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()
         # Create all agents from unified manifest.agents dict
         for name, config in self.manifest.agents.items():
-            agent = self._create_agent_from_config(
-                name,
-                config,
-                deps_type=shared_deps_type,
-            )
+            agent = self._create_agent_from_config(name, config, deps_type=shared_deps_type)
             agent.agent_pool = self
             self.register(name, agent)
 
         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
 
@@ -179,32 +172,23 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
                 await self.exit_stack.enter_async_context(self.mcp)
                 await self.exit_stack.enter_async_context(self.skills)
                 aggregating_provider = self.mcp.get_aggregating_provider()
-                agents = list(self.agents.values())
-                acp_agents = list(self.acp_agents.values())
-                agui_agents = list(self.agui_agents.values())
-                claude_code_agents = list(self.claude_code_agents.values())
+                agents = list(self.all_agents.values())
                 teams = list(self.teams.values())
                 for agent in agents:
                     agent.tools.add_provider(aggregating_provider)
                 # Collect remaining components to initialize (MCP already initialized)
-                components: list[AbstractAsyncContextManager[Any]] = [
+                comps: list[AbstractAsyncContextManager[Any]] = [
                     self.storage,
                     self.sessions,
                     *agents,
-                    *acp_agents,
-                    *agui_agents,
-                    *claude_code_agents,
                     *teams,
                 ]
-                # MCP server is now managed externally - removed from pool
-                # Initialize all components
+                node_inits = [self.exit_stack.enter_async_context(c) for c in comps]
                 if self.parallel_load:
-                    await asyncio.gather(
-                        *(self.exit_stack.enter_async_context(c) for c in components)
-                    )
+                    await asyncio.gather(*node_inits)
                 else:
-                    for component in components:
-                        await self.exit_stack.enter_async_context(component)
+                    for init in node_inits:
+                        await init
 
             except Exception as e:
                 await self.cleanup()
@@ -240,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.
 
@@ -253,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
@@ -281,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)
@@ -327,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
@@ -341,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
@@ -355,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](
@@ -368,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.
 
@@ -380,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
 
@@ -394,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
@@ -413,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
@@ -426,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(
@@ -438,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.
 
@@ -449,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
 
@@ -463,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
@@ -538,6 +486,15 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
 
         return {i.name: i for i in self._items.values() if isinstance(i, MessageNode)}
 
+    @property
+    def compaction_pipeline(self) -> CompactionPipeline | None:
+        """Get the configured compaction pipeline for message history management.
+
+        Returns:
+            CompactionPipeline instance or None if not configured
+        """
+        return self.manifest.get_compaction_pipeline()
+
     def _validate_item(self, item: MessageNode[Any, Any] | Any) -> MessageNode[Any, Any]:
         """Validate and convert items before registration.
 
@@ -628,19 +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
-        model_override: ModelId | str | None = None,
-        session: SessionIdType | SessionQuery = None,
+        output_type: type[TResult] = str,  # type: ignore
     ) -> Agent[TPoolDeps, TResult]: ...
 
     @overload
@@ -649,9 +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
-        model_override: ModelId | str | None = None,
-        session: SessionIdType | SessionQuery = None,
+        output_type: type[TResult] = str,  # type: ignore
     ) -> Agent[TCustomDeps, TResult]: ...
 
     def get_agent(
@@ -659,9 +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,
-        model_override: ModelId | str | None = None,
-        session: SessionIdType | SessionQuery = None,
+        output_type: Any = str,
     ) -> Agent[Any, Any]:
         """Get or configure an agent from the pool.
 
@@ -672,9 +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
-            model_override: Optional model override
-            session: Optional session ID or query to recover conversation
+            output_type: Optional type for structured responses
 
         Returns:
             Either:
@@ -684,6 +630,10 @@ class AgentPool[TPoolDeps = None](BaseRegistry[NodeName, MessageNode[Any, Any]])
         Raises:
             KeyError: If agent name not found
             ValueError: If configuration is invalid
+
+        Note:
+            To change the model, call `await agent.set_model(model_id)` after
+            getting the agent.
         """
         from agentpool.agents import Agent
 
@@ -692,13 +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 model_override:
-            base.set_model(model_override)
-        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]:
@@ -777,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,
@@ -804,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
@@ -977,16 +928,13 @@ 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()
+
         return Agent(
             # context=context,
             model=model,
@@ -1005,116 +953,15 @@ 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,
-            auto_cache=config.auto_cache,
             hooks=config.hooks.get_agent_hooks() if config.hooks else None,
             tool_confirmation_mode=config.requires_tool_confirmation,
-        )
-
-    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,
+            builtin_tools=builtin_tools or None,
+            usage_limits=config.usage_limits,
+            providers=config.model_providers,
         )