agentshim 0.2.0__tar.gz → 0.3.0__tar.gz

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

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

{agentshim-0.2.0 → agentshim-0.3.0}/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.3.0/agentshim/copilot/__init__.py

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

agentshim-0.3.0/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,
+        )

agentshim-0.3.0/agentshim/copilot/events.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, cast
+
+from ..utils import truncate_content, truncate_tool_params
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    return cast("dict[str, Any]", value) if isinstance(value, dict) else {}
+
+
+def _extract_tool_result(result_raw: Any) -> tuple[str, int | None]:
+    result = _as_dict(result_raw)
+    exit_code: int | None = None
+
+    detailed = result.get("detailedContent")
+    if isinstance(detailed, str) and detailed:
+        output = detailed
+    else:
+        content = result.get("content")
+        output = content if isinstance(content, str) else ""
+
+    contents = result.get("contents")
+    if isinstance(contents, list):
+        rendered_blocks: list[str] = []
+        for item_raw in contents:
+            item = _as_dict(item_raw)
+            item_type = item.get("type")
+            if item_type in ("text", "terminal"):
+                text = item.get("text")
+                if isinstance(text, str) and text:
+                    rendered_blocks.append(text)
+                if item_type == "terminal":
+                    candidate_exit_code = item.get("exitCode")
+                    if isinstance(candidate_exit_code, int):
+                        exit_code = candidate_exit_code
+            elif item_type == "resource_link":
+                name = item.get("title") or item.get("name") or item.get("uri")
+                uri = item.get("uri")
+                if isinstance(name, str) and isinstance(uri, str):
+                    rendered_blocks.append(f"{name}: {uri}")
+        if not output and rendered_blocks:
+            output = "\n".join(rendered_blocks)
+
+    return output, exit_code
+
+
+class CopilotEvent(ABC):
+    """Base class for Copilot CLI JSONL events."""
+
+    @abstractmethod
+    def render(self, log_prefix: str) -> str | None:
+        """Render the event as a string for terminal output."""
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CopilotEvent | None:
+        event_type = data.get("type")
+        payload = _as_dict(data.get("data"))
+
+        if event_type == "session.start":
+            session_id_raw = payload.get("sessionId")
+            session_id = session_id_raw if isinstance(session_id_raw, str) else None
+            return SessionStartEvent(session_id=session_id)
+
+        if event_type == "assistant.intent":
+            intent = payload.get("intent")
+            if isinstance(intent, str):
+                return IntentEvent(intent=intent)
+            return None
+
+        if event_type == "assistant.message":
+            message_id_raw = payload.get("messageId")
+            message_id = message_id_raw if isinstance(message_id_raw, str) else None
+            content_raw = payload.get("content")
+            content = content_raw if isinstance(content_raw, str) else ""
+            output_tokens_raw = payload.get("outputTokens")
+            output_tokens = output_tokens_raw if isinstance(output_tokens_raw, int) else 0
+            return MessageEvent(message_id=message_id, content=content, output_tokens=output_tokens)
+
+        if event_type == "assistant.message_delta":
+            message_id_raw = payload.get("messageId")
+            message_id = message_id_raw if isinstance(message_id_raw, str) else None
+            delta_raw = payload.get("deltaContent")
+            delta = delta_raw if isinstance(delta_raw, str) else ""
+            return MessageDeltaEvent(message_id=message_id, delta_content=delta)
+
+        if event_type == "assistant.turn_end":
+            turn_id_raw = payload.get("turnId")
+            turn_id = turn_id_raw if isinstance(turn_id_raw, str) else None
+            return TurnEndEvent(turn_id=turn_id)
+
+        if event_type == "assistant.usage":
+            model_raw = payload.get("model")
+            model = model_raw if isinstance(model_raw, str) else ""
+            return UsageEvent(
+                model=model,
+                input_tokens=int(payload.get("inputTokens") or 0),
+                output_tokens=int(payload.get("outputTokens") or 0),
+                cache_read_tokens=int(payload.get("cacheReadTokens") or 0),
+                cache_write_tokens=int(payload.get("cacheWriteTokens") or 0),
+                reasoning_tokens=int(payload.get("reasoningTokens") or 0),
+            )
+
+        if event_type == "tool.execution_start":
+            tool_id_raw = payload.get("toolCallId")
+            tool_id = tool_id_raw if isinstance(tool_id_raw, str) else None
+            tool_name_raw = payload.get("toolName")
+            tool_name = tool_name_raw if isinstance(tool_name_raw, str) else "Tool"
+            return ToolUseEvent(
+                tool_id=tool_id,
+                tool_name=tool_name,
+                arguments=payload.get("arguments"),
+            )
+
+        if event_type == "tool.execution_complete":
+            tool_id_raw = payload.get("toolCallId")
+            tool_id = tool_id_raw if isinstance(tool_id_raw, str) else None
+            success = bool(payload.get("success"))
+            output, exit_code = _extract_tool_result(payload.get("result"))
+            error = _as_dict(payload.get("error"))
+            error_message_raw = error.get("message")
+            error_message = error_message_raw if isinstance(error_message_raw, str) else ""
+            return ToolResultEvent(
+                tool_id=tool_id,
+                success=success,
+                output=output,
+                error_message=error_message,
+                exit_code=exit_code,
+            )
+
+        if event_type == "session.error":
+            error_type_raw = payload.get("errorType")
+            error_type = error_type_raw if isinstance(error_type_raw, str) else None
+            message_raw = payload.get("message")
+            message = message_raw if isinstance(message_raw, str) else ""
+            return ErrorEvent(message=message, error_type=error_type)
+
+        if event_type == "result":
+            session_id_raw = data.get("sessionId")
+            session_id = session_id_raw if isinstance(session_id_raw, str) else None
+            exit_code_raw = data.get("exitCode")
+            exit_code = exit_code_raw if isinstance(exit_code_raw, int) else None
+            usage = _as_dict(data.get("usage"))
+            return ResultEvent(session_id=session_id, exit_code=exit_code, usage=usage)
+
+        return None
+
+
+class SessionStartEvent(CopilotEvent):
+    """Session start event carrying the resumable session id."""
+
+    def __init__(self, session_id: str | None):
+        self.session_id = session_id
+
+    def render(self, log_prefix: str) -> str | None:
+        return None
+
+
+class IntentEvent(CopilotEvent):
+    """Ephemeral agent intent update."""
+
+    def __init__(self, intent: str):
+        self.intent = intent
+
+    def render(self, log_prefix: str) -> str:
+        return f"{log_prefix} \033[36m[Intent] {self.intent}\033[0m"
+
+
+class MessageEvent(CopilotEvent):
+    """Final assistant message content."""
+
+    def __init__(self, message_id: str | None, content: str, output_tokens: int = 0):
+        self.message_id = message_id
+        self.content = content
+        self.output_tokens = output_tokens
+
+    def render(self, log_prefix: str) -> str | None:
+        return self.content
+
+
+class MessageDeltaEvent(CopilotEvent):
+    """Streaming assistant message delta."""
+
+    def __init__(self, message_id: str | None, delta_content: str):
+        self.message_id = message_id
+        self.delta_content = delta_content
+
+    def render(self, log_prefix: str) -> str | None:
+        return self.delta_content
+
+
+class TurnEndEvent(CopilotEvent):
+    """Turn completion marker."""
+
+    def __init__(self, turn_id: str | None):
+        self.turn_id = turn_id
+
+    def render(self, log_prefix: str) -> str | None:
+        return None
+
+
+class UsageEvent(CopilotEvent):
+    """Per-request usage summary."""
+
+    def __init__(
+        self,
+        model: str,
+        input_tokens: int = 0,
+        output_tokens: int = 0,
+        cache_read_tokens: int = 0,
+        cache_write_tokens: int = 0,
+        reasoning_tokens: int = 0,
+    ):
+        self.model = model
+        self.input_tokens = input_tokens
+        self.output_tokens = output_tokens
+        self.cache_read_tokens = cache_read_tokens
+        self.cache_write_tokens = cache_write_tokens
+        self.reasoning_tokens = reasoning_tokens
+
+    def render(self, log_prefix: str) -> str | None:
+        return None
+
+
+class ToolUseEvent(CopilotEvent):
+    """Tool execution start event."""
+
+    def __init__(self, tool_id: str | None, tool_name: str, arguments: Any):
+        self.tool_id = tool_id
+        self.tool_name = tool_name
+        self.arguments = arguments
+
+    def render(self, log_prefix: str) -> str:
+        truncated = truncate_tool_params(self.tool_name, self.arguments)
+        return f"{log_prefix} \033[34m[Tool Use] {self.tool_name} {truncated}\033[0m"
+
+
+class ToolResultEvent(CopilotEvent):
+    """Tool execution completion event."""
+
+    def __init__(
+        self,
+        tool_id: str | None,
+        success: bool,
+        output: str = "",
+        error_message: str = "",
+        exit_code: int | None = None,
+    ):
+        self.tool_id = tool_id
+        self.success = success
+        self.output = output
+        self.error_message = error_message
+        self.exit_code = exit_code
+        self.tool_name_resolved: str = "Tool"
+
+    def render(self, log_prefix: str) -> str:
+        if self.output:
+            truncated = truncate_content(self.output)
+            return f"{log_prefix} \033[32m[Tool Result] {truncated}\033[0m"
+        if self.error_message:
+            return f"{log_prefix} \033[31m[Tool Error] {self.error_message}\033[0m"
+        if self.success:
+            return f"{log_prefix} \033[32m{self.tool_name_resolved} ran successfully\033[0m"
+        return f"{log_prefix} \033[31m[Tool Error] {self.tool_name_resolved} failed\033[0m"
+
+
+class ErrorEvent(CopilotEvent):
+    """Session-level error event."""
+
+    def __init__(self, message: str, error_type: str | None = None):
+        self.message = message
+        self.error_type = error_type
+
+    def render(self, log_prefix: str) -> str:
+        label = f"{self.error_type}: " if self.error_type else ""
+        return f"{log_prefix} \033[31m[Error] {label}{self.message}\033[0m"
+
+
+class ResultEvent(CopilotEvent):
+    """Top-level non-interactive result summary."""
+
+    def __init__(self, session_id: str | None, exit_code: int | None, usage: dict[str, Any] | None = None):
+        self.session_id = session_id
+        self.exit_code = exit_code
+        self.usage = usage or {}
+
+    def render(self, log_prefix: str) -> str | None:
+        return None

agentshim-0.3.0/agentshim/copilot_events.py

@@ -0,0 +1,29 @@
+"""Compatibility shim for older ``agentshim.copilot_events`` imports."""
+
+from .copilot.events import (
+    CopilotEvent,
+    ErrorEvent,
+    IntentEvent,
+    MessageDeltaEvent,
+    MessageEvent,
+    ResultEvent,
+    SessionStartEvent,
+    ToolResultEvent,
+    ToolUseEvent,
+    TurnEndEvent,
+    UsageEvent,
+)
+
+__all__ = [
+    "CopilotEvent",
+    "ErrorEvent",
+    "IntentEvent",
+    "MessageDeltaEvent",
+    "MessageEvent",
+    "ResultEvent",
+    "SessionStartEvent",
+    "ToolResultEvent",
+    "ToolUseEvent",
+    "TurnEndEvent",
+    "UsageEvent",
+]

{agentshim-0.2.0 → agentshim-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentshim"
-version = "0.2.0"
+version = "0.3.0"
 description = "Provider-agnostic coding-agent CLI shims"
 readme = "README.md"
 requires-python = ">=3.10"

agentshim-0.3.0/tests/fixtures/copilot/session_turn_1.jsonl

@@ -0,0 +1,11 @@
+{"type":"session.mcp_server_status_changed","data":{"serverName":"github-mcp-server","status":"connected"},"id":"ac33a30f-af73-4ed8-80f7-f09b383b247b","timestamp":"2026-04-23T06:53:56.847Z","parentId":"aa1cfd37-9c6a-40ca-ad3c-bc70fdf8bb54","ephemeral":true}
+{"type":"session.mcp_servers_loaded","data":{"servers":[{"name":"github-mcp-server","status":"connected","source":"builtin"}]},"id":"b3d155a6-7724-4590-b5e1-2d186b4798d0","timestamp":"2026-04-23T06:53:57.036Z","parentId":"cb9d73a1-75de-4a6c-af7e-01a3f60cc170","ephemeral":true}
+{"type":"session.mcp_servers_loaded","data":{"servers":[{"name":"github-mcp-server","status":"connected","source":"builtin"}]},"id":"d53123ef-3fe2-453c-ac8a-f2efea54c721","timestamp":"2026-04-23T06:53:57.037Z","parentId":"cb9d73a1-75de-4a6c-af7e-01a3f60cc170","ephemeral":true}
+{"type":"session.skills_loaded","data":{"skills":[{"name":"customize-cloud-agent","description":"Skill for customizing the Copilot cloud agent (formerly known as Copilot coding agent) environment, including copilot-setup-steps.yml configuration, preinstalling tools and dependencies, runners, and settings.","source":"builtin","userInvocable":false,"enabled":true,"path":"/home/shli/.cache/copilot/pkg/linux-x64/1.0.34/builtin-skills/customize-cloud-agent/SKILL.md"}]},"id":"c3189a84-d0b1-4aa3-b906-92cd01f5c6fc","timestamp":"2026-04-23T06:53:57.054Z","parentId":"cb9d73a1-75de-4a6c-af7e-01a3f60cc170","ephemeral":true}
+{"type":"session.mcp_servers_loaded","data":{"servers":[{"name":"github-mcp-server","status":"connected","source":"builtin"}]},"id":"e6e3ec03-ad6a-4e70-8a42-cb3e3bfd82ca","timestamp":"2026-04-23T06:53:58.212Z","parentId":"cb9d73a1-75de-4a6c-af7e-01a3f60cc170","ephemeral":true}
+{"type":"session.tools_updated","data":{"model":"gpt-4.1"},"id":"6b97da6a-cd9b-4bb1-a38c-938f438021ba","timestamp":"2026-04-23T06:53:58.225Z","parentId":"e4fb6ec2-196e-4044-ac50-3f001e682bea","ephemeral":true}
+{"type":"user.message","data":{"content":"Remember the word CEDAR. Reply with exactly STORED and nothing else.","transformedContent":"<current_datetime>2026-04-23T06:53:58.229+00:00</current_datetime>\n\nRemember the word CEDAR. Reply with exactly STORED and nothing else.\n\n<reminder>\n<sql_tables>No tables currently exist. Default tables (todos, todo_deps) will be created automatically when you first use the SQL tool.</sql_tables>\n</reminder>","attachments":[],"supportedNativeDocumentMimeTypes":[],"interactionId":"9606351c-ffc7-4fec-bf69-42ee96ec9659"},"id":"b9ab8585-78d4-4aed-b963-dbd3a0fe5007","timestamp":"2026-04-23T06:53:58.229Z","parentId":"e4fb6ec2-196e-4044-ac50-3f001e682bea"}
+{"type":"assistant.turn_start","data":{"turnId":"0","interactionId":"9606351c-ffc7-4fec-bf69-42ee96ec9659"},"id":"6052f203-493e-4a7b-aa96-94e8a3089c84","timestamp":"2026-04-23T06:53:58.246Z","parentId":"b9ab8585-78d4-4aed-b963-dbd3a0fe5007"}
+{"type":"assistant.message","data":{"messageId":"820e17d9-4774-4177-bc49-151c30d209dc","content":"STORED","toolRequests":[],"interactionId":"9606351c-ffc7-4fec-bf69-42ee96ec9659","outputTokens":5,"requestId":"8AE6:34351:1619720:1992F62:69E9C129"},"id":"a06c95a9-52cc-4f1c-8790-0b7400a80ef2","timestamp":"2026-04-23T06:54:02.234Z","parentId":"6052f203-493e-4a7b-aa96-94e8a3089c84"}
+{"type":"assistant.turn_end","data":{"turnId":"0"},"id":"c6592e58-599c-44e2-9211-7d7541acdd25","timestamp":"2026-04-23T06:54:02.236Z","parentId":"a06c95a9-52cc-4f1c-8790-0b7400a80ef2"}
+{"type":"result","timestamp":"2026-04-23T06:54:02.355Z","sessionId":"33333333-3333-4333-8333-333333333333","exitCode":0,"usage":{"premiumRequests":0,"totalApiDurationMs":2743,"sessionDurationMs":6363,"codeChanges":{"linesAdded":0,"linesRemoved":0,"filesModified":[]}}}