@plurnk/plurnk-providers 1.18.0 → 1.19.0

package/src/AiSdkProvider.test.ts

@@ -272,7 +272,7 @@ test("(#482) conformance judges the grant: tolerated overflow is accepted, past-
     );
 });
 
-test("request-observer open failures preserve the durability cause and issue no provider I/O", async () => {
+test("{§provider-request-observer} 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({
@@ -299,7 +299,7 @@ test("request-observer open failures preserve the durability cause and issue no
     assert.equal(calls, 0);
 });
 
-test("request-observer settlement failures preserve the durability cause without retrying I/O", async () => {
+test("{§provider-request-observer} 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({
@@ -533,7 +533,7 @@ test("only the trailing eos_token is stripped; a quoted one mid-body survives",
     assert.equal(res.assistant.content, "quotes <eos> in the body"); // only the tail goes
 });
 
-test("identity getters and default prompt estimate", async () => {
+test("{§provider-prompt-measurement} identity getters and default prompt estimate", async () => {
     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
@@ -578,7 +578,7 @@ test("injected prompt measurement preserves provenance and request cost estimati
     });
 });
 
-test("an exact request overflow rejects before observer or provider I/O", async () => {
+test("{§provider-capacity-failure} an exact request overflow rejects before observer or provider I/O", async () => {
     const calls = installFetch([{ choices: [{ delta: { content: "unreachable" } }] }]);
     let observed = false;
     const p = testProvider({
@@ -672,7 +672,7 @@ test("an unsupported fixed reasoning policy fails before provider I/O", () => {
     );
 });
 
-test("native SDK warnings survive as source-attributed provider Notices", async () => {
+test("{§provider-sdk-warning} native SDK warnings survive as source-attributed provider Notices", async () => {
     const usage = {
         inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
         outputTokens: { total: 1, text: 1, reasoning: 0 },
@@ -1251,7 +1251,7 @@ test("{§provider-tagged-reasoning} verbatim, non-leading, and structured-reason
 });
 
 test("{§provider-tagged-reasoning} grammar evidence retains the exact pre-projection tagged sentence", async () => {
-    const content = "<think>🧠reason</think>```SEND\ndone\n```\n```TASK\n[{\"content\":\"Task completed.\",\"status\":\"completed\"}]\n```";
+    const content = "<think>🧠reason</think>````SEND\ndone\n````";
     const config = {
         ...injectedBase,
         contextWindow: 640,
@@ -1269,7 +1269,7 @@ test("{§provider-tagged-reasoning} grammar evidence retains the exact pre-proje
     });
 
     assert.equal(response.assistant.reasoning, "🧠reason");
-    assert.equal(response.assistant.content, "```SEND\ndone\n```\n```TASK\n[{\"content\":\"Task completed.\",\"status\":\"completed\"}]\n```");
+    assert.equal(response.assistant.content, "````SEND\ndone\n````");
     assert.deepEqual(response.grammarEvidence, {
         input: content,
         contentStart: [..."<think>🧠reason</think>"].length,
@@ -1857,81 +1857,6 @@ test("meta: passes backend fields through without reinterpreting monetary values
     assert.equal(res.meta?.system_fingerprint, "fp_abc");
 });
 
-// — first-party telemetry headers ({§provider-request-authority}) —
-
-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 = 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 = 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
-    mock.restoreAll();
-
-    // the primary worker's own turn: Primary == Worker-Id, still stamped (never skipped on equality)
-    calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "w-root", primaryWorkerId: "w-root", messages: [] });
-    assert.equal(headerVal(calls[0].init, "Plurnk-Worker-Primary"), "w-root");
-    mock.restoreAll();
-
-    // absent when the consumer supplies none — the provider never invents a primary
-    calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "w-root", messages: [] });
-    assert.equal(headerVal(calls[0].init, "Plurnk-Worker-Primary"), undefined);
-});
-
-test("Plurnk-Worker-Primary is structurally dropped when firstPartyMetadata is off", 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: "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 = 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", 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 = 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);
-    assert.equal(headerVal(calls[0].init, "Plurnk-Client"), undefined);
-});
-
 test("grammar transport: no grammar passed sends no grammar field, but the penalty rides", 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, grammarStyle: "llamacpp" });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
@@ -2048,7 +1973,7 @@ test("streaming:false: a non-ok response rejects as a classified ProviderError (
     });
 });
 
-test("generate fail-hards on a missing or empty workerId", async () => {
+test("{§provider-cache-identity} generate fail-hards on a missing or empty 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 });
     installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await assert.rejects(() => p.generate({ workerId: "", messages: [] }), /workerId is required/);
@@ -2096,6 +2021,58 @@ test("{§provider-input-modalities} compatible transports serialize image files
     }]);
 });
 
+for (const [mediaType, format] of [["audio/wav", "wav"], ["audio/mpeg", "mp3"]]) {
+    test(`{§provider-input-modalities} ${mediaType} reaches the compatible wire as native input_audio`, async () => {
+        const provider = testProvider({
+            model: "audio-model", url: "https://example.test/v1/chat/completions", fetchTimeoutMs: 5000,
+            temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0,
+        });
+        const calls = installFetch([{ choices: [{ delta: { content: "heard" } }] }]);
+        const bytes = new Uint8Array([82, 73, 70, 70]);
+        await provider.generate({ workerId: "audio", messages: [{ role: "user", content: [
+            { type: "text", text: "listen" }, { type: "file", data: bytes, mediaType: mediaType! },
+        ] }] });
+        assert.deepEqual(JSON.parse(String(calls[0]?.init.body)).messages, [{ role: "user", content: [
+            { type: "text", text: "listen" },
+            { type: "input_audio", input_audio: { data: Buffer.from(bytes).toString("base64"), format } },
+        ] }]);
+    });
+}
+
+test("{§provider-input-modalities} Google serializes native audio through its own SDK adapter", async () => {
+    const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+    const google = createGoogleGenerativeAI({ apiKey: "fixture", baseURL: "https://example.test/v1beta" });
+    const calls = installFetchJson({ candidates: [{ content: { role: "model", parts: [{ text: "heard" }] }, finishReason: "STOP" }] });
+    const provider = testProvider({
+        model: "audio-fixture", languageModel: google("audio-fixture"), fetchTimeoutMs: 5000,
+        temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0,
+        streaming: false,
+    });
+    const bytes = new Uint8Array([82, 73, 70, 70]);
+    await provider.generate({ workerId: "audio", messages: [{ role: "user", content: [
+        { type: "text", text: "listen" }, { type: "file", data: bytes, mediaType: "audio/wav" },
+    ] }] });
+    assert.deepEqual(JSON.parse(String(calls[0]?.init.body)).contents, [{ role: "user", parts: [
+        { text: "listen" }, { inlineData: { mimeType: "audio/wav", data: Buffer.from(bytes).toString("base64") } },
+    ] }]);
+});
+
+test("{§provider-input-modalities} an unsupported audio codec fails visibly instead of dropping its part", async () => {
+    const provider = testProvider({
+        model: "audio-model", url: "https://example.test/v1/chat/completions", fetchTimeoutMs: 5000,
+        temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0,
+    });
+    const calls = installFetch([]);
+    await assert.rejects(provider.generate({ workerId: "audio", messages: [{ role: "user", content: [
+        { type: "file", data: new Uint8Array([79, 103, 103, 83]), mediaType: "audio/ogg" },
+    ] }] }), (error: unknown) => {
+        assert.ok(error instanceof ProviderError);
+        assert.match(error.message, /audio\/ogg/u);
+        return true;
+    });
+    assert.equal(calls.length, 0, "no text-only substitute is sent to the provider");
+});
+
 test("generate wraps an HTTP failure as a ProviderError carrying Problem Details", async () => {
     const { ProviderError } = await import("./errors.ts");
     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" });
@@ -2572,40 +2549,6 @@ test("caller sampling cannot forge logprobs (reserved keys): the env flag is the
     assert.equal("top_logprobs" in body, false);
     mock.restoreAll();
 });
-
-// — 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 = 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);
-    assert.equal(headers.get("plurnk-workspace-id"), "s-9");
-    assert.equal(headers.get("plurnk-loop"), "3");
-    assert.equal(headers.get("plurnk-turn"), "41");
-});
-
-test("third-party providers structurally DROP the coordinate (gate off by default)", 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: "r", messages: [], workspaceId: "s-9", loop: 3, turn: 41 });
-    const headers = new Headers(calls[0].init.headers);
-    assert.equal(headers.has("plurnk-workspace-id"), false);
-    assert.equal(headers.has("plurnk-loop"), false);
-    assert.equal(headers.has("plurnk-turn"), false);
-});
-
-test("coordinates are 1-based — 0/absent/empty emit no header", 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: "r", messages: [], workspaceId: "", loop: 0, turn: 0 });
-    const headers = new Headers(calls[0].init.headers);
-    assert.equal(headers.has("plurnk-workspace-id"), false);
-    assert.equal(headers.has("plurnk-loop"), false);
-    assert.equal(headers.has("plurnk-turn"), false);
-    assert.equal(headers.has("plurnk-strikes"), false);
-});
-
 // -- {§provider-generation-envelope} --
 
 test("the adapter exposes independent model limits and the resolved generation envelope", () => {
@@ -2626,15 +2569,6 @@ test("the adapter exposes independent model limits and the resolved generation e
     assert.equal(unknown.outputBudget, null);
 });
 
-test("router-owned tuning: tuningFloors:false drops the temperature/penalty floors, caller sampling still rides", async () => {
-    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);
-    assert.equal(body.temperature, 0.9);           // caller intent passes verbatim
-    assert.equal("frequency_penalty" in body, false); // the floor is suppressed; the router owns tuning
-});
-
 // -- {§provider-cache-affinity} / {§provider-cache-write-policy} --
 
 test("a compatible route's declared body affinity is managed by workerId", async () => {
@@ -2988,3 +2922,40 @@ test("a response whose usage counters contradict each other is delivered with un
     const raw = response.assistantRaw as { usageRefusal?: { reason: string; usage: unknown } };
     assert.deepEqual(raw.usageRefusal, { reason: "provider usage.outputTokenDetails.textTokens must be a non-negative safe integer", usage }, "the durable response carries the refused counters");
 });
+
+test("{§provider-connectivity} a stream still producing content outlives the attempt deadline; stream-idle governs it instead", async () => {
+    const encoder = new TextEncoder();
+    const chunk = (content: string, finish: string | null = null) => `data: ${JSON.stringify({
+        id: "long", object: "chat.completion.chunk", created: 1, model: "m",
+        choices: [{ index: 0, delta: { content }, finish_reason: finish }],
+    })}\n\n`;
+    mock.method(globalThis, "fetch", async () => new Response(new ReadableStream({
+        async start(controller) {
+            for (let index = 0; index < 8; index += 1) {
+                controller.enqueue(encoder.encode(chunk(`part${index} `)));
+                await new Promise((resolve) => setTimeout(resolve, 25));
+            }
+            controller.enqueue(encoder.encode(chunk("", "stop")));
+            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            controller.close();
+        },
+    }), { headers: { "content-type": "text/event-stream" } }));
+    try {
+        const p = testProvider({
+            model: "m",
+            url: "http://x/v1/chat/completions",
+            fetchTimeoutMs: 60,
+            streamIdleTimeoutMs: 1_000,
+            temperature: 0.2,
+            repeatPenalty: 1.15,
+            reasoning: { mode: "off", budget: null },
+            retryAttempts: 1,
+            source: "provider:test",
+            operationTimeoutMs: 5_000,
+        });
+        const response = await p.generate({ workerId: "long", messages: [] });
+        assert.equal(response.assistant.content, "part0 part1 part2 part3 part4 part5 part6 part7 ", "about 200 ms of streaming against a 60 ms attempt deadline completes");
+    } finally {
+        mock.restoreAll();
+    }
+});

package/src/AiSdkProvider.ts

@@ -54,7 +54,7 @@ const raceAgainstDeadline = async <T>(work: PromiseLike<T>, signal: AbortSignal)
 
 // Backend wire spellings for the resolved reasoning intent. The switch beside each
 // mapping retains any backend-specific omission/explicit-disable constraint.
-export type ReasoningStyle = "none" | "think" | "include_reasoning" | "effort" | "effort_explicit" | "effort_required" | "thinking_effort" | "template" | "anthropic";
+export type ReasoningStyle = "none" | "think" | "include_reasoning" | "effort" | "effort_explicit" | "effort_required" | "thinking_effort" | "thinking_config" | "template" | "anthropic";
 
 export type NativeReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
 export type CompatibleReasoningEffort = NativeReasoningEffort | "max";
@@ -126,7 +126,6 @@ export type AiSdkProviderConfig = {
     // a fixed deployment choice and therefore wins on every request.
     serviceTier?: string;
     streaming?: boolean;                        // SSE transport (default true); false → one non-streamed JSON
-    firstPartyMetadata?: boolean;              // forward per-turn attributions + client as Plurnk-* headers (plurnk only); default false
     apiKeyRejectedMessage?: string;            // friendly hint when a present key is 401/403-rejected (distinct from unset); default undefined
     eosText?: string;                          // server-reported eos_token, stripped from the content tail (--special renders it as text); default undefined
     // Slot affinity wiring is provider-internal, never consumer-facing.
@@ -199,10 +198,6 @@ export type AiSdkProviderConfig = {
     // the standard factory always supplies them. Resolved against contextWindow
     // at read time (getters), so a probe that lands after config assembly still
     // derives correctly.
-    // The plurnk.ai router owns tuning — false suppresses the
-    // client-side temperature/penalty FLOORS on this provider (caller `sampling`
-    // still passes through verbatim). Default true (floors ride).
-    tuningFloors?: boolean;
 };
 
 class ProviderRequestObserverError extends Error {
@@ -296,13 +291,11 @@ export default class AiSdkProvider implements Provider {
     #reasoningResponseProviderOptions: AiSdkProviderOptions | undefined;
     #serviceTier: string | undefined;
     #streaming: boolean;
-    #firstPartyMetadata: boolean;
     #supportsSlotPinning: boolean;
     #slotCount: number | null;
     #retryAttempts: number;
     #errorDetailLimit: number | undefined;
     #topLogprobs: number | null;
-    #tuningFloors: boolean;
     #rawBody: boolean;
     #servedModel: string | undefined;
     #requiresOutputBudget: boolean | undefined;
@@ -418,14 +411,12 @@ export default class AiSdkProvider implements Provider {
         }
         this.#serviceTier = config.serviceTier;
         this.#streaming = config.streaming ?? true;
-        this.#firstPartyMetadata = config.firstPartyMetadata ?? false;
         this.#apiKeyRejectedMessage = config.apiKeyRejectedMessage;
         this.#eosText = config.eosText;
         this.#hasApiKey = "Authorization" in this.#headers;
         this.#supportsSlotPinning = config.supportsSlotPinning ?? false;
         this.#slotCount = config.slotCount ?? null;
         this.#topLogprobs = config.topLogprobs ?? null;
-        this.#tuningFloors = config.tuningFloors ?? true;
         this.#rawBody = config.rawBody ?? false;
         this.#servedModel = config.servedModel;
         this.#requiresOutputBudget = config.requiresOutputBudget;
@@ -477,7 +468,7 @@ export default class AiSdkProvider implements Provider {
                 return tokens;
             };
         }
-        this.#requestBody = new AiSdkRequestBody({ reasoningBudget: this.#reasoningBudget, additiveReasoningProvider: this.#additiveReasoningProvider, reasoning: this.#reasoning, reasoningToggle: this.#reasoningToggle, compatibleAdaptiveReasoning: this.#compatibleAdaptiveReasoning, compatibleOffReasoning: this.#compatibleOffReasoning, adaptiveReasoningProviderOptions: this.#adaptiveReasoningProviderOptions, repeatPenalty: this.#repeatPenalty, frequencyPenalty: this.#frequencyPenalty, dryMultiplier: this.#dryMultiplier, dryBase: this.#dryBase, dryAllowedLength: this.#dryAllowedLength, repeatLastN: this.#repeatLastN, reasoningStyle: this.#reasoningStyle, source: this.#source, grammarStyle: this.#grammarStyle, cacheAffinity: this.#cacheAffinity, reasoningResponseProviderOptions: this.#reasoningResponseProviderOptions, firstPartyMetadata: this.#firstPartyMetadata, supportsSlotPinning: this.#supportsSlotPinning, slotCount: this.#slotCount });
+        this.#requestBody = new AiSdkRequestBody({ reasoningBudget: this.#reasoningBudget, additiveReasoningProvider: this.#additiveReasoningProvider, reasoning: this.#reasoning, reasoningToggle: this.#reasoningToggle, compatibleAdaptiveReasoning: this.#compatibleAdaptiveReasoning, compatibleOffReasoning: this.#compatibleOffReasoning, adaptiveReasoningProviderOptions: this.#adaptiveReasoningProviderOptions, repeatPenalty: this.#repeatPenalty, frequencyPenalty: this.#frequencyPenalty, dryMultiplier: this.#dryMultiplier, dryBase: this.#dryBase, dryAllowedLength: this.#dryAllowedLength, repeatLastN: this.#repeatLastN, reasoningStyle: this.#reasoningStyle, source: this.#source, grammarStyle: this.#grammarStyle, cacheAffinity: this.#cacheAffinity, reasoningResponseProviderOptions: this.#reasoningResponseProviderOptions, supportsSlotPinning: this.#supportsSlotPinning, slotCount: this.#slotCount });
     }
 
     get contextWindow(): number | null { return this.#contextWindow; }
@@ -613,7 +604,7 @@ export default class AiSdkProvider implements Provider {
         });
     }
 
-    async generate({ messages, workerId, primaryWorkerId, signal, grammar, maxOutputTokens, attributions, client, strikes, workspaceId, loop, turn, sampling, observeRequest, observeReasoning, callKind }: ProviderGenerateArgs): Promise<ProviderResponse> {
+    async generate({ messages, workerId, signal, grammar, maxOutputTokens, sampling, observeRequest, observeReasoning, callKind }: ProviderGenerateArgs): Promise<ProviderResponse> {
         // {§provider-interface} The worker identity is required.
         if (workerId === undefined || workerId.length === 0) throw new Error("generate: workerId is required — the worker's stable, opaque identity");
         if (callKind !== undefined && callKind !== "emission" && callKind !== "bare") {
@@ -655,9 +646,8 @@ export default class AiSdkProvider implements Provider {
         // paths and the name promises every request) < the caller's `sampling`
         // < the managed fields, which always win.
         const body: Record<string, unknown> = {
-            // Floors are suppressed on router-owned-tuning providers (plurnk) —
-            // the router's per-model tuning must not be overridden by client floors.
-            ...(this.#tuningFloors ? { ...(this.#temperature !== null ? { temperature: this.#temperature } : {}), ...this.#requestBody.repetitionPenaltyBody() } : {}),
+            ...(this.#temperature !== null ? { temperature: this.#temperature } : {}),
+            ...this.#requestBody.repetitionPenaltyBody(),
             ...this.#requestBody.samplingBody(sampling),
             ...(this.#serviceTier !== undefined ? { service_tier: this.#serviceTier } : {}),
             ...this.#requestBody.reasoningBody(preserveGrammarSentence, capacity.reasoningBudget),
@@ -672,13 +662,11 @@ export default class AiSdkProvider implements Provider {
                 : {}),
         };
 
-        // Per-request headers = static auth/routing + any first-party telemetry.
-        const metaHeaders = this.#requestBody.metadataHeaders(attributions, client, strikes, workerId, primaryWorkerId, workspaceId, loop, turn, callKind);
+        // Per-request headers = static auth/routing only.
         const headers = new Headers(this.#headers);
         if (this.#cacheAffinity?.target === "header") {
             headers.set(this.#cacheAffinity.name, workerId);
         }
-        for (const [name, value] of Object.entries(metaHeaders)) headers.set(name, value);
         const requestHeaders = Object.fromEntries(headers.entries());
         const accounting: ProviderRequestAccounting[] = [];
         const operationTimeout = this.#operationTimeoutMs > 0
@@ -803,15 +791,13 @@ export default class AiSdkProvider implements Provider {
                         streaming: this.#streaming,
                         captureRawBody: this.#rawBody,
                         ...observers,
-                        temperature: this.#tuningFloors
-                            ? (typeof sampling?.temperature === "number" ? sampling.temperature : this.#temperature ?? undefined)
-                            : typeof sampling?.temperature === "number" ? sampling.temperature : undefined,
+                        temperature: typeof sampling?.temperature === "number" ? sampling.temperature : this.#temperature ?? undefined,
                         topP: typeof sampling?.top_p === "number" ? sampling.top_p : undefined,
                         topK: typeof sampling?.top_k === "number" ? sampling.top_k : undefined,
                         presencePenalty: typeof sampling?.presence_penalty === "number" ? sampling.presence_penalty : undefined,
                         frequencyPenalty: typeof sampling?.frequency_penalty === "number"
                             ? sampling.frequency_penalty
-                            : this.#tuningFloors && this.#frequencyPenalty > 0 ? this.#frequencyPenalty : undefined,
+                            : this.#frequencyPenalty > 0 ? this.#frequencyPenalty : undefined,
                         stopSequences: typeof sampling?.stop === "string"
                             ? [sampling.stop]
                             : Array.isArray(sampling?.stop) && sampling.stop.every((value) => typeof value === "string")

package/src/AiSdkRequestBody.ts

@@ -1,5 +1,5 @@
 // The provider-specific request body and headers one generate call sends: reasoning, grammar, sampling, repetition, slots, metadata. Split out of AiSdkProvider; every knob it reads is injected.
-import type { ProviderCallKind, ReasoningPolicy } from "./types.ts";
+import type { ReasoningPolicy } from "./types.ts";
 import type { JSONValue } from "ai";
 import { type Reasoning } from "./env.ts";
 import { fixedEffort } from "./reasoning-effort.ts";
@@ -80,13 +80,12 @@ export default class AiSdkRequestBody {
     readonly #grammarStyle: GrammarStyle;
     readonly #cacheAffinity: CacheAffinity | undefined;
     readonly #reasoningResponseProviderOptions: AiSdkProviderOptions | undefined;
-    readonly #firstPartyMetadata: boolean;
     readonly #supportsSlotPinning: boolean;
     readonly #slotCount: number | null;
     #runSlots = new Map<string, number>();
     #nextSlot = 0;
 
-    constructor({ reasoningBudget, additiveReasoningProvider, reasoning, reasoningToggle, compatibleAdaptiveReasoning, compatibleOffReasoning, adaptiveReasoningProviderOptions, repeatPenalty, frequencyPenalty, dryMultiplier, dryBase, dryAllowedLength, repeatLastN, reasoningStyle, source, grammarStyle, cacheAffinity, reasoningResponseProviderOptions, firstPartyMetadata, supportsSlotPinning, slotCount }: {
+    constructor({ reasoningBudget, additiveReasoningProvider, reasoning, reasoningToggle, compatibleAdaptiveReasoning, compatibleOffReasoning, adaptiveReasoningProviderOptions, repeatPenalty, frequencyPenalty, dryMultiplier, dryBase, dryAllowedLength, repeatLastN, reasoningStyle, source, grammarStyle, cacheAffinity, reasoningResponseProviderOptions, supportsSlotPinning, slotCount }: {
         reasoningBudget: number | null;
         additiveReasoningProvider: "anthropic" | "bedrock" | undefined;
         reasoning: Reasoning;
@@ -105,7 +104,6 @@ export default class AiSdkRequestBody {
         grammarStyle: GrammarStyle;
         cacheAffinity: CacheAffinity | undefined;
         reasoningResponseProviderOptions: AiSdkProviderOptions | undefined;
-        firstPartyMetadata: boolean;
         supportsSlotPinning: boolean;
         slotCount: number | null;
     }) {
@@ -127,7 +125,6 @@ export default class AiSdkRequestBody {
         this.#grammarStyle = grammarStyle;
         this.#cacheAffinity = cacheAffinity;
         this.#reasoningResponseProviderOptions = reasoningResponseProviderOptions;
-        this.#firstPartyMetadata = firstPartyMetadata;
         this.#supportsSlotPinning = supportsSlotPinning;
         this.#slotCount = slotCount;
     }
@@ -204,6 +201,14 @@ export default class AiSdkRequestBody {
                     thinking: { type: "enabled" },
                     reasoning_effort: fixedEffort(mode),
                 };
+            // {§google-reasoning-request} — Gemini's OpenAI-compatible extension. Readable
+            // thoughts ride on every reasoning request; Gemini refuses `reasoning_effort` beside a
+            // thinking_config, so the level travels inside it. Gemini cannot turn reasoning off.
+            case "thinking_config": {
+                if (mode === "off") throw new TypeError(`${this.#source}: thinking_config reasoning has no off projection`);
+                const level = mode === "adaptive" ? {} : { thinking_level: fixedEffort(mode) };
+                return { extra_body: { google: { thinking_config: { include_thoughts: true, ...level } } } };
+            }
             // Anthropic-compatible native dynamic or manual budget mode.
             case "anthropic": return mode === "off"
                 ? { thinking: { type: "disabled" } }
@@ -294,43 +299,6 @@ export default class AiSdkRequestBody {
     }
 
 
-    // First-party telemetry headers ({§provider-request-authority} {§provider-call-kind}): forwarded only when the spec
-    // opted in (the plurnk endpoint). The gate is here, not at the call site, so
-    // attributions/client/strikes can never reach a third-party backend even if
-    // the consumer passes them to the wrong provider. Empty values emit no header
-    // — EXCEPT strikes, where 0 is a real value (clean streak) distinct from
-    // absent (consumer didn't report); contract {§strikes-first-party-metadata}. Strikes
-    // ride HTTP headers only — the packet never carries them (the model must
-    // never see strike state; engine accounting is not a metric to game).
-    metadataHeaders(attributions: string[] | undefined, client: string | undefined, strikes: number | undefined, workerId: string, primaryWorkerId: string | undefined, workspaceId: string | undefined, loop: number | undefined, turn: number | undefined, callKind: ProviderCallKind | undefined): Record<string, string> {
-        if (!this.#firstPartyMetadata) return {};
-        const h: Record<string, string> = {};
-        if (attributions !== undefined && attributions.length > 0) h["Plurnk-Attribution"] = JSON.stringify(attributions);
-        if (client !== undefined && client.length > 0) h["Plurnk-Client"] = client;
-        if (strikes !== undefined && Number.isInteger(strikes) && strikes >= 0) h["Plurnk-Strikes"] = String(strikes);
-        // Worker identity: the opaque workerId
-        // the consumer already supplies, forwarded so the endpoint can key
-        // per-worker affinity/telemetry — same gate as every first-party signal.
-        h["Plurnk-Worker-Id"] = workerId;
-        // Root worker of the lineage ({§worker-primary}): the no-parent ancestor of this turn's
-        // worker tree. The consumer classifies primary-vs-spawned by equality
-        // (primaryWorkerId == workerId ⇒ the primary/root worker). The provider
-        // EMITS what the consumer supplies and never invents a primary; the
-        // consumer's contract is to stamp it EVERY turn (including the primary's
-        // own, where it equals workerId). Absence is the consumer's violation for
-        // the endpoint to surface, not a provider default.
-        if (primaryWorkerId !== undefined && primaryWorkerId.length > 0) h["Plurnk-Worker-Primary"] = primaryWorkerId;
-        // Turn coordinate ({§lifecycle-terms}): workspace/loop/turn, the
-        // daemon-side sequence the endpoint can never scrape from the wire.
-        // Coordinates are 1-based — 0 is not a real value, so no strikes-style
-        // zero exception; absent/empty/0 emits no header.
-        if (workspaceId !== undefined && workspaceId.length > 0) h["Plurnk-Workspace-Id"] = workspaceId;
-        if (loop !== undefined && Number.isInteger(loop) && loop >= 1) h["Plurnk-Loop"] = String(loop);
-        if (turn !== undefined && Number.isInteger(turn) && turn >= 1) h["Plurnk-Turn"] = String(turn);
-        if (callKind !== undefined) h["Plurnk-Call-Kind"] = callKind;
-        return h;
-    }
-
 
     requestProviderOptions(
         workerId: string,

package/src/Mock.test.ts

@@ -8,10 +8,18 @@ import { ProviderError } from "./errors.ts";
 const build = (responses: MockResponse[] = [{ assistant: { content: "hi", reasoning: null } }]) =>
     new Mock({ contextWindow: 100000, responses });
 
+// The suite runs on this package's own panel, which ships an output budget. "No budget" is therefore
+// something a test states — the panel's explicit empty value — never an ambient absence of the key.
+const withoutOutputBudget = <T>(body: () => T): T => {
+    const panel = process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET;
+    process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = "";
+    try { return body(); } finally { process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = panel; }
+};
+
 // — Identity ({§provider-interface}) —
 
 test("Mock: contextWindow and model are stable across reads", () => {
-    const m = build();
+    const m = withoutOutputBudget(() => build());
     assert.equal(m.contextWindow, 100000);
     assert.equal(m.inputCapacity, null);
     assert.equal(m.contextWindow, 100000);
@@ -193,8 +201,8 @@ test("Mock resolves percentage and absolute generation budgets against its windo
     }
 });
 
-test("no generation-budget env leaves a bare Mock unbounded", () => {
-    const m = new Mock({ contextWindow: 49152, responses: [] });
+test("an empty generation budget leaves a bare Mock unbounded", () => {
+    const m = withoutOutputBudget(() => new Mock({ contextWindow: 49152, responses: [] }));
     assert.equal(m.outputBudget, null);
     assert.equal(m.reasoningBudget, null);
     assert.equal(m.inputCapacity, null);

package/src/Mock.ts

@@ -41,7 +41,7 @@ export type MockResponse = {
 export type MockReturnedAssistant = ProviderAssistant & { ops?: unknown[] };
 export type MockReturnedResponse = ProviderResponse & { assistant: MockReturnedAssistant };
 
-const DEFAULT_USAGE: ProviderUsage = {
+const MOCK_USAGE: ProviderUsage = {
     inputTokens: 0,
     outputTokens: 0,
     totalTokens: 0,
@@ -154,7 +154,7 @@ export default class Mock implements Provider {
         }
         const a = next.assistant;
         const usage: ProviderUsage = {
-            ...DEFAULT_USAGE,
+            ...MOCK_USAGE,
             ...next.usage,
         };
         const requestAccounting: ProviderRequestAccounting = validateProviderRequestAccounting({
@@ -196,4 +196,4 @@ export default class Mock implements Provider {
     get remaining(): number { return this.#queue.length; }
 }
 
-export { DEFAULT_USAGE as mockDefaultUsage };
+export { MOCK_USAGE as mockDefaultUsage };

package/src/ProviderRegistry.test.ts

@@ -73,7 +73,6 @@ test("instantiateProvider: a selected plugin composes its static and runtime att
     const context: PluginAttributionContext = {
         workspaceId: "workspace",
         workerId: "worker",
-        primaryWorkerId: "primary",
         loop: 3,
         turn: 2,
         attempt: 1,

package/src/ProviderRegistry.ts

@@ -60,7 +60,7 @@ export const instantiateProvider = async (
     const catalog = catalogProviderFromEnv(name, env, model, baseUrl);
     if (catalog !== null) return catalog;
     if (name === "ollama") return ollamaProviderFromEnv(env, model, baseUrl === undefined ? undefined : { baseUrl });
-    if (name === "openai" || name === "plurnk") return compatibleProviderFromEnv(name, env, model, baseUrl);
+    if (name === "openai") return compatibleProviderFromEnv(env, model, baseUrl);
     const { registry, skipped, packageAttributions = new Map(), grammarStyles = new Map() } = await providerPackages(discoverFn, env);
     const specifier = registry.get(name);
     if (specifier === undefined) {

package/src/accounting.test.ts

@@ -2,7 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
     aggregateProviderAccounting,
-    plurnkCostNormalizer,
     providerCostNormalizer,
 } from "./accounting.ts";
 
@@ -48,16 +47,6 @@ test("DeepInfra's documented response estimate remains estimated", () => {
     });
 });
 
-test("first-party charged evidence is validated at its adapter boundary", () => {
-    const charged = {
-        kind: "charged",
-        amount: { amount: "0.01", currency: "USD" },
-        source: "plurnk endpoint",
-    } as const;
-    assert.deepEqual(plurnkCostNormalizer(evidence({ charge: charged })), charged);
-    assert.equal(plurnkCostNormalizer(evidence({})), undefined);
-});
-
 test("response cost normalization is an explicit adapter capability", () => {
     assert.equal(providerCostNormalizer("@ai-sdk/anthropic"), undefined);
     assert.equal(providerCostNormalizer("@ai-sdk/xai")!(evidence({ usage: {} })), undefined);