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

agentpool/agents/claude_code_agent/converters.py

@@ -7,159 +7,20 @@ event types as native agents.
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, cast
 
 from pydantic_ai import PartDeltaEvent, TextPartDelta, ThinkingPartDelta
 
-from agentpool.agents.events import (
-    DiffContentItem,
-    LocationContentItem,
-    ToolCallCompleteEvent,
-    ToolCallStartEvent,
-)
+from agentpool.agents.events import ToolCallCompleteEvent, ToolCallStartEvent
 
 
 if TYPE_CHECKING:
     from claude_agent_sdk import ContentBlock, McpServerConfig, Message, ToolUseBlock
 
-    from agentpool.agents.events import RichAgentStreamEvent, ToolCallContentItem
-    from agentpool.tools.base import ToolKind
+    from agentpool.agents.events import RichAgentStreamEvent
     from agentpool_config.mcp_server import MCPServerConfig as NativeMCPServerConfig
 
 
-@dataclass
-class RichToolInfo:
-    """Rich display information derived from tool name and input."""
-
-    title: str
-    """Human-readable title for the tool call."""
-    kind: ToolKind = "other"
-    """Category of tool operation."""
-    locations: list[LocationContentItem] = field(default_factory=list)
-    """File locations involved in the operation."""
-    content: list[ToolCallContentItem] = field(default_factory=list)
-    """Rich content items (diffs, text, etc.)."""
-
-
-def derive_rich_tool_info(name: str, input_data: dict[str, Any]) -> RichToolInfo:  # noqa: PLR0911, PLR0915
-    """Derive rich display info from tool name and input arguments.
-
-    Maps MCP tool names and their inputs to human-readable titles, kinds,
-    and location information for rich UI display. Handles both Claude Code
-    built-in tools and MCP bridge tools.
-
-    Args:
-        name: The tool name (e.g., "Read", "mcp__server__read")
-        input_data: The tool input arguments
-
-    Returns:
-        RichToolInfo with derived display information
-    """
-    # Extract the actual tool name if it's an MCP bridge tool
-    # Format: mcp__{server_name}__{tool_name}
-    actual_name = name
-    if name.startswith("mcp__") and "__" in name[5:]:
-        parts = name.split("__")
-        if len(parts) >= 3:  # noqa: PLR2004
-            actual_name = parts[-1]  # Get the last part (actual tool name)
-
-    # Normalize to lowercase for matching
-    tool_lower = actual_name.lower()
-    # Read operations
-    if tool_lower in ("read", "read_file"):
-        path = input_data.get("file_path") or input_data.get("path", "")
-        offset = input_data.get("offset") or input_data.get("line")
-        limit = input_data.get("limit")
-
-        suffix = ""
-        if limit:
-            start = (offset or 0) + 1
-            end = (offset or 0) + limit
-            suffix = f" ({start}-{end})"
-        elif offset:
-            suffix = f" (from line {offset + 1})"
-        title = f"Read {path}{suffix}" if path else "Read File"
-        locations = [LocationContentItem(path=path, line=offset or 0)] if path else []
-        return RichToolInfo(title=title, kind="read", locations=locations)
-
-    # Write operations
-    if tool_lower in ("write", "write_file"):
-        path = input_data.get("file_path") or input_data.get("path", "")
-        content = input_data.get("content", "")
-        return RichToolInfo(
-            title=f"Write {path}" if path else "Write File",
-            kind="edit",
-            locations=[LocationContentItem(path=path)] if path else [],
-            content=[DiffContentItem(path=path, old_text=None, new_text=content)] if path else [],
-        )
-    # Edit operations
-    if tool_lower in ("edit", "edit_file"):
-        path = input_data.get("file_path") or input_data.get("path", "")
-        old_string = input_data.get("old_string") or input_data.get("old_text", "")
-        new_string = input_data.get("new_string") or input_data.get("new_text", "")
-        return RichToolInfo(
-            title=f"Edit {path}" if path else "Edit File",
-            kind="edit",
-            locations=[LocationContentItem(path=path)] if path else [],
-            content=[DiffContentItem(path=path, old_text=old_string, new_text=new_string)]
-            if path
-            else [],
-        )
-    # Delete operations
-    if tool_lower in ("delete", "delete_path", "delete_file"):
-        path = input_data.get("file_path") or input_data.get("path", "")
-        locations = [LocationContentItem(path=path)] if path else []
-        title = f"Delete {path}" if path else "Delete"
-        return RichToolInfo(title=title, kind="delete", locations=locations)
-    # Bash/terminal operations
-    if tool_lower in ("bash", "execute", "run_command", "execute_command", "execute_code"):
-        command = input_data.get("command") or input_data.get("code", "")
-        # Escape backticks in command
-        escaped_cmd = command.replace("`", "\\`") if command else ""
-        title = f"`{escaped_cmd}`" if escaped_cmd else "Terminal"
-        return RichToolInfo(title=title, kind="execute")
-    # Search operations
-    if tool_lower in ("grep", "search", "glob", "find"):
-        pattern = input_data.get("pattern") or input_data.get("query", "")
-        path = input_data.get("path", "")
-        title = f"Search for '{pattern}'" if pattern else "Search"
-        if path:
-            title += f" in {path}"
-        locations = [LocationContentItem(path=path)] if path else []
-        return RichToolInfo(title=title, kind="search", locations=locations)
-    # List directory
-    if tool_lower in ("ls", "list", "list_directory"):
-        path = input_data.get("path", ".")
-        title = f"List {path}" if path != "." else "List current directory"
-        locations = [LocationContentItem(path=path)] if path else []
-        return RichToolInfo(title=title, kind="search", locations=locations)
-    # Web operations
-    if tool_lower in ("webfetch", "web_fetch", "fetch"):
-        url = input_data.get("url", "")
-        return RichToolInfo(title=f"Fetch {url}" if url else "Web Fetch", kind="fetch")
-    if tool_lower in ("websearch", "web_search", "search_web"):
-        query = input_data.get("query", "")
-        return RichToolInfo(title=f"Search: {query}" if query else "Web Search", kind="fetch")
-    # Task/subagent operations
-    if tool_lower == "task":
-        description = input_data.get("description", "")
-        return RichToolInfo(title=description if description else "Task", kind="think")
-    # Notebook operations
-    if tool_lower in ("notebookread", "notebook_read"):
-        path = input_data.get("notebook_path", "")
-        title = f"Read Notebook {path}" if path else "Read Notebook"
-        locations = [LocationContentItem(path=path)] if path else []
-        return RichToolInfo(title=title, kind="read", locations=locations)
-    if tool_lower in ("notebookedit", "notebook_edit"):
-        path = input_data.get("notebook_path", "")
-        title = f"Edit Notebook {path}" if path else "Edit Notebook"
-        locations = [LocationContentItem(path=path)] if path else []
-        return RichToolInfo(title=title, kind="edit", locations=locations)
-    # Default: use the tool name as title
-    return RichToolInfo(title=actual_name, kind="other")
-
-
 def content_block_to_event(block: ContentBlock, index: int = 0) -> RichAgentStreamEvent[Any] | None:
     """Convert a Claude SDK ContentBlock to a streaming event.
 
@@ -172,6 +33,8 @@ def content_block_to_event(block: ContentBlock, index: int = 0) -> RichAgentStre
     """
     from claude_agent_sdk import TextBlock, ThinkingBlock, ToolUseBlock
 
+    from agentpool.agents.events.infer_info import derive_rich_tool_info
+
     match block:
         case TextBlock(text=text):
             return PartDeltaEvent(index=index, delta=TextPartDelta(content_delta=text))

agentpool/agents/claude_code_agent/models.py

@@ -0,0 +1,77 @@
+"""Pydantic models for Claude Code server info structures."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ClaudeCodeBasemodel(BaseModel):
+    """Base model."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class ClaudeCodeModelInfo(ClaudeCodeBasemodel):
+    """Information about an available AI model from Claude Code."""
+
+    value: str
+    """Model identifier used in API calls (e.g., "default", "opus", "haiku")."""
+
+    display_name: str = Field(..., alias="displayName")
+    """Human-readable display name (e.g., "Opus", "Default (recommended)")."""
+
+    description: str
+    """Full description including capabilities and pricing."""
+
+
+class ClaudeCodeCommandInfo(ClaudeCodeBasemodel):
+    """Information about an available slash command from Claude Code."""
+
+    name: str
+    """Command name without the / prefix (e.g., "compact", "review")."""
+
+    description: str
+    """Full description of what the command does."""
+
+    argument_hint: str = Field(..., alias="argumentHint")
+    """Usage hint for command arguments (may be empty string)."""
+
+
+class ClaudeCodeAccountInfo(ClaudeCodeBasemodel):
+    """Account information from Claude Code."""
+
+    email: str | None = None
+    """User email address."""
+
+    subscription_type: str | None = Field(default=None, alias="subscriptionType")
+    """Subscription type (e.g., "Claude API")."""
+
+    token_source: str | None = Field(default=None, alias="tokenSource")
+    """Where tokens come from (e.g., "claude.ai")."""
+
+    api_key_source: str | None = Field(default=None, alias="apiKeySource")
+    """Where API key comes from (e.g., "ANTHROPIC_API_KEY")."""
+
+
+class ClaudeCodeServerInfo(ClaudeCodeBasemodel):
+    """Complete server initialization info from Claude Code.
+
+    This is returned by the Claude Code server during initialization and contains
+    all available capabilities including models, commands, output styles, and
+    account information.
+    """
+
+    models: list[ClaudeCodeModelInfo] = Field(default_factory=list)
+    """List of available AI models."""
+
+    commands: list[ClaudeCodeCommandInfo] = Field(default_factory=list)
+    """List of available slash commands."""
+
+    output_style: str = Field(default="default")
+    """Current output style setting."""
+
+    available_output_styles: list[str] = Field(default_factory=list)
+    """List of all available output styles."""
+
+    account: ClaudeCodeAccountInfo | None = Field(default=None)
+    """Account and authentication information."""

agentpool/agents/claude_code_agent/static_info.py

@@ -0,0 +1,100 @@
+"""Static model information."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from tokonomics.model_discovery.model_info import ModelInfo, ModelPricing
+
+from agentpool.agents.modes import ModeInfo
+
+
+if TYPE_CHECKING:
+    from claude_agent_sdk import PermissionMode
+
+
+VALID_MODES: set[PermissionMode] = {
+    "default",
+    "acceptEdits",
+    "plan",
+    "bypassPermissions",
+}
+
+# Static Claude Code models - these are the simple IDs the SDK accepts
+# Use id_override to ensure pydantic_ai_id returns simple names like "opus"
+
+OPUS = ModelInfo(
+    id="claude-opus-4-5",
+    name="Claude Opus",
+    provider="anthropic",
+    description="Claude Opus - most capable model",
+    context_window=200000,
+    max_output_tokens=32000,
+    input_modalities={"text", "image"},
+    output_modalities={"text"},
+    pricing=ModelPricing(
+        prompt=0.000005,  # $5 per 1M tokens
+        completion=0.000025,  # $25 per 1M tokens
+    ),
+    id_override="opus",  # Claude Code SDK uses simple names
+)
+SONNET = ModelInfo(
+    id="claude-sonnet-4-5",
+    name="Claude Sonnet",
+    provider="anthropic",
+    description="Claude Sonnet - balanced performance and speed",
+    context_window=200000,
+    max_output_tokens=16000,
+    input_modalities={"text", "image"},
+    output_modalities={"text"},
+    pricing=ModelPricing(
+        prompt=0.000003,  # $3 per 1M tokens
+        completion=0.000015,  # $15 per 1M tokens
+    ),
+    id_override="sonnet",  # Claude Code SDK uses simple names
+)
+HAIKU = ModelInfo(
+    id="claude-haiku-4-5",
+    name="Claude Haiku",
+    provider="anthropic",
+    description="Claude Haiku - fast and cost-effective",
+    context_window=200000,
+    max_output_tokens=8000,
+    input_modalities={"text", "image"},
+    output_modalities={"text"},
+    pricing=ModelPricing(
+        prompt=0.000001,  # $1.00 per 1M tokens
+        completion=0.000005,  # $5 per 1M tokens
+    ),
+    id_override="haiku",  # Claude Code SDK uses simple names
+)
+
+MODELS = [OPUS, SONNET, HAIKU]
+
+
+MODES = [
+    ModeInfo(
+        id="default",
+        name="Default",
+        description="Require confirmation for tool usage",
+        category_id="permissions",
+    ),
+    ModeInfo(
+        id="acceptEdits",
+        name="Accept Edits",
+        description="Auto-approve file edits without confirmation",
+        category_id="permissions",
+    ),
+    ModeInfo(
+        id="plan",
+        name="Plan",
+        description="Planning mode - no tool execution",
+        category_id="permissions",
+    ),
+    ModeInfo(
+        id="bypassPermissions",
+        name="Bypass Permissions",
+        description="Skip all permission checks (use with caution)",
+        category_id="permissions",
+    ),
+]

agentpool/agents/claude_code_agent/usage.py

@@ -0,0 +1,242 @@
+"""Claude Code usage limits helper.
+
+Fetches usage information from Anthropic's OAuth API using stored credentials.
+Works on both Linux and macOS.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+import subprocess
+import sys
+
+import anyenv
+import httpx
+from pydantic import BaseModel
+
+
+class UsageLimit(BaseModel):
+    """A single usage limit with utilization percentage and reset time."""
+
+    utilization: float
+    """Utilization percentage (0-100)."""
+
+    resets_at: datetime | None = None
+    """When this limit resets, or None if not set."""
+
+
+class ExtraUsage(BaseModel):
+    """Extra usage information for paid plans."""
+
+    is_enabled: bool = False
+    monthly_limit: float | None = None
+    used_credits: float | None = None
+    utilization: float | None = None
+
+
+class ClaudeCodeUsage(BaseModel):
+    """Claude Code usage limits."""
+
+    five_hour: UsageLimit | None = None
+    """5-hour rolling usage limit."""
+
+    seven_day: UsageLimit | None = None
+    """7-day rolling usage limit."""
+
+    seven_day_opus: UsageLimit | None = None
+    """7-day Opus-specific limit."""
+
+    seven_day_sonnet: UsageLimit | None = None
+    """7-day Sonnet-specific limit."""
+
+    seven_day_oauth_apps: UsageLimit | None = None
+    """7-day OAuth apps limit."""
+
+    extra_usage: ExtraUsage | None = None
+    """Extra usage info for paid plans."""
+
+    def format_table(self) -> str:
+        """Format usage as a readable table."""
+        lines = ["Claude Code Usage Limits", "=" * 50]
+
+        def format_limit(name: str, limit: UsageLimit | None) -> str | None:
+            if limit is None:
+                return None
+            reset_str = ""
+            if limit.resets_at:
+                reset_str = f" (resets {limit.resets_at.strftime('%Y-%m-%d %H:%M UTC')})"
+            return f"{name}: {limit.utilization:.0f}%{reset_str}"
+
+        for name, limit in [
+            ("5-hour", self.five_hour),
+            ("7-day", self.seven_day),
+            ("7-day Opus", self.seven_day_opus),
+            ("7-day Sonnet", self.seven_day_sonnet),
+            ("7-day OAuth Apps", self.seven_day_oauth_apps),
+        ]:
+            formatted = format_limit(name, limit)
+            if formatted:
+                lines.append(formatted)
+
+        if self.extra_usage and self.extra_usage.is_enabled:
+            lines.append("")
+            lines.append("Extra Usage (paid):")
+            if self.extra_usage.utilization is not None:
+                lines.append(f"  Utilization: {self.extra_usage.utilization:.0f}%")
+            if self.extra_usage.used_credits is not None:
+                lines.append(f"  Used credits: {self.extra_usage.used_credits}")
+            if self.extra_usage.monthly_limit is not None:
+                lines.append(f"  Monthly limit: {self.extra_usage.monthly_limit}")
+
+        return "\n".join(lines)
+
+
+def _get_credentials_path() -> Path | None:
+    """Get the path to Claude Code credentials file.
+
+    Returns:
+        Path to credentials file, or None if not found.
+    """
+    # Linux: ~/.claude/.credentials.json
+    linux_path = Path.home() / ".claude" / ".credentials.json"
+    if linux_path.exists():
+        return linux_path
+
+    # macOS: Also check ~/.claude first (newer versions)
+    if linux_path.exists():
+        return linux_path
+
+    return None
+
+
+def _get_access_token_from_file(path: Path) -> str | None:
+    """Read access token from credentials file."""
+    try:
+        data = anyenv.load_json(path.read_text(), return_type=dict)
+        val = data.get("claudeAiOauth", {}).get("accessToken")
+    except (anyenv.JsonLoadError, OSError):
+        return None
+    else:
+        assert isinstance(val, str)
+        return val
+
+
+def _get_access_token_from_keychain() -> str | None:
+    """Read access token from macOS Keychain."""
+    if sys.platform != "darwin":
+        return None
+
+    try:
+        result = subprocess.run(
+            ["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        data = anyenv.load_json(result.stdout.strip(), return_type=dict)
+        val = data.get("claudeAiOauth", {}).get("accessToken")
+    except (subprocess.CalledProcessError, anyenv.JsonLoadError, FileNotFoundError):
+        return None
+    else:
+        assert isinstance(val, str)
+        return val
+
+
+def get_access_token() -> str | None:
+    """Get Claude Code OAuth access token.
+
+    Checks both file-based storage (Linux/newer macOS) and Keychain (macOS).
+
+    Returns:
+        Access token string, or None if not found.
+    """
+    # Try file-based first (works on Linux and newer macOS)
+    creds_path = _get_credentials_path()
+    if creds_path:
+        token = _get_access_token_from_file(creds_path)
+        if token:
+            return token
+    # Fall back to macOS Keychain
+    return _get_access_token_from_keychain()
+
+
+async def get_usage_async(token: str | None = None) -> ClaudeCodeUsage:
+    """Fetch Claude Code usage limits asynchronously.
+
+    Args:
+        token: OAuth access token. If not provided, will attempt to read from
+               stored credentials.
+
+    Returns:
+        ClaudeCodeUsage with current limits.
+
+    Raises:
+        ValueError: If no token provided and credentials not found.
+        httpx.HTTPStatusError: If API request fails.
+    """
+    if token is None:
+        token = get_access_token()
+        if token is None:
+            msg = "No Claude Code credentials found. Please authenticate with Claude Code first."
+            raise ValueError(msg)
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(
+            "https://api.anthropic.com/api/oauth/usage",
+            headers={
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "claude-code/2.0.32",
+                "Authorization": f"Bearer {token}",
+                "anthropic-beta": "oauth-2025-04-20",
+            },
+        )
+        response.raise_for_status()
+        return ClaudeCodeUsage.model_validate(response.json())
+
+
+def get_usage(token: str | None = None) -> ClaudeCodeUsage:
+    """Fetch Claude Code usage limits synchronously.
+
+    Args:
+        token: OAuth access token. If not provided, will attempt to read from
+               stored credentials.
+
+    Returns:
+        ClaudeCodeUsage with current limits.
+
+    Raises:
+        ValueError: If no token provided and credentials not found.
+        httpx.HTTPStatusError: If API request fails.
+    """
+    if token is None:
+        token = get_access_token()
+        if token is None:
+            msg = "No Claude Code credentials found. Please authenticate with Claude Code first."
+            raise ValueError(msg)
+
+    with httpx.Client() as client:
+        response = client.get(
+            "https://api.anthropic.com/api/oauth/usage",
+            headers={
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "claude-code/2.0.32",
+                "Authorization": f"Bearer {token}",
+                "anthropic-beta": "oauth-2025-04-20",
+            },
+        )
+        response.raise_for_status()
+        return ClaudeCodeUsage.model_validate(response.json())
+
+
+if __name__ == "__main__":
+    # Quick test
+    try:
+        usage = get_usage()
+        print(usage.format_table())
+    except ValueError as e:
+        print(f"Error: {e}")
+    except httpx.HTTPStatusError as e:
+        print(f"API Error: {e.response.status_code} - {e.response.text}")

agentpool/agents/events/__init__.py

@@ -9,17 +9,21 @@ from .events import (
     FileContentItem,
     LocationContentItem,
     PlanUpdateEvent,
+    PartStartEvent,
+    PartDeltaEvent,
     RichAgentStreamEvent,
     RunErrorEvent,
     RunStartedEvent,
     SlashedAgentStreamEvent,
     StreamCompleteEvent,
+    SubAgentEvent,
     TerminalContentItem,
     TextContentItem,
     ToolCallCompleteEvent,
     ToolCallContentItem,
     ToolCallProgressEvent,
     ToolCallStartEvent,
+    ToolResultMetadataEvent,
 )
 from .event_emitter import StreamEventEmitter
 from .builtin_handlers import (
@@ -32,6 +36,14 @@ from .tts_handlers import (
     EdgeTTSEventHandler,
     OpenAITTSEventHandler,
 )
+from .processors import (
+    FileTracker,
+    FileTrackingProcessor,
+    StreamPipeline,
+    StreamProcessor,
+    event_handler_processor,
+    extract_file_path_from_tool_call,
+)
 
 __all__ = [
     "BaseTTSEventHandler",
@@ -42,8 +54,12 @@ __all__ = [
     "DiffContentItem",
     "EdgeTTSEventHandler",
     "FileContentItem",
+    "FileTracker",
+    "FileTrackingProcessor",
     "LocationContentItem",
     "OpenAITTSEventHandler",
+    "PartDeltaEvent",
+    "PartStartEvent",
     "PlanUpdateEvent",
     "RichAgentStreamEvent",
     "RunErrorEvent",
@@ -51,13 +67,19 @@ __all__ = [
     "SlashedAgentStreamEvent",
     "StreamCompleteEvent",
     "StreamEventEmitter",
+    "StreamPipeline",
+    "StreamProcessor",
+    "SubAgentEvent",
     "TerminalContentItem",
     "TextContentItem",
     "ToolCallCompleteEvent",
     "ToolCallContentItem",
     "ToolCallProgressEvent",
     "ToolCallStartEvent",
+    "ToolResultMetadataEvent",
     "detailed_print_handler",
+    "event_handler_processor",
+    "extract_file_path_from_tool_call",
     "resolve_event_handlers",
     "simple_print_handler",
 ]