clauderipple 0.7.0 → 0.8.1

package/dist/router/src/providers/google/translate.js

@@ -0,0 +1,539 @@
+// Anthropic Messages ⇄ Google Gemini `generateContent`. Pure translation and streaming mapping
+// for the AI Studio wire; the transport (endpoint, auth, envelope) is separated in transport.ts so
+// another Google backend can be added without touching any of this.
+//
+// Prompt-cache rule (the same one every translated provider follows): the generated body must be a
+// byte-stable prefix of the next turn's, so nothing here uses a timestamp or a random value, key
+// order is fixed, and replayed thinking is dropped from the history.
+//
+// Gemini-3 thought signatures are the one piece of state that cannot live in the body alone: a
+// functionCall part must carry back the `thoughtSignature` the model attached, so the request path
+// reads it from a map keyed by our own tool_use id (see thoughtSignatures.ts). A missing signature
+// is answered with the documented validator-bypass sentinel — see `SIGNATURE_SENTINEL`.
+import crypto from "node:crypto";
+import { clampEffort } from "../../compat.js";
+import { estimateTokens, normalizeSchema, serverToolNames, systemWithDroppedToolNote, toolNameForResponses } from "../chatgpt/translate.js";
+import { identityPrefix, instructionsSuffix } from "../../identity.js";
+/**
+ * The value Google's own thought-signatures guide documents for a fake signature: it "instructs the
+ * API to skip validation for that turn", for exactly our case — functionCall parts "that were not
+ * generated by the API and therefore don't have an associated thought signature" (migrating a
+ * history in). It is a last resort and costs reasoning continuity, so it is used only where a real
+ * signature is unavailable, and never on a Gemini 2.5 turn (which never asked for one).
+ *
+ * Source: https://cloud.google.com/vertex-ai/generative-ai/docs/thought-signatures (read
+ * 2026-10-01: "should be a last resort as it will negatively impact model performance").
+ */
+export const SIGNATURE_SENTINEL = "skip_thought_signature_validator";
+// ---- text helpers ------------------------------------------------------------------
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => String(block.text ?? ""))
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+function inlineImages(content) {
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const block of content) {
+        if (block.type !== "image")
+            continue;
+        const source = block.source;
+        if (source?.type === "base64" && typeof source.data === "string") {
+            out.push({ mimeType: typeof source.media_type === "string" ? source.media_type : "image/png", data: source.data });
+        }
+    }
+    return out;
+}
+// ---- effort → thinkingConfig -------------------------------------------------------
+// Google exposes reasoning depth two different ways depending on the model family:
+//
+//   - Gemini 3 (`gemini-3-*`, `gemini-3.<n>-*`) takes a *level* on
+//     `generationConfig.thinkingConfig.thinkingLevel`. The documented allowed values are
+//     `minimal`, `low`, `medium`, `high` (Google Cloud "Get started with Gemini 3" / "Gemini 3
+//     Flash": Flash supports minimal…high, Pro supports low/high). The Generative Language
+//     Discovery document adds a second spelling (`thinkingLevel: "OFF" | "BASIC" | "DEEP"`,
+//     ai.google.dev/api/generate-content), which does not agree with the guide — so this is
+//     (assumption)-grade and the lower-case guide spelling is used. Our seven-step ladder is
+//     clamped onto those four: `max`/`xhigh`→`high`, `none`→`minimal`.
+//   - Gemini 2.5 takes a token *budget* on `generationConfig.thinkingConfig.thinkingBudget`
+//     (an integer; `0` disables thinking). The per-generation ranges are (assumption): flash
+//     0..24576, pro 128..32768 — the numbers below stay well inside both.
+//
+// A model that matches neither family gets no thinkingConfig at all: inventing a field for an
+// unknown model is the one failure shape worse than sending no reasoning hint.
+const GEMINI3_LEVELS = ["minimal", "low", "medium", "high"];
+/** The Gemini-3 thinking level our effort maps to, or undefined when the effort is not one we know. */
+function gemini3Level(effort) {
+    switch (effort) {
+        case "none": return "minimal";
+        case "minimal": return "minimal";
+        case "low": return "low";
+        case "medium": return "medium";
+        case "high": return "high";
+        // The top of our ladder has no separate step on this wire; clamp to the top the wire has.
+        case "xhigh": return "high";
+        case "max": return "high";
+        case "ultra": return "high";
+        default: return undefined;
+    }
+}
+/** A Gemini-2.5 thinking budget for our effort, or undefined when the effort is not one we know. */
+function gemini25Budget(effort) {
+    switch (effort) {
+        case "none": return 0;
+        case "minimal": return 1024;
+        case "low": return 1024;
+        case "medium": return 8192;
+        case "high": return 16384;
+        case "xhigh": return 24576;
+        case "max": return 24576;
+        case "ultra": return 24576;
+        default: return undefined;
+    }
+}
+function thinkingFamily(model) {
+    if (/^gemini-3[-.]/.test(model))
+        return "gemini3";
+    if (/^gemini-2\.5/.test(model))
+        return "gemini25";
+    return null;
+}
+/**
+ * The reasoning effort a request will actually put on the wire, named for the identity line. A
+ * provider whose caps declare a ladder clamps to it first, so the model is told the level it sees.
+ */
+function namedEffort(opts) {
+    if (!opts.effort)
+        return undefined;
+    const levels = opts.caps?.effortLevels;
+    return levels && levels.length > 0 ? clampEffort(opts.effort, levels) : opts.effort;
+}
+function thinkingConfigFor(model, effort) {
+    if (!effort)
+        return undefined;
+    const family = thinkingFamily(model);
+    if (family === "gemini3") {
+        const level = gemini3Level(effort);
+        return level ? { thinkingLevel: level } : undefined;
+    }
+    if (family === "gemini25") {
+        const budget = gemini25Budget(effort);
+        return budget === undefined ? undefined : { thinkingBudget: budget };
+    }
+    return undefined;
+}
+// ---- messages → contents -----------------------------------------------------------
+/** The system text this provider should see: what it is, the caller's prompt, the configured addendum. */
+function systemForGoogle(sys, opts) {
+    return [identityPrefix({ model: opts.model, effort: namedEffort(opts), identity: opts.identity }), sys, instructionsSuffix({ model: opts.model, instructionsAppend: opts.instructionsAppend })]
+        .filter(Boolean)
+        .join("\n\n");
+}
+/** Build `contents` from the Anthropic history, repairing the tool_call/tool_result adjacency Gemini needs. */
+function toContents(req, opts) {
+    const contents = [];
+    const messages = req.messages;
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        const blocks = Array.isArray(message.content) ? message.content : null;
+        if (message.role === "assistant") {
+            const parts = [];
+            const calls = [];
+            // Gemini signs only the first functionCall of a step, so a parallel call with no signature of
+            // its own is normal, not missing. The sentinel is for a turn that has no real signature at all
+            // (a restart, another model's history), and then only on its first call, where one belongs:
+            // sent on every unsigned call it would skip validation — and cost reasoning — on healthy turns.
+            const signedTurn = (blocks ?? []).some((block) => block.type === "tool_use" && opts.thoughtSignatures?.get(block.id) !== undefined);
+            let sentinelPlaced = false;
+            for (const block of blocks ?? []) {
+                if (block.type === "text") {
+                    const text = String(block.text ?? "");
+                    if (text)
+                        parts.push({ text });
+                }
+                else if (block.type === "tool_use") {
+                    const call = block;
+                    const wireName = toolNameForResponses(call.name);
+                    calls.push({ id: call.id, wireName });
+                    const part = { functionCall: { name: wireName, args: asArgs(call.input), id: call.id } };
+                    const signature = opts.thoughtSignatures?.get(call.id);
+                    if (signature)
+                        part.thoughtSignature = signature;
+                    else if (opts.signatureSentinel && !signedTurn && !sentinelPlaced && thinkingFamily(opts.model) === "gemini3") {
+                        part.thoughtSignature = SIGNATURE_SENTINEL;
+                        sentinelPlaced = true;
+                    }
+                    parts.push(part);
+                }
+                // thinking / redacted_thinking / anything else: dropped on purpose (cache stability)
+            }
+            // A turn Gemini cannot represent (thinking-only, for instance) would serialize as `parts: []`,
+            // which Gemini rejects; it is skipped rather than sent empty.
+            if (parts.length > 0)
+                contents.push({ role: "model", parts });
+            if (calls.length > 0) {
+                // Gemini requires every functionCall in a turn to be answered by an adjacent functionResponse
+                // batch. Gather the tool_result blocks from the user turn(s) that follow, then skip them.
+                const required = new Map(calls.map((call) => [call.id, call]));
+                const results = new Map();
+                const orphanResults = [];
+                let j = i + 1;
+                while (j < messages.length) {
+                    const next = messages[j];
+                    const nextContent = next.content;
+                    if (next.role === "assistant" || !Array.isArray(nextContent))
+                        break;
+                    const resultBlocks = nextContent.filter((b) => b.type === "tool_result");
+                    if (resultBlocks.length === 0)
+                        break;
+                    for (const block of resultBlocks) {
+                        const id = block.tool_use_id;
+                        if (typeof id === "string" && required.has(id) && !results.has(id))
+                            results.set(id, block);
+                        else
+                            orphanResults.push(block);
+                    }
+                    j++;
+                }
+                const responseParts = [];
+                for (const call of calls)
+                    responseParts.push(functionResponsePart(call, results.get(call.id)));
+                for (const orphan of orphanResults)
+                    responseParts.push(...orphanResultParts(orphan));
+                contents.push({ role: "user", parts: responseParts });
+                i = j - 1;
+                continue;
+            }
+            continue;
+        }
+        // user
+        if (typeof message.content === "string") {
+            if (message.content)
+                contents.push({ role: "user", parts: [{ text: message.content }] });
+            continue;
+        }
+        const parts = [];
+        for (const block of blocks ?? []) {
+            if (block.type === "text") {
+                const text = String(block.text ?? "");
+                if (text)
+                    parts.push({ text });
+            }
+            else if (block.type === "image") {
+                const image = inlineImages([block])[0];
+                // Gemini takes base64 bytes through inlineData; a remote URL carries no bytes we hold, so a
+                // short marker stands in rather than inlining the URL as a huge text blob.
+                if (image)
+                    parts.push({ inlineData: { mimeType: image.mimeType, data: image.data } });
+                else
+                    parts.push({ text: `[image: ${String(block.source?.url ?? "")}]` });
+            }
+            else if (block.type === "tool_result") {
+                // A result with no adjacent call cannot be a functionResponse; it is sent as user text.
+                parts.push(...orphanResultParts(block));
+            }
+            // thinking etc. dropped
+        }
+        if (parts.length > 0)
+            contents.push({ role: "user", parts });
+    }
+    // Gemini rejects a request that opens on a functionCall turn ("function call turn comes
+    // immediately after a user turn or after a function response turn", HTTP 400). Compaction can
+    // truncate a long history so it opens on an assistant tool call.
+    const first = contents[0];
+    if (first?.role === "model" && first.parts.some((part) => part.functionCall !== undefined)) {
+        contents.unshift({ role: "user", parts: [{ text: "(continue)" }] });
+    }
+    // Gemini also rejects an assistant-tail history ("Requests ending with a model turn are not
+    // supported", HTTP 400). A compaction, an interrupt or a replayed turn can leave one.
+    const last = contents[contents.length - 1];
+    if (!last || last.role === "model")
+        contents.push({ role: "user", parts: [{ text: "(continue)" }] });
+    return contents;
+}
+/** A tool's input as Gemini's `functionCall.args` wants it: a JSON object, never a string. */
+function asArgs(input) {
+    if (input && typeof input === "object" && !Array.isArray(input))
+        return input;
+    if (typeof input === "string") {
+        try {
+            const parsed = JSON.parse(input);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* fall through to the empty object */ }
+    }
+    return {};
+}
+const MISSING_TOOL_RESULT = "[missing tool_result for this tool_use in history]";
+const EMPTY_TOOL_OUTPUT = "(empty tool output)";
+const EMPTY_TEXT = "(empty)";
+function functionResponsePart(call, result) {
+    if (!result) {
+        // Repair the boundary without inventing success: say a result is missing rather than claiming one.
+        return { functionResponse: { name: call.wireName, response: { result: MISSING_TOOL_RESULT }, id: call.id } };
+    }
+    const block = result;
+    let output = textOf(block.content);
+    if (block.is_error && !output)
+        output = "Tool execution failed";
+    if (!output)
+        output = EMPTY_TOOL_OUTPUT;
+    return { functionResponse: { name: call.wireName, response: { result: output }, id: call.id } };
+}
+function orphanResultParts(block) {
+    const b = block;
+    let output = textOf(b.content);
+    if (b.is_error && !output)
+        output = "Tool execution failed";
+    if (!output)
+        output = EMPTY_TOOL_OUTPUT;
+    const parts = [{ text: `[Tool result]\n${output}` }];
+    for (const image of inlineImages(b.content))
+        parts.push({ inlineData: { mimeType: image.mimeType, data: image.data } });
+    return parts;
+}
+// ---- tools -------------------------------------------------------------------------
+// Anthropic's server-side tools (`web_search` and friends) are run by Anthropic, not by the model
+// holding them. Declaring one to this provider offers a tool that cannot execute: the model calls
+// it, nothing answers, and the turn returns empty with no error. The same rule every translated
+// provider follows.
+function functionTools(req) {
+    const dropped = serverToolNames(req.tools);
+    return (req.tools ?? [])
+        .filter((tool) => typeof tool.name === "string" && !dropped.has(tool.name))
+        .map((tool) => ({
+        name: toolNameForResponses(tool.name),
+        description: tool.description ?? "",
+        parametersJsonSchema: normalizeSchema(tool.input_schema),
+    }));
+}
+/** Whether a `tool_choice` that named a dropped tool would force the model onto something undeclared. */
+function choiceSurvives(req) {
+    const choice = req.tool_choice;
+    return choice?.type === "tool" && !!choice.name && !serverToolNames(req.tools).has(choice.name);
+}
+function mapToolChoice(req, tools) {
+    // `mode: "ANY"` with no declarations is a guaranteed 400, so a tool-less request sends no config.
+    if (tools.length === 0)
+        return undefined;
+    const choice = req.tool_choice;
+    if (!choice)
+        return undefined;
+    if (choice.type === "auto")
+        return { functionCallingConfig: { mode: "AUTO" } };
+    if (choice.type === "any")
+        return { functionCallingConfig: { mode: "ANY" } };
+    if (choice.type === "none")
+        return { functionCallingConfig: { mode: "NONE" } };
+    return choiceSurvives(req)
+        ? { functionCallingConfig: { mode: "ANY", allowedFunctionNames: [toolNameForResponses(choice.name)] } }
+        : undefined;
+}
+export function toGeminiRequest(req, opts) {
+    const out = { contents: toContents(req, opts) };
+    const sys = systemForGoogle(systemWithDroppedToolNote(req), opts);
+    if (sys)
+        out.systemInstruction = { parts: [{ text: sys }] };
+    const tools = functionTools(req);
+    if (tools.length > 0) {
+        out.tools = [{ functionDeclarations: tools }];
+        const toolConfig = mapToolChoice(req, tools);
+        if (toolConfig)
+            out.toolConfig = toolConfig;
+    }
+    const generationConfig = {};
+    if (typeof req.max_tokens === "number")
+        generationConfig.maxOutputTokens = req.max_tokens;
+    if (typeof req.temperature === "number")
+        generationConfig.temperature = req.temperature;
+    if (Array.isArray(req.stop_sequences) && req.stop_sequences.every((value) => typeof value === "string")) {
+        generationConfig.stopSequences = req.stop_sequences;
+    }
+    const thinkingConfig = thinkingConfigFor(opts.model, namedEffort(opts));
+    if (thinkingConfig)
+        generationConfig.thinkingConfig = thinkingConfig;
+    if (Object.keys(generationConfig).length > 0)
+        out.generationConfig = generationConfig;
+    return out;
+}
+export { estimateTokens };
+/** Maps Gemini `streamGenerateContent` SSE chunks to Anthropic Messages SSE. */
+export class GoogleStreamMapper {
+    started = false;
+    finished = false;
+    blockIndex = -1;
+    open = null;
+    sawTool = false;
+    finishReason;
+    sawCompletion = false;
+    toolCounter = 0;
+    toolNames;
+    onFunctionCall;
+    messageId = `msg_${crypto.randomBytes(12).toString("hex")}`;
+    content = [];
+    usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
+    stopReason = "end_turn";
+    failure;
+    model;
+    startInput;
+    constructor(model, startInput = 0, toolNames = new Map(), onFunctionCall) {
+        this.model = model;
+        this.startInput = startInput;
+        this.toolNames = toolNames;
+        this.onFunctionCall = onFunctionCall;
+    }
+    get isFinished() { return this.finished; }
+    /** Whether Gemini said the answer was over (a `finishReason` was seen). */
+    get completed() { return this.sawCompletion; }
+    start() {
+        if (this.started)
+            return [];
+        this.started = true;
+        return [{ event: "message_start", data: { type: "message_start", message: { id: this.messageId, type: "message", role: "assistant", model: this.model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: this.startInput, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } } }];
+    }
+    closeBlock() {
+        if (!this.open)
+            return [];
+        const index = this.open.index;
+        this.open = null;
+        return [{ event: "content_block_stop", data: { type: "content_block_stop", index } }];
+    }
+    openBlock(kind, contentBlock, toolIndex) {
+        const out = this.closeBlock();
+        const index = ++this.blockIndex;
+        this.open = { kind, index, ...(toolIndex === undefined ? {} : { toolIndex }) };
+        out.push({ event: "content_block_start", data: { type: "content_block_start", index, content_block: contentBlock } });
+        return out;
+    }
+    setUsage(value) {
+        if (!value || typeof value !== "object")
+            return;
+        const num = (v) => (typeof v === "number" && Number.isFinite(v) ? Math.max(0, v) : 0);
+        const prompt = num(value.promptTokenCount);
+        const cached = num(value.cachedContentTokenCount);
+        const candidates = num(value.candidatesTokenCount);
+        const thoughts = num(value.thoughtsTokenCount);
+        this.usage = {
+            input_tokens: Math.max(0, prompt - cached),
+            output_tokens: candidates + thoughts,
+            cache_read_input_tokens: cached,
+            cache_creation_input_tokens: 0,
+        };
+    }
+    /** The vendor echoes the name it was given; Claude Code only recognises the original. */
+    restore(name) {
+        return this.toolNames.get(name) ?? name;
+    }
+    feedParts(parts) {
+        const out = [];
+        for (const part of parts) {
+            if (typeof part.text === "string" && part.text) {
+                if (part.thought === true) {
+                    if (!this.open || this.open.kind !== "thinking") {
+                        this.content.push({ type: "thinking", thinking: "" });
+                        out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+                    }
+                    const last = this.content[this.content.length - 1];
+                    if (last?.type === "thinking")
+                        last.thinking += part.text;
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "thinking_delta", thinking: part.text } } });
+                }
+                else {
+                    if (!this.open || this.open.kind !== "text") {
+                        this.content.push({ type: "text", text: "" });
+                        out.push(...this.openBlock("text", { type: "text", text: "" }));
+                    }
+                    const last = this.content[this.content.length - 1];
+                    if (last?.type === "text")
+                        last.text += part.text;
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "text_delta", text: part.text } } });
+                }
+                continue;
+            }
+            if (part.functionCall && typeof part.functionCall.name === "string") {
+                this.sawTool = true;
+                const index = this.toolCounter++;
+                const name = this.restore(part.functionCall.name);
+                const id = `toolu_${crypto.randomBytes(12).toString("hex")}`;
+                const args = typeof part.functionCall.args === "object" && part.functionCall.args !== null ? JSON.stringify(part.functionCall.args) : "{}";
+                const tool = { type: "tool_use", id, name, input: {}, args, index };
+                this.content.push(tool);
+                // A whole functionCall arrives in one part, so it opens, takes its arguments in a single
+                // delta, and closes — there is nothing to stream.
+                out.push(...this.openBlock("tool", { type: "tool_use", id, name, input: {} }, index));
+                out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "input_json_delta", partial_json: args } } });
+                out.push(...this.closeBlock());
+                // Let the adapter remember the signature against the id it just minted, so the next turn can
+                // send it back with the replayed functionCall.
+                this.onFunctionCall?.({ id, name, signature: typeof part.thoughtSignature === "string" && part.thoughtSignature ? part.thoughtSignature : undefined });
+            }
+            // inlineData (image output) is not handled in this stage; it is ignored rather than guessed at.
+        }
+        // A part's own text may have been empty but a later part non-empty; the caller decides on close.
+        return out;
+    }
+    feed(chunk) {
+        if (this.finished)
+            return [];
+        const out = [...this.start()];
+        if (chunk.error && typeof chunk.error === "object") {
+            const message = typeof chunk.error.message === "string" ? chunk.error.message : "upstream error";
+            const status = typeof chunk.error.status === "string" ? chunk.error.status : undefined;
+            return [...out, ...this.fail(message, status)];
+        }
+        if (chunk.usageMetadata)
+            this.setUsage(chunk.usageMetadata);
+        const candidates = Array.isArray(chunk.candidates) ? chunk.candidates : [];
+        for (const candidate of candidates) {
+            if (typeof candidate?.finishReason === "string" && candidate.finishReason) {
+                this.finishReason = candidate.finishReason;
+                this.sawCompletion = true;
+            }
+            const parts = candidate?.content?.parts;
+            if (Array.isArray(parts))
+                out.push(...this.feedParts(parts));
+        }
+        return out;
+    }
+    finish() {
+        if (this.finished)
+            return [];
+        this.finished = true;
+        this.stopReason = this.sawTool ? "tool_use" : this.finishReason === "MAX_TOKENS" ? "max_tokens" : "end_turn";
+        return [...this.start(), ...this.closeBlock(), { event: "message_delta", data: { type: "message_delta", delta: { stop_reason: this.stopReason, stop_sequence: null }, usage: this.usage } }, { event: "message_stop", data: { type: "message_stop" } }];
+    }
+    fail(message, status) {
+        if (this.finished)
+            return [];
+        this.finished = true;
+        // `overloaded_error` is the one mid-stream error Claude Code retries on its own; `api_error` is
+        // final. Gemini's RESOURCE_EXHAUSTED becomes a rate limit the client backs off from.
+        const type = status === "RESOURCE_EXHAUSTED" ? "rate_limit_error" : status === "UNAVAILABLE" || status === "INTERNAL" || status === "DEADLINE_EXCEEDED" ? "overloaded_error" : "api_error";
+        this.failure = { type, message };
+        return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
+    }
+    message() {
+        const content = this.content.map((block) => {
+            if (block.type !== "tool_use")
+                return block;
+            let input = {};
+            try {
+                input = block.args ? JSON.parse(block.args) : {};
+            }
+            catch { /* malformed vendor arguments become an empty tool input */ }
+            return { type: "tool_use", id: block.id, name: block.name, input };
+        });
+        return { id: this.messageId, type: "message", role: "assistant", model: this.model, content, stop_reason: this.stopReason, stop_sequence: null, usage: this.usage };
+    }
+}
+export function formatSse(event) {
+    return `event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`;
+}

package/dist/router/src/providers/google/transport.js

@@ -0,0 +1,118 @@
+// The Google transport: endpoint, authentication, envelope and response unwrapping, kept apart from
+// the translation so the two Google backends share one `translate.ts`.
+//
+//   api-key      the AI Studio Generative Language API, called with a key on `x-goog-api-key`.
+//   antigravity  Cloud Code Assist / Antigravity: an OAuth bearer, the Gemini body wrapped in a
+//                `{ project, model, request: {…} }` envelope on `v1internal:`, and the answer nested
+//                back under `response`. Account selection, refresh and retry live in index.ts; this
+//                file only builds the bytes and unwraps the frames.
+//
+// The antigravity wire is taken from the reference implementation opencodex as a behavioral spec
+// (src/adapters/google.ts:1056-1160, src/adapters/google-antigravity-wire.ts) and is **not measured
+// live** — this environment has no Antigravity subscription. See docs/ARCHITECTURE.md §4d.
+import { antigravityRequestId, antigravitySessionId, antigravityUserAgent, GOOGLE_OAUTH, resolveAntigravityWireModel } from "./antigravity.js";
+const DEFAULT_BASE = "https://generativelanguage.googleapis.com";
+/** The AI Studio key: the provider's own, or the environment names Google's own SDKs read. Never logged. */
+export function resolveApiKey(configured) {
+    const key = configured?.trim();
+    if (key)
+        return key;
+    const env = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    return env && env.trim() ? env.trim() : undefined;
+}
+export function googleBaseUrl(configured) {
+    return (configured?.trim() || DEFAULT_BASE).replace(/\/+$/, "");
+}
+/** The Cloud Code Assist base; the daily host, overridable by the provider's `url`. */
+export function antigravityBaseUrl(configured) {
+    return (configured?.trim() || GOOGLE_OAUTH.dailyApi).replace(/\/+$/, "");
+}
+export function createTransport(mode, opts) {
+    if (mode === "antigravity") {
+        const base = antigravityBaseUrl(opts.url);
+        return {
+            kind: "antigravity",
+            build(req, o) {
+                const auth = o.antigravity;
+                if (!auth)
+                    throw new Error("ClaudeRipple: the Google Antigravity mode needs a signed-in account; run `clauderipple google-login`");
+                const resolved = resolveAntigravityWireModel(o.model, o.effort);
+                const request = { ...req, sessionId: antigravitySessionId(auth.conversationKey) };
+                // The transport owns `thinkingConfig` on this wire. The translation guesses a level from the
+                // base id, but CCA's wire id already encodes the tier for some models (gemini-3.8-flash-low);
+                // sending a level beside one states the effort twice and the run tier becomes unknowable. So
+                // whatever the translation set is replaced by exactly what the resolved wire id wants — a
+                // level, or nothing.
+                const generationConfig = { ...(request.generationConfig ?? {}) };
+                if (resolved.thinkingLevel)
+                    generationConfig.thinkingConfig = { thinkingLevel: resolved.thinkingLevel };
+                else
+                    delete generationConfig.thinkingConfig;
+                if (Object.keys(generationConfig).length > 0)
+                    request.generationConfig = generationConfig;
+                else
+                    delete request.generationConfig;
+                // Claude models on CCA force validated function calling (the real client always sets it). A
+                // client that asked for no tools is honoured by dropping the declarations, the wire shape of a
+                // tool-less turn. Source: opencodex src/adapters/google.ts:1109-1120.
+                if (/^claude-/.test(resolved.wire) && request.tools) {
+                    if (request.toolConfig?.functionCallingConfig?.mode === "NONE") {
+                        delete request.tools;
+                        delete request.toolConfig;
+                    }
+                    else {
+                        request.toolConfig = { functionCallingConfig: { ...(request.toolConfig?.functionCallingConfig ?? {}), mode: "VALIDATED" } };
+                    }
+                }
+                const method = o.stream ? "streamGenerateContent" : "generateContent";
+                const query = o.stream ? "?alt=sse" : "";
+                const envelope = {
+                    model: resolved.wire,
+                    // A protocol constant, distinct from the HTTP User-Agent header below. Source: opencodex
+                    // src/adapters/google.ts:1149-1155.
+                    userAgent: "antigravity",
+                    requestType: "agent",
+                    project: auth.projectId,
+                    requestId: antigravityRequestId(),
+                    request,
+                };
+                return {
+                    url: `${base}/${GOOGLE_OAUTH.apiVersion}:${method}${query}`,
+                    headers: {
+                        "content-type": "application/json",
+                        accept: o.stream ? "text/event-stream" : "application/json",
+                        // The IDE client family is required to unlock newer agent models. Never a giveaway literal.
+                        "user-agent": antigravityUserAgent(),
+                        authorization: `Bearer ${auth.accessToken}`,
+                    },
+                    body: JSON.stringify(envelope),
+                };
+            },
+            unwrap(raw) {
+                const wrapped = raw.response;
+                // A top-level `{ error: … }` frame has no `response`; it is returned as it is so the mapper
+                // still sees the error.
+                return wrapped && typeof wrapped === "object" && !Array.isArray(wrapped) ? wrapped : raw;
+            },
+        };
+    }
+    const base = googleBaseUrl(opts.url);
+    const apiKey = resolveApiKey(opts.apiKey);
+    return {
+        kind: "api-key",
+        build(req, o) {
+            if (!apiKey)
+                throw new Error("ClaudeRipple: this Google provider has no API key; set apiKey or GEMINI_API_KEY");
+            const method = o.stream ? "streamGenerateContent" : "generateContent";
+            const query = o.stream ? "?alt=sse" : "";
+            return {
+                url: `${base}/v1beta/models/${encodeURIComponent(o.model)}:${method}${query}`,
+                headers: { "content-type": "application/json", accept: o.stream ? "text/event-stream" : "application/json", "x-goog-api-key": apiKey },
+                body: JSON.stringify(req),
+            };
+        },
+        unwrap(raw) {
+            return raw;
+        },
+    };
+}