modelrig 0.0.1 → 0.2.0

package/dist/adapters/openai-compat.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Generic openai-compatible adapter — Phase 4 addendum A1
+ * (provider-coverage-plan §1: "the DeepSeek adapter is its
+ * parameterization"). One adapter covers every OpenAI-dialect host; what
+ * varies is INJECTED: base URL, auth key, model-id shaping, and — the
+ * doctrine part — the per-model capability profile READ FROM THE REGISTRY.
+ * Speaking the dialect proves nothing: strict schema enforcement, caching,
+ * grounding are all probe-established facts, never dialect assumptions.
+ *
+ * Host quirks referenced from LiteLLM's per-provider transformation modules
+ * (vendor/litellm-upstream/litellm/llms/{deepinfra,fireworks_ai}/):
+ * DeepInfra base URL https://api.deepinfra.com/v1/openai (standard Bearer,
+ * OpenAI params incl. response_format); Fireworks base URL
+ * https://api.fireworks.ai/inference/v1 with model ids on the wire as
+ * accounts/fireworks/models/<short>.
+ * Portions derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retained per
+ * litellm-vendoring-strategy.md.
+ */
+import type { CapabilityFlag, ProviderAdapter, ProviderId } from "../types/provider";
+import type { ClassifiedFailure, ShapingInput } from "./gemini";
+import type { OpenAIWireTool, OpenAIWireToolChoice } from "./tool-mapping";
+/** Fireworks serves models at accounts/fireworks/models/<short> — routes
+ * declare the short name; the wire gets the full path (LiteLLM
+ * fireworks_ai transformation, harvested). */
+export declare function shapeFireworksModelId(model: string): string;
+export interface OpenAICompatHost {
+    readonly baseUrl: string;
+    readonly shapeModelId?: (model: string) => string;
+}
+/** The researched Tier-2 hosts (provider-coverage-plan §2, architect pick
+ * 2026-08-02): DeepInfra (widest open catalog, lowest price) + Fireworks
+ * (SOC 2/HIPAA reliability counterweight). Same weights on both on purpose
+ * — host-level conformance/latency/price deltas become registry facts. */
+export declare const OPENAI_COMPAT_HOSTS: Readonly<Record<"deepinfra" | "fireworks", OpenAICompatHost>>;
+export declare function classifyCompatFailure(message: string, host: string): ClassifiedFailure;
+interface ChatMessage {
+    readonly role: "system" | "user";
+    readonly content: string;
+}
+export interface OpenAICompatShapedParams {
+    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 type: "json_schema";
+        readonly json_schema: {
+            readonly name: string;
+            readonly strict: true;
+            readonly schema: object;
+        };
+    };
+    readonly tools?: readonly OpenAIWireTool[];
+    readonly tool_choice?: OpenAIWireToolChoice;
+}
+/** Pure request shaping. The PROFILE decides the wire shape: strict
+ * json_schema only when the registry granted structured_native for this
+ * model; else json_object (ajv still arbitrates above). */
+export declare function buildOpenAICompatParams(model: string, req: ShapingInput, profileFlags: ReadonlySet<CapabilityFlag>): OpenAICompatShapedParams;
+export interface OpenAICompatAdapterConfig {
+    readonly providerId: ProviderId;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly shapeModelId?: (model: string) => string;
+    /** Registry-fed per-model capability flags — the ONLY capability source.
+     * The conservative dialect baseline is json_mode alone. */
+    readonly capabilityProfile: (model: string) => ReadonlySet<CapabilityFlag>;
+}
+export declare function createOpenAICompatAdapter(config: OpenAICompatAdapterConfig): ProviderAdapter;
+export {};
+//# sourceMappingURL=openai-compat.d.ts.map

package/dist/adapters/openai-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compat.d.ts","sourceRoot":"","sources":["../../src/adapters/openai-compat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EACf,UAAU,EACX,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;AAQhG;;8CAE8C;AAC9C,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACnD;AAED;;;0EAG0E;AAC1E,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,GAAG,WAAW,EAAE,gBAAgB,CAAC,CAG7F,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAiBtF;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,wBAAwB;IACvC,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,EACrB;QAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;KAAE,GAChC;QACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,WAAW,EAAE;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;KACjG,CAAC;IACN,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAOD;;2DAE2D;AAC3D,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,YAAY,EACjB,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,GACxC,wBAAwB,CAqC1B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD;+DAC2D;IAC3D,QAAQ,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC,cAAc,CAAC,CAAC;CAC5E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,yBAAyB,GAAG,eAAe,CAwK5F"}

package/dist/adapters/openai-compat.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Generic openai-compatible adapter — Phase 4 addendum A1
+ * (provider-coverage-plan §1: "the DeepSeek adapter is its
+ * parameterization"). One adapter covers every OpenAI-dialect host; what
+ * varies is INJECTED: base URL, auth key, model-id shaping, and — the
+ * doctrine part — the per-model capability profile READ FROM THE REGISTRY.
+ * Speaking the dialect proves nothing: strict schema enforcement, caching,
+ * grounding are all probe-established facts, never dialect assumptions.
+ *
+ * Host quirks referenced from LiteLLM's per-provider transformation modules
+ * (vendor/litellm-upstream/litellm/llms/{deepinfra,fireworks_ai}/):
+ * DeepInfra base URL https://api.deepinfra.com/v1/openai (standard Bearer,
+ * OpenAI params incl. response_format); Fireworks base URL
+ * https://api.fireworks.ai/inference/v1 with model ids on the wire as
+ * accounts/fireworks/models/<short>.
+ * Portions derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retained per
+ * litellm-vendoring-strategy.md.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_COMPAT_HOSTS = void 0;
+exports.shapeFireworksModelId = shapeFireworksModelId;
+exports.classifyCompatFailure = classifyCompatFailure;
+exports.buildOpenAICompatParams = buildOpenAICompatParams;
+exports.createOpenAICompatAdapter = createOpenAICompatAdapter;
+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 DEFAULT_MAX_TOKENS = 32000;
+/** Fireworks serves models at accounts/fireworks/models/<short> — routes
+ * declare the short name; the wire gets the full path (LiteLLM
+ * fireworks_ai transformation, harvested). */
+function shapeFireworksModelId(model) {
+    return model.startsWith("accounts/") ? model : `accounts/fireworks/models/${model}`;
+}
+/** The researched Tier-2 hosts (provider-coverage-plan §2, architect pick
+ * 2026-08-02): DeepInfra (widest open catalog, lowest price) + Fireworks
+ * (SOC 2/HIPAA reliability counterweight). Same weights on both on purpose
+ * — host-level conformance/latency/price deltas become registry facts. */
+exports.OPENAI_COMPAT_HOSTS = {
+    deepinfra: { baseUrl: "https://api.deepinfra.com/v1/openai" },
+    fireworks: { baseUrl: "https://api.fireworks.ai/inference/v1", shapeModelId: shapeFireworksModelId },
+};
+function classifyCompatFailure(message, host) {
+    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|\b403\b|api key|unauthorized/.test(msg)) {
+        // F2: non-retryable — a dead key never burns backoff retries.
+        return { cls: "config_auth", fixHint: `check the ${host} 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" };
+}
+/** json_object mode 400s on several compat backends when the literal word
+ * "JSON" appears nowhere in the prompt (the DeepSeek-family quirk; coached
+ * prompts normally guarantee it — this is belt-and-suspenders). */
+const JSON_GUARD = "Respond with a single valid JSON object.";
+/** Pure request shaping. The PROFILE decides the wire shape: strict
+ * json_schema only when the registry granted structured_native for this
+ * model; else json_object (ajv still arbitrates above). */
+function buildOpenAICompatParams(model, req, profileFlags) {
+    const wantJson = req.outputSchema !== null;
+    const strict = wantJson && profileFlags.has("structured_native");
+    let systemPrompt = req.systemPrompt;
+    if (wantJson && !strict && !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
+            ? strict
+                ? {
+                    response_format: {
+                        type: "json_schema",
+                        json_schema: { name: "output", strict: true, schema: req.outputSchema },
+                    },
+                }
+                : { 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 createOpenAICompatAdapter(config) {
+    const shapeModel = config.shapeModelId ?? ((m) => m);
+    return {
+        id: config.providerId,
+        supports(feature, model) {
+            return config.capabilityProfile(model).has(feature);
+        },
+        supportsTools: () => true,
+        async call(req) {
+            const model = req.candidate.model;
+            const fail = (cls, message, fixHint, usage) => ({
+                ok: false,
+                failure: {
+                    class: cls,
+                    message,
+                    provider: config.providerId,
+                    model,
+                    ...(fixHint !== undefined ? { fixHint } : {}),
+                },
+                ...(usage !== undefined ? { usage } : {}),
+            });
+            try {
+                const client = new openai_1.default({
+                    apiKey: config.apiKey,
+                    baseURL: config.baseUrl,
+                    timeout: req.timeoutMs,
+                });
+                const params = buildOpenAICompatParams(shapeModel(model), req, config.capabilityProfile(model));
+                const dispatchedAt = Date.now();
+                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;
+                // TTFB (Phase 4 WS3): first streamed chunk = first body byte.
+                let ttfbMs;
+                const toolCallAcc = (0, tool_mapping_1.createOpenAIToolCallAccumulator)();
+                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;
+                        cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+                        cacheWriteTokens = chunk.usage.input_tokens_details?.cache_write_tokens ?? 0;
+                    }
+                }
+                // Hosts have no service tiers in this dialect — standard, always.
+                // prompt_tokens already INCLUDES cached → tokensIn is subset-correct.
+                const usage = {
+                    tokensIn: promptTokens,
+                    tokensOut: completionTokens,
+                    tokensCached: cachedTokens,
+                    tokensCacheWrite: cacheWriteTokens,
+                    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 ${config.providerId} (finish_reason=${finishReason ?? "none"})`, undefined, usage);
+                }
+                if (finishReason === "length" && req.outputSchema !== null) {
+                    return fail("content_invalid", `${config.providerId} 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 } = classifyCompatFailure(message, config.providerId);
+                return {
+                    ok: false,
+                    failure: {
+                        class: cls,
+                        message,
+                        provider: config.providerId,
+                        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: config.baseUrl, timeout: req.timeoutMs });
+                const params = buildOpenAICompatParams(shapeModel(model), req, config.capabilityProfile(model));
+                const dispatchedAt = Date.now();
+                const stream = await client.chat.completions.create(params);
+                // Compat hosts have no service tiers in this dialect — standard, always.
+                yield* (0, openai_stream_1.streamOpenAIDialect)(stream, req, dispatchedAt, {
+                    provider: config.providerId,
+                    cachedTokenSource: "details",
+                    mapServedTier: () => "standard",
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const { cls, fixHint } = classifyCompatFailure(message, config.providerId);
+                yield {
+                    kind: "final",
+                    result: {
+                        ok: false,
+                        failure: {
+                            class: cls,
+                            message,
+                            provider: config.providerId,
+                            model,
+                            cause: error,
+                            ...(fixHint !== undefined ? { fixHint } : {}),
+                        },
+                    },
+                };
+            }
+        },
+    };
+}

package/dist/adapters/openai-stream.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared streaming loop for the OpenAI-dialect adapters (G-1/G-5 Phase A,
+ * spec §4.3). The openai / grok / deepseek / deepinfra / fireworks adapters all
+ * speak `client.chat.completions.create({ stream: true })`; this is the one
+ * place that drains such a stream into `AdapterStreamEvent`s — raw text deltas
+ * as they arrive, then a single terminal `final` carrying the same
+ * `AdapterResult` the adapter's buffered `call()` would return.
+ *
+ * ADDITIVE: `call()` is untouched. This powers the OPTIONAL `stream()` method
+ * the run loop uses only when a delta sink is wired (`rig.runStream`); every
+ * other path is byte-for-byte the pre-Phase-A behavior. Providers without a
+ * `stream()` (anthropic events / gemini non-streaming) fall back to buffered
+ * dispatch, which is the spec's sanctioned `buffered` mode.
+ */
+import type { AdapterRequest, AdapterStreamEvent, ProviderId, ServiceTier } from "../types/provider";
+import type { OpenAIToolCallDelta } from "./tool-mapping";
+/** The permissive chunk shape common to the OpenAI-dialect hosts. */
+export interface OpenAIDialectChunk {
+    readonly service_tier?: string;
+    readonly choices: Array<{
+        readonly delta?: {
+            readonly content?: string | null;
+            readonly refusal?: string | null;
+            readonly tool_calls?: readonly OpenAIToolCallDelta[];
+        };
+        readonly finish_reason?: string | null;
+    }>;
+    readonly usage?: {
+        readonly prompt_tokens?: number;
+        readonly completion_tokens?: number;
+        readonly prompt_tokens_details?: {
+            readonly cached_tokens?: number;
+        };
+        readonly prompt_cache_hit_tokens?: number;
+        /** Cache-WRITE tokens — GPT-5.6+ bills explicit writes at 1.25× and reports
+         * them here (spec §2 table). Absent on ≤5.5 (writes free) and every non-
+         * openai dialect host, so cache-write is 0 there. */
+        readonly input_tokens_details?: {
+            readonly cache_write_tokens?: number;
+        };
+    } | null;
+}
+export interface OpenAIStreamConfig {
+    readonly provider: ProviderId;
+    /** Where cached-token counts live in this dialect's usage block. */
+    readonly cachedTokenSource: "details" | "cache_hit";
+    /** Served-tier resolver (openai maps flex/priority; the rest are standard). */
+    readonly mapServedTier: (raw: string | null, requested: ServiceTier) => ServiceTier;
+}
+/**
+ * Drain an OpenAI-dialect completion stream into `AdapterStreamEvent`s. Emits a
+ * `delta` per content token, then exactly one `final`. The final result mirrors
+ * `call()`'s terminal decisions for the shared dialect: refusal → fail;
+ * tool-call turn → ok + normalized calls; empty → content_invalid; a
+ * schema-route truncation (`finish_reason=length`) → content_invalid.
+ */
+export declare function streamOpenAIDialect(chunks: AsyncIterable<OpenAIDialectChunk>, req: AdapterRequest, dispatchedAt: number, cfg: OpenAIStreamConfig): AsyncGenerator<AdapterStreamEvent>;
+//# sourceMappingURL=openai-stream.d.ts.map

package/dist/adapters/openai-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-stream.d.ts","sourceRoot":"","sources":["../../src/adapters/openai-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAElB,UAAU,EACV,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;QACtB,QAAQ,CAAC,KAAK,CAAC,EAAE;YACf,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;YACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;YACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;SACtD,CAAC;QACF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACxC,CAAC,CAAC;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAChC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;QACpC,QAAQ,CAAC,qBAAqB,CAAC,EAAE;YAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACrE,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;QAC1C;;6DAEqD;QACrD,QAAQ,CAAC,oBAAoB,CAAC,EAAE;YAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1E,GAAG,IAAI,CAAC;CACV;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,iBAAiB,EAAE,SAAS,GAAG,WAAW,CAAC;IACpD,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,SAAS,EAAE,WAAW,KAAK,WAAW,CAAC;CACrF;AAED;;;;;;GAMG;AACH,wBAAuB,mBAAmB,CACxC,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,EACzC,GAAG,EAAE,cAAc,EACnB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,kBAAkB,GACtB,cAAc,CAAC,kBAAkB,CAAC,CAqGpC"}

package/dist/adapters/openai-stream.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Shared streaming loop for the OpenAI-dialect adapters (G-1/G-5 Phase A,
+ * spec §4.3). The openai / grok / deepseek / deepinfra / fireworks adapters all
+ * speak `client.chat.completions.create({ stream: true })`; this is the one
+ * place that drains such a stream into `AdapterStreamEvent`s — raw text deltas
+ * as they arrive, then a single terminal `final` carrying the same
+ * `AdapterResult` the adapter's buffered `call()` would return.
+ *
+ * ADDITIVE: `call()` is untouched. This powers the OPTIONAL `stream()` method
+ * the run loop uses only when a delta sink is wired (`rig.runStream`); every
+ * other path is byte-for-byte the pre-Phase-A behavior. Providers without a
+ * `stream()` (anthropic events / gemini non-streaming) fall back to buffered
+ * dispatch, which is the spec's sanctioned `buffered` mode.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamOpenAIDialect = streamOpenAIDialect;
+const tool_mapping_1 = require("./tool-mapping");
+/**
+ * Drain an OpenAI-dialect completion stream into `AdapterStreamEvent`s. Emits a
+ * `delta` per content token, then exactly one `final`. The final result mirrors
+ * `call()`'s terminal decisions for the shared dialect: refusal → fail;
+ * tool-call turn → ok + normalized calls; empty → content_invalid; a
+ * schema-route truncation (`finish_reason=length`) → content_invalid.
+ */
+async function* streamOpenAIDialect(chunks, req, dispatchedAt, cfg) {
+    let ttfbMs;
+    let text = "";
+    let refusalText = "";
+    const toolCallAcc = (0, tool_mapping_1.createOpenAIToolCallAccumulator)();
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let cachedTokens = 0;
+    let cacheWriteTokens = 0;
+    let responseTier = null;
+    let finishReason = null;
+    for await (const chunk of chunks) {
+        if (ttfbMs === undefined)
+            ttfbMs = Date.now() - dispatchedAt;
+        if (responseTier === null && chunk.service_tier !== undefined)
+            responseTier = chunk.service_tier;
+        const choice = chunk.choices[0];
+        const content = choice?.delta?.content;
+        if (content) {
+            text += content;
+            yield { kind: "delta", text: content };
+        }
+        if (typeof choice?.delta?.refusal === "string" && choice.delta.refusal.length > 0) {
+            refusalText += choice.delta.refusal;
+        }
+        toolCallAcc.push(choice?.delta?.tool_calls);
+        if (choice?.finish_reason)
+            finishReason = choice.finish_reason;
+        if (chunk.usage) {
+            promptTokens = chunk.usage.prompt_tokens ?? 0;
+            completionTokens = chunk.usage.completion_tokens ?? 0;
+            cachedTokens =
+                cfg.cachedTokenSource === "cache_hit"
+                    ? chunk.usage.prompt_cache_hit_tokens ?? 0
+                    : chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+            // Cache-write (GPT-5.6+): 0 on every dialect that does not report it.
+            cacheWriteTokens = chunk.usage.input_tokens_details?.cache_write_tokens ?? 0;
+        }
+    }
+    // prompt_tokens already INCLUDES cached (and any write) on the OpenAI dialect,
+    // so tokensIn = promptTokens honors the subset invariant as-is. There is no 1h
+    // TTL tier on this dialect (OpenAI 5.6 writes are a single 30m tier) → 1h = 0.
+    const usage = {
+        tokensIn: promptTokens,
+        tokensOut: completionTokens,
+        tokensCached: cachedTokens,
+        tokensCacheWrite: cacheWriteTokens,
+        servedTier: cfg.mapServedTier(responseTier, req.requestedTier),
+        ...(ttfbMs !== undefined ? { ttfbMs } : {}),
+    };
+    const fail = (message, fixHint) => ({
+        kind: "final",
+        result: {
+            ok: false,
+            failure: {
+                class: "content_invalid",
+                message,
+                provider: cfg.provider,
+                model: req.candidate.model,
+                ...(fixHint !== undefined ? { fixHint } : {}),
+            },
+            usage,
+        },
+    });
+    if (refusalText.length > 0) {
+        yield {
+            kind: "final",
+            result: {
+                ok: false,
+                failure: {
+                    class: "refusal",
+                    message: `${cfg.provider} refused output: ${refusalText.slice(0, 200)}`,
+                    provider: cfg.provider,
+                    model: req.candidate.model,
+                },
+                usage,
+            },
+        };
+        return;
+    }
+    const toolCalls = toolCallAcc.finalize();
+    if (toolCalls !== undefined) {
+        yield { kind: "final", result: { ok: true, text, usage, toolCalls } };
+        return;
+    }
+    if (text.trim().length === 0) {
+        yield fail(`empty response from ${cfg.provider} (finish_reason=${finishReason ?? "none"})`);
+        return;
+    }
+    if (finishReason === "length" && req.outputSchema !== null) {
+        yield fail(`${cfg.provider} output truncated (finish_reason=length)`, "raise maxOutputTokens for this route");
+        return;
+    }
+    yield { kind: "final", result: { ok: true, text, usage } };
+}

package/dist/adapters/openai.d.ts

@@ -0,0 +1,55 @@
+/**
+ * OpenAI ProviderAdapter — plan step 5.
+ * Transformation logic ported from apps/api/src/services/openai-provider.ts:
+ * response_format json_schema strict, service tiers (flex allowlist + served
+ * tier from the stream), prompt-cache key + retention passthrough, streaming
+ * with usage, structured-output refusal detection, suspicious-short guard.
+ * NOT ported: logging, pricing tables, env reads, the analyst-persona system
+ * prompt (route templates own prompt content).
+ *
+ * Portions may be derived from LiteLLM (https://github.com/BerriAI/litellm),
+ * Copyright (c) 2023 Berri AI, MIT License — retain this notice if LiteLLM's
+ * openai transformation logic is consulted during the port.
+ */
+import type { CapabilityFlag, ProviderAdapter } from "../types/provider";
+import type { ClassifiedFailure, ShapingInput } from "./gemini";
+import type { OpenAIWireTool, OpenAIWireToolChoice } from "./tool-mapping";
+export interface OpenAIAdapterConfig {
+    readonly apiKey: string;
+}
+export declare function isModelFlexEligible(modelName: string): boolean;
+export declare function openaiSupports(feature: CapabilityFlag, model: string): boolean;
+export declare function classifyOpenAIFailure(message: string): ClassifiedFailure;
+interface ChatMessage {
+    readonly role: "system" | "user";
+    readonly content: string;
+}
+export interface OpenAIShapedParams {
+    readonly model: string;
+    readonly max_completion_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 service_tier?: "flex" | "priority";
+    readonly prompt_cache_key?: string;
+    readonly prompt_cache_retention?: "24h";
+    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 buildOpenAIParams(model: string, req: ShapingInput): OpenAIShapedParams;
+export declare function createOpenAIAdapter(config: OpenAIAdapterConfig): ProviderAdapter;
+export {};
+//# sourceMappingURL=openai.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../src/adapters/openai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAEhB,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,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAMD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAI9D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAe9E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAiBxE;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,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,YAAY,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,KAAK,CAAC;IACxC,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;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,kBAAkB,CA6CtF;AAcD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,eAAe,CAwMhF"}