modelrig 0.0.1 → 0.1.0

package/dist/adapters/deepseek.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * DeepSeek ProviderAdapter — plan step 5 (sanctioned cut if C1 date at risk).
+ * Transformation logic ported from apps/api/src/services/deepseek-provider.ts:
+ * OpenAI-compatible API at api.deepseek.com, json_object forcing (DeepSeek has
+ * NO native strict json_schema — the run loop's json_mode path injects the
+ * schema-coached prompt; this adapter receives it already coached),
+ * prompt_cache_hit_tokens accounting, reasoning_content excluded from the
+ * JSON buffer (only delta.content is accumulated).
+ * NOT ported: logging, pricing tables, env reads, the analyst-persona prompt.
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * deepseek 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.deepseekSupports = deepseekSupports;
+exports.classifyDeepSeekFailure = classifyDeepSeekFailure;
+exports.buildDeepSeekParams = buildDeepSeekParams;
+exports.createDeepSeekAdapter = createDeepSeekAdapter;
+const openai_1 = __importDefault(require("openai"));
+const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+const DEFAULT_MAX_TOKENS = 64000; // R1/V3 max — full capacity for long reports (ported)
+function deepseekSupports(feature, model) {
+    if (feature === "trace_visible") {
+        // Reasoner models stream reasoning_content — the trace IS caller-visible.
+        return model.includes("reasoner");
+    }
+    return feature === "json_mode" || feature === "prefix_cache_implicit";
+}
+function classifyDeepSeekFailure(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 DeepSeek API key configured for this rig" };
+    }
+    if (/not found|does not exist/.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" };
+}
+/** DeepSeek's json_object mode 400s when the literal word "JSON" appears
+ * nowhere in the prompt. The run loop's coached prompt normally guarantees
+ * it; this one-line guard is the adapter's belt-and-suspenders (ported). */
+const JSON_GUARD = "Respond with a single valid JSON object.";
+function buildDeepSeekParams(model, req) {
+    const wantJson = req.outputSchema !== null;
+    let systemPrompt = req.systemPrompt;
+    if (wantJson && !req.systemPrompt.includes("JSON") && !req.userPrompt.includes("JSON")) {
+        systemPrompt = systemPrompt === "" ? JSON_GUARD : `${systemPrompt}\n\n${JSON_GUARD}`;
+    }
+    const messages = [
+        ...(systemPrompt !== "" ? [{ role: "system", content: systemPrompt }] : []),
+        { role: "user", content: req.userPrompt },
+    ];
+    return {
+        model,
+        max_tokens: req.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...(wantJson ? { response_format: { type: "json_object" } } : {}),
+    };
+}
+function createDeepSeekAdapter(config) {
+    return {
+        id: "deepseek",
+        supports: deepseekSupports,
+        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: "deepseek",
+                    model,
+                    ...(fixHint !== undefined ? { fixHint } : {}),
+                },
+                ...(usage !== undefined ? { usage } : {}),
+            });
+            try {
+                const client = new openai_1.default({
+                    apiKey: config.apiKey,
+                    baseURL: DEEPSEEK_BASE_URL,
+                    timeout: req.timeoutMs,
+                });
+                const params = buildDeepSeekParams(model, req);
+                const dispatchedAt = Date.now();
+                const stream = await client.chat.completions.create(params);
+                let text = "";
+                let promptTokens = 0;
+                let completionTokens = 0;
+                let cachedTokens = 0;
+                let finishReason = null;
+                // TTFB (Phase 4 WS3): first streamed chunk = first body byte.
+                let ttfbMs;
+                // Only delta.content is accumulated — a reasoner's reasoning_content
+                // (chain-of-thought) must never leak into the JSON buffer (ported).
+                for await (const chunk of stream) {
+                    if (ttfbMs === undefined)
+                        ttfbMs = Date.now() - dispatchedAt;
+                    const choice = chunk.choices[0];
+                    if (choice?.delta?.content)
+                        text += choice.delta.content;
+                    if (choice?.finish_reason)
+                        finishReason = choice.finish_reason;
+                    if (chunk.usage) {
+                        promptTokens = chunk.usage.prompt_tokens ?? 0;
+                        completionTokens = chunk.usage.completion_tokens ?? 0;
+                        // DeepSeek's automatic prefix cache: tokens billed ~10x cheaper.
+                        cachedTokens = chunk.usage.prompt_cache_hit_tokens ?? 0;
+                    }
+                }
+                // DeepSeek has no service tiers — served is always standard.
+                const usage = {
+                    tokensIn: promptTokens,
+                    tokensOut: completionTokens,
+                    tokensCached: cachedTokens,
+                    servedTier: "standard",
+                    ...(ttfbMs !== undefined ? { ttfbMs } : {}),
+                };
+                if (text.trim().length === 0) {
+                    return fail("content_invalid", `empty response from DeepSeek (finish_reason=${finishReason ?? "none"})`, undefined, usage);
+                }
+                if (finishReason === "length" && req.outputSchema !== null) {
+                    return fail("content_invalid", "DeepSeek JSON 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 } = classifyDeepSeekFailure(message);
+                return {
+                    ok: false,
+                    failure: {
+                        class: cls,
+                        message,
+                        provider: "deepseek",
+                        model,
+                        cause: error,
+                        ...(fixHint !== undefined ? { fixHint } : {}),
+                    },
+                };
+            }
+        },
+    };
+}

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;AAElE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAyBD,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,CAkCxF;AA0BD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,eAAe,CAyHhF"}

package/dist/adapters/gemini.js

@@ -0,0 +1,222 @@
+"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");
+/** 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 requires temperature=1.0 — lower values cause looping (ported). */
+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 !== "";
+    const config = {
+        temperature: GEMINI_TEMPERATURE,
+        maxOutputTokens: req.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
+        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: {} }];
+        }
+    }
+    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,
+        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;
+                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,44 @@
+/**
+ * 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";
+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;
+    };
+    readonly response_format?: {
+        readonly type: "json_schema";
+        readonly json_schema: {
+            readonly name: string;
+            readonly schema: object;
+            readonly strict: true;
+        };
+    };
+}
+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;AAEhE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAa7E;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,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;CACH;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,gBAAgB,CAwBlF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CA4G5E"}

package/dist/adapters/grok.js

@@ -0,0 +1,168 @@
+"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 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":
+            return true;
+        case "grounded_native": // Live Search exists but is not wired — probes may grant later
+        case "context_cache_explicit":
+        case "prompt_cache_key":
+        case "tier_flex":
+        case "trace_visible":
+            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: req.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...(req.outputSchema !== null
+            ? {
+                response_format: {
+                    type: "json_schema",
+                    json_schema: {
+                        name: "modelrig_route_output",
+                        schema: req.outputSchema,
+                        strict: true,
+                    },
+                },
+            }
+            : {}),
+    };
+}
+function createGrokAdapter(config) {
+    return {
+        id: "grok",
+        supports: grokSupports,
+        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 finishReason = null;
+                // 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;
+                    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;
+                    }
+                }
+                // xAI has no service tiers — served is always standard.
+                const usage = {
+                    tokensIn: promptTokens,
+                    tokensOut: completionTokens,
+                    tokensCached: cachedTokens,
+                    servedTier: "standard",
+                };
+                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 } : {}),
+                    },
+                };
+            }
+        },
+    };
+}