@plurnk/plurnk-providers 1.4.0 → 1.6.0

package/src/AiSdkProvider.test.ts

@@ -1,7 +1,25 @@
 import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
-import AiSdkProvider, { effortFromBudget } from "./AiSdkProvider.ts";
+import AiSdkProvider, { effortFromBudget, type AiSdkProviderConfig } from "./AiSdkProvider.ts";
 import { ProviderError } from "./errors.ts";
+import { providerCostNormalizer } from "./accounting.ts";
+import type { LanguageModel } from "ai";
+
+type TestProviderConfig = Omit<AiSdkProviderConfig, "operationTimeoutMs" | "firstContentTimeoutMs">
+    & Partial<Pick<AiSdkProviderConfig, "operationTimeoutMs" | "firstContentTimeoutMs">>;
+
+const testProvider = (config: TestProviderConfig): AiSdkProvider => {
+    const {
+        operationTimeoutMs = config.fetchTimeoutMs,
+        firstContentTimeoutMs = 0,
+        ...rest
+    } = config;
+    return new AiSdkProvider({
+        ...rest,
+        operationTimeoutMs,
+        firstContentTimeoutMs,
+    });
+};
 
 // Build a fake fetch returning a one-chunk SSE stream, capturing the request
 // so tests can assert what the spine sent on the wire.
@@ -59,6 +77,31 @@ const installFetchJson = (payload: unknown) => {
     return calls;
 };
 
+const settledCharge = {
+    kind: "charged",
+    amount: { amount: "0.00000042", currency: "XMR" },
+    usdEquivalent: "0.000071",
+    source: "plurnk endpoint settlement",
+} as const;
+
+const billedErrorBody = {
+    status: 422,
+    error: {
+        message: "non-conforming emission rejected",
+        type: "grammar_invalid",
+    },
+    usage: {
+        prompt_tokens: 8,
+        completion_tokens: 3,
+        reasoning_tokens: 0,
+        prompt_tokens_details: { cached_tokens: 2 },
+        total_tokens: 11,
+    },
+    charge: settledCharge,
+};
+
+const directCost = ({ charge }: { charge?: unknown }) => charge as typeof settledCharge | undefined;
+
 const jsonChoice = { model: "m", choices: [{ message: { content: "x" }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } };
 
 const injectedBase = {
@@ -88,9 +131,9 @@ test("per-instance fetch owns streaming and buffered requests", async () => {
         }), { status: 200, headers: { "Content-Type": "application/json" } });
     };
 
-    const streamed = await new AiSdkProvider({ ...injectedBase, fetch: streamingFetch, rawBody: true })
+    const streamed = await testProvider({ ...injectedBase, fetch: streamingFetch, rawBody: true })
         .generate({ workerId: "stream", messages: [{ role: "user", content: "hello" }] });
-    const buffered = await new AiSdkProvider({ ...injectedBase, fetch: bufferedFetch, streaming: false })
+    const buffered = await testProvider({ ...injectedBase, fetch: bufferedFetch, streaming: false })
         .generate({ workerId: "buffer", messages: [{ role: "user", content: "hello" }] });
 
     assert.equal(streamed.assistant.content, "streamed");
@@ -114,12 +157,17 @@ test("caller cancellation and provider timeout reach an injected fetch", async (
         });
     };
     const caller = new AbortController();
-    const callerProvider = new AiSdkProvider({ ...injectedBase, fetch: pendingFetch });
+    const callerProvider = testProvider({ ...injectedBase, fetch: pendingFetch });
     const callerRequest = callerProvider.generate({ workerId: "cancel", messages: [], signal: caller.signal });
     caller.abort(new Error("operator cancelled"));
     await assert.rejects(callerRequest, /operator cancelled/);
 
-    const timeoutProvider = new AiSdkProvider({ ...injectedBase, fetch: pendingFetch, fetchTimeoutMs: 1 });
+    const timeoutProvider = testProvider({
+        ...injectedBase,
+        fetch: pendingFetch,
+        fetchTimeoutMs: 1,
+        operationTimeoutMs: 100,
+    });
     await assert.rejects(
         timeoutProvider.generate({ workerId: "timeout", messages: [] }),
         (error: ProviderError) => error.kind === "network_failure",
@@ -141,7 +189,7 @@ test("per-instance fetch owns tokenization and retry attempts", async () => {
             { choices: [], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } },
         ]), { status: 200 });
     };
-    const provider = new AiSdkProvider({
+    const provider = testProvider({
         ...injectedBase,
         fetch: providerFetch,
         retryAttempts: 1,
@@ -157,6 +205,60 @@ test("per-instance fetch owns tokenization and retry attempts", async () => {
     ]);
 });
 
+test("request-observer open failures preserve the durability cause and issue no provider I/O", async () => {
+    const root = new Error("durable request open failed");
+    let calls = 0;
+    const provider = testProvider({
+        ...injectedBase,
+        retryAttempts: 3,
+        fetch: async () => {
+            calls++;
+            return new Response(JSON.stringify(jsonChoice), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+        streaming: false,
+    });
+
+    await assert.rejects(
+        provider.generate({
+            workerId: "observer-open",
+            messages: [],
+            observeRequest: async () => { throw root; },
+        }),
+        (error: unknown) => error === root,
+    );
+    assert.equal(calls, 0);
+});
+
+test("request-observer settlement failures preserve the durability cause without retrying I/O", async () => {
+    const root = new Error("durable request settlement failed");
+    let calls = 0;
+    const provider = testProvider({
+        ...injectedBase,
+        retryAttempts: 3,
+        fetch: async () => {
+            calls++;
+            return new Response(JSON.stringify(jsonChoice), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+        streaming: false,
+    });
+
+    await assert.rejects(
+        provider.generate({
+            workerId: "observer-settle",
+            messages: [],
+            observeRequest: async () => async () => { throw root; },
+        }),
+        (error: unknown) => error === root,
+    );
+    assert.equal(calls, 1);
+});
+
 // Sequenced fetch mock for retry tests: each entry is one HTTP response. A 200
 // streams its chunks; any other status returns that error (with an optional
 // retry-after header). The last entry repeats once the script runs out.
@@ -204,8 +306,13 @@ test("effortFromBudget: maps budget to tiers", () => {
 
 test("a 524 Cloudflare edge timeout fails fast - not retried despite retryAttempts", async () => {
     const calls = installFetchScript([{ status: 524, retryAfter: 120 }]);
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 3 });
-    await assert.rejects(p.generate({ workerId: "r", messages: [] }));
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 3 });
+    await assert.rejects(
+        p.generate({ workerId: "r", messages: [] }),
+        (error: ProviderError) => error.kind === "network_failure"
+            && error.status === 524
+            && error.problem.retryable === false,
+    );
     await flush();
     assert.equal(calls.length, 1); // edge code: one attempt, no retry despite retryAttempts: 3
     mock.restoreAll();
@@ -214,7 +321,7 @@ test("a 524 Cloudflare edge timeout fails fast - not retried despite retryAttemp
 test("a 422 grammar_invalid is a failed exchange, not transport replay policy", async () => {
     const body = JSON.stringify({ error: { message: "non-conforming emission rejected: ...", type: "grammar_invalid" } });
     const calls = installFetchScript([{ status: 422, body }]);
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 2 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 2 });
     await assert.rejects(
         p.generate({ workerId: "r", messages: [] }),
         (e: unknown) => e instanceof ProviderError && e.kind === "grammar_invalid",
@@ -229,7 +336,7 @@ test("an SSE error frame is a failed exchange, not an empty completion", async (
         status: 422,
         error: { message: "non-conforming emission rejected", type: "grammar_invalid" },
     }]);
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     await assert.rejects(
         p.generate({ workerId: "r", messages: [] }),
         (e: unknown) => e instanceof ProviderError && e.kind === "grammar_invalid",
@@ -237,29 +344,138 @@ test("an SSE error frame is a failed exchange, not an empty completion", async (
     assert.equal(calls.length, 1);
 });
 
+test("a buffered classified error retains normalized usage and settled charge", async () => {
+    const calls = installFetchScript([{ status: 422, body: JSON.stringify(billedErrorBody) }]);
+    const p = testProvider({
+        ...injectedBase,
+        streaming: false,
+        normalizeCost: directCost,
+    });
+    await assert.rejects(
+        p.generate({ workerId: "billed-json-error", messages: [] }),
+        (error: unknown) => {
+            assert.ok(error instanceof ProviderError);
+            assert.equal(error.kind, "grammar_invalid");
+            assert.deepEqual(error.accounting, [{
+                provider: "provider",
+                model: "m",
+                outcome: "error",
+                status: 422,
+                usage: {
+                    inputTokens: 8,
+                    outputTokens: 3,
+                    totalTokens: 11,
+                    inputTokenDetails: { cacheReadTokens: 2 },
+                    outputTokenDetails: { textTokens: 3, reasoningTokens: 0 },
+                },
+                cost: settledCharge,
+            }]);
+            assert.equal(error.attempt, undefined, "accounting evidence does not fabricate an assistant response");
+            return true;
+        },
+    );
+    assert.equal(calls.length, 1);
+});
+
+test("an SSE classified error retains the same normalized usage and settled charge", async () => {
+    const calls = installFetch([billedErrorBody]);
+    const p = testProvider({
+        ...injectedBase,
+        normalizeCost: directCost,
+    });
+    await assert.rejects(
+        p.generate({ workerId: "billed-sse-error", messages: [] }),
+        (error: unknown) => {
+            assert.ok(error instanceof ProviderError);
+            assert.equal(error.kind, "grammar_invalid");
+            assert.deepEqual(error.accounting, [{
+                provider: "provider",
+                model: "m",
+                outcome: "error",
+                status: 422,
+                usage: {
+                    inputTokens: 8,
+                    outputTokens: 3,
+                    totalTokens: 11,
+                    inputTokenDetails: { cacheReadTokens: 2 },
+                    outputTokenDetails: { textTokens: 3, reasoningTokens: 0 },
+                },
+                cost: settledCharge,
+            }]);
+            assert.equal(error.attempt, undefined);
+            return true;
+        },
+    );
+    assert.equal(calls.length, 1);
+});
+
+test("a successful response normalizes direct charge without duplicating it as metadata", async () => {
+    installFetchJson({ ...jsonChoice, charge: settledCharge });
+    const p = testProvider({
+        ...injectedBase,
+        streaming: false,
+        normalizeCost: directCost,
+    });
+    const response = await p.generate({ workerId: "billed-json-success", messages: [] });
+    assert.deepEqual(response.accounting[0]?.cost, settledCharge);
+    assert.equal(response.meta?.charge, undefined);
+});
+
+test("malformed monetary evidence closes the physical request before surfacing the normalization failure", async () => {
+    const root = new TypeError("direct charge is malformed");
+    const settled: unknown[] = [];
+    const calls = installFetchJson({ ...jsonChoice, charge: { malformed: true } });
+    const provider = testProvider({
+        ...injectedBase,
+        retryAttempts: 3,
+        streaming: false,
+        normalizeCost: () => { throw root; },
+    });
+
+    await assert.rejects(
+        provider.generate({
+            workerId: "malformed-charge",
+            messages: [],
+            observeRequest: async () => async (accounting) => { settled.push(accounting); },
+        }),
+        (error: unknown) => error === root,
+    );
+    assert.equal(calls.length, 1);
+    assert.deepEqual(settled, [{
+        provider: "provider",
+        model: "m",
+        outcome: "response",
+        usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        cost: {
+            kind: "unknown",
+            reason: "provider request accounting could not be normalized after physical I/O",
+        },
+    }]);
+});
+
 test("a trailing eos_token (--special EOG leak) is stripped from content", async () => {
     installFetchJson({ model: "m", choices: [{ message: { content: "the answer<eos>" }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 3, total_tokens: 4 } });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, eosText: "<eos>" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, eosText: "<eos>" });
     const res = await p.generate({ workerId: "r", messages: [] });
     assert.equal(res.assistant.content, "the answer"); // trailing <eos> gone; packet + verdict see clean bytes
 });
 
 test("without a probed eos_token the content passes through untouched", async () => {
     installFetchJson({ model: "m", choices: [{ message: { content: "keeps <eos> literally" }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 3, total_tokens: 4 } });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
     const res = await p.generate({ workerId: "r", messages: [] });
     assert.equal(res.assistant.content, "keeps <eos> literally"); // no eosText (a cloud backend) -> no strip
 });
 
 test("only the trailing eos_token is stripped; a quoted one mid-body survives", async () => {
     installFetchJson({ model: "m", choices: [{ message: { content: "quotes <eos> in the body<eos>" }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 5, total_tokens: 6 } });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, eosText: "<eos>" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, eosText: "<eos>" });
     const res = await p.generate({ workerId: "r", messages: [] });
     assert.equal(res.assistant.content, "quotes <eos> in the body"); // only the tail goes
 });
 
 test("identity getters and default prompt estimate", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     assert.equal(p.model, "m");
     assert.equal(p.contextWindow, null); // default
     assert.deepEqual(
@@ -272,43 +488,258 @@ test("identity getters and default prompt estimate", async () => {
         },
         "chars/2 is explicitly an estimate; high-token-density Unicode prevents an upper-bound claim",
     );
-    assert.equal(p.calculateCost({ prompt: 9, completion: 9, reasoning: 0, cached: 0, total: 18 }), 0); // current unknown-rate sentinel
 });
 
-test("injected prompt measurement preserves provenance and calculateCost is used", async () => {
+test("injected prompt measurement preserves provenance and request cost estimation stays internal", async () => {
     const seen: string[] = [];
-    const p = new AiSdkProvider({
+    installFetchJson(jsonChoice);
+    const p = testProvider({
         model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0,
         countPromptTokens: (messages) => {
             seen.push(...messages.map(({ content }) => content));
             return { kind: "upper_bound", tokens: 7, source: "test:proven-bound" };
         },
-        calculateCost: (u) => u.total * 2,
+        streaming: false,
+        estimateCost: (usage) => ({
+            kind: "estimated",
+            amount: { amount: String((usage?.totalTokens ?? 0) * 2), currency: "USD" },
+            source: "test estimator",
+        }),
     });
     assert.deepEqual(
         await p.countPromptTokens([{ role: "system", content: "system" }, { role: "user", content: "user" }]),
         { kind: "upper_bound", tokens: 7, source: "test:proven-bound" },
     );
     assert.deepEqual(seen, ["system", "user"]);
-    assert.equal(p.calculateCost({ prompt: 1, completion: 1, reasoning: 0, cached: 0, total: 5 }), 10);
+    const response = await p.generate({ workerId: "accounted", messages: [] });
+    assert.deepEqual(response.accounting[0]?.cost, {
+        kind: "estimated",
+        amount: { amount: "4", currency: "USD" },
+        source: "test estimator",
+    });
 });
 
 test("generate maps a streamed response into ProviderResponse", async () => {
-    const p = new AiSdkProvider({ model: "req-model", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "req-model", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([
         { model: "wire-model", choices: [{ delta: { content: "hel" } }] },
         { choices: [{ delta: { content: "lo" }, finish_reason: "stop" }] },
         { usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5, cached_tokens: 1 } },
     ]);
-    const { assistant, assistantRaw } = await p.generate({ workerId: "r", messages: [{ role: "user", content: "hi" }] });
+    const { assistant, assistantRaw, accounting } = await p.generate({ workerId: "r", messages: [{ role: "user", content: "hi" }] });
     assert.equal(assistant.content, "hello");
     assert.equal(assistant.model, "wire-model"); // wire-reported wins
     assert.equal(assistant.finishReason, "stop");
-    assert.deepEqual(assistant.usage, { prompt: 3, completion: 2, reasoning: 0, cached: 1, total: 5 });
+    assert.deepEqual(accounting[0]?.usage, {
+        inputTokens: 3,
+        outputTokens: 2,
+        totalTokens: 5,
+        inputTokenDetails: { cacheReadTokens: 1 },
+    });
     assert.equal(assistant.reasoning, null); // none emitted
     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: "charged",
+        amount: { amount: "0.00154935", currency: "USD" },
+        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,
+        normalizeCost: providerCostNormalizer("@openrouter/ai-sdk-provider"),
+    };
+
+    await t.test("buffered", async () => {
+        const response = await testProvider({ ...config, streaming: false })
+            .generate({ workerId: "buffered", messages: [] });
+        assert.deepEqual(response.accounting[0]?.cost, charge);
+    });
+    await t.test("streamed", async () => {
+        const response = await testProvider(config)
+            .generate({ workerId: "streamed", messages: [] });
+        assert.deepEqual(response.accounting[0]?.cost, charge);
+    });
+});
+
+test("native SDK providers share the first-content retry contract", async () => {
+    let calls = 0;
+    const usage = {
+        inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+        outputTokens: { total: 1, text: 1, reasoning: 0 },
+    };
+    const languageModel = {
+        specificationVersion: "v4",
+        provider: "native.test",
+        modelId: "native-timeout",
+        supportedUrls: {},
+        doGenerate: async () => { throw new Error("buffered generation is not under test"); },
+        doStream: async ({ abortSignal }: { abortSignal?: AbortSignal }) => {
+            calls++;
+            if (calls > 1) {
+                return {
+                    stream: new ReadableStream({
+                        start(controller) {
+                            controller.enqueue({ type: "stream-start", warnings: [] });
+                            controller.enqueue({ type: "response-metadata", id: "native-retry", modelId: "native-timeout" });
+                            controller.enqueue({ type: "text-start", id: "text-1" });
+                            controller.enqueue({ type: "text-delta", id: "text-1", delta: "recovered" });
+                            controller.enqueue({ type: "text-end", id: "text-1" });
+                            controller.enqueue({
+                                type: "finish",
+                                finishReason: { unified: "stop", raw: "completed" },
+                                usage,
+                            });
+                            controller.close();
+                        },
+                    }),
+                    response: {},
+                };
+            }
+            return {
+                stream: new ReadableStream({
+                    start(controller) {
+                        controller.enqueue({ type: "stream-start", warnings: [] });
+                        const timer = setTimeout(() => controller.close(), 100);
+                        abortSignal?.addEventListener("abort", () => {
+                            clearTimeout(timer);
+                            controller.error(abortSignal.reason);
+                        }, { once: true });
+                    },
+                }),
+                response: {},
+            };
+        },
+    } as unknown as LanguageModel;
+    const provider = testProvider({
+        model: "native-timeout",
+        languageModel,
+        fetchTimeoutMs: 5_000,
+        operationTimeoutMs: 5_000,
+        firstContentTimeoutMs: 10,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 1,
+        source: "provider:test-native",
+    });
+
+    const result = await provider.generate({ workerId: "native-retry", messages: [] });
+    assert.equal(result.assistant.content, "recovered");
+    assert.equal(calls, 2);
+    assert.deepEqual(result.accounting.map(({ outcome }) => outcome), ["error", "response"]);
+});
+
+test("compatible xAI wire usage becomes an exact tick charge without raw-body capture", async () => {
+    const p = testProvider({
+        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,
+        normalizeCost: providerCostNormalizer("@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.accounting[0]?.cost, {
+        kind: "charged",
+        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 = testProvider({
+        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,
+        normalizeCost: providerCostNormalizer("@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.accounting[0]?.cost, {
+        kind: "charged",
+        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 }) => {
@@ -317,7 +748,7 @@ test("generate surfaces and normalizes an out-of-set finish_reason", async () =>
             ...(typeof options === "object" && options.code !== undefined ? { code: options.code } : {}),
         });
     });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { content: "x" }, finish_reason: "function_call" }] }]);
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.finishReason, null);
@@ -335,7 +766,7 @@ test("#161: a streamed resource interruption is a failed exchange with complete
             usage: { prompt_tokens: 7, completion_tokens: 5, total_tokens: 12 },
         },
     ]);
-    const provider = new AiSdkProvider({
+    const provider = testProvider({
         ...injectedBase,
         retryAttempts: 2,
         rawBody: true,
@@ -354,12 +785,10 @@ test("#161: a streamed resource interruption is a failed exchange with complete
             assert.equal(error.attempt?.assistant.content, "partial answer");
             assert.equal(error.attempt?.assistant.reasoning, "partial thought");
             assert.equal(error.attempt?.assistant.finishReason, "resource_interrupted");
-            assert.deepEqual(error.attempt?.assistant.usage, {
-                prompt: 7,
-                completion: 2,
-                reasoning: 3,
-                cached: 0,
-                total: 12,
+            assert.deepEqual(error.accounting[0]?.usage, {
+                inputTokens: 7,
+                outputTokens: 5,
+                totalTokens: 12,
             });
             assert.equal(
                 (error.attempt?.assistantRaw as { rawFinishReason?: string }).rawFinishReason,
@@ -382,7 +811,7 @@ test("#161: a buffered resource interruption preserves the successful wire respo
         usage: { prompt_tokens: 7, completion_tokens: 5, total_tokens: 12 },
     };
     const calls = installFetchJson(wire);
-    const provider = new AiSdkProvider({
+    const provider = testProvider({
         ...injectedBase,
         streaming: false,
         retryAttempts: 2,
@@ -411,37 +840,37 @@ test("#161: a buffered resource interruption preserves the successful wire respo
 test("generate translates a backend cap synonym to canonical length", async () => {
     // gemini shouts MAX_TOKENS, anthropic says max_tokens -- both must reach core as
     // "length" so its truncation check (=== "length") is a cross-backend invariant.
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { content: "x" }, finish_reason: "MAX_TOKENS" }] }]);
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.finishReason, "length");
 });
 
 test("generate translates end_turn to canonical stop", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { content: "x" }, finish_reason: "end_turn" }] }]);
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.finishReason, "stop");
 });
 
 test("generate translates xAI completed to canonical stop", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { content: "x" }, finish_reason: "completed" }] }]);
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.finishReason, "stop");
 });
 
 test("generate aggregates reasoning deltas under multiple field names", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { reasoning_content: "be", thinking: "cause" } }] }]);
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.reasoning, "because");
     assert.equal("reasoningEncrypted" in assistant, false); // open reasoning only -> field absent
 });
 
-test("{§provider-tagged-reasoning} explicit think-tags projects one streamed leading envelope and reclassifies usage", async () => {
+test("{§provider-tagged-reasoning} explicit think-tags project content without estimating token attribution", async () => {
     const config = { ...injectedBase, reasoningResponseStyle: "think-tags" as const, rawBody: true };
-    const p = new AiSdkProvider(config);
+    const p = testProvider(config);
     installFetch([
         { choices: [{ delta: { content: "<thi" } }] },
         { choices: [{ delta: { content: "nk>12345</th" } }] },
@@ -453,12 +882,10 @@ test("{§provider-tagged-reasoning} explicit think-tags projects one streamed le
 
     assert.equal(response.assistant.reasoning, "12345");
     assert.equal(response.assistant.content, "abcde");
-    assert.deepEqual(response.assistant.usage, {
-        prompt: 3,
-        completion: 5,
-        reasoning: 5,
-        cached: 0,
-        total: 13,
+    assert.deepEqual(response.accounting[0]?.usage, {
+        inputTokens: 3,
+        outputTokens: 10,
+        totalTokens: 13,
     });
     assert.deepEqual(
         ((response.assistantRaw as { content: string; reasoning: string }).content),
@@ -476,12 +903,12 @@ test("{§provider-tagged-reasoning} explicit think-tags projects one buffered le
         usage: { prompt_tokens: 3, completion_tokens: 10, total_tokens: 13 },
     });
     const config = { ...injectedBase, streaming: false, reasoningResponseStyle: "think-tags" as const };
-    const response = await new AiSdkProvider(config).generate({ workerId: "tagged-buffer", messages: [] });
+    const response = await testProvider(config).generate({ workerId: "tagged-buffer", messages: [] });
 
     assert.equal(response.assistant.reasoning, "12345");
     assert.equal(response.assistant.content, "abcde");
-    assert.equal(response.assistant.usage.completion, 5);
-    assert.equal(response.assistant.usage.reasoning, 5);
+    assert.equal(response.accounting[0]?.usage?.outputTokens, 10);
+    assert.equal(response.accounting[0]?.usage?.outputTokenDetails, undefined);
 });
 
 test("{§provider-tagged-reasoning} tagged text does not overwrite itemized reasoning usage", async () => {
@@ -496,12 +923,14 @@ test("{§provider-tagged-reasoning} tagged text does not overwrite itemized reas
         },
     });
     const config = { ...injectedBase, streaming: false, reasoningResponseStyle: "think-tags" as const };
-    const response = await new AiSdkProvider(config).generate({ workerId: "tagged-itemized", messages: [] });
+    const response = await testProvider(config).generate({ workerId: "tagged-itemized", messages: [] });
 
     assert.equal(response.assistant.reasoning, "12345");
     assert.equal(response.assistant.content, "abcde");
-    assert.equal(response.assistant.usage.completion, 7);
-    assert.equal(response.assistant.usage.reasoning, 3);
+    assert.deepEqual(response.accounting[0]?.usage?.outputTokenDetails, {
+        textTokens: 7,
+        reasoningTokens: 3,
+    });
 });
 
 test("{§provider-tagged-reasoning} an unclosed capped envelope is wholly reasoning in streamed and buffered responses", async () => {
@@ -510,15 +939,13 @@ test("{§provider-tagged-reasoning} an unclosed capped envelope is wholly reason
         { choices: [{ delta: { content: "<think>unfinished" }, finish_reason: "length" }] },
         { usage: { prompt_tokens: 3, completion_tokens: 8, total_tokens: 11 } },
     ]);
-    const streamed = await new AiSdkProvider(config).generate({ workerId: "tagged-capped-stream", messages: [] });
+    const streamed = await testProvider(config).generate({ workerId: "tagged-capped-stream", messages: [] });
     assert.equal(streamed.assistant.reasoning, "unfinished");
     assert.equal(streamed.assistant.content, "");
-    assert.deepEqual(streamed.assistant.usage, {
-        prompt: 3,
-        completion: 0,
-        reasoning: 8,
-        cached: 0,
-        total: 11,
+    assert.deepEqual(streamed.accounting[0]?.usage, {
+        inputTokens: 3,
+        outputTokens: 8,
+        totalTokens: 11,
     });
 
     mock.restoreAll();
@@ -528,11 +955,11 @@ test("{§provider-tagged-reasoning} an unclosed capped envelope is wholly reason
         usage: { prompt_tokens: 3, completion_tokens: 8, total_tokens: 11 },
     });
     const bufferedConfig = { ...config, streaming: false };
-    const buffered = await new AiSdkProvider(bufferedConfig).generate({ workerId: "tagged-capped-buffer", messages: [] });
+    const buffered = await testProvider(bufferedConfig).generate({ workerId: "tagged-capped-buffer", messages: [] });
     assert.equal(buffered.assistant.reasoning, "unfinished");
     assert.equal(buffered.assistant.content, "");
-    assert.equal(buffered.assistant.usage.completion, 0);
-    assert.equal(buffered.assistant.usage.reasoning, 8);
+    assert.equal(buffered.accounting[0]?.usage?.outputTokens, 8);
+    assert.equal(buffered.accounting[0]?.usage?.outputTokenDetails, undefined);
 });
 
 test("{§provider-tagged-reasoning} verbatim, non-leading, and structured-reasoning controls preserve literal tags", async () => {
@@ -541,11 +968,11 @@ test("{§provider-tagged-reasoning} verbatim, non-leading, and structured-reason
         choices: [{ message: { content: "<think>literal</think>answer" }, finish_reason: "stop" }],
         usage: { prompt_tokens: 1, completion_tokens: 4, total_tokens: 5 },
     });
-    const verbatim = await new AiSdkProvider({ ...injectedBase, streaming: false })
+    const verbatim = await testProvider({ ...injectedBase, streaming: false })
         .generate({ workerId: "verbatim", messages: [] });
     assert.equal(verbatim.assistant.content, "<think>literal</think>answer");
     assert.equal(verbatim.assistant.reasoning, null);
-    assert.equal(verbatim.assistant.usage.completion, 4);
+    assert.equal(verbatim.accounting[0]?.usage?.outputTokens, 4);
 
     mock.restoreAll();
     installFetchJson({
@@ -554,7 +981,7 @@ test("{§provider-tagged-reasoning} verbatim, non-leading, and structured-reason
         usage: { prompt_tokens: 1, completion_tokens: 5, total_tokens: 6 },
     });
     const taggedConfig = { ...injectedBase, streaming: false, reasoningResponseStyle: "think-tags" as const };
-    const nonLeading = await new AiSdkProvider(taggedConfig)
+    const nonLeading = await testProvider(taggedConfig)
         .generate({ workerId: "non-leading", messages: [] });
     assert.equal(nonLeading.assistant.content, "show <think>literal</think> exactly");
     assert.equal(nonLeading.assistant.reasoning, null);
@@ -568,14 +995,14 @@ test("{§provider-tagged-reasoning} verbatim, non-leading, and structured-reason
         }, finish_reason: "stop" }],
         usage: { prompt_tokens: 1, completion_tokens: 7, total_tokens: 8 },
     });
-    const structured = await new AiSdkProvider(taggedConfig)
+    const structured = await testProvider(taggedConfig)
         .generate({ workerId: "structured", messages: [] });
     assert.equal(structured.assistant.content, "<think>literal visible bytes</think>");
     assert.equal(structured.assistant.reasoning, "structured reasoning");
 });
 
 test("{§provider-tagged-reasoning} grammar evidence retains the exact pre-projection tagged sentence", async () => {
-    const content = "<think>🧠reason</think><<PLAN::PLAN\n<<SEND[200]:done:SEND";
+    const content = "<think>🧠reason</think># PLAN0\n\n## SEND0 [200]\ndone";
     const config = {
         ...injectedBase,
         contextWindow: 640,
@@ -586,14 +1013,14 @@ test("{§provider-tagged-reasoning} grammar evidence retains the exact pre-proje
     };
     installFetch([{ choices: [{ delta: { content }, finish_reason: "stop" }] }]);
 
-    const response = await new AiSdkProvider(config).generate({
+    const response = await testProvider(config).generate({
         workerId: "tagged-grammar",
         messages: [],
         grammar: `root ::= ${JSON.stringify(content)}`,
     });
 
     assert.equal(response.assistant.reasoning, "🧠reason");
-    assert.equal(response.assistant.content, "<<PLAN::PLAN\n<<SEND[200]:done:SEND");
+    assert.equal(response.assistant.content, "# PLAN0\n\n## SEND0 [200]\ndone");
     assert.deepEqual(response.grammarEvidence, {
         input: content,
         contentStart: [..."<think>🧠reason</think>"].length,
@@ -610,7 +1037,7 @@ test("encrypted reasoning (non-streamed): encrypted entries normalize and text e
             { type: "reasoning.text", text: "never surfaced here" },
         ],
     }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     // Wire detail ID is preserved; the assistant-message location supports the
     // derived classification but supplies no downstream client entity ID.
@@ -624,7 +1051,7 @@ test("distinct encrypted-reasoning wire ids stay distinct items", async () => {
         { type: "reasoning.encrypted", data: "AAA", format: "openai-responses-v1", id: "rs_1" },
         { type: "reasoning.encrypted", data: "BBB", format: "openai-responses-v1", id: "rs_2" },
     ] }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.reasoningEncrypted?.length, 2);
     assert.deepEqual(assistant.reasoningEncrypted?.map((i) => i.id), ["rs_1", "rs_2"]);
@@ -634,7 +1061,7 @@ test("assistant-message location classifies encrypted reasoning without inventin
     installFetchJson({ model: "m", choices: [{ message: { content: "ok", reasoning_details: [
         { type: "reasoning.encrypted", data: "OPAQUE", format: "openai-responses-v1", id: null, index: 0 },
     ] }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.deepEqual(assistant.reasoningEncrypted, [{
         id: null,
@@ -644,7 +1071,7 @@ test("assistant-message location classifies encrypted reasoning without inventin
 });
 
 test("encrypted reasoning (streamed): chunked blob concatenates per entry index", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([
         { choices: [{ delta: { reasoning_details: [{ type: "reasoning.encrypted", data: "gAAAA", format: "openai-responses-v1", id: "rs_1", index: 0 }] } }] },
         { choices: [{ delta: { reasoning_details: [{ type: "reasoning.encrypted", data: "BqXYZ", id: "rs_1", index: 0 }] } }] },
@@ -655,32 +1082,35 @@ test("encrypted reasoning (streamed): chunked blob concatenates per entry index"
     assert.equal(assistant.content, "4");
 });
 
-test("reasoningStyle 'think' gates on budget != 0 (magnitude irrelevant for native)", async () => {
-    const on = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "think" });
+test("reasoningStyle 'think' follows activation (magnitude is irrelevant to the boolean wire control)", async () => {
+    const on = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "think" });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await on.generate({ workerId: "r", messages: [] });
     assert.equal(JSON.parse(calls[0].init.body as string).think, true);
 
     mock.restoreAll();
-    const off = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "think" });
+    const off = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "think" });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await off.generate({ workerId: "r", messages: [] });
     assert.equal("think" in JSON.parse(calls[0].init.body as string), false);
 });
 
-test("reasoningStyle 'effort' sends a reasoning_effort tier from the budget", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "on", budget: 5000 }, retryAttempts: 0, reasoningStyle: "effort" });
-    const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "r", messages: [] });
-    assert.equal(JSON.parse(calls[0].init.body as string).reasoning_effort, "high");
+test("reasoningStyle 'effort' enables at the portable default without inventing a budget", async () => {
+    for (const [budget, expected] of [[null, "medium"], [5000, "high"]] as const) {
+        const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "on", budget }, retryAttempts: 0, reasoningStyle: "effort" });
+        const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+        await p.generate({ workerId: "r", messages: [] });
+        assert.equal(JSON.parse(calls[0].init.body as string).reasoning_effort, expected);
+        mock.restoreAll();
+    }
 });
 
 test("reasoningStyle 'effort_explicit': off SENDS none, adaptive OMITS, on sends the tier", async () => {
     // expected === null → the field must be ABSENT from the wire body. Fireworks
     // 400s reasoning_effort='adaptive' for non-MiniMax models (wire-verified,
     // Adaptive = the backend's own default posture = omission.
-    for (const [reasoning, expected] of [[{ mode: "off", budget: null }, "none"], [{ mode: "adaptive", budget: null }, null], [{ mode: "on", budget: 5000 }, "high"]] as Array<[{ mode: "off" | "adaptive" | "on"; budget: number | null }, string | null]>) {
-        const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning, retryAttempts: 0, reasoningStyle: "effort_explicit" });
+    for (const [reasoning, expected] of [[{ mode: "off", budget: null }, "none"], [{ mode: "adaptive", budget: null }, null], [{ mode: "on", budget: null }, "medium"], [{ mode: "on", budget: 5000 }, "high"]] as Array<[{ mode: "off" | "adaptive" | "on"; budget: number | null }, string | null]>) {
+        const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning, retryAttempts: 0, reasoningStyle: "effort_explicit" });
         const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
         await p.generate({ workerId: "r", messages: [] });
         const body = JSON.parse(calls[0].init.body as string);
@@ -694,10 +1124,11 @@ test("{§deepseek-reasoning-request} #157: thinking_effort maps the complete Dee
     const cases = [
         [{ mode: "off", budget: null }, { thinking: { type: "disabled" } }],
         [{ mode: "adaptive", budget: null }, {}],
+        [{ mode: "on", budget: null }, { thinking: { type: "enabled" } }],
         [{ mode: "on", budget: 5000 }, { thinking: { type: "enabled" }, reasoning_effort: "high" }],
     ] as const;
     for (const [reasoning, expected] of cases) {
-        const p = new AiSdkProvider({
+        const p = testProvider({
             model: "m",
             url: "http://x/v1/chat/completions",
             fetchTimeoutMs: 5000,
@@ -723,7 +1154,7 @@ test("{§deepseek-reasoning-request} #157: thinking_effort maps the complete Dee
 });
 
 test("the family temperature default rides every request; caller sampling overrides it", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [] });
     assert.equal(JSON.parse(calls[0].init.body as string).temperature, 0.2);
@@ -742,7 +1173,7 @@ test("the family temperature default rides every request; caller sampling overri
 test("DRY + repeat_last_n ride the llamacpp path when set; unset leaves the box default; never on cloud", async () => {
     const base = { model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off" as const, budget: null }, retryAttempts: 0 };
     // set + llamacpp -> the loop-breakers ride the wire
-    const p = new AiSdkProvider({ ...base, grammarStyle: "llamacpp", dryMultiplier: 0.8, dryBase: 1.75, dryAllowedLength: 2, repeatLastN: 512 });
+    const p = testProvider({ ...base, grammarStyle: "llamacpp", dryMultiplier: 0.8, dryBase: 1.75, dryAllowedLength: 2, repeatLastN: 512 });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [] });
     let body = JSON.parse(calls[0].init.body as string);
@@ -753,7 +1184,7 @@ test("DRY + repeat_last_n ride the llamacpp path when set; unset leaves the box
     assert.equal(body.repeat_penalty, 1.15); // repeat_penalty always rides the llamacpp path
     mock.restoreAll();
     // unset -> no dry_*/repeat_last_n on the wire (box keeps its own defaults)
-    const p2 = new AiSdkProvider({ ...base, grammarStyle: "llamacpp" });
+    const p2 = testProvider({ ...base, grammarStyle: "llamacpp" });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p2.generate({ workerId: "r", messages: [] });
     body = JSON.parse(calls[0].init.body as string);
@@ -761,7 +1192,7 @@ test("DRY + repeat_last_n ride the llamacpp path when set; unset leaves the box
     assert.equal("repeat_last_n" in body, false);
     mock.restoreAll();
     // DRY is a llama.cpp sampler: a cloud ("none") provider never emits it, even if configured
-    const p3 = new AiSdkProvider({ ...base, grammarStyle: "none", dryMultiplier: 0.8, repeatLastN: 512 });
+    const p3 = testProvider({ ...base, grammarStyle: "none", dryMultiplier: 0.8, repeatLastN: 512 });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p3.generate({ workerId: "r", messages: [] });
     body = JSON.parse(calls[0].init.body as string);
@@ -771,7 +1202,7 @@ test("DRY + repeat_last_n ride the llamacpp path when set; unset leaves the box
 });
 
 test("llamacpp grammar path: temperature default + the managed repeat-penalty floor", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
     const body = JSON.parse(calls[0].init.body as string);
@@ -781,13 +1212,13 @@ test("llamacpp grammar path: temperature default + the managed repeat-penalty fl
 
 test("the repeat penalty rides every request rail-off, keyed per backend", async () => {
     // llama.cpp with NO grammar carries its key too (unconstrained local is guarded)
-    const llama = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
+    const llama = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await llama.generate({ workerId: "r", messages: [] });
     assert.equal(JSON.parse(calls[0].init.body as string).repeat_penalty, 1.15);
     mock.restoreAll();
     // A `none`-style cloud backend with a frequency penalty gets frequency_penalty.
-    const cloud = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, frequencyPenalty: 0.4, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const cloud = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, frequencyPenalty: 0.4, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await cloud.generate({ workerId: "r", messages: [] });
     const cloudBody = JSON.parse(calls[0].init.body as string);
@@ -796,14 +1227,14 @@ test("the repeat penalty rides every request rail-off, keyed per backend", async
     assert.equal("repeat_penalty" in cloudBody, false);
     mock.restoreAll();
     // frequencyPenalty unset (default 0) opts out cleanly - sends nothing (an out-of-date plugin runs unguarded, never breaks)
-    const bare = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const bare = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await bare.generate({ workerId: "r", messages: [] });
     assert.equal("frequency_penalty" in JSON.parse(calls[0].init.body as string), false);
 });
 
 test("sampling passthrough forwards caller params; managed + reserved keys win", async () => {
-    const p = new AiSdkProvider({ model: "managed-model", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "managed-model", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({
         workerId: "r",
@@ -826,7 +1257,7 @@ test("sampling passthrough forwards caller params; managed + reserved keys win",
 });
 
 test("sampling passthrough guards contract invariants: n/tools/caps stripped, platform knobs pass", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({
         workerId: "r",
@@ -851,15 +1282,17 @@ 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 p = testProvider({ 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 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 +1301,64 @@ 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 () => {
-    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" } }] }]);
+test("template reasoning projects a leading think envelope without losing grammar evidence", async () => {
+    const p = testProvider({ 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 = "<think>\ncon🙂sider</think>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, "con🙂sider");
+    assert.equal(res.assistant.content, "x");
+    assert.deepEqual(res.grammarEvidence, {
+        input,
+        contentStart: [..."<think>\ncon🙂sider</think>"].length,
+        transported: true,
+    });
+});
+
+test("a verbatim template response remains exact evidence when it has no channel envelope", async () => {
+    const p = testProvider({ 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: { 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 = testProvider({ 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 = testProvider({ 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 = testProvider({ 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.
@@ -891,16 +1375,16 @@ test("channel-escape detector: billed completion tokens vastly beyond visible ch
         }
         return new Response(sseStream(chunks), { status: 200 });
     };
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetch, tokenizeUrl: "http://x/tokenize", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetch, tokenizeUrl: "http://x/tokenize", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
     const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
     const escape = res.notices?.find((e) => e.message.includes("escaped the grammar"));
     assert.ok(escape, "escape notice attached");
     assert.equal(escape!.kind, "grammar_unenforced");
-    assert.match(escape!.message ?? "", /5000 completion tokens billed/);
+    assert.match(escape!.message ?? "", /5000 output tokens billed/);
 });
 
 test("channel-escape state is absent without a transported grammar", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template", grammarStyle: "llamacpp" });
     installFetch([
         { choices: [{ delta: { content: "x" }, finish_reason: "length" }] },
         { usage: { prompt_tokens: 10, completion_tokens: 5000, total_tokens: 5010 } },
@@ -911,7 +1395,7 @@ test("channel-escape state is absent without a transported grammar", async () =>
 });
 
 test("reasoningStyle 'template' sends llama-server activation, parser, and response-wide allowance", async () => {
-    const on = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { percent: 0.1 }, completionReserve: { percent: 0.25 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template" });
+    const on = testProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { percent: 0.1 }, completionReserve: { percent: 0.25 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "template" });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await on.generate({ workerId: "r", messages: [] });
     let body = JSON.parse(calls[0].init.body as string);
@@ -920,7 +1404,7 @@ test("reasoningStyle 'template' sends llama-server activation, parser, and respo
     assert.equal(body.thinking_budget_tokens, 64);
 
     mock.restoreAll();
-    const off = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { percent: 0.1 }, completionReserve: { percent: 0.25 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "template" });
+    const off = testProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { percent: 0.1 }, completionReserve: { percent: 0.25 }, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "template" });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await off.generate({ workerId: "r", messages: [] });
     body = JSON.parse(calls[0].init.body as string);
@@ -931,33 +1415,54 @@ test("reasoningStyle 'template' sends llama-server activation, parser, and respo
 
 test("reasoningStyle 'template' explicit budget tightens the reserve and cannot exceed it", async () => {
     const base = { model: "m", url: "http://x/v1/chat/completions", contextWindow: 640, reasoningReserve: { tokens: 64 } as const, completionReserve: { tokens: 160 } as const, fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryAttempts: 0, reasoningStyle: "template" as const };
-    const p = new AiSdkProvider({ ...base, reasoning: { mode: "on", budget: 32 } });
+    const p = testProvider({ ...base, reasoning: { mode: "on", budget: 32 } });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], sampling: { thinking_budget_tokens: 999, reasoning_format: "none" } });
     const body = JSON.parse(calls[0].init.body as string);
     assert.equal(body.thinking_budget_tokens, 32);
     assert.equal(body.reasoning_format, "auto");
     assert.throws(
-        () => new AiSdkProvider({ ...base, reasoning: { mode: "on", budget: 65 } }),
+        () => testProvider({ ...base, reasoning: { mode: "on", budget: 65 } }),
         /REASONING_BUDGET \(65\) exceeds the resolved PLURNK_PROVIDERS_REASONING_RESERVE \(64\)/,
     );
 });
 
-test("budget 0 suppresses effort and include_reasoning", async () => {
-    const effort = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "effort" });
+test("reasoningStyle 'template' explicit activation without a budget uses the resolved reserve", async () => {
+    const p = testProvider({
+        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: "on", budget: null },
+        retryAttempts: 0,
+        reasoningStyle: "template",
+    });
+    const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    await p.generate({ workerId: "r", messages: [] });
+    const body = JSON.parse(calls[0].init.body as string);
+    assert.deepEqual(body.chat_template_kwargs, { enable_thinking: true });
+    assert.equal(body.thinking_budget_tokens, 64);
+});
+
+test("reasoning off suppresses effort and include_reasoning controls", async () => {
+    const effort = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "effort" });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await effort.generate({ workerId: "r", messages: [] });
     assert.equal("reasoning_effort" in JSON.parse(calls[0].init.body as string), false);
 
     mock.restoreAll();
-    const relay = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "include_reasoning" });
+    const relay = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, reasoningStyle: "include_reasoning" });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await relay.generate({ workerId: "r", messages: [] });
     assert.equal("include_reasoning" in JSON.parse(calls[0].init.body as string), false);
 });
 
 test("reasoningStyle 'include_reasoning' sets the relay passthrough toggle", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "include_reasoning" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "include_reasoning" });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [] });
     assert.equal(JSON.parse(calls[0].init.body as string).include_reasoning, true);
@@ -966,7 +1471,7 @@ test("reasoningStyle 'include_reasoning' sets the relay passthrough toggle", asy
 // — grammar-constrained sampling —
 
 test("grammar transport 'llamacpp': top-level grammar + the repeat-penalty floor", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
     const body = JSON.parse(calls[0].init.body as string);
@@ -976,7 +1481,7 @@ test("grammar transport 'llamacpp': top-level grammar + the repeat-penalty floor
 });
 
 test("grammar transport 'none' (default): the grammar is never sent — no silent unconstrained", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], grammar: "root ::= statement" });
     const body = JSON.parse(calls[0].init.body as string);
@@ -986,7 +1491,7 @@ test("grammar transport 'none' (default): the grammar is never sent — no silen
 
 // — exact pre-projection grammar evidence ({§gbnf-response-observation}) —
 
-const grammarProvider = () => new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", source: "provider:test" });
+const grammarProvider = () => testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", source: "provider:test" });
 const streamingContent = (content: string) => installFetch([{ choices: [{ delta: { content }, finish_reason: "stop" }] }]);
 
 test("an unsplit grammar response carries the exact observed sentence", async () => {
@@ -1020,7 +1525,7 @@ test("empty unsplit content remains exact grammar evidence", async () => {
 });
 
 test("grammarStyle 'none' produces no grammar observation", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 }); // grammarStyle defaults to "none"
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 }); // grammarStyle defaults to "none"
     streamingContent("anything goes");
     const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "ok"' });
     assert.equal(res.assistant.content, "anything goes");
@@ -1039,7 +1544,7 @@ test("provider evidence does not depend on the local validator understanding the
 // — PLURNK_PROVIDERS_GBNF_DEBUG: validate the grammar, withhold it, and preserve the observation —
 
 test("gbnfDebug marks an unconstrained observation as not transported", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", gbnfDebug: true, source: "provider:test" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", gbnfDebug: true, source: "provider:test" });
     const calls = installFetch([{ choices: [{ delta: { content: "ok" }, finish_reason: "stop" }] }]);
     const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "ok"' });
     const body = JSON.parse(calls[0].init.body as string);
@@ -1051,7 +1556,7 @@ test("gbnfDebug marks an unconstrained observation as not transported", async ()
 });
 
 test("gbnfDebug preserves conflicting bytes without a provider verdict", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", gbnfDebug: true, source: "provider:test" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", gbnfDebug: true, source: "provider:test" });
     const calls = installFetch([{ choices: [{ delta: { content: "xon-conforming output" }, finish_reason: "stop" }] }]);
     const res = await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "ok"' });
     assert.equal(res.assistant.content, "xon-conforming output");
@@ -1062,7 +1567,7 @@ test("gbnfDebug preserves conflicting bytes without a provider verdict", async (
 });
 
 test("gbnfDebug: an INVALID grammar throws before any wire call — it never reaches the model", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", gbnfDebug: true });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp", gbnfDebug: true });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await assert.rejects(
         () => p.generate({ workerId: "r", messages: [], grammar: 'foo ::= "a"' }), // no `root` rule → invalid GBNF
@@ -1074,7 +1579,7 @@ test("gbnfDebug: an INVALID grammar throws before any wire call — it never rea
 // — meta bag: verbatim provider metadata —
 
 test("meta: passes backend fields through without reinterpreting monetary values", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
     const balance = { amount: "0.0000042", currency: "XMR" };
     installFetchJson({ ...jsonChoice, balance, system_fingerprint: "fp_abc" });
     const res = await p.generate({ workerId: "r", messages: [] });
@@ -1088,15 +1593,34 @@ const headerVal = (init: RequestInit, name: string): string | undefined =>
     new Headers(init.headers).get(name) ?? undefined;
 
 test("firstPartyMetadata: attributions + client ride as Plurnk-* headers", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], attributions: ["@acme/x@1.2.0", "@foo/y@0.3.1"], client: "plurnk.nvim/1.4.0" });
     assert.equal(headerVal(calls[0].init, "Plurnk-Attribution"), '["@acme/x@1.2.0","@foo/y@0.3.1"]');
     assert.equal(headerVal(calls[0].init, "Plurnk-Client"), "plurnk.nvim/1.4.0");
 });
 
+test("Plurnk-Call-Kind carries the caller's emission or bare output contract under the first-party gate", async () => {
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    await p.generate({ workerId: "emission", messages: [], callKind: "emission" });
+    await p.generate({ workerId: "bare", messages: [], callKind: "bare" });
+    assert.equal(headerVal(calls[0].init, "Plurnk-Call-Kind"), "emission");
+    assert.equal(headerVal(calls[1].init, "Plurnk-Call-Kind"), "bare");
+});
+
+test("generate rejects an unknown call kind before provider I/O", async () => {
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    await assert.rejects(
+        p.generate({ workerId: "invalid", messages: [], callKind: "unknown" as never }),
+        /unsupported callKind "unknown"/,
+    );
+    assert.equal(calls.length, 0);
+});
+
 test("Plurnk-Worker-Primary: the lineage root rides under the gate; emitted even when it equals workerId", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "w-child", primaryWorkerId: "w-root", messages: [] });
     assert.equal(headerVal(calls[0].init, "Plurnk-Worker-Primary"), "w-root"); // a descendant: Primary != Worker-Id
@@ -1115,22 +1639,23 @@ test("Plurnk-Worker-Primary: the lineage root rides under the gate; emitted even
 });
 
 test("Plurnk-Worker-Primary is structurally dropped when firstPartyMetadata is off", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "w-child", primaryWorkerId: "w-root", messages: [] });
     assert.equal(headerVal(calls[0].init, "Plurnk-Worker-Primary"), undefined); // never reaches a third-party backend
 });
 
 test("firstPartyMetadata off (default): the headers are structurally dropped even when values are passed", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "r", messages: [], attributions: ["@acme/x@1.2.0"], client: "plurnk-cli/2.0.0" });
+    await p.generate({ workerId: "r", messages: [], attributions: ["@acme/x@1.2.0"], client: "plurnk-cli/2.0.0", callKind: "bare" });
     assert.equal(headerVal(calls[0].init, "Plurnk-Attribution"), undefined);   // never leaks to a non-first-party backend
     assert.equal(headerVal(calls[0].init, "Plurnk-Client"), undefined);
+    assert.equal(headerVal(calls[0].init, "Plurnk-Call-Kind"), undefined);
 });
 
 test("firstPartyMetadata on but empty values: no header emitted", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], attributions: [], client: "" });
     assert.equal(headerVal(calls[0].init, "Plurnk-Attribution"), undefined);
@@ -1138,7 +1663,7 @@ test("firstPartyMetadata on but empty values: no header emitted", async () => {
 });
 
 test("grammar transport: no grammar passed sends no grammar field, but the penalty rides", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [] });
     const body = JSON.parse(calls[0].init.body as string);
@@ -1147,7 +1672,7 @@ test("grammar transport: no grammar passed sends no grammar field, but the penal
 });
 
 test("maxTokens transports as max_tokens; absent → no wire field (server default)", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], maxTokens: 2048 });
     assert.equal(JSON.parse(calls[0].init.body as string).max_tokens, 2048);
@@ -1159,7 +1684,7 @@ test("maxTokens transports as max_tokens; absent → no wire field (server defau
 });
 
 test("slot affinity is internal: sticky per workerId, distinct workers spread across slots", async () => {
-    const pinning = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, supportsSlotPinning: true, slotCount: 2 });
+    const pinning = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, supportsSlotPinning: true, slotCount: 2 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await pinning.generate({ workerId: "run-A", messages: [] });
     await pinning.generate({ workerId: "run-B", messages: [] });
@@ -1170,20 +1695,20 @@ test("slot affinity is internal: sticky per workerId, distinct workers spread ac
 });
 
 test("slot affinity: no pinning backend or unknown slotCount → no id_slot ever", async () => {
-    const cloud = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 }); // default: no pinning
+    const cloud = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 }); // default: no pinning
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await cloud.generate({ workerId: "run-A", messages: [] });
     assert.equal("id_slot" in JSON.parse(calls[0].init.body as string), false);
 
     mock.restoreAll();
-    const noCount = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, supportsSlotPinning: true }); // slotCount null
+    const noCount = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, supportsSlotPinning: true }); // slotCount null
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await noCount.generate({ workerId: "run-A", messages: [] });
     assert.equal("id_slot" in JSON.parse(calls[0].init.body as string), false);
 });
 
 test("slot affinity: a worker past the LRU window (slotCount*8) loses its pin; recent workers stay sticky", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, supportsSlotPinning: true, slotCount: 2 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, supportsSlotPinning: true, slotCount: 2 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     const slotOf = (i: number) => JSON.parse(calls[i].init.body as string).id_slot;
     for (let i = 0; i < 16; i++) await p.generate({ workerId: `r${i}`, messages: [] }); // fills the 16-entry window {r0..r15}
@@ -1197,7 +1722,7 @@ test("slot affinity: a worker past the LRU window (slotCount*8) loses its pin; r
 
 test("streaming:false: a non-ok response rejects as a classified ProviderError (covers the non-streamed transport)", async () => {
     const { ProviderError } = await import("./errors.ts");
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, source: "provider:test" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, source: "provider:test" });
     mock.method(globalThis, "fetch", async () => new Response("boom", { status: 500 }));
     await assert.rejects(() => p.generate({ workerId: "r", messages: [] }), (err: unknown) => {
         assert.ok(err instanceof ProviderError, `expected ProviderError, got ${String(err)}`);
@@ -1208,14 +1733,14 @@ test("streaming:false: a non-ok response rejects as a classified ProviderError (
 });
 
 test("generate fail-hards on a missing or empty workerId", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await assert.rejects(() => p.generate({ workerId: "", messages: [] }), /workerId is required/);
     await assert.rejects(() => (p.generate as (a: object) => Promise<unknown>)({ messages: [] }), /workerId is required/);
 });
 
 test("messages pass through verbatim — the provider injects no turn (PLAN lives in the grammar, never a provider prefill)", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "out" } }] }]);
     const input = [{ role: "user" as const, content: "hi" }];
     const res = await p.generate({ workerId: "r", messages: input });
@@ -1225,7 +1750,7 @@ test("messages pass through verbatim — the provider injects no turn (PLAN live
 
 test("generate wraps an HTTP failure as a ProviderError carrying Problem Details", async () => {
     const { ProviderError } = await import("./errors.ts");
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, source: "provider:test" });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, source: "provider:test" });
     mock.method(globalThis, "fetch", async () => new Response("rate limited", { status: 429 }));
     await assert.rejects(() => p.generate({ workerId: "r", messages: [] }), (err: unknown) => {
         assert.ok(err instanceof ProviderError, `expected ProviderError, got ${String(err)}`);
@@ -1239,14 +1764,14 @@ test("generate wraps an HTTP failure as a ProviderError carrying Problem Details
 });
 
 test("generate rejects on a pre-aborted external signal", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     const signal = AbortSignal.abort(new Error("nope"));
     await assert.rejects(() => p.generate({ workerId: "r", messages: [], signal }));
 });
 
 test("configured headers and url are sent verbatim", async () => {
-    const p = new AiSdkProvider({
+    const p = testProvider({
         model: "m", url: "http://host/custom/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0,
         headers: { Authorization: "Bearer secret", "X-Title": "plurnk" },
     });
@@ -1262,32 +1787,34 @@ 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: 408, retryAfter: 0 },
+        { status: 409, retryAfter: 0 },
         { status: 429, retryAfter: 0 },
         { status: 503, retryAfter: 0 },
         { status: 200, chunks: [{ choices: [{ delta: { content: "ok" } }] }] },
     ]);
-    const p = new AiSdkProvider({ ...retryCfg, retryAttempts: 3 });
+    const p = testProvider({ ...retryCfg, retryAttempts: 4 });
     const res = await p.generate({ workerId: "r", messages: [] });
     assert.equal(res.assistant.content, "ok");
-    assert.equal(calls.length, 3); // 429 → 503 → 200
+    assert.equal(calls.length, 5); // 408 → 409 → 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(
@@ -1297,7 +1824,30 @@ test("streamed-body silence fails the exchange without replaying partial output"
             },
         }), { status: 200 });
     });
-    const p = new AiSdkProvider({
+    const p = testProvider({
+        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",
+    });
+    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 = testProvider({
         model: "m",
         url: "http://x/v1/chat/completions",
         fetchTimeoutMs: 1000,
@@ -1305,18 +1855,196 @@ test("streamed-body silence fails the exchange without replaying partial output"
         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"
+            && error.problem.timeoutPhase === "stream_idle"
+            && error.problem.timeoutMs === 10,
+    );
+    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 = testProvider({
+        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"
-            && /chunk timeout/i.test(error.message),
+            && 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("an attempt timeout retries within the larger operation deadline and settles every physical request", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
+        calls++;
+        if (calls > 1) {
+            return new Response(sseStream([
+                { choices: [{ delta: { content: "recovered" }, finish_reason: "stop" }] },
+            ]), { status: 200 });
+        }
+        return await new Promise<Response>((_resolve, reject) => {
+            const signal = init?.signal;
+            signal?.addEventListener("abort", () => reject(signal.reason), { once: true });
+        });
+    });
+    const connectivity = { operationTimeoutMs: 5_000 };
+    const settled: Array<{ outcome: string }> = [];
+    const p = testProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 10,
+        streamIdleTimeoutMs: 0,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 1,
+        source: "provider:test",
+        ...connectivity,
+    });
+    const result = await p.generate({
+        workerId: "r",
+        messages: [],
+        observeRequest: async () => async (accounting) => { settled.push(accounting); },
+    });
+    assert.equal(result.assistant.content, "recovered");
+    assert.equal(calls, 2);
+    assert.deepEqual(settled.map(({ outcome }) => outcome), ["error", "response"]);
+    assert.deepEqual(result.accounting.map(({ outcome }) => outcome), ["error", "response"]);
+    mock.restoreAll();
+});
+
+test("first-content silence retries independently of the stream-idle deadline", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async () => {
+        calls++;
+        if (calls > 1) {
+            return new Response(sseStream([
+                { choices: [{ delta: { content: "recovered" }, finish_reason: "stop" }] },
+            ]), { status: 200 });
+        }
+        return new Response(new ReadableStream({
+            start(controller) {
+                setTimeout(() => controller.close(), 100);
+            },
+        }), { status: 200 });
+    });
+    const connectivity = { operationTimeoutMs: 5_000, firstContentTimeoutMs: 10 };
+    const p = testProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 5_000,
+        streamIdleTimeoutMs: 0,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 1,
+        source: "provider:test",
+        ...connectivity,
+    });
+    const result = await p.generate({ workerId: "r", messages: [] });
+    assert.equal(result.assistant.content, "recovered");
+    assert.equal(calls, 2);
+    mock.restoreAll();
+});
+
+test("operation-deadline exhaustion is a distinct non-retryable failure", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
+        calls++;
+        return await new Promise<Response>((_resolve, reject) => {
+            const signal = init?.signal;
+            signal?.addEventListener("abort", () => reject(signal.reason), { once: true });
+        });
+    });
+    const connectivity = { operationTimeoutMs: 10 };
+    const p = testProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 50,
+        streamIdleTimeoutMs: 0,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 3,
+        source: "provider:test",
+        ...connectivity,
+    });
+    await assert.rejects(
+        p.generate({ workerId: "r", messages: [] }),
+        (error: ProviderError) => error.kind === "deadline_exceeded"
+            && error.status === 504
+            && error.problem.retryable === false
+            && error.problem.timeoutPhase === "operation"
+            && error.problem.timeoutMs === 10
+            && error.accounting.length === 1
+            && error.accounting[0]?.outcome === "error",
     );
     assert.equal(calls, 1);
     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 = testProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 5000,
+        operationTimeoutMs: 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 === "deadline_exceeded"
+            && error.problem.timeoutPhase === "operation",
+    );
+    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();
+});
+
 test("a zero stream-idle timeout permits a slow inter-chunk pause", async () => {
     mock.method(globalThis, "fetch", async () => new Response(new ReadableStream({
         async start(controller) {
@@ -1326,7 +2054,7 @@ test("a zero stream-idle timeout permits a slow inter-chunk pause", async () =>
             controller.close();
         },
     }), { status: 200 }));
-    const p = new AiSdkProvider({
+    const p = testProvider({
         model: "m",
         url: "http://x/v1/chat/completions",
         fetchTimeoutMs: 1000,
@@ -1344,7 +2072,7 @@ test("a zero stream-idle timeout permits a slow inter-chunk pause", async () =>
 test("retry: exhausting the budget surfaces the classified ProviderError", async () => {
     const { ProviderError } = await import("./errors.ts");
     const calls = installFetchScript([{ status: 429, retryAfter: 0 }]); // always rate-limited
-    const p = new AiSdkProvider({ ...retryCfg, retryAttempts: 2 });
+    const p = testProvider({ ...retryCfg, retryAttempts: 2 });
     await assert.rejects(
         () => p.generate({ workerId: "r", messages: [] }),
         (err: unknown) => { assert.ok(err instanceof ProviderError); assert.equal(err.kind, "rate_limit"); return true; },
@@ -1357,7 +2085,7 @@ test("retry: a Retry-After HTTP-date is honored — a past date parses to a 0ms
         { status: 503, retryAfter: "Wed, 21 Oct 2015 07:28:00 GMT" }, // date form, in the past → max(0, past−now) = 0
         { status: 200, chunks: [{ choices: [{ delta: { content: "ok" }, finish_reason: "stop" }] }] },
     ]);
-    const p = new AiSdkProvider({ ...retryCfg, retryAttempts: 1 });
+    const p = testProvider({ ...retryCfg, retryAttempts: 1 });
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.content, "ok");
     assert.equal(calls.length, 2); // initial 503 + one retry, no real wall-clock wait
@@ -1365,14 +2093,14 @@ test("retry: a Retry-After HTTP-date is honored — a past date parses to a 0ms
 
 test("retry: a terminal error (401 unauthorized) is never retried", async () => {
     const calls = installFetchScript([{ status: 401 }]);
-    const p = new AiSdkProvider({ ...retryCfg, retryAttempts: 5 });
+    const p = testProvider({ ...retryCfg, retryAttempts: 5 });
     await assert.rejects(() => p.generate({ workerId: "r", messages: [] }), /401/);
     assert.equal(calls.length, 1); // terminal — no retry despite budget
 });
 
 test("retry: retryAttempts 0 surfaces the first transient failure immediately", async () => {
     const calls = installFetchScript([{ status: 503, retryAfter: 0 }]);
-    const p = new AiSdkProvider({ ...retryCfg, retryAttempts: 0 });
+    const p = testProvider({ ...retryCfg, retryAttempts: 0 });
     await assert.rejects(() => p.generate({ workerId: "r", messages: [] }));
     assert.equal(calls.length, 1); // no retry budget
 });
@@ -1380,7 +2108,7 @@ test("retry: retryAttempts 0 surfaces the first transient failure immediately",
 test("retry: a caller abort during backoff rejects promptly with no further attempt", async () => {
     const ac = new AbortController();
     const calls = installFetchScript([{ status: 503, retryAfter: 5 }]); // 5s backoff we never wait out
-    const p = new AiSdkProvider({ ...retryCfg, retryAttempts: 3 });
+    const p = testProvider({ ...retryCfg, retryAttempts: 3 });
     const promise = p.generate({ workerId: "r", messages: [], signal: ac.signal });
     await flush(); // attempt 0 fails, enters the backoff sleep
     assert.equal(calls.length, 1);
@@ -1391,23 +2119,29 @@ test("retry: a caller abort during backoff rejects promptly with no further atte
 
 // — Anthropic reasoning style (wire `thinking` parameter) —
 
-test("reasoningStyle 'anthropic' maps the budget to the thinking param", async () => {
+test("reasoningStyle 'anthropic' maps an optional budget or the resolved reserve to the thinking param", async () => {
     // N>0 → enabled with budget_tokens
-    const capped = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "on", budget: 4096 }, reasoningStyle: "anthropic" });
+    const capped = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "on", budget: 4096 }, reasoningStyle: "anthropic" });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await capped.generate({ workerId: "r", messages: [] });
     assert.deepEqual(JSON.parse(calls[0].init.body as string).thinking, { type: "enabled", budget_tokens: 4096 });
 
+    mock.restoreAll();
+    const unbudgeted = testProvider({ model: "m", url: "http://x/v1/chat/completions", contextWindow: 8192, reasoningReserve: { tokens: 2048 }, fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "on", budget: null }, reasoningStyle: "anthropic" });
+    calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    await unbudgeted.generate({ workerId: "r", messages: [] });
+    assert.deepEqual(JSON.parse(calls[0].init.body as string).thinking, { type: "enabled", budget_tokens: 2048 });
+
     mock.restoreAll();
     // 0 → explicit disabled
-    const off = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, reasoningStyle: "anthropic" });
+    const off = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, reasoningStyle: "anthropic" });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await off.generate({ workerId: "r", messages: [] });
     assert.deepEqual(JSON.parse(calls[0].init.body as string).thinking, { type: "disabled" });
 
     mock.restoreAll();
     // -1 adaptive → omit (API default depth)
-    const adaptive = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, reasoningStyle: "anthropic" });
+    const adaptive = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, retryAttempts: 0, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, reasoningStyle: "anthropic" });
     calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await adaptive.generate({ workerId: "r", messages: [] });
     assert.equal("thinking" in JSON.parse(calls[0].init.body as string), false);
@@ -1425,14 +2159,14 @@ test("streaming:false posts without stream and parses the single JSON response",
             usage: { prompt_tokens: 3, completion_tokens: 1, total_tokens: 4 },
         }), { status: 200, headers: { "Content-Type": "application/json" } });
     });
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
     const res = await p.generate({ workerId: "r", messages: [] });
     const sent = JSON.parse(calls[0].body);
     assert.equal("stream" in sent, false);                 // no streaming flag
     assert.equal(res.assistant.content, "hello");          // content from message.content
     assert.equal(res.assistant.reasoning, "because");      // reasoning_content mapped
     assert.equal(res.assistant.finishReason, "stop");
-    assert.equal(res.assistant.usage.total, 4);
+    assert.equal(res.accounting[0]?.usage?.totalTokens, 4);
     mock.restoreAll();
 });
 
@@ -1441,7 +2175,7 @@ const captureBase = { model: "m", url: "http://x/v1/chat/completions", fetchTime
 
 test("logprobs OFF by default: no wire request, no assistant.logprobs, no rawBody", async () => {
     const calls = installFetch([{ model: "m", choices: [{ delta: { content: "hi" }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } }]);
-    const p = new AiSdkProvider({ ...captureBase });
+    const p = testProvider({ ...captureBase });
     const res = await p.generate({ workerId: "r", messages: [{ role: "user", content: "q" }] });
     const body = JSON.parse((calls[0].init.body as string));
     assert.equal("logprobs" in body, false);
@@ -1458,7 +2192,7 @@ test("logprobs ON (streamed): requests logprobs+top_logprobs, surfaces raw logpr
         { token: "no", logprob: -0.1, sampling_logprob: -0.1, top_logprobs: [{ token: "no", logprob: -0.1 }] },
     ] } }] };
     const calls = installFetch([chunk]);
-    const p = new AiSdkProvider({ ...captureBase, topLogprobs: 2 });
+    const p = testProvider({ ...captureBase, topLogprobs: 2 });
     const res = await p.generate({ workerId: "r", messages: [{ role: "user", content: "q" }] });
     const body = JSON.parse((calls[0].init.body as string));
     assert.equal(body.logprobs, true);
@@ -1472,7 +2206,7 @@ test("logprobs ON (streamed): requests logprobs+top_logprobs, surfaces raw logpr
 test("rawBody ON (non-streamed): verbatim wire body incl. sampling_logprob preserved", async () => {
     const wire = { model: "m", extra_top_level: "kept", choices: [{ message: { content: "no" }, finish_reason: "stop", logprobs: { content: [{ token: "no", logprob: -0.1, sampling_logprob: -0.1, token_id: 42 }] } }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } };
     installFetchJson(wire);
-    const p = new AiSdkProvider({ ...captureBase, streaming: false, topLogprobs: 0, rawBody: true });
+    const p = testProvider({ ...captureBase, streaming: false, topLogprobs: 0, rawBody: true });
     const res = await p.generate({ workerId: "r", messages: [{ role: "user", content: "q" }] });
     assert.deepEqual(res.rawBody, wire); // verbatim
     assert.equal((res.rawBody as typeof wire).choices[0].logprobs.content[0].sampling_logprob, -0.1);
@@ -1483,7 +2217,7 @@ test("rawBody ON (non-streamed): verbatim wire body incl. sampling_logprob prese
 
 test("caller sampling cannot forge logprobs (reserved keys): the env flag is the only control", async () => {
     const calls = installFetch([{ model: "m", choices: [{ delta: { content: "hi" }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } }]);
-    const p = new AiSdkProvider({ ...captureBase }); // logprobs OFF
+    const p = testProvider({ ...captureBase }); // logprobs OFF
     await p.generate({ workerId: "r", messages: [{ role: "user", content: "q" }], sampling: { logprobs: true, top_logprobs: 5 } });
     const body = JSON.parse((calls[0].init.body as string));
     assert.equal("logprobs" in body, false);   // sampling passthrough stripped it
@@ -1494,7 +2228,7 @@ test("caller sampling cannot forge logprobs (reserved keys): the env flag is the
 // — turn coordinate headers ({§lifecycle-terms}): same gate as every first-party signal —
 
 test("workspaceId/loop/turn ride as Plurnk-Workspace-Id/Loop/Turn under the first-party gate", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], workspaceId: "s-9", loop: 3, turn: 41 });
     const headers = new Headers(calls[0].init.headers);
@@ -1504,7 +2238,7 @@ test("workspaceId/loop/turn ride as Plurnk-Workspace-Id/Loop/Turn under the firs
 });
 
 test("third-party providers structurally DROP the coordinate (gate off by default)", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], workspaceId: "s-9", loop: 3, turn: 41 });
     const headers = new Headers(calls[0].init.headers);
@@ -1514,7 +2248,7 @@ test("third-party providers structurally DROP the coordinate (gate off by defaul
 });
 
 test("coordinates are 1-based — 0/absent/empty emit no header", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, firstPartyMetadata: true });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], workspaceId: "", loop: 0, turn: 0 });
     const headers = new Headers(calls[0].init.headers);
@@ -1528,18 +2262,18 @@ test("coordinates are 1-based — 0/absent/empty emit no header", async () => {
 
 test("reserves derive from the detected window; absolutes stand alone; null window + percent = no claim", () => {
     const base = { model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null } as const, retryAttempts: 0 };
-    const derived = new AiSdkProvider({ ...base, contextWindow: 49152, reasoningReserve: { percent: 0.1 }, completionReserve: { percent: 0.25 } });
+    const derived = testProvider({ ...base, contextWindow: 49152, reasoningReserve: { percent: 0.1 }, completionReserve: { percent: 0.25 } });
     assert.equal(derived.reasoningReserve, 4915);   // jennifer/turboderp: 10% of 49152
     assert.equal(derived.completionReserve, 12288); // 25% of 49152
-    const pinned = new AiSdkProvider({ ...base, contextWindow: null, reasoningReserve: { tokens: 4096 }, completionReserve: { percent: 0.25 } });
+    const pinned = testProvider({ ...base, contextWindow: null, reasoningReserve: { tokens: 4096 }, completionReserve: { percent: 0.25 } });
     assert.equal(pinned.reasoningReserve, 4096);    // absolute pin needs no window
     assert.equal(pinned.completionReserve, null);   // percent without a window = underivable
-    const legacy = new AiSdkProvider({ ...base, contextWindow: 49152 });
+    const legacy = testProvider({ ...base, contextWindow: 49152 });
     assert.equal(legacy.reasoningReserve, null);    // out-of-date sibling: no claim
 });
 
 test("router-owned tuning: tuningFloors:false drops the temperature/penalty floors, caller sampling still rides", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, frequencyPenalty: 0.4, reasoning: { mode: "off", budget: null }, retryAttempts: 0, tuningFloors: false });
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, frequencyPenalty: 0.4, reasoning: { mode: "off", budget: null }, retryAttempts: 0, tuningFloors: false });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "r", messages: [], sampling: { temperature: 0.9 } });
     const body = JSON.parse(calls[0].init.body as string);
@@ -1547,25 +2281,148 @@ test("router-owned tuning: tuningFloors:false drops the temperature/penalty floo
     assert.equal("frequency_penalty" in body, false); // the floor is suppressed; the router owns tuning
 });
 
-// -- prompt-cache affinity (workerId -> prompt_cache_key) --
+// -- {§provider-cache-affinity} / {§provider-cache-write-policy} --
 
-test("promptCacheKey on: body sends prompt_cache_key = workerId (serverless replica affinity)", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, promptCacheKey: true });
+test("a compatible route's declared body affinity is managed by workerId", async () => {
+    const p = testProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        fetchTimeoutMs: 5000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 0,
+        cacheAffinity: { target: "body", name: "prompt_cache_key" },
+    });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "worker-abc", messages: [] });
+    await p.generate({ workerId: "worker-abc", messages: [], sampling: { prompt_cache_key: "hijack" } });
     assert.equal(JSON.parse(calls[0].init.body as string).prompt_cache_key, "worker-abc");
 });
 
-test("promptCacheKey off (default): no prompt_cache_key on the wire", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+test("an undeclared compatible route receives no guessed cache field", async () => {
+    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await p.generate({ workerId: "worker-abc", messages: [] });
     assert.equal("prompt_cache_key" in JSON.parse(calls[0].init.body as string), false);
 });
 
-test("prompt_cache_key is managed: caller sampling cannot forge/override the affinity key", async () => {
-    const p = new AiSdkProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, promptCacheKey: true });
+test("a compatible route's declared header affinity composes with static headers", async () => {
+    const p = testProvider({
+        model: "m",
+        url: "http://x/v1/chat/completions",
+        headers: { Authorization: "Bearer key" },
+        fetchTimeoutMs: 5000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 0,
+        cacheAffinity: { target: "header", name: "x-grok-conv-id" },
+    });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "worker-abc", messages: [], sampling: { prompt_cache_key: "hijack" } });
-    assert.equal(JSON.parse(calls[0].init.body as string).prompt_cache_key, "worker-abc"); // managed wins
+    await p.generate({ workerId: "worker-abc", messages: [] });
+    const headers = new Headers(calls[0].init.headers);
+    assert.equal(headers.get("authorization"), "Bearer key");
+    assert.equal(headers.get("x-grok-conv-id"), "worker-abc");
+});
+
+test("native request projections compose reasoning visibility, affinity, and system cache control", async () => {
+    let request: Record<string, unknown> | undefined;
+    const usage = {
+        inputTokens: { total: 2, noCache: 2, cacheRead: 0, cacheWrite: 0 },
+        outputTokens: { total: 1, text: 1, reasoning: 0 },
+    };
+    const languageModel = {
+        specificationVersion: "v4",
+        provider: "native.test",
+        modelId: "native-cache",
+        supportedUrls: {},
+        doGenerate: async (options: Record<string, unknown>) => {
+            request = options;
+            return {
+                content: [{ type: "text", text: "ok" }],
+                finishReason: { unified: "stop", raw: "stop" },
+                usage,
+                response: { id: "response", modelId: "native-cache" },
+                warnings: [],
+            };
+        },
+        doStream: async () => { throw new Error("streaming is not under test"); },
+    } as unknown as LanguageModel;
+    const p = testProvider({
+        model: "native-cache",
+        languageModel,
+        fetchTimeoutMs: 5000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "adaptive", budget: null },
+        retryAttempts: 0,
+        streaming: false,
+        cacheAffinity: { target: "provider-option", provider: "openai", name: "promptCacheKey" },
+        reasoningResponseProviderOptions: {
+            google: { thinkingConfig: { includeThoughts: true } },
+        },
+        systemCacheProviderOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } },
+        },
+    });
+    await p.generate({
+        workerId: "worker-native",
+        messages: [
+            { role: "system", content: "stable definition" },
+            { role: "system", content: "stable policy" },
+            { role: "user", content: "changing packet" },
+        ],
+    });
+
+    assert.deepEqual(request?.providerOptions, {
+        google: { thinkingConfig: { includeThoughts: true } },
+        openai: { promptCacheKey: "worker-native" },
+    });
+    assert.deepEqual(request?.prompt, [
+        { role: "system", content: "stable definition", providerOptions: undefined },
+        {
+            role: "system",
+            content: "stable policy",
+            providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
+        },
+        { role: "user", content: [{ type: "text", text: "changing packet" }], providerOptions: undefined },
+    ]);
+});
+
+test("native AI SDK reasoning turns on without an operator token budget", async () => {
+    let request: Record<string, unknown> | undefined;
+    const languageModel = {
+        specificationVersion: "v4",
+        provider: "native.test",
+        modelId: "native-reasoning",
+        supportedUrls: {},
+        doGenerate: async (options: Record<string, unknown>) => {
+            request = options;
+            return {
+                content: [{ type: "reasoning", text: "consider" }, { type: "text", text: "ok" }],
+                finishReason: { unified: "stop", raw: "stop" },
+                usage: {
+                    inputTokens: { total: 2, noCache: 2, cacheRead: 0, cacheWrite: 0 },
+                    outputTokens: { total: 2, text: 1, reasoning: 1 },
+                },
+                response: { id: "response", modelId: "native-reasoning" },
+                warnings: [],
+            };
+        },
+        doStream: async () => { throw new Error("streaming is not under test"); },
+    } as unknown as LanguageModel;
+    const p = testProvider({
+        model: "native-reasoning",
+        languageModel,
+        fetchTimeoutMs: 5000,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        reasoning: { mode: "on", budget: null },
+        retryAttempts: 0,
+        streaming: false,
+    });
+    const response = await p.generate({ workerId: "worker-native", messages: [{ role: "user", content: "hello" }] });
+
+    assert.equal(request?.reasoning, "medium");
+    assert.equal(response.assistant.reasoning, "consider");
 });