coding-agent-wrapper 0.1.1__tar.gz → 0.1.4__tar.gz

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-agent-wrapper
-Version: 0.1.1
+Version: 0.1.4
 Summary: Unified Python library and CLI for orchestrating coding agents (Claude Code, Codex, etc.) with MCP tool servers and credential management.
 Project-URL: Homepage, https://github.com/zzjas/caw
 Project-URL: Repository, https://github.com/zzjas/caw
@@ -30,7 +30,7 @@ Description-Content-Type: text/markdown
 
 # caw
 
-**Coding Agent Wrapper** — a Python library and CLI for orchestrating coding agents (Claude Code, Codex) with a unified interface, MCP tool servers, and credential management for Docker containers.
+**Coding Agent Wrapper** — a Python library and CLI for orchestrating coding agents (Claude Code, Codex, opencode) with a unified interface, MCP tool servers, and credential management for Docker containers.
 
 ## Install
 
@@ -91,6 +91,7 @@ with agent.start_session() as session:
 |----------|-----|---------------|
 | Claude Code | `claude` | `claude_code` |
 | Codex | `codex` | `codex` |
+| opencode | `opencode` | `opencode` |
 
 Set via constructor, environment variable, or at runtime:
 
@@ -197,7 +198,7 @@ Sessions are persisted to JSONL in `caw_data/` by default.
 
 ## CLI: `caw auth` — Credential Management for Docker Containers
 
-Manages coding agent OAuth credentials so they stay in sync between your host and Docker containers. Supports Claude Code and Codex. Host credential files are never modified — they are bind-mounted into the container at run time.
+Manages coding agent OAuth credentials so they stay in sync between your host and Docker containers. Supports Claude Code, Codex, and opencode. Host credential files are never modified — they are bind-mounted into the container at run time.
 
 ```bash
 caw auth setup                        # snapshot configs, write mount manifest

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/README.md

@@ -1,6 +1,6 @@
 # caw
 
-**Coding Agent Wrapper** — a Python library and CLI for orchestrating coding agents (Claude Code, Codex) with a unified interface, MCP tool servers, and credential management for Docker containers.
+**Coding Agent Wrapper** — a Python library and CLI for orchestrating coding agents (Claude Code, Codex, opencode) with a unified interface, MCP tool servers, and credential management for Docker containers.
 
 ## Install
 
@@ -61,6 +61,7 @@ with agent.start_session() as session:
 |----------|-----|---------------|
 | Claude Code | `claude` | `claude_code` |
 | Codex | `codex` | `codex` |
+| opencode | `opencode` | `opencode` |
 
 Set via constructor, environment variable, or at runtime:
 
@@ -167,7 +168,7 @@ Sessions are persisted to JSONL in `caw_data/` by default.
 
 ## CLI: `caw auth` — Credential Management for Docker Containers
 
-Manages coding agent OAuth credentials so they stay in sync between your host and Docker containers. Supports Claude Code and Codex. Host credential files are never modified — they are bind-mounted into the container at run time.
+Manages coding agent OAuth credentials so they stay in sync between your host and Docker containers. Supports Claude Code, Codex, and opencode. Host credential files are never modified — they are bind-mounted into the container at run time.
 
 ```bash
 caw auth setup                        # snapshot configs, write mount manifest

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/caw/__init__.py

@@ -1,11 +1,23 @@
 """caw - Coding Agent Wrapper."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.4"
 
 from caw.agent import Agent, Session, register_provider
+from caw.auth import get_docker_flags as auth_get_docker_flags
+from caw.auth import get_status as auth_get_status
+from caw.auth import setup as auth_setup
 from caw.display import Display, DisplayMode, get_global_display, set_global_display
 from caw.faststats import FastStats
-from caw.storage import JsonlWriter, SessionStore
+from caw.logger import AgentLogger
+from caw.mcp import (
+    MCPServerHandle,
+    create_mcp_http_server_bundle,
+    create_stateless_tool_server,
+    create_subagent_tool_server,
+    get_state_from_context,
+    mcp_tool,
+    register_tool,
+)
 from caw.models import (
     AgentSpec,
     ContentBlock,
@@ -24,30 +36,25 @@ from caw.models import (
 from caw.provider import Provider, ProviderSession
 from caw.providers.claude_code import ClaudeCodeProvider
 from caw.providers.codex import CodexProvider
-from caw.mcp import (
-    MCPServerHandle,
-    create_mcp_http_server_bundle,
-    create_stateless_tool_server,
-    create_subagent_tool_server,
-    get_state_from_context,
-    mcp_tool,
-    register_tool,
-)
+from caw.providers.opencode import OpencodeProvider
+from caw.storage import JsonlWriter, SessionStore
 from caw.toolkit import ToolKit, tool
 from caw.viewer import ViewerServer, start_viewer_server
-from caw.auth import setup as auth_setup, get_status as auth_get_status, get_docker_flags as auth_get_docker_flags
 
 # Auto-register built-in providers
 register_provider("claude_code", ClaudeCodeProvider)
 register_provider("claude", ClaudeCodeProvider)
 register_provider("cc", ClaudeCodeProvider)
 register_provider("codex", CodexProvider)
+register_provider("opencode", OpencodeProvider)
 
 __all__ = [
     "Agent",
+    "AgentLogger",
     "AgentSpec",
     "ClaudeCodeProvider",
     "CodexProvider",
+    "OpencodeProvider",
     "JsonlWriter",
     "ContentBlock",
     "InteractiveResult",

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/caw/agent.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from typing import Any
 
 from caw.display import get_global_display
+from caw.logger import AgentLogger
 from caw.models import AgentSpec, InteractiveResult, MCPServer, ModelTier, ToolGroup, ToolUse, Trajectory, Turn
 from caw.provider import Provider, ProviderSession
 from caw.storage import SessionStore
@@ -103,6 +104,7 @@ class Session:
         tool_handles: list[Any] | None = None,
         auto_wait: bool = True,
         metadata: dict[str, Any] | None = None,
+        logger: AgentLogger | None = None,
     ) -> None:
         self._session = provider_session
         self._store = store
@@ -114,6 +116,9 @@ class Session:
         self._send_lock = threading.Lock()
         self._async_send_lock: asyncio.Lock | None = None
         self._traj_path: str | Path | None = None
+        self._logger = logger
+        if logger is not None:
+            self._session.set_logger(logger)
 
     async def send_async(self, message: str) -> Turn:
         """Async version of :meth:`send` — runs in a thread.
@@ -296,12 +301,14 @@ class Agent:
         stateless_tools: list[Any] | None = None,
         name: str = "",
         description: str = "",
+        logger: AgentLogger | None = None,
         **kwargs: Any,
     ) -> None:
         self._provider_name = provider
         self._provider: Provider | None = None
         self._mcp_servers: list[MCPServer] = []
         self._subagents: list[AgentSpec] = []
+        self._logger = logger
         self._tool_servers: list[Any] = []  # list[MCPServerHandle], lazy import
         if tool_servers:
             for ts in tool_servers:
@@ -504,12 +511,19 @@ class Agent:
         traj_path:
             If set, the trajectory is saved to this path after each
             step and when :meth:`Session.end` is called.
+        logger:
+            Optional generic logger (any object with ``info``/``warn``/
+            ``error`` string methods). If set, every major event — user
+            message, tool call, tool result, assistant text, thinking,
+            turn-end stats — is also emitted as a one-line summary
+            through it. See :mod:`caw.logger`.
         """
         merged = {**self._kwargs, **kwargs}
 
-        # Pop auto_wait and metadata — these are Session concerns, not provider kwargs
+        # Pop auto_wait, metadata, logger — these are Session concerns, not provider kwargs
         auto_wait = merged.pop("auto_wait", True)
         session_metadata: dict[str, Any] = merged.pop("metadata", {})
+        logger: AgentLogger | None = merged.pop("logger", None) or self._logger
         # Agent-level metadata as base, session kwargs override
         if self._metadata:
             session_metadata = {**self._metadata, **session_metadata}
@@ -567,6 +581,7 @@ class Agent:
             tool_handles=all_handles,
             auto_wait=auto_wait,
             metadata=session_metadata,
+            logger=logger,
         )
 
         if traj_path is not None:

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/caw/auth/providers.py

@@ -259,6 +259,78 @@ class CodexAuthProvider(AgentAuthProvider):
         return files
 
 
+# ---------------------------------------------------------------------------
+# opencode
+# ---------------------------------------------------------------------------
+
+
+class OpencodeAuthProvider(AgentAuthProvider):
+    name = "opencode"
+
+    def validate(self, src_home: Path) -> list[str]:
+        missing: list[str] = []
+        if not (src_home / ".local" / "share" / "opencode" / "auth.json").exists():
+            missing.append(str(src_home / ".local" / "share" / "opencode" / "auth.json"))
+        return missing
+
+    def describe(self, src_home: Path) -> str:
+        try:
+            with open(src_home / ".local" / "share" / "opencode" / "auth.json") as f:
+                auth_data = json.load(f)
+            providers = list(auth_data.keys())
+            if not providers:
+                return "Auth file present (no providers configured)"
+            kinds = []
+            for p in providers:
+                entry = auth_data.get(p) or {}
+                kinds.append(f"{p}({entry.get('type', 'unknown')})")
+            return f"Providers: {', '.join(kinds)}"
+        except Exception:
+            return "Could not read auth info"
+
+    def collect(self, src_home: Path) -> list[CollectedFile]:
+        files: list[CollectedFile] = []
+
+        # auth.json — credential (bind-mounted for token refresh write-back)
+        auth_src = src_home / ".local" / "share" / "opencode" / "auth.json"
+        with open(auth_src, "rb") as f:
+            auth_content = f.read()
+        files.append(
+            CollectedFile(
+                manifest_file=ManifestFile(
+                    src="opencode/auth.json",
+                    container_target=".local/share/opencode/auth.json",
+                    host_original=".local/share/opencode/auth.json",
+                    type="credential",
+                    strategy="bind",
+                    mode="0600",
+                ),
+                content=auth_content,
+            )
+        )
+
+        # opencode.jsonc / opencode.json — config, copied (no local-project paths to strip)
+        for fname in ("opencode.jsonc", "opencode.json"):
+            cfg = src_home / ".config" / "opencode" / fname
+            if cfg.exists():
+                files.append(
+                    CollectedFile(
+                        manifest_file=ManifestFile(
+                            src=f"opencode/{fname}",
+                            container_target=f".config/opencode/{fname}",
+                            host_original=f".config/opencode/{fname}",
+                            type="config",
+                            strategy="copy",
+                            mode="0644",
+                        ),
+                        content=cfg.read_bytes(),
+                    )
+                )
+                break  # only one of the two should exist
+
+        return files
+
+
 # ---------------------------------------------------------------------------
 # Provider registry
 # ---------------------------------------------------------------------------
@@ -268,5 +340,6 @@ PROVIDERS: dict[str, AgentAuthProvider] = {
     for p in [
         ClaudeAuthProvider(),
         CodexAuthProvider(),
+        OpencodeAuthProvider(),
     ]
 }

coding_agent_wrapper-0.1.4/caw/logger.py

@@ -0,0 +1,89 @@
+"""Generic logger protocol for caw.
+
+The Agent layer emits a one-line summary for every major event
+(tool call, tool result, assistant text, thinking, turn end) through
+this interface, in addition to the existing rich-console Display.
+
+Any object with ``info``/``warn``/``error`` string methods satisfies
+the protocol — including ``logging.Logger`` (after a tiny adapter for
+``warn``→``warning``) and the project's own ``RedisLogger``. Pass an
+instance via ``Agent(logger=...)`` or ``agent.start_session(logger=...)``.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Protocol, runtime_checkable
+
+from caw.models import TextBlock, ThinkingBlock, ToolUse, UsageStats
+
+
+@runtime_checkable
+class AgentLogger(Protocol):
+    """Minimal logger surface used by caw."""
+
+    def info(self, message: str) -> None: ...
+    def warn(self, message: str) -> None: ...
+    def error(self, message: str) -> None: ...
+
+
+def _truncate(text: str, max_len: int = 200) -> str:
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 1] + "…"
+
+
+def log_tool_call(logger: AgentLogger | None, block: ToolUse) -> None:
+    if logger is None:
+        return
+    try:
+        args = json.dumps(block.arguments, separators=(",", ":"))
+    except (TypeError, ValueError):
+        args = str(block.arguments)
+    logger.info(f"tool_call {block.name} {_truncate(args)}")
+
+
+def log_tool_result(logger: AgentLogger | None, block: ToolUse) -> None:
+    if logger is None:
+        return
+    tag = "tool_error" if block.is_error else "tool_result"
+    logger.info(f"{tag} {block.name} → {_truncate(block.output or '')}")
+
+
+def log_text(logger: AgentLogger | None, block: TextBlock) -> None:
+    if logger is None or not block.text:
+        return
+    logger.info(f"assistant {_truncate(block.text)}")
+
+
+def log_thinking(logger: AgentLogger | None, block: ThinkingBlock) -> None:
+    if logger is None or not block.text:
+        return
+    logger.info(f"thinking {_truncate(block.text)}")
+
+
+def log_turn_end(logger: AgentLogger | None, usage: UsageStats, duration_ms: int) -> None:
+    if logger is None:
+        return
+    parts = [
+        f"duration={duration_ms}ms",
+        f"tokens={usage.input_tokens}in/{usage.output_tokens}out",
+    ]
+    if usage.cost_usd:
+        parts.append(f"cost=${usage.cost_usd:.4f}")
+    logger.info("turn_end " + " ".join(parts))
+
+
+def log_user_message(logger: AgentLogger | None, message: str) -> None:
+    if logger is None:
+        return
+    logger.info(f"user {_truncate(message)}")
+
+
+def log_metadata(logger: AgentLogger | None, **kwargs: str) -> None:
+    if logger is None:
+        return
+    pairs = [f"{k}={v}" for k, v in kwargs.items() if v]
+    if pairs:
+        logger.info("metadata " + " ".join(pairs))

coding_agent_wrapper-0.1.4/caw/pricing.json

@@ -0,0 +1,32 @@
+{
+  "_comment": "Pricing in USD per 1 million tokens, keyed by agent then model",
+  "codex": {
+    "gpt-5.2-codex": {
+      "input": 1.75,
+      "cached_input": 0.175,
+      "output": 14.0
+    },
+    "gpt-5.3-codex": {
+      "input": 1.75,
+      "cached_input": 0.175,
+      "output": 14.0
+    }
+  },
+  "opencode": {
+    "openai/gpt-5.3-codex": {
+      "input": 1.75,
+      "cached_input": 0.175,
+      "output": 14.0
+    },
+    "openai/gpt-5.3-codex-spark": {
+      "input": 0.25,
+      "cached_input": 0.025,
+      "output": 2.0
+    },
+    "openai/gpt-5.2-codex": {
+      "input": 1.75,
+      "cached_input": 0.175,
+      "output": 14.0
+    }
+  }
+}

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/caw/provider.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import Any
 
+from caw.logger import AgentLogger
 from caw.models import InteractiveResult, MCPServer, ModelTier, ToolGroup, Trajectory, Turn
 
 
@@ -51,6 +52,10 @@ class ProviderSession(ABC):
         """Set callback invoked after each step within send()."""
         pass  # default no-op; concrete providers override
 
+    def set_logger(self, logger: AgentLogger | None) -> None:
+        """Attach a generic logger that receives a one-line summary per event."""
+        pass  # default no-op; concrete providers override
+
 
 class Provider(ABC):
     """ABC that each coding agent backend implements."""

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/caw/providers/claude_code.py

@@ -14,6 +14,16 @@ from datetime import datetime, timedelta, timezone
 from typing import Any
 
 from caw.display import Display, get_global_display
+from caw.logger import (
+    AgentLogger,
+    log_metadata,
+    log_text,
+    log_thinking,
+    log_tool_call,
+    log_tool_result,
+    log_turn_end,
+    log_user_message,
+)
 from caw.models import (
     ContentBlock,
     InteractiveResult,
@@ -167,6 +177,7 @@ class ClaudeCodeSession(ProviderSession):
         self._mcp_config_path: str | None = None
         self._last_raw_output: str = ""
         self._step_callback = None
+        self._logger: AgentLogger | None = None
 
     # ------------------------------------------------------------------
     # MCP config helpers
@@ -210,6 +221,14 @@ class ClaudeCodeSession(ProviderSession):
                     session=self._session_id,
                 )
             display.on_user_message(message)
+        if not self._has_sent:
+            log_metadata(
+                self._logger,
+                agent="claude_code",
+                model=self._model or "",
+                session=self._session_id,
+            )
+        log_user_message(self._logger, message)
 
         cmd = [
             "claude",
@@ -304,6 +323,7 @@ class ClaudeCodeSession(ProviderSession):
 
         if display:
             display.on_turn_end(turn.result, usage, duration_ms)
+        log_turn_end(self._logger, usage, duration_ms)
 
         self._turns.append(turn)
         self._total_usage = self._total_usage + turn.usage
@@ -321,6 +341,9 @@ class ClaudeCodeSession(ProviderSession):
     def set_step_callback(self, callback):
         self._step_callback = callback
 
+    def set_logger(self, logger: AgentLogger | None) -> None:
+        self._logger = logger
+
     # ------------------------------------------------------------------
     # Per-event processing
     # ------------------------------------------------------------------
@@ -340,19 +363,25 @@ class ClaudeCodeSession(ProviderSession):
                 self._model = event.get("model", "")
                 if display and self._model:
                     display.on_metadata(model=self._model)
+                if self._model:
+                    log_metadata(self._logger, model=self._model)
 
         elif event_type == "assistant":
             new_blocks = self._parse_assistant_blocks(event)
             for block in new_blocks:
                 blocks.append(block)
-                if display:
-                    if isinstance(block, TextBlock):
+                if isinstance(block, TextBlock):
+                    if display:
                         display.on_text(block)
-                    elif isinstance(block, ThinkingBlock):
+                    log_text(self._logger, block)
+                elif isinstance(block, ThinkingBlock):
+                    if display:
                         display.on_thinking(block)
-                    elif isinstance(block, ToolUse):
+                    log_thinking(self._logger, block)
+                elif isinstance(block, ToolUse):
+                    if display:
                         display.on_tool_call(block)
-                if isinstance(block, ToolUse):
+                    log_tool_call(self._logger, block)
                     tool_blocks[block.id] = block
 
         elif event_type == "user":
@@ -385,6 +414,7 @@ class ClaudeCodeSession(ProviderSession):
                             tool_blocks[tid].is_error = is_error
                             if display:
                                 display.on_tool_result(tool_blocks[tid])
+                            log_tool_result(self._logger, tool_blocks[tid])
 
         elif event_type == "result":
             return self._parse_usage(event), event.get("duration_ms", 0)
@@ -461,6 +491,7 @@ class ClaudeCodeSession(ProviderSession):
             turns=list(self._turns),
             usage=self._total_usage,
             duration_ms=self._total_duration_ms,
+            reasoning=self._reasoning or "",
             metadata={},
         )
 

{coding_agent_wrapper-0.1.1 → coding_agent_wrapper-0.1.4}/caw/providers/codex.py

@@ -14,6 +14,16 @@ from pathlib import Path
 from typing import Any
 
 from caw.display import Display, get_global_display
+from caw.logger import (
+    AgentLogger,
+    log_metadata,
+    log_text,
+    log_thinking,
+    log_tool_call,
+    log_tool_result,
+    log_turn_end,
+    log_user_message,
+)
 from caw.models import (
     ContentBlock,
     MCPServer,
@@ -163,10 +173,14 @@ class CodexSession(ProviderSession):
         self._total_duration_ms = 0
         self._last_raw_output: str = ""
         self._step_callback = None
+        self._logger: AgentLogger | None = None
 
     def set_step_callback(self, callback):
         self._step_callback = callback
 
+    def set_logger(self, logger: AgentLogger | None) -> None:
+        self._logger = logger
+
     # ------------------------------------------------------------------
     # MCP config helpers
     # ------------------------------------------------------------------
@@ -198,6 +212,14 @@ class CodexSession(ProviderSession):
                     session=self._session_id,
                 )
             display.on_user_message(message)
+        if not self._has_sent:
+            log_metadata(
+                self._logger,
+                agent="codex",
+                model=self._model or "",
+                session=self._session_id,
+            )
+        log_user_message(self._logger, message)
 
         # Build the prompt (prepend system prompt on first turn)
         prompt = message
@@ -300,6 +322,7 @@ class CodexSession(ProviderSession):
 
         if display:
             display.on_turn_end(turn.result, usage, 0)
+        log_turn_end(self._logger, usage, 0)
 
         self._turns.append(turn)
         self._total_usage = self._total_usage + turn.usage
@@ -345,6 +368,7 @@ class CodexSession(ProviderSession):
                 tool_blocks[tool_id] = block
                 if display:
                     display.on_tool_call(block)
+                log_tool_call(self._logger, block)
 
             elif item_type == "mcp_tool_call":
                 server = item.get("server", "")
@@ -359,6 +383,7 @@ class CodexSession(ProviderSession):
                 tool_blocks[tool_id] = block
                 if display:
                     display.on_tool_call(block)
+                log_tool_call(self._logger, block)
 
             elif item_type == "file_change":
                 block = ToolUse(
@@ -370,6 +395,7 @@ class CodexSession(ProviderSession):
                 tool_blocks[tool_id] = block
                 if display:
                     display.on_tool_call(block)
+                log_tool_call(self._logger, block)
 
         elif event_type in ("item.completed", "item.updated"):
             item = event.get("item", {})
@@ -383,6 +409,8 @@ class CodexSession(ProviderSession):
                     tool_blocks[tool_id].is_error = item.get("exit_code", 0) != 0
                     if display and is_final:
                         display.on_tool_result(tool_blocks[tool_id])
+                    if is_final:
+                        log_tool_result(self._logger, tool_blocks[tool_id])
 
             elif item_type == "mcp_tool_call":
                 tool_id = item.get("id", "")
@@ -406,6 +434,8 @@ class CodexSession(ProviderSession):
                         tool_blocks[tool_id].is_error = True
                     if display and is_final:
                         display.on_tool_result(tool_blocks[tool_id])
+                    if is_final:
+                        log_tool_result(self._logger, tool_blocks[tool_id])
 
             elif item_type == "file_change":
                 tool_id = item.get("id", "")
@@ -413,6 +443,8 @@ class CodexSession(ProviderSession):
                     tool_blocks[tool_id].output = item.get("patch", item.get("content", ""))
                     if display and is_final:
                         display.on_tool_result(tool_blocks[tool_id])
+                    if is_final:
+                        log_tool_result(self._logger, tool_blocks[tool_id])
 
             elif item_type == "reasoning" and is_final:
                 text = item.get("text", "")
@@ -421,6 +453,7 @@ class CodexSession(ProviderSession):
                     blocks.append(block)
                     if display:
                         display.on_thinking(block)
+                    log_thinking(self._logger, block)
 
             elif item_type == "agent_message" and is_final:
                 text = item.get("text", "")
@@ -429,6 +462,7 @@ class CodexSession(ProviderSession):
                     blocks.append(block)
                     if display:
                         display.on_text(block)
+                    log_text(self._logger, block)
 
         elif event_type == "turn.completed":
             return self._parse_usage(event)
@@ -446,7 +480,10 @@ class CodexSession(ProviderSession):
                 blocks.append(block)
                 if display:
                     display.on_text(block)
+                log_text(self._logger, block)
             else:
+                if self._logger:
+                    self._logger.error(f"codex turn failed: {error_msg}")
                 raise RuntimeError(f"Codex turn failed: {error_msg}")
 
         return None