atom-agent 1.4.0 → 1.5.1

package/dist/adapters.js

@@ -6,10 +6,56 @@
 // Normalized output matches zen ChatResult:
 //   {content, tool_calls:[{id,function:{name,arguments}}], usage?}
 // so runAgenticLoop/retry/rollback/status code is untouched.
-import { allToolDefinitions } from "./tools.js";
+import { chatToolDefinitions } from "./tools.js";
 import { getProvider, modelsUrlForProvider, } from "./providers.js";
 export const ANTHROPIC_VERSION = "2023-06-01";
 export const ANTHROPIC_MAX_TOKENS = 4096;
+// ---- OpenCode Zen client identity (free `*-free` promo models) ----
+//
+// Zen's free pool is gated on official-client identity, verified live
+// 2026-09-12 against https://opencode.ai/zen/v1/chat/completions:
+// - `User-Agent: opencode/*` alone → 429 FreeUsageLimitError.
+// - UA alone (no session) → 400 MissingSessionID
+//   ("OpenCode's free tier can only be used in OpenCode").
+// - UA + `x-opencode-session: ses_…` → 200 (any value passes; the check
+//   is presence-only, the id needs no server-side registration).
+// - `x-opencode-client` / `x-opencode-project` are NOT required (probed).
+// Paid models are not gated.
+// Lives here (not zen.ts) so both zen.ts and the key-validation path below
+// share one constant without a runtime import cycle.
+export const ZEN_CLIENT_UA = "opencode/1.18.16";
+const ZEN_ID_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function zenRandomSuffix(length = 24) {
+    let out = "";
+    for (let i = 0; i < length; i++) {
+        out += ZEN_ID_ALPHABET[Math.floor(Math.random() * ZEN_ID_ALPHABET.length)];
+    }
+    return out;
+}
+// One stable session per process (mirrors one client conversation; avoids
+// minting a new server-side session per keystroke). Reset only on restart.
+let cachedZenSessionId = null;
+/** Stable `ses_…` id for this process (generated once, lazily). */
+export function zenSessionId() {
+    if (!cachedZenSessionId)
+        cachedZenSessionId = `ses_${zenRandomSuffix()}`;
+    return cachedZenSessionId;
+}
+/** Fresh `msg_…` id per POST (mirrors one id per client message). */
+export function zenRequestId() {
+    return `msg_${zenRandomSuffix()}`;
+}
+// Base headers for any Zen HTTP call (chat POST, models GET, key check).
+// Anonymous-capable: omits Authorization when no key (never `Bearer `).
+export function zenHeaders(apiKey, opts) {
+    return {
+        "Content-Type": "application/json",
+        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+        "User-Agent": ZEN_CLIENT_UA,
+        "x-opencode-session": opts?.sessionId ?? zenSessionId(),
+        "x-opencode-request": opts?.requestId ?? zenRequestId(),
+    };
+}
 // ---- Reasoning-effort mappings (one /effort knob, three wire shapes) ----
 //
 // OpenAI-chat kind sends `reasoning_effort` verbatim (no mapping needed).
@@ -64,10 +110,13 @@ export function geminiThinkingLevelFor(effort) {
 export function isEffortRejection(errorText) {
     return /reasoning_effort|reasoning effort|thinking_level|budget_tokens|\bthinking\b/i.test(errorText);
 }
-function toolDefs() {
+function toolDefs(includeUpdateGoal = true) {
     // Builtins plus extension-registered custom tools, so non-OpenAI kinds
     // see the same model-visible surface as the OpenAI-chat path.
-    return allToolDefinitions();
+    // includeUpdateGoal:false hides update_goal when the turn has no live
+    // goal (same contract as chatToolDefinitions — default keeps every
+    // existing caller byte-identical).
+    return chatToolDefinitions(includeUpdateGoal);
 }
 function parseArgsObject(raw) {
     try {
@@ -81,11 +130,16 @@ function parseArgsObject(raw) {
     }
 }
 import { ephemeralBreakpoint, assemblePrefix } from "./prompt-cache.js";
+import { hasMediaRefs, lowerOpenAIContent, resolveMediaRefs, stripMedia, } from "./media.js";
 export function buildAnthropicBody(history, model, opts) {
     const systems = [];
     const messages = [];
     // Group consecutive tool messages into one user message with
     // multiple tool_result blocks (Anthropic convention).
+    // Media lowering (see src/media.ts): histories without descriptors take
+    // the string path byte-identically; descriptor-bearing user/tool content
+    // expands to text + base64 image blocks (strip mode: prose markers).
+    const strip = opts?.stripMedia === true;
     let pendingToolResults = [];
     function flushTools() {
         if (pendingToolResults.length === 0)
@@ -95,20 +149,64 @@ export function buildAnthropicBody(history, model, opts) {
     }
     for (const m of history) {
         if (m.role === "system") {
-            systems.push(m.content);
+            systems.push(strip ? stripMedia(m.content) : m.content);
             continue;
         }
         if (m.role === "tool") {
+            if (!hasMediaRefs(m.content)) {
+                pendingToolResults.push({
+                    type: "tool_result",
+                    tool_use_id: m.tool_call_id,
+                    content: strip ? stripMedia(m.content) : m.content,
+                });
+                continue;
+            }
+            if (strip) {
+                pendingToolResults.push({
+                    type: "tool_result",
+                    tool_use_id: m.tool_call_id,
+                    content: stripMedia(m.content),
+                });
+                continue;
+            }
+            const { text, media } = resolveMediaRefs(m.content);
+            const blocks = [{ type: "text", text }];
+            for (const part of media) {
+                if (!part.ok)
+                    continue; // placeholder already inline in text
+                blocks.push({
+                    type: "image",
+                    source: { type: "base64", media_type: part.mime, data: part.base64 },
+                });
+            }
             pendingToolResults.push({
                 type: "tool_result",
                 tool_use_id: m.tool_call_id,
-                content: m.content,
+                content: blocks,
             });
             continue;
         }
         flushTools();
         if (m.role === "user") {
-            messages.push({ role: "user", content: m.content });
+            if (!hasMediaRefs(m.content)) {
+                messages.push({ role: "user", content: strip ? stripMedia(m.content) : m.content });
+            }
+            else if (strip) {
+                messages.push({ role: "user", content: stripMedia(m.content) });
+            }
+            else {
+                const { text, media } = resolveMediaRefs(m.content);
+                const blocks = [{ type: "text", text }];
+                for (const part of media) {
+                    if (!part.ok)
+                        continue;
+                    blocks.push({
+                        type: "image",
+                        source: { type: "base64", media_type: part.mime, data: part.base64 },
+                    });
+                }
+                messages.push({ role: "user", content: blocks });
+            }
         }
         else {
             // assistant: text + tool_use blocks
@@ -140,7 +238,7 @@ export function buildAnthropicBody(history, model, opts) {
     // Compaction path (includeTools:false) omits `tools` + `tool_choice`
     // entirely — asserted in tests as "no `tools` key".
     if (includeTools) {
-        const defs = toolDefs().map((t) => ({
+        const defs = toolDefs(opts?.includeUpdateGoal !== false).map((t) => ({
             name: t.function.name,
             description: t.function.description,
             input_schema: t.function.parameters,
@@ -222,10 +320,15 @@ export function geminiHeaders(apiKey) {
     };
 }
 export function buildGeminiBody(history, _model, opts) {
+    // Media lowering (see src/media.ts): histories without descriptors take
+    // the legacy path byte-identically. Tool-result images ride as inline_data
+    // user parts after their functionResponse (function responses stay text);
+    // user-message images ride inline. Strip mode: prose markers only.
+    const strip = opts?.stripMedia === true;
     const systems = [];
     for (const m of history) {
         if (m.role === "system")
-            systems.push(m.content);
+            systems.push(strip ? stripMedia(m.content) : m.content);
     }
     // tool_call_id -> function name (tool messages carry only the id).
     const nameById = new Map();
@@ -239,27 +342,83 @@ export function buildGeminiBody(history, _model, opts) {
     }
     const contents = [];
     let pendingResponses = [];
+    // Images resolved out of tool results (flushed as user inline_data parts
+    // right after their functionResponse group).
+    let pendingToolImages = [];
     function flushResponses() {
-        if (pendingResponses.length === 0)
+        if (pendingResponses.length === 0 && pendingToolImages.length === 0)
             return;
-        contents.push({ role: "user", parts: pendingResponses });
-        pendingResponses = [];
+        if (pendingResponses.length > 0) {
+            contents.push({ role: "user", parts: pendingResponses });
+            pendingResponses = [];
+        }
+        if (pendingToolImages.length > 0) {
+            const parts = [
+                {
+                    text: `Image(s) from tool result: ${pendingToolImages.map((i) => i.name).join(", ")}`,
+                },
+            ];
+            for (const img of pendingToolImages) {
+                parts.push({ inline_data: { mime_type: img.mime, data: img.data } });
+            }
+            pendingToolImages = [];
+            contents.push({ role: "user", parts });
+        }
     }
     for (const m of history) {
         if (m.role === "system")
             continue;
         if (m.role === "tool") {
+            if (!hasMediaRefs(m.content)) {
+                pendingResponses.push({
+                    functionResponse: {
+                        name: nameById.get(m.tool_call_id) ?? "unknown",
+                        response: { result: strip ? stripMedia(m.content) : m.content },
+                    },
+                });
+                continue;
+            }
+            if (strip) {
+                pendingResponses.push({
+                    functionResponse: {
+                        name: nameById.get(m.tool_call_id) ?? "unknown",
+                        response: { result: stripMedia(m.content) },
+                    },
+                });
+                continue;
+            }
+            const { text, media } = resolveMediaRefs(m.content);
             pendingResponses.push({
                 functionResponse: {
                     name: nameById.get(m.tool_call_id) ?? "unknown",
-                    response: { result: m.content },
+                    response: { result: text },
                 },
             });
+            for (const part of media) {
+                if (!part.ok)
+                    continue;
+                pendingToolImages.push({ mime: part.mime, data: part.base64, name: part.name });
+            }
             continue;
         }
         flushResponses();
         if (m.role === "user") {
-            contents.push({ role: "user", parts: [{ text: m.content }] });
+            if (!hasMediaRefs(m.content)) {
+                contents.push({ role: "user", parts: [{ text: strip ? stripMedia(m.content) : m.content }] });
+            }
+            else if (strip) {
+                contents.push({ role: "user", parts: [{ text: stripMedia(m.content) }] });
+            }
+            else {
+                const { text, media } = resolveMediaRefs(m.content);
+                const parts = [{ text }];
+                for (const part of media) {
+                    if (!part.ok)
+                        continue;
+                    parts.push({ inline_data: { mime_type: part.mime, data: part.base64 } });
+                }
+                contents.push({ role: "user", parts });
+            }
         }
         else {
             const am = m;
@@ -290,7 +449,7 @@ export function buildGeminiBody(history, _model, opts) {
     if (includeTools) {
         body.tools = [
             {
-                functionDeclarations: toolDefs().map((t) => ({
+                functionDeclarations: toolDefs(opts?.includeUpdateGoal !== false).map((t) => ({
                     name: t.function.name,
                     description: t.function.description,
                     parameters: stripGeminiSchemaKeys(t.function.parameters),
@@ -330,10 +489,15 @@ export function buildGeminiBody(history, _model, opts) {
 //
 // Budget: env ATOM_STALL_TIMEOUT_MS when a finite value > 0 (max-clamped to
 // 5min; an explicitly tiny value is the operator's choice, and lets tests
-// use millisecond budgets), else the 60s default. The hung read is left to
+// use millisecond budgets), else the 60s default. Header budget (time to
+// first `data:` line) defaults to 300s like opencode's headerTimeout —
+// queued free-tier requests sit headerless for minutes while chunk stalls
+// (mid-generation silence) trip much sooner. The hung read is left to
 // settle — callers cancel/release the reader on the way out as before.
 export const DEFAULT_SSE_STALL_TIMEOUT_MS = 60_000;
 export const MAX_SSE_STALL_TIMEOUT_MS = 300_000;
+export const DEFAULT_SSE_HEADER_TIMEOUT_MS = 300_000;
+export const MAX_SSE_HEADER_TIMEOUT_MS = 300_000;
 export function sseStallTimeoutMs() {
     const raw = process.env.ATOM_STALL_TIMEOUT_MS;
     if (raw !== undefined) {
@@ -343,6 +507,15 @@ export function sseStallTimeoutMs() {
     }
     return DEFAULT_SSE_STALL_TIMEOUT_MS;
 }
+export function sseHeaderTimeoutMs() {
+    const raw = process.env.ATOM_HEADER_TIMEOUT_MS;
+    if (raw !== undefined) {
+        const n = Number(raw.trim());
+        if (Number.isFinite(n) && n > 0)
+            return Math.min(Math.floor(n), MAX_SSE_HEADER_TIMEOUT_MS);
+    }
+    return DEFAULT_SSE_HEADER_TIMEOUT_MS;
+}
 export function isStallError(e) {
     return e instanceof Error && e.message.startsWith("Truncated stream from model (stall:");
 }
@@ -387,7 +560,9 @@ async function collectSSEText(res) {
         tail = joined.slice(-8);
     };
     const throwIfDataStalled = () => {
-        const budget = sseStallTimeoutMs();
+        // Header phase (no data yet) gets the generous header budget; once real
+        // SSE traffic exists the tighter chunk budget applies.
+        const budget = rawText.length === 0 ? sseHeaderTimeoutMs() : sseStallTimeoutMs();
         if (Date.now() - lastDataAt > budget) {
             throw new Error(`Truncated stream from model (stall: no output for ${budget}ms — queued or stalled upstream; resend to retry).`);
         }
@@ -406,7 +581,9 @@ async function collectSSEText(res) {
                     catch (e) {
                         if (isStallError(e)) {
                             // Free the dead socket on the way out, then surface the stall
-                            // unchanged (permanent Truncated contract — never retried).
+                            // unchanged. Stalls are retryable upstream (one retry when data
+                            // was already seen, full backoff for header stalls) — never
+                            // swallowed here.
                             try {
                                 await reader.cancel?.();
                             }
@@ -1032,6 +1209,307 @@ export function parseGeminiJson(data) {
     }
     return result;
 }
+// Extract plain text from a history content value (string, or an OpenAI
+// parts array — text parts concatenate, anything else is skipped).
+function responsesTextOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    let out = "";
+    for (const p of content) {
+        if (typeof p !== "object" || p === null)
+            continue;
+        if (typeof p["text"] === "string")
+            out += p["text"];
+    }
+    return out;
+}
+// Convert one user content value to Responses input parts: plain strings
+// ride as string content; descriptor-bearing strings lower through
+// lowerOpenAIContent into input_text/input_image parts (strip mode: prose
+// markers as a single input_text part).
+function responsesUserContent(content, strip) {
+    const lowered = lowerOpenAIContent("user", content, strip ? "strip" : "send");
+    if (typeof lowered === "string")
+        return lowered;
+    const parts = [];
+    for (const p of lowered) {
+        if (p["type"] === "text" && typeof p["text"] === "string") {
+            parts.push({ type: "input_text", text: p["text"] });
+        }
+        else if (p["type"] === "image_url" &&
+            typeof p["image_url"] === "object" &&
+            p["image_url"] !== null &&
+            typeof p["image_url"]["url"] === "string") {
+            parts.push({
+                type: "input_image",
+                image_url: p["image_url"]["url"],
+            });
+        }
+    }
+    return parts.length > 0 ? parts : "";
+}
+export function buildResponsesBody(history, model, opts) {
+    const strip = opts?.stripMedia === true;
+    const systems = [];
+    const input = [];
+    for (const m of history) {
+        if (m.role === "system") {
+            const lowered = lowerOpenAIContent("system", m.content, strip ? "strip" : "send");
+            const text = responsesTextOf(lowered);
+            if (text)
+                systems.push(text);
+            continue;
+        }
+        if (m.role === "user") {
+            input.push({ role: "user", content: responsesUserContent(m.content, strip) });
+            continue;
+        }
+        if (m.role === "tool") {
+            input.push({
+                type: "function_call_output",
+                call_id: m.tool_call_id,
+                output: strip ? stripMedia(m.content) : m.content,
+            });
+            continue;
+        }
+        // assistant: text rides as an assistant message, tool_calls as
+        // function_call items (arguments stay a JSON string, as the API sends).
+        const am = m;
+        if (typeof am.content === "string" && am.content.length > 0) {
+            input.push({ role: "assistant", content: am.content });
+        }
+        for (const tc of am.tool_calls ?? []) {
+            input.push({
+                type: "function_call",
+                call_id: tc.id,
+                name: tc.function.name,
+                arguments: tc.function.arguments || "{}",
+            });
+        }
+    }
+    const body = { model, input };
+    if (systems.length > 0)
+        body.instructions = systems.join("\n\n");
+    // Compaction path (includeTools:false) omits `tools` entirely — same
+    // contract as every other kind ("no `tools` key", asserted in tests).
+    if (opts?.includeTools !== false) {
+        body.tools = toolDefs(opts?.includeUpdateGoal !== false).map((t) => ({
+            type: "function",
+            name: t.function.name,
+            description: t.function.description,
+            parameters: t.function.parameters,
+        }));
+    }
+    return body;
+}
+// Server-authoritative effort rejection for the Responses `reasoning`
+// knob: a 400 naming it means this model/deployment has no such control.
+// Narrow (reasoning only) so unrelated 400s keep failing loudly.
+export function isResponsesEffortRejection(errorText) {
+    return /reasoning/i.test(errorText);
+}
+// Build a ChatResult from one Responses `response` object (shared by the
+// streaming terminal event and the non-streaming JSON body):
+// output[] message items contribute output_text (refusals surface as text
+// so the turn never goes empty silently); function_call items become tool
+// calls (call_id first, id fallback — verified live shape carries both).
+// status "incomplete" (e.g. max_output_tokens cut the response) sets
+// `truncated` instead of throwing: the loop fails carried calls inline and
+// continues, same contract as chat finish_reason "length".
+export function parseResponsesObject(data) {
+    const o = (typeof data === "object" && data !== null ? data : {});
+    const output = o["output"];
+    let text = "";
+    const calls = [];
+    if (Array.isArray(output)) {
+        for (const item of output) {
+            if (item["type"] === "message") {
+                const content = item["content"];
+                if (Array.isArray(content)) {
+                    for (const part of content) {
+                        if (part["type"] === "output_text" && typeof part["text"] === "string") {
+                            text += part["text"];
+                        }
+                        else if (part["type"] === "refusal" && typeof part["refusal"] === "string") {
+                            text += part["refusal"];
+                        }
+                    }
+                }
+            }
+            else if (item["type"] === "function_call") {
+                const name = typeof item["name"] === "string" ? item["name"] : "";
+                if (!name)
+                    continue; // nameless-drop parity with every other kind
+                const callId = typeof item["call_id"] === "string" && item["call_id"]
+                    ? item["call_id"]
+                    : typeof item["id"] === "string" && item["id"]
+                        ? item["id"]
+                        : `responses-${calls.length}`;
+                let args = "{}";
+                const raw = item["arguments"];
+                if (typeof raw === "string")
+                    args = raw;
+                else if (typeof raw === "object" && raw !== null) {
+                    try {
+                        args = JSON.stringify(raw);
+                    }
+                    catch {
+                        args = "{}";
+                    }
+                }
+                calls.push({ id: callId, type: "function", function: { name, arguments: args } });
+            }
+        }
+    }
+    if (calls.length === 0 && text.trim() === "") {
+        throw new Error("Empty reply from model (unexpected payload).");
+    }
+    const result = {
+        content: text.length > 0 ? text : null,
+        tool_calls: calls.length > 0 ? calls : undefined,
+    };
+    if (o["status"] === "incomplete")
+        result.truncated = true;
+    const usage = o["usage"];
+    if (usage && typeof usage === "object") {
+        const details = usage["input_tokens_details"];
+        const hit = openAIUsage(usage["input_tokens"], usage["output_tokens"], {
+            read: details && typeof details === "object"
+                ? details["cached_tokens"]
+                : undefined,
+        });
+        if (hit)
+            result.usage = hit;
+    }
+    const effort = o["reasoning"]?.["effort"];
+    if (typeof effort === "string" && effort.trim().length > 0) {
+        const label = effort.trim();
+        result.reasoning = label.length > 24 ? `${label.slice(0, 24)}…` : label;
+    }
+    return result;
+}
+export async function readResponsesSSEMessage(res, opts) {
+    const { rawText, events } = await collectSSEText(res);
+    let fullText = "";
+    let sawData = false;
+    let streamingAnnounced = false;
+    function announce(kind, name) {
+        if (kind === "streaming" && !streamingAnnounced) {
+            streamingAnnounced = true;
+        }
+        try {
+            opts?.onPhase?.(kind, name ?? "");
+        }
+        catch {
+            // ignore observer errors
+        }
+    }
+    const slots = new Map();
+    function slotAt(index) {
+        let slot = slots.get(index);
+        if (!slot) {
+            slot = { callId: "", name: "", args: "" };
+            slots.set(index, slot);
+        }
+        return slot;
+    }
+    for (const { event, data } of events) {
+        if (!data || data === "[DONE]")
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(data);
+        }
+        catch {
+            continue; // malformed JSON data line: skip, never crash
+        }
+        sawData = true;
+        const o = evt;
+        const type = typeof o["type"] === "string" ? o["type"] : "";
+        if (type === "error") {
+            const msg = typeof o["error"]?.["message"] === "string"
+                ? o["error"]["message"]
+                : typeof o["message"] === "string"
+                    ? o["message"]
+                    : "unknown streaming error";
+            throw new Error(`Model error: ${msg}`.slice(0, 300));
+        }
+        if (type === "response.output_text.delta" && typeof o["delta"] === "string") {
+            const frag = o["delta"];
+            if (frag.length > 0) {
+                fullText += frag;
+                announce("streaming");
+                try {
+                    opts?.onToken?.(fullText);
+                }
+                catch {
+                    // ignore observer errors
+                }
+            }
+            continue;
+        }
+        if (type === "response.output_item.added") {
+            const item = o["item"];
+            if (item && item["type"] === "function_call") {
+                const index = typeof o["output_index"] === "number" ? o["output_index"] : 0;
+                const slot = slotAt(index);
+                if (typeof item["call_id"] === "string")
+                    slot.callId = item["call_id"];
+                if (typeof item["name"] === "string" && item["name"]) {
+                    slot.name = item["name"];
+                    try {
+                        opts?.onToolDelta?.(slot.name, index);
+                    }
+                    catch {
+                        // ignore
+                    }
+                    announce("tool", slot.name);
+                }
+            }
+            continue;
+        }
+        if (type === "response.function_call_arguments.delta" && typeof o["delta"] === "string") {
+            const index = typeof o["output_index"] === "number" ? o["output_index"] : 0;
+            slotAt(index).args += o["delta"];
+            continue;
+        }
+        // Terminal states carry the authoritative response object: the final
+        // result is built from it (never from accumulated deltas), so delta
+        // drift cannot corrupt tool arguments. `failed` throws; `completed`
+        // and `incomplete` return (incomplete flags truncated downstream).
+        if (type === "response.completed" || type === "response.incomplete") {
+            return parseResponsesObject(o["response"]);
+        }
+        if (type === "response.failed") {
+            const resp = o["response"];
+            const err = resp?.["error"];
+            const msg = (typeof err?.["message"] === "string" ? err["message"] : null) ??
+                "response failed";
+            throw new Error(`Model error: ${msg}`.slice(0, 300));
+        }
+        // created / in_progress / content_part.* / output_item.done / ping:
+        // no model output — ignored (pings must not extend stall budgets, and
+        // collectSSEText already only counts `data:` lines for data-silence).
+    }
+    // Tolerance: a body with no SSE data lines is really single-shot JSON
+    // (the non-streaming response object).
+    if (!sawData) {
+        const candidate = rawText.trim();
+        if (candidate.length > 0) {
+            try {
+                return parseResponsesObject(JSON.parse(candidate));
+            }
+            catch (e) {
+                if (e instanceof Error && e.message.startsWith("Empty reply"))
+                    throw e;
+                // not a response object either -> truncation error below
+            }
+        }
+    }
+    throw new Error("Truncated stream from model (connection aborted before response.completed).");
+}
 // ---- Models-list parsing per kind (pure; ANY failure -> fallback) ----
 function entryId(entry) {
     if (typeof entry === "string")
@@ -1126,11 +1604,14 @@ export async function validateProviderKey(id, apiKey, storedBaseURL) {
                 return { ok: true };
             return { ok: false, error: `Gemini HTTP ${res.status}` };
         }
-        // OpenAI-kind: GET {base}/models with Bearer.
+        // OpenAI-kind: GET {base}/models with Bearer. Zen also sends the
+        // official-client identity (same gate family as the free-pool UA check).
         const url = modelsUrlForProvider(id, storedBaseURL);
-        const headers = {
-            Authorization: `Bearer ${apiKey}`,
-        };
+        const headers = id === "opencode-zen"
+            ? zenHeaders(apiKey)
+            : {
+                Authorization: `Bearer ${apiKey}`,
+            };
         const res = await fetch(url, { headers });
         if (res.ok)
             return { ok: true };

package/dist/agent/goal-evaluator.js

@@ -51,6 +51,9 @@ export async function requestGoalVerdict(req) {
         endpointOverride: req.endpointOverride,
         disableTools: true,
         maxOutputTokens: req.maxOutputTokens ?? GOAL_JUDGE_MAX_TOKENS,
+        // The judge needs prose, not pixels — same strip contract as the
+        // compaction summary POST.
+        stripMedia: true,
         ...(req.signal ? { signal: req.signal } : {}),
     });
     // Totals keep accumulating: forward real judge usage when present.