machinaos 0.0.78 → 0.0.80

package/server/services/cli_agent/mcp_server.py

@@ -26,7 +26,6 @@ Tools deferred to v2: ``getDiagnostics``, ``executeCode``.
 from __future__ import annotations
 
 import contextvars
-import logging
 import secrets
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -35,7 +34,6 @@ from typing import Any, Awaitable, Callable, Dict, List, Optional, Set
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
 from starlette.responses import JSONResponse, Response
-from starlette.routing import Mount
 
 from core.logging import get_logger
 
@@ -46,6 +44,7 @@ logger = get_logger(__name__)
 # BatchContext + token registry
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class BatchContext:
     """Scoping data attached to one batch's bearer token.
@@ -54,6 +53,7 @@ class BatchContext:
     ``finally`` block. Tools dereference the calling batch via the
     bearer token in `Authorization` header.
     """
+
     workflow_id: str
     node_id: str
     workspace_dir: Path
@@ -91,15 +91,18 @@ def register_batch(token: str, ctx: BatchContext) -> None:
     _active_tokens[token] = ctx
     tool_names = [t.get("node_type") for t in ctx.connected_tools]
     logger.info(
-        "[CC-Agent MCP register_batch] node=%s wf=%s token=%s... "
-        "skills=%d tools=%d creds=%d %s",
-        ctx.node_id, ctx.workflow_id, token[:8],
-        len(ctx.connected_skill_names), len(ctx.connected_tools),
+        "[CC-Agent MCP register_batch] node=%s wf=%s token=%s... " "skills=%d tools=%d creds=%d %s",
+        ctx.node_id,
+        ctx.workflow_id,
+        token[:8],
+        len(ctx.connected_skill_names),
+        len(ctx.connected_tools),
         len(ctx.allowed_credentials),
         f"tools={tool_names}" if tool_names else "(no tools wired)",
     )
     # Per-batch workflow-tool exposure lives in workflow_tools.py.
     from services.cli_agent.workflow_tools import expose_workflow_tools
+
     expose_workflow_tools(ctx.connected_tools)
 
 
@@ -111,6 +114,7 @@ def unregister_batch(token: str) -> None:
         return
     logger.debug("[CC-Agent MCP] unregistered batch token=%s...", token[:8])
     from services.cli_agent.workflow_tools import unexpose_workflow_tools
+
     unexpose_workflow_tools(ctx.connected_tools)
 
 
@@ -118,6 +122,72 @@ def lookup_batch(token: str) -> Optional[BatchContext]:
     return _active_tokens.get(token)
 
 
+def rebind_batch(
+    token: str,
+    *,
+    connected_tools: Optional[List[Dict[str, Any]]] = None,
+    connected_skill_names: Optional[Set[str]] = None,
+    allowed_credentials: Optional[Set[str]] = None,
+    workspace_dir: Optional[Path] = None,
+) -> Optional[BatchContext]:
+    """In-place rebind of an existing batch's surface.
+
+    Used by :class:`ClaudeSessionPool` on warm-subprocess reuse:
+    claude bakes the bearer token into its argv at spawn time (via
+    ``--mcp-config``), so a warm subprocess keeps hitting the SAME
+    token across batches. If the operator disconnects a tool between
+    batches, the bearer-token's :class:`BatchContext` must be updated
+    in place — otherwise the per-handler scope check in
+    ``workflow_tools._build_handler`` still sees the stale
+    ``connected_tools`` and lets disconnected tools fire.
+
+    For ``connected_tools``: refcount diff is applied to FastMCP — any
+    node_type that's in the OLD list but not the new gets one
+    :func:`unexpose_workflow_tools` decrement (may remove the tool
+    from FastMCP when its refcount hits zero); any node_type that's
+    new gets one :func:`expose_workflow_tools` increment. Tools that
+    survive in both lists are left alone but their ``parameters`` /
+    ``label`` fields are refreshed via the in-place list assignment.
+
+    Returns the rebound context, or ``None`` if the token is unknown.
+    """
+    ctx = _active_tokens.get(token)
+    if ctx is None:
+        return None
+    if connected_tools is not None:
+        from services.cli_agent.workflow_tools import (
+            expose_workflow_tools,
+            unexpose_workflow_tools,
+        )
+
+        old_by_type = {t.get("node_type"): t for t in ctx.connected_tools if t.get("node_type")}
+        new_by_type = {t.get("node_type"): t for t in connected_tools if t.get("node_type")}
+        added = [v for k, v in new_by_type.items() if k not in old_by_type]
+        removed = [v for k, v in old_by_type.items() if k not in new_by_type]
+        if removed:
+            unexpose_workflow_tools(removed)
+        if added:
+            expose_workflow_tools(added)
+        ctx.connected_tools = list(connected_tools)
+        logger.info(
+            "[CC-Agent MCP rebind_batch] node=%s wf=%s token=%s... " "+%d -%d kept=%d (now %d tools)",
+            ctx.node_id,
+            ctx.workflow_id,
+            token[:8],
+            len(added),
+            len(removed),
+            len(old_by_type.keys() & new_by_type.keys()),
+            len(ctx.connected_tools),
+        )
+    if connected_skill_names is not None:
+        ctx.connected_skill_names = set(connected_skill_names)
+    if allowed_credentials is not None:
+        ctx.allowed_credentials = set(allowed_credentials)
+    if workspace_dir is not None:
+        ctx.workspace_dir = Path(workspace_dir).resolve()
+    return ctx
+
+
 def active_batch_count() -> int:
     return len(_active_tokens)
 
@@ -126,18 +196,13 @@ def active_batch_count() -> int:
 # ContextVar — thread/task-local handle to the current batch
 # ---------------------------------------------------------------------------
 
-_current_batch: contextvars.ContextVar[Optional[BatchContext]] = (
-    contextvars.ContextVar("machina_current_batch", default=None)
-)
+_current_batch: contextvars.ContextVar[Optional[BatchContext]] = contextvars.ContextVar("machina_current_batch", default=None)
 
 
 def _require_batch() -> BatchContext:
     ctx = _current_batch.get()
     if ctx is None:
-        raise RuntimeError(
-            "MCP tool called without an active batch context. "
-            "This indicates the auth middleware was bypassed."
-        )
+        raise RuntimeError("MCP tool called without an active batch context. " "This indicates the auth middleware was bypassed.")
     return ctx
 
 
@@ -152,6 +217,7 @@ def _require_batch() -> BatchContext:
 # Auth middleware
 # ---------------------------------------------------------------------------
 
+
 class _BearerAuthMiddleware(BaseHTTPMiddleware):
     """Validate `Authorization: Bearer <token>` against the registry.
 
@@ -173,9 +239,7 @@ class _BearerAuthMiddleware(BaseHTTPMiddleware):
         if path.endswith("/healthz"):
             return await call_next(request)
 
-        auth = request.headers.get("authorization") or request.headers.get(
-            "Authorization"
-        )
+        auth = request.headers.get("authorization") or request.headers.get("Authorization")
         token: Optional[str] = None
         if auth and auth.lower().startswith("bearer "):
             token = auth[7:].strip() or None
@@ -186,7 +250,10 @@ class _BearerAuthMiddleware(BaseHTTPMiddleware):
                 "[CC-Agent MCP auth] %s %s -> 401 (no Bearer token; "
                 "auth_header=%r ua=%r) — claude CLI either didn't read the "
                 "lockfile or is hitting the wrong URL.",
-                method, path, auth, ua,
+                method,
+                path,
+                auth,
+                ua,
             )
             return JSONResponse(
                 {"error": "missing or malformed Authorization header"},
@@ -196,9 +263,10 @@ class _BearerAuthMiddleware(BaseHTTPMiddleware):
         ctx = lookup_batch(token)
         if ctx is None:
             logger.warning(
-                "[CC-Agent MCP auth] %s %s -> 401 (token=%s... not in "
-                "active registry — batch may have ended)",
-                method, path, token[:8],
+                "[CC-Agent MCP auth] %s %s -> 401 (token=%s... not in " "active registry — batch may have ended)",
+                method,
+                path,
+                token[:8],
             )
             return JSONResponse(
                 {"error": "invalid or expired token"},
@@ -207,7 +275,11 @@ class _BearerAuthMiddleware(BaseHTTPMiddleware):
 
         logger.info(
             "[CC-Agent MCP auth] %s %s -> OK (node=%s wf=%s token=%s...)",
-            method, path, ctx.node_id, ctx.workflow_id, token[:8],
+            method,
+            path,
+            ctx.node_id,
+            ctx.workflow_id,
+            token[:8],
         )
 
         reset_token = _current_batch.set(ctx)
@@ -221,6 +293,7 @@ class _BearerAuthMiddleware(BaseHTTPMiddleware):
 # Tool registration helper — defers FastMCP import so module import is cheap
 # ---------------------------------------------------------------------------
 
+
 def _build_tools(mcp: Any) -> None:  # FastMCP type
     """Register the 5 v1 tools on a `FastMCP` instance."""
 
@@ -272,9 +345,7 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
                     }
                     if read and p.stat().st_size <= max_bytes:
                         try:
-                            info["content"] = p.read_text(
-                                encoding="utf-8", errors="replace"
-                            )
+                            info["content"] = p.read_text(encoding="utf-8", errors="replace")
                         except OSError as exc:
                             info["read_error"] = str(exc)
                     entries.append(info)
@@ -301,6 +372,7 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
         ctx = _require_batch()
         try:
             from services.skill_loader import get_skill_loader
+
             loader = get_skill_loader()
             registry = loader.scan_skills()
             results = []
@@ -308,15 +380,14 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
                 meta = registry.get(name)
                 if meta is None:
                     continue
-                results.append({
-                    "name": meta.name,
-                    "description": meta.description,
-                    "allowed_tools": list(meta.allowed_tools),
-                    "category": (
-                        meta.metadata.get("category")
-                        if isinstance(meta.metadata, dict) else None
-                    ),
-                })
+                results.append(
+                    {
+                        "name": meta.name,
+                        "description": meta.description,
+                        "allowed_tools": list(meta.allowed_tools),
+                        "category": (meta.metadata.get("category") if isinstance(meta.metadata, dict) else None),
+                    }
+                )
             return {"skills": results}
         except Exception as exc:  # pragma: no cover
             logger.exception("[CC-Agent MCP] listSkills failed")
@@ -339,6 +410,7 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
             }
         try:
             from services.skill_loader import get_skill_loader
+
             loader = get_skill_loader()
             skill = loader.load_skill(name)
             if skill is None:
@@ -375,6 +447,7 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
             }
         try:
             from core.container import container
+
             auth = container.auth_service()
             value = await auth.get_api_key(name)
             if not value:
@@ -413,6 +486,7 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
             broadcaster = ctx.broadcaster
             if broadcaster is None:
                 from services.status_broadcaster import get_status_broadcaster
+
                 broadcaster = get_status_broadcaster()
             payload = {
                 "source": source or f"mcp:{ctx.node_id}",
@@ -432,7 +506,7 @@ def _build_tools(mcp: Any) -> None:  # FastMCP type
 
 _app_singleton: Optional[Any] = None  # Starlette app
 _mcp_singleton: Optional[Any] = None  # FastMCP instance — used by per-batch
-                                       # dynamic tool (un)registration.
+# dynamic tool (un)registration.
 
 
 def get_mcp_app() -> Any:
@@ -471,6 +545,7 @@ def get_mcp_app() -> Any:
 # Test/diagnostic helpers (used by tests + verification step #11/#12)
 # ---------------------------------------------------------------------------
 
+
 def _reset_for_tests() -> None:  # pragma: no cover
     """Wipe the token registry + per-batch workflow-tool refcounts.
     ONLY use in tests."""
@@ -479,4 +554,5 @@ def _reset_for_tests() -> None:  # pragma: no cover
     _app_singleton = None
     _mcp_singleton = None
     from services.cli_agent.workflow_tools import _reset_for_tests as _wt_reset
+
     _wt_reset()

package/server/services/cli_agent/protocol.py

@@ -25,6 +25,7 @@ from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
 # Shared data types
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class CanonicalUsage:
     """Vendor-normalised token counts.
@@ -34,6 +35,7 @@ class CanonicalUsage:
     differently) maps into this so the existing `services/pricing.py`
     can compute USD without per-vendor branches.
     """
+
     input_tokens: int = 0
     output_tokens: int = 0
     cache_read: int = 0
@@ -48,6 +50,7 @@ class SessionResult:
 
     Shared keys are the schema; vendor extras live in `provider_data`.
     """
+
     task_id: str
     session_id: Optional[str] = None
     provider: str = ""
@@ -68,6 +71,7 @@ class SessionResult:
 @dataclass
 class BatchResult:
     """Aggregated result returned by `AICliService.run_batch()`."""
+
     tasks: List[SessionResult] = field(default_factory=list)
     n_tasks: int = 0
     n_succeeded: int = 0
@@ -83,48 +87,57 @@ class BatchResult:
 # Provider protocol (structural typing)
 # ---------------------------------------------------------------------------
 
+
 @runtime_checkable
 class AICliProvider(Protocol):
     """Structural Protocol for an AI CLI provider.
 
     Concrete classes:
-      - `providers.anthropic_claude.AnthropicClaudeProvider`
+      - `nodes.agent.claude_code_agent._provider.AnthropicClaudeProvider`
       - `providers.openai_codex.OpenAICodexProvider`
       - `providers.google_gemini.GoogleGeminiProvider` (v2 stub)
     """
 
-    name: str                          # "claude" | "codex" | "gemini"
-    package_name: str                  # npm package
-    binary_name: str                   # "claude" | "codex" | "gemini"
-    ide_lock_env_var: Optional[str]    # CLAUDE_IDE_LOCK | GEMINI_IDE_LOCK | None
-    ide_lockfile_dir: Optional[Path]   # ~/.claude/ide | <tmpdir>/gemini/ide
+    name: str  # "claude" | "codex" | "gemini"
+    package_name: str  # npm package
+    binary_name: str  # "claude" | "codex" | "gemini"
+    ide_lock_env_var: Optional[str]  # CLAUDE_IDE_LOCK | GEMINI_IDE_LOCK | None
+    ide_lockfile_dir: Optional[Path]  # <MACHINA_CLAUDE_DIR>/ide | <tmpdir>/gemini/ide
 
     # ---- spawn surface ---------------------------------------------------
 
-    def binary_path(self) -> Path: ...
+    def binary_path(self) -> Path:
+        ...
         # Resolve the CLI binary. Resolution chain (Composio pattern):
         #   1) shutil.which(<binary_name>)
         #   2) `npx --yes <package_name>` shim path
         # Raises FileNotFoundError if neither is available.
 
-    def headless_argv(self, task: Any, *, defaults: Dict[str, Any]) -> List[str]: ...
-        # Build the full argv (binary + flags) for a headless run of
-        # `task` (a `<Provider>TaskSpec` Pydantic model). `defaults`
-        # comes from `ai_cli_providers.json` for this provider.
+    def interactive_argv(self, task: Any, *, defaults: Dict[str, Any]) -> List[str]:
+        ...
+        # Build the full argv (binary + flags) for spawning a session
+        # over `task` (a `<Provider>TaskSpec` Pydantic model). For
+        # Claude, this is the interactive-TUI shape (no `-p`, prompt as
+        # positional after `--`); for Codex, it's `codex exec --json`
+        # since that's Codex's automation surface. `defaults` comes
+        # from `ai_cli_providers.json` for this provider.
 
     # ---- native auth (no token wrapping) --------------------------------
 
-    def login_argv(self) -> List[str]: ...
+    def login_argv(self) -> List[str]:
+        ...
         # CLI's own login command, e.g. ["claude", "login"]. Spawned
         # interactively from the Credentials Modal. CLI stores its own
         # credentials in `~/.claude/`, `~/.codex/`, `~/.gemini/`.
 
-    def auth_status_argv(self) -> Optional[List[str]]: ...
+    def auth_status_argv(self) -> Optional[List[str]]:
+        ...
         # No-op invocation to verify auth, e.g. ["claude", "--print", "-p", "ok"].
         # Returns None if no cheap probe exists; in that case the framework
         # infers from the first session's stderr.
 
-    def detect_auth_error(self, stderr: str, exit_code: int) -> bool: ...
+    def detect_auth_error(self, stderr: str, exit_code: int) -> bool:
+        ...
         # Match "not logged in" patterns:
         #   Claude: "Please run 'claude login'"
         #   Codex:  HTTP 401 / "OPENAI_API_KEY not set"
@@ -132,11 +145,13 @@ class AICliProvider(Protocol):
 
     # ---- streaming output parsing ---------------------------------------
 
-    def parse_event(self, line: str) -> Optional[Dict[str, Any]]: ...
+    def parse_event(self, line: str) -> Optional[Dict[str, Any]]:
+        ...
         # Parse a single NDJSON line from stdout. Return None for
         # un-parseable garbage.
 
-    def is_final_event(self, event: Dict[str, Any]) -> bool: ...
+    def is_final_event(self, event: Dict[str, Any]) -> bool:
+        ...
         # True if this event marks end-of-task. For Claude: `type=="result"`.
         # For Gemini: `type=="result"`. For Codex: `type=="complete"` or
         # heuristic fallback.
@@ -146,7 +161,8 @@ class AICliProvider(Protocol):
         events: List[Dict[str, Any]],
         stderr: str,
         exit_code: int,
-    ) -> Dict[str, Any]: ...
+    ) -> Dict[str, Any]:
+        ...
         # Reconstruct a partial dict of `SessionResult` fields from the
         # event stream. Returns:
         #   {
@@ -161,13 +177,15 @@ class AICliProvider(Protocol):
         # bloating the shared schema. Pattern from
         # Hermes agent/transports/types.py NormalizedResponse.
 
-    def canonical_usage(self, events: List[Dict[str, Any]]) -> CanonicalUsage: ...
+    def canonical_usage(self, events: List[Dict[str, Any]]) -> CanonicalUsage:
+        ...
         # Normalise vendor token-counting into the shared `CanonicalUsage`
         # shape. Pattern from Hermes agent/usage_pricing.py.
 
     # ---- feature gating --------------------------------------------------
 
-    def supports(self, feature: str) -> bool: ...
+    def supports(self, feature: str) -> bool:
+        ...
         # Feature flags consulted by the session/service layer.
         # Recognised: "max_budget", "max_turns", "session_id", "resume",
         # "mcp_runtime", "json_cost", "ide_lockfile", "sandbox".

package/server/services/cli_agent/providers/__init__.py

@@ -1,9 +1,13 @@
-"""Concrete `AICliProvider` implementations.
+"""Concrete `AICliProvider` implementations that still live under the
+generic framework (i.e. haven't been migrated to the canonical
+plugin-folder layout yet):
 
-- `anthropic_claude.AnthropicClaudeProvider` — full v1 surface
 - `openai_codex.OpenAICodexProvider` — sandbox-first, no session
 - `google_gemini.GoogleGeminiProvider` — v2 stub raising NotImplementedError
 
-Imports are intentionally not eager — `factory.create_cli_provider()`
-lazy-imports each one.
+The claude provider has moved to its plugin folder
+(``server/nodes/agent/claude_code_agent/_provider.py``) and is
+discovered via the ``register_provider`` registry. The codex
+provider will follow once `codex_agent` adopts the per-plugin
+folder structure.
 """

package/server/services/cli_agent/providers/google_gemini.py

@@ -30,10 +30,7 @@ class GoogleGeminiProvider:
     name = "gemini"
 
     def __init__(self) -> None:
-        raise NotImplementedError(
-            "GoogleGeminiProvider is a v2 stub. The factory raises "
-            "NotImplementedError for 'gemini' in v1."
-        )
+        raise NotImplementedError("GoogleGeminiProvider is a v2 stub. The factory raises " "NotImplementedError for 'gemini' in v1.")
 
     # The Protocol surface below is declared so static type-checkers see
     # the class as a complete `AICliProvider`. None of these are reachable
@@ -47,7 +44,16 @@ class GoogleGeminiProvider:
     def binary_path(self) -> Path:  # pragma: no cover
         raise NotImplementedError
 
-    def headless_argv(self, task: Any, *, defaults: Dict[str, Any]) -> List[str]:  # pragma: no cover
+    def interactive_argv(
+        self,
+        task: Any,
+        *,
+        defaults: Dict[str, Any],
+        mcp_endpoint_url: Optional[str] = None,
+        mcp_bearer_token: Optional[str] = None,
+        connected_tool_names: Optional[List[str]] = None,
+        include_prompt: bool = True,
+    ) -> List[str]:  # pragma: no cover
         raise NotImplementedError
 
     def login_argv(self) -> List[str]:  # pragma: no cover

package/server/services/cli_agent/providers/openai_codex.py

@@ -46,9 +46,15 @@ NAME = "codex"
 
 # Best-effort markers for Codex's "stream-end" / "task complete" event.
 # Update if/when OpenAI publishes a stable schema.
-_FINAL_EVENT_TYPES = frozenset({
-    "complete", "task_complete", "done", "finished", "result",
-})
+_FINAL_EVENT_TYPES = frozenset(
+    {
+        "complete",
+        "task_complete",
+        "done",
+        "finished",
+        "result",
+    }
+)
 
 _AUTH_ERROR_MARKERS = (
     "OPENAI_API_KEY not set",
@@ -68,9 +74,7 @@ class OpenAICodexProvider:
     def __init__(self) -> None:
         cfg = get_provider_config(NAME)
         if cfg is None:
-            raise RuntimeError(
-                f"Provider config missing for {NAME!r}. Check ai_cli_providers.json."
-            )
+            raise RuntimeError(f"Provider config missing for {NAME!r}. Check ai_cli_providers.json.")
         self.name = NAME
         self.package_name = cfg.package_name
         self.binary_name = cfg.binary_name
@@ -93,21 +97,29 @@ class OpenAICodexProvider:
             return Path(npx)
 
         raise FileNotFoundError(
-            f"Neither {self.binary_name!r} nor 'npx' found in PATH. "
-            f"Install with: npm install -g {self.package_name}"
+            f"Neither {self.binary_name!r} nor 'npx' found in PATH. " f"Install with: npm install -g {self.package_name}"
         )
 
-    def headless_argv(
+    def interactive_argv(
         self,
         task: Any,  # CodexTaskSpec
         *,
         defaults: Dict[str, Any],
+        mcp_endpoint_url: Optional[str] = None,
+        mcp_bearer_token: Optional[str] = None,
+        connected_tool_names: Optional[List[str]] = None,
+        include_prompt: bool = True,
     ) -> List[str]:
+        """Build the codex spawn argv. Codex's automation surface is
+        ``codex exec --json`` (not a TUI mode like claude); this method
+        keeps the name aligned with the Protocol while emitting Codex's
+        documented non-interactive form. MCP bridging params are accepted
+        for Protocol uniformity but unused (codex's MCP config lives in
+        ``~/.codex/config.toml``). ``include_prompt`` is honoured so the
+        session pool can spawn without an initial prompt."""
+        _ = (mcp_endpoint_url, mcp_bearer_token, connected_tool_names)
         if not isinstance(task, CodexTaskSpec):
-            raise TypeError(
-                "OpenAICodexProvider.headless_argv requires CodexTaskSpec, "
-                f"got {type(task).__name__}"
-            )
+            raise TypeError("OpenAICodexProvider.interactive_argv requires CodexTaskSpec, " f"got {type(task).__name__}")
 
         which_codex = shutil.which(self.binary_name)
         if which_codex:
@@ -115,18 +127,12 @@ class OpenAICodexProvider:
         else:
             npx = shutil.which("npx")
             if not npx:
-                raise FileNotFoundError(
-                    f"Neither {self.binary_name!r} nor 'npx' found in PATH"
-                )
+                raise FileNotFoundError(f"Neither {self.binary_name!r} nor 'npx' found in PATH")
             argv = [npx, "--yes", self.package_name]
 
         argv += ["exec", "--json"]
 
-        model = (
-            task.model
-            or defaults.get("default_model")
-            or self._defaults.get("default_model", "gpt-5.2-codex")
-        )
+        model = task.model or defaults.get("default_model") or self._defaults.get("default_model", "gpt-5.2-codex")
         argv += ["--model", model]
 
         sandbox = task.sandbox or defaults.get(
@@ -144,11 +150,11 @@ class OpenAICodexProvider:
         # System prompt — Codex doesn't have a dedicated --system-prompt
         # flag in `exec`. Prepend it to the user prompt with a clear
         # divider when present.
-        prompt = task.prompt
-        if task.system_prompt:
-            prompt = f"<system>\n{task.system_prompt}\n</system>\n\n{task.prompt}"
-
-        argv += [prompt]
+        if include_prompt and task.prompt:
+            prompt = task.prompt
+            if task.system_prompt:
+                prompt = f"<system>\n{task.system_prompt}\n</system>\n\n{task.prompt}"
+            argv += [prompt]
         return argv
 
     # ---- native auth -----------------------------------------------------
@@ -195,10 +201,7 @@ class OpenAICodexProvider:
         response = self._extract_response(events)
         provider_data = self._extract_provider_data(events)
 
-        tool_calls = sum(
-            1 for e in events
-            if e.get("type") in ("tool_call", "tool_use", "function_call")
-        )
+        tool_calls = sum(1 for e in events if e.get("type") in ("tool_call", "tool_use", "function_call"))
 
         success = exit_code == 0
         error: Optional[str] = None
@@ -240,10 +243,7 @@ class OpenAICodexProvider:
     def canonical_usage(self, events: List[Dict[str, Any]]) -> CanonicalUsage:
         # Codex doesn't expose token counts in `--json` output. Return zeros.
         # If a future Codex schema adds usage, extract here.
-        request_count = sum(
-            1 for e in events
-            if e.get("type") in ("assistant", "message", "response")
-        )
+        request_count = sum(1 for e in events if e.get("type") in ("assistant", "message", "response"))
         return CanonicalUsage(request_count=request_count)
 
     # ---- feature gating --------------------------------------------------