@plurnk/plurnk-providers 1.3.12 → 1.4.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/aiSdkTransport.ts

@@ -1,7 +1,7 @@
 import { createOpenAICompatible, type ProviderErrorStructure } from "@ai-sdk/openai-compatible";
 import { generateText, streamText, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
 import { z } from "zod/v4";
-import type { ChatMessage, FinishReason, ProviderUsage, TokenLogprob } from "./types.ts";
+import type { ChatMessage, ProviderAttemptFinishReason, ProviderUsage, TokenLogprob } from "./types.ts";
 import { normalizeUsage, type RawUsage } from "./usage.ts";
 import { emitWarningOnce } from "./warnings.ts";
 
@@ -66,7 +66,7 @@ const wireUsageOf = (
     return null;
 };
 
-const finishReasonOf = (reason: string | undefined): FinishReason => {
+const finishReasonOf = (reason: string | undefined): ProviderAttemptFinishReason => {
     switch (reason?.toLowerCase()) {
         case "stop":
         case "completed":
@@ -86,6 +86,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 +135,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<{
@@ -224,11 +228,14 @@ const executeModel = async (
         const values = [rawBody];
         const evidence = extractEvidence(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),
@@ -253,11 +260,14 @@ const executeModel = async (
     const evidence = extractEvidence(rawChunks);
     const content = await result.text;
     const reasoningText = evidence.reasoning || (await result.reasoningText) || "";
+    const rawFinishReason = await result.rawFinishReason;
     return {
         model: (await result.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),
@@ -305,10 +315,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 +348,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 +363,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 +384,6 @@ const extractEvidence = (values: unknown[]): {
         reasoningEncrypted: [...encrypted.values()],
         logprobs,
         reasoning,
+        reasoningProjected,
     };
 };

package/src/boundaries.test.ts

@@ -19,17 +19,22 @@ test("provider source does not import the service or database", () => {
 test("provider source does not import the PLURNK parser", () => {
     for (const file of sourceFiles()) {
         const source = readFileSync(join(root, file), "utf8");
-        assert.ok(!/from\s+["']@plurnk\/plurnk-grammar/.test(source), `${file} imports the parser`);
+        assert.ok(
+            !/from\s+["']@plurnk\/plurnk-contracts\/grammar["']/.test(source),
+            `${file} imports the parser rather than the runtime-neutral contracts entrypoint`,
+        );
     }
 });
 
-test("#608: the OpenAI-compatible entrypoint excludes Node-owned provider machinery", () => {
+test("the OpenAI-compatible entrypoint excludes Node-owned provider machinery", () => {
     const allowed = new Set([
         "AiSdkProvider.ts",
         "aiSdkTransport.ts",
         "env.ts",
+        "errors.ts",
+        "notices.ts",
         "openai.ts",
-        "telemetry.ts",
+        "promptTokens.ts",
         "types.ts",
         "usage.ts",
         "warnings.ts",

package/src/catalogProvider.test.ts

@@ -15,6 +15,7 @@ const env = {
     PLURNK_PROVIDERS_REASONING_RESERVE: "10%",
     PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%",
     PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
+    PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT: "512",
     PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
 };
 
@@ -39,6 +40,22 @@ test("catalog provider resolves model physics and Models.dev USD rates", () => {
     }) ?? 0) > 0);
 });
 
+test("an operator context window caps catalog physics and percentage reserves derive from the cap", () => {
+    const provider = catalogProviderFromEnv("openai", {
+        ...env,
+        PLURNK_PROVIDERS_CONTEXT_WINDOW: "128000",
+    }, "gpt-4.1-mini");
+    assert.equal(provider?.contextWindow, 128_000);
+    assert.equal(provider?.reasoningReserve, 16_000);
+    assert.equal(provider?.completionReserve, 32_000);
+
+    const oversized = catalogProviderFromEnv("openai", {
+        ...env,
+        PLURNK_PROVIDERS_CONTEXT_WINDOW: "2000000",
+    }, "gpt-4.1-mini");
+    assert.equal(oversized?.contextWindow, 1_047_576, "an operator ceiling cannot enlarge model physics");
+});
+
 test("official AI SDK provider owns the native request while PLURNK owns call settings", async () => {
     const calls: Array<{ url: string; body: Record<string, unknown> }> = [];
     mock.method(globalThis, "fetch", async (input: string | URL | Request, init?: RequestInit) => {

package/src/catalogProvider.ts

@@ -1,23 +1,27 @@
 import { lookupProvider, resolveModel, type ModelInfo } from "@plurnk/plurnk-models";
 import {
     contextWindowFromEnv,
+    effectiveContextWindow,
     dataCaptureFromEnv,
     envelopeFromEnv,
     parseRequiredFloat,
     parseRequiredInt,
     promptCacheKeyFromEnv,
     reasoningFromEnv,
+    reasoningResponseStyleFromEnv,
     resolveReserve,
     tokenRatesFromEnv,
     type ReserveSpec,
 } from "./env.ts";
 import AiSdkProvider, { type ReasoningStyle } from "./AiSdkProvider.ts";
 import { configuredProviderInfo, createSdkModel } from "./sdkModels.ts";
-import { providerSource } from "./telemetry.ts";
+import { providerSource } from "./notices.ts";
 import type { Provider, ProviderUsage } from "./types.ts";
 import { calculateCostUsd } from "./usage.ts";
 import { emitWarningOnce } from "./warnings.ts";
 import type { LanguageModel } from "ai";
+import type { PluginAttribution, PluginAttributionContext } from "@plurnk/plurnk-meta";
+import type { ProviderCost } from "@plurnk/plurnk-contracts";
 
 const reasoningStyleFromEnv = (
     env: NodeJS.ProcessEnv,
@@ -28,7 +32,7 @@ const reasoningStyleFromEnv = (
     if (value === undefined || value.length === 0) return undefined;
     const styles: readonly ReasoningStyle[] = [
         "none", "think", "include_reasoning", "effort",
-        "effort_explicit", "template", "anthropic",
+        "effort_explicit", "thinking_effort", "template", "anthropic",
     ];
     if (!styles.includes(value as ReasoningStyle)) {
         throw new Error(`${name} provider: PLURNK_PROVIDERS_PROVIDER_${prefix}_REASONING_STYLE has invalid value "${value}"`);
@@ -45,6 +49,7 @@ export const providerFromSdkModel = ({
     headers,
     contextWindow,
     info,
+    attributions,
 }: {
     name: string;
     env: NodeJS.ProcessEnv;
@@ -54,10 +59,11 @@ export const providerFromSdkModel = ({
     headers?: Readonly<Record<string, string>>;
     contextWindow: number;
     info?: ModelInfo;
+    attributions?: (context: PluginAttributionContext) => PluginAttribution;
 }): Provider => {
     emitWarningOnce(
-        `${name} provider: countTokens is a chars/2 upper bound — exact counts come from the mimetypes tokenizer seam or tokenize()`,
-        "PLURNK_TOKENIZER_HEURISTIC",
+        `${name} provider: physical prompt counting is a chars/2 estimate; over-policy recovery fails closed without exact or bounded request evidence`,
+        "PLURNK_PROMPT_COUNT_ESTIMATE",
     );
 
     const reasoning = reasoningFromEnv(env, name);
@@ -86,9 +92,20 @@ export const providerFromSdkModel = ({
     const calculateCost = rates === null
         ? undefined
         : (usage: ProviderUsage): number => calculateCostUsd(usage, rates);
+    const rateSource = configuredRates === null ? "Models.dev catalog rates" : "operator-configured rates";
+    const calculateCharge: (usage: ProviderUsage) => Exclude<ProviderCost, { kind: "authoritative" }> = rates === null
+        ? () => ({ kind: "unknown", reason: "no provider rate or settled charge is available" })
+        : rates.input === 0 && rates.output === 0 && rates.cached === 0
+            ? () => ({ kind: "free", source: rateSource })
+            : (usage: ProviderUsage) => ({
+                kind: "estimated",
+                usd: String(calculateCostUsd(usage, rates)),
+                source: rateSource,
+            });
 
     return new AiSdkProvider({
         model,
+        ...(attributions === undefined ? {} : { attributions }),
         ...(languageModel === undefined ? {} : { languageModel }),
         ...(url === undefined ? {} : { url }),
         ...(headers === undefined ? {} : { headers: { ...headers } }),
@@ -96,16 +113,19 @@ export const providerFromSdkModel = ({
         fetchTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "PLURNK_PROVIDERS_FETCH_TIMEOUT", name),
         streamIdleTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", name),
         reasoning,
+        reasoningResponseStyle: reasoningResponseStyleFromEnv(env, name),
         temperature: parseRequiredFloat(env.PLURNK_PROVIDERS_TEMPERATURE, "PLURNK_PROVIDERS_TEMPERATURE", name, 0),
         repeatPenalty: parseRequiredFloat(env.PLURNK_PROVIDERS_REPEAT_PENALTY, "PLURNK_PROVIDERS_REPEAT_PENALTY", name, 0),
         frequencyPenalty: parseRequiredFloat(env.PLURNK_PROVIDERS_FREQUENCY_PENALTY, "PLURNK_PROVIDERS_FREQUENCY_PENALTY", name, 0),
         reasoningReserve,
         completionReserve,
         retryAttempts: parseRequiredInt(env.PLURNK_PROVIDERS_RETRY_ATTEMPTS, "PLURNK_PROVIDERS_RETRY_ATTEMPTS", name),
+        errorDetailLimit: parseRequiredInt(env.PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT, "PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT", name),
         reasoningStyle: reasoningStyleFromEnv(env, name),
         promptCacheKey: url === undefined ? false : promptCacheKeyFromEnv(env, name),
         serviceTier: env.PLURNK_PROVIDERS_SERVICE_TIER,
         calculateCost,
+        calculateCharge,
         source: providerSource(name),
         gbnfDebug: env.PLURNK_PROVIDERS_GBNF_DEBUG !== undefined
             && env.PLURNK_PROVIDERS_GBNF_DEBUG !== ""
@@ -133,13 +153,8 @@ export const catalogProviderFromEnv = (
     const sdk = createSdkModel(name, wireModel, env, baseUrlOverride);
     if (sdk === null) return null;
 
-    emitWarningOnce(
-        `${name} provider: countTokens is a chars/2 upper bound — exact counts come from the mimetypes tokenizer seam or tokenize()`,
-        "PLURNK_TOKENIZER_HEURISTIC",
-    );
-
     const info = resolved?.info;
-    const contextWindow = contextOverride ?? info?.contextWindow ?? null;
+    const contextWindow = effectiveContextWindow(contextOverride, info?.contextWindow ?? null);
     if (contextWindow === null) {
         throw new Error(
             `${name} provider: context window unresolved for "${wireModel}" — set PLURNK_PROVIDERS_CONTEXT_WINDOW or update the Models.dev snapshot`,