atom-agent 0.3.0

package/dist/adapters.js

@@ -0,0 +1,926 @@
+// Adapter boundary for non-OpenAI kinds (anthropic-messages,
+// gemini-generate). OpenAI-chat kind reuses zen.ts verbatim.
+// Pure translation + SSE parsing; no zen runtime imports (type-only)
+// so zen.ts can import this module without a runtime cycle.
+//
+// Normalized output matches zen ChatResult:
+//   {content, tool_calls:[{id,function:{name,arguments}}], usage?}
+// so runAgenticLoop/retry/rollback/status code is untouched.
+import { TOOL_DEFINITIONS } from "./tools.js";
+import { getProvider, modelsUrlForProvider, } from "./providers.js";
+export const ANTHROPIC_VERSION = "2023-06-01";
+export const ANTHROPIC_MAX_TOKENS = 4096;
+function toolDefs() {
+    return TOOL_DEFINITIONS;
+}
+function parseArgsObject(raw) {
+    try {
+        const v = JSON.parse(raw || "{}");
+        return typeof v === "object" && v !== null
+            ? v
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+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).
+    let pendingToolResults = [];
+    function flushTools() {
+        if (pendingToolResults.length === 0)
+            return;
+        messages.push({ role: "user", content: [...pendingToolResults] });
+        pendingToolResults = [];
+    }
+    for (const m of history) {
+        if (m.role === "system") {
+            systems.push(m.content);
+            continue;
+        }
+        if (m.role === "tool") {
+            pendingToolResults.push({
+                type: "tool_result",
+                tool_use_id: m.tool_call_id,
+                content: m.content,
+            });
+            continue;
+        }
+        flushTools();
+        if (m.role === "user") {
+            messages.push({ role: "user", content: m.content });
+        }
+        else {
+            // assistant: text + tool_use blocks
+            const am = m;
+            const blocks = [];
+            if (typeof am.content === "string" && am.content.length > 0) {
+                blocks.push({ type: "text", text: am.content });
+            }
+            for (const tc of am.tool_calls ?? []) {
+                blocks.push({
+                    type: "tool_use",
+                    id: tc.id,
+                    name: tc.function.name,
+                    input: parseArgsObject(tc.function.arguments),
+                });
+            }
+            if (blocks.length === 0)
+                blocks.push({ type: "text", text: "" });
+            messages.push({ role: "assistant", content: blocks });
+        }
+    }
+    flushTools();
+    const includeTools = opts?.includeTools !== false;
+    const body = {
+        model,
+        max_tokens: ANTHROPIC_MAX_TOKENS,
+        messages,
+    };
+    // Compaction path (includeTools:false) omits `tools` + `tool_choice`
+    // entirely — asserted in tests as "no `tools` key".
+    if (includeTools) {
+        body.tools = toolDefs().map((t) => ({
+            name: t.function.name,
+            description: t.function.description,
+            input_schema: t.function.parameters,
+        }));
+        body.tool_choice = { type: "auto" };
+    }
+    if (systems.length > 0)
+        body.system = systems.join("\n\n");
+    return body;
+}
+export function anthropicHeaders(apiKey) {
+    return {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": ANTHROPIC_VERSION,
+    };
+}
+// ---- Gemini request ----
+// Gemini FunctionDeclaration parameters reject JSON-Schema keywords outside
+// its subset — notably `additionalProperties` (HTTP 400: Unknown name
+// "additionalProperties" at tools[...].function_declarations[...].parameters).
+// TOOL_DEFINITIONS are OpenAI-canonical (every schema carries
+// `additionalProperties: false`), so the GEMINI adapter strips the rejected
+// keys here, recursively, at conversion time. Anthropic input_schema and
+// OpenAI parameters accept them — those paths stay byte-identical, and the
+// canonical schemas are never mutated.
+const GEMINI_STRIPPED_SCHEMA_KEYS = new Set([
+    "additionalProperties",
+    "$schema",
+    "$id",
+    "$ref",
+]);
+function stripGeminiSchemaKeys(value) {
+    if (Array.isArray(value))
+        return value.map(stripGeminiSchemaKeys);
+    if (typeof value === "object" && value !== null) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (GEMINI_STRIPPED_SCHEMA_KEYS.has(k))
+                continue;
+            out[k] = stripGeminiSchemaKeys(v);
+        }
+        return out;
+    }
+    return value;
+}
+export function geminiChatUrl(model) {
+    return `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse`;
+}
+export function geminiGenerateUrl(model) {
+    return `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`;
+}
+export function geminiHeaders(apiKey) {
+    return {
+        "Content-Type": "application/json",
+        "x-goog-api-key": apiKey,
+    };
+}
+export function buildGeminiBody(history, _model, opts) {
+    const systems = [];
+    for (const m of history) {
+        if (m.role === "system")
+            systems.push(m.content);
+    }
+    // tool_call_id -> function name (tool messages carry only the id).
+    const nameById = new Map();
+    for (const m of history) {
+        if (m.role === "assistant") {
+            for (const tc of m.tool_calls ?? []) {
+                if (tc.id)
+                    nameById.set(tc.id, tc.function.name);
+            }
+        }
+    }
+    const contents = [];
+    let pendingResponses = [];
+    function flushResponses() {
+        if (pendingResponses.length === 0)
+            return;
+        contents.push({ role: "user", parts: pendingResponses });
+        pendingResponses = [];
+    }
+    for (const m of history) {
+        if (m.role === "system")
+            continue;
+        if (m.role === "tool") {
+            pendingResponses.push({
+                functionResponse: {
+                    name: nameById.get(m.tool_call_id) ?? "unknown",
+                    response: { result: m.content },
+                },
+            });
+            continue;
+        }
+        flushResponses();
+        if (m.role === "user") {
+            contents.push({ role: "user", parts: [{ text: m.content }] });
+        }
+        else {
+            const am = m;
+            const parts = [];
+            if (typeof am.content === "string" && am.content.length > 0) {
+                parts.push({ text: am.content });
+            }
+            for (const tc of am.tool_calls ?? []) {
+                parts.push({
+                    functionCall: {
+                        name: tc.function.name,
+                        args: parseArgsObject(tc.function.arguments),
+                    },
+                });
+            }
+            if (parts.length === 0)
+                parts.push({ text: "" });
+            contents.push({ role: "model", parts });
+        }
+    }
+    flushResponses();
+    const includeTools = opts?.includeTools !== false;
+    const body = {
+        contents,
+    };
+    // Compaction path (includeTools:false) omits `tools` entirely — asserted
+    // in tests as "no `tools` key".
+    if (includeTools) {
+        body.tools = [
+            {
+                functionDeclarations: toolDefs().map((t) => ({
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: stripGeminiSchemaKeys(t.function.parameters),
+                })),
+            },
+        ];
+    }
+    // Compaction cap (gemini kind uses generationConfig.maxOutputTokens).
+    if (typeof opts?.maxOutputTokens === "number" &&
+        Number.isFinite(opts.maxOutputTokens) &&
+        opts.maxOutputTokens > 0) {
+        body.generationConfig = { maxOutputTokens: Math.floor(opts.maxOutputTokens) };
+    }
+    if (systems.length > 0) {
+        body.system_instruction = { parts: [{ text: systems.join("\n\n") }] };
+    }
+    return body;
+}
+async function collectSSEText(res) {
+    const body = res.body;
+    const decoder = new TextDecoder();
+    let rawText = "";
+    if (body == null)
+        return { rawText, events: [] };
+    try {
+        if (typeof body.getReader === "function") {
+            const reader = body.getReader();
+            try {
+                for (;;) {
+                    let chunk;
+                    try {
+                        chunk = await reader.read();
+                    }
+                    catch (e) {
+                        throw new Error(`Truncated stream from model (connection aborted: ${e instanceof Error ? e.message : String(e)}).`);
+                    }
+                    if (chunk.done)
+                        break;
+                    const v = chunk.value;
+                    rawText +=
+                        typeof v === "string"
+                            ? v
+                            : decoder.decode(v, { stream: true });
+                }
+            }
+            finally {
+                try {
+                    reader.releaseLock?.();
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        else if (typeof body[Symbol.asyncIterator] === "function") {
+            for await (const v of body) {
+                rawText +=
+                    typeof v === "string"
+                        ? v
+                        : decoder.decode(v, { stream: true });
+            }
+        }
+        else {
+            const textFn = res.text;
+            if (typeof textFn === "function") {
+                rawText = String((await textFn.call(res)) ?? "");
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith("Truncated stream"))
+            throw e;
+        throw new Error(`Truncated stream from model (connection aborted: ${e instanceof Error ? e.message : String(e)}).`);
+    }
+    // Split into SSE events: "event:" sets the type for following "data:".
+    const events = [];
+    let curEvent = "message";
+    for (const rawLine of rawText.split("\n")) {
+        let line = rawLine;
+        if (line.endsWith("\r"))
+            line = line.slice(0, -1);
+        if (line.length === 0) {
+            curEvent = "message";
+            continue;
+        }
+        if (line.startsWith(":"))
+            continue;
+        if (line.startsWith("event:")) {
+            curEvent = line.slice("event:".length).trim() || "message";
+            continue;
+        }
+        if (!line.startsWith("data:"))
+            continue; // id:/retry: ignored
+        let payload = line.slice("data:".length);
+        if (payload.startsWith(" "))
+            payload = payload.slice(1);
+        events.push({ event: curEvent, data: payload });
+        // blank line resets below; consecutive data lines keep last event
+    }
+    return { rawText, events };
+}
+function finiteCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.floor(value)
+        : undefined;
+}
+function openAIUsage(prompt, completion) {
+    const out = {};
+    const p = finiteCount(prompt);
+    if (p !== undefined)
+        out.prompt_tokens = p;
+    const c = finiteCount(completion);
+    if (c !== undefined)
+        out.completion_tokens = c;
+    if (p !== undefined && c !== undefined)
+        out.total_tokens = p + c;
+    return out.prompt_tokens !== undefined ||
+        out.completion_tokens !== undefined ||
+        out.total_tokens !== undefined
+        ? out
+        : undefined;
+}
+// Merge one POST's incrementally-reported usage: last value seen per key wins
+// (one stream carries one POST's usage). `total` is authoritative when the
+// provider sends one (Gemini totalTokenCount — kept verbatim, never
+// recomputed over). Otherwise, when `recomputeTotal` is set (Anthropic never
+// sends a total), total_tokens is recomputed from prompt+completion whenever
+// both are known, so a split report (message_start input + message_delta
+// output) never leaves the first chunk's stale total behind. A merge that
+// still carries no usable count returns undefined (never an empty object).
+function mergeUsage(base, partial, opts) {
+    if (partial === undefined && opts?.total === undefined)
+        return base;
+    const merged = { ...base, ...partial };
+    if (opts?.total !== undefined) {
+        merged.total_tokens = opts.total;
+    }
+    else if ((merged.total_tokens === undefined || opts?.recomputeTotal === true) &&
+        merged.prompt_tokens !== undefined &&
+        merged.completion_tokens !== undefined) {
+        merged.total_tokens = merged.prompt_tokens + merged.completion_tokens;
+    }
+    return merged.prompt_tokens !== undefined ||
+        merged.completion_tokens !== undefined ||
+        merged.total_tokens !== undefined
+        ? merged
+        : undefined;
+}
+// ---- Anthropic SSE + JSON ----
+export async function readAnthropicSSEMessage(res, opts) {
+    const { rawText, events } = await collectSSEText(res);
+    const blocks = [];
+    let usage;
+    let stopReason;
+    let sawData = false;
+    let sawStop = false;
+    let streamingAnnounced = false;
+    function announce() {
+        if (!streamingAnnounced) {
+            streamingAnnounced = true;
+            try {
+                opts?.onPhase?.("streaming");
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    function blockAt(index) {
+        while (blocks.length <= index)
+            blocks.push({ kind: "text", text: "" });
+        return blocks[index];
+    }
+    for (const { data } of events) {
+        if (data === "[DONE]") {
+            sawStop = true;
+            continue;
+        }
+        if (!data)
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(data);
+        }
+        catch {
+            continue; // malformed JSON data line: skip, never crash
+        }
+        sawData = true;
+        const o = evt;
+        const type = o["type"];
+        if (type === "message_start") {
+            const msg = o["message"];
+            const u = msg?.["usage"];
+            if (u) {
+                const hit = openAIUsage(u["input_tokens"], u["output_tokens"]);
+                const merged = mergeUsage(usage, hit, { recomputeTotal: true });
+                if (merged !== undefined)
+                    usage = merged;
+            }
+            continue;
+        }
+        if (type === "content_block_start") {
+            const index = typeof o["index"] === "number" ? o["index"] : 0;
+            const cb = o["content_block"];
+            const btype = cb?.["type"];
+            if (btype === "tool_use") {
+                const name = typeof cb?.["name"] === "string" ? cb["name"] : "";
+                const id = typeof cb?.["id"] === "string" ? cb["id"] : "";
+                blocks[index] = { kind: "tool", id, name, json: "" };
+                announce();
+                if (name) {
+                    try {
+                        opts?.onToolDelta?.(name, index);
+                    }
+                    catch {
+                        // ignore
+                    }
+                    try {
+                        opts?.onPhase?.("tool", name);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+            else {
+                blocks[index] = { kind: "text", text: "" };
+            }
+            continue;
+        }
+        if (type === "content_block_delta") {
+            const index = typeof o["index"] === "number" ? o["index"] : 0;
+            const delta = o["delta"];
+            const dtype = delta?.["type"];
+            const slot = blockAt(index);
+            if (dtype === "text_delta" && typeof delta?.["text"] === "string") {
+                const frag = delta["text"];
+                announce();
+                if (slot.kind === "text")
+                    slot.text += frag;
+                else
+                    blocks[index] = { kind: "text", text: frag };
+                try {
+                    opts?.onPhase?.("streaming");
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    opts?.onToken?.(fullText(blocks));
+                }
+                catch {
+                    // ignore
+                }
+            }
+            else if (dtype === "input_json_delta" &&
+                typeof delta?.["partial_json"] === "string") {
+                const frag = delta["partial_json"];
+                announce();
+                if (slot.kind === "tool")
+                    slot.json += frag;
+                // input_json fragments do not emit onToken (not user text)
+            }
+            continue;
+        }
+        if (type === "message_delta") {
+            const delta = o["delta"];
+            if (typeof delta?.["stop_reason"] === "string") {
+                stopReason = delta["stop_reason"];
+            }
+            const u = o["usage"];
+            // Tolerance: some streams put the counts at the top level of
+            // message_delta instead of under `usage` (nested `usage` wins).
+            const inputSrc = u?.["input_tokens"] !== undefined ? u["input_tokens"] : o["input_tokens"];
+            const outputSrc = u?.["output_tokens"] !== undefined ? u["output_tokens"] : o["output_tokens"];
+            if (u !== undefined || o["input_tokens"] !== undefined || o["output_tokens"] !== undefined) {
+                const hit = openAIUsage(inputSrc, outputSrc);
+                const merged = mergeUsage(usage, hit, { recomputeTotal: true });
+                if (merged !== undefined)
+                    usage = merged;
+            }
+            // Some streams put output_tokens at top level of message_delta
+            if (stopReason !== undefined)
+                sawStop = true;
+            continue;
+        }
+        if (type === "message_stop") {
+            sawStop = true;
+            continue;
+        }
+        // Tolerance: non-streaming JSON body delivered as single SSE data line
+        // (e.g. {content:[...], stop_reason, usage}).
+        if (Array.isArray(o["content"]) && o["stop_reason"] !== undefined) {
+            return parseAnthropicJson(o);
+        }
+    }
+    // Tolerance: body with no SSE data lines is really single-shot JSON.
+    if (!sawData) {
+        const candidate = rawText.trim();
+        if (candidate.length > 0) {
+            try {
+                const data = JSON.parse(candidate);
+                if (Array.isArray(data["content"]))
+                    return parseAnthropicJson(data);
+            }
+            catch {
+                // fall through to truncation error
+            }
+        }
+        throw new Error("Truncated stream from model (connection aborted before [DONE]).");
+    }
+    if (!sawStop) {
+        throw new Error("Truncated stream from model (connection aborted before [DONE]).");
+    }
+    void stopReason;
+    return buildAnthropicResult(blocks, usage, opts);
+}
+function fullText(blocks) {
+    return blocks
+        .filter((b) => b.kind === "text")
+        .map((b) => b.text)
+        .join("");
+}
+function buildAnthropicResult(blocks, usage, opts) {
+    const text = fullText(blocks);
+    const calls = [];
+    blocks.forEach((b, i) => {
+        if (b.kind !== "tool")
+            return;
+        if (!b.name) {
+            if (b.id) {
+                try {
+                    opts?.onWarning?.(`dropped tool call ${b.id} with no function name`);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            return;
+        }
+        calls.push({
+            id: b.id || `anthropic-${i}`,
+            type: "function",
+            function: { name: b.name, arguments: b.json || "{}" },
+        });
+    });
+    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 (usage !== undefined)
+        result.usage = usage;
+    return result;
+}
+// Non-streaming Anthropic JSON:
+// {content:[{type:"text",text},{type:"tool_use",id,name,input}], usage:{input_tokens,output_tokens}}
+export function parseAnthropicJson(data) {
+    const o = data;
+    const content = o["content"];
+    let text = "";
+    const calls = [];
+    if (Array.isArray(content)) {
+        for (let i = 0; i < content.length; i++) {
+            const b = content[i];
+            if (b["type"] === "text" && typeof b["text"] === "string") {
+                text += b["text"];
+            }
+            else if (b["type"] === "tool_use") {
+                const name = typeof b["name"] === "string" ? b["name"] : "";
+                if (!name)
+                    continue; // nameless-drop parity
+                const id = typeof b["id"] === "string" ? b["id"] : `anthropic-${i}`;
+                let args = "{}";
+                try {
+                    args = JSON.stringify(b["input"] ?? {});
+                }
+                catch {
+                    args = "{}";
+                }
+                calls.push({ id, 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,
+    };
+    const u = o["usage"];
+    if (u) {
+        const hit = openAIUsage(u["input_tokens"], u["output_tokens"]);
+        if (hit)
+            result.usage = hit;
+    }
+    return result;
+}
+// ---- Gemini SSE + JSON ----
+export async function readGeminiSSEMessage(res, opts) {
+    const { rawText, events } = await collectSSEText(res);
+    let text = "";
+    const calls = [];
+    let usage;
+    let sawData = false;
+    let sawDone = false;
+    // functionCall accumulation: consecutive chunks for the same call merge
+    // their args objects; a new name starts a new slot.
+    function pushFunctionCall(name, args) {
+        let argsJson = "{}";
+        try {
+            argsJson = JSON.stringify(args ?? {});
+        }
+        catch {
+            argsJson = "{}";
+        }
+        const last = calls[calls.length - 1];
+        if (last && last.name === name && last.argsJson === "{}" && argsJson !== "{}") {
+            last.argsJson = argsJson;
+            return;
+        }
+        // Merge object fragments for a repeated name (tolerance for split args).
+        if (last && last.name === name) {
+            try {
+                const a = JSON.parse(last.argsJson);
+                const b = typeof args === "object" && args !== null
+                    ? args
+                    : {};
+                last.argsJson = JSON.stringify({ ...a, ...b });
+                return;
+            }
+            catch {
+                // fall through to new slot
+            }
+        }
+        calls.push({ name, argsJson, index: calls.length });
+        try {
+            opts?.onToolDelta?.(name, calls.length - 1);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            opts?.onPhase?.("tool", name);
+        }
+        catch {
+            // ignore
+        }
+    }
+    for (const { data } of events) {
+        if (data === "[DONE]") {
+            sawDone = true;
+            continue;
+        }
+        if (!data)
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(data);
+        }
+        catch {
+            continue;
+        }
+        sawData = true;
+        const o = evt;
+        const candidates = o["candidates"];
+        if (Array.isArray(candidates)) {
+            for (const c of candidates) {
+                const content = c["content"];
+                const parts = content?.["parts"];
+                if (!Array.isArray(parts))
+                    continue;
+                for (const p of parts) {
+                    if (typeof p["text"] === "string" && p["text"].length > 0) {
+                        text += p["text"];
+                        try {
+                            opts?.onPhase?.("streaming");
+                        }
+                        catch {
+                            // ignore
+                        }
+                        try {
+                            opts?.onToken?.(text);
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    const fc = p["functionCall"];
+                    if (fc && typeof fc["name"] === "string" && fc["name"]) {
+                        pushFunctionCall(fc["name"], fc["args"]);
+                    }
+                }
+            }
+        }
+        const um = o["usageMetadata"];
+        if (um) {
+            const hit = openAIUsage(um["promptTokenCount"], um["candidatesTokenCount"]);
+            const total = finiteCount(um["totalTokenCount"]);
+            const merged = mergeUsage(usage, hit, { total });
+            if (merged !== undefined)
+                usage = merged;
+        }
+    }
+    // Tolerance: no SSE data lines -> single-shot :generateContent JSON.
+    if (!sawData) {
+        const candidate = rawText.trim();
+        if (candidate.length > 0) {
+            try {
+                const data = JSON.parse(candidate);
+                if (Array.isArray(data["candidates"]))
+                    return parseGeminiJson(data);
+            }
+            catch {
+                // fall through
+            }
+        }
+        throw new Error("Truncated stream from model (connection aborted before [DONE]).");
+    }
+    // Gemini SSE streams do not always send [DONE]; a stream that produced
+    // data and ended cleanly is accepted. An empty stream is truncated.
+    void sawDone;
+    const tool_calls = [];
+    for (let i = 0; i < calls.length; i++) {
+        const c = calls[i];
+        if (!c.name)
+            continue; // nameless-drop parity
+        tool_calls.push({
+            id: `gemini-${i}`,
+            type: "function",
+            function: { name: c.name, arguments: c.argsJson },
+        });
+    }
+    if (tool_calls.length === 0 && text.trim() === "") {
+        throw new Error("Empty reply from model (unexpected payload).");
+    }
+    const result = {
+        content: text.length > 0 ? text : null,
+        tool_calls: tool_calls.length > 0 ? tool_calls : undefined,
+    };
+    if (usage !== undefined)
+        result.usage = usage;
+    return result;
+}
+// Non-streaming :generateContent JSON:
+// {candidates:[{content:{parts:[{text},{functionCall:{name,args}}]}}], usageMetadata}
+export function parseGeminiJson(data) {
+    const o = data;
+    let text = "";
+    const calls = [];
+    const candidates = o["candidates"];
+    if (Array.isArray(candidates)) {
+        for (const c of candidates) {
+            const content = c["content"];
+            const parts = content?.["parts"];
+            if (!Array.isArray(parts))
+                continue;
+            for (const p of parts) {
+                if (typeof p["text"] === "string")
+                    text += p["text"];
+                const fc = p["functionCall"];
+                if (fc && typeof fc["name"] === "string" && fc["name"]) {
+                    let argsJson = "{}";
+                    try {
+                        argsJson = JSON.stringify(fc["args"] ?? {});
+                    }
+                    catch {
+                        argsJson = "{}";
+                    }
+                    calls.push({
+                        id: `gemini-${calls.length}`,
+                        type: "function",
+                        function: { name: fc["name"], arguments: argsJson },
+                    });
+                }
+            }
+        }
+    }
+    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,
+    };
+    const um = o["usageMetadata"];
+    if (um) {
+        const hit = openAIUsage(um["promptTokenCount"], um["candidatesTokenCount"]);
+        const total = finiteCount(um["totalTokenCount"]);
+        const merged = mergeUsage(undefined, hit, { total });
+        if (merged !== undefined)
+            result.usage = merged;
+    }
+    return result;
+}
+// ---- Models-list parsing per kind (pure; ANY failure -> fallback) ----
+function entryId(entry) {
+    if (typeof entry === "string")
+        return entry || null;
+    if (typeof entry !== "object" || entry === null)
+        return null;
+    const e = entry;
+    const id = e["id"] ?? e["name"];
+    return typeof id === "string" && id.length > 0 ? id : null;
+}
+// OpenAI-kind for NON-zen providers: accept every listed id.
+export function parseOpenAIModelsList(data, fallback) {
+    try {
+        const entries = Array.isArray(data)
+            ? data
+            : data?.data;
+        if (!Array.isArray(entries) || entries.length === 0)
+            return [...fallback];
+        const picked = [];
+        for (const entry of entries) {
+            const id = entryId(entry);
+            if (id)
+                picked.push(id);
+        }
+        return picked.length > 0 ? picked : [...fallback];
+    }
+    catch {
+        return [...fallback];
+    }
+}
+export function parseAnthropicModelsList(data, fallback) {
+    try {
+        const entries = Array.isArray(data)
+            ? data
+            : data?.data;
+        if (!Array.isArray(entries) || entries.length === 0)
+            return [...fallback];
+        const picked = [];
+        for (const entry of entries) {
+            const id = entryId(entry);
+            if (id)
+                picked.push(id);
+        }
+        return picked.length > 0 ? picked : [...fallback];
+    }
+    catch {
+        return [...fallback];
+    }
+}
+export function parseGeminiModelsList(data, fallback) {
+    try {
+        const o = data;
+        const entries = Array.isArray(o?.models) ? o.models : null;
+        if (!Array.isArray(entries) || entries.length === 0)
+            return [...fallback];
+        const picked = [];
+        for (const entry of entries) {
+            let id = entryId(entry);
+            if (id && id.startsWith("models/"))
+                id = id.slice("models/".length);
+            if (id)
+                picked.push(id);
+        }
+        return picked.length > 0 ? picked : [...fallback];
+    }
+    catch {
+        return [...fallback];
+    }
+}
+// ---- Key validation (cheap GET per kind; mocked in tests, never live) ----
+export async function validateProviderKey(id, apiKey, storedBaseURL) {
+    if (!apiKey)
+        return { ok: false, error: "missing API key" };
+    const def = getProvider(id);
+    if (!def)
+        return { ok: false, error: `unknown provider: ${id}` };
+    try {
+        if (id === "anthropic") {
+            const res = await fetch("https://api.anthropic.com/v1/models", {
+                headers: {
+                    "x-api-key": apiKey,
+                    "anthropic-version": ANTHROPIC_VERSION,
+                },
+            });
+            if (res.ok)
+                return { ok: true };
+            return { ok: false, error: `Anthropic HTTP ${res.status}` };
+        }
+        if (id === "google-gemini") {
+            const res = await fetch("https://generativelanguage.googleapis.com/v1beta/models", { headers: { "x-goog-api-key": apiKey } });
+            if (res.ok)
+                return { ok: true };
+            return { ok: false, error: `Gemini HTTP ${res.status}` };
+        }
+        // OpenAI-kind: GET {base}/models with Bearer.
+        const url = modelsUrlForProvider(id, storedBaseURL);
+        const headers = {
+            Authorization: `Bearer ${apiKey}`,
+        };
+        const res = await fetch(url, { headers });
+        if (res.ok)
+            return { ok: true };
+        const label = id === "opencode-zen"
+            ? "Zen"
+            : (def.name ?? String(id));
+        return { ok: false, error: `${label} HTTP ${res.status}` };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}