@plurnk/plurnk-providers 1.7.0 → 1.8.0

package/src/aiSdkTransport.ts

@@ -1,5 +1,5 @@
 import { createOpenAICompatible, type ProviderErrorStructure } from "@ai-sdk/openai-compatible";
-import { APICallError, generateText, streamText, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
+import { APICallError, generateText, streamText, type CallWarning, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
 import { z } from "zod/v4";
 import type { ChatMessage, ProviderAttemptFinishReason, ProviderChargeEvidence, ProviderUsage, TokenLogprob } from "./types.ts";
 import { normalizeUsage, type RawUsage } from "./usage.ts";
@@ -176,6 +176,7 @@ export type AiSdkTransportResponse = {
     logprobs: TokenLogprob[];
     chargeEvidence: ProviderChargeEvidence;
     rawBody?: unknown;
+    warnings: readonly CallWarning[];
 };
 
 export type AiSdkModelRequest = Omit<AiSdkTransportRequest, "url" | "model" | "body" | "fetch"> & {
@@ -221,11 +222,32 @@ const transportTimeout = (
 
 const streamFailureValues = new WeakMap<object, readonly unknown[]>();
 
-const applyRetryDirective = (error: unknown): unknown => {
-    if (!APICallError.isInstance(error)) return error;
+const retainStreamFailureValues = <T extends object>(source: object, target: T): T => {
+    const values = streamFailureValues.get(source);
+    if (values !== undefined) streamFailureValues.set(target, values);
+    return target;
+};
+
+const normalizeRetryAttemptError = (error: unknown): unknown => {
+    if (!APICallError.isInstance(error)) {
+        // Node's Undici stream reader reports a peer-aborted HTTP/2 body as this
+        // raw TypeError after headers have arrived. Normalize it at the attempt
+        // boundary so the owned scheduler sees the same retryability that the
+        // public ProviderError contract would otherwise assign too late.
+        if (error instanceof TypeError && error.message.trim().toLowerCase() === "terminated") {
+            return retainStreamFailureValues(error, new APICallError({
+                message: error.message,
+                url: "model:generation",
+                requestBodyValues: {},
+                cause: error,
+                isRetryable: true,
+            }));
+        }
+        return error;
+    }
     const directed = retryDirective(error.statusCode, error.responseHeaders ?? {});
     if (directed === null || directed === error.isRetryable) return error;
-    return new APICallError({
+    return retainStreamFailureValues(error, new APICallError({
         message: error.message,
         url: error.url,
         requestBodyValues: error.requestBodyValues,
@@ -235,7 +257,7 @@ const applyRetryDirective = (error: unknown): unknown => {
         cause: error,
         isRetryable: directed,
         data: error.data,
-    });
+    }));
 };
 
 const executeModel = async (
@@ -246,7 +268,7 @@ const executeModel = async (
     } catch (cause) {
         if (request.signal?.aborted) throw request.signal.reason;
         const timeout = transportTimeout(cause, request);
-        if (timeout === null) throw applyRetryDirective(cause);
+        if (timeout === null) throw normalizeRetryAttemptError(cause);
         throw new APICallError({
             message: timeout.message,
             url: "model:generation",
@@ -364,6 +386,7 @@ const executeModelOnce = async (
                 },
             },
             ...(request.captureRawBody ? { rawBody } : {}),
+            warnings: result.warnings ?? [],
         };
     }
 
@@ -389,9 +412,10 @@ const executeModelOnce = async (
     const content = await result.text;
     const reasoningText = evidence.reasoning || (await result.reasoningText) || "";
     const rawFinishReason = await result.rawFinishReason;
-    const [response, providerMetadata] = await Promise.all([
+    const [response, providerMetadata, warnings] = await Promise.all([
         result.response,
         result.providerMetadata,
+        result.warnings,
     ]);
     return {
         model: response.modelId,
@@ -416,6 +440,7 @@ const executeModelOnce = async (
             },
         },
         ...(request.captureRawBody ? { rawBody: rawChunks } : {}),
+        warnings: warnings ?? [],
     };
 };
 

package/src/catalogProvider.test.ts

@@ -2,7 +2,8 @@ import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
 import { once } from "node:events";
 import { createServer } from "node:http";
-import { catalogProviderFromEnv } from "./catalogProvider.ts";
+import { catalogProviderFromEnv, providerFromSdkModel } from "./catalogProvider.ts";
+import type { LanguageModel } from "ai";
 import { resetEmittedWarnings } from "./warnings.ts";
 
 const env = {
@@ -37,6 +38,48 @@ test("catalog provider resolves model physics and Models.dev USD rates", () => {
     assert.equal(provider?.maxOutputTokens, 32_768);
     assert.equal(provider?.outputBudget, 32_768);
     assert.equal(provider?.reasoningBudget, null);
+    assert.deepEqual(provider?.supportedReasoningPolicies, ["off", "adaptive"]);
+});
+
+test("provider adapters advertise only reasoning policies they can preserve", () => {
+    const deepseek = catalogProviderFromEnv("deepseek", {
+        ...env,
+        DEEPSEEK_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+        PLURNK_PROVIDERS_PROVIDER_DEEPSEEK_REASONING_STYLE: "thinking_effort",
+    }, "deepseek-v4-flash");
+    assert.deepEqual(deepseek?.supportedReasoningPolicies, ["off", "adaptive", "high"]);
+
+    assert.throws(
+        () => catalogProviderFromEnv("deepseek", {
+            ...env,
+            DEEPSEEK_API_KEY: "test-key",
+            PLURNK_PROVIDERS_REASONING: "medium",
+            PLURNK_PROVIDERS_PROVIDER_DEEPSEEK_REASONING_STYLE: "thinking_effort",
+        }, "deepseek-v4-flash"),
+        /reasoning policy 'medium' is unsupported; supported policies: off, adaptive, high/,
+    );
+
+    const mistral = catalogProviderFromEnv("mistral", {
+        ...env,
+        MISTRAL_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "mistral-small-latest");
+    assert.deepEqual(mistral?.supportedReasoningPolicies, ["off", "adaptive", "high"], "Mistral's low/medium coercion is not advertised as exact support");
+
+    const grok = catalogProviderFromEnv("xai", {
+        ...env,
+        XAI_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "grok-4.6");
+    assert.deepEqual(grok?.supportedReasoningPolicies, ["adaptive", "low", "medium", "high"], "Grok 4.6 cannot disable reasoning");
+
+    const gemini = catalogProviderFromEnv("google", {
+        ...env,
+        GEMINI_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "gemini-3.7-flash");
+    assert.deepEqual(gemini?.supportedReasoningPolicies, ["adaptive", "low", "medium", "high"], "Gemini 3's mandatory minimum is not advertised as off");
 });
 
 test("an operator context window caps catalog physics and percentage output policy", () => {
@@ -110,7 +153,7 @@ test("official AI SDK provider owns the native request while PLURNK owns call se
     assert.equal(calls[0]?.body.prompt_cache_key, "worker", "the official OpenAI SDK projects the documented affinity key");
 });
 
-test("xAI's native chat contract caps the complete reasoning response", async () => {
+test("xAI's native chat contract affirmatively requests adaptive high and caps the complete reasoning response", async () => {
     let call: { headers: Headers; body: Record<string, unknown> } | undefined;
     mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
         call = {
@@ -122,21 +165,21 @@ test("xAI's native chat contract caps the complete reasoning response", async ()
                 id: "response-xai",
                 object: "chat.completion.chunk",
                 created: 1,
-                model: "grok-build-0.1",
+                model: "grok-4.6",
                 choices: [{ index: 0, delta: { reasoning_content: "consider" }, finish_reason: null }],
             })}`,
             `data: ${JSON.stringify({
                 id: "response-xai",
                 object: "chat.completion.chunk",
                 created: 2,
-                model: "grok-build-0.1",
+                model: "grok-4.6",
                 choices: [{ index: 0, delta: { content: "OK" }, finish_reason: "stop" }],
             })}`,
             `data: ${JSON.stringify({
                 id: "response-xai",
                 object: "chat.completion.chunk",
                 created: 3,
-                model: "grok-build-0.1",
+                model: "grok-4.6",
                 choices: [],
                 usage: {
                     prompt_tokens: 5,
@@ -155,7 +198,7 @@ test("xAI's native chat contract caps the complete reasoning response", async ()
         ...env,
         XAI_API_KEY: "test-key",
         PLURNK_PROVIDERS_REASONING: "adaptive",
-    }, "grok-build-0.1");
+    }, "grok-4.6");
     const result = await provider?.generate({
         workerId: "xai-worker",
         messages: [{ role: "user", content: "hello" }],
@@ -163,6 +206,7 @@ test("xAI's native chat contract caps the complete reasoning response", async ()
     });
 
     assert.equal(call?.body.max_completion_tokens, 16);
+    assert.equal(call?.body.reasoning_effort, "high", "adaptive is affirmative on xAI's graded route");
     assert.equal("max_tokens" in (call?.body ?? {}), false);
     assert.equal(call?.headers.get("x-grok-conv-id"), "xai-worker");
     assert.equal(result?.assistant.reasoning, "consider");
@@ -221,14 +265,14 @@ test("Cerebras explicit reasoning activation needs no operator effort or token b
     const provider = catalogProviderFromEnv("cerebras", {
         ...env,
         CEREBRAS_API_KEY: "test-key",
-        PLURNK_PROVIDERS_REASONING: "on",
+        PLURNK_PROVIDERS_REASONING: "high",
     }, "gemma-4-31b");
     const result = await provider?.generate({
         workerId: "worker",
         messages: [{ role: "user", content: "hello" }],
     });
 
-    assert.equal(body?.reasoning_effort, "medium", "the native SDK projects unqualified on to its enabled posture");
+    assert.equal(body?.reasoning_effort, "high", "the native SDK preserves the explicit durable effort");
     assert.equal("thinking_budget_tokens" in (body ?? {}), false, "activation does not invent a token budget");
     assert.equal(result?.assistant.reasoning, "consider");
     assert.equal(result?.accounting[0]?.usage?.outputTokenDetails?.reasoningTokens, 1);
@@ -236,7 +280,7 @@ test("Cerebras explicit reasoning activation needs no operator effort or token b
 
 test("Google adaptive reasoning requests and preserves readable thought summaries", async () => {
     const bodies: Array<{
-        generationConfig?: { thinkingConfig?: { includeThoughts?: boolean } };
+        generationConfig?: { thinkingConfig?: { includeThoughts?: boolean; thinkingLevel?: string; thinkingBudget?: number } };
     }> = [];
     mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
         bodies.push(JSON.parse(String(init?.body)) as typeof bodies[number]);
@@ -275,25 +319,109 @@ test("Google adaptive reasoning requests and preserves readable thought summarie
 
     assert.deepEqual(bodies[0]?.generationConfig?.thinkingConfig, {
         includeThoughts: true,
-    }, "adaptive leaves thinking depth to Google while requesting its readable summary");
+        thinkingLevel: "high",
+    }, "Gemini 3 adaptive selects its documented high/dynamic posture and readable summary");
     assert.equal(result?.assistant.reasoning, "consider");
     assert.equal(result?.assistant.content, "done");
     assert.equal(result?.accounting[0]?.usage?.outputTokenDetails?.reasoningTokens, 1);
 
-    const disabled = catalogProviderFromEnv("google", {
+    assert.throws(
+        () => catalogProviderFromEnv("google", {
+            ...env,
+            GEMINI_API_KEY: "test-key",
+            PLURNK_PROVIDERS_REASONING: "off",
+        }, "gemini-3.7-flash"),
+        /reasoning policy 'off' is unsupported/,
+        "Gemini 3's mandatory minimum thinking is not mislabeled as off",
+    );
+
+    const dynamic25 = catalogProviderFromEnv("google", {
         ...env,
         GEMINI_API_KEY: "test-key",
-        PLURNK_PROVIDERS_REASONING: "off",
-    }, "gemini-3.7-flash");
-    await disabled?.generate({
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "gemini-2.5-flash");
+    await dynamic25?.generate({
         workerId: "worker",
         messages: [{ role: "user", content: "hello" }],
     });
-    assert.equal(
-        bodies[1]?.generationConfig?.thinkingConfig?.includeThoughts,
-        undefined,
-        "off does not request readable thoughts",
-    );
+    assert.deepEqual(bodies[1]?.generationConfig?.thinkingConfig, {
+        includeThoughts: true,
+        thinkingBudget: -1,
+    }, "Gemini 2.5 adaptive uses the provider's native dynamic budget sentinel");
+});
+
+test("native Anthropic adaptive policy uses adaptive thinking rather than a fixed high effort", async () => {
+    let request: Record<string, unknown> | undefined;
+    const languageModel = {
+        specificationVersion: "v4",
+        provider: "anthropic.messages",
+        modelId: "claude-sonnet-4-6",
+        supportedUrls: {},
+        doGenerate: async (options: Record<string, unknown>) => {
+            request = options;
+            return {
+                content: [{ type: "text", text: "ok" }],
+                finishReason: { unified: "stop", raw: "stop" },
+                usage: {
+                    inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+                    outputTokens: { total: 1, text: 1, reasoning: 0 },
+                },
+                response: { id: "response", modelId: "claude-sonnet-4-6" },
+                warnings: [],
+            };
+        },
+        doStream: async (options: Record<string, unknown>) => {
+            request = options;
+            return {
+                stream: new ReadableStream({
+                    start(controller) {
+                        controller.enqueue({ type: "stream-start", warnings: [] });
+                        controller.enqueue({ type: "response-metadata", id: "response", modelId: "claude-sonnet-4-6" });
+                        controller.enqueue({ type: "text-start", id: "text-1" });
+                        controller.enqueue({ type: "text-delta", id: "text-1", delta: "ok" });
+                        controller.enqueue({ type: "text-end", id: "text-1" });
+                        controller.enqueue({
+                            type: "finish",
+                            finishReason: { unified: "stop", raw: "stop" },
+                            usage: {
+                                inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+                                outputTokens: { total: 1, text: 1, reasoning: 0 },
+                            },
+                        });
+                        controller.close();
+                    },
+                }),
+                response: {},
+            };
+        },
+    } as unknown as LanguageModel;
+    const provider = providerFromSdkModel({
+        name: "anthropic",
+        env: {
+            ...env,
+            PLURNK_PROVIDERS_REASONING: "adaptive",
+            PLURNK_PROVIDERS_STREAMING: "0",
+        },
+        model: "claude-sonnet-4-6",
+        languageModel,
+        sdkPackage: "@ai-sdk/anthropic",
+        additiveReasoningProvider: "anthropic",
+        contextWindow: 16_384,
+        info: {
+            name: "Claude Sonnet 4.6",
+            contextWindow: 16_384,
+            maxOutputTokens: 8_192,
+            reasoning: true,
+            attachment: true,
+            toolCall: true,
+            modalities: { input: ["text", "image"], output: ["text"] },
+        },
+    });
+    await provider.generate({ workerId: "worker", messages: [{ role: "user", content: "hello" }] });
+    assert.equal(request?.reasoning, "provider-default");
+    assert.deepEqual(request?.providerOptions, {
+        anthropic: { thinking: { type: "adaptive", display: "summarized" } },
+    });
 });
 
 test("native provider routes project their documented cache controls through the actual SDK request", async (t) => {
@@ -378,6 +506,8 @@ test("native provider routes project their documented cache controls through the
         const provider = catalogProviderFromEnv("openrouter", {
             ...env,
             OPENROUTER_API_KEY: "test-key",
+            OPENROUTER_HTTP_REFERER: "https://github.com/plurnk/plurnk-service",
+            OPENROUTER_APP_TITLE: "Plurnk",
         }, "anthropic/claude-sonnet-4.6", `http://127.0.0.1:${address.port}/api/v1`);
         await provider?.generate({
             workerId: "openrouter-worker",
@@ -387,6 +517,8 @@ test("native provider routes project their documented cache controls through the
             ],
         });
         assert.equal(call?.headers.get("x-session-id"), "openrouter-worker");
+        assert.equal(call?.headers.get("http-referer"), "https://github.com/plurnk/plurnk-service");
+        assert.equal(call?.headers.get("x-openrouter-title"), "Plurnk");
         assert.deepEqual((call?.body.messages as unknown[] | undefined)?.[0], {
             role: "system",
             content: [{

package/src/catalogProvider.ts

@@ -12,10 +12,11 @@ import {
     reasoningFromEnv,
     reasoningResponseStyleFromEnv,
 } from "./env.ts";
-import AiSdkProvider, { type ReasoningStyle } from "./AiSdkProvider.ts";
+import AiSdkProvider, { type AiSdkProviderConfig, type GrammarStyle, type ReasoningStyle } from "./AiSdkProvider.ts";
 import { configuredProviderInfo, createSdkModel } from "./sdkModels.ts";
 import { providerSource } from "./notices.ts";
 import type { Provider, ProviderCostNormalizer } from "./types.ts";
+import { REASONING_POLICIES, type ReasoningPolicy } from "@plurnk/plurnk-contracts";
 import { estimateProviderCost } from "./cost.ts";
 import { emitWarningOnce } from "./warnings.ts";
 import type { LanguageModel } from "ai";
@@ -39,6 +40,102 @@ const reasoningStyleFromEnv = (
     return value as ReasoningStyle;
 };
 
+const activationPolicies = Object.freeze(["off", "adaptive"] as const);
+const deepSeekPolicies = Object.freeze(["off", "adaptive", "high"] as const);
+const adaptiveOnly = Object.freeze(["adaptive"] as const);
+const reasoningWithoutOff = Object.freeze(["adaptive", "low", "medium", "high"] as const);
+
+const mistralSupportsEffort = (model: string): boolean =>
+    model === "mistral-small-latest"
+    || model === "mistral-small-2603"
+    || model === "mistral-medium-3"
+    || model === "mistral-medium-3.5";
+
+const xaiReasoningIsModelFixed = (model: string): boolean =>
+    /^grok-4\.20(?:-\d{4})?-(?:non-)?reasoning$/.test(model);
+
+const googleReasoningCannotBeOff = (model: string): boolean =>
+    /^gemini-2\.5-pro(?:-|$)/i.test(model)
+    || /^gemini-(?:[3-9]|\d{2})[.-]/i.test(model);
+
+const anthropicSupportsAdaptiveThinking = (model: string): boolean =>
+    /claude-(?:opus-(?:4-[678]|5)|sonnet-(?:4-6|5)|fable-5)/.test(model);
+
+const supportedReasoningPolicies = ({
+    info,
+    native,
+    style,
+    sdkPackage,
+    model,
+}: {
+    info?: ModelInfo;
+    native: boolean;
+    style: ReasoningStyle;
+    sdkPackage?: string;
+    model: string;
+}): readonly ReasoningPolicy[] => {
+    if (info !== undefined && info.reasoning !== true) return activationPolicies;
+    if (native) {
+        if (sdkPackage === "@ai-sdk/mistral") {
+            return mistralSupportsEffort(model) ? deepSeekPolicies : adaptiveOnly;
+        }
+        if (sdkPackage === "@ai-sdk/xai") {
+            if (xaiReasoningIsModelFixed(model)) return adaptiveOnly;
+            if (model === "grok-4.6") return reasoningWithoutOff;
+        }
+        if (sdkPackage === "@ai-sdk/google" && googleReasoningCannotBeOff(model)) {
+            return reasoningWithoutOff;
+        }
+        return REASONING_POLICIES;
+    }
+    if (style === "effort" || style === "effort_explicit") return REASONING_POLICIES;
+    if (style === "thinking_effort") return deepSeekPolicies;
+    return activationPolicies;
+};
+
+const adaptiveReasoningProjection = ({
+    sdkPackage,
+    model,
+    reasoningCapable,
+}: {
+    sdkPackage?: string;
+    model: string;
+    reasoningCapable: boolean;
+}): Pick<AiSdkProviderConfig, "adaptiveReasoning" | "adaptiveReasoningProviderOptions"> => {
+    if (!reasoningCapable) return { adaptiveReasoning: "provider-default" };
+    if (sdkPackage === "@ai-sdk/google" && /^gemini-2\.5(?:-|$)/i.test(model)) {
+        return {
+            adaptiveReasoning: "provider-default",
+            adaptiveReasoningProviderOptions: {
+                google: { thinkingConfig: { thinkingBudget: -1 } },
+            },
+        };
+    }
+    if (sdkPackage === "@ai-sdk/anthropic" && anthropicSupportsAdaptiveThinking(model)) {
+        return {
+            adaptiveReasoning: "provider-default",
+            adaptiveReasoningProviderOptions: {
+                anthropic: { thinking: { type: "adaptive", display: "summarized" } },
+            },
+        };
+    }
+    if (sdkPackage === "@ai-sdk/amazon-bedrock" && anthropicSupportsAdaptiveThinking(model)) {
+        return {
+            adaptiveReasoning: "provider-default",
+            adaptiveReasoningProviderOptions: {
+                bedrock: { reasoningConfig: { type: "adaptive" } },
+            },
+        };
+    }
+    if (sdkPackage === "@ai-sdk/mistral" && !mistralSupportsEffort(model)) {
+        return { adaptiveReasoning: "provider-default" };
+    }
+    if (sdkPackage === "@ai-sdk/xai" && xaiReasoningIsModelFixed(model)) {
+        return { adaptiveReasoning: "provider-default" };
+    }
+    return { adaptiveReasoning: "high" };
+};
+
 export const providerFromSdkModel = ({
     name,
     env,
@@ -54,6 +151,8 @@ export const providerFromSdkModel = ({
     systemCacheProviderOptions,
     reasoningResponseProviderOptions,
     additiveReasoningProvider,
+    sdkPackage,
+    grammarStyle,
 }: {
     name: string;
     env: NodeJS.ProcessEnv;
@@ -65,10 +164,14 @@ export const providerFromSdkModel = ({
     contextWindow: number;
     info?: ModelInfo;
     attributions?: (context: PluginAttributionContext) => PluginAttribution;
+    // {§provider-grammar-transport} — plugin-declared constrained-decoding
+    // capability; "none" keeps the grammar off the wire.
+    grammarStyle?: GrammarStyle;
     cacheAffinity?: CacheAffinity;
     systemCacheProviderOptions?: AiSdkProviderOptions;
     reasoningResponseProviderOptions?: AiSdkProviderOptions;
     additiveReasoningProvider?: "anthropic" | "bedrock";
+    sdkPackage?: string;
 }): Provider => {
     emitWarningOnce(
         `${name} provider: request-level prompt counting is a chars/2 estimate; capacity is deferred to the provider`,
@@ -86,6 +189,13 @@ export const providerFromSdkModel = ({
         maxOutputTokens,
     );
     const reasoning = reasoningFromEnv(env, name, envelope.reasoningBudget);
+    const reasoningStyle = reasoningStyleFromEnv(env, name) ?? "none";
+    const reasoningCapable = info?.reasoning === true;
+    const adaptiveReasoning = adaptiveReasoningProjection({
+        sdkPackage,
+        model,
+        reasoningCapable,
+    });
 
     const catalogCost = info?.cost;
     const rates = catalogCost === undefined ? null : {
@@ -118,7 +228,17 @@ export const providerFromSdkModel = ({
         maxOutputTokens,
         outputBudget: envelope.outputBudget,
         reasoningBudget: reasoning.budget,
-        ...(additiveReasoningProvider === undefined ? {} : { additiveReasoningProvider }),
+        supportedReasoningPolicies: supportedReasoningPolicies({
+            info,
+            native: languageModel !== undefined,
+            style: reasoningStyle,
+            sdkPackage,
+            model,
+        }),
+        ...adaptiveReasoning,
+        ...(additiveReasoningProvider === undefined || !reasoningCapable
+            ? {}
+            : { additiveReasoningProvider }),
         fetchTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "PLURNK_PROVIDERS_FETCH_TIMEOUT", name),
         operationTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_OPERATION_TIMEOUT, "PLURNK_PROVIDERS_OPERATION_TIMEOUT", name),
         firstContentTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT, "PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT", name),
@@ -130,7 +250,7 @@ export const providerFromSdkModel = ({
         frequencyPenalty: parseRequiredFloat(env.PLURNK_PROVIDERS_FREQUENCY_PENALTY, "PLURNK_PROVIDERS_FREQUENCY_PENALTY", name, 0),
         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),
+        reasoningStyle,
         ...(affinityEnabled && cacheAffinity !== undefined ? { cacheAffinity } : {}),
         ...(cacheWritePolicy === "stable-system" && systemCacheProviderOptions !== undefined
             ? { systemCacheProviderOptions }
@@ -141,6 +261,7 @@ export const providerFromSdkModel = ({
         serviceTier: env.PLURNK_PROVIDERS_SERVICE_TIER,
         estimateCost,
         source: providerSource(name),
+        ...(grammarStyle === undefined ? {} : { grammarStyle }),
         gbnfDebug: env.PLURNK_PROVIDERS_GBNF_DEBUG !== undefined
             && env.PLURNK_PROVIDERS_GBNF_DEBUG !== ""
             && env.PLURNK_PROVIDERS_GBNF_DEBUG !== "0",
@@ -186,6 +307,7 @@ export const catalogProviderFromEnv = (
         systemCacheProviderOptions: sdk.systemCacheProviderOptions,
         reasoningResponseProviderOptions: sdk.reasoningResponseProviderOptions,
         additiveReasoningProvider: sdk.additiveReasoningProvider,
+        sdkPackage: sdk.catalog?.npm,
         contextWindow,
         info,
     });

package/src/compatibleProvider.test.ts

@@ -21,6 +21,17 @@ const env = {
     PLURNK_PROVIDERS_CACHE_WRITE_POLICY: "stable-system",
 };
 
+const streamedChatResponse = (content: string) => new Response([
+    `data: ${JSON.stringify({
+        id: "test-completion",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: "local",
+        choices: [{ index: 0, delta: { content }, finish_reason: "stop" }],
+    })}`,
+    "data: [DONE]",
+].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+
 test.afterEach(() => mock.restoreAll());
 
 test("an undifferentiated compatible endpoint receives no guessed prompt-cache field", async () => {
@@ -30,11 +41,7 @@ test("an undifferentiated compatible endpoint receives no guessed prompt-cache f
             return new Response(JSON.stringify({ data: [{ id: "local", n_ctx: 8192 }] }));
         }
         body = JSON.parse(String(init?.body)) as Record<string, unknown>;
-        return new Response(JSON.stringify({
-            model: "local",
-            choices: [{ message: { content: "ok" }, finish_reason: "stop" }],
-            usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-        }), { headers: { "content-type": "application/json" } });
+        return streamedChatResponse("ok");
     });
 
     const provider = await compatibleProviderFromEnv("openai", env, "local");
@@ -55,11 +62,7 @@ test("the server-wide DRY-off floor emits no DRY request fields", async () => {
             }));
         }
         body = JSON.parse(String(init?.body)) as Record<string, unknown>;
-        return new Response(JSON.stringify({
-            model: "local",
-            choices: [{ message: { content: "ok" }, finish_reason: "stop" }],
-            usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
-        }), { headers: { "content-type": "application/json" } });
+        return streamedChatResponse("ok");
     });
 
     const provider = await compatibleProviderFromEnv("openai", {

package/src/compatibleProvider.ts

@@ -182,6 +182,7 @@ export const compatibleProviderFromEnv = async (
     }
     const envelope = generationEnvelopeFromEnv(env, provider, contextWindow, null);
     const reasoning = reasoningFromEnv(env, provider, envelope.reasoningBudget);
+    const supportedReasoningPolicies = ["off", "adaptive"] as const;
     return new AiSdkProvider({
         model,
         url,
@@ -191,6 +192,7 @@ export const compatibleProviderFromEnv = async (
         maxOutputTokens: null,
         outputBudget: envelope.outputBudget,
         reasoningBudget: reasoning.budget,
+        supportedReasoningPolicies,
         fetchTimeoutMs: timeout,
         operationTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_OPERATION_TIMEOUT, "PLURNK_PROVIDERS_OPERATION_TIMEOUT", provider),
         firstContentTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT, "PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT", provider),

package/src/cost.ts

@@ -132,8 +132,9 @@ export const addDecimals = (values: readonly string[]): string => {
 };
 
 export const sumProviderCostsUsd = (costs: readonly ProviderCost[]): string | null => {
-    const values = costs.map(providerCostUsd);
-    return values.some((value) => value === null)
-        ? null
-        : addDecimals(values as string[]);
+    // {§tokenomics-provider-usage} — a request without USD-expressible cost
+    // (an uncataloged model, or a response-less failure) is skipped; it never
+    // erases the expressible evidence. Null only when nothing is expressible.
+    const values = costs.map(providerCostUsd).filter((value): value is string => value !== null);
+    return values.length === 0 ? null : addDecimals(values);
 };

package/src/discover.test.ts

@@ -47,6 +47,33 @@ test("discover: a provider package missing plurnk.name is ignored, not crashed",
     assert.deepEqual([...registry.keys()], ["named"]);
 });
 
+test("{§provider-grammar-transport} discover: the manifest grammarStyle declaration is recorded and validated", async (t) => {
+    const root = await buildModules(t, {
+        "@acme/llamacpp-rail": {
+            name: "@acme/llamacpp-rail",
+            plurnk: { kind: "provider", name: "rail", grammarStyle: "llamacpp" },
+        },
+        "@acme/plain": {
+            name: "@acme/plain",
+            plurnk: { kind: "provider", name: "plain" },
+        },
+    });
+    const { grammarStyles } = await discover({ cwd: root });
+    assert.equal(grammarStyles.get("rail"), "llamacpp");
+    assert.equal(grammarStyles.get("plain"), "none");
+    assert.equal(grammarStyles.get("absent"), undefined);
+});
+
+test("{§provider-grammar-transport} discover: an invalid grammarStyle fails loudly, never guessing", async (t) => {
+    const root = await buildModules(t, {
+        "@acme/bad-grammar": {
+            name: "@acme/bad-grammar",
+            plurnk: { kind: "provider", name: "bad", grammarStyle: "guff" },
+        },
+    });
+    await assert.rejects(discover({ cwd: root }), /grammarStyle must be "none" or "llamacpp"/);
+});
+
 test("discover: an array kind claims no provider family", async (t) => {
     const root = await buildModules(t, {
         "@acme/dual": {