@plurnk/plurnk-providers 1.3.12 → 1.5.0

package/src/ProviderRegistry.test.ts

@@ -1,20 +1,21 @@
 import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
 import { instantiateProvider, loadActiveProvider, resetDiscoveryCache } from "./ProviderRegistry.ts";
+import type { PluginAttributionContext } from "@plurnk/plurnk-meta";
 
 const mapOf = (entries: Record<string, string>, skipped: Record<string, string> = {}) =>
     async () => ({ registry: new Map(Object.entries(entries)), skipped: new Map(Object.entries(skipped)), attributions: new Map<string, string | string[]>() });
 
-// Alias PARSING is tested in @plurnk/plurnk-aliases (its owner, #27). Here we
+// Alias parsing is tested in @plurnk/plurnk-aliases (its owner). Here we
 // exercise the resolution + two-tier instantiation this module owns; the active
 // alias is driven end-to-end by loadActiveProvider below.
 
-// — provider resolution (SPEC §5) —
+// — provider resolution ({§provider-resolution}) —
 
 const fullEnv = Object.freeze({
     PLURNK_PROVIDERS_FETCH_TIMEOUT: "600000",
     PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT: "0",
-    PLURNK_PROVIDERS_REASONING: "off", PLURNK_PROVIDERS_TEMPERATURE: "0.2", PLURNK_PROVIDERS_REPEAT_PENALTY: "1.15", PLURNK_PROVIDERS_FREQUENCY_PENALTY: "0.4", PLURNK_PROVIDERS_REASONING_RESERVE: "10%", PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%", PLURNK_PROVIDERS_PROBE_ATTEMPTS: "3", PLURNK_PROVIDERS_PROBE_DELAY: "1", PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0", PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
+    PLURNK_PROVIDERS_REASONING: "off", PLURNK_PROVIDERS_TEMPERATURE: "0.2", PLURNK_PROVIDERS_REPEAT_PENALTY: "1.15", PLURNK_PROVIDERS_FREQUENCY_PENALTY: "0.4", PLURNK_PROVIDERS_REASONING_RESERVE: "10%", PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%", PLURNK_PROVIDERS_PROBE_ATTEMPTS: "3", PLURNK_PROVIDERS_PROBE_DELAY: "1", PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0", PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT: "512", PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
     OPENAI_BASE_URL: "http://x",
 });
 
@@ -49,6 +50,38 @@ test("instantiateProvider: an installed AI SDK provider resolves through discove
     assert.deepEqual(calls, ["@acme/ai-provider", "model-a"]);
 });
 
+test("instantiateProvider: a selected plugin composes its static and runtime attribution sources", async () => {
+    resetDiscoveryCache();
+    const context: PluginAttributionContext = {
+        workspaceId: "workspace",
+        workerId: "worker",
+        primaryWorkerId: "primary",
+        loop: 3,
+        turn: 2,
+        attempt: 1,
+    };
+    const sdkProvider = {
+        languageModel: () => ({} as never),
+        attributions: ({ attempt }: PluginAttributionContext) => attempt === 1
+            ? ["runtime:provider", "static:provider"]
+            : [],
+    };
+    const provider = await instantiateProvider(
+        "acme",
+        { ...fullEnv, PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192" },
+        "model-a",
+        async () => ({ default: sdkProvider }),
+        async () => ({
+            registry: new Map([["acme", "@acme/ai-provider"]]),
+            skipped: new Map(),
+            attributions: new Map([["acme", "static:provider"]]),
+            packageAttributions: new Map([["@acme/ai-provider", ["static:provider"]]]),
+        }),
+    );
+
+    assert.deepEqual(provider.attributions?.(context), ["runtime:provider", "static:provider"]);
+});
+
 test("instantiateProvider: a per-alias baseUrl drives the built-in Ollama probe", async () => {
     resetDiscoveryCache();
     const calls: string[] = [];
@@ -112,7 +145,7 @@ test("instantiateProvider: unknown provider throws — no standard, no discovere
     );
 });
 
-test("instantiateProvider: an untrusted (skipped) provider gives a precise error, not 'unknown' (#15)", async () => {
+test("instantiateProvider: an untrusted (skipped) provider gives a precise error, not 'unknown'", async () => {
     resetDiscoveryCache();
     const imports: string[] = [];
     await assert.rejects(
@@ -171,7 +204,7 @@ test("instantiateProvider: per-alias knobs scope through to the provider (per-al
     mock.restoreAll();
 });
 
-test("#633: public construction applies the package floor to a sparse consumer environment", async () => {
+test("public construction applies the package floor to a sparse consumer environment", async () => {
     const provider = await instantiateProvider(
         "fireworks",
         { FIREWORKS_API_KEY: "fw" },
@@ -182,7 +215,74 @@ test("#633: public construction applies the package floor to a sparse consumer e
     assert.equal(provider.model, "accounts/fireworks/models/deepseek-v4-pro");
 });
 
-test("#633: an explicit malformed operator override still fails at its owning contract", async () => {
+test("{§deepseek-reasoning-request} #157: direct DeepSeek composes catalog facts, credential, reasoning control, and cached cost", async () => {
+    const calls: Array<{ url: string; init?: RequestInit }> = [];
+    mock.method(globalThis, "fetch", async (url: string | URL | Request, init?: RequestInit) => {
+        calls.push({ url: String(url), init });
+        const chunks = [
+            {
+                id: "deepseek-test",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "deepseek-v4-flash",
+                choices: [{ index: 0, delta: { content: "ok" }, finish_reason: "stop" }],
+                usage: null,
+            },
+            {
+                id: "deepseek-test",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "deepseek-v4-flash",
+                choices: [],
+                usage: {
+                    prompt_tokens: 10,
+                    prompt_cache_hit_tokens: 8,
+                    prompt_cache_miss_tokens: 2,
+                    completion_tokens: 2,
+                    total_tokens: 12,
+                },
+            },
+        ];
+        const body = [...chunks.map((chunk) => `data: ${JSON.stringify(chunk)}`), "data: [DONE]"].join("\n\n");
+        return new Response(body, { status: 200, headers: { "Content-Type": "text/event-stream" } });
+    });
+
+    const provider = await instantiateProvider(
+        "deepseek",
+        {
+            DEEPSEEK_API_KEY: "test-key",
+            PLURNK_PROVIDERS_REASONING: "off",
+            PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
+        },
+        "deepseek-v4-flash",
+        async () => ({}),
+        mapOf({}),
+    );
+    const response = await provider.generate({
+        workerId: "worker",
+        messages: [{ role: "user", content: "Reply with ok." }],
+    });
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].url, "https://api.deepseek.com/chat/completions");
+    assert.equal(new Headers(calls[0].init?.headers).get("Authorization"), "Bearer test-key");
+    const request = JSON.parse(String(calls[0].init?.body)) as Record<string, unknown>;
+    assert.equal(request.model, "deepseek-v4-flash");
+    assert.deepEqual(request.thinking, { type: "disabled" });
+    assert.equal(provider.contextWindow, 1_000_000);
+    assert.equal(response.assistant.content, "ok");
+    assert.deepEqual(response.assistant.usage, {
+        prompt: 10,
+        completion: 2,
+        reasoning: 0,
+        cached: 8,
+        total: 12,
+    });
+    assert.ok(Math.abs(provider.calculateCost(response.assistant.usage) - 0.0000008624) < 1e-15);
+    mock.restoreAll();
+});
+
+test("an explicit malformed operator override still fails at its owning contract", async () => {
     await assert.rejects(
         () => instantiateProvider(
             "fireworks",
@@ -198,7 +298,7 @@ test("#633: an explicit malformed operator override still fails at its owning co
     );
 });
 
-test("#634: a catalog provider with unknown model metadata never falls through to plugin discovery", async () => {
+test("a catalog provider with unknown model metadata never falls through to plugin discovery", async () => {
     let scanned = false;
     await assert.rejects(
         () => instantiateProvider(
@@ -223,7 +323,7 @@ test("#634: a catalog provider with unknown model metadata never falls through t
     assert.equal(scanned, false);
 });
 
-test("#634: explicit metadata constructs an out-of-snapshot Cloudflare model in the consolidated transport", async () => {
+test("explicit metadata constructs an out-of-snapshot Cloudflare model in the consolidated transport", async () => {
     let scanned = false;
     const provider = await instantiateProvider(
         "cloudflare",
@@ -248,7 +348,56 @@ test("#634: explicit metadata constructs an out-of-snapshot Cloudflare model in
     assert.equal(scanned, false);
 });
 
-test("#622: two Fireworks aliases independently select default and priority service tiers", async () => {
+test("{§provider-tagged-reasoning} a Cloudflare model alias carries its explicit response style through the public registry", async () => {
+    const calls: string[] = [];
+    mock.method(globalThis, "fetch", async (input: string | URL | Request) => {
+        calls.push(String(input));
+        const chunks = [
+            {
+                id: "cloudflare-reasoning",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
+                choices: [{ index: 0, delta: { content: "<think>working</think>done" }, finish_reason: "stop" }],
+            },
+            {
+                id: "cloudflare-reasoning",
+                object: "chat.completion.chunk",
+                created: 2,
+                model: "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
+                choices: [],
+                usage: { prompt_tokens: 2, completion_tokens: 4, total_tokens: 6 },
+            },
+        ];
+        const body = [...chunks.map((chunk) => `data: ${JSON.stringify(chunk)}`), "data: [DONE]"].join("\n\n");
+        return new Response(body, { status: 200, headers: { "Content-Type": "text/event-stream" } });
+    });
+    const provider = await instantiateProvider(
+        "cloudflare",
+        {
+            ...fullEnv,
+            CLOUDFLARE_ACCOUNT_ID: "account",
+            CLOUDFLARE_API_TOKEN: "token",
+            PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE: "verbatim",
+            PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE_cfds1: "think-tags",
+        },
+        "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
+        async () => ({}),
+        mapOf({}),
+        undefined,
+        "cfds1",
+    );
+
+    const response = await provider.generate({ workerId: "cloudflare-worker", messages: [] });
+
+    assert.equal(response.assistant.reasoning, "working");
+    assert.equal(response.assistant.content, "done");
+    assert.deepEqual(calls, [
+        "https://api.cloudflare.com/client/v4/accounts/account/ai/v1/chat/completions",
+    ]);
+});
+
+test("two Fireworks aliases independently select default and priority service tiers", async () => {
     const bodies: Record<string, unknown>[] = [];
     mock.method(globalThis, "fetch", async (_url: string, init?: RequestInit) => {
         bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);

package/src/ProviderRegistry.ts

@@ -1,9 +1,9 @@
 // Provider instantiation + active-alias resolution. Alias PARSING (the
 // PLURNK_MODEL_<alias>=<provider>/<model> cascade + PLURNK_BASEURL_<alias>
 // overrides) lives in @plurnk/plurnk-aliases — the zero-dep parser shared with
-// thin clients (#27); this module resolves the active alias to a Provider.
+// thin clients; this module resolves the active alias to a Provider.
 //
-// Resolution order (SPEC §5): models.dev catalog → PLURNK provider declaration
+// {§provider-resolution} Models.dev catalog → PLURNK provider declaration
 // → local protocol adapter → scope-agnostic AI SDK plugin discovery. Generic
 // provider facts belong to models.dev or operator config; PLURNK owns only the
 // stable Provider contract and product-specific local behavior.
@@ -17,20 +17,27 @@ import { ollamaProviderFromEnv } from "./ollama.ts";
 import { compatibleProviderFromEnv } from "./compatibleProvider.ts";
 import { contextWindowFromEnv } from "./env.ts";
 import { withProviderDefaults } from "./defaults.ts";
+import Meta, {
+    type PluginAttribution,
+    type PluginAttributionContext,
+} from "@plurnk/plurnk-meta";
 
 // Two injectable seams, both defaulting to production behavior and never passed
 // by real callers: the module importer (tests exercise the bespoke path without
 // a real package on disk) and the discovery scan (tests inject a fixed map).
 type ImportModule = (specifier: string) => Promise<unknown>;
 const importModule: ImportModule = (specifier) => import(specifier);
-type DiscoverFn = (options?: DiscoverOptions) => Promise<Discovery>;
+type DiscoveryInput = Omit<Discovery, "packageAttributions"> & {
+    packageAttributions?: Discovery["packageAttributions"];
+};
+type DiscoverFn = (options?: DiscoverOptions) => Promise<DiscoveryInput>;
 
 // The node_modules scan is filesystem work that never changes within a process,
 // so it runs once and the result is memoized. A long-lived daemon pays one scan
 // at first bespoke instantiation; every later run reuses it. The trust gate is
 // boot config, so the env from the first scan stands for the process.
-let discoveredCache: Discovery | null = null;
-const providerPackages = async (discoverFn: DiscoverFn, env: NodeJS.ProcessEnv): Promise<Discovery> => {
+let discoveredCache: DiscoveryInput | null = null;
+const providerPackages = async (discoverFn: DiscoverFn, env: NodeJS.ProcessEnv): Promise<DiscoveryInput> => {
     discoveredCache ??= await discoverFn({ env });
     return discoveredCache;
 };
@@ -54,7 +61,7 @@ export const instantiateProvider = async (
     if (catalog !== null) return catalog;
     if (name === "ollama") return ollamaProviderFromEnv(env, model, baseUrl === undefined ? undefined : { baseUrl });
     if (name === "openai" || name === "plurnk") return compatibleProviderFromEnv(name, env, model, baseUrl);
-    const { registry, skipped } = await providerPackages(discoverFn, env);
+    const { registry, skipped, packageAttributions = new Map() } = await providerPackages(discoverFn, env);
     const specifier = registry.get(name);
     if (specifier === undefined) {
         const declined = skipped.get(name);
@@ -80,12 +87,18 @@ export const instantiateProvider = async (
     if (contextWindow === null) {
         throw new Error(`${specifier}: PLURNK_PROVIDERS_CONTEXT_WINDOW must be set because Models.dev has no metadata for provider "${name}"`);
     }
+    const declared = packageAttributions.get(specifier) ?? [];
+    const attributions = (context: PluginAttributionContext): PluginAttribution => Meta.composeAttributions(
+        declared,
+        Meta.runtimeAttribution(sdkProvider, context, specifier),
+    );
     return providerFromSdkModel({
         name,
         env,
         model,
         languageModel: sdkProvider.languageModel(model),
         contextWindow,
+        attributions,
     });
 };
 

package/src/accounting.test.ts

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { authoritativeChargeNormalizer } from "./accounting.ts";
+
+const evidence = ({ providerMetadata, usage }: { providerMetadata?: unknown; usage?: unknown }) => ({
+    ...(providerMetadata === undefined ? {} : { providerMetadata }),
+    ...(usage === undefined ? {} : { usage }),
+    response: { id: "response-1" },
+});
+
+test("xAI response ticks normalize to an exact provider-authoritative charge", () => {
+    const normalize = authoritativeChargeNormalizer("@ai-sdk/xai");
+    assert.notEqual(normalize, undefined);
+    assert.deepEqual(normalize!(evidence({ usage: { cost_in_usd_ticks: 15_493_500 } })), {
+        kind: "authoritative",
+        amount: { amount: "15493500", currency: "USDTICK" },
+        usdEquivalent: "0.00154935",
+        source: "xAI response usage.cost_in_usd_ticks",
+    });
+});
+
+test("OpenRouter response cost normalizes without rate reconstruction", () => {
+    const normalize = authoritativeChargeNormalizer("@openrouter/ai-sdk-provider");
+    assert.notEqual(normalize, undefined);
+    assert.deepEqual(normalize!(evidence({ providerMetadata: { openrouter: { usage: { cost: 3.2e-7 } } } })), {
+        kind: "authoritative",
+        amount: { amount: "0.00000032", currency: "USD" },
+        usdEquivalent: "0.00000032",
+        source: "OpenRouter response usage.cost",
+    });
+});
+
+test("DeepInfra's documented response estimate wins over local rate reconstruction", () => {
+    const normalize = authoritativeChargeNormalizer("@ai-sdk/deepinfra");
+    assert.notEqual(normalize, undefined);
+    assert.deepEqual(normalize!(evidence({ usage: { estimated_cost: 5.04e-5 } })), {
+        kind: "authoritative",
+        amount: { amount: "0.0000504", currency: "USD" },
+        usdEquivalent: "0.0000504",
+        source: "DeepInfra response usage.estimated_cost",
+    });
+});
+
+test("response cost normalization is an explicit adapter capability", () => {
+    assert.equal(authoritativeChargeNormalizer("@ai-sdk/anthropic"), undefined);
+    assert.equal(
+        authoritativeChargeNormalizer("@ai-sdk/xai")!(evidence({ usage: {} })),
+        undefined,
+    );
+    assert.throws(
+        () => authoritativeChargeNormalizer("@ai-sdk/xai")!(evidence({ usage: { cost_in_usd_ticks: "1" } })),
+        /cost_in_usd_ticks must be numeric/,
+    );
+    assert.throws(
+        () => authoritativeChargeNormalizer("@ai-sdk/deepinfra")!(evidence({ usage: { estimated_cost: "1" } })),
+        /estimated_cost must be numeric/,
+    );
+});

package/src/accounting.ts

@@ -0,0 +1,88 @@
+import type {
+    AuthoritativeChargeNormalizer,
+} from "./types.ts";
+
+const recordOf = (value: unknown): Record<string, unknown> | null =>
+    typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : null;
+
+const decimalFromNumber = (value: number, subject: string): string => {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${subject} must be a finite non-negative number`);
+    }
+    const source = String(value);
+    if (!/[eE]/.test(source)) return source;
+    const [coefficient, exponentSource] = source.toLowerCase().split("e");
+    const exponent = Number(exponentSource);
+    const [integer, fraction = ""] = coefficient!.split(".");
+    const digits = `${integer}${fraction}`;
+    const point = integer!.length + exponent;
+    if (point <= 0) return `0.${"0".repeat(-point)}${digits}`;
+    if (point >= digits.length) return `${digits}${"0".repeat(point - digits.length)}`;
+    return `${digits.slice(0, point)}.${digits.slice(point)}`;
+};
+
+const usdFromTicks = (ticks: number): string => {
+    if (!Number.isSafeInteger(ticks) || ticks < 0) {
+        throw new TypeError("xAI costInUsdTicks must be a non-negative safe integer");
+    }
+    const digits = String(ticks).padStart(11, "0");
+    const integer = digits.slice(0, -10).replace(/^0+(?=\d)/, "");
+    const fraction = digits.slice(-10).replace(/0+$/, "");
+    return fraction === "" ? integer : `${integer}.${fraction}`;
+};
+
+const xaiCharge: AuthoritativeChargeNormalizer = ({ usage }) => {
+    const wireUsage = recordOf(usage);
+    if (wireUsage === null || !("cost_in_usd_ticks" in wireUsage)) return undefined;
+    const ticks = wireUsage.cost_in_usd_ticks;
+    if (typeof ticks !== "number") {
+        throw new TypeError("xAI usage.cost_in_usd_ticks must be numeric");
+    }
+    return {
+        kind: "authoritative",
+        amount: { amount: String(ticks), currency: "USDTICK" },
+        usdEquivalent: usdFromTicks(ticks),
+        source: "xAI response usage.cost_in_usd_ticks",
+    };
+};
+
+const openRouterCharge: AuthoritativeChargeNormalizer = ({ providerMetadata }) => {
+    const usage = recordOf(recordOf(recordOf(providerMetadata)?.openrouter)?.usage);
+    if (usage === null || !("cost" in usage)) return undefined;
+    const cost = usage.cost;
+    if (typeof cost !== "number") throw new TypeError("OpenRouter usage.cost must be numeric");
+    const amount = decimalFromNumber(cost, "OpenRouter usage.cost");
+    return {
+        kind: "authoritative",
+        amount: { amount, currency: "USD" },
+        usdEquivalent: amount,
+        source: "OpenRouter response usage.cost",
+    };
+};
+
+const deepInfraCharge: AuthoritativeChargeNormalizer = ({ usage }) => {
+    const wireUsage = recordOf(usage);
+    if (wireUsage === null || !("estimated_cost" in wireUsage)) return undefined;
+    const cost = wireUsage.estimated_cost;
+    if (typeof cost !== "number") throw new TypeError("DeepInfra usage.estimated_cost must be numeric");
+    const amount = decimalFromNumber(cost, "DeepInfra usage.estimated_cost");
+    return {
+        kind: "authoritative",
+        amount: { amount, currency: "USD" },
+        usdEquivalent: amount,
+        source: "DeepInfra response usage.estimated_cost",
+    };
+};
+
+export const authoritativeChargeNormalizer = (
+    sdkPackage: string,
+): AuthoritativeChargeNormalizer | undefined => {
+    switch (sdkPackage) {
+        case "@ai-sdk/xai": return xaiCharge;
+        case "@ai-sdk/deepinfra": return deepInfraCharge;
+        case "@openrouter/ai-sdk-provider": return openRouterCharge;
+        default: return undefined;
+    }
+};

package/src/aiSdkTransport.ts

@@ -1,7 +1,8 @@
 import { createOpenAICompatible, type ProviderErrorStructure } from "@ai-sdk/openai-compatible";
-import { generateText, streamText, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
+import { APICallError, generateText, streamText, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
+import { prepareRetries } from "ai/internal";
 import { z } from "zod/v4";
-import type { ChatMessage, FinishReason, ProviderUsage, TokenLogprob } from "./types.ts";
+import type { ChatMessage, ProviderAttemptFinishReason, ProviderChargeEvidence, ProviderUsage, TokenLogprob } from "./types.ts";
 import { normalizeUsage, type RawUsage } from "./usage.ts";
 import { emitWarningOnce } from "./warnings.ts";
 
@@ -66,7 +67,15 @@ const wireUsageOf = (
     return null;
 };
 
-const finishReasonOf = (reason: string | undefined): FinishReason => {
+const wireUsageEvidenceOf = (values: readonly unknown[]): unknown => {
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        const record = recordOf(values[index]);
+        if (record !== null && record.usage !== undefined) return record.usage;
+    }
+    return undefined;
+};
+
+const finishReasonOf = (reason: string | undefined): ProviderAttemptFinishReason => {
     switch (reason?.toLowerCase()) {
         case "stop":
         case "completed":
@@ -86,6 +95,8 @@ const finishReasonOf = (reason: string | undefined): FinishReason => {
         case "safety":
         case "recitation":
             return "content_filter";
+        case "insufficient_system_resource":
+            return "resource_interrupted";
         default:
             if (reason !== undefined && reason.length > 0) {
                 emitWarningOnce(
@@ -133,7 +144,9 @@ export type AiSdkTransportResponse = {
     model: string;
     content: string;
     reasoning: string;
-    finishReason: FinishReason;
+    reasoningProjected: boolean;
+    finishReason: ProviderAttemptFinishReason;
+    rawFinishReason?: string;
     usage: ProviderUsage;
     metadata: Record<string, unknown>;
     reasoningEncrypted: Array<{
@@ -142,6 +155,7 @@ export type AiSdkTransportResponse = {
         encrypted: Array<{ data: string; format: string | null }>;
     }>;
     logprobs: TokenLogprob[];
+    chargeEvidence: ProviderChargeEvidence;
     rawBody?: unknown;
 };
 
@@ -159,8 +173,46 @@ export type AiSdkModelRequest = Omit<AiSdkTransportRequest, "url" | "model" | "b
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "none" | "provider-default";
 };
 
+const isStreamIdleTimeout = (cause: unknown): cause is Error | DOMException =>
+    typeof cause === "object"
+    && cause !== null
+    && (cause as { name?: string }).name === "TimeoutError"
+    && /chunk timeout/i.test(String((cause as { message?: unknown }).message ?? ""));
+
 const executeModel = async (
     request: AiSdkModelRequest,
+): Promise<AiSdkTransportResponse> => {
+    const timeoutSignal = AbortSignal.timeout(request.fetchTimeoutMs);
+    const operationSignal = request.signal === undefined
+        ? timeoutSignal
+        : AbortSignal.any([request.signal, timeoutSignal]);
+    const { retry } = prepareRetries({
+        maxRetries: request.retryAttempts,
+        abortSignal: operationSignal,
+    });
+    return retry(async () => {
+        try {
+            return await executeModelOnce({
+                ...request,
+                signal: operationSignal,
+                retryAttempts: 0,
+            });
+        } catch (cause) {
+            if (operationSignal.aborted) throw operationSignal.reason;
+            if (!isStreamIdleTimeout(cause)) throw cause;
+            throw new APICallError({
+                message: cause.message,
+                url: "model:generation",
+                requestBodyValues: {},
+                cause,
+                isRetryable: true,
+            });
+        }
+    });
+};
+
+const executeModelOnce = async (
+    request: AiSdkModelRequest,
 ): Promise<AiSdkTransportResponse> => {
     const {
         languageModel: model,
@@ -223,17 +275,33 @@ const executeModel = async (
         const rawBody = result.response.body;
         const values = [rawBody];
         const evidence = extractEvidence(values);
+        const accountingUsage = wireUsageEvidenceOf(values);
         const reasoningText = evidence.reasoning || result.reasoningText || "";
+        const rawFinishReason = result.rawFinishReason;
         return {
             model: result.response.modelId,
             content: result.text,
             reasoning: reasoningText,
-            finishReason: finishReasonOf(result.rawFinishReason),
+            reasoningProjected: evidence.reasoningProjected,
+            finishReason: finishReasonOf(rawFinishReason),
+            ...(rawFinishReason === undefined ? {} : { rawFinishReason }),
             usage: wireUsageOf(values, reasoningText, result.text)
                 ?? usageOf(result.usage, reasoningText, result.text),
             metadata: metadataOf(values),
             reasoningEncrypted: evidence.reasoningEncrypted,
             logprobs: evidence.logprobs,
+            chargeEvidence: {
+                ...(accountingUsage === undefined ? {} : { usage: accountingUsage }),
+                ...(result.providerMetadata === undefined
+                    ? {}
+                    : { providerMetadata: result.providerMetadata }),
+                response: {
+                    id: result.response.id,
+                    ...(result.response.headers === undefined
+                        ? {}
+                        : { headers: result.response.headers }),
+                },
+            },
             ...(request.captureRawBody ? { rawBody } : {}),
         };
     }
@@ -251,18 +319,34 @@ const executeModel = async (
     }
     if (streamError !== undefined) throw streamError;
     const evidence = extractEvidence(rawChunks);
+    const accountingUsage = wireUsageEvidenceOf(rawChunks);
     const content = await result.text;
     const reasoningText = evidence.reasoning || (await result.reasoningText) || "";
+    const rawFinishReason = await result.rawFinishReason;
+    const [response, providerMetadata] = await Promise.all([
+        result.response,
+        result.providerMetadata,
+    ]);
     return {
-        model: (await result.response).modelId,
+        model: response.modelId,
         content,
         reasoning: reasoningText,
-        finishReason: finishReasonOf(await result.rawFinishReason),
+        reasoningProjected: evidence.reasoningProjected,
+        finishReason: finishReasonOf(rawFinishReason),
+        ...(rawFinishReason === undefined ? {} : { rawFinishReason }),
         usage: wireUsageOf(rawChunks, reasoningText, content)
             ?? usageOf(await result.usage, reasoningText, content),
         metadata: metadataOf(rawChunks),
         reasoningEncrypted: evidence.reasoningEncrypted,
         logprobs: evidence.logprobs,
+        chargeEvidence: {
+            ...(accountingUsage === undefined ? {} : { usage: accountingUsage }),
+            ...(providerMetadata === undefined ? {} : { providerMetadata }),
+            response: {
+                id: response.id,
+                ...(response.headers === undefined ? {} : { headers: response.headers }),
+            },
+        },
         ...(request.captureRawBody ? { rawBody: rawChunks } : {}),
     };
 };
@@ -305,10 +389,12 @@ const extractEvidence = (values: unknown[]): {
     reasoningEncrypted: AiSdkTransportResponse["reasoningEncrypted"];
     logprobs: TokenLogprob[];
     reasoning: string;
+    reasoningProjected: boolean;
 } => {
     const encrypted = new Map<string, AiSdkTransportResponse["reasoningEncrypted"][number]>();
     const logprobs: TokenLogprob[] = [];
     let reasoning = "";
+    let reasoningProjected = false;
     let anonymous = 0;
     for (const value of values) {
         const choices = recordOf(value)?.choices;
@@ -336,7 +422,10 @@ const extractEvidence = (values: unknown[]): {
         }
         const message = recordOf(choice.delta) ?? recordOf(choice.message) ?? {};
         for (const key of ["reasoning_content", "reasoning", "thinking"]) { // lexicon-allow: backend wire fields
-            if (typeof message[key] === "string") reasoning += message[key];
+            if (typeof message[key] === "string") {
+                reasoningProjected = true;
+                reasoning += message[key];
+            }
         }
         if (!Array.isArray(message.reasoning_details)) continue;
         for (const value of message.reasoning_details) {
@@ -348,6 +437,9 @@ const extractEvidence = (values: unknown[]): {
                 : id === null ? `anonymous:${anonymous++}` : `id:${id}`;
             const item: AiSdkTransportResponse["reasoningEncrypted"][number] = encrypted.get(key) ?? {
                 id,
+                // {§provider-encrypted-reasoning} The documented wire location
+                // is the assistant message. `id` above still identifies only
+                // this provider detail, never a downstream message entity.
                 subtype: "message",
                 encrypted: [],
             };
@@ -366,5 +458,6 @@ const extractEvidence = (values: unknown[]): {
         reasoningEncrypted: [...encrypted.values()],
         logprobs,
         reasoning,
+        reasoningProjected,
     };
 };