@inbrowser/model 0.1.0 → 0.2.0

package/dist/providers/claude-code.js

@@ -0,0 +1,182 @@
+import { renderPrompt } from './claude-cli.js';
+/** Map the relay's `reasoningEffort` onto the SDK's `effort` option.
+ *  `off` is the relay's "do not request reasoning" sentinel; the SDK
+ *  has no off level, so we omit the field entirely and let the
+ *  model's default kick in. */
+function toEffort(effort) {
+    return effort === 'low' || effort === 'medium' || effort === 'high' ? effort : undefined;
+}
+/**
+ * Build a Claude Code SDK `ModelClient`. `claudeCodeModelClient({ model })`
+ * with no other options uses the host's ambient subscription credentials:
+ *
+ * ```ts
+ * const relay = createRelay({
+ *   store,
+ *   providers: { 'claude-code': (c) => claudeCodeModelClient(c) },
+ * });
+ * // client request: { provider: 'claude-code', model: 'claude-opus-4-8',
+ * //                   messages, tools: [], apiKey: '' }
+ * ```
+ *
+ * Construction values (model, SDK options) come in the config; per-call
+ * values (messages, reasoning) come in the `ModelRequest`.
+ */
+export function claudeCodeModelClient(config) {
+    const loadSdk = config.loadSdk ??
+        (async () => {
+            // Non-literal specifier so the browser build (which reaches this module
+            // through the root barrel) doesn't resolve the Node-only SDK at build
+            // time; it loads at runtime only when this provider is actually used.
+            const sdkSpecifier = '@anthropic-ai/claude-agent-sdk';
+            const mod = (await import(sdkSpecifier));
+            return { query: mod.query };
+        });
+    return {
+        id: `claude-code:${config.model}`,
+        supportsTools: false,
+        async *chat(req, signal) {
+            if (signal?.aborted)
+                return;
+            if (req.tools.length > 0) {
+                yield {
+                    kind: 'error',
+                    message: 'claude-code provider does not support caller-defined tools — the bare-model SDK configuration has no tool-registration surface. Send `tools: []` (or use an API provider for tool calling).',
+                };
+                return;
+            }
+            const { system, prompt } = renderPrompt(req.messages);
+            if (!prompt) {
+                yield { kind: 'error', message: 'claude-code provider: no user message to send.' };
+                return;
+            }
+            let sdk;
+            try {
+                sdk = await loadSdk();
+            }
+            catch (e) {
+                yield {
+                    kind: 'error',
+                    message: `claude-code: failed to load @anthropic-ai/claude-agent-sdk (install it as a peer dep): ${e instanceof Error ? e.message : String(e)}`,
+                };
+                return;
+            }
+            // Compose the subprocess env. The SDK's auth precedence is
+            // ANTHROPIC_API_KEY → CLAUDE_CODE_OAUTH_TOKEN → ~/.claude/.credentials.json.
+            // We strip ANTHROPIC_API_KEY so subscription always wins; we
+            // optionally inject CLAUDE_CODE_OAUTH_TOKEN for explicit-token
+            // hosts.
+            const env = { ...process.env };
+            delete env.ANTHROPIC_API_KEY;
+            if (config.oauthToken)
+                env.CLAUDE_CODE_OAUTH_TOKEN = config.oauthToken;
+            if (config.env)
+                Object.assign(env, config.env);
+            // Belt-and-suspenders: if the caller's config.env tried to set
+            // ANTHROPIC_API_KEY back, strip it again.
+            delete env.ANTHROPIC_API_KEY;
+            const abortController = new AbortController();
+            const onAbort = () => abortController.abort();
+            signal?.addEventListener('abort', onAbort, { once: true });
+            const effort = toEffort(req.reasoningEffort);
+            const sdkOptions = {
+                ...(config.model ? { model: config.model } : {}),
+                systemPrompt: system,
+                tools: [],
+                settingSources: [],
+                mcpServers: {},
+                strictMcpConfig: true,
+                permissionMode: 'bypassPermissions',
+                includePartialMessages: true,
+                ...(effort ? { effort } : {}),
+                abortController,
+                env,
+            };
+            let promptTokens = 0;
+            let outputTokens = 0;
+            let cachedTokens;
+            let sawText = false;
+            let sawResult = false;
+            let fallbackText = '';
+            try {
+                for await (const msg of sdk.query({ prompt, options: sdkOptions })) {
+                    if (signal?.aborted)
+                        return;
+                    if (msg.type === 'stream_event' && msg.event?.type === 'content_block_delta') {
+                        const delta = msg.event.delta;
+                        if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+                            sawText = true;
+                            yield { kind: 'text', text: delta.text };
+                        }
+                        else if (delta?.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+                            yield { kind: 'thinking', text: delta.thinking };
+                        }
+                        continue;
+                    }
+                    // Buffer the assistant message's full text in case partial
+                    // streaming wasn't honored — we fall back to it on terminal
+                    // result if no text deltas streamed.
+                    if (msg.type === 'assistant' && msg.message?.content) {
+                        for (const block of msg.message.content) {
+                            if (block.type === 'text' && typeof block.text === 'string') {
+                                fallbackText += block.text;
+                            }
+                        }
+                        continue;
+                    }
+                    if (msg.type === 'result') {
+                        sawResult = true;
+                        if (msg.is_error || (msg.subtype && msg.subtype !== 'success')) {
+                            yield {
+                                kind: 'error',
+                                message: `claude-code SDK reported ${msg.subtype ?? 'error'}: ${typeof msg.result === 'string' && msg.result
+                                    ? msg.result.slice(0, 400)
+                                    : '(no detail)'}`,
+                            };
+                            return;
+                        }
+                        // Defensive fallback: terminal result text when no deltas
+                        // streamed (some SDK paths skip partial events).
+                        if (!sawText) {
+                            const text = typeof msg.result === 'string' && msg.result ? msg.result : fallbackText;
+                            if (text)
+                                yield { kind: 'text', text };
+                        }
+                        promptTokens = msg.usage?.input_tokens ?? promptTokens;
+                        outputTokens = msg.usage?.output_tokens ?? outputTokens;
+                        if (typeof msg.usage?.cache_read_input_tokens === 'number') {
+                            cachedTokens = msg.usage.cache_read_input_tokens;
+                        }
+                        yield {
+                            kind: 'usage',
+                            usage: {
+                                promptTokens,
+                                outputTokens,
+                                ...(typeof cachedTokens === 'number' ? { cachedTokens } : {}),
+                                // costUsd intentionally omitted — subscription is N/A.
+                            },
+                        };
+                        return;
+                    }
+                    // system / compact_boundary / rate_limit_event / unknown — skip.
+                }
+            }
+            catch (e) {
+                if (signal?.aborted)
+                    return;
+                yield { kind: 'error', message: e instanceof Error ? e.message : String(e) };
+                return;
+            }
+            finally {
+                signal?.removeEventListener('abort', onAbort);
+            }
+            if (!sawResult) {
+                yield {
+                    kind: 'error',
+                    message: 'claude-code SDK stream ended without a result message.',
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=claude-code.js.map

package/dist/providers/claude-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.js","sourceRoot":"","sources":["../../src/providers/claude-code.ts"],"names":[],"mappings":"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"}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,32 @@
+import type { ModelClient, ModelEvent, ModelRequest } from '../contract.js';
+import type { CloudProviderConfig } from './types.js';
+/** Per-request settings the provider reads off the `ModelRequest`. */
+export interface GeminiConfig extends CloudProviderConfig {
+}
+/**
+ * Build the upstream Gemini Request — URL + headers + body — without
+ * executing it. The returned Request carries no AbortSignal; the
+ * caller adds one at fetch time. Construction values (apiKey, model)
+ * come from the provider config; per-call values (messages, tools,
+ * sampling) from the `ModelRequest`.
+ */
+export declare function buildGeminiRequest(config: CloudProviderConfig, req: ModelRequest): Request;
+/**
+ * Parse an already-fetched Gemini SSE response into `ModelEvent`s.
+ * `signal` is optional — the relay passes the consumer's signal in,
+ * the page-direct caller passes its own.
+ *
+ * Function calls are accumulated across chunks (Gemini re-sends the
+ * growing parts list) and flushed as one `tool_call` per logical call
+ * at stream end, so a turn with N calls yields exactly N events with
+ * complete args and signatures.
+ */
+export declare function geminiEventsFromResponse(response: Response, signal?: AbortSignal): AsyncGenerator<ModelEvent>;
+/**
+ * Build a Gemini `ModelClient`. Construction values (apiKey, model)
+ * come in the config; per-call values (messages, tools, sampling) come
+ * in the `ModelRequest`.
+ */
+export declare function geminiModelClient(config: GeminiConfig): ModelClient;
+export declare function sanitizeGeminiSchema(node: unknown): unknown;
+//# sourceMappingURL=gemini.d.ts.map

package/dist/providers/gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../src/providers/gemini.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAY,MAAM,gBAAgB,CAAC;AAEtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAoBtD,sEAAsE;AACtE,MAAM,WAAW,YAAa,SAAQ,mBAAmB;CAAG;AA4I5D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAY1F;AA0BD;;;;;;;;;GASG;AACH,wBAAuB,wBAAwB,CAC7C,QAAQ,EAAE,QAAQ,EAClB,MAAM,CAAC,EAAE,WAAW,GACnB,cAAc,CAAC,UAAU,CAAC,CAwJ5B;AAsCD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW,CA8CnE;AAuBD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAa3D"}

package/dist/providers/gemini.js

@@ -0,0 +1,441 @@
+import { readSseDataLines } from '../sse.js';
+/**
+ * Gemini provider — raw fetch against the Generative Language REST
+ * API, parsing SSE directly. The `@google/genai` SDK is intentionally
+ * NOT used here: dropping it lets the same code run unchanged
+ * page-side and inside the relay (no SDK transport quirks), and lets
+ * both built-in providers (Gemini + OpenRouter) be treated
+ * symmetrically — both speak fetch + SSE.
+ *
+ * Endpoint: POST .../models/{model}:streamGenerateContent?alt=sse
+ *
+ * The chunk shape and thoughtSignature placement match what the SDK
+ * produced. Streamed function calls are accumulated across chunks and
+ * emitted exactly once (see `geminiEventsFromResponse`): Gemini
+ * re-sends the growing `content.parts[]` list every chunk, so emitting
+ * a `tool_call` per chunk would duplicate every call.
+ */
+const ENDPOINT_BASE = 'https://generativelanguage.googleapis.com/v1beta/models';
+function toGeminiBody(config, req) {
+    const contents = [];
+    let systemText = '';
+    for (const m of req.messages) {
+        if (m.role === 'system') {
+            systemText += (systemText ? '\n\n' : '') + (m.text ?? '');
+            continue;
+        }
+        if (m.role === 'user') {
+            contents.push({ role: 'user', parts: [{ text: m.text ?? '' }] });
+            continue;
+        }
+        if (m.role === 'assistant') {
+            const parts = [];
+            if (m.text)
+                parts.push({ text: m.text });
+            for (const c of m.toolCalls ?? []) {
+                // Gemini 3: `thoughtSignature` is a sibling of `functionCall`
+                // on the part, NOT a child. Echoing it on a different field
+                // returns INVALID_ARGUMENT.
+                const part = {
+                    functionCall: {
+                        name: c.name,
+                        args: c.args ?? {},
+                    },
+                };
+                if (c.signature)
+                    part.thoughtSignature = c.signature;
+                parts.push(part);
+            }
+            if (parts.length > 0)
+                contents.push({ role: 'model', parts });
+            continue;
+        }
+        if (m.role === 'tool') {
+            let parsed = null;
+            try {
+                if (m.resultJson)
+                    parsed = JSON.parse(m.resultJson);
+            }
+            catch {
+                parsed = m.resultJson;
+            }
+            contents.push({
+                role: 'user',
+                parts: [
+                    {
+                        functionResponse: {
+                            name: m.name ?? 'tool',
+                            response: { result: parsed },
+                        },
+                    },
+                ],
+            });
+        }
+    }
+    const body = { contents };
+    if (systemText)
+        body.systemInstruction = { parts: [{ text: systemText }] };
+    if (req.tools.length > 0) {
+        const functionDeclarations = req.tools.map((t) => ({
+            name: t.function.name,
+            description: t.function.description,
+            parameters: sanitizeGeminiSchema(t.function.parameters),
+        }));
+        body.tools = [{ functionDeclarations }];
+    }
+    const gen = {
+        thinkingConfig: { includeThoughts: true },
+        // Generous output budget. Left unset, the model can truncate a
+        // large tool-call argument — writeApp/writeCode emit whole source
+        // files as a string arg — and a truncated call is exactly what
+        // Gemini then rejects as MALFORMED_FUNCTION_CALL. 65536 is the
+        // Gemini 3 family max, so this never *reduces* a model's default;
+        // a model that somehow doesn't support it fails loudly with a
+        // 400, not silently.
+        maxOutputTokens: 65536,
+    };
+    // Per-request temperature wins; otherwise fall back to the
+    // construction-time default (the docs agent pins 0.2; the relay sets
+    // neither, preserving "send only what the client did").
+    const temperature = req.temperature ?? config.temperature;
+    if (typeof temperature === 'number')
+        gen.temperature = temperature;
+    if (typeof req.topP === 'number')
+        gen.topP = req.topP;
+    if (typeof req.topK === 'number')
+        gen.topK = req.topK;
+    body.generationConfig = gen;
+    return body;
+}
+/**
+ * Build the upstream Gemini Request — URL + headers + body — without
+ * executing it. The returned Request carries no AbortSignal; the
+ * caller adds one at fetch time. Construction values (apiKey, model)
+ * come from the provider config; per-call values (messages, tools,
+ * sampling) from the `ModelRequest`.
+ */
+export function buildGeminiRequest(config, req) {
+    const url = `${ENDPOINT_BASE}/${encodeURIComponent(config.model)}:streamGenerateContent?alt=sse`;
+    return new Request(url, {
+        method: 'POST',
+        headers: {
+            // Relay guarantees a resolved key before the provider runs
+            // (BYOK 400s if missing; server-managed injects).
+            'x-goog-api-key': config.apiKey ?? '',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(toGeminiBody(config, req)),
+    });
+}
+/**
+ * Format an error for a `{kind:'error'}` event — critically,
+ * including `error.cause` when present. Node's `fetch` (undici)
+ * reports network failures as a bare `TypeError: fetch failed` and
+ * stows the real reason — `UND_ERR_HEADERS_TIMEOUT`,
+ * `UND_ERR_BODY_TIMEOUT`, `ECONNRESET`, … — on `.cause`. Without
+ * this, every server-side failure surfaces as an identical "fetch
+ * failed" that tells us nothing.
+ */
+function describeError(e) {
+    if (!(e instanceof Error))
+        return String(e);
+    const cause = e.cause;
+    if (cause == null)
+        return e.message;
+    let causeStr;
+    if (cause instanceof Error) {
+        causeStr = cause.message ? `${cause.name}: ${cause.message}` : cause.name;
+    }
+    else if (typeof cause === 'object' && cause !== null && 'code' in cause) {
+        causeStr = String(cause.code);
+    }
+    else {
+        causeStr = String(cause);
+    }
+    return `${e.message} (${causeStr})`;
+}
+/**
+ * Parse an already-fetched Gemini SSE response into `ModelEvent`s.
+ * `signal` is optional — the relay passes the consumer's signal in,
+ * the page-direct caller passes its own.
+ *
+ * Function calls are accumulated across chunks (Gemini re-sends the
+ * growing parts list) and flushed as one `tool_call` per logical call
+ * at stream end, so a turn with N calls yields exactly N events with
+ * complete args and signatures.
+ */
+export async function* geminiEventsFromResponse(response, signal) {
+    if (!response.ok) {
+        const text = await response.text().catch(() => response.statusText);
+        yield { kind: 'error', message: `Gemini ${response.status}: ${text.slice(0, 240)}` };
+        return;
+    }
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let cachedTokens = 0;
+    // Diagnostics for the "thinking-only, no output" case: Gemini can
+    // end a response after the thinking phase having produced nothing
+    // visible. `finishReason` on the last chunk names why (MAX_TOKENS /
+    // SAFETY / RECITATION); a missing one means the stream was simply
+    // truncated. `sawOutput` tracks whether any *visible* output (text
+    // or a tool call — not thinking) actually came through.
+    let sawOutput = false;
+    let lastFinishReason;
+    // Function calls accumulate here and are flushed once, after the
+    // stream closes (see the per-part merge below and the flush loop).
+    // Keyed by the call's ordinal position among the turn's function
+    // calls — the one correlation key Gemini's stream offers (parts carry
+    // no id or index).
+    const pending = new Map();
+    try {
+        for await (const payload of readSseDataLines(response.body)) {
+            if (signal?.aborted)
+                return;
+            let chunk;
+            try {
+                chunk = JSON.parse(payload);
+            }
+            catch {
+                continue;
+            }
+            const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+            // Position of a functionCall part *among the functionCall parts in
+            // this chunk* — NOT its raw index in `parts[]`. Gemini re-sends the
+            // whole accumulating parts list each chunk, but the leading text
+            // deltas drop out of later chunks, so a call's raw array index
+            // shifts between chunks while its ordinal among function calls
+            // stays put. That ordinal is the stable correlation key.
+            //
+            // Invariant this relies on: across re-sends Gemini only ever
+            // appends function-call parts, never dropping or reordering an
+            // earlier one, so the k-th call keeps ordinal k. That holds for the
+            // relay's custom-function tools — it advertises no built-in Google
+            // tools whose parts could interleave and shift the ordinals.
+            let fnOrdinal = 0;
+            for (const p of parts) {
+                if (typeof p.text === 'string' && p.text.length > 0) {
+                    if (p.thought === true) {
+                        yield { kind: 'thinking', text: p.text };
+                    }
+                    else {
+                        sawOutput = true;
+                        yield { kind: 'text', text: p.text };
+                    }
+                }
+                if (p.functionCall) {
+                    sawOutput = true;
+                    const slot = fnOrdinal++;
+                    let call = pending.get(slot);
+                    if (!call) {
+                        call = { name: '', args: {} };
+                        pending.set(slot, call);
+                    }
+                    // Merge re-sends into the slot. Name and args fill in over
+                    // successive chunks; Gemini sends the complete args object each
+                    // time, so the latest non-empty snapshot is the full one
+                    // (replace, don't concatenate). An all-empty re-send never
+                    // clobbers args already captured.
+                    //
+                    // This reads the default `functionCall.args` shape. Gemini 3's
+                    // opt-in argument-streaming mode instead emits `partialArgs`
+                    // fragments with `willContinue` — the relay never requests that
+                    // mode (`toGeminiBody` sends no `functionCallingConfig`), so
+                    // args always arrive whole. If that ever changes, reconstruct
+                    // from `partialArgs` here; until then such args would stay `{}`.
+                    if (p.functionCall.name)
+                        call.name = p.functionCall.name;
+                    const incomingArgs = p.functionCall.args;
+                    if (incomingArgs &&
+                        typeof incomingArgs === 'object' &&
+                        !Array.isArray(incomingArgs) &&
+                        Object.keys(incomingArgs).length > 0) {
+                        call.args = incomingArgs;
+                    }
+                    // thoughtSignature is a sibling of functionCall on the part and
+                    // frequently arrives on a later chunk than the args. Capturing
+                    // it per-slot is what keeps the signature attached to its call
+                    // for Gemini-3 replay.
+                    if (p.thoughtSignature)
+                        call.signature = p.thoughtSignature;
+                }
+            }
+            const finishReason = chunk.candidates?.[0]?.finishReason;
+            if (finishReason)
+                lastFinishReason = finishReason;
+            const usage = chunk.usageMetadata;
+            if (usage) {
+                promptTokens = usage.promptTokenCount ?? promptTokens;
+                completionTokens = usage.candidatesTokenCount ?? completionTokens;
+                if (typeof usage.cachedContentTokenCount === 'number') {
+                    cachedTokens = usage.cachedContentTokenCount;
+                }
+            }
+        }
+    }
+    catch (e) {
+        if (signal?.aborted)
+            return;
+        yield { kind: 'error', message: describeError(e) };
+        return;
+    }
+    // Stream ended cleanly but the model never produced visible output —
+    // only thinking. Surface why: a non-STOP `finishReason` names it,
+    // `none` means the stream was truncated before one arrived.
+    if (!sawOutput) {
+        yield {
+            kind: 'error',
+            message: `Gemini produced no output — finishReason=${lastFinishReason ?? 'none'} (response ended after thinking only)`,
+        };
+        return;
+    }
+    // Flush the accumulated function calls — exactly one `tool_call` per
+    // logical call, carrying its complete args and thoughtSignature. The
+    // `id` is the call's stable ordinal (not a per-chunk random value), so
+    // re-parsing the same stream is deterministic and the id is identical
+    // across the args/signature that arrived on different chunks.
+    for (const [slot, call] of pending) {
+        // Skip a slot that never got a name — a stray empty partial, never
+        // dispatchable — so a turn with N real calls still yields exactly N
+        // events. A named call with empty args is legitimate (a no-arg tool)
+        // and is kept.
+        if (!call.name)
+            continue;
+        yield {
+            kind: 'tool_call',
+            id: `gem_${slot}`,
+            name: call.name,
+            args: call.args,
+            ...(call.signature ? { signature: call.signature } : {}),
+        };
+    }
+    yield {
+        kind: 'usage',
+        usage: {
+            promptTokens,
+            outputTokens: completionTokens,
+            ...(cachedTokens > 0 ? { cachedTokens } : {}),
+        },
+    };
+}
+/**
+ * Total Gemini attempts per call. Three classes of failure benefit
+ * from retry — all transient, all leave the turn with no usable
+ * output, and the same prompt frequently succeeds on the next attempt:
+ *
+ *   - `MALFORMED_FUNCTION_CALL` — Gemini 3 intermittently emits a
+ *     function call its own API then rejects.
+ *   - `finishReason=STOP` with no visible output — the model decided
+ *     to think and then said nothing. Common in long-context turns.
+ *   - `finishReason=none` — the stream was truncated before a
+ *     finishReason arrived; usually a transient transport blip.
+ *
+ * Deterministic failures (`finishReason=SAFETY` / `RECITATION` /
+ * `MAX_TOKENS`) are NOT retried — those are determined by the input
+ * and a retry only burns API calls.
+ *
+ * The retried attempt is a *fresh* generation — its thinking is
+ * streamed too, so a recovered turn shows the prior (discarded)
+ * thinking ahead of the real answer. A cosmetic cost on what was
+ * otherwise a hard failure.
+ */
+const MAX_GEMINI_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 500;
+/** Substrings that identify a retryable provider error. Matched
+ *  against `ModelEvent.message` from `geminiEventsFromResponse`. */
+const RETRYABLE_ERROR_MARKERS = [
+    'MALFORMED_FUNCTION_CALL',
+    'finishReason=STOP',
+    'finishReason=none',
+];
+function isRetryableError(message) {
+    return RETRYABLE_ERROR_MARKERS.some((m) => message.includes(m));
+}
+/**
+ * Build a Gemini `ModelClient`. Construction values (apiKey, model)
+ * come in the config; per-call values (messages, tools, sampling) come
+ * in the `ModelRequest`.
+ */
+export function geminiModelClient(config) {
+    return {
+        id: `gemini:${config.model}`,
+        supportsTools: true,
+        async *chat(req, signal) {
+            for (let attempt = 1; attempt <= MAX_GEMINI_ATTEMPTS; attempt++) {
+                if (signal?.aborted)
+                    return;
+                const request = buildGeminiRequest(config, req);
+                let response;
+                try {
+                    response = await fetch(request, signal ? { signal } : {});
+                }
+                catch (e) {
+                    if (signal?.aborted)
+                        return;
+                    yield { kind: 'error', message: describeError(e) };
+                    return;
+                }
+                let retry = false;
+                for await (const evt of geminiEventsFromResponse(response, signal)) {
+                    // Swallow retryable errors so the next attempt can recover.
+                    // The non-retryable kinds (SAFETY, RECITATION, MAX_TOKENS,
+                    // network/parse failures) fall straight through and surface.
+                    // Final attempt always yields whatever it produces.
+                    if (evt.kind === 'error' &&
+                        isRetryableError(evt.message) &&
+                        attempt < MAX_GEMINI_ATTEMPTS) {
+                        retry = true;
+                        break;
+                    }
+                    yield evt;
+                }
+                if (!retry)
+                    return;
+                try {
+                    await response.body?.cancel();
+                }
+                catch {
+                    /* already released — fine */
+                }
+                if (signal?.aborted)
+                    return;
+                await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+            }
+        },
+    };
+}
+/**
+ * Strip JSON-Schema keywords Gemini's `function_declarations[].parameters`
+ * validator rejects. The validator is a narrow subset of OpenAPI 3.0
+ * Schema — anything `zodToJsonSchema` (or hand-written JSON Schema)
+ * emits beyond that subset 400s with `Unknown name "<key>"`.
+ *
+ * Keys stripped:
+ *   - `additionalProperties` — emitted by `zodToJsonSchema` on every
+ *     object; Gemini rejects it outright.
+ *   - `$schema`, `$ref`, `$defs`, `definitions` — JSON-Schema-isms not
+ *     supported in OpenAPI 3.0 Schema.
+ *
+ * OpenRouter's adapter accepts the standard JSON Schema unchanged —
+ * no equivalent sanitizer there.
+ *
+ * Implementation: deep-clone walk so we never mutate the caller's
+ * schema object (the same `parameters` reference is held by the
+ * ToolRegistry and shared across providers).
+ */
+const STRIP_KEYS = new Set(['additionalProperties', '$schema', '$ref', '$defs', 'definitions']);
+export function sanitizeGeminiSchema(node) {
+    if (Array.isArray(node)) {
+        return node.map(sanitizeGeminiSchema);
+    }
+    if (node && typeof node === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(node)) {
+            if (STRIP_KEYS.has(k))
+                continue;
+            out[k] = sanitizeGeminiSchema(v);
+        }
+        return out;
+    }
+    return node;
+}
+//# sourceMappingURL=gemini.js.map