@plurnk/plurnk-providers 1.4.0 → 1.6.0

package/src/errors.test.ts

@@ -1,7 +1,7 @@
 import test from "node:test";
 import { strict as assert } from "node:assert";
 import { APICallError, RetryError } from "ai";
-import { ProviderError, classifyProviderError, toProviderError } from "./errors.ts";
+import { ProviderError, ProviderTimeoutError, classifyProviderError, toProviderError } from "./errors.ts";
 import type { ProviderAttempt } from "./types.ts";
 import { providerSource } from "./notices.ts";
 
@@ -29,12 +29,27 @@ test("classifyProviderError maps HTTP status to kind", () => {
     assert.equal(k(403), "unauthorized");
     assert.equal(k(402), "quota_exceeded");
     assert.equal(k(429), "rate_limit");
+    assert.equal(k(408), "network_failure");
+    assert.equal(k(409), "network_failure");
     assert.equal(k(500), "network_failure");
     assert.equal(k(503), "network_failure");
     assert.equal(k(400), "invalid_response");
     assert.equal(k(404), "invalid_response");
 });
 
+test("provider retry directives survive HTTP failure normalization", () => {
+    const final = new APICallError({
+        message: "edge router says not to replay",
+        url: "https://example.test/v1/chat/completions",
+        requestBodyValues: {},
+        statusCode: 524,
+        isRetryable: false,
+    });
+    const error = toProviderError(final, "provider:test");
+    assert.equal(error.kind, "network_failure");
+    assert.equal(error.problem.retryable, false);
+});
+
 test("classifyProviderError: a 422 flagged grammar_invalid is distinct; other 422s are invalid responses", () => {
     const rejected = apiError(422, JSON.stringify({ error: { type: "grammar_invalid", message: "non-conforming emission rejected: ..." } }));
     assert.equal(classifyProviderError(rejected).kind, "grammar_invalid");
@@ -75,11 +90,17 @@ test("#161: ProviderError carries resource-interrupted attempt evidence outside
         assistant: {
             content: "partial",
             reasoning: null,
-            usage: { prompt: 3, completion: 1, reasoning: 0, cached: 0, total: 4 },
             finishReason: "resource_interrupted",
             model: "served-model",
         },
         assistantRaw: { rawFinishReason: "insufficient_system_resource" },
+        accounting: [{
+            provider: "provider:deepseek",
+            model: "served-model",
+            outcome: "response",
+            usage: { inputTokens: 3, outputTokens: 1, totalTokens: 4 },
+            cost: { kind: "unknown", reason: "fixture has no monetary evidence" },
+        }],
     } as ProviderAttempt;
     const error = new ProviderError(
         "provider:deepseek",
@@ -96,6 +117,7 @@ test("#161: ProviderError carries resource-interrupted attempt evidence outside
     );
 
     assert.equal(error.attempt, attempt);
+    assert.deepEqual(error.accounting, attempt.accounting);
     assert.deepEqual(error.problem, {
         type: "https://problems.plurnk.dev/provider/deepseek/resource-interrupted",
         title: "Resource interrupted",
@@ -146,3 +168,26 @@ test("retry exhaustion is explicit and does not recommend another automatic repl
     assert.equal(error.problem.retryExhausted, true);
     assert.equal(error.cause, cause);
 });
+
+test("retry exhaustion retains the exact inner deadline phase", () => {
+    const failures = [1, 2].map(() => new APICallError({
+        message: "attempt timed out",
+        url: "https://example.test/v1/chat/completions",
+        requestBodyValues: {},
+        cause: new ProviderTimeoutError("attempt", 10),
+        isRetryable: true,
+    }));
+    const cause = new RetryError({
+        message: "Failed after 2 attempts.",
+        reason: "maxRetriesExceeded",
+        errors: failures,
+    });
+    const error = toProviderError(cause, "provider:test");
+    assert.equal(error.kind, "network_failure");
+    assert.equal(error.status, 503);
+    assert.equal(error.problem.retryable, false);
+    assert.equal(error.problem.attempts, 2);
+    assert.equal(error.problem.retryExhausted, true);
+    assert.equal(error.problem.timeoutPhase, "attempt");
+    assert.equal(error.problem.timeoutMs, 10);
+});

package/src/errors.ts

@@ -1,11 +1,12 @@
 import { Problems, type ProblemDetails } from "@plurnk/plurnk-contracts";
 import { APICallError, RetryError } from "ai";
 import { providerSource } from "./notices.ts";
-import type { ProviderAttempt } from "./types.ts";
+import type { ProviderAttempt, ProviderRequestAccounting } from "./types.ts";
 
 export type ProviderErrorKind =
     | "rate_limit"
     | "network_failure"
+    | "deadline_exceeded"
     | "model_refused"
     | "invalid_response"
     | "unauthorized"
@@ -19,8 +20,40 @@ export interface ClassifiedProviderError {
     retryable?: boolean;
     attempts?: number;
     retryExhausted?: boolean;
+    extensions?: Readonly<Record<string, unknown>>;
 }
 
+export type ProviderTimeoutPhase = "attempt" | "first_content" | "stream_idle" | "operation";
+
+export class ProviderTimeoutError extends Error {
+    readonly phase: ProviderTimeoutPhase;
+    readonly timeoutMs: number;
+
+    constructor(phase: ProviderTimeoutPhase, timeoutMs: number, cause?: unknown) {
+        const labels: Record<ProviderTimeoutPhase, string> = {
+            attempt: "Provider attempt",
+            first_content: "First provider content",
+            stream_idle: "Provider stream idle",
+            operation: "Provider operation",
+        };
+        super(`${labels[phase]} exceeded its ${timeoutMs} ms deadline.`, cause === undefined ? undefined : { cause });
+        this.name = "ProviderTimeoutError";
+        this.phase = phase;
+        this.timeoutMs = timeoutMs;
+    }
+}
+
+export const providerTimeoutOf = (error: unknown): ProviderTimeoutError | null => {
+    const seen = new Set<unknown>();
+    let current = error;
+    while (typeof current === "object" && current !== null && !seen.has(current)) {
+        if (current instanceof ProviderTimeoutError) return current;
+        seen.add(current);
+        current = (current as { cause?: unknown }).cause;
+    }
+    return null;
+};
+
 const defaultStatus = (kind: ProviderErrorKind): number => {
     switch (kind) {
         case "unauthorized": return 401;
@@ -29,6 +62,7 @@ const defaultStatus = (kind: ProviderErrorKind): number => {
         case "model_refused":
         case "grammar_invalid": return 422;
         case "invalid_response": return 502;
+        case "deadline_exceeded": return 504;
         case "network_failure":
         case "resource_interrupted": return 503;
     }
@@ -39,6 +73,7 @@ const retryable = (kind: ProviderErrorKind): boolean => {
         case "rate_limit":
         case "network_failure":
             return true;
+        case "deadline_exceeded":
         case "invalid_response":
         case "grammar_invalid":
         case "resource_interrupted":
@@ -60,6 +95,7 @@ const buildProblem = (
     const code: Record<ProviderErrorKind, string> = {
         rate_limit: "rate-limit",
         network_failure: "network-failure",
+        deadline_exceeded: "deadline-exceeded",
         model_refused: "model-refused",
         invalid_response: "invalid-response",
         unauthorized: "unauthorized",
@@ -84,6 +120,7 @@ export class ProviderError extends Error {
     readonly kind: ProviderErrorKind;
     readonly problem: ProblemDetails;
     readonly attempt?: ProviderAttempt;
+    #accounting: ProviderRequestAccounting[];
 
     constructor(
         source: string,
@@ -95,6 +132,7 @@ export class ProviderError extends Error {
             retryable?: boolean;
             extensions?: Readonly<Record<string, unknown>>;
             attempt?: ProviderAttempt;
+            accounting?: readonly ProviderRequestAccounting[];
         } = {},
     ) {
         super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
@@ -102,6 +140,7 @@ export class ProviderError extends Error {
         this.source = providerSource(source);
         this.kind = kind;
         this.attempt = options.attempt;
+        this.#accounting = [...(options.accounting ?? options.attempt?.accounting ?? [])];
         const status = options.status !== null && options.status !== undefined
             && Number.isInteger(options.status) && options.status >= 400 && options.status <= 599
             ? options.status
@@ -119,6 +158,16 @@ export class ProviderError extends Error {
     get status(): number {
         return this.problem.status;
     }
+
+    get accounting(): readonly ProviderRequestAccounting[] {
+        return this.#accounting;
+    }
+
+    // A capacity pool adds the already-settled requests from prior backends as
+    // the same failure crosses that orchestration boundary.
+    prependAccounting(accounting: readonly ProviderRequestAccounting[]): void {
+        if (accounting.length > 0) this.#accounting = [...accounting, ...this.#accounting];
+    }
 }
 
 const wireErrorType = (body: string): string | null => {
@@ -150,6 +199,17 @@ export const classifyProviderError = (
         };
     }
     if (APICallError.isInstance(err)) {
+        const timeout = providerTimeoutOf(err);
+        if (timeout !== null) {
+            return {
+                kind: "network_failure",
+                message: timeout.message,
+                extensions: {
+                    timeoutPhase: timeout.phase,
+                    timeoutMs: timeout.timeoutMs,
+                },
+            };
+        }
         const status = err.statusCode ?? 0;
         const message = err.message.trim().length > 0
             ? preview(err.message, detailLimit)
@@ -157,8 +217,12 @@ export const classifyProviderError = (
         const body = err.responseBody ?? "";
         if (status === 401 || status === 403) return { kind: "unauthorized", message };
         if (status === 402) return { kind: "quota_exceeded", message };
-        if (status === 429) return { kind: "rate_limit", message };
-        if (status >= 500) return { kind: "network_failure", message };
+        if (status === 429) return { kind: "rate_limit", message, retryable: err.isRetryable };
+        if (status === 408 || status === 409) {
+            return { kind: "network_failure", message, retryable: err.isRetryable };
+        }
+        if (status === 0 && err.isRetryable) return { kind: "network_failure", message };
+        if (status >= 500) return { kind: "network_failure", message, retryable: err.isRetryable };
         if (status === 422 && wireErrorType(body) === "grammar_invalid") {
             return { kind: "grammar_invalid", message };
         }
@@ -198,6 +262,7 @@ export const toProviderError = (
         cause: err,
         retryable: classified.retryable,
         extensions: {
+            ...(classified.extensions ?? {}),
             ...(classified.attempts === undefined ? {} : { attempts: classified.attempts }),
             ...(classified.retryExhausted === undefined
                 ? {}

package/src/index.ts

@@ -10,13 +10,20 @@ export type {
     ProviderOptions,
     ProviderResponse,
     ProviderEncryptedReasoningItem,
+    ProviderAccounting,
+    ProviderCost,
+    ProviderCostNormalizer,
+    ProviderCallKind,
+    ProviderGenerateArgs,
+    ProviderRequestAccounting,
+    ProviderRequestIdentity,
+    ProviderRequestObserver,
+    ProviderRequestSettlement,
     ProviderUsage,
     PromptTokenMeasurement,
     TokenLogprob,
     TokenAlternative,
-    AuthoritativeCharge,
 } from "./types.ts";
-export type { ProviderCost } from "@plurnk/plurnk-contracts";
 export { assertPromptTokenMeasurement } from "./promptTokens.ts";
 
 // Alias cascade — re-exported from the zero-dep @plurnk/plurnk-aliases, so
@@ -45,14 +52,23 @@ export { default as Pool } from "./Pool.ts";
 export type { ProviderFetch } from "./AiSdkProvider.ts";
 export { parseRequiredInt, parseOptionalInt, parseRequiredFloat, parseOptionalFloat, requireEnv, reasoningFromEnv, reasoningResponseStyleFromEnv, scopeEnvToAlias, dataCaptureFromEnv, contextWindowFromEnv, effectiveContextWindow, envelopeFromEnv, resolveReserve, PROVIDERS_KNOBS } from "./env.ts";
 export type { Reasoning, ReasoningMode, ReasoningResponseStyle, ReserveSpec } from "./env.ts";
-export { normalizeUsage, calculateCostUsd } from "./usage.ts";
+export { normalizeUsage, calculateCostUsdDecimal, validateProviderUsage } from "./usage.ts";
 export {
-    providerCostFor,
+    addDecimals,
+    estimateProviderCost,
     providerCostUsd,
     resolveProviderCost,
-    validateAuthoritativeCharge,
+    sumProviderCostsUsd,
+    validateChargedCost,
+    validateDecimal,
     validateProviderCost,
 } from "./cost.ts";
+export {
+    aggregateProviderAccounting,
+    plurnkCostNormalizer,
+    providerCostNormalizer,
+    validateProviderRequestAccounting,
+} from "./accounting.ts";
 export type { RawUsage, TokenRates } from "./usage.ts";
 export { ProviderError, classifyProviderError, toProviderError } from "./errors.ts";
 export { providerSource } from "./notices.ts";

package/src/ollama.test.ts

@@ -4,6 +4,8 @@ import { ollamaProviderFromEnv } from "./ollama.ts";
 
 const env = Object.freeze({
     PLURNK_PROVIDERS_FETCH_TIMEOUT: "1000",
+    PLURNK_PROVIDERS_OPERATION_TIMEOUT: "3000",
+    PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT: "1000",
     PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT: "0",
     PLURNK_PROVIDERS_REASONING: "off",
     PLURNK_PROVIDERS_TEMPERATURE: "0.2",
@@ -13,7 +15,8 @@ const env = Object.freeze({
     PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%",
     PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
     PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT: "512",
-    PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
+    PLURNK_PROVIDERS_CACHE_AFFINITY: "1",
+    PLURNK_PROVIDERS_CACHE_WRITE_POLICY: "stable-system",
 });
 
 test.afterEach(() => mock.restoreAll());

package/src/ollama.ts

@@ -1,5 +1,5 @@
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { contextWindowFromEnv, effectiveContextWindow, parseRequiredInt, requireEnv } from "./env.ts";
+import { contextWindowFromEnv, effectiveContextWindow, parseTimeoutMs, requireEnv } from "./env.ts";
 import { providerFromSdkModel } from "./catalogProvider.ts";
 import type { Provider, ProviderOptions } from "./types.ts";
 
@@ -20,7 +20,7 @@ const fetchContextWindow = async ({
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ model }),
-        signal: AbortSignal.timeout(timeout),
+        ...(timeout > 0 ? { signal: AbortSignal.timeout(timeout) } : {}),
     });
     if (!response.ok) throw new Error(`ollama provider: /api/show returned ${response.status}`);
     const data = await response.json() as ShowResponse;
@@ -41,7 +41,7 @@ export const ollamaProviderFromEnv = async (
         "OLLAMA_BASE_URL or OLLAMA_HOST (or a PLURNK_BASEURL_<alias> override)",
         "ollama",
     ).replace(/\/+$/, "").replace(/\/v1$/, "");
-    const timeout = parseRequiredInt(
+    const timeout = parseTimeoutMs(
         env.PLURNK_PROVIDERS_FETCH_TIMEOUT,
         "PLURNK_PROVIDERS_FETCH_TIMEOUT",
         "ollama",

package/src/sdkModels.test.ts

@@ -19,9 +19,49 @@ test("createSdkModel uses Models.dev provider facts and operator credentials", (
     const sdk = createSdkModel("xai", "grok-build-0.1", { XAI_API_KEY: "test-key" });
     assert.notEqual(sdk, null);
     assert.equal(sdk?.catalog?.npm, "@ai-sdk/xai");
-    const languageModel = sdk?.languageModel as { provider: string; modelId: string };
-    assert.equal(languageModel.provider, "xai.responses");
-    assert.equal(languageModel.modelId, "grok-build-0.1");
+    assert.equal(sdk?.languageModel, undefined);
+    assert.deepEqual(sdk?.compatible, {
+        url: "https://api.x.ai/v1/chat/completions",
+        headers: { Authorization: "Bearer test-key" },
+    });
+    assert.deepEqual(sdk?.cacheAffinity, { target: "header", name: "x-grok-conv-id" });
+    assert.notEqual(sdk?.normalizeCost, undefined);
+});
+
+test("createSdkModel constructs Cerebras from Models.dev facts", () => {
+    const sdk = createSdkModel("cerebras", "gemma-4-31b", {
+        CEREBRAS_API_KEY: "test-key",
+    });
+    assert.notEqual(sdk, null);
+    assert.equal(sdk?.catalog?.npm, "@ai-sdk/cerebras");
+    assert.notEqual(sdk?.languageModel, undefined);
+    assert.equal(sdk?.compatible, undefined);
+});
+
+test("the Google SDK adapter owns its readable-reasoning response projection", () => {
+    assert.deepEqual(
+        createSdkModel("google", "gemini-3.7-flash", { GEMINI_API_KEY: "test-key" })?.reasoningResponseProviderOptions,
+        { google: { thinkingConfig: { includeThoughts: true } } },
+    );
+    assert.equal(
+        createSdkModel("cerebras", "gemma-4-31b", { CEREBRAS_API_KEY: "test-key" })?.reasoningResponseProviderOptions,
+        undefined,
+    );
+});
+
+test("createSdkModel attaches DeepInfra's documented response-cost normalizer", () => {
+    const sdk = createSdkModel("deepinfra", "zai-org/GLM-5.2", {
+        DEEPINFRA_API_KEY: "test-key",
+    });
+    assert.notEqual(sdk?.languageModel, undefined);
+    assert.deepEqual(sdk?.normalizeCost?.({
+        usage: { estimated_cost: 5.04e-5 },
+        response: { id: "response-1" },
+    }), {
+        kind: "estimated",
+        amount: { amount: "0.0000504", currency: "USD" },
+        source: "DeepInfra response usage.estimated_cost",
+    });
 });
 
 test("createSdkModel expands catalog endpoint variables without treating them as credentials", () => {
@@ -35,6 +75,57 @@ test("createSdkModel expands catalog endpoint variables without treating them as
         url: "https://api.cloudflare.com/client/v4/accounts/account/ai/v1/chat/completions",
         headers: { Authorization: "Bearer token" },
     });
+    assert.deepEqual(sdk?.cacheAffinity, { target: "header", name: "x-session-affinity" });
+});
+
+test("catalog routes own their documented cache-affinity request projection", () => {
+    assert.deepEqual(
+        createSdkModel("openai", "gpt-4.1-mini", { OPENAI_API_KEY: "key" })?.cacheAffinity,
+        { target: "provider-option", provider: "openai", name: "promptCacheKey" },
+    );
+    assert.deepEqual(
+        createSdkModel("deepinfra", "zai-org/GLM-5.2", { DEEPINFRA_API_KEY: "key" })?.cacheAffinity,
+        { target: "provider-option", provider: "deepinfra", name: "prompt_cache_key" },
+    );
+    assert.deepEqual(
+        createSdkModel("openrouter", "openai/gpt-5", { OPENROUTER_API_KEY: "key" })?.cacheAffinity,
+        { target: "header", name: "x-session-id" },
+    );
+    assert.deepEqual(
+        createSdkModel("fireworks", "accounts/fireworks/models/test", { FIREWORKS_API_KEY: "key" })?.cacheAffinity,
+        { target: "body", name: "prompt_cache_key" },
+    );
+});
+
+test("explicit stable-system cache breakpoints exist only on supported Claude routes", () => {
+    const cacheControl = { type: "ephemeral" };
+    assert.deepEqual(
+        createSdkModel("anthropic", "claude-sonnet-4-6", { ANTHROPIC_API_KEY: "key" })?.systemCacheProviderOptions,
+        { anthropic: { cacheControl } },
+    );
+    assert.deepEqual(
+        createSdkModel("openrouter", "anthropic/claude-sonnet-4.6", { OPENROUTER_API_KEY: "key" })?.systemCacheProviderOptions,
+        { openrouter: { cacheControl } },
+    );
+    assert.equal(
+        createSdkModel("openrouter", "openai/gpt-5", { OPENROUTER_API_KEY: "key" })?.systemCacheProviderOptions,
+        undefined,
+    );
+    assert.equal(
+        createSdkModel("deepseek", "deepseek-v4-flash", { DEEPSEEK_API_KEY: "key" })?.systemCacheProviderOptions,
+        undefined,
+    );
+});
+
+test("an operator-declared compatible provider receives no guessed cache extension", () => {
+    const sdk = createSdkModel("acme", "model", {
+        ACME_API_KEY: "key",
+        PLURNK_PROVIDERS_PROVIDER_ACME_NPM: "@ai-sdk/openai-compatible",
+        PLURNK_PROVIDERS_PROVIDER_ACME_BASE_URL: "https://api.acme.test/v1",
+        PLURNK_PROVIDERS_PROVIDER_ACME_API_KEY_ENV: "ACME_API_KEY",
+    });
+    assert.equal(sdk?.cacheAffinity, undefined);
+    assert.equal(sdk?.systemCacheProviderOptions, undefined);
 });
 
 test("#157: a cataloged compatible provider fails before transport when its declared credential is absent", () => {

package/src/sdkModels.ts

@@ -1,25 +1,34 @@
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { createCerebras } from "@ai-sdk/cerebras";
 import { createDeepInfra } from "@ai-sdk/deepinfra";
 import { createGoogle } from "@ai-sdk/google";
 import { createGroq } from "@ai-sdk/groq";
 import { createMistral } from "@ai-sdk/mistral";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createTogetherAI } from "@ai-sdk/togetherai";
-import { createXai } from "@ai-sdk/xai";
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import { lookupProvider, type ProviderInfo } from "@plurnk/plurnk-models";
 import type { LanguageModel } from "ai";
+import { providerCostNormalizer } from "./accounting.ts";
+import type { AiSdkProviderOptions, CacheAffinity } from "./AiSdkProvider.ts";
+import type { ProviderCostNormalizer } from "./types.ts";
 
 export type SdkModel = {
     readonly languageModel?: LanguageModel;
+    readonly normalizeCost?: ProviderCostNormalizer;
     readonly compatible?: {
         readonly url: string;
         readonly headers: Readonly<Record<string, string>>;
     };
+    readonly cacheAffinity?: CacheAffinity;
+    readonly systemCacheProviderOptions?: AiSdkProviderOptions;
+    readonly reasoningResponseProviderOptions?: AiSdkProviderOptions;
     readonly catalog: ProviderInfo | null;
 };
 
+const cacheControl = { type: "ephemeral" as const };
+
 const envPrefix = (provider: string): string =>
     provider.replaceAll(/[^a-zA-Z0-9]/g, "_").toUpperCase();
 
@@ -105,11 +114,15 @@ export const createSdkModel = (
     const catalog = lookupProvider(provider) ?? configuredProviderInfo(provider, env);
     if (catalog === null) return null;
     const url = baseUrl(provider, env, catalog, baseUrlOverride);
+    const normalizeCost = providerCostNormalizer(catalog.npm);
 
     switch (catalog.npm) {
         case "@ai-sdk/openai":
             return {
                 languageModel: createOpenAI({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).chat(model),
+                ...(catalog.id === "openai"
+                    ? { cacheAffinity: { target: "provider-option" as const, provider: "openai", name: "promptCacheKey" } }
+                    : {}),
                 catalog,
             };
         case "@ai-sdk/groq":
@@ -117,6 +130,11 @@ export const createSdkModel = (
                 languageModel: createGroq({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
                 catalog,
             };
+        case "@ai-sdk/cerebras":
+            return {
+                languageModel: createCerebras({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                catalog,
+            };
         case "@ai-sdk/mistral":
             return {
                 languageModel: createMistral({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
@@ -130,21 +148,41 @@ export const createSdkModel = (
         case "@ai-sdk/deepinfra":
             return {
                 languageModel: createDeepInfra({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                ...(normalizeCost === undefined ? {} : { normalizeCost }),
+                ...(catalog.id === "deepinfra"
+                    ? { cacheAffinity: { target: "provider-option" as const, provider: "deepinfra", name: "prompt_cache_key" } }
+                    : {}),
                 catalog,
             };
         case "@ai-sdk/google":
             return {
                 languageModel: createGoogle({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                reasoningResponseProviderOptions: {
+                    google: { thinkingConfig: { includeThoughts: true } },
+                },
                 catalog,
             };
-        case "@ai-sdk/xai":
+        case "@ai-sdk/xai": {
+            const key = requireApiKey(provider, env, catalog);
+            const compatibleBase = url ?? "https://api.x.ai/v1";
             return {
-                languageModel: createXai({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                compatible: {
+                    url: `${compatibleBase}/chat/completions`,
+                    headers: { Authorization: `Bearer ${key}` },
+                },
+                ...(catalog.id === "xai"
+                    ? { cacheAffinity: { target: "header" as const, name: "x-grok-conv-id" } }
+                    : {}),
+                ...(normalizeCost === undefined ? {} : { normalizeCost }),
                 catalog,
             };
+        }
         case "@ai-sdk/anthropic":
             return {
                 languageModel: createAnthropic({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                ...(catalog.id === "anthropic"
+                    ? { systemCacheProviderOptions: { anthropic: { cacheControl } } }
+                    : {}),
                 catalog,
             };
         case "@ai-sdk/amazon-bedrock":
@@ -169,6 +207,13 @@ export const createSdkModel = (
                         ...(env.OPENROUTER_X_TITLE === undefined ? {} : { "X-Title": env.OPENROUTER_X_TITLE }),
                     },
                 }).languageModel(model),
+                ...(catalog.id === "openrouter"
+                    ? { cacheAffinity: { target: "header" as const, name: "x-session-id" } }
+                    : {}),
+                ...(catalog.id === "openrouter" && model.replace(/^~/, "").startsWith("anthropic/")
+                    ? { systemCacheProviderOptions: { openrouter: { cacheControl } } }
+                    : {}),
+                ...(normalizeCost === undefined ? {} : { normalizeCost }),
                 catalog,
             };
         case "@ai-sdk/openai-compatible":
@@ -182,6 +227,11 @@ export const createSdkModel = (
                         ? {}
                         : { Authorization: `Bearer ${key}` },
                 },
+                ...(catalog.id === "cloudflare-workers-ai"
+                    ? { cacheAffinity: { target: "header" as const, name: "x-session-affinity" } }
+                    : catalog.id === "fireworks-ai"
+                        ? { cacheAffinity: { target: "body" as const, name: "prompt_cache_key" } }
+                        : {}),
                 catalog,
             };
         default: