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

agentpool/messaging/message_history.py

@@ -477,6 +477,18 @@ class MessageHistory:
         # Use cost_info if available
         return self.chat_messages.get_history_tokens()
 
+    def get_last_message_id(self) -> str | None:
+        """Get the message_id of the last message in history.
+
+        Used for setting parent_id on new messages to build the message tree.
+
+        Returns:
+            The message_id of the last message, or None if history is empty.
+        """
+        if not self.chat_messages:
+            return None
+        return self.chat_messages[-1].message_id
+
 
 if __name__ == "__main__":
     from agentpool import Agent

agentpool/messaging/messages.py

@@ -30,6 +30,7 @@ from agentpool.common_types import MessageRole, SimpleJsonType  # noqa: TC001
 from agentpool.log import get_logger
 from agentpool.utils.inspection import dataclasses_no_defaults_repr
 from agentpool.utils.now import get_now
+from agentpool.utils.pydantic_ai_helpers import safe_args_as_dict
 
 
 if TYPE_CHECKING:
@@ -198,6 +199,14 @@ class ChatMessage[TContent]:
     conversation_id: str | None = None
     """ID of the conversation this message belongs to."""
 
+    parent_id: str | None = None
+    """ID of the parent message for tree-structured conversations.
+
+    This enables branching conversations where each message knows its predecessor.
+    For user messages, this typically points to the previous assistant response.
+    For assistant responses, this points to the user message being responded to.
+    """
+
     response_time: float | None = None
     """Time it took the LLM to respond."""
 
@@ -295,12 +304,29 @@ class ChatMessage[TContent]:
         message: TPromptContent,
         conversation_id: str | None = None,
         instructions: str | None = None,
+        parent_id: str | None = None,
     ) -> ChatMessage[TPromptContent]:
-        """Create a user prompt message."""
+        """Create a user prompt message.
+
+        Args:
+            message: The prompt content
+            conversation_id: ID of the conversation
+            instructions: Optional instructions for the model
+            parent_id: ID of the parent message (typically the previous assistant response)
+
+        Returns:
+            A ChatMessage representing the user prompt
+        """
         part = UserPromptPart(content=message)
         request = ModelRequest(parts=[part], instructions=instructions)
         id_ = conversation_id or str(uuid4())
-        return ChatMessage(messages=[request], role="user", content=message, conversation_id=id_)
+        return ChatMessage(
+            messages=[request],
+            role="user",
+            content=message,
+            conversation_id=id_,
+            parent_id=parent_id,
+        )
 
     @classmethod
     def from_pydantic_ai[TContentType](
@@ -310,6 +336,7 @@ class ChatMessage[TContent]:
         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."""
         match message:
@@ -322,6 +349,7 @@ class ChatMessage[TContent]:
                     # instructions=instructions,
                     forwarded_from=forwarded_from or [],
                     name=name,
+                    parent_id=parent_id,
                 )
             case ModelResponse(
                 usage=usage,
@@ -348,6 +376,7 @@ class ChatMessage[TContent]:
                     provider_response_id=provider_response_id,
                     name=name,
                     forwarded_from=forwarded_from or [],
+                    parent_id=parent_id,
                 )
             case _ as unreachable:
                 assert_never(unreachable)
@@ -360,7 +389,9 @@ class ChatMessage[TContent]:
         agent_name: str | None = None,
         message_id: str | None = None,
         conversation_id: str | None = None,
+        parent_id: str | None = None,
         response_time: float,
+        metadata: SimpleJsonType | None = None,
     ) -> ChatMessage[OutputDataT]:
         """Create a ChatMessage from a PydanticAI run result.
 
@@ -369,19 +400,29 @@ class ChatMessage[TContent]:
             agent_name: Name of the agent that generated this response
             message_id: Unique message identifier
             conversation_id: Conversation identifier
+            parent_id: ID of the parent message (typically the user message)
             response_time: Total time taken for the response
+            metadata: Optional metadata to attach to the message
 
         Returns:
             A ChatMessage with all fields populated from the result
         """
-        # Calculate costs
+        # Calculate costs - prefer provider-reported cost if available
         run_usage = result.usage()
         usage = result.response.usage
-        cost_info = await TokenCost.from_usage(
-            model=result.response.model_name or "",
-            usage=run_usage,
-            provider=result.response.provider_name,
-        )
+        provider_cost = (result.response.provider_details or {}).get("cost")
+        if provider_cost is not None:
+            # Use actual cost from provider (e.g., OpenRouter returns this)
+            cost_info: TokenCost | None = TokenCost(
+                token_usage=run_usage, total_cost=Decimal(str(provider_cost))
+            )
+        else:
+            # Fall back to calculated cost
+            cost_info = await TokenCost.from_usage(
+                model=result.response.model_name or "",
+                usage=run_usage,
+                provider=result.response.provider_name,
+            )
 
         return ChatMessage[OutputDataT](
             content=result.output,
@@ -395,9 +436,11 @@ class ChatMessage[TContent]:
             provider_name=result.response.provider_name,
             message_id=message_id or str(uuid4()),
             conversation_id=conversation_id,
+            parent_id=parent_id,
             cost_info=cost_info,
             response_time=response_time,
             provider_details={},
+            metadata=metadata or {},
         )
 
     def forwarded(self, previous_message: ChatMessage[Any]) -> Self:
@@ -509,7 +552,7 @@ class ChatMessage[TContent]:
                 call_part = call_parts[part.tool_call_id]
                 tool_info = ToolCallInfo(
                     tool_name=call_part.tool_name,
-                    args=call_part.args_as_dict(),
+                    args=safe_args_as_dict(call_part),
                     agent_name=agent_name or "UNSET",
                     result=part.content,
                     tool_call_id=call_part.tool_call_id or str(uuid4()),

agentpool/messaging/processing.py

@@ -18,6 +18,7 @@ if TYPE_CHECKING:
 
 async def prepare_prompts(
     *prompt: PromptCompatible | ChatMessage[Any],
+    parent_id: str | None = None,
 ) -> tuple[ChatMessage[Any], list[UserContent], ChatMessage[Any] | None]:
     """Prepare prompts for processing.
 
@@ -25,6 +26,7 @@ async def prepare_prompts(
 
     Args:
         *prompt: The prompt(s) to prepare.
+        parent_id: Optional ID of the parent message (typically the previous response).
 
     Returns:
         A tuple of:
@@ -41,7 +43,7 @@ async def prepare_prompts(
         # 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)
+    user_msg = ChatMessage.user_prompt(message=prompts, parent_id=parent_id)
     return user_msg, prompts, None
 
 

agentpool/models/acp_agents/base.py

@@ -13,7 +13,6 @@ from exxec.configs import (
     ExecutionEnvironmentConfig,  # noqa: TC002
 )
 from pydantic import ConfigDict, Field
-from tokonomics.model_discovery import ProviderType  # noqa: TC002
 
 from agentpool_config.nodes import NodeConfig
 from agentpool_config.system_prompts import PromptConfig  # noqa: TC001
@@ -239,15 +238,6 @@ class BaseACPAgentConfig(NodeConfig):
             return get_environment(self.client_execution_environment)
         return self.client_execution_environment.get_provider()
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Return the model providers used by this ACP agent.
-
-        Override in subclasses to specify which providers the agent uses.
-        Used for intelligent model discovery and fallback configuration.
-        """
-        return []
-
 
 class ACPAgentConfig(BaseACPAgentConfig):
     """Configuration for a custom ACP agent with explicit command.
@@ -286,18 +276,6 @@ class ACPAgentConfig(BaseACPAgentConfig):
     )
     """Arguments to pass to the command."""
 
-    providers: list[ProviderType] = Field(
-        default_factory=list,
-        title="Providers",
-        examples=[["openai", "anthropic"], ["gemini"]],
-    )
-    """Model providers this agent can use."""
-
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Return configured providers for custom ACP agents."""
-        return list(self.providers)
-
     def get_command(self) -> str:
         """Get the command to spawn the ACP server."""
         return self.command

agentpool/models/acp_agents/mcp_capable.py

@@ -5,8 +5,8 @@ from __future__ import annotations
 import json
 from typing import TYPE_CHECKING, Any, Literal, assert_never, cast
 
+import anyenv
 from pydantic import BaseModel, ConfigDict, Field
-from tokonomics.model_discovery import ProviderType  # noqa: TC002
 
 from agentpool.models.acp_agents.base import BaseACPAgentConfig
 from agentpool_config.output_types import StructuredResponseConfig  # noqa: TC001
@@ -211,9 +211,9 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Fallback model when default is overloaded."""
 
-    dangerously_skip_permissions: bool = Field(
+    auto_approve: bool = Field(
         default=False,
-        title="Dangerously Skip Permissions",
+        title="Auto Approve",
     )
     """Bypass all permission checks. Only for sandboxed environments."""
 
@@ -267,7 +267,7 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
                 args.extend(["--tools", ""])
         if self.fallback_model:
             args.extend(["--fallback-model", self.fallback_model])
-        if self.dangerously_skip_permissions:
+        if self.auto_approve:
             args.append("--dangerously-skip-permissions")
         if self.output_type:
             args.extend(["--output-format", "json"])
@@ -286,128 +286,7 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
             return None
         # StructuredResponseConfig - resolve schema via get_schema()
         model_cls = cast(type[BaseModel], self.output_type.response_schema.get_schema())
-        return json.dumps(model_cls.model_json_schema())
-
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Claude Code uses Anthropic models."""
-        return ["anthropic"]
-
-
-class GeminiACPAgentConfig(MCPCapableACPAgentConfig):
-    """Configuration for Gemini CLI via ACP.
-
-    Provides typed settings for the gemini CLI with ACP support.
-
-    Example:
-        ```yaml
-        agents:
-          coder:
-            type: acp
-            provider: gemini
-            cwd: /path/to/project
-            model: gemini-2.5-pro
-            approval_mode: auto_edit
-            allowed_tools:
-              - read_file
-              - write_file
-              - terminal
-        ```
-    """
-
-    model_config = ConfigDict(json_schema_extra={"title": "Gemini ACP Agent Configuration"})
-
-    provider: Literal["gemini"] = Field("gemini", init=False)
-    """Discriminator for Gemini ACP agent."""
-
-    model: str | None = Field(
-        default=None,
-        title="Model",
-        examples=["gemini-2.5-pro", "gemini-2.5-flash"],
-    )
-    """Model override."""
-
-    approval_mode: Literal["default", "auto_edit", "yolo"] | None = Field(
-        default=None,
-        title="Approval Mode",
-        examples=["auto_edit", "yolo"],
-    )
-    """Approval mode for tool execution."""
-
-    sandbox: bool = Field(default=False, title="Sandbox")
-    """Run in sandbox mode."""
-
-    yolo: bool = Field(default=False, title="YOLO")
-    """Automatically accept all actions."""
-
-    allowed_tools: list[str] | None = Field(
-        default=None,
-        title="Allowed Tools",
-        examples=[["read_file", "write_file", "terminal"], ["search"]],
-    )
-    """Tools allowed to run without confirmation."""
-
-    allowed_mcp_server_names: list[str] | None = Field(
-        default=None,
-        title="Allowed MCP Server Names",
-        examples=[["filesystem", "github"], ["slack"]],
-    )
-    """Allowed MCP server names."""
-
-    extensions: list[str] | None = Field(
-        default=None,
-        title="Extensions",
-        examples=[["python", "typescript"], ["rust", "go"]],
-    )
-    """List of extensions to use. If not provided, all are used."""
-
-    include_directories: list[str] | None = Field(
-        default=None,
-        title="Include Directories",
-        examples=[["/path/to/lib", "/path/to/shared"], ["./vendor"]],
-    )
-    """Additional directories to include in the workspace."""
-
-    output_format: Literal["text", "json", "stream-json"] | None = Field(
-        default=None,
-        title="Output Format",
-        examples=["json", "stream-json"],
-    )
-    """Output format."""
-
-    def get_command(self) -> str:
-        """Get the command to spawn the ACP server."""
-        return "gemini"
-
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Gemini CLI uses Google Gemini models."""
-        return ["gemini"]
-
-    async def get_args(self, prompt_manager: PromptManager | None = None) -> list[str]:
-        """Build command arguments from settings."""
-        args: list[str] = ["--experimental-acp"]
-
-        if self.model:
-            args.extend(["--model", self.model])
-        if self.approval_mode:
-            args.extend(["--approval-mode", self.approval_mode])
-        if self.sandbox:
-            args.append("--sandbox")
-        if self.yolo:
-            args.append("--yolo")
-        if self.allowed_tools:
-            args.extend(["--allowed-tools", *self.allowed_tools])
-        if self.allowed_mcp_server_names:
-            args.extend(["--allowed-mcp-server-names", *self.allowed_mcp_server_names])
-        if self.extensions:
-            args.extend(["--extensions", *self.extensions])
-        if self.include_directories:
-            args.extend(["--include-directories", *self.include_directories])
-        if self.output_format:
-            args.extend(["--output-format", self.output_format])
-
-        return args
+        return anyenv.dump_json(model_cls.model_json_schema())
 
 
 class FastAgentACPAgentConfig(MCPCapableACPAgentConfig):
@@ -513,11 +392,6 @@ class FastAgentACPAgentConfig(MCPCapableACPAgentConfig):
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """fast-agent supports multiple providers."""
-        return ["openai", "anthropic", "gemini", "openrouter"]
-
 
 class AuggieACPAgentConfig(MCPCapableACPAgentConfig):
     """Configuration for Auggie (Augment Code) via ACP.
@@ -681,11 +555,6 @@ class AuggieACPAgentConfig(MCPCapableACPAgentConfig):
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Auggie uses Augment Code's models."""
-        return []
-
 
 class KimiACPAgentConfig(MCPCapableACPAgentConfig):
     """Configuration for Kimi CLI via ACP.
@@ -737,7 +606,7 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Working directory for the agent."""
 
-    yolo: bool = Field(default=False, title="YOLO")
+    auto_approve: bool = Field(default=False, title="Auto Approve")
     """Automatically approve all actions."""
 
     thinking: bool | None = Field(default=None, title="Thinking")
@@ -767,24 +636,15 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
         if mcp_json:
             args.extend(["--mcp-config", mcp_json])
 
-        if self.yolo:
+        if self.auto_approve:
             args.append("--yolo")
         if self.thinking is not None and self.thinking:
             args.append("--thinking")
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Kimi uses Moonshot AI's models."""
-        return []
-
 
 # Union of all ACP agent config types
 MCPCapableACPAgentConfigTypes = (
-    ClaudeACPAgentConfig
-    | GeminiACPAgentConfig
-    | FastAgentACPAgentConfig
-    | AuggieACPAgentConfig
-    | KimiACPAgentConfig
+    ClaudeACPAgentConfig | FastAgentACPAgentConfig | AuggieACPAgentConfig | KimiACPAgentConfig
 )