modelrig 0.0.1 → 0.2.0

package/dist/adapters/gemini.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Gemini ProviderAdapter — plan step 5 (the hardest port).
+ * Transformation logic ported from apps/api/src/services/gemini-provider.ts:
+ * grounding tool passthrough, explicit context-cache passthrough (cache name
+ * via AdapterRequest.cache.key), thinking level, flex tier + capacity-shed
+ * classification, responseJsonSchema, served-tier extraction.
+ * NOT ported (by design): logging, pricing tables (registry owns pricing),
+ * env reads, the analyst-persona system instruction (route templates own
+ * prompt content), and especially the model fallback chain — silent model
+ * substitution is an invariant violation here; a failed model fails typed.
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * gemini transformation logic is consulted during the port.
+ */
+import type { AdapterRequest, CapabilityFlag, ProviderAdapter } from "../types/provider";
+import type { FailureClass } from "../types/failures";
+export interface GeminiAdapterConfig {
+    readonly apiKey: string;
+}
+export declare function geminiSupports(feature: CapabilityFlag, model: string): boolean;
+export interface ClassifiedFailure {
+    readonly cls: FailureClass;
+    readonly fixHint?: string;
+}
+/**
+ * Map a Gemini SDK/API error message into the failure taxonomy. Ported from
+ * classifyGeminiError + classifyGeminiFallbackReason; branch ORDER is
+ * load-bearing — auth before INVALID_ARGUMENT (a bad key surfaces as 400
+ * INVALID_ARGUMENT "API key not valid"), quota before generic 429 capacity.
+ */
+export declare function classifyGeminiFailure(message: string): ClassifiedFailure;
+/** The candidate-independent part of an AdapterRequest (also what the pure
+ * shaping helpers take, so unit tests never need a branded CandidateRef). */
+export type ShapingInput = Omit<AdapterRequest, "candidate">;
+export interface GeminiShapedRequest {
+    readonly model: string;
+    readonly contents: string;
+    readonly config: Record<string, unknown>;
+}
+/** Pure request shaping — everything except the abort signal. */
+export declare function buildGeminiRequest(model: string, req: ShapingInput): GeminiShapedRequest;
+export declare function createGeminiAdapter(config: GeminiAdapterConfig): ProviderAdapter;
+//# sourceMappingURL=gemini.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../src/adapters/gemini.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EACV,cAAc,EAGd,cAAc,EACd,eAAe,EAEhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,mBAAmB,CAAC;AAKlE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAkCD,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG9E;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAyCxE;AAED;6EAC6E;AAC7E,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;AAE7D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,mBAAmB,CA2CxF;AA0BD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,eAAe,CAmJhF"}

package/dist/adapters/gemini.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * Gemini ProviderAdapter — plan step 5 (the hardest port).
+ * Transformation logic ported from apps/api/src/services/gemini-provider.ts:
+ * grounding tool passthrough, explicit context-cache passthrough (cache name
+ * via AdapterRequest.cache.key), thinking level, flex tier + capacity-shed
+ * classification, responseJsonSchema, served-tier extraction.
+ * NOT ported (by design): logging, pricing tables (registry owns pricing),
+ * env reads, the analyst-persona system instruction (route templates own
+ * prompt content), and especially the model fallback chain — silent model
+ * substitution is an invariant violation here; a failed model fails typed.
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * gemini transformation logic is consulted during the port.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiSupports = geminiSupports;
+exports.classifyGeminiFailure = classifyGeminiFailure;
+exports.buildGeminiRequest = buildGeminiRequest;
+exports.createGeminiAdapter = createGeminiAdapter;
+const genai_1 = require("@google/genai");
+const tool_mapping_1 = require("./tool-mapping");
+const sampling_1 = require("./sampling");
+/** Models that accept thinkingConfig — passing it to 2.x models 400s.
+ * Ported from the production THINKING_CAPABLE_MODELS set. */
+const THINKING_CAPABLE_MODELS = new Set([
+    "gemini-3.1-pro-preview",
+    "gemini-3.0-pro-preview",
+    "gemini-3.1-flash-preview",
+]);
+/** Gemini-3 default. Google STRONGLY recommends temperature=1.0 for all
+ * Gemini 3 models and warns that values below 1.0 can cause looping / degraded
+ * output — concentrated on complex reasoning/math tasks, not simple
+ * classification (verified 2026-08-20 against ai.google.dev/gemini-api/docs/gemini-3;
+ * the source pipeline ran gemini-3.1-pro at 0.1 for CLASSIFICATION without
+ * looping, which the reasoning-task carve-out explains). It is a recommendation,
+ * not a hard API cap: the accepted range stays 0–2. This is the DEFAULT the
+ * adapter sends when a route declares no `sampling.temperature`; a declared
+ * value overrides it and is sent as-is (CE-6), with a load-time warning emitted
+ * for a sub-1.0 value on a Gemini-3 candidate (routes/loader.ts). */
+const GEMINI_TEMPERATURE = 1.0;
+const DEFAULT_MAX_OUTPUT_TOKENS = 64000; // thinking tokens count against this
+const TOP_P = 0.95;
+const TOP_K = 40;
+const GEMINI_CAPABILITIES = new Set([
+    "structured_native",
+    "json_mode",
+    "grounded_native",
+    "context_cache_explicit",
+    "prefix_cache_implicit",
+    "tier_flex",
+]);
+function geminiSupports(feature, model) {
+    void model; // Phase 1 static stub: flags are family-wide for the 2.5/3.x models in use
+    return GEMINI_CAPABILITIES.has(feature);
+}
+/**
+ * Map a Gemini SDK/API error message into the failure taxonomy. Ported from
+ * classifyGeminiError + classifyGeminiFallbackReason; branch ORDER is
+ * load-bearing — auth before INVALID_ARGUMENT (a bad key surfaces as 400
+ * INVALID_ARGUMENT "API key not valid"), quota before generic 429 capacity.
+ */
+function classifyGeminiFailure(message) {
+    const msg = message.toLowerCase();
+    if (/cachedcontent|cached_content/.test(msg)) {
+        return { cls: "cache_invalid", fixHint: "recreate the context cache and retry without it if it keeps failing" };
+    }
+    if (/\b40[13]\b|api[_ ]key|permission_denied|unauthenticated/.test(msg)) {
+        // F2: a dead key must not burn backoff retries — config_auth is
+        // non-retryable and the run loop advances to the next candidate.
+        return { cls: "config_auth", fixHint: "check the Gemini API key/credentials configured for this rig" };
+    }
+    if (/quota|\brpm\b|\btpm\b|rate limit/.test(msg)) {
+        return { cls: "capacity_shed" };
+    }
+    if (/\b50[234]\b/.test(msg) ||
+        /service unavailable|preempted|sheddable|overloaded|bad gateway|gateway timeout/.test(msg) ||
+        /\b429\b|resource has been exhausted|serving capacity/.test(msg)) {
+        return { cls: "capacity_shed" };
+    }
+    if (/abort|cancel|timeout|etimedout/.test(msg)) {
+        return { cls: "timeout" };
+    }
+    if (/fetch failed|econnreset|econnrefused|enotfound|eai_again|epipe|eproto|err_tls/.test(msg)) {
+        return { cls: "network" };
+    }
+    if (/\b404\b|not found/.test(msg)) {
+        return {
+            cls: "network",
+            fixHint: "the candidate model was not found — fix the model id in the route's candidate list",
+        };
+    }
+    if (/invalid_argument|invalid argument/.test(msg)) {
+        return {
+            cls: "network",
+            fixHint: "request shape rejected (often a response schema over Gemini's complexity ceiling) — another candidate may accept it",
+        };
+    }
+    return { cls: "network" };
+}
+/** Pure request shaping — everything except the abort signal. */
+function buildGeminiRequest(model, req) {
+    const usingCache = req.cache?.key !== undefined && req.cache.key !== "";
+    // CE-6: a declared sampling field OVERRIDES the ported constant; absent, the
+    // constant stands (byte-identical to pre-CE-6). topK stays internal (gemini-only,
+    // not on the customer surface — spec §1 non-goals).
+    const config = {
+        temperature: req.sampling?.temperature ?? GEMINI_TEMPERATURE,
+        maxOutputTokens: (0, sampling_1.effectiveMaxOutputTokens)(req, DEFAULT_MAX_OUTPUT_TOKENS),
+        topP: req.sampling?.topP ?? TOP_P,
+        topK: TOP_K,
+        ...(THINKING_CAPABLE_MODELS.has(model) ? { thinkingConfig: { thinkingLevel: "high" } } : {}),
+    };
+    if (req.outputSchema !== null) {
+        config.responseMimeType = "application/json";
+        config.responseJsonSchema = req.outputSchema;
+    }
+    // cachedContent excludes systemInstruction and tools — the API rejects
+    // requests setting both (they are baked into the cache at creation time,
+    // including the googleSearch tool for cached grounded steps).
+    if (usingCache) {
+        config.cachedContent = req.cache?.key;
+    }
+    else {
+        if (req.systemPrompt !== "") {
+            config.systemInstruction = req.systemPrompt;
+        }
+        if (req.grounding === true) {
+            config.tools = [{ googleSearch: {} }];
+        }
+        else if (req.tools !== undefined && req.tools.length > 0) {
+            // Caller-supplied tools (spec §4.4) → Gemini functionDeclarations.
+            // Grounding wins the single `tools` slot when both are asked for.
+            config.tools = (0, tool_mapping_1.toGeminiTools)(req.tools);
+            const toolConfig = (0, tool_mapping_1.toGeminiToolConfig)(req.toolChoice);
+            if (toolConfig !== undefined)
+                config.toolConfig = toolConfig;
+        }
+    }
+    if (req.requestedTier === "flex") {
+        config.serviceTier = "flex";
+    }
+    return { model, contents: req.userPrompt, config };
+}
+/** Best-effort served-tier extraction (ported): response.serviceTier, then
+ * usageMetadata.trafficType (Vertex path), else assume the requested tier —
+ * production bills flex when a flex request was accepted without a tier echo. */
+function extractServedTier(rawServiceTier, trafficType, requested) {
+    if (rawServiceTier === "flex" || trafficType === "ON_DEMAND_FLEX")
+        return "flex";
+    if (rawServiceTier === "standard" || rawServiceTier === "default" || trafficType === "ON_DEMAND") {
+        return "standard";
+    }
+    if (rawServiceTier === "priority" || trafficType === "ON_DEMAND_PRIORITY")
+        return "priority";
+    return requested;
+}
+function createGeminiAdapter(config) {
+    const ai = new genai_1.GoogleGenAI({ apiKey: config.apiKey });
+    return {
+        id: "gemini",
+        supports: geminiSupports,
+        supportsTools: () => true,
+        async call(req) {
+            const model = req.candidate.model;
+            const abortController = new AbortController();
+            const timeoutId = setTimeout(() => abortController.abort(), req.timeoutMs);
+            // F1: post-response failures (refusal/empty/truncation) still billed
+            // tokens — they attach the response usage so the run loop accounts them.
+            const fail = (cls, message, fixHint, usage) => ({
+                ok: false,
+                failure: {
+                    class: cls,
+                    message,
+                    provider: "gemini",
+                    model,
+                    ...(fixHint !== undefined ? { fixHint } : {}),
+                },
+                ...(usage !== undefined ? { usage } : {}),
+            });
+            try {
+                const shaped = buildGeminiRequest(model, req);
+                const dispatchedAt = Date.now();
+                const response = await ai.models.generateContent({
+                    model: shaped.model,
+                    contents: shaped.contents,
+                    config: { ...shaped.config, abortSignal: abortController.signal },
+                });
+                // TTFB (Phase 4 WS3): generateContent is non-streaming — the first
+                // body byte genuinely arrives with the whole body, so TTFB = total.
+                const ttfbMs = Date.now() - dispatchedAt;
+                const usageMetadata = (response.usageMetadata ?? {});
+                const respWithTier = response;
+                const servedTier = extractServedTier(respWithTier.serviceTier, usageMetadata.trafficType, req.requestedTier);
+                const tokensIn = usageMetadata.promptTokenCount ?? 0;
+                // Thinking tokens are billed as output and count against
+                // maxOutputTokens — include them in tokensOut for honest accounting.
+                const tokensOut = (usageMetadata.candidatesTokenCount ?? 0) + (usageMetadata.thoughtsTokenCount ?? 0);
+                const tokensCached = usageMetadata.cachedContentTokenCount ?? 0;
+                const usage = { tokensIn, tokensOut, tokensCached, servedTier, ttfbMs };
+                const candidates = response.candidates;
+                const finishReason = candidates?.[0]?.finishReason;
+                // Tool-call turn (spec §4.4): collect functionCall parts. When present,
+                // surface normalized calls and skip the text/empty/truncation guards.
+                // Read any accompanying text from the parts (not the `response.text`
+                // getter, which can throw/warn on a functionCall-only response).
+                if (req.tools !== undefined && req.tools.length > 0) {
+                    const parts = candidates?.[0]?.content?.parts ?? [];
+                    const fnCalls = parts
+                        .map((p) => p.functionCall)
+                        .filter((fc) => fc !== undefined && fc !== null);
+                    const toolCalls = (0, tool_mapping_1.geminiFunctionCallsToToolCalls)(fnCalls);
+                    if (toolCalls !== undefined) {
+                        const toolText = parts
+                            .map((p) => p.text)
+                            .filter((t) => typeof t === "string")
+                            .join("");
+                        return { ok: true, text: toolText, usage, toolCalls };
+                    }
+                }
+                if (finishReason === "SAFETY" || finishReason === "PROHIBITED_CONTENT") {
+                    return fail("refusal", `Gemini blocked output via safety filter (finishReason=${finishReason})`, undefined, usage);
+                }
+                if (finishReason === "RECITATION") {
+                    return fail("refusal", "Gemini blocked output via recitation filter (finishReason=RECITATION)", undefined, usage);
+                }
+                const text = response.text ?? "";
+                if (text.trim().length === 0) {
+                    return fail("content_invalid", `empty response from Gemini (finishReason=${finishReason ?? "none"})`, undefined, usage);
+                }
+                if (finishReason === "MAX_TOKENS" && req.outputSchema !== null) {
+                    // A truncated structured emission is mid-object and unparseable.
+                    return fail("content_invalid", "Gemini structured output truncated (finishReason=MAX_TOKENS)", "raise maxOutputTokens for this route or reduce thinking budget", usage);
+                }
+                return { ok: true, text, usage };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                // An abort we triggered is our timeout regardless of message text.
+                if (abortController.signal.aborted) {
+                    return fail("timeout", `Gemini call exceeded timeoutMs=${req.timeoutMs}: ${message}`);
+                }
+                const { cls, fixHint } = classifyGeminiFailure(message);
+                return {
+                    ok: false,
+                    failure: {
+                        class: cls,
+                        message,
+                        provider: "gemini",
+                        model,
+                        cause: error,
+                        ...(fixHint !== undefined ? { fixHint } : {}),
+                    },
+                };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        },
+    };
+}

package/dist/adapters/grok.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Grok (xAI) ProviderAdapter — provider expansion 2026-08-02 (Matt: "add
+ * Grok to the testing asap"). OpenAI-compatible API at api.x.ai/v1 with
+ * native strict json_schema structured outputs and automatic prompt caching
+ * (cached tokens surface in prompt_tokens_details, deepseek-style). No
+ * service tiers. Reasoning models keep their trace server-side — only
+ * delta.content is accumulated, mirroring the deepseek reasoner rule.
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * xai transformation logic is consulted during the port.
+ */
+import type { CapabilityFlag, ProviderAdapter } from "../types/provider";
+import type { ClassifiedFailure, ShapingInput } from "./gemini";
+import type { OpenAIWireTool, OpenAIWireToolChoice } from "./tool-mapping";
+export interface GrokAdapterConfig {
+    readonly apiKey: string;
+}
+export declare function grokSupports(feature: CapabilityFlag, _model: string): boolean;
+export declare function classifyGrokFailure(message: string): ClassifiedFailure;
+interface ChatMessage {
+    readonly role: "system" | "user";
+    readonly content: string;
+}
+export interface GrokShapedParams {
+    readonly model: string;
+    readonly max_tokens: number;
+    readonly messages: readonly ChatMessage[];
+    readonly stream: true;
+    readonly stream_options: {
+        readonly include_usage: true;
+    };
+    /** CE-6 declared sampling — present only when the route/raw asks for them. */
+    readonly temperature?: number;
+    readonly top_p?: number;
+    /** Prompt-cache routing hint (WS-C) — the stable-prefix fingerprint the run
+     * loop stamps; xAI keeps a warm cache keyed to it (writes free today). */
+    readonly prompt_cache_key?: string;
+    readonly response_format?: {
+        readonly type: "json_schema";
+        readonly json_schema: {
+            readonly name: string;
+            readonly schema: object;
+            readonly strict: true;
+        };
+    };
+    readonly tools?: readonly OpenAIWireTool[];
+    readonly tool_choice?: OpenAIWireToolChoice;
+}
+export declare function buildGrokParams(model: string, req: ShapingInput): GrokShapedParams;
+export declare function createGrokAdapter(config: GrokAdapterConfig): ProviderAdapter;
+export {};
+//# sourceMappingURL=grok.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grok.d.ts","sourceRoot":"","sources":["../../src/adapters/grok.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMhE,OAAO,KAAK,EAAuB,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAMhG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAc7E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAsBtE;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;KAAE,CAAC;IAC1D,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;8EAC0E;IAC1E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE;QACzB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,WAAW,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;SAAE,CAAC;KACjG,CAAC;IACF,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,gBAAgB,CAsClF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAgK5E"}

package/dist/adapters/grok.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Grok (xAI) ProviderAdapter — provider expansion 2026-08-02 (Matt: "add
+ * Grok to the testing asap"). OpenAI-compatible API at api.x.ai/v1 with
+ * native strict json_schema structured outputs and automatic prompt caching
+ * (cached tokens surface in prompt_tokens_details, deepseek-style). No
+ * service tiers. Reasoning models keep their trace server-side — only
+ * delta.content is accumulated, mirroring the deepseek reasoner rule.
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * xai 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.grokSupports = grokSupports;
+exports.classifyGrokFailure = classifyGrokFailure;
+exports.buildGrokParams = buildGrokParams;
+exports.createGrokAdapter = createGrokAdapter;
+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");
+const GROK_BASE_URL = "https://api.x.ai/v1";
+const DEFAULT_MAX_TOKENS = 32000;
+function grokSupports(feature, _model) {
+    switch (feature) {
+        case "structured_native":
+        case "json_mode":
+        case "prefix_cache_implicit":
+        case "prompt_cache_key": // prompt_cache_key routing hint (WS-C) — cache-policy registry truth
+            return true;
+        case "grounded_native": // Live Search exists but is not wired — probes may grant later
+        case "context_cache_explicit":
+        case "tier_flex":
+        case "trace_visible":
+        case "zero_retention": // never a static adapter attestation — set only from the credential-scoped registry facts (claims.ts)
+            return false;
+    }
+}
+function classifyGrokFailure(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|incorrect api key/.test(msg)) {
+        // F2: non-retryable — a dead key never burns backoff retries.
+        return { cls: "config_auth", fixHint: "check the xAI API key configured for this rig" };
+    }
+    if (/credit|spending limit|insufficient_quota|billing/.test(msg)) {
+        // xAI 403 "used all available credits / monthly spending limit" —
+        // account-level hard stop observed 2026-08-03; retries are pure waste.
+        return { cls: "config_auth", fixHint: "the xAI account is out of credits or over its spending limit" };
+    }
+    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" };
+}
+function buildGrokParams(model, req) {
+    const messages = [
+        ...(req.systemPrompt !== "" ? [{ role: "system", content: req.systemPrompt }] : []),
+        { role: "user", content: req.userPrompt },
+    ];
+    return {
+        model,
+        max_tokens: (0, sampling_1.effectiveMaxOutputTokens)(req, DEFAULT_MAX_TOKENS),
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...(0, sampling_1.openAISamplingFields)(req),
+        // Prompt caching (WS-C): the run loop stamps `cache.key` (the stable-prefix
+        // fingerprint) for prompt_cache_key providers; pass it through as xAI's hint.
+        ...(req.cache?.key !== undefined && req.cache.key !== ""
+            ? { prompt_cache_key: req.cache.key }
+            : {}),
+        ...(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) }
+                    : {}),
+            }
+            : {}),
+    };
+}
+function createGrokAdapter(config) {
+    return {
+        id: "grok",
+        supports: grokSupports,
+        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: "grok",
+                    model,
+                    ...(fixHint !== undefined ? { fixHint } : {}),
+                },
+                ...(usage !== undefined ? { usage } : {}),
+            });
+            try {
+                const client = new openai_1.default({
+                    apiKey: config.apiKey,
+                    baseURL: GROK_BASE_URL,
+                    timeout: req.timeoutMs,
+                });
+                const params = buildGrokParams(model, req);
+                const stream = await client.chat.completions.create(params);
+                let text = "";
+                let promptTokens = 0;
+                let completionTokens = 0;
+                let cachedTokens = 0;
+                let cacheWriteTokens = 0;
+                let finishReason = null;
+                const toolCallAcc = (0, tool_mapping_1.createOpenAIToolCallAccumulator)();
+                // Only delta.content is accumulated — a reasoning model's trace must
+                // never leak into the JSON buffer (deepseek reasoner rule applied).
+                for await (const chunk of stream) {
+                    const choice = chunk.choices[0];
+                    if (choice?.delta?.content)
+                        text += choice.delta.content;
+                    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;
+                    }
+                }
+                // xAI has no service tiers — served is always standard. prompt_tokens
+                // already INCLUDES cached → tokensIn is subset-correct.
+                const usage = {
+                    tokensIn: promptTokens,
+                    tokensOut: completionTokens,
+                    tokensCached: cachedTokens,
+                    tokensCacheWrite: cacheWriteTokens,
+                    servedTier: "standard",
+                };
+                // Tool-call turn (spec §4.4): surface normalized calls, skip the
+                // empty/truncation content guards below.
+                const toolCalls = toolCallAcc.finalize();
+                if (toolCalls !== undefined) {
+                    return { ok: true, text, usage, toolCalls };
+                }
+                if (text.trim().length === 0) {
+                    return fail("content_invalid", `empty response from Grok (finish_reason=${finishReason ?? "none"})`, undefined, usage);
+                }
+                if (finishReason === "length" && req.outputSchema !== null) {
+                    return fail("content_invalid", "Grok 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 } = classifyGrokFailure(message);
+                return {
+                    ok: false,
+                    failure: {
+                        class: cls,
+                        message,
+                        provider: "grok",
+                        model,
+                        cause: error,
+                        ...(fixHint !== undefined ? { fixHint } : {}),
+                    },
+                };
+            }
+        },
+        async *stream(req) {
+            const model = req.candidate.model;
+            try {
+                const client = new openai_1.default({ apiKey: config.apiKey, baseURL: GROK_BASE_URL, timeout: req.timeoutMs });
+                const params = buildGrokParams(model, req);
+                const dispatchedAt = Date.now();
+                const stream = await client.chat.completions.create(params);
+                // xAI has no service tiers — served is always standard.
+                yield* (0, openai_stream_1.streamOpenAIDialect)(stream, req, dispatchedAt, {
+                    provider: "grok",
+                    cachedTokenSource: "details",
+                    mapServedTier: () => "standard",
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const { cls, fixHint } = classifyGrokFailure(message);
+                yield {
+                    kind: "final",
+                    result: {
+                        ok: false,
+                        failure: {
+                            class: cls,
+                            message,
+                            provider: "grok",
+                            model,
+                            cause: error,
+                            ...(fixHint !== undefined ? { fixHint } : {}),
+                        },
+                    },
+                };
+            }
+        },
+    };
+}