@chibitek/chibi 0.1.157 → 0.1.160

package/dist-server/server/connector-proxy.js

@@ -0,0 +1,249 @@
+// Harness-owned Composio MCP bridge.
+//
+// Provider CLIs only see this stdio server. Ordinary MCP traffic is relayed
+// to the configured Composio Session, but connection requests are converted
+// into first-class OpenMausBot chat cards. The agent never authors an auth
+// URL and credentials never pass through its transcript.
+//
+// stdout is the MCP transport. Never log there.
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+const UPSTREAM = process.env.OMB_CONNECTOR_UPSTREAM_URL ?? "";
+const HARNESS = process.env.OMB_HARNESS_URL ?? "http://127.0.0.1:8799";
+const BOT_ID = process.env.OMB_BOT_ID ?? "";
+const THREAD_ID = process.env.OMB_THREAD_ID ?? "";
+const TOKEN = process.env.OMB_CONNECTOR_TOKEN ?? process.env.OMB_COMMS_TOKEN ?? "";
+const MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
+const INITIALIZE_RELAY_TIMEOUT_MS = 1_000;
+const RELAY_TIMEOUT_MS = 10 * 60_000;
+function parsedHeaders() {
+    try {
+        const value = JSON.parse(process.env.OMB_CONNECTOR_UPSTREAM_HEADERS ?? "{}");
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return {};
+        return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+const upstreamHeaders = parsedHeaders();
+let upstreamSessionId = "";
+const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+function textResult(id, text, isError = false) {
+    return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) } };
+}
+function jsonRpcError(id, message) {
+    return { jsonrpc: "2.0", id, error: { code: -32000, message } };
+}
+function initializeResult(id, protocolVersion) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+            protocolVersion: typeof protocolVersion === "string" && protocolVersion ? protocolVersion : "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "openmausbot-connectors", version: "1" },
+        },
+    };
+}
+async function readBounded(response) {
+    const declared = Number(response.headers.get("content-length") ?? "0");
+    if (declared > MAX_RESPONSE_BYTES)
+        throw new Error("connector response exceeded 20 MB");
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = "";
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > MAX_RESPONSE_BYTES) {
+            await reader.cancel();
+            throw new Error("connector response exceeded 20 MB");
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+}
+function parseUpstream(text, id) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{"))
+        return JSON.parse(trimmed);
+    const frames = trimmed
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trim())
+        .filter((line) => line && line !== "[DONE]")
+        .flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return frames.findLast((frame) => frame.id === id) ?? frames.at(-1) ?? null;
+}
+async function relay(message, timeoutMs = RELAY_TIMEOUT_MS) {
+    if (!UPSTREAM)
+        throw new Error("connected apps are unavailable");
+    const response = await fetch(UPSTREAM, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...upstreamHeaders,
+            ...(upstreamSessionId ? { "mcp-session-id": upstreamSessionId } : {}),
+        },
+        body: JSON.stringify(message),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const nextSession = response.headers.get("mcp-session-id");
+    if (nextSession)
+        upstreamSessionId = nextSession;
+    if (!response.ok)
+        throw new Error(`connector service returned HTTP ${response.status}`);
+    return parseUpstream(await readBounded(response), message.id);
+}
+function connectorAdds(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return [];
+    const toolkits = args.toolkits;
+    if (!Array.isArray(toolkits))
+        return [];
+    const seen = new Set();
+    const requests = [];
+    for (const item of toolkits) {
+        if (typeof item === "string") {
+            const slug = item.trim().toLowerCase();
+            const key = JSON.stringify([slug, ""]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                requests.push({ slug });
+            }
+            continue;
+        }
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const row = item;
+        const action = String(row.action ?? "add").toLowerCase();
+        if (!["add", "connect", "initiate"].includes(action))
+            continue;
+        const slug = typeof row.toolkit === "string" ? row.toolkit : row.name;
+        if (typeof slug !== "string")
+            continue;
+        const normalized = slug.trim().toLowerCase();
+        const alias = (typeof row.alias === "string" ? row.alias : typeof row.account === "string" ? row.account : "").trim();
+        const key = JSON.stringify([normalized, alias.toLowerCase()]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        requests.push({ slug: normalized, ...(alias ? { alias } : {}) });
+    }
+    return requests;
+}
+async function showConnectorCards(items) {
+    const response = await fetch(`${HARNESS}/api/internal/connectors/request`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${TOKEN}` },
+        body: JSON.stringify({ botId: BOT_ID, threadId: THREAD_ID, items, resumeKey: randomUUID() }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        throw new Error(String(body.error ?? `could not show connection card (HTTP ${response.status})`));
+    }
+}
+async function handle(message) {
+    const id = message.id;
+    const method = String(message.method ?? "");
+    // OpenCode (and other MCP clients) mark a stdio server failed unless
+    // initialize returns capabilities/serverInfo. Relaying that handshake to
+    // Composio can time out, return a newer protocolVersion, or throw when the
+    // upstream URL never reached the child env — all of which previously
+    // surfaced as a tools/call-shaped {content,isError} payload.
+    if (method === "notifications/initialized" || method === "initialized") {
+        if (UPSTREAM)
+            void relay(message).catch(() => { });
+        return;
+    }
+    if (method === "initialize") {
+        if (UPSTREAM) {
+            try {
+                // Capture the upstream session id when the service is healthy, but
+                // never let a stalled provider prevent the local MCP client from
+                // mounting the connector tools. The client sends initialized only
+                // after this bounded attempt and the local initialize response.
+                await relay(message, INITIALIZE_RELAY_TIMEOUT_MS);
+            }
+            catch {
+                // Best-effort session setup. The client still needs a valid result.
+            }
+        }
+        if (id !== undefined) {
+            const params = (message.params ?? {});
+            send(initializeResult(id, params.protocolVersion));
+        }
+        return;
+    }
+    if (method === "tools/call") {
+        const params = (message.params ?? {});
+        const name = String(params.name ?? "");
+        const requests = /MANAGE_CONNECTIONS$/i.test(name) ? connectorAdds(params.arguments) : [];
+        if (requests.length) {
+            await showConnectorCards(requests);
+            const labels = requests.map((r) => (r.alias ? `${r.slug} (${r.alias})` : r.slug)).join(", ");
+            send(textResult(id, `Atomic showed the user a secure connection card for ${labels}. End this turn now. The app will continue the task automatically after the connection finishes.`));
+            return;
+        }
+        if (/WAIT_FOR_CONNECTIONS$/i.test(name)) {
+            send(textResult(id, "Atomic is handling connection completion and will continue the task automatically."));
+            return;
+        }
+    }
+    try {
+        const response = await relay(message);
+        if (response && id !== undefined)
+            send(response);
+    }
+    catch (error) {
+        if (id === undefined)
+            return;
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(id, messageText, true));
+        else
+            send(jsonRpcError(id, messageText));
+    }
+}
+const input = readline.createInterface({ input: process.stdin, terminal: false });
+input.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    let message;
+    try {
+        message = JSON.parse(trimmed);
+    }
+    catch {
+        return;
+    }
+    void handle(message).catch((error) => {
+        if (message.id === undefined)
+            return;
+        const method = String(message.method ?? "");
+        const messageText = error instanceof Error ? error.message : String(error);
+        if (method === "tools/call")
+            send(textResult(message.id, messageText, true));
+        else
+            send(jsonRpcError(message.id, messageText));
+    });
+});
+input.on("close", () => process.exit(0));

package/dist-server/server/container-computer.js

@@ -6,13 +6,13 @@
 // `cua-driver mcp` inside the container; this module never reimplements clicks,
 // typing, screenshots, accessibility, or window discovery.
 import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { chmod, lstat, mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve, win32 } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { augmentedPath, resolveCliSpawn } from "./env-path.js";
+import { colimaStartPlan, dockerEnvForColima, startColima } from "./colima-docker.js";
 import { spawnOptionsFor } from "./spawn-command.js";
 import { DATA_DIR } from "./config.js";
 import { SPAWNED_PROXIES } from "./proxy-paths.js";
@@ -188,7 +188,11 @@ async function sh(cmd, args, timeout = 8000) {
         timeout,
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
-        env: { ...process.env, PATH: augmentedPath() },
+        // Every docker call on a Mac goes to Colima's socket, whatever docker
+        // context Docker Desktop may have left active.
+        env: cmd === "docker"
+            ? dockerEnvForColima({ ...process.env, PATH: augmentedPath() })
+            : { ...process.env, PATH: augmentedPath() },
     }));
     return { stdout };
 }
@@ -233,77 +237,36 @@ export async function containerRuntimeStatus(runner = sh, platform = process.pla
         daemonUp: healthyIndex >= 0,
     };
 }
-const COLIMA_START_TIMEOUT_MS = 4 * 60_000;
-const DESKTOP_LAUNCH_TIMEOUT_MS = 30_000;
-export async function containerRuntimeStartPlan(runner = sh, platform = process.platform, appExists = existsSync, env = process.env) {
-    if (platform === "darwin") {
-        const context = await runner("docker", ["context", "show"], 4000).then(({ stdout }) => stdout.trim()).catch(() => "");
-        const desktopApp = ["/Applications/Docker.app", join(env.HOME ?? "", "Applications", "Docker.app")].some((path) => appExists(path));
-        const desktop = { label: "Docker Desktop", command: "open", args: ["-a", "Docker"], timeoutMs: DESKTOP_LAUNCH_TIMEOUT_MS };
-        if (context === "desktop-linux" && desktopApp)
-            return desktop;
-        if (await installed("colima", runner, platform)) {
-            // `colima start` on a running profile is a no-op, so an instance the
-            // person started with their own flags is left exactly as it is.
-            const profile = context.startsWith("colima-") ? context.slice("colima-".length) : "";
-            return {
-                label: "Colima",
-                command: "colima",
-                args: ["start", ...(profile ? ["--profile", profile] : [])],
-                timeoutMs: COLIMA_START_TIMEOUT_MS,
-            };
-        }
-        return desktopApp ? desktop : null;
-    }
-    if (platform === "win32") {
-        const exe = win32.join(env.ProgramFiles ?? "C:\\Program Files", "Docker", "Docker", "Docker Desktop.exe");
-        // Start-Process returns at once; Docker Desktop keeps running on its own.
-        return appExists(exe)
-            ? {
-                label: "Docker Desktop",
-                command: "powershell.exe",
-                args: ["-NoProfile", "-NonInteractive", "-Command", `Start-Process -FilePath '${exe.replaceAll("'", "''")}'`],
-                timeoutMs: DESKTOP_LAUNCH_TIMEOUT_MS,
-            }
-            : null;
-    }
-    return null;
+/** How this machine's stopped Docker engine is started, or null when Atomic
+ * must not try: Colima on a Mac where it is installed, never Docker Desktop
+ * on any platform (colima-docker.ts). Linux needs root for the daemon and
+ * Windows runs the Local VM on Podman, so neither is started here. */
+export async function containerRuntimeStartPlan(runner = sh, platform = process.platform, env = process.env) {
+    return platform === "darwin" && await installed("colima", runner, platform) ? colimaStartPlan(env) : null;
 }
 let runtimeStartInFlight = null;
-/** Start the person's installed Docker engine when it is stopped, then wait,
- * bounded, until `docker info` answers. Never installs anything and never
- * touches Podman or Apple container. One start at a time: concurrent callers
- * (startup and a turn) share the same attempt. Callers decide whether the
- * person allowed it; this only does it. */
+let runtimeStartError = null;
+/** Why the last start left the Local VM without an engine; null once docker answers. */
+export const containerRuntimeError = () => runtimeStartError;
+/** Start the person's installed Colima when docker is not answering, with a
+ * retry and a restart, bounded (startColima). Never installs anything, never
+ * opens Docker Desktop, never touches Podman or Apple container. One start at
+ * a time: concurrent callers (startup and a turn) share the same attempt.
+ * Callers decide whether the person allowed it; this only does it. */
 export function ensureContainerRuntime(opts = {}) {
     if (runtimeStartInFlight)
         return runtimeStartInFlight;
     const attempt = (async () => {
         const runner = opts.runner ?? sh;
         const platform = opts.platform ?? process.platform;
-        const sleep = opts.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
         const before = await containerRuntimeStatus(runner, platform);
         if (before.daemonUp || before.runtime !== "docker")
-            return { status: before, started: null };
-        const plan = await containerRuntimeStartPlan(runner, platform, opts.appExists, opts.env);
-        if (!plan)
-            return { status: before, started: null };
-        try {
-            await runner(plan.command, plan.args, plan.timeoutMs);
-        }
-        catch {
-            // Colima can exit non-zero while its VM is still coming up, and the
-            // wait below is the real test; a launch that truly failed times out.
-        }
-        const deadline = Date.now() + (opts.waitMs ?? 120_000);
-        let status = await containerRuntimeStatus(runner, platform);
-        while (!status.daemonUp && Date.now() < deadline) {
-            await sleep(opts.pollMs ?? 2000);
-            status = await containerRuntimeStatus(runner, platform);
-        }
-        return { status, started: plan.label };
+            return { status: before, started: null, error: null };
+        const plan = await containerRuntimeStartPlan(runner, platform, opts.env);
+        return startColima(plan, before, { runner, platform, status: () => containerRuntimeStatus(runner, platform), ...opts });
     })();
     runtimeStartInFlight = attempt;
+    void attempt.then((outcome) => { runtimeStartError = outcome.status.daemonUp ? null : outcome.error; }, () => { });
     void attempt.finally(() => { if (runtimeStartInFlight === attempt)
         runtimeStartInFlight = null; }).catch(() => { });
     return attempt;
@@ -989,6 +952,11 @@ export function containerComputerMcp(runtime, control, target = SHARED_LOCAL_VM_
         // through `ps` for the life of the bridge.
         env: {
             ELECTRON_RUN_AS_NODE: "1",
+            // The bridge pins docker to Colima itself too (container-mcp.ts); this
+            // keeps a host that spawns it with a scrubbed environment on Colima.
+            ...(runtime === "docker" && process.platform === "darwin"
+                ? { DOCKER_HOST: dockerEnvForColima(process.env, "darwin").DOCKER_HOST ?? "" }
+                : {}),
             ...(control ? { OMB_CONTROL_URL: control.url, OMB_CONTROL_TOKEN: control.token } : {}),
             // Where the bridge remembers Cua Driver's tool list, and whether it
             // must stand in for Cua Driver until the first tool call (the VM is
@@ -1011,7 +979,7 @@ export function setupCommands(runtime, platform = process.platform, target = SHA
         : runtime === "podman" && platform !== "linux"
             ? "podman machine init; podman machine start"
             : runtime === "docker" && platform === "darwin"
-                ? "colima start || open -a Docker"
+                ? "colima start"
                 : runtime === "docker" && platform === "linux"
                     ? "sudo systemctl start docker"
                     : null;

package/dist-server/server/container-mcp.js

@@ -3,6 +3,8 @@
 // piping, drain-safe exit, and watchdog live in mcp-bridge.ts, shared with
 // the VPS entry point.
 import { cuaExecArgs } from "./container-computer.js";
+import { dockerEnvForColima } from "./colima-docker.js";
+import { augmentedPath } from "./env-path.js";
 import { runMcpBridge } from "./mcp-bridge.js";
 const [runtime, container, socket] = process.argv.slice(2);
 if (!runtime || !["docker", "podman", "container"].includes(runtime)) {
@@ -27,6 +29,9 @@ runMcpBridge({
     command: runtime,
     args: cuaExecArgs(["mcp", "--socket", socket], { container, interactive: true }),
     label: "Cua Driver",
+    // On a Mac, docker always talks to Colima's socket, never to whatever
+    // context Docker Desktop left active.
+    ...(runtime === "docker" ? { env: dockerEnvForColima({ ...process.env, PATH: augmentedPath() }) } : {}),
     // No liveness watchdog: the runtime CLI talks to a local daemon and fails
     // fast on its own — there is no silent WAN peer to wedge on.
     ...(controlUrl && controlToken ? { gate: { url: controlUrl, token: controlToken } } : {}),

package/dist-server/server/drivers/claude-message.js

@@ -0,0 +1,12 @@
+// Extract text from the native Claude response before transcript normalization.
+export function firstText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((b) => b?.type === "text" && b.text)
+            .map((b) => b.text)
+            .join("");
+    }
+    return "";
+}

package/dist-server/server/drivers/claude.js

@@ -1,3 +1,4 @@
+import { firstText } from "./claude-message.js";
 // Claude driver — upstream ClaudeDriver skeleton over agentcal's
 // drivers/claude.js runtime (stream-json both directions, prompt over
 // stdin, completion from a real `result` event — verified against
@@ -811,17 +812,6 @@ function decodeConfig(raw) {
         ...(disallowedTools !== undefined ? { disallowedTools } : {}),
     };
 }
-function firstText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((b) => b?.type === "text" && b.text)
-            .map((b) => b.text)
-            .join("");
-    }
-    return "";
-}
 /** Claude's stream-json input accepts the same image source blocks as the
  * Anthropic Messages API. Keep the old string form for text-only turns so a
  * CLI update cannot disturb the overwhelmingly common path. */
@@ -1739,7 +1729,7 @@ export const ClaudeDriver = {
                                     delivered.sessionId = o.session_id;
                                 session.sessionId = o.session_id;
                             }
-                            emit({ ...base(threadId, currentTurnId()), type: "session.started", sessionId: o.session_id, model: o.model, ...(retry.rebuilt ? { rebuilt: true } : {}) });
+                            emit({ ...base(threadId, currentTurnId()), type: "session.started", sessionId: o.session_id, model: o.model, modelEvidenceLevel: "session-reported", ...(retry.rebuilt ? { rebuilt: true } : {}) });
                         }
                         else if (o.subtype === "compact_boundary") {
                             // The CLI summarized the history, notes included: the next
@@ -1773,6 +1763,13 @@ export const ClaudeDriver = {
                     }
                     case "assistant": {
                         const msg = o.message ?? {};
+                        if (o.is_api_error_message !== true && typeof o.error !== "string") {
+                            emit({ ...base(threadId, currentTurnId()), type: "model.evidence",
+                                callId: typeof msg.id === "string" ? msg.id : newId(),
+                                responseId: typeof msg.id === "string" ? msg.id : undefined,
+                                model: typeof msg.model === "string" ? msg.model : null,
+                                level: typeof msg.model === "string" ? "response-reported" : "unknown" });
+                        }
                         const text = firstText(msg.content);
                         // CLI auth diagnostics enter the shared fallback path, never assistant text.
                         if (claudeAuthFailure(o, text)) {

package/dist-server/server/drivers/codex-image.js

@@ -0,0 +1,141 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { killCliTree, spawnCli } from "../procs.js";
+import { codexConfigMcpServers, codexUserMcpOffArgs } from "./codex-mcp-names.js";
+import { codexPersonalSetupOffArgs } from "./codex-personal.js";
+import { codexToolSurfaceArgs } from "./codex-tool-surface.js";
+/** A separate ephemeral app-server: no chat bus, history, mounted integrations,
+ * API billing fallback or provider-supplied file reads. Prompt travels on stdin. */
+export async function codexImage(cli, env, prompt, signal, diagnostic, model) {
+    signal.throwIfAborted();
+    const cwd = await mkdtemp(join(tmpdir(), "atomic-avatar-"));
+    const args = ["app-server", ...codexToolSurfaceArgs(),
+        ...codexUserMcpOffArgs(codexConfigMcpServers(env, cwd)), ...codexPersonalSetupOffArgs(env, cwd),
+        ...["shell_tool", "unified_exec", "view_image", "apps", "multi_agent", "multi_agent_v2", "code_mode"]
+            .flatMap(name => ["-c", `features.${name}=false`]),
+        "-c", "features.image_generation=true", "-c", 'web_search="disabled"',
+        "-c", 'model_provider="openai"', "-c", 'forced_login_method="chatgpt"',
+        "-c", "project_doc_max_bytes=0",
+    ];
+    let child;
+    try {
+        child = spawnCli(cli, args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+    }
+    catch {
+        await rm(cwd, { recursive: true, force: true });
+        throw new Error("Could not start image generation.");
+    }
+    const pending = new Map();
+    let nextId = 0, buffer = "", image, done = false;
+    let resolveImage;
+    let rejectImage;
+    const result = new Promise((resolve, reject) => { resolveImage = resolve; rejectImage = reject; });
+    // The handshake may still be awaiting an RPC when an abort/exit occurs.
+    void result.catch(() => { });
+    const fail = () => {
+        const error = new Error("Codex image generation did not complete.");
+        for (const waiter of pending.values())
+            waiter.reject(error);
+        pending.clear();
+        if (!done)
+            rejectImage(error);
+        done = true;
+    };
+    const send = (message) => { child.stdin.write(JSON.stringify(message) + "\n", error => { if (error)
+        fail(); }); };
+    const request = (method, params) => new Promise((resolve, reject) => {
+        if (done) {
+            reject(new Error("Image session ended."));
+            return;
+        }
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        send({ id, method, params });
+    });
+    child.on("error", fail);
+    child.on("exit", fail);
+    child.stdin.on("error", fail);
+    child.stderr.resume();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        buffer += chunk;
+        if (Buffer.byteLength(buffer) > 32 * 1024 * 1024) {
+            fail();
+            return;
+        }
+        for (;;) {
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                break;
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            try {
+                const message = JSON.parse(line);
+                if (message.method === "item/completed" || message.method === "turn/completed")
+                    diagnostic?.({ method: message.method,
+                        itemType: message.params?.item?.type, status: message.params?.turn?.status ?? message.params?.item?.status,
+                        imageBytes: message.params?.item?.type === "imageGeneration" ? message.params.item.result?.length ?? 0 : undefined,
+                        errorTerms: message.params?.turn?.error?.message?.match(/\b(?:usage|limit|quota|expired|auth|model|configuration|tools?|sandbox|rate|429|401|403|400|unsupported|invalid|image_generation|reasoning|summary|does not exist|not supported|not available|gpt-[\w.-]+)\b/gi) ?? undefined });
+                if (message.method && message.id !== undefined) {
+                    // No permission, tool or user-input request can widen this session.
+                    send({ id: message.id, error: { code: -32601, message: "Not available in avatar generation." } });
+                    fail();
+                    return;
+                }
+                if (message.id !== undefined) {
+                    const waiter = pending.get(message.id);
+                    pending.delete(message.id);
+                    if (message.error)
+                        waiter?.reject(new Error("Codex image request failed."));
+                    else
+                        waiter?.resolve(message.result);
+                }
+                else if (message.method === "item/completed" && message.params?.item?.type === "imageGeneration") {
+                    const item = message.params.item;
+                    if (item.status !== "failed" && typeof item.result === "string")
+                        image = item.result;
+                }
+                else if (message.method === "turn/completed") {
+                    if (message.params?.turn?.status !== "completed" || !image) {
+                        fail();
+                        return;
+                    }
+                    done = true;
+                    resolveImage(image);
+                }
+            }
+            catch {
+                fail();
+                return;
+            }
+        }
+    });
+    signal.addEventListener("abort", fail, { once: true });
+    try {
+        if (signal.aborted)
+            fail();
+        await request("initialize", { clientInfo: { name: "atomic_avatar", version: "1" }, capabilities: { experimentalApi: true } });
+        send({ method: "initialized", params: {} });
+        const catalog = await request("model/list", { limit: 100 });
+        const choices = Array.isArray(catalog.data) ? catalog.data.filter(item => item && item.hidden !== true &&
+            (typeof item.model === "string" || typeof item.id === "string")) : [];
+        const choice = choices.find(item => item.id === model || item.model === model) ?? choices.find(item => item.isDefault) ?? choices[0];
+        if (!choice)
+            throw new Error("No subscription image model is available.");
+        const started = await request("thread/start", { cwd, model: choice.model ?? choice.id, modelProvider: "openai", ephemeral: true, approvalPolicy: "never", sandbox: "read-only",
+            developerInstructions: "Generate exactly one image with the native image generation tool. Do not run commands, read files, use other tools or ask for credentials." });
+        if (typeof started.thread?.id !== "string")
+            throw new Error("Missing image session.");
+        await request("turn/start", { threadId: started.thread.id, input: [{ type: "text", text: prompt }],
+            approvalPolicy: "never", sandboxPolicy: { type: "readOnly" } });
+        return await result;
+    }
+    finally {
+        signal.removeEventListener("abort", fail);
+        fail();
+        const stopped = await killCliTree(child);
+        if (stopped)
+            await rm(cwd, { recursive: true, force: true });
+    }
+}

package/dist-server/server/drivers/codex.js

@@ -1,12 +1,8 @@
 import { codexToolSurfaceArgs } from "./codex-tool-surface.js";
-// Codex driver — upstream CodexDriver skeleton over agentcal's
-// drivers/codex.js runtime: the official `codex` CLI headless over its
-// app-server JSON-RPC protocol (newline-delimited JSON on stdio).
-// Completion is a real `turn/completed` notification; approval requests
-// arrive as in-process server→client JSON-RPC requests and surface as
-// canonical request.opened events (answered via respondToRequest — no MCP
-// proxy or unix socket needed, unlike claude). Verified against
-// codex-cli 0.144.4 by agentcal.
+import { codexImage } from "./codex-image.js";
+// Official Codex app-server over newline-delimited JSON-RPC on stdio.
+// Completion comes from turn/completed; native approval requests become
+// canonical request.opened events answered through respondToRequest.
 //
 // resumeCursor is the codex thread id; a later turn tries thread/resume
 // and preserves that history or reports a failed resume.
@@ -1557,7 +1553,7 @@ export const CodexDriver = {
                     if (!codexThreadId)
                         throw new Error("Codex did not return a native thread id");
                     await syncCodexInstructions(threadId, codexThreadId, developerInstructions, resumedNativeThread, request);
-                    emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null, ...(rebuiltFromReplay ? { rebuilt: true } : {}) });
+                    emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null, modelEvidenceLevel: startedModel ? "session-reported" : "requested-only", ...(rebuiltFromReplay ? { rebuilt: true } : {}) });
                     const note = turn.systemStable !== undefined
                         ? volatileNoteFor(threadId, codexThreadId, !resumedNativeThread || rebuiltFromReplay, turn)
                         : "";
@@ -1700,6 +1696,7 @@ export const CodexDriver = {
             cancelAuthentication: () => authentication.cancel(),
             signOut: () => authentication.signOut(),
             snapshot,
+            ...(!config.managed ? { generateImage: (prompt, options) => codexImage(config.cli, childEnv(), prompt, options.signal, undefined, decodeCodexSelection(models.default).model ?? undefined) } : {}),
             adapter: {
                 provider: DRIVER_KIND,
                 capabilities: {