agentshim 0.2.0__tar.gz → 0.3.1__tar.gz

{agentshim-0.2.0 → agentshim-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentshim
-Version: 0.2.0
+Version: 0.3.1
 Summary: Provider-agnostic coding-agent CLI shims
 Requires-Python: >=3.10
 Requires-Dist: litellm>=1.0.0

{agentshim-0.2.0 → agentshim-0.3.1}/agentshim/__init__.py

@@ -1,5 +1,6 @@
 from .base import BaseAgentSession, BaseCodingAgent, CodingAgent, get_provider_class, list_providers, register_provider
 from .claude import ClaudeCodeCodingAgent
+from .copilot import CopilotCodingAgent
 from .codex import CodexCodingAgent
 from .gemini import GeminiCodingAgent
 from .mcp_config import HttpMcpServer, McpServerConfig, StdioMcpServer
@@ -13,6 +14,7 @@ __all__ = [
     "get_provider_class",
     "list_providers",
     "register_provider",
+    "CopilotCodingAgent",
     "CodexCodingAgent",
     "GeminiCodingAgent",
     "OpencodeCodingAgent",

{agentshim-0.2.0 → agentshim-0.3.1}/agentshim/claude/agent.py

@@ -53,6 +53,10 @@ class ClaudeGenerationSession(CLIGenerationSession):
     def _handle_event(self, event: ClaudeEvent):
         """Handle a single parsed Claude event."""
         if isinstance(event, MultiEvent):
+            if event.usage and self.event_handler is not None:
+                on_usage = getattr(self.event_handler, "on_usage", None)
+                if on_usage is not None:
+                    on_usage(event.usage)
             for sub_event in event.events:
                 self._handle_event(sub_event)
             return
@@ -105,6 +109,9 @@ class ClaudeGenerationSession(CLIGenerationSession):
 
         elif isinstance(event, ResultEvent):
             self.final_result = event.result
+            self.final_usage = event.usage
+            self.total_cost_usd = event.total_cost_usd
+            self.duration_ms = event.duration_ms
             # Anthropic reports cache_creation + cache_read as disjoint
             # from input_tokens; fold them into input_tokens to match the
             # crucible invariant (cached ⊆ input).

{agentshim-0.2.0 → agentshim-0.3.1}/agentshim/claude/events.py

@@ -36,7 +36,8 @@ class ClaudeEvent(ABC):
                             parameters=block.get("input"),
                         )
                     )
-            return MultiEvent(events) if events else None
+            usage = message.get("usage")
+            return MultiEvent(events, usage=usage) if events else None
         if event_type == "user":
             message = data.get("message", {})
             content_blocks = message.get("content", [])
@@ -53,6 +54,7 @@ class ClaudeEvent(ABC):
                 num_turns=data.get("num_turns"),
                 usage=data.get("usage"),
                 total_cost_usd=data.get("total_cost_usd"),
+                duration_ms=data.get("duration_ms"),
             )
 
         return None
@@ -61,8 +63,13 @@ class ClaudeEvent(ABC):
 class MultiEvent(ClaudeEvent):
     """Container for multiple events from a single message."""
 
-    def __init__(self, events: list[ClaudeEvent]):
+    def __init__(
+        self,
+        events: list[ClaudeEvent],
+        usage: dict[str, Any] | None = None,
+    ):
         self.events = events
+        self.usage = usage
 
     def render(self, log_prefix: str) -> str | None:
         # MultiEvent doesn't render itself; events are handled individually
@@ -138,11 +145,13 @@ class ResultEvent(ClaudeEvent):
         num_turns: int | None = None,
         usage: dict[str, Any] | None = None,
         total_cost_usd: float | None = None,
+        duration_ms: int | None = None,
     ):
         self.result = result
         self.num_turns = num_turns
         self.usage = usage
         self.total_cost_usd = total_cost_usd
+        self.duration_ms = duration_ms
 
     def render(self, log_prefix: str) -> str | None:
         # Result events are silent (result is captured separately)

{agentshim-0.2.0 → agentshim-0.3.1}/agentshim/cli_agent.py

@@ -56,6 +56,11 @@ class CLIGenerationSession:
         # Providers populate this during event handling; stays at the
         # empty default if the session crashes before any terminal event.
         self.usage: ProviderUsage = ProviderUsage()
+        # Final provider-reported accounting snapshot, when the CLI exposes
+        # one on a terminal event.
+        self.final_usage: dict[str, Any] | None = None
+        self.total_cost_usd: float | None = None
+        self.duration_ms: int | None = None
         # Provider session id captured from the event stream (set by subclasses
         # that parse JSON events). ``None`` if the underlying CLI did not emit
         # an id during this run.

{agentshim-0.2.0 → agentshim-0.3.1}/agentshim/codex/agent.py

@@ -15,6 +15,7 @@ from ..usage import ProviderUsage, TokenUsage
 from .events import (
     CodexEvent,
     ErrorEvent,
+    LifecycleEvent,
     TextEvent,
     ThreadStartedEvent,
     ToolResultEvent,
@@ -38,21 +39,28 @@ class CodexGenerationSession(CLIGenerationSession):
         self._accumulated_tokens = TokenUsage()
 
     def _process_stdout(self, line: str) -> None:
-        if not line:
+        if not line.strip():
             return
         try:
             data = json.loads(line)
         except json.JSONDecodeError:
-            self.stdout_lines.append(line.rstrip())
-            if not self.silent:
+            stripped = line.rstrip()
+            self.stdout_lines.append(stripped)
+            if self.event_handler and stripped:
+                self.event_handler.on_thinking(stripped)
+            elif not self.silent:
                 if self._at_line_start:
                     self._log_raw(f"{self.log_prefix} ")
-                self._log_raw(line.rstrip() + "\n")
+                self._log_raw(stripped + "\n")
                 self._at_line_start = True
             return
 
         event = CodexEvent.from_dict(data)
         if event is None:
+            stripped = line.rstrip()
+            if self.event_handler and stripped:
+                self.event_handler.on_thinking(stripped)
+            self.stdout_lines.append(stripped)
             return
         self._handle_event(event)
 
@@ -65,6 +73,13 @@ class CodexGenerationSession(CLIGenerationSession):
         if isinstance(event, ThreadStartedEvent):
             if self.session_id is None and event.thread_id:
                 self.session_id = event.thread_id
+            if self.event_handler and event.thread_id:
+                self.event_handler.on_thinking(f"[codex thread {event.thread_id} started]")
+            return
+
+        if isinstance(event, LifecycleEvent):
+            if self.event_handler and event.event_type == "turn.started":
+                self.event_handler.on_thinking("[codex turn started]")
             return
 
         if isinstance(event, TextEvent):
@@ -76,12 +91,12 @@ class CodexGenerationSession(CLIGenerationSession):
             return
 
         if isinstance(event, ToolUseEvent):
-            if event.tool_id:
+            if event.tool_name == "execute" and event.tool_id:
                 self.tool_map[event.tool_id] = event.tool_name
                 self.tool_start_times[event.tool_id] = time.time()
                 self.tool_args[event.tool_id] = event.parameters
-                if self.event_handler:
-                    self.event_handler.on_tool_call(event.tool_name, event.parameters)
+            if self.event_handler:
+                self.event_handler.on_tool_call(event.tool_name, event.parameters)
             return
 
         if isinstance(event, TurnCompletedEvent):
@@ -96,16 +111,48 @@ class CodexGenerationSession(CLIGenerationSession):
                 total_cost_usd=None,
                 provider="codex",
             )
+            normalized_usage = {
+                "input_tokens": event.input_tokens,
+                "output_tokens": event.output_tokens,
+                "cache_read_input_tokens": event.cached_input_tokens,
+                "cache_creation_input_tokens": 0,
+            }
+            if event.has_usage:
+                self.final_usage = normalized_usage
+            if self.event_handler is not None and event.has_usage:
+                on_usage = getattr(self.event_handler, "on_usage", None)
+                if on_usage is not None:
+                    on_usage(normalized_usage)
+                self.event_handler.on_thinking(
+                    f"[codex turn complete: in={normalized_usage['input_tokens']} "
+                    f"cached={normalized_usage['cache_read_input_tokens']} "
+                    f"out={normalized_usage['output_tokens']}]"
+                )
+            elif self.event_handler is not None:
+                self.event_handler.on_thinking("[codex turn complete]")
             return
 
         if isinstance(event, ToolResultEvent):
             if not event.tool_id:
-                return
-            event.tool_name_resolved = self.tool_map.get(event.tool_id, "Tool")
+                if event.tool_name is None:
+                    return
+                event.tool_name_resolved = event.tool_name
+                args = event.parameters or {}
+                duration = None
+                if self.event_handler:
+                    self.event_handler.on_tool_call(event.tool_name, args)
+            else:
+                event.tool_name_resolved = self.tool_map.get(
+                    event.tool_id,
+                    event.tool_name or "Tool",
+                )
+
+                start_time = self.tool_start_times.get(event.tool_id)
+                duration = time.time() - start_time if start_time else None
+                args = self.tool_args.get(event.tool_id, event.parameters or {})
 
-            start_time = self.tool_start_times.get(event.tool_id)
-            duration = time.time() - start_time if start_time else None
-            args = self.tool_args.get(event.tool_id, {})
+                if event.tool_id not in self.tool_map and self.event_handler and event.tool_name:
+                    self.event_handler.on_tool_call(event.tool_name, args)
 
             self.recorder.add_tool_call(
                 tool=event.tool_name_resolved,
@@ -140,8 +187,20 @@ class CodexGenerationSession(CLIGenerationSession):
         if isinstance(event, ErrorEvent):
             self.stdout_lines.append(event.message)
 
+    def _process_stderr(self, line: str) -> None:
+        line_stripped = line.rstrip("\n")
+        self.stderr_lines.append(line)
+        if self.event_handler and line_stripped:
+            self.event_handler.on_thinking(f"[codex stderr] {line_stripped}")
+        elif not self.silent:
+            self.logger.bind(stderr=True).info(f"[STDERR] {line_stripped}")
+
     def run(self, prompt: str) -> str:
-        super().run(prompt)
+        started = time.monotonic()
+        try:
+            super().run(prompt)
+        finally:
+            self.duration_ms = int((time.monotonic() - started) * 1000)
         if self.final_result:
             return self.final_result
         return "\n".join(self.stdout_lines)

{agentshim-0.2.0 → agentshim-0.3.1}/agentshim/codex/events.py

@@ -27,13 +27,7 @@ class CodexEvent(ABC):
             return LifecycleEvent(event_type)
 
         if event_type == "turn.completed":
-            usage_raw = data.get("usage")
-            usage = cast("dict[str, Any]", usage_raw) if isinstance(usage_raw, dict) else {}
-            return TurnCompletedEvent(
-                input_tokens=int(usage.get("input_tokens") or 0),
-                cached_input_tokens=int(usage.get("cached_input_tokens") or 0),
-                output_tokens=int(usage.get("output_tokens") or 0),
-            )
+            return TurnCompletedEvent.from_usage_payload(data.get("usage"))
 
         if event_type in ("item.started", "item.completed"):
             item_raw = data.get("item")
@@ -52,7 +46,15 @@ class CodexEvent(ABC):
                 text_raw = item.get("text", "")
                 return TextEvent(text=text_raw if isinstance(text_raw, str) else "")
 
+            if item_type == "reasoning":
+                if not completed:
+                    return None
+                text_raw = item.get("text", "")
+                return TextEvent(text=text_raw if isinstance(text_raw, str) else "")
+
             if item_type == "command_execution":
+                command_raw = item.get("command", "")
+                command = command_raw if isinstance(command_raw, str) else ""
                 exit_code_raw = item.get("exit_code")
                 exit_code = exit_code_raw if isinstance(exit_code_raw, int) else None
                 status_raw = item.get("status")
@@ -63,23 +65,22 @@ class CodexEvent(ABC):
                         output=item.get("aggregated_output", ""),
                         exit_code=exit_code,
                         status=status,
+                        tool_name="execute",
+                        parameters={"command": command},
                     )
-                command_raw = item.get("command", "")
-                command = command_raw if isinstance(command_raw, str) else ""
                 return ToolUseEvent(
                     tool_id=item_id,
-                    tool_name="shell",
+                    tool_name="execute",
                     parameters={"command": command},
                 )
 
             status_raw = item.get("status")
             status = status_raw if isinstance(status_raw, str) else None
             if completed:
-                return ToolResultEvent(
+                return ToolUseEvent(
                     tool_id=item_id,
-                    output=_summarize_item(item),
-                    exit_code=None,
-                    status=status,
+                    tool_name=item_type or "item",
+                    parameters=_item_parameters(item),
                 )
             return ToolUseEvent(
                 tool_id=item_id,
@@ -171,6 +172,8 @@ class ToolResultEvent(CodexEvent):
         tool_id: str | None,
         exit_code: int | None = None,
         status: str | None = None,
+        tool_name: str | None = None,
+        parameters: Any = None,
     ):
         if isinstance(output, list):
             items = cast("list[Any]", output)
@@ -180,7 +183,9 @@ class ToolResultEvent(CodexEvent):
         self.tool_id = tool_id
         self.exit_code = exit_code
         self.status = status
-        self.tool_name_resolved: str = "Tool"
+        self.tool_name = tool_name
+        self.parameters = parameters
+        self.tool_name_resolved: str = tool_name or "Tool"
 
     def render(self, log_prefix: str) -> str:
         if not self.output:
@@ -197,10 +202,27 @@ class TurnCompletedEvent(CodexEvent):
         input_tokens: int = 0,
         cached_input_tokens: int = 0,
         output_tokens: int = 0,
+        usage: dict[str, Any] | None = None,
     ):
         self.input_tokens = input_tokens
         self.cached_input_tokens = cached_input_tokens
         self.output_tokens = output_tokens
+        self.usage = usage
+
+    @classmethod
+    def from_usage_payload(cls, usage_raw: Any) -> TurnCompletedEvent:
+        usage = cast("dict[str, Any]", usage_raw) if isinstance(usage_raw, dict) else None
+        usage_dict = usage or {}
+        return cls(
+            input_tokens=int(usage_dict.get("input_tokens") or 0),
+            cached_input_tokens=int(usage_dict.get("cached_input_tokens") or 0),
+            output_tokens=int(usage_dict.get("output_tokens") or 0),
+            usage=usage,
+        )
+
+    @property
+    def has_usage(self) -> bool:
+        return self.usage is not None
 
     def render(self, log_prefix: str) -> str | None:
         return None

agentshim-0.3.1/agentshim/copilot/__init__.py

@@ -0,0 +1,3 @@
+from .agent import CopilotCodingAgent, CopilotGenerationSession
+
+__all__ = ["CopilotCodingAgent", "CopilotGenerationSession"]

agentshim-0.3.1/agentshim/copilot/agent.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import time
+from collections.abc import Callable
+from typing import Any
+
+from agentshim.trajectory import TrajectoryRecorderProtocol
+
+from ..base import register_provider
+from ..cli_agent import CLICodingAgent, CLIGenerationSession
+from ..events import AgentEventHandler
+from ..mcp_config import HttpMcpServer, McpServerConfig
+from ..sandbox import SandboxConfig
+from ..usage import ProviderUsage, TokenUsage
+from .events import (
+    CopilotEvent,
+    ErrorEvent,
+    IntentEvent,
+    MessageDeltaEvent,
+    MessageEvent,
+    ResultEvent,
+    SessionStartEvent,
+    ToolResultEvent,
+    ToolUseEvent,
+    TurnEndEvent,
+    UsageEvent,
+)
+
+
+class CopilotGenerationSession(CLIGenerationSession):
+    """Session that parses Copilot CLI JSONL events."""
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        self.tool_map: dict[str, str] = {}
+        self.tool_start_times: dict[str, float] = {}
+        self.tool_args: dict[str, Any] = {}
+        self.final_result: str | None = None
+        self._seen_message_deltas: set[str] = set()
+        self._streamed_text_chunks: list[str] = []
+        self._accumulated_tokens = TokenUsage()
+        self._turn_count = 0
+        self._message_output_tokens = 0
+        self._saw_usage_event = False
+
+    def _refresh_usage(self) -> None:
+        effective_output_tokens = self._accumulated_tokens.output_tokens
+        if not self._saw_usage_event:
+            effective_output_tokens = self._message_output_tokens
+        self.usage = ProviderUsage(
+            tokens=TokenUsage(
+                input_tokens=self._accumulated_tokens.input_tokens,
+                output_tokens=effective_output_tokens,
+                cached_input_tokens=self._accumulated_tokens.cached_input_tokens,
+                turns=self._turn_count,
+            ),
+            total_cost_usd=None,
+            provider="copilot",
+        )
+
+    def _process_stdout(self, line: str) -> None:
+        if not line:
+            return
+        try:
+            data = json.loads(line)
+        except json.JSONDecodeError:
+            self.stdout_lines.append(line.rstrip())
+            if not self.silent:
+                if self._at_line_start:
+                    self._log_raw(f"{self.log_prefix} ")
+                self._log_raw(line.rstrip() + "\n")
+                self._at_line_start = True
+            return
+
+        if not isinstance(data, dict):
+            return
+
+        event = CopilotEvent.from_dict(data)
+        if event is None:
+            return
+        self._handle_event(event)
+
+    def _handle_event(self, event: CopilotEvent) -> None:
+        self._update_state(event)
+        if not self.silent:
+            self._render_event(event)
+
+    def _update_state(self, event: CopilotEvent) -> None:
+        if isinstance(event, SessionStartEvent):
+            if self.session_id is None and event.session_id:
+                self.session_id = event.session_id
+            return
+
+        if isinstance(event, MessageDeltaEvent):
+            if event.message_id:
+                self._seen_message_deltas.add(event.message_id)
+            if event.delta_content:
+                self._streamed_text_chunks.append(event.delta_content)
+                if self.event_handler:
+                    self.event_handler.on_thinking(event.delta_content)
+            return
+
+        if isinstance(event, MessageEvent):
+            if event.content:
+                self.stdout_lines.append(event.content)
+                self.final_result = event.content
+                if not self._saw_usage_event:
+                    self._message_output_tokens += event.output_tokens
+                    self._refresh_usage()
+                if self.event_handler:
+                    self.event_handler.on_thinking(event.content)
+            return
+
+        if isinstance(event, ToolUseEvent):
+            if event.tool_id:
+                self.tool_map[event.tool_id] = event.tool_name
+                self.tool_start_times[event.tool_id] = time.time()
+                self.tool_args[event.tool_id] = event.arguments
+                if self.event_handler:
+                    self.event_handler.on_tool_call(event.tool_name, event.arguments)
+            return
+
+        if isinstance(event, ToolResultEvent):
+            if not event.tool_id:
+                return
+            event.tool_name_resolved = self.tool_map.get(event.tool_id, "Tool")
+            start_time = self.tool_start_times.get(event.tool_id)
+            duration = time.time() - start_time if start_time else None
+            args = self.tool_args.get(event.tool_id, {})
+            stdout = event.output or event.error_message
+
+            self.recorder.add_tool_call(
+                tool=event.tool_name_resolved,
+                args=args,
+                stdout=stdout,
+                exit_code=event.exit_code,
+                duration=duration,
+            )
+            if self.event_handler:
+                self.event_handler.on_tool_result(
+                    tool=event.tool_name_resolved,
+                    stdout=stdout,
+                    exit_code=event.exit_code,
+                    duration=duration,
+                )
+            return
+
+        if isinstance(event, UsageEvent):
+            self._saw_usage_event = True
+            cached = event.cache_read_tokens + event.cache_write_tokens
+            self._accumulated_tokens = self._accumulated_tokens + TokenUsage(
+                input_tokens=event.input_tokens + cached,
+                output_tokens=event.output_tokens + event.reasoning_tokens,
+                cached_input_tokens=cached,
+                turns=0,
+            )
+            self._refresh_usage()
+            return
+
+        if isinstance(event, TurnEndEvent):
+            self._turn_count += 1
+            self._refresh_usage()
+            return
+
+        if isinstance(event, ResultEvent):
+            if self.session_id is None and event.session_id:
+                self.session_id = event.session_id
+            return
+
+        if isinstance(event, ErrorEvent):
+            if event.message:
+                self.stdout_lines.append(event.message)
+
+    def _render_event(self, event: CopilotEvent) -> None:
+        if isinstance(event, MessageDeltaEvent):
+            if event.delta_content:
+                self._print_stream_content(event.delta_content)
+            return
+
+        if isinstance(event, MessageEvent):
+            if event.message_id and event.message_id in self._seen_message_deltas:
+                return
+            if event.content:
+                self._print_stream_content(event.content)
+            return
+
+        if not self._at_line_start:
+            self._log_raw("\n")
+            self._at_line_start = True
+
+        if isinstance(event, IntentEvent):
+            output = event.render(self.log_prefix)
+        else:
+            output = event.render(self.log_prefix)
+        if output:
+            self._log_raw(output + "\n")
+
+    def run(self, prompt: str) -> str:
+        super().run(prompt)
+        if self.final_result:
+            return self.final_result
+        if self._streamed_text_chunks:
+            return "".join(self._streamed_text_chunks).strip()
+        return "\n".join(self.stdout_lines)
+
+
+@register_provider("copilot", "github-copilot", "copilot-cli")
+class CopilotCodingAgent(CLICodingAgent):
+    """Coding agent implementation using the GitHub Copilot CLI tool."""
+
+    def __init__(
+        self,
+        model: str | None = None,
+        recorder: TrajectoryRecorderProtocol | None = None,
+        event_handler: AgentEventHandler | None = None,
+        mcp_servers: list[McpServerConfig] | None = None,
+        sandbox: bool | SandboxConfig = False,
+    ):
+        if sandbox:
+            raise NotImplementedError("sandbox is not supported for CopilotCodingAgent")
+        super().__init__("copilot", model, recorder, event_handler, mcp_servers)
+
+    @property
+    def copilot_path(self) -> str:
+        """Return path to copilot binary (for backward compatibility)."""
+        return self.binary_path
+
+    @property
+    def _log_prefix(self) -> str:
+        return "[Copilot]"
+
+    def _build_mcp_config_json(self) -> str:
+        servers: dict[str, dict[str, Any]] = {}
+        for server in self.mcp_servers:
+            if isinstance(server, HttpMcpServer):
+                entry: dict[str, Any] = {"type": "sse", "url": server.url}
+                if server.headers:
+                    entry["headers"] = dict(server.headers)
+                servers[server.name] = entry
+            else:
+                entry = {"command": server.command, "args": server.args}
+                if server.env:
+                    entry["env"] = server.env
+                servers[server.name] = entry
+        return json.dumps({"mcpServers": servers})
+
+    def _get_command(self, prompt: str, resume_session_id: str | None = None) -> list[str]:
+        cmd = [
+            self.binary_path,
+            "--output-format",
+            "json",
+            "--stream",
+            "off",
+            "--allow-all-tools",
+            "--allow-all-paths",
+            "--allow-all-urls",
+        ]
+        if resume_session_id:
+            cmd.extend(["--resume", resume_session_id])
+        if self.model:
+            cmd.extend(["--model", self.model])
+        if self.mcp_servers:
+            cmd.extend(["--additional-mcp-config", self._build_mcp_config_json()])
+        cmd.extend(["-p", prompt])
+        return cmd
+
+    def _create_session(
+        self,
+        cmd: list[str],
+        cwd: str | None = None,
+        timeout: int = 300,
+        silent: bool = False,
+        recorder: TrajectoryRecorderProtocol | None = None,
+        on_process_started: Callable[[subprocess.Popen[str]], None] | None = None,
+    ) -> CopilotGenerationSession:
+        return CopilotGenerationSession(
+            binary_name=self.binary_name,
+            env=self.env,
+            log_prefix=self._log_prefix,
+            cmd=cmd,
+            logger=self.logger,
+            cwd=cwd,
+            timeout=timeout,
+            silent=silent,
+            recorder=recorder,
+            event_handler=self.event_handler,
+            on_process_started=on_process_started,
+        )