modelrig 0.0.1 → 0.2.0

package/dist/adapters/openai.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * OpenAI ProviderAdapter — plan step 5.
+ * Transformation logic ported from apps/api/src/services/openai-provider.ts:
+ * response_format json_schema strict, service tiers (flex allowlist + served
+ * tier from the stream), prompt-cache key + retention passthrough, streaming
+ * with usage, structured-output refusal detection, suspicious-short guard.
+ * NOT ported: logging, pricing tables, env reads, the analyst-persona system
+ * prompt (route templates own prompt content).
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * openai transformation logic is consulted during the port.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModelFlexEligible = isModelFlexEligible;
+exports.openaiSupports = openaiSupports;
+exports.classifyOpenAIFailure = classifyOpenAIFailure;
+exports.buildOpenAIParams = buildOpenAIParams;
+exports.createOpenAIAdapter = createOpenAIAdapter;
+const openai_1 = __importDefault(require("openai"));
+const tool_mapping_1 = require("./tool-mapping");
+const openai_stream_1 = require("./openai-stream");
+const sampling_1 = require("./sampling");
+/** OpenAI's documented flex-eligible allowlist as of 2026-05 (ported).
+ * Mini and nano variants are silently downgraded to default tier. */
+const FLEX_ELIGIBLE_PREFIXES = ["gpt-5.4", "gpt-5.2", "gpt-5.1", "gpt-5", "gpt-4.1"];
+function isModelFlexEligible(modelName) {
+    if (!modelName)
+        return false;
+    if (modelName.includes("-mini") || modelName.includes("-nano"))
+        return false;
+    return FLEX_ELIGIBLE_PREFIXES.some((prefix) => modelName.startsWith(prefix));
+}
+function openaiSupports(feature, model) {
+    switch (feature) {
+        case "structured_native":
+        case "json_mode":
+        case "prompt_cache_key":
+        case "prefix_cache_implicit":
+            return true;
+        case "tier_flex":
+            return isModelFlexEligible(model);
+        case "grounded_native":
+        case "context_cache_explicit":
+        case "trace_visible": // reasoning tokens are billed but never exposed
+        case "zero_retention": // never a static adapter attestation — set only from the credential-scoped registry facts (claims.ts)
+            return false;
+    }
+}
+function classifyOpenAIFailure(message) {
+    const msg = message.toLowerCase();
+    if (/\b429\b|rate limit|\brate\b/.test(msg))
+        return { cls: "capacity_shed" };
+    if (/\b50[023]\b|service unavailable|overloaded/.test(msg))
+        return { cls: "capacity_shed" };
+    if (/timeout|etimedout|abort/.test(msg))
+        return { cls: "timeout" };
+    if (/econnreset|econnrefused|enotfound|fetch failed|network/.test(msg))
+        return { cls: "network" };
+    if (/\b401\b|api key/.test(msg)) {
+        // F2: non-retryable — a dead key never burns backoff retries.
+        return { cls: "config_auth", fixHint: "check the OpenAI API key configured for this rig" };
+    }
+    if (/does not exist|not found|\bmodel\b.*invalid/.test(msg)) {
+        return {
+            cls: "network",
+            fixHint: "the candidate model was not found — fix the model id in the route's candidate list",
+        };
+    }
+    return { cls: "network" };
+}
+const DEFAULT_MAX_COMPLETION_TOKENS = 32000;
+function buildOpenAIParams(model, req) {
+    const messages = [
+        ...(req.systemPrompt !== "" ? [{ role: "system", content: req.systemPrompt }] : []),
+        { role: "user", content: req.userPrompt },
+    ];
+    return {
+        model,
+        max_completion_tokens: (0, sampling_1.effectiveMaxOutputTokens)(req, DEFAULT_MAX_COMPLETION_TOKENS),
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...(0, sampling_1.openAISamplingFields)(req),
+        ...(req.requestedTier === "flex"
+            ? { service_tier: "flex" }
+            : req.requestedTier === "priority"
+                ? { service_tier: "priority" }
+                : {}),
+        ...(req.cache?.key !== undefined && req.cache.key !== ""
+            ? {
+                prompt_cache_key: req.cache.key,
+                // Extended retention only when the directive asks for a day or more.
+                ...((req.cache.ttlSeconds ?? 0) >= 86400 ? { prompt_cache_retention: "24h" } : {}),
+            }
+            : {}),
+        ...(req.outputSchema !== null
+            ? {
+                response_format: {
+                    type: "json_schema",
+                    json_schema: {
+                        name: "modelrig_route_output",
+                        schema: req.outputSchema,
+                        strict: true,
+                    },
+                },
+            }
+            : {}),
+        ...(req.tools !== undefined && req.tools.length > 0
+            ? {
+                tools: (0, tool_mapping_1.toOpenAITools)(req.tools),
+                ...((0, tool_mapping_1.toOpenAIToolChoice)(req.toolChoice) !== undefined
+                    ? { tool_choice: (0, tool_mapping_1.toOpenAIToolChoice)(req.toolChoice) }
+                    : {}),
+            }
+            : {}),
+    };
+}
+/** Ported suspicious-short heuristic: finish_reason 'stop' + <200 visible
+ * completion tokens on a 50K+ token prompt = flex degradation / stream drop. */
+const SUSPICIOUSLY_SHORT_VISIBLE = 200;
+const LONG_FORM_PROMPT_THRESHOLD = 50000;
+function mapServedTier(raw, requested) {
+    if (raw === "flex")
+        return "flex";
+    if (raw === "priority")
+        return "priority";
+    if (raw === "default" || raw === "auto")
+        return "standard";
+    return requested === "flex" || requested === "priority" ? requested : "standard";
+}
+function createOpenAIAdapter(config) {
+    return {
+        id: "openai",
+        supports: openaiSupports,
+        supportsTools: () => true,
+        async call(req) {
+            const model = req.candidate.model;
+            // F1: post-stream failures still billed tokens — attach usage.
+            const fail = (cls, message, fixHint, usage) => ({
+                ok: false,
+                failure: {
+                    class: cls,
+                    message,
+                    provider: "openai",
+                    model,
+                    ...(fixHint !== undefined ? { fixHint } : {}),
+                },
+                ...(usage !== undefined ? { usage } : {}),
+            });
+            try {
+                const client = new openai_1.default({ apiKey: config.apiKey, timeout: req.timeoutMs });
+                const params = buildOpenAIParams(model, req);
+                const dispatchedAt = Date.now();
+                const stream = await client.chat.completions.create(params);
+                // TTFB (Phase 4 WS3): first streamed chunk = first body byte.
+                let ttfbMs;
+                let text = "";
+                let refusalText = "";
+                const toolCallAcc = (0, tool_mapping_1.createOpenAIToolCallAccumulator)();
+                let promptTokens = 0;
+                let completionTokens = 0;
+                let cachedTokens = 0;
+                let cacheWriteTokens = 0;
+                let reasoningTokens = 0;
+                let responseTier = null;
+                let finishReason = null;
+                for await (const chunk of stream) {
+                    if (ttfbMs === undefined)
+                        ttfbMs = Date.now() - dispatchedAt;
+                    if (responseTier === null && chunk.service_tier !== undefined) {
+                        responseTier = chunk.service_tier;
+                    }
+                    const choice = chunk.choices[0];
+                    if (choice?.delta?.content)
+                        text += choice.delta.content;
+                    if (typeof choice?.delta?.refusal === "string" && choice.delta.refusal.length > 0) {
+                        refusalText += choice.delta.refusal;
+                    }
+                    toolCallAcc.push(choice?.delta?.tool_calls);
+                    if (choice?.finish_reason)
+                        finishReason = choice.finish_reason;
+                    if (chunk.usage) {
+                        promptTokens = chunk.usage.prompt_tokens ?? 0;
+                        completionTokens = chunk.usage.completion_tokens ?? 0;
+                        cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+                        cacheWriteTokens = chunk.usage.input_tokens_details?.cache_write_tokens ?? 0;
+                        reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0;
+                    }
+                }
+                // prompt_tokens already INCLUDES cached+write → tokensIn is subset-correct.
+                const usage = {
+                    tokensIn: promptTokens,
+                    tokensOut: completionTokens,
+                    tokensCached: cachedTokens,
+                    tokensCacheWrite: cacheWriteTokens,
+                    servedTier: mapServedTier(responseTier, req.requestedTier),
+                    ...(ttfbMs !== undefined ? { ttfbMs } : {}),
+                };
+                // Any streamed refusal is terminal for this call, even alongside
+                // partial content — OpenAI's structured-output semantics (ported).
+                if (refusalText.length > 0) {
+                    return fail("refusal", `OpenAI refused structured output: ${refusalText.slice(0, 200)}`, undefined, usage);
+                }
+                // Tool-call turn (spec §4.4): the model chose to call a tool. Surface
+                // the normalized calls; text may legitimately be empty — do NOT run the
+                // empty/suspicious-short/validation guards below.
+                const toolCalls = toolCallAcc.finalize();
+                if (toolCalls !== undefined) {
+                    return { ok: true, text, usage, toolCalls };
+                }
+                const visibleCompletionTokens = Math.max(0, completionTokens - reasoningTokens);
+                if (finishReason === "stop" &&
+                    completionTokens > 0 &&
+                    visibleCompletionTokens < SUSPICIOUSLY_SHORT_VISIBLE &&
+                    promptTokens >= LONG_FORM_PROMPT_THRESHOLD) {
+                    return fail("content_invalid", `suspiciously short OpenAI response: ${visibleCompletionTokens} visible completion tokens ` +
+                        `for ${promptTokens} prompt tokens (likely flex-tier degradation or stream drop)`, undefined, usage);
+                }
+                if (text.trim().length === 0) {
+                    return fail("content_invalid", `empty response from OpenAI (finish_reason=${finishReason ?? "none"})`, undefined, usage);
+                }
+                if (finishReason === "length" && req.outputSchema !== null) {
+                    return fail("content_invalid", "OpenAI structured output truncated (finish_reason=length)", "raise maxOutputTokens for this route", usage);
+                }
+                return { ok: true, text, usage };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const { cls, fixHint } = classifyOpenAIFailure(message);
+                return {
+                    ok: false,
+                    failure: {
+                        class: cls,
+                        message,
+                        provider: "openai",
+                        model,
+                        cause: error,
+                        ...(fixHint !== undefined ? { fixHint } : {}),
+                    },
+                };
+            }
+        },
+        async *stream(req) {
+            const model = req.candidate.model;
+            try {
+                const client = new openai_1.default({ apiKey: config.apiKey, timeout: req.timeoutMs });
+                const params = buildOpenAIParams(model, req);
+                const dispatchedAt = Date.now();
+                const stream = await client.chat.completions.create(params);
+                yield* (0, openai_stream_1.streamOpenAIDialect)(stream, req, dispatchedAt, {
+                    provider: "openai",
+                    cachedTokenSource: "details",
+                    mapServedTier,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const { cls, fixHint } = classifyOpenAIFailure(message);
+                yield {
+                    kind: "final",
+                    result: {
+                        ok: false,
+                        failure: {
+                            class: cls,
+                            message,
+                            provider: "openai",
+                            model,
+                            cause: error,
+                            ...(fixHint !== undefined ? { fixHint } : {}),
+                        },
+                    },
+                };
+            }
+        },
+    };
+}

package/dist/adapters/sampling.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared sampling-param mapping for the adapters (CE-6, spec §2/§3). One place
+ * resolves `AdapterRequest.sampling` into wire fields so every adapter honours
+ * the same precedence and the same absent⇒byte-identical pin.
+ *
+ * Two rules, everywhere:
+ *  - max-output-tokens: `sampling.maxOutputTokens` wins, then the existing
+ *    top-level `maxOutputTokens` (the raw lane's channel), then the adapter's
+ *    own default. Absent both ⇒ the default ⇒ identical to pre-CE-6.
+ *  - temperature/top_p: emitted ONLY when the request declares them, so an
+ *    absent block adds NO keys — the OpenAI-dialect and Anthropic adapters keep
+ *    sending nothing (provider defaults win), exactly as before CE-6.
+ */
+import type { AdapterRequest } from "../types/provider";
+/** The sampling-relevant slice of a request (also what the pure `build*Params`
+ * shaping helpers take, so unit tests never need a branded CandidateRef). */
+export type SamplingShapingInput = Pick<AdapterRequest, "sampling" | "maxOutputTokens">;
+/** Effective max-output-tokens: declared sampling wins, then the top-level
+ * (raw-lane) field, then the adapter default. */
+export declare function effectiveMaxOutputTokens(req: SamplingShapingInput, fallback: number): number;
+/** OpenAI-dialect + Anthropic sampling fields — both speak `temperature` and
+ * `top_p`. Returns keys ONLY for declared fields, so spreading it onto the
+ * params object is a no-op when sampling is absent. */
+export declare function openAISamplingFields(req: SamplingShapingInput): {
+    temperature?: number;
+    top_p?: number;
+};
+//# sourceMappingURL=sampling.d.ts.map

package/dist/adapters/sampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.d.ts","sourceRoot":"","sources":["../../src/adapters/sampling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;6EAC6E;AAC7E,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,iBAAiB,CAAC,CAAC;AAExF;iDACiD;AACjD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5F;AAED;;uDAEuD;AACvD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,oBAAoB,GACxB;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAO1C"}

package/dist/adapters/sampling.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Shared sampling-param mapping for the adapters (CE-6, spec §2/§3). One place
+ * resolves `AdapterRequest.sampling` into wire fields so every adapter honours
+ * the same precedence and the same absent⇒byte-identical pin.
+ *
+ * Two rules, everywhere:
+ *  - max-output-tokens: `sampling.maxOutputTokens` wins, then the existing
+ *    top-level `maxOutputTokens` (the raw lane's channel), then the adapter's
+ *    own default. Absent both ⇒ the default ⇒ identical to pre-CE-6.
+ *  - temperature/top_p: emitted ONLY when the request declares them, so an
+ *    absent block adds NO keys — the OpenAI-dialect and Anthropic adapters keep
+ *    sending nothing (provider defaults win), exactly as before CE-6.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectiveMaxOutputTokens = effectiveMaxOutputTokens;
+exports.openAISamplingFields = openAISamplingFields;
+/** Effective max-output-tokens: declared sampling wins, then the top-level
+ * (raw-lane) field, then the adapter default. */
+function effectiveMaxOutputTokens(req, fallback) {
+    return req.sampling?.maxOutputTokens ?? req.maxOutputTokens ?? fallback;
+}
+/** OpenAI-dialect + Anthropic sampling fields — both speak `temperature` and
+ * `top_p`. Returns keys ONLY for declared fields, so spreading it onto the
+ * params object is a no-op when sampling is absent. */
+function openAISamplingFields(req) {
+    const s = req.sampling;
+    if (s === undefined)
+        return {};
+    return {
+        ...(s.temperature !== undefined ? { temperature: s.temperature } : {}),
+        ...(s.topP !== undefined ? { top_p: s.topP } : {}),
+    };
+}

package/dist/adapters/tool-mapping.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Unified tool-calling — native ↔ normalized mapping (G-1/G-5 Phase A,
+ * http-gateway spec §4.4).
+ *
+ * ModelRig speaks ONE tool vocabulary to callers: the OpenAI `tools` /
+ * `tool_calls` shape (`types/provider.ts`). This module is the single place
+ * each provider dialect is translated to and from it. Adapters stay thin: they
+ * call a `to<Provider>Tools` on the way out and a `<provider>…ToToolCalls` on
+ * the way back. Pure functions, no I/O — every branch is unit-tested here so an
+ * adapter integration test never has to reconstruct a provider's tool wire.
+ *
+ * We normalize the PROTOCOL only. Executing a tool and feeding the result back
+ * is the caller's job (spec §4.4).
+ */
+import type { ToolCall, ToolChoice, ToolDefinition } from "../types/provider";
+export interface OpenAIWireTool {
+    readonly type: "function";
+    readonly function: {
+        readonly name: string;
+        readonly description?: string;
+        readonly parameters?: object;
+    };
+}
+export type OpenAIWireToolChoice = "auto" | "none" | "required" | {
+    readonly type: "function";
+    readonly function: {
+        readonly name: string;
+    };
+};
+export declare function toOpenAITools(tools: readonly ToolDefinition[]): OpenAIWireTool[];
+export declare function toOpenAIToolChoice(choice: ToolChoice | undefined): OpenAIWireToolChoice | undefined;
+/** One streamed `tool_calls` delta fragment (OpenAI). `arguments` arrives in
+ * pieces keyed by `index`; `id`/`name` land on the first fragment. */
+export interface OpenAIToolCallDelta {
+    readonly index: number;
+    readonly id?: string;
+    readonly type?: "function";
+    readonly function?: {
+        readonly name?: string;
+        readonly arguments?: string;
+    };
+}
+/** Accumulates streamed OpenAI tool-call deltas (and absorbs a non-streamed
+ * `tool_calls` array — a single fragment each) into normalized `ToolCall`s. */
+export declare function createOpenAIToolCallAccumulator(): {
+    push(deltas: readonly OpenAIToolCallDelta[] | undefined): void;
+    finalize(): ToolCall[] | undefined;
+};
+export interface AnthropicWireTool {
+    readonly name: string;
+    readonly description?: string;
+    readonly input_schema: object;
+}
+export type AnthropicWireToolChoice = {
+    readonly type: "auto";
+} | {
+    readonly type: "any";
+} | {
+    readonly type: "tool";
+    readonly name: string;
+};
+export declare function toAnthropicTools(tools: readonly ToolDefinition[]): AnthropicWireTool[];
+export declare function toAnthropicToolChoice(choice: ToolChoice | undefined): AnthropicWireToolChoice | undefined;
+/** A completed Anthropic `tool_use` content block. */
+export interface AnthropicToolUseBlock {
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+}
+export declare function anthropicToolUseToToolCalls(blocks: readonly AnthropicToolUseBlock[]): ToolCall[] | undefined;
+export interface GeminiWireTool {
+    readonly functionDeclarations: ReadonlyArray<{
+        readonly name: string;
+        readonly description?: string;
+        readonly parameters?: object;
+    }>;
+}
+export type GeminiWireToolConfig = {
+    readonly functionCallingConfig: {
+        readonly mode: "AUTO" | "ANY" | "NONE";
+        readonly allowedFunctionNames?: readonly string[];
+    };
+};
+export declare function toGeminiTools(tools: readonly ToolDefinition[]): GeminiWireTool[];
+export declare function toGeminiToolConfig(choice: ToolChoice | undefined): GeminiWireToolConfig | undefined;
+/** A Gemini response `functionCall` part. */
+export interface GeminiFunctionCall {
+    readonly name: string;
+    readonly args?: unknown;
+}
+export declare function geminiFunctionCallsToToolCalls(calls: readonly GeminiFunctionCall[]): ToolCall[] | undefined;
+//# sourceMappingURL=tool-mapping.d.ts.map

package/dist/adapters/tool-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-mapping.d.ts","sourceRoot":"","sources":["../../src/adapters/tool-mapping.ts"],"names":[],"mappings":"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"}

package/dist/adapters/tool-mapping.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Unified tool-calling — native ↔ normalized mapping (G-1/G-5 Phase A,
+ * http-gateway spec §4.4).
+ *
+ * ModelRig speaks ONE tool vocabulary to callers: the OpenAI `tools` /
+ * `tool_calls` shape (`types/provider.ts`). This module is the single place
+ * each provider dialect is translated to and from it. Adapters stay thin: they
+ * call a `to<Provider>Tools` on the way out and a `<provider>…ToToolCalls` on
+ * the way back. Pure functions, no I/O — every branch is unit-tested here so an
+ * adapter integration test never has to reconstruct a provider's tool wire.
+ *
+ * We normalize the PROTOCOL only. Executing a tool and feeding the result back
+ * is the caller's job (spec §4.4).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOpenAITools = toOpenAITools;
+exports.toOpenAIToolChoice = toOpenAIToolChoice;
+exports.createOpenAIToolCallAccumulator = createOpenAIToolCallAccumulator;
+exports.toAnthropicTools = toAnthropicTools;
+exports.toAnthropicToolChoice = toAnthropicToolChoice;
+exports.anthropicToolUseToToolCalls = anthropicToolUseToToolCalls;
+exports.toGeminiTools = toGeminiTools;
+exports.toGeminiToolConfig = toGeminiToolConfig;
+exports.geminiFunctionCallsToToolCalls = geminiFunctionCallsToToolCalls;
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.function.name,
+            ...(t.function.description !== undefined ? { description: t.function.description } : {}),
+            ...(t.function.parameters !== undefined ? { parameters: t.function.parameters } : {}),
+        },
+    }));
+}
+function toOpenAIToolChoice(choice) {
+    if (choice === undefined)
+        return undefined;
+    return choice; // the normalized shape IS the OpenAI shape.
+}
+/** Accumulates streamed OpenAI tool-call deltas (and absorbs a non-streamed
+ * `tool_calls` array — a single fragment each) into normalized `ToolCall`s. */
+function createOpenAIToolCallAccumulator() {
+    const byIndex = new Map();
+    const order = [];
+    return {
+        push(deltas) {
+            if (deltas === undefined)
+                return;
+            for (const d of deltas) {
+                let entry = byIndex.get(d.index);
+                if (entry === undefined) {
+                    entry = { id: "", name: "", args: "" };
+                    byIndex.set(d.index, entry);
+                    order.push(d.index);
+                }
+                if (d.id !== undefined)
+                    entry.id = d.id;
+                if (d.function?.name !== undefined)
+                    entry.name = d.function.name;
+                if (d.function?.arguments !== undefined)
+                    entry.args += d.function.arguments;
+            }
+        },
+        finalize() {
+            if (order.length === 0)
+                return undefined;
+            return order.map((idx, i) => {
+                const e = byIndex.get(idx);
+                return {
+                    // Some hosts omit an id in the stream — synthesize a stable one.
+                    id: e.id !== "" ? e.id : `call_${i}`,
+                    type: "function",
+                    function: { name: e.name, arguments: e.args === "" ? "{}" : e.args },
+                };
+            });
+        },
+    };
+}
+const EMPTY_INPUT_SCHEMA = { type: "object", properties: {} };
+function toAnthropicTools(tools) {
+    return tools.map((t) => ({
+        name: t.function.name,
+        ...(t.function.description !== undefined ? { description: t.function.description } : {}),
+        // Anthropic requires an input_schema; default to an open object when the
+        // caller declared a parameterless tool.
+        input_schema: (t.function.parameters ?? EMPTY_INPUT_SCHEMA),
+    }));
+}
+function toAnthropicToolChoice(choice) {
+    if (choice === undefined || choice === "auto")
+        return undefined; // auto is Anthropic's default
+    if (choice === "none")
+        return undefined; // Anthropic omits tools to force no call; caller-handled
+    if (choice === "required")
+        return { type: "any" };
+    return { type: "tool", name: choice.function.name };
+}
+function anthropicToolUseToToolCalls(blocks) {
+    if (blocks.length === 0)
+        return undefined;
+    return blocks.map((b) => ({
+        id: b.id,
+        type: "function",
+        // Anthropic hands back a parsed object; the normalized shape is the raw
+        // JSON string (OpenAI parity), so re-stringify.
+        function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+    }));
+}
+function toGeminiTools(tools) {
+    return [
+        {
+            functionDeclarations: tools.map((t) => ({
+                name: t.function.name,
+                ...(t.function.description !== undefined ? { description: t.function.description } : {}),
+                ...(t.function.parameters !== undefined ? { parameters: t.function.parameters } : {}),
+            })),
+        },
+    ];
+}
+function toGeminiToolConfig(choice) {
+    if (choice === undefined)
+        return undefined;
+    if (choice === "auto")
+        return { functionCallingConfig: { mode: "AUTO" } };
+    if (choice === "none")
+        return { functionCallingConfig: { mode: "NONE" } };
+    if (choice === "required")
+        return { functionCallingConfig: { mode: "ANY" } };
+    return {
+        functionCallingConfig: { mode: "ANY", allowedFunctionNames: [choice.function.name] },
+    };
+}
+function geminiFunctionCallsToToolCalls(calls) {
+    if (calls.length === 0)
+        return undefined;
+    return calls.map((c, i) => ({
+        // Gemini function calls carry no id — synthesize a stable one.
+        id: `call_${i}`,
+        type: "function",
+        function: { name: c.name, arguments: JSON.stringify(c.args ?? {}) },
+    }));
+}