atom-agent 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 1.5.1 — 2026-09-12
+
+- OpenCode Zen free tiers all usable (`src/adapters.ts`, `src/zen.ts`,
+  `src/providers.ts`): every request now carries the official-client
+  identity (`User-Agent: opencode/*` plus `x-opencode-session` /
+  `x-opencode-request`), clearing the upstream `429 FreeUsageLimitError`
+  and `400 MissingSessionID` gates for anonymous and keyed calls alike.
+  Suites in `tests/zen-headers.test.ts`
+- New Responses-family transport (`src/adapters.ts`,
+  `src/zen.ts`): `muse-spark-1.2` / `muse-spark-1.3` (including the free
+  contributor tiers) ride Zen's `/responses` endpoint with full
+  retry/hook/compaction/media parity — tool calls, streaming tokens,
+  reasoning-effort mapping, and `incomplete` → `truncated` handling.
+  Routing is automatic by model family; every other provider is
+  byte-identical. Suites in `tests/zen-responses.test.ts`
+- Picker lists all eight free Zen models (`FALLBACK_MODELS` in
+  `src/zen.ts`, `fallbackModels` in `src/providers.ts`): `big-pickle`,
+  `mimo-v2.5-free`, `ling-3.0-flash-fin-free`, `nemotron-3-ultra-free`,
+  `nemotron-3.5-lightning-free`, `deepseek-v4-flash-free`,
+  `muse-spark-1.3-contributor-free`, `muse-spark-1.2-contributor-free`
+- Loop/telemetry phase timing (`src/agent/loop.ts`,
+  `src/agent/types.ts`, `src/telemetry.ts`): per-turn model vs tool
+  totals, slowest model call, and truncation notices surfaced through
+  `LoopStats`; telemetry schema v2 with v1 back-compat, failed-turn
+  partial replies preserved for post-mortem. Accuracy fixes: each failed
+  POST and each truncation counts exactly once; timeline events fire for
+  failed turns only
+- Housekeeping: downloaded third-party skills (`.agents/skills/`,
+  `skills-lock.json`) are now gitignored
+
 ## 1.5.0 — 2026-09-12
 
 - Local agentic Web UI (`src/web/server.ts`, `src/web/runtime.ts`,

package/README.md

@@ -3,6 +3,7 @@
 > A fast, transparent AI coding agent for your terminal.
 
 [![npm version](https://img.shields.io/npm/v/atom-agent.svg)](https://www.npmjs.com/package/atom-agent)
+[![npm downloads](https://img.shields.io/npm/dm/atom-agent.svg)](https://www.npmjs.com/package/atom-agent)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-blue.svg)](https://nodejs.org/)
 [![License](https://img.shields.io/npm/l/atom-agent.svg)](LICENSE)
 

package/dist/adapters.js

@@ -10,6 +10,52 @@ 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).
@@ -84,7 +130,7 @@ function parseArgsObject(raw) {
     }
 }
 import { ephemeralBreakpoint, assemblePrefix } from "./prompt-cache.js";
-import { hasMediaRefs, resolveMediaRefs, stripMedia, } from "./media.js";
+import { hasMediaRefs, lowerOpenAIContent, resolveMediaRefs, stripMedia, } from "./media.js";
 export function buildAnthropicBody(history, model, opts) {
     const systems = [];
     const messages = [];
@@ -443,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) {
@@ -456,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:");
 }
@@ -500,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).`);
         }
@@ -519,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?.();
                             }
@@ -1145,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")
@@ -1239,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/loop.js

@@ -311,6 +311,21 @@ export async function runLoopWithChat(chatFn, history, opts) {
             bottleneck = { name, durationMs: Math.floor(durationMs) };
         }
     };
+    // v2 phase tracking: model time is measured alongside tool time so a 289s
+    // streaming stall is never hidden behind a 94ms glob again.
+    let slowestModel = null;
+    let modelTotalMs = 0;
+    let toolTotalMs = 0;
+    let truncationNotices = 0;
+    const noteModel = (id, durationMs) => {
+        if (!Number.isFinite(durationMs) || durationMs < 0)
+            return;
+        const floored = Math.floor(durationMs);
+        modelTotalMs += floored;
+        if (!slowestModel || floored > slowestModel.durationMs) {
+            slowestModel = { id, durationMs: floored };
+        }
+    };
     const finishStats = () => {
         try {
             let endChars = startChars;
@@ -337,6 +352,11 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 durationMs: Math.max(0, Date.now() - turnStartMs),
                 bottleneck,
                 contextGrowthChars: endChars - startChars,
+                slowestModel,
+                modelTotalMs,
+                toolTotalMs,
+                dominantPhase: modelTotalMs >= toolTotalMs ? "model" : "tool",
+                truncationNotices,
             };
             opts?.onLoopStats?.(stats);
         }
@@ -399,11 +419,17 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 // A failed POST still records its model call (with the error) so the
                 // trace shows what was attempted — the caller still rolls back.
                 const modelEnd = Date.now();
+                const failedMs = Math.max(0, modelEnd - modelStart);
+                noteModel(`model-step-${step}`, failedMs);
+                if (typeof e?.message === "string" && e.message.startsWith("Truncated stream")) {
+                    truncationNotices += 1;
+                }
+                failures += 1;
                 reportModelCall({
                     step,
                     startedAt: telemetryIso(modelStart),
                     endedAt: telemetryIso(modelEnd),
-                    durationMs: Math.max(0, modelEnd - modelStart),
+                    durationMs: failedMs,
                     usageReported: false,
                     toolCallCount: 0,
                     finishReason: "error",
@@ -416,7 +442,7 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 // wins; every other failure throws exactly as before.
                 if (isEmptyReplyError(e) && emptyRounds < MAX_EMPTY_ROUNDS) {
                     emptyRounds += 1;
-                    failures += 1;
+                    // failures already counted once above for this failed POST.
                     history.push({ role: "assistant", content: "" });
                     history.push({ role: "user", content: emptyResponseFollowUp(emptyRounds) });
                     continue;
@@ -483,11 +509,15 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 // actually carried it (usageReported) — never synthesized here.
                 const modelEnd = Date.now();
                 const callsCount = (msg.tool_calls ?? []).length;
+                const okMs = Math.max(0, modelEnd - modelStart);
+                noteModel(`model-step-${step}`, okMs);
+                if (msg.truncated === true)
+                    truncationNotices += 1;
                 reportModelCall({
                     step,
                     startedAt: telemetryIso(modelStart),
                     endedAt: telemetryIso(modelEnd),
-                    durationMs: Math.max(0, modelEnd - modelStart),
+                    durationMs: okMs,
                     usage: msg.usage,
                     usageReported: msg.usage !== undefined,
                     reasoningLabel: msg.reasoning,
@@ -851,8 +881,11 @@ export async function runLoopWithChat(chatFn, history, opts) {
                 catch {
                     // observer errors never break the loop
                 }
-                if (typeof durationMs === "number")
+                if (typeof durationMs === "number") {
                     noteBottleneck(name, durationMs);
+                    if (Number.isFinite(durationMs) && durationMs >= 0)
+                        toolTotalMs += Math.floor(durationMs);
+                }
                 if (!isError && (name === "write" || name === "edit")) {
                     filesWritten = true;
                     verifiedAfterWrite = false;
@@ -904,6 +937,8 @@ export async function runLoopWithChat(chatFn, history, opts) {
             // step/total-call budgets above keep bounding runaway retries.
             // Truncated-without-calls never reaches here (handled by the turn-end
             // gates above, exactly as before).
+            // NOTE: truncationNotices is counted at the POST (success) and stream-death
+            // sites above — not here — so each truncated response counts exactly once.
             if (msg.truncated === true) {
                 for (let i = 0; i < calls.length; i++) {
                     const call = calls[i];

package/dist/providers.js

@@ -57,9 +57,10 @@ export const PROVIDERS = [
         consoleURL: "https://opencode.ai/auth",
         envVars: ["OPENCODE_ZEN_API_KEY"],
         // Task 5: strong tool-reliable default (live-list + docs verified
-        // 2026-09-08, see DEFAULT_MODEL in src/zen.ts). Free big-pickle stays
-        // listed as a fallback, selectable via /model. kimi-k2.6 / minimax-m2.7
-        // replace kimi-k2.5 / minimax-m2.5 (both deprecated upstream 2026-08-05).
+        // 2026-09-08, see DEFAULT_MODEL in src/zen.ts). Free models ride along
+        // as fallbacks, selectable via /model (chat family + responses family;
+        // kimi-k2.6 / minimax-m2.7 replace kimi-k2.5 / minimax-m2.5, both
+        // deprecated upstream 2026-08-05).
         defaultModel: "deepseek-v4-pro",
         fallbackModels: [
             "deepseek-v4-pro",
@@ -67,6 +68,13 @@ export const PROVIDERS = [
             "glm-5.2",
             "minimax-m2.7",
             "big-pickle",
+            "mimo-v2.5-free",
+            "ling-3.0-flash-fin-free",
+            "nemotron-3-ultra-free",
+            "nemotron-3.5-lightning-free",
+            "deepseek-v4-flash-free",
+            "muse-spark-1.3-contributor-free",
+            "muse-spark-1.2-contributor-free",
         ],
         notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {