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

agentpool/messaging/message_history.py

@@ -6,10 +6,11 @@ import asyncio
 from collections import deque
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
+import json
 from typing import TYPE_CHECKING, Any, Self, assert_never
 from uuid import UUID, uuid4
 
-from psygnal import Signal
+from anyenv.signals import Signal
 from upathtools import read_path, to_upath
 
 from agentpool.log import get_logger
@@ -24,6 +25,7 @@ if TYPE_CHECKING:
     from datetime import datetime
     from types import TracebackType
 
+    from fsspec.asyn import AsyncFileSystem
     from pydantic_ai import UserContent
     from toprompt import AnyPromptType
     from upathtools import JoinablePathLike
@@ -48,7 +50,7 @@ class MessageHistory:
         session_id: str
         timestamp: datetime = field(default_factory=get_now)
 
-    history_cleared = Signal(HistoryCleared)
+    history_cleared = Signal[HistoryCleared]()
 
     def __init__(
         self,
@@ -94,6 +96,14 @@ class MessageHistory:
         # Note: max_messages and max_tokens will be handled in add_message/get_history
         # to maintain the rolling window during conversation
 
+        # Filesystem for message history
+        from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+        from fsspec.implementations.memory import MemoryFileSystem
+
+        self._memory_fs = MemoryFileSystem()
+        self._fs = AsyncFileSystemWrapper(self._memory_fs)
+        self._fs_initialized = False
+
     @property
     def storage(self) -> StorageManager:
         return self._storage
@@ -150,17 +160,20 @@ class MessageHistory:
         self,
         *,
         max_tokens: int | None = None,
-        include_system: bool = False,
         format_template: str | None = None,
-        num_messages: int | None = None,  # Add this parameter
+        num_messages: int | None = None,
     ) -> str:
         """Format conversation history as a single context message.
 
         Args:
             max_tokens: Optional limit to include only last N tokens
-            include_system: Whether to include system messages
             format_template: Optional custom format (defaults to agent/message pairs)
             num_messages: Optional limit to include only last N messages
+
+        Note:
+            System prompts are stored as metadata (ModelRequest.instructions),
+            not as separate messages with role="system". ChatMessage.role only
+            supports "user" and "assistant".
         """
         template = format_template or "Agent {agent}: {content}\n"
         messages: list[str] = []
@@ -323,14 +336,14 @@ class MessageHistory:
         self.chat_messages.clear()
         self.chat_messages.extend(history)
 
-    def clear(self) -> None:
+    async def clear(self) -> None:
         """Clear conversation history and prompts."""
         from agentpool.messaging import ChatMessageList
 
         self.chat_messages = ChatMessageList()
         self._last_messages = []
         event = self.HistoryCleared(session_id=str(self.id))
-        self.history_cleared.emit(event)
+        await self.history_cleared.emit(event)
 
     @asynccontextmanager
     async def temporary_state(
@@ -489,12 +502,78 @@ class MessageHistory:
             return None
         return self.chat_messages[-1].message_id
 
+    def _update_filesystem(self) -> None:
+        """Update filesystem with current message history."""
+        # Clear existing files
+        self._memory_fs.store.clear()
+        self._memory_fs.pseudo_dirs.clear()
+
+        # Create directory structure
+        self._memory_fs.makedirs("messages", exist_ok=True)
+        self._memory_fs.makedirs("by_role", exist_ok=True)
+
+        for msg in self.chat_messages:
+            # Format: {timestamp}_{role}_{message_id}
+            timestamp = msg.timestamp.strftime("%Y%m%d_%H%M%S_%f")
+            base_name = f"{timestamp}_{msg.role}_{msg.message_id}"
+
+            # Write message content
+            content_path = f"messages/{base_name}.txt"
+            content = str(msg.content)
+            self._memory_fs.pipe(content_path, content.encode("utf-8"))
+
+            # Write metadata
+            metadata = {
+                "message_id": msg.message_id,
+                "role": msg.role,
+                "timestamp": msg.timestamp.isoformat(),
+                "parent_id": msg.parent_id,
+                "model_name": msg.model_name,
+                "tokens": msg.usage.total_tokens if msg.usage else None,
+                "cost": float(msg.cost_info.total_cost) if msg.cost_info else None,
+            }
+            metadata_path = f"messages/{base_name}.json"
+            self._memory_fs.pipe(metadata_path, json.dumps(metadata, indent=2).encode("utf-8"))
+
+            # Create role-based directory symlinks (by storing paths)
+            role_dir = f"by_role/{msg.role}"
+            self._memory_fs.makedirs(role_dir, exist_ok=True)
+
+        # Write summary
+        summary = {
+            "session_id": self.id,
+            "total_messages": len(self.chat_messages),
+            "total_tokens": self.get_history_tokens(),
+            "total_cost": self.chat_messages.get_total_cost(),
+            "roles": {
+                "user": len([m for m in self.chat_messages if m.role == "user"]),
+                "assistant": len([m for m in self.chat_messages if m.role == "assistant"]),
+            },
+        }
+        self._memory_fs.pipe("summary.json", json.dumps(summary, indent=2).encode("utf-8"))
+
+        self._fs_initialized = True
+
+    def get_fs(self) -> AsyncFileSystem:
+        """Get filesystem view of message history.
+
+        Returns:
+            AsyncFileSystem containing:
+            - messages/{timestamp}_{role}_{message_id}.txt - Message content
+            - messages/{timestamp}_{role}_{message_id}.json - Message metadata
+            - by_role/{role}/ - Messages organized by role
+            - summary.json - Conversation statistics
+        """
+        # Update filesystem on access
+        self._update_filesystem()
+        return self._fs
+
 
 if __name__ == "__main__":
     from agentpool import Agent
 
     async def main() -> None:
-        async with Agent() as agent:
+        async with Agent(model="openai:gpt-5-nano") as agent:
             await agent.conversation.add_context_from_path("E:/mcp_zed.yml")
             print(agent.conversation.get_history())
 

agentpool/messaging/messagenode.py

@@ -5,9 +5,8 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Literal, Self, overload
-from uuid import uuid4
 
-from psygnal import Signal
+from anyenv.signals import Signal
 
 from agentpool.log import get_logger
 from agentpool.messaging import ChatMessage
@@ -20,8 +19,8 @@ if TYPE_CHECKING:
     from datetime import timedelta
     from types import TracebackType
 
-    from evented.configs import EventConfig
     from evented.event_data import EventData
+    from evented_config import EventConfig
 
     from agentpool.common_types import (
         AnyTransformFn,
@@ -34,7 +33,7 @@ if TYPE_CHECKING:
     from agentpool.storage import StorageManager
     from agentpool.talk import Talk, TeamTalk
     from agentpool.talk.stats import AggregatedMessageStats, MessageStats
-    from agentpool.tools.base import Tool
+    from agentpool.tools.base import FunctionTool
     from agentpool_config.forward_targets import ConnectionType
     from agentpool_config.mcp_server import MCPServerConfig
 
@@ -45,10 +44,10 @@ logger = get_logger(__name__)
 class MessageNode[TDeps, TResult](ABC):
     """Base class for all message processing nodes."""
 
-    message_received = Signal(ChatMessage)
+    message_received = Signal[ChatMessage[Any]]()
     """Signal emitted when node receives a message."""
 
-    message_sent = Signal(ChatMessage)
+    message_sent = Signal[ChatMessage[Any]]()
     """Signal emitted when node creates a message."""
 
     def __init__(
@@ -86,18 +85,33 @@ class MessageNode[TDeps, TResult](ABC):
         name_ = f"node_{self._name}"
         self.mcp = MCPManager(name_, servers=mcp_servers, owner=self.name)
         self.enable_db_logging = enable_logging
-        self.conversation_id = str(uuid4())
-        # Connect to the combined signal to capture all messages
-        # TODO: need to check this
-        # node.message_received.connect(self.log_message)
+        self.conversation_id: str | None = None
+        self.conversation_title: str | None = None
 
-    async def __aenter__(self) -> Self:
-        """Initialize base message node."""
-        if self.enable_db_logging and self.storage:
+    def _set_conversation_title(self, title: str) -> None:
+        """Callback for setting conversation title (called by storage manager)."""
+        self.conversation_title = title
+
+    async def log_conversation(self, initial_prompt: str | None = None) -> None:
+        """Log conversation to storage if enabled.
+
+        Should be called at the start of run_stream() after conversation_id is set.
+        For native agents, generate conversation_id first with uuid4().
+        For wrapped agents (Claude Code), set conversation_id from SDK session first.
+
+        Args:
+            initial_prompt: Optional initial prompt to trigger title generation.
+        """
+        if self.enable_db_logging and self.storage and self.conversation_id:
             await self.storage.log_conversation(
                 conversation_id=self.conversation_id,
                 node_name=self.name,
+                initial_prompt=initial_prompt,
+                on_title_generated=self._set_conversation_title,
             )
+
+    async def __aenter__(self) -> Self:
+        """Initialize base message node."""
         try:
             await self._events.__aenter__()
             await self.mcp.__aenter__()
@@ -161,7 +175,7 @@ class MessageNode[TDeps, TResult](ABC):
 
     def to_tool(
         self, *, name: str | None = None, description: str | None = None, **kwargs: Any
-    ) -> Tool[TResult]:
+    ) -> FunctionTool[TResult]:
         """Convert node to a callable tool.
 
         Args:
@@ -354,6 +368,30 @@ class MessageNode[TDeps, TResult](ABC):
     async def run(self, *prompts: Any, **kwargs: Any) -> ChatMessage[TResult]:
         """Execute node with prompts. Implementation-specific run logic."""
 
+    async def run_message(
+        self,
+        message: ChatMessage[Any],
+        **kwargs: Any,
+    ) -> ChatMessage[TResult]:
+        """Run with an incoming ChatMessage (e.g., from Talk routing).
+
+        Extracts content from the message, preserves conversation_id,
+        and sets parent_id to track the message chain.
+
+        Args:
+            message: The incoming ChatMessage to process
+            **kwargs: Additional arguments passed to run()
+
+        Returns:
+            Response ChatMessage with message chain tracked via parent_id
+        """
+        return await self.run(
+            message.content,
+            conversation_id=message.conversation_id,
+            parent_id=message.message_id,
+            **kwargs,
+        )
+
     async def get_message_history(self, limit: int | None = None) -> list[ChatMessage[Any]]:
         """Get message history from storage."""
         from agentpool_config.session import SessionQuery

agentpool/messaging/messages.py

@@ -72,9 +72,7 @@ Metadata:
   {{ key }}: {{ value }}
 {%- endfor %}
 {%- endif %}
-{%- if forwarded_from %}
-Forwarded via: {{ forwarded_from|join(' -> ') }}
-{%- endif %}"""
+"""
 
 MARKDOWN_TEMPLATE = """## {{ name or role.title() }}
 *{{ timestamp.strftime('%Y-%m-%d %H:%M:%S') }}*
@@ -98,10 +96,7 @@ MARKDOWN_TEMPLATE = """## {{ name or role.title() }}
 ```
 {%- endif %}
 
-{% if forwarded_from %}
-
-*Forwarded via: {{ forwarded_from|join(' → ') }}*
-{% endif %}"""
+"""
 
 MESSAGE_TEMPLATES = {
     "simple": SIMPLE_TEMPLATE,
@@ -216,9 +211,6 @@ class ChatMessage[TContent]:
     name: str | None = None
     """Display name for the message sender in UI."""
 
-    forwarded_from: list[str] = field(default_factory=list)
-    """List of agent names (the chain) that forwarded this message to the sender."""
-
     provider_details: dict[str, Any] = field(default_factory=dict)
     """Provider specific metadata / extra information."""
 
@@ -335,7 +327,6 @@ class ChatMessage[TContent]:
         message: ModelMessage,
         conversation_id: str | None = None,
         name: str | None = None,
-        forwarded_from: list[str] | None = None,
         parent_id: str | None = None,
     ) -> ChatMessage[TContentType]:
         """Convert a Pydantic model to a ChatMessage."""
@@ -346,8 +337,6 @@ class ChatMessage[TContent]:
                     content=content,
                     role="user",
                     message_id=run_id or str(uuid.uuid4()),
-                    # instructions=instructions,
-                    forwarded_from=forwarded_from or [],
                     name=name,
                     parent_id=parent_id,
                 )
@@ -375,7 +364,6 @@ class ChatMessage[TContent]:
                     finish_reason=finish_reason,
                     provider_response_id=provider_response_id,
                     name=name,
-                    forwarded_from=forwarded_from or [],
                     parent_id=parent_id,
                 )
             case _ as unreachable:
@@ -443,18 +431,6 @@ class ChatMessage[TContent]:
             metadata=metadata or {},
         )
 
-    def forwarded(self, previous_message: ChatMessage[Any]) -> Self:
-        """Create new message showing it was forwarded from another message.
-
-        Args:
-            previous_message: The message that led to this one's creation
-
-        Returns:
-            New message with updated chain showing the path through previous message
-        """
-        from_ = [*previous_message.forwarded_from, previous_message.name or "unknown"]
-        return replace(self, forwarded_from=from_)
-
     @property
     def response(self) -> ModelResponse:
         """Return the last response from the message history."""

agentpool/messaging/processing.py

@@ -17,34 +17,27 @@ if TYPE_CHECKING:
 
 
 async def prepare_prompts(
-    *prompt: PromptCompatible | ChatMessage[Any],
+    *prompt: PromptCompatible,
     parent_id: str | None = None,
-) -> tuple[ChatMessage[Any], list[UserContent], ChatMessage[Any] | None]:
+    conversation_id: str | None = None,
+) -> tuple[ChatMessage[Any], list[UserContent]]:
     """Prepare prompts for processing.
 
-    Extracted from MessageNode.pre_run logic.
-
     Args:
         *prompt: The prompt(s) to prepare.
         parent_id: Optional ID of the parent message (typically the previous response).
+        conversation_id: Optional conversation ID for the user message.
 
     Returns:
         A tuple of:
-            - Either incoming message, or a constructed incoming message based
-              on the prompt(s).
+            - A ChatMessage representing the user prompt.
             - A list of prompts to be sent to the model.
-            - The original ChatMessage if forwarded, None otherwise
     """
-    if len(prompt) == 1 and isinstance(prompt[0], ChatMessage):
-        original_msg = prompt[0]
-        # Update received message's chain to show it came through its source
-        user_msg = original_msg.forwarded(original_msg).to_request()
-        prompts = await convert_prompts([user_msg.content])
-        # clear cost info to avoid double-counting
-        return user_msg, prompts, original_msg
     prompts = await convert_prompts(prompt)
-    user_msg = ChatMessage.user_prompt(message=prompts, parent_id=parent_id)
-    return user_msg, prompts, None
+    user_msg = ChatMessage.user_prompt(
+        message=prompts, parent_id=parent_id, conversation_id=conversation_id
+    )
+    return user_msg, prompts
 
 
 async def finalize_message(
@@ -52,7 +45,6 @@ async def finalize_message(
     previous_message: ChatMessage[Any] | None,
     node: MessageNode[Any, Any],
     connections: ConnectionManager,
-    original_message: ChatMessage[Any] | None,
     wait_for_connections: bool | None = None,
 ) -> ChatMessage[Any]:
     """Handle message finalization and routing.
@@ -62,16 +54,12 @@ async def finalize_message(
         previous_message: The original user message (if any)
         node: The message node that produced the message
         connections: Connection manager for routing
-        original_message: The original ChatMessage if forwarded, None otherwise
         wait_for_connections: Whether to wait for connected nodes
 
     Returns:
         The finalized message
     """
-    # For chain processing, update the response's chain if input was forwarded
-    if original_message:
-        message = message.forwarded(original_message)
-    node.message_sent.emit(message)  # Emit signals
+    await node.message_sent.emit(message)  # Emit signals
     await node.log_message(message)  # Log message if enabled
     # Route to connections
     await connections.route_message(message, wait=wait_for_connections)

agentpool/models/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from agentpool.models.acp_agents import ACPAgentConfig, ACPAgentConfigTypes, BaseACPAgentConfig
-from agentpool.models.agents import NativeAgentConfig
+from agentpool.models.agents import AnyToolConfig, NativeAgentConfig  # noqa: F401
 from agentpool.models.agui_agents import AGUIAgentConfig
 from agentpool.models.claude_code_agents import ClaudeCodeAgentConfig
 from agentpool.models.manifest import AgentsManifest, AnyAgentConfig

agentpool/models/acp_agents/base.py

@@ -7,10 +7,10 @@ import os
 import tempfile
 from typing import TYPE_CHECKING, Annotated, Any, Literal
 
-from exxec import ExecutionEnvironmentStr, get_environment  # noqa: TC002
-from exxec.configs import (
+from exxec_config import (
     E2bExecutionEnvironmentConfig,
     ExecutionEnvironmentConfig,  # noqa: TC002
+    ExecutionEnvironmentStr,  # noqa: TC002
 )
 from pydantic import ConfigDict, Field
 
@@ -223,6 +223,8 @@ class BaseACPAgentConfig(NodeConfig):
 
     def get_execution_environment(self) -> ExecutionEnvironment:
         """Create execution environment from config."""
+        from exxec import get_environment
+
         if isinstance(self.execution_environment, str):
             return get_environment(self.execution_environment)
         return self.execution_environment.get_provider()
@@ -232,6 +234,8 @@ class BaseACPAgentConfig(NodeConfig):
 
         Returns None if not configured (caller should fall back to main env).
         """
+        from exxec import get_environment
+
         if self.client_execution_environment is None:
             return None
         if isinstance(self.client_execution_environment, str):

agentpool/models/acp_agents/mcp_capable.py

@@ -9,12 +9,14 @@ import anyenv
 from pydantic import BaseModel, ConfigDict, Field
 
 from agentpool.models.acp_agents.base import BaseACPAgentConfig
+from agentpool_config import AnyToolConfig, BaseToolConfig  # noqa: TC001
 from agentpool_config.output_types import StructuredResponseConfig  # noqa: TC001
-from agentpool_config.toolsets import ToolsetConfig  # noqa: TC001
+from agentpool_config.toolsets import BaseToolsetConfig
 
 
 if TYPE_CHECKING:
     from agentpool.prompts.manager import PromptManager
+    from agentpool.resource_providers import ResourceProvider
 
 
 ClaudeCodeModelName = Literal["default", "sonnet", "opus", "haiku", "sonnet[1m]", "opusplan"]
@@ -23,6 +25,7 @@ ClaudeCodeToolName = Literal[
     "Bash",
     "BashOutput",
     "Edit",
+    "EnterPlanMode",
     "ExitPlanMode",
     "Glob",
     "Grep",
@@ -47,23 +50,51 @@ class MCPCapableACPAgentConfig(BaseACPAgentConfig):
     that can be exposed via an internal MCP bridge.
     """
 
-    toolsets: list[ToolsetConfig] = Field(
+    tools: list[AnyToolConfig | str] = Field(
         default_factory=list,
-        title="Toolsets",
+        title="Tools",
         examples=[
             [
                 {"type": "subagent"},
                 {"type": "agent_management"},
+                "webbrowser:open",
             ],
         ],
     )
-    """Toolsets to expose to this ACP agent via MCP bridge.
+    """Tools and toolsets to expose to this ACP agent via MCP bridge.
 
-    These toolsets will be started as an in-process MCP server and made
-    available to the external ACP agent. This allows ACP agents to use
-    internal agentpool toolsets like subagent delegation.
+    Supports both single tools and toolsets. These will be started as an
+    in-process MCP server and made available to the external ACP agent.
     """
 
+    def get_tool_providers(self) -> list[ResourceProvider]:
+        """Get all resource providers for this agent's tools.
+
+        Returns:
+            List of ResourceProvider instances
+        """
+        from agentpool.resource_providers import StaticResourceProvider
+        from agentpool.tools.base import Tool
+
+        providers: list[ResourceProvider] = []
+        static_tools: list[Tool] = []
+
+        for tool_config in self.tools:
+            try:
+                if isinstance(tool_config, BaseToolsetConfig):
+                    providers.append(tool_config.get_provider())
+                elif isinstance(tool_config, str):
+                    static_tools.append(Tool.from_callable(tool_config))
+                elif isinstance(tool_config, BaseToolConfig):
+                    static_tools.append(tool_config.get_tool())
+            except Exception:  # noqa: BLE001
+                continue
+
+        if static_tools:
+            providers.append(StaticResourceProvider(name="tools", tools=static_tools))
+
+        return providers
+
     def build_mcp_config_json(self) -> str | None:
         """Convert inherited mcp_servers to standard MCP config JSON format.
 
@@ -197,12 +228,12 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Additional directories to allow tool access to."""
 
-    tools: list[ClaudeCodeToolName | str] | None = Field(
+    builtin_tools: list[ClaudeCodeToolName | str] | None = Field(
         default=None,
-        title="Tools",
+        title="Built-in Tools",
         examples=[["Bash", "Edit", "Read"], []],
     )
-    """Available tools from built-in set. Empty list disables all tools."""
+    """Available tools from Claude's built-in set. Empty list disables all tools."""
 
     fallback_model: ClaudeCodeModelName | None = Field(
         default=None,
@@ -260,9 +291,9 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
             args.append("--strict-mcp-config")
         if self.add_dir:
             args.extend(["--add-dir", *self.add_dir])
-        if self.tools is not None:
-            if self.tools:
-                args.extend(["--tools", ",".join(self.tools)])
+        if self.builtin_tools is not None:
+            if self.builtin_tools:
+                args.extend(["--tools", ",".join(self.builtin_tools)])
             else:
                 args.extend(["--tools", ""])
         if self.fallback_model:
@@ -307,7 +338,7 @@ class FastAgentACPAgentConfig(MCPCapableACPAgentConfig):
             provider: fast-agent
             cwd: /path/to/project
             model: claude-3.5-sonnet-20241022
-            toolsets:
+            tools:
               - type: subagent
               - type: agent_management
             skills_dir: ./my-skills
@@ -644,7 +675,85 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
         return args
 
 
+class AgentpoolACPAgentConfig(MCPCapableACPAgentConfig):
+    """Configuration for agentpool's own ACP server.
+
+    This allows using agentpool serve-acp as an ACP agent, with MCP bridge support
+    for tool metadata preservation.
+
+    Example:
+        ```yaml
+        acp_agents:
+          my_agentpool:
+            type: agentpool
+            config_path: path/to/agent_config.yml
+            agent: agent_name  # Optional: specific agent to use
+            mcp_servers:
+              - type: stdio
+                command: mcp-server-filesystem
+                args: ["--root", "/workspace"]
+        ```
+    """
+
+    model_config = ConfigDict(title="Agentpool ACP Agent")
+
+    provider: Literal["agentpool"] = Field("agentpool", init=False)
+    """Discriminator for agentpool ACP agent."""
+
+    config_path: str | None = None
+    """Path to agentpool configuration file (optional)."""
+
+    agent: str | None = None
+    """Specific agent name to use from config (defaults to first agent)."""
+
+    file_access: bool = True
+    """Enable file system access for the agent."""
+
+    terminal_access: bool = True
+    """Enable terminal access for the agent."""
+
+    load_skills: bool = True
+    """Load client-side skills from .claude/skills directory."""
+
+    def get_command(self) -> str:
+        """Get the command to run agentpool serve-acp."""
+        return "agentpool"
+
+    async def get_args(self, prompt_manager: PromptManager | None = None) -> list[str]:
+        """Build command arguments for agentpool serve-acp."""
+        args = ["serve-acp"]
+
+        # Add config path if specified
+        if self.config_path:
+            args.append(self.config_path)
+
+        # Add agent selection
+        if self.agent:
+            args.extend(["--agent", self.agent])
+
+        # Add file/terminal access flags
+        if not self.file_access:
+            args.append("--no-file-access")
+        if not self.terminal_access:
+            args.append("--no-terminal-access")
+
+        # Add skills flag
+        if not self.load_skills:
+            args.append("--no-skills")
+
+        # Convert inherited mcp_servers to --mcp-config format
+        mcp_json = self.build_mcp_config_json()
+        if mcp_json:
+            args.extend(["--mcp-config", mcp_json])
+
+        return args
+
+
 # Union of all ACP agent config types
 MCPCapableACPAgentConfigTypes = (
-    ClaudeACPAgentConfig | FastAgentACPAgentConfig | AuggieACPAgentConfig | KimiACPAgentConfig
+    ClaudeACPAgentConfig
+    | FastAgentACPAgentConfig
+    | AuggieACPAgentConfig
+    | KimiACPAgentConfig
+    | AgentpoolACPAgentConfig
 )