modelrig 0.0.1 → 0.2.0

package/dist/adapters/anthropic.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * Anthropic ProviderAdapter — provider expansion 2026-08-02. Messages API
+ * via @anthropic-ai/sdk with streaming. Structured output is a FORCED TOOL
+ * CALL: the route schema becomes the single tool's input_schema and
+ * tool_choice pins it, so the accumulated input_json_delta stream IS the
+ * JSON output (Anthropic's recommended structured-output pattern; the run
+ * loop still ajv-validates like every provider). Prompt caching (WS-C) is
+ * explicit `cache_control` on Anthropic: when the request opts in, the system
+ * prefix is marked with an ephemeral breakpoint (buildAnthropicParams) and the
+ * `context_cache_explicit` capability is advertised per the cache-policy registry.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStrictSchemaRejection = isStrictSchemaRejection;
+exports.anthropicSupports = anthropicSupports;
+exports.classifyAnthropicFailure = classifyAnthropicFailure;
+exports.buildAnthropicParams = buildAnthropicParams;
+exports.normalizeAnthropicInputUsage = normalizeAnthropicInputUsage;
+exports.createAnthropicAdapter = createAnthropicAdapter;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const tool_mapping_1 = require("./tool-mapping");
+const sampling_1 = require("./sampling");
+const DEFAULT_MAX_TOKENS = 32000;
+const OUTPUT_TOOL_NAME = "route_output";
+/** Strict tool use (constrained decoding) — public beta. Schemas that
+ * exceed Anthropic's compile limits (e.g. >16 union-typed parameters) are
+ * rejected with a 400; the call() path downgrades to advisory mode then. */
+const STRUCTURED_OUTPUTS_BETA = "structured-outputs-2025-11-13";
+/** True when a 400 says the schema cannot compile for strict mode —
+ * downgrade to advisory, do NOT surface as a failure. */
+function isStrictSchemaRejection(message) {
+    return /union|exponential compilation|does not support strict|strict.*not supported/i.test(message);
+}
+function anthropicSupports(feature, _model) {
+    switch (feature) {
+        case "structured_native": // forced tool call with the route schema
+        case "json_mode":
+        case "context_cache_explicit": // cache_control ephemeral blocks (WS-C) — cache-policy registry truth
+            return true;
+        case "grounded_native": // web-search tool exists but is not wired
+        case "prompt_cache_key": // anthropic ignores keys — caching is prefix-based via cache_control
+        case "prefix_cache_implicit":
+        case "tier_flex":
+        case "trace_visible": // extended thinking not enabled by this adapter
+        case "zero_retention": // never a static adapter attestation — set only from the credential-scoped registry facts (claims.ts)
+            return false;
+    }
+}
+function classifyAnthropicFailure(message) {
+    const msg = message.toLowerCase();
+    if (/\b429\b|rate limit|rate_limit/.test(msg))
+        return { cls: "capacity_shed" };
+    if (/\b529\b|overloaded|\b50[023]\b|service unavailable/.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|authentication|x-api-key|api key/.test(msg)) {
+        // F2: non-retryable — a dead key never burns backoff retries.
+        return { cls: "config_auth", fixHint: "check the Anthropic API key configured for this rig" };
+    }
+    if (/credit|spending limit|insufficient_quota|billing/.test(msg)) {
+        // Account-level hard stop — retrying burns nothing but time (learned
+        // from the 2026-08-03 xAI credit exhaustion mid-bake-off).
+        return { cls: "config_auth", fixHint: "the Anthropic account is out of credits or over its spending limit" };
+    }
+    if (/not_found|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" };
+}
+function buildAnthropicParams(model, req, strict = false) {
+    // Structured output is a FORCED tool call on the route schema (existing
+    // path). Otherwise, caller-supplied `tools` (spec §4.4) map to Anthropic's
+    // tool_use — the two are mutually exclusive here (a structured route does
+    // not also expose free tools in Phase A).
+    const toolBlock = req.outputSchema !== null
+        ? {
+            tools: [
+                {
+                    name: OUTPUT_TOOL_NAME,
+                    description: "Emit the structured output for this route.",
+                    input_schema: req.outputSchema,
+                    ...(strict ? { strict: true } : {}),
+                },
+            ],
+            tool_choice: { type: "tool", name: OUTPUT_TOOL_NAME },
+        }
+        : req.tools !== undefined && req.tools.length > 0
+            ? {
+                tools: (0, tool_mapping_1.toAnthropicTools)(req.tools),
+                ...((0, tool_mapping_1.toAnthropicToolChoice)(req.toolChoice) !== undefined
+                    ? { tool_choice: (0, tool_mapping_1.toAnthropicToolChoice)(req.toolChoice) }
+                    : {}),
+            }
+            : {};
+    // Prompt caching (WS-C): when the request opts in (`cache` set by the run
+    // loop's policy-gated stamp), mark the system prompt — the stable prefix in
+    // ModelRig's system-carries-the-task convention — with a `cache_control`
+    // ephemeral breakpoint. Anthropic caches the prefix up to and including the
+    // marked block (default 5m TTL, refreshes free on read); the `cache.key` is
+    // ignored (caching is prefix-based, not key-based — that is why the telemetry
+    // `cache_key` for anthropic is null). Extended 1h TTL is a documented
+    // follow-up (needs the extended-cache beta header; WS-A already accounts the
+    // 5m/1h split when the provider reports it).
+    const wantsCache = req.cache?.key !== undefined && req.cache.key !== "";
+    const systemField = req.systemPrompt === ""
+        ? {}
+        : wantsCache
+            ? {
+                system: [
+                    { type: "text", text: req.systemPrompt, cache_control: { type: "ephemeral" } },
+                ],
+            }
+            : { system: req.systemPrompt };
+    return {
+        model,
+        max_tokens: (0, sampling_1.effectiveMaxOutputTokens)(req, DEFAULT_MAX_TOKENS),
+        ...(0, sampling_1.openAISamplingFields)(req),
+        ...systemField,
+        messages: [{ role: "user", content: req.userPrompt }],
+        stream: true,
+        ...toolBlock,
+    };
+}
+/**
+ * Normalize Anthropic's `message_start` usage to ModelRig's convention
+ * (research §4 fix). Anthropic's `input_tokens` is the UNCACHED portion only;
+ * ModelRig requires `tokensIn` to INCLUDE cache reads and writes as subsets, so
+ * we add them back. Pure and total — the fixture-tested seam for the subset
+ * invariant and the 5m/1h split.
+ */
+function normalizeAnthropicInputUsage(u) {
+    const uncached = u.input_tokens ?? 0;
+    const read = u.cache_read_input_tokens ?? 0;
+    const write = u.cache_creation_input_tokens ?? 0;
+    // 1h split when the extended-TTL beta reports it; clamp to the total write so
+    // a malformed payload can never make the 1h bucket exceed the write bucket.
+    const write1h = Math.min(u.cache_creation?.ephemeral_1h_input_tokens ?? 0, write);
+    return {
+        tokensIn: uncached + read + write,
+        tokensCached: read,
+        tokensCacheWrite: write,
+        tokensCacheWrite1h: write1h,
+    };
+}
+function createAnthropicAdapter(config) {
+    return {
+        id: "anthropic",
+        supports: anthropicSupports,
+        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: "anthropic",
+                    model,
+                    ...(fixHint !== undefined ? { fixHint } : {}),
+                },
+                ...(usage !== undefined ? { usage } : {}),
+            });
+            const wantJson = req.outputSchema !== null;
+            try {
+                const client = new sdk_1.default({ apiKey: config.apiKey, timeout: req.timeoutMs });
+                // Strict-first (constrained decoding, structured-outputs beta): the
+                // strongest available rung. Schemas over Anthropic's compile limits
+                // (e.g. >16 union-typed parameters — hit live by earnings_5c on
+                // 2026-08-03) get an immediate 400; downgrade to advisory mode and
+                // let the run loop's ajv validation arbitrate, like every provider.
+                let stream;
+                if (wantJson) {
+                    try {
+                        stream = await client.messages.create(buildAnthropicParams(model, req, true), { headers: { "anthropic-beta": STRUCTURED_OUTPUTS_BETA } });
+                    }
+                    catch (strictError) {
+                        const message = strictError instanceof Error ? strictError.message : String(strictError);
+                        if (!isStrictSchemaRejection(message))
+                            throw strictError;
+                        stream = await client.messages.create(buildAnthropicParams(model, req));
+                    }
+                }
+                else {
+                    stream = await client.messages.create(buildAnthropicParams(model, req));
+                }
+                const events = stream;
+                // Caller-supplied tools (spec §4.4) live on the non-structured path:
+                // accumulate each `tool_use` block's input_json_delta by block index.
+                const wantTools = req.outputSchema === null && req.tools !== undefined && req.tools.length > 0;
+                const toolBlocks = new Map();
+                let text = "";
+                // Input-side usage, normalized at message_start (subset invariant +
+                // research §4 tokensIn fix + 5m/1h split live in normalizeAnthropicInputUsage).
+                let inputUsage = {
+                    tokensIn: 0,
+                    tokensCached: 0,
+                    tokensCacheWrite: 0,
+                    tokensCacheWrite1h: 0,
+                };
+                let completionTokens = 0;
+                let stopReason = null;
+                for await (const event of events) {
+                    if (event.type === "message_start" && event.message?.usage !== undefined) {
+                        inputUsage = normalizeAnthropicInputUsage(event.message.usage);
+                    }
+                    else if (event.type === "content_block_start" &&
+                        wantTools &&
+                        event.content_block?.type === "tool_use") {
+                        toolBlocks.set(event.index ?? 0, {
+                            id: event.content_block.id ?? "",
+                            name: event.content_block.name ?? "",
+                            json: "",
+                        });
+                    }
+                    else if (event.type === "content_block_delta") {
+                        // Tools path: input_json_delta is the tool's arguments, per block.
+                        // Schema path: the forced tool's input_json_delta IS the output.
+                        // Plain path: text deltas. Never mix the buffers.
+                        if (wantTools && event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+                            const blk = toolBlocks.get(event.index ?? 0);
+                            if (blk !== undefined)
+                                blk.json += event.delta.partial_json;
+                        }
+                        else if (wantJson && event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+                            text += event.delta.partial_json;
+                        }
+                        else if (event.delta?.type === "text_delta" && event.delta.text) {
+                            text += event.delta.text;
+                        }
+                    }
+                    else if (event.type === "message_delta") {
+                        if (event.usage?.output_tokens !== undefined) {
+                            completionTokens = event.usage.output_tokens;
+                        }
+                        if (event.delta?.stop_reason)
+                            stopReason = event.delta.stop_reason;
+                    }
+                }
+                // Anthropic has no service tiers on this path — served is standard.
+                // The input side (tokensIn incl. cached+write, the write buckets) was
+                // normalized by normalizeAnthropicInputUsage (research §4 fix).
+                const usage = {
+                    ...inputUsage,
+                    tokensOut: completionTokens,
+                    servedTier: "standard",
+                };
+                // Tool-call turn (spec §4.4): `arguments` is the raw JSON string the
+                // model streamed (OpenAI parity) — text may be empty, skip the guards.
+                if (wantTools && toolBlocks.size > 0) {
+                    const toolCalls = [...toolBlocks.values()].map((b, i) => ({
+                        id: b.id !== "" ? b.id : `call_${i}`,
+                        type: "function",
+                        function: { name: b.name, arguments: b.json === "" ? "{}" : b.json },
+                    }));
+                    return { ok: true, text, usage, toolCalls };
+                }
+                if (stopReason === "refusal") {
+                    return fail("refusal", "Anthropic refused this request (stop_reason=refusal)", undefined, usage);
+                }
+                if (text.trim().length === 0) {
+                    return fail("content_invalid", `empty response from Anthropic (stop_reason=${stopReason ?? "none"})`, undefined, usage);
+                }
+                if (stopReason === "max_tokens" && wantJson) {
+                    return fail("content_invalid", "Anthropic structured output truncated (stop_reason=max_tokens)", "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 } = classifyAnthropicFailure(message);
+                return {
+                    ok: false,
+                    failure: {
+                        class: cls,
+                        message,
+                        provider: "anthropic",
+                        model,
+                        cause: error,
+                        ...(fixHint !== undefined ? { fixHint } : {}),
+                    },
+                };
+            }
+        },
+    };
+}

package/dist/adapters/build-adapters.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Build the provider-adapter map from resolved config + registry facts.
+ * Extracted from index.ts (the SDK entrypoint) so that file stays under the LOC
+ * cap — the same reason wireRigArtifacts / buildExportedRouteMirrors live apart.
+ * Mechanical, one caller; behaviour is byte-identical to the prior inline block.
+ */
+import type { RigConfig } from "../config";
+import type { RegistryFacts } from "../registry/facts";
+import type { CapabilityFlag, ProviderAdapter } from "../types/provider";
+export declare function buildAdapters(config: RigConfig, registryFacts: RegistryFacts, compatStatic: ReadonlySet<CapabilityFlag>): Map<string, ProviderAdapter>;
+//# sourceMappingURL=build-adapters.d.ts.map

package/dist/adapters/build-adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-adapters.d.ts","sourceRoot":"","sources":["../../src/adapters/build-adapters.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAQzE,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EACjB,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,GACxC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CA6B9B"}

package/dist/adapters/build-adapters.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Build the provider-adapter map from resolved config + registry facts.
+ * Extracted from index.ts (the SDK entrypoint) so that file stays under the LOC
+ * cap — the same reason wireRigArtifacts / buildExportedRouteMirrors live apart.
+ * Mechanical, one caller; behaviour is byte-identical to the prior inline block.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdapters = buildAdapters;
+const anthropic_1 = require("./anthropic");
+const deepseek_1 = require("./deepseek");
+const gemini_1 = require("./gemini");
+const grok_1 = require("./grok");
+const openai_1 = require("./openai");
+const openai_compat_1 = require("./openai-compat");
+function buildAdapters(config, registryFacts, compatStatic) {
+    const adapters = new Map();
+    if (config.keys.gemini)
+        adapters.set("gemini", (0, gemini_1.createGeminiAdapter)({ apiKey: config.keys.gemini }));
+    if (config.keys.openai)
+        adapters.set("openai", (0, openai_1.createOpenAIAdapter)({ apiKey: config.keys.openai }));
+    if (config.keys.deepseek) {
+        adapters.set("deepseek", (0, deepseek_1.createDeepSeekAdapter)({ apiKey: config.keys.deepseek }));
+    }
+    if (config.keys.anthropic) {
+        adapters.set("anthropic", (0, anthropic_1.createAnthropicAdapter)({ apiKey: config.keys.anthropic }));
+    }
+    if (config.keys.grok)
+        adapters.set("grok", (0, grok_1.createGrokAdapter)({ apiKey: config.keys.grok }));
+    // A1 aggregator hosts behind the generic openai-compatible adapter.
+    for (const hostId of ["deepinfra", "fireworks"]) {
+        const apiKey = config.keys[hostId];
+        if (!apiKey)
+            continue;
+        const host = openai_compat_1.OPENAI_COMPAT_HOSTS[hostId];
+        adapters.set(hostId, (0, openai_compat_1.createOpenAICompatAdapter)({
+            providerId: hostId,
+            baseUrl: host.baseUrl,
+            apiKey,
+            ...(host.shapeModelId !== undefined ? { shapeModelId: host.shapeModelId } : {}),
+            capabilityProfile: (model) => registryFacts.flagsFor(hostId, model, compatStatic) ?? compatStatic,
+        }));
+    }
+    return adapters;
+}

package/dist/adapters/deepseek.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+import type { CapabilityFlag, ProviderAdapter } from "../types/provider";
+import type { ClassifiedFailure, ShapingInput } from "./gemini";
+import type { OpenAIWireTool, OpenAIWireToolChoice } from "./tool-mapping";
+export interface DeepSeekAdapterConfig {
+    readonly apiKey: string;
+}
+export declare function deepseekSupports(feature: CapabilityFlag, model: string): boolean;
+export declare function classifyDeepSeekFailure(message: string): ClassifiedFailure;
+interface ChatMessage {
+    readonly role: "system" | "user";
+    readonly content: string;
+}
+export interface DeepSeekShapedParams {
+    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;
+    readonly response_format?: {
+        readonly type: "json_object";
+    };
+    readonly tools?: readonly OpenAIWireTool[];
+    readonly tool_choice?: OpenAIWireToolChoice;
+}
+export declare function buildDeepSeekParams(model: string, req: ShapingInput): DeepSeekShapedParams;
+export declare function createDeepSeekAdapter(config: DeepSeekAdapterConfig): ProviderAdapter;
+export {};
+//# sourceMappingURL=deepseek.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deepseek.d.ts","sourceRoot":"","sources":["../../src/adapters/deepseek.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;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,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAMhF;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAiB1E;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,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,QAAQ,CAAC,eAAe,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAOD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,oBAAoB,CA2B1F;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CA8JpF"}

package/dist/adapters/deepseek.js

@@ -0,0 +1,216 @@
+"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 tool_mapping_1 = require("./tool-mapping");
+const openai_stream_1 = require("./openai-stream");
+const sampling_1 = require("./sampling");
+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: (0, sampling_1.effectiveMaxOutputTokens)(req, DEFAULT_MAX_TOKENS),
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...(0, sampling_1.openAISamplingFields)(req),
+        ...(wantJson ? { response_format: { type: "json_object" } } : {}),
+        ...(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 createDeepSeekAdapter(config) {
+    return {
+        id: "deepseek",
+        supports: deepseekSupports,
+        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: "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;
+                const toolCallAcc = (0, tool_mapping_1.createOpenAIToolCallAccumulator)();
+                // 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;
+                    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;
+                        // 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 } : {}),
+                };
+                // Tool-call turn (spec §4.4): surface normalized calls, skip content guards.
+                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 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 } : {}),
+                    },
+                };
+            }
+        },
+        async *stream(req) {
+            const model = req.candidate.model;
+            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);
+                // DeepSeek: cached tokens surface as prompt_cache_hit_tokens; no tiers.
+                yield* (0, openai_stream_1.streamOpenAIDialect)(stream, req, dispatchedAt, {
+                    provider: "deepseek",
+                    cachedTokenSource: "cache_hit",
+                    mapServedTier: () => "standard",
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const { cls, fixHint } = classifyDeepSeekFailure(message);
+                yield {
+                    kind: "final",
+                    result: {
+                        ok: false,
+                        failure: {
+                            class: cls,
+                            message,
+                            provider: "deepseek",
+                            model,
+                            cause: error,
+                            ...(fixHint !== undefined ? { fixHint } : {}),
+                        },
+                    },
+                };
+            }
+        },
+    };
+}