@plurnk/plurnk-providers 1.4.0 → 1.5.0

package/src/AiSdkProvider.test.ts

@@ -2,6 +2,8 @@ import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
 import AiSdkProvider, { effortFromBudget } from "./AiSdkProvider.ts";
 import { ProviderError } from "./errors.ts";
+import { authoritativeChargeNormalizer } from "./accounting.ts";
+import type { LanguageModel } from "ai";
 
 // Build a fake fetch returning a one-chunk SSE stream, capturing the request
 // so tests can assert what the spine sent on the wire.
@@ -309,6 +311,139 @@ test("generate maps a streamed response into ProviderResponse", async () => {
     assert.notEqual(assistantRaw, undefined);
 });
 
+test("native SDK accounting metadata becomes a normalized charge in buffered and streamed responses", async (t) => {
+    const usage = {
+        inputTokens: { total: 2, noCache: 2, cacheRead: 0, cacheWrite: 0 },
+        outputTokens: { total: 1, text: 1, reasoning: 0 },
+    };
+    const providerMetadata = { openrouter: { usage: { cost: 0.00154935 } } };
+    const charge = {
+        kind: "authoritative",
+        amount: { amount: "0.00154935", currency: "USD" },
+        usdEquivalent: "0.00154935",
+        source: "OpenRouter response usage.cost",
+    };
+    const languageModel = {
+        specificationVersion: "v4",
+        provider: "openrouter.chat",
+        modelId: "router-test",
+        supportedUrls: {},
+        doGenerate: async () => ({
+            content: [{ type: "text", text: "ok" }],
+            finishReason: { unified: "stop", raw: "completed" },
+            usage,
+            providerMetadata,
+            response: { id: "response-buffered", modelId: "router-test" },
+            warnings: [],
+        }),
+        doStream: async () => ({
+            stream: new ReadableStream({
+                start(controller) {
+                    controller.enqueue({ type: "stream-start", warnings: [] });
+                    controller.enqueue({ type: "response-metadata", id: "response-streamed", modelId: "router-test" });
+                    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: "completed" },
+                        usage,
+                        providerMetadata,
+                    });
+                    controller.close();
+                },
+            }),
+            response: {},
+        }),
+    } as unknown as LanguageModel;
+    const config = {
+        model: "router-test",
+        languageModel,
+        fetchTimeoutMs: 5_000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off" as const, budget: null },
+        retryAttempts: 0,
+        normalizeCharge: authoritativeChargeNormalizer("@openrouter/ai-sdk-provider"),
+    };
+
+    await t.test("buffered", async () => {
+        const response = await new AiSdkProvider({ ...config, streaming: false })
+            .generate({ workerId: "buffered", messages: [] });
+        assert.deepEqual(response.charge, charge);
+    });
+    await t.test("streamed", async () => {
+        const response = await new AiSdkProvider(config)
+            .generate({ workerId: "streamed", messages: [] });
+        assert.deepEqual(response.charge, charge);
+    });
+});
+
+test("compatible xAI wire usage becomes an exact tick charge without raw-body capture", async () => {
+    const p = new AiSdkProvider({
+        model: "grok-test",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 5_000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 0,
+        streaming: false,
+        normalizeCharge: authoritativeChargeNormalizer("@ai-sdk/xai"),
+    });
+    installFetchJson({
+        id: "response-1",
+        model: "grok-test",
+        choices: [{ message: { content: "ok" }, finish_reason: "stop" }],
+        usage: {
+            prompt_tokens: 2,
+            completion_tokens: 1,
+            total_tokens: 3,
+            cost_in_usd_ticks: 15_493_500,
+        },
+    });
+    const response = await p.generate({ workerId: "xai", messages: [] });
+    assert.deepEqual(response.charge, {
+        kind: "authoritative",
+        amount: { amount: "15493500", currency: "USDTICK" },
+        usdEquivalent: "0.00154935",
+        source: "xAI response usage.cost_in_usd_ticks",
+    });
+    assert.equal(response.rawBody, undefined);
+});
+
+test("streamed xAI final usage retains its exact tick charge", async () => {
+    const p = new AiSdkProvider({
+        model: "grok-test",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 5_000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 0,
+        normalizeCharge: authoritativeChargeNormalizer("@ai-sdk/xai"),
+    });
+    installFetch([
+        { choices: [{ delta: { content: "ok" }, finish_reason: "stop" }] },
+        {
+            choices: [],
+            usage: {
+                prompt_tokens: 2,
+                completion_tokens: 1,
+                total_tokens: 3,
+                cost_in_usd_ticks: 15_493_500,
+            },
+        },
+    ]);
+    const response = await p.generate({ workerId: "xai", messages: [] });
+    assert.deepEqual(response.charge, {
+        kind: "authoritative",
+        amount: { amount: "15493500", currency: "USDTICK" },
+        usdEquivalent: "0.00154935",
+        source: "xAI response usage.cost_in_usd_ticks",
+    });
+});
+
 test("generate surfaces and normalizes an out-of-set finish_reason", async () => {
     const warnings: Array<{ message: string; code?: string }> = [];
     mock.method(process, "emitWarning", (message: string | Error, options?: string | { code?: string }) => {
@@ -852,14 +987,16 @@ test("sampling passthrough guards contract invariants: n/tools/caps stripped, pl
 
 test("template reasoning returns the exact pre-projection grammar sentence ({§gbnf-response-observation})", async () => {
     const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { tokens: 64 }, completionReserve: { tokens: 160 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
-    const calls = installFetch([{ choices: [{ delta: { reasoning_content: "con🙂sider", content: "x" } }] }]);
     const grammarInput = "<|channel>thought\ncon🙂sider<channel|>x";
+    const calls = installFetch([{ choices: [{ delta: { content: grammarInput } }] }]);
     const res = await p.generate({ workerId: "r", messages: [], grammar: `root ::= ${JSON.stringify(grammarInput)}` });
     const body = JSON.parse(calls[0].init.body as string);
     assert.deepEqual(body.chat_template_kwargs, { enable_thinking: true });
-    assert.equal(body.reasoning_format, "auto");
+    assert.equal(body.reasoning_format, "none");
     assert.equal(body.thinking_budget_tokens, 64);
     assert.equal(body.grammar, `root ::= ${JSON.stringify(grammarInput)}`);
+    assert.equal(res.assistant.reasoning, "con🙂sider");
+    assert.equal(res.assistant.content, "x");
     assert.deepEqual(res.grammarEvidence, {
         input: grammarInput,
         contentStart: [..."<|channel>thought\ncon🙂sider<channel|>"].length,
@@ -868,13 +1005,48 @@ test("template reasoning returns the exact pre-projection grammar sentence ({§g
     assert.equal(res.meta?.railsVerdict, undefined, "the provider represents evidence but does not grade itself");
 });
 
-test("template reasoning does not invent pre-projection evidence when the wire omits its reasoning field", async () => {
+test("a verbatim template response remains exact evidence when it has no channel envelope", async () => {
     const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { tokens: 64 }, completionReserve: { tokens: 160 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
-    installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
+    const body = JSON.parse(calls[0].init.body as string);
+    assert.equal(body.reasoning_format, "none");
+    assert.deepEqual(res.grammarEvidence, { input: "x", contentStart: 0, transported: true });
+});
+
+test("a template grammar preserves exact evidence when reasoning is disabled", async () => {
+    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { tokens: 64 }, completionReserve: { tokens: 160 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
+    const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
+    const body = JSON.parse(calls[0].init.body as string);
+    assert.deepEqual(body.chat_template_kwargs, { enable_thinking: false });
+    assert.equal(body.reasoning_format, "none");
+    assert.deepEqual(res.grammarEvidence, { input: "x", contentStart: 0, transported: true });
+});
+
+test("an unexpectedly projected template response cannot claim pre-projection evidence", async () => {
+    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { tokens: 64 }, completionReserve: { tokens: 160 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
+    installFetch([{ choices: [{ delta: { reasoning_content: "reason", content: "x" } }] }]);
     const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
     assert.equal(res.grammarEvidence, undefined);
 });
 
+test("template reasoning preserves an empty grammar-required channel as exact evidence", async () => {
+    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { tokens: 64 }, completionReserve: { tokens: 160 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
+    const input = "<|channel>thought\n<channel|>x";
+    const calls = installFetch([{ choices: [{ delta: { content: input } }] }]);
+    const res = await p.generate({ workerId: "r", messages: [], grammar: `root ::= ${JSON.stringify(input)}` });
+    const body = JSON.parse(calls[0].init.body as string);
+    assert.equal(body.reasoning_format, "none");
+    assert.equal(res.assistant.reasoning, null);
+    assert.equal(res.assistant.content, "x");
+    assert.deepEqual(res.grammarEvidence, {
+        input,
+        contentStart: [..."<|channel>thought\n<channel|>"].length,
+        transported: true,
+    });
+});
+
 test("channel-escape detector: billed completion tokens vastly beyond visible channels attach grammar_unenforced", async () => {
     // The run105 shape: tiny visible content, no reasoning, thousands billed — the decode
     // escaped into a discarded reasoning block, unconstrained.
@@ -1262,6 +1434,15 @@ test("configured headers and url are sent verbatim", async () => {
 
 const retryCfg = { model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null } as const };
 
+const stalledStreamResponse = (): Response => new Response(new ReadableStream({
+    start(controller) {
+        controller.enqueue(new TextEncoder().encode(
+            'data: {"id":"stalled","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"content":"partial"},"finish_reason":null}]}\n\n',
+        ));
+        setTimeout(() => controller.close(), 100);
+    },
+}), { status: 200 });
+
 test("retry: a transient failure retries and a later success resolves", async () => {
     const calls = installFetchScript([
         { status: 429, retryAfter: 0 },
@@ -1274,20 +1455,11 @@ test("retry: a transient failure retries and a later success resolves", async ()
     assert.equal(calls.length, 3); // 429 → 503 → 200
 });
 
-test("streamed-body silence fails the exchange without replaying partial output", async () => {
+test("streamed-body silence retries and returns the retry's complete output", async () => {
     let calls = 0;
     mock.method(globalThis, "fetch", async () => {
         calls++;
-        if (calls === 1) {
-            return new Response(new ReadableStream({
-                start(controller) {
-                    controller.enqueue(new TextEncoder().encode(
-                        'data: {"id":"first","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"content":"partial"},"finish_reason":null}]}\n\n',
-                    ));
-                    setTimeout(() => controller.close(), 100);
-                },
-            }), { status: 200 });
-        }
+        if (calls === 1) return stalledStreamResponse();
         return new Response(new ReadableStream({
             start(controller) {
                 controller.enqueue(new TextEncoder().encode(
@@ -1300,7 +1472,7 @@ test("streamed-body silence fails the exchange without replaying partial output"
     const p = new AiSdkProvider({
         model: "m",
         url: "http://x/v1/chat/completions",
-        fetchTimeoutMs: 1000,
+        fetchTimeoutMs: 5000,
         streamIdleTimeoutMs: 10,
         temperature: 0.2,
         repeatPenalty: 1.15,
@@ -1308,12 +1480,100 @@ test("streamed-body silence fails the exchange without replaying partial output"
         retryAttempts: 1,
         source: "provider:test",
     });
+    const result = await p.generate({ workerId: "r", messages: [] });
+    assert.equal(result.assistant.content, "recovered", "the retry's complete output, not the stalled partial");
+    assert.equal(calls, 2, "the stall retried once and the retry succeeded");
+    mock.restoreAll();
+});
+
+test("streamed-body silence does not replay when retries are disabled", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async () => {
+        calls++;
+        return stalledStreamResponse();
+    });
+    const p = new AiSdkProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 1000,
+        streamIdleTimeoutMs: 10,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 0,
+        source: "provider:test",
+    });
     await assert.rejects(
         p.generate({ workerId: "r", messages: [] }),
         (error: ProviderError) => error.kind === "network_failure"
             && /chunk timeout/i.test(error.message),
     );
-    assert.equal(calls, 1);
+    assert.equal(calls, 1, "zero retries permits exactly one provider request");
+    mock.restoreAll();
+});
+
+test("streamed-body silence exhausts the configured retry budget once", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async () => {
+        calls++;
+        return stalledStreamResponse();
+    });
+    const p = new AiSdkProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 5000,
+        streamIdleTimeoutMs: 10,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 1,
+        source: "provider:test",
+    });
+    await assert.rejects(
+        p.generate({ workerId: "r", messages: [] }),
+        (error: ProviderError) => error.kind === "network_failure"
+            && error.problem.attempts === 2
+            && error.problem.retryExhausted === true
+            && error.problem.retryable === false,
+    );
+    assert.equal(calls, 2, "one configured retry permits exactly two provider requests");
+    mock.restoreAll();
+});
+
+test("the total generation deadline spans stalled-stream retry scheduling", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async () => {
+        calls++;
+        if (calls > 1) {
+            return new Response(new ReadableStream({
+                start(controller) {
+                    controller.enqueue(new TextEncoder().encode(
+                        'data: {"id":"second","object":"chat.completion.chunk","created":2,"model":"m","choices":[{"index":0,"delta":{"content":"late"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n',
+                    ));
+                    controller.close();
+                },
+            }), { status: 200 });
+        }
+        return stalledStreamResponse();
+    });
+    const p = new AiSdkProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 50,
+        streamIdleTimeoutMs: 10,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 3,
+        source: "provider:test",
+    });
+    const started = Date.now();
+    await assert.rejects(
+        p.generate({ workerId: "r", messages: [] }),
+        (error: ProviderError) => error.kind === "network_failure",
+    );
+    assert.ok(Date.now() - started < 500, "the configured total deadline ends retry scheduling");
+    assert.equal(calls, 1, "the total deadline expires before another request begins");
     mock.restoreAll();
 });
 

package/src/AiSdkProvider.ts

@@ -6,7 +6,7 @@
 // ordinary vendor protocol. The compatible URL path remains only for PLURNK
 // extensions and local endpoint probes the SDK cannot represent.
 
-import type { ChatMessage, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderResponse, ProviderUsage } from "./types.ts";
+import type { AuthoritativeChargeNormalizer, ChatMessage, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderResponse, ProviderUsage } from "./types.ts";
 import type { ProviderCost } from "@plurnk/plurnk-contracts";
 import type { Reasoning, ReasoningResponseStyle, ReserveSpec } from "./env.ts";
 import { executeAiSdkModel, executeOpenAICompatible } from "./aiSdkTransport.ts";
@@ -18,6 +18,7 @@ import { validateGbnf } from "@plurnk/gbnf";
 import { assertPromptTokenMeasurement, estimatePromptTokens } from "./promptTokens.ts";
 import { emitWarningOnce } from "./warnings.ts";
 import type { PluginAttribution, PluginAttributionContext } from "@plurnk/plurnk-meta";
+import { validateAuthoritativeCharge } from "./cost.ts";
 
 export type ProviderFetch = typeof globalThis.fetch;
 
@@ -44,6 +45,7 @@ export type AiSdkProviderConfig = {
     countPromptTokens?: (messages: readonly ChatMessage[], signal?: AbortSignal) => PromptTokenMeasurement | Promise<PromptTokenMeasurement>;
     calculateCost?: (usage: ProviderUsage) => number; // default () => 0
     calculateCharge?: (usage: ProviderUsage) => Exclude<ProviderCost, { kind: "authoritative" }>;
+    normalizeCharge?: AuthoritativeChargeNormalizer;
     source?: string;                           // notice/problem source, e.g. "provider:openai"; default "provider"
     grammarStyle?: GrammarStyle;               // how a GBNF grammar is carried; default "none" (not sent)
     // Send the OpenAI-standard `prompt_cache_key` set to workerId, so a
@@ -157,19 +159,15 @@ type TaggedReasoningProjection = {
     readonly contentStart: number;
 };
 
-// {§provider-tagged-reasoning} Only the model-contract position is structural:
-// one exact leading envelope. Parsing after stream assembly keeps SSE and JSON
-// on one path and leaves later literal tags in the visible suffix untouched.
-const projectTaggedReasoning = (
+const projectLeadingReasoning = (
     content: string,
     structuredReasoning: string,
-    style: ReasoningResponseStyle,
+    opening: string,
+    closing: string,
 ): TaggedReasoningProjection => {
-    const opening = "<think>";
-    if (style !== "think-tags" || structuredReasoning.length > 0 || !content.startsWith(opening)) {
+    if (structuredReasoning.length > 0 || !content.startsWith(opening)) {
         return { content, reasoning: structuredReasoning, projected: false, contentStart: 0 };
     }
-    const closing = "</think>";
     const closingIndex = content.indexOf(closing, opening.length);
     if (closingIndex === -1) {
         return {
@@ -188,6 +186,24 @@ const projectTaggedReasoning = (
     };
 };
 
+// {§provider-tagged-reasoning} Only the model-contract position is structural:
+// one exact leading envelope. Parsing after stream assembly keeps SSE and JSON
+// on one path and leaves later literal tags in the visible suffix untouched.
+const projectTaggedReasoning = (
+    content: string,
+    structuredReasoning: string,
+    style: ReasoningResponseStyle,
+): TaggedReasoningProjection => style === "think-tags"
+    ? projectLeadingReasoning(content, structuredReasoning, "<think>", "</think>")
+    : { content, reasoning: structuredReasoning, projected: false, contentStart: 0 };
+
+// llama-server's template reasoning parser can project this leading channel out
+// of the OpenAI-compatible response. Grammar evidence needs the sentence before
+// that lossy projection, so constrained template turns request it verbatim and
+// split the observed enclosure here.
+const projectTemplateReasoning = (content: string): TaggedReasoningProjection =>
+    projectLeadingReasoning(content, "", "<|channel>thought\n", "<channel|>");
+
 // Shared budget→effort breakpoints (xai and google had identical copies).
 export const effortFromBudget = (budget: number): "low" | "medium" | "high" => {
     if (budget <= 1000) return "low";
@@ -243,6 +259,7 @@ export default class AiSdkProvider implements Provider {
     #promptTokensUrl: string | undefined;
     #calculateCost: (usage: ProviderUsage) => number;
     #calculateCharge?: (usage: ProviderUsage) => Exclude<ProviderCost, { kind: "authoritative" }>;
+    #normalizeCharge?: AuthoritativeChargeNormalizer;
     #source: string;
     #grammarStyle: GrammarStyle;
     #promptCacheKey: boolean;
@@ -268,7 +285,6 @@ export default class AiSdkProvider implements Provider {
     // tokenizeUrl (llama-server), so `provider.tokenize === undefined` remains
     // the honest capability signal for every other backend.
     tokenize?: (text: string) => Promise<number[]>;
-
     constructor(config: AiSdkProviderConfig) {
         this.#model = config.model;
         this.#url = config.url;
@@ -307,6 +323,7 @@ export default class AiSdkProvider implements Provider {
         this.#promptTokensUrl = config.promptTokensUrl;
         this.#calculateCost = config.calculateCost ?? (() => 0);
         this.#calculateCharge = config.calculateCharge;
+        this.#normalizeCharge = config.normalizeCharge;
         this.#source = config.source ?? "provider";
         this.#grammarStyle = config.grammarStyle ?? "none";
         this.#promptCacheKey = config.promptCacheKey ?? false;
@@ -428,9 +445,10 @@ export default class AiSdkProvider implements Provider {
             ?? { kind: "unknown", reason: "no provider rate or settled charge is available" };
     }
 
-    // Reasoning intent maps independently of grammar transport. The llama-server
-    // template mapping is owned by {§llama-reasoning-request}.
-    #reasoningBody(): Record<string, unknown> {
+    // Reasoning activation and allowance are independent of grammar transport;
+    // only the response representation becomes lossless when evidence is needed.
+    // The llama-server template mapping is owned by {§llama-reasoning-request}.
+    #reasoningBody(preserveGrammarSentence = false): Record<string, unknown> {
         const { mode, budget } = this.#reasoning;
         const on = mode !== "off";
         switch (this.#reasoningStyle) {
@@ -440,7 +458,7 @@ export default class AiSdkProvider implements Provider {
                     : mode === "on" ? budget : this.reasoningReserve;
                 return {
                     chat_template_kwargs: { enable_thinking: on },
-                    reasoning_format: "auto",
+                    reasoning_format: preserveGrammarSentence ? "none" : "auto",
                     ...(allowance === null ? {} : { thinking_budget_tokens: allowance }),
                 };
             }
@@ -621,6 +639,8 @@ export default class AiSdkProvider implements Provider {
         const wantGrammar = grammar !== undefined && this.#grammarStyle !== "none";
         if (wantGrammar && this.#gbnfDebug) this.#assertGrammarValid(grammar!);
         const sendGrammar = wantGrammar && !this.#gbnfDebug ? grammar : undefined;
+        const preserveGrammarSentence = wantGrammar
+            && this.#reasoningStyle === "template";
 
         // Assembly order = precedence: the family's sampling DEFAULTS
         // (PLURNK_PROVIDERS_TEMPERATURE — universal, measured on grammar
@@ -634,7 +654,7 @@ export default class AiSdkProvider implements Provider {
             ...(this.#serviceTier !== undefined ? { service_tier: this.#serviceTier } : {}),
             model: this.#model,
             messages,
-            ...this.#reasoningBody(),
+            ...this.#reasoningBody(preserveGrammarSentence),
             ...this.#grammarBody(sendGrammar),
             ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
             // Request per-token logprobs only when enabled (managed field —
@@ -649,7 +669,9 @@ export default class AiSdkProvider implements Provider {
 
         // Per-request headers = static auth/routing + any first-party telemetry.
         const metaHeaders = this.#metadataHeaders(attributions, client, strikes, workerId, primaryWorkerId, workspaceId, loop, turn);
-        const headers = Object.keys(metaHeaders).length > 0 ? { ...this.#headers, ...metaHeaders } : this.#headers;
+        const headers = Object.keys(metaHeaders).length === 0
+            ? this.#headers
+            : { ...this.#headers, ...metaHeaders };
         let raw;
         try {
             raw = this.#languageModel === undefined
@@ -716,45 +738,47 @@ export default class AiSdkProvider implements Provider {
         // wire text for forensics.
         if (this.#eosText !== undefined) raw.content = stripTrailingSpecial(raw.content, this.#eosText);
 
-        const taggedReasoning = projectTaggedReasoning(
-            raw.content,
-            raw.reasoning,
-            this.#reasoningResponseStyle,
-        );
+        const grammarInput = raw.content;
+        const projectedReasoning = preserveGrammarSentence && !raw.reasoningProjected
+            ? projectTemplateReasoning(raw.content)
+            : projectTaggedReasoning(
+                raw.content,
+                raw.reasoning,
+                this.#reasoningResponseStyle,
+            );
 
-        // Preserve the exact sentence seen at the grammar boundary. llama-server's
-        // `reasoning_format: "auto"` projects one raw Harmony enclosure into the
-        // reasoning/content fields; the wire field's presence is the proof that the
-        // projection occurred. The provider represents this evidence and never grades it.
+        // Preserve the exact sentence seen at the grammar boundary. Constrained
+        // template turns request `reasoning_format: "none"`, so even an empty
+        // channel remains observable. An unexpectedly projected response cannot
+        // supply independent pre-projection evidence.
         let grammarEvidence: GrammarEvidence | undefined;
         if (wantGrammar) {
-            if (taggedReasoning.projected) {
-                grammarEvidence = {
-                    input: raw.content,
-                    contentStart: taggedReasoning.contentStart,
-                    transported: sendGrammar !== undefined,
-                };
-            } else if (this.#reasoningStyle === "template" && this.#reasoning.mode !== "off") {
-                if (raw.reasoningProjected) {
-                    const prefix = `<|channel>thought\n${raw.reasoning}<channel|>`;
+            if (preserveGrammarSentence) {
+                if (!raw.reasoningProjected) {
                     grammarEvidence = {
-                        input: `${prefix}${raw.content}`,
-                        contentStart: [...prefix].length,
+                        input: grammarInput,
+                        contentStart: projectedReasoning.projected ? projectedReasoning.contentStart : 0,
                         transported: sendGrammar !== undefined,
                     };
                 }
+            } else if (projectedReasoning.projected) {
+                grammarEvidence = {
+                    input: grammarInput,
+                    contentStart: projectedReasoning.contentStart,
+                    transported: sendGrammar !== undefined,
+                };
             } else {
                 grammarEvidence = {
-                    input: raw.content,
+                    input: grammarInput,
                     contentStart: 0,
                     transported: sendGrammar !== undefined,
                 };
             }
         }
 
-        if (taggedReasoning.projected) {
-            raw.content = taggedReasoning.content;
-            raw.reasoning = taggedReasoning.reasoning;
+        if (projectedReasoning.projected) {
+            raw.content = projectedReasoning.content;
+            raw.reasoning = projectedReasoning.reasoning;
             raw.usage = attributeUnitemizedReasoning(raw.usage, raw.reasoning, raw.content);
         }
 
@@ -804,8 +828,13 @@ export default class AiSdkProvider implements Provider {
             model: raw.model,
             ...(logprobs !== undefined ? { logprobs, meanLogprob } : {}),
         };
+        const normalizedCharge = this.#normalizeCharge?.(raw.chargeEvidence);
+        const charge = normalizedCharge === undefined
+            ? undefined
+            : validateAuthoritativeCharge(normalizedCharge);
         const evidence = {
             assistantRaw: raw,
+            ...(charge === undefined ? {} : { charge }),
             ...(grammarEvidence !== undefined ? { grammarEvidence } : {}),
             ...(raw.rawBody !== undefined ? { rawBody: raw.rawBody } : {}),
             ...(meta !== undefined ? { meta } : {}),
@@ -837,4 +866,5 @@ export default class AiSdkProvider implements Provider {
             ...evidence,
         };
     }
+
 }

package/src/Mock.ts

@@ -5,7 +5,7 @@
 // Provider contract. Production providers don't expose the `ops` escape
 // hatch — that's an intg-only convenience.
 
-import type { ChatMessage, FinishReason, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderAssistant, ProviderEncryptedReasoningItem, ProviderResponse, ProviderUsage } from "./types.ts";
+import type { AuthoritativeCharge, ChatMessage, FinishReason, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderAssistant, ProviderEncryptedReasoningItem, ProviderResponse, ProviderUsage } from "./types.ts";
 import type { ProviderCost } from "@plurnk/plurnk-contracts";
 import { resolveEnvelopeFromEnv } from "./env.ts";
 
@@ -28,6 +28,7 @@ export type MockAssistant = {
 export type MockResponse = {
     assistant: MockAssistant;
     assistantRaw?: unknown;
+    charge?: AuthoritativeCharge;
     grammarEvidence?: GrammarEvidence;
 };
 
@@ -36,6 +37,7 @@ export type MockReturnedAssistant = ProviderAssistant & { ops?: unknown[] };
 export type MockReturnedResponse = ProviderResponse & { assistant: MockReturnedAssistant };
 
 const DEFAULT_USAGE: ProviderUsage = { prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 };
+type MockGenerateArgs = Omit<Parameters<Provider["generate"]>[0], "workerId"> & { workerId?: string };
 
 export default class Mock implements Provider {
     #contextWindow: number | null;
@@ -79,7 +81,7 @@ export default class Mock implements Provider {
     calculateCost(_usage: ProviderUsage): number { return 0; }
     calculateCharge(_usage: ProviderUsage): Exclude<ProviderCost, { kind: "authoritative" }> { return { kind: "free", source: "mock provider" }; }
 
-    async generate({ signal, grammar }: { messages: ChatMessage[]; workerId?: string; signal?: AbortSignal; grammar?: string }): Promise<MockReturnedResponse> {
+    async generate({ signal, grammar }: MockGenerateArgs): Promise<MockReturnedResponse> {
         // Honor abort before consuming the queue — an aborted call makes no
         // "wire call" and must not exhaust a queued response
         // ({§provider-failure-normalization}).
@@ -103,6 +105,7 @@ export default class Mock implements Provider {
         return {
             assistant,
             assistantRaw: next.assistantRaw ?? null,
+            ...(next.charge === undefined ? {} : { charge: next.charge }),
             ...(grammarEvidence !== undefined ? { grammarEvidence } : {}),
         };
     }

package/src/Pool.ts

@@ -128,7 +128,7 @@ export default class Pool implements Provider {
     calculateCost(usage: ProviderUsage): number { return this.#backends[0].calculateCost(usage); }
     calculateCharge(usage: ProviderUsage): Exclude<ProviderCost, { kind: "authoritative" }> {
         const backend = this.#backends[0];
-        return resolveProviderCost(undefined, backend.calculateCharge?.(usage), () => backend.calculateCost(usage)) as Exclude<ProviderCost, { kind: "authoritative" }>;
+        return resolveProviderCost(undefined, backend.calculateCharge?.(usage)) as Exclude<ProviderCost, { kind: "authoritative" }>;
     }
 
     // --- dispatch ---