@plurnk/plurnk-providers 1.18.0 → 1.19.0

package/src/accounting.ts

@@ -1,5 +1,4 @@
 import type {
-    ChargedCost,
     ProviderAccounting,
     ProviderCostNormalizer,
     ProviderRequestAccounting,
@@ -7,7 +6,6 @@ import type {
 } from "./types.ts";
 import {
     sumProviderCostsUsd,
-    validateChargedCost,
     validateProviderCost,
 } from "./cost.ts";
 import { validateProviderUsage } from "./usage.ts";
@@ -82,12 +80,6 @@ const deepInfraCost: ProviderCostNormalizer = ({ usage }) => {
     };
 };
 
-// The first-party endpoint owns the direct charged-cost wire field.
-export const plurnkCostNormalizer: ProviderCostNormalizer = ({ charge }) => {
-    if (charge === undefined) return undefined;
-    return validateChargedCost(charge) as ChargedCost;
-};
-
 export const providerCostNormalizer = (
     sdkPackage: string,
 ): ProviderCostNormalizer | undefined => {

package/src/aiSdkTransport.test.ts

@@ -19,7 +19,7 @@ const request = {
     captureRawBody: false,
 };
 
-test("the transport performs exactly one physical request", async () => {
+test("{§provider-sdk-boundary} the transport performs exactly one physical request", async () => {
     let calls = 0;
     await assert.rejects(
         executeOpenAICompatible({
@@ -416,3 +416,65 @@ test("inconsistent usage counters refuse normalization without failing the respo
         assert.equal(result.usageRefusal, undefined);
     });
 });
+
+test("{§google-thought-response}: Gemini's flagged thought content is reasoning, never emission", async (t) => {
+    const chunk = (delta: Record<string, unknown>, extra: Record<string, unknown> = {}) => ({
+        id: "gemini-1", object: "chat.completion.chunk", created: 1, model: "gemini-3.8-flash",
+        choices: [{ index: 0, delta, finish_reason: null }], ...extra,
+    });
+    const thought = (content: string) => ({ role: "assistant", content, extra_content: { google: { thought: true } } });
+    const sse = (chunks: object[]) => `${chunks.map((c) => `data: ${JSON.stringify(c)}\n\n`).join("")}data: [DONE]\n\n`;
+
+    await t.test("streamed: flagged deltas are observed and settled as reasoning; the answer stays clean", async () => {
+        const reasoning: string[] = [];
+        const text: string[] = [];
+        const result = await executeOpenAICompatible({
+            ...request,
+            streaming: true,
+            observeReasoning: (delta) => reasoning.push(delta),
+            observeText: (delta) => text.push(delta),
+            fetch: async () => new Response(sse([
+                chunk(thought("<thought>**Checking 391**\n\n")),
+                chunk(thought("17 × 23 = 391.")),
+                chunk({ content: "</thought>No. " }),
+                chunk({ content: "391 = 17 × 23.", extra_content: { google: { thought_signature: "c2ln" } } }),
+                { ...chunk({}), choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage: { prompt_tokens: 5, completion_tokens: 8, total_tokens: 90 } },
+            ]), { headers: { "content-type": "text/event-stream" } }),
+        });
+        assert.equal(result.content, "No. 391 = 17 × 23.");
+        assert.equal(result.reasoning, "**Checking 391**\n\n17 × 23 = 391.");
+        assert.equal(result.reasoningProjected, true);
+        assert.deepEqual(reasoning, ["**Checking 391**\n\n", "17 × 23 = 391."]);
+        assert.deepEqual(text, ["No. ", "391 = 17 × 23."]);
+    });
+
+    await t.test("whole: the flagged message's leading <thought> wrapper is reasoning and the remainder is content", async () => {
+        const result = await executeOpenAICompatible({
+            ...request,
+            fetch: async () => new Response(JSON.stringify({
+                id: "gemini-2", object: "chat.completion", created: 1, model: "gemini-3.8-flash",
+                choices: [{ index: 0, finish_reason: "stop", message: {
+                    role: "assistant",
+                    content: "<thought>**Checking 391**\n17 × 23 = 391.</thought>No. It is divisible by 17 and 23.",
+                    extra_content: { google: { thought: true, thought_signature: "c2ln" } },
+                } }],
+                usage: { prompt_tokens: 5, completion_tokens: 9, total_tokens: 90 },
+            }), { headers: { "content-type": "application/json" } }),
+        });
+        assert.equal(result.content, "No. It is divisible by 17 and 23.");
+        assert.equal(result.reasoning, "**Checking 391**\n17 × 23 = 391.");
+        assert.equal(result.reasoningProjected, true);
+    });
+
+    await t.test("unflagged content is never inspected for the wrapper", async () => {
+        const result = await executeOpenAICompatible({
+            ...request,
+            fetch: async () => new Response(JSON.stringify({
+                id: "plain", object: "chat.completion", created: 1, model: "m",
+                choices: [{ index: 0, finish_reason: "stop", message: { role: "assistant", content: "<thought>literal</thought>tail" } }],
+            }), { headers: { "content-type": "application/json" } }),
+        });
+        assert.equal(result.content, "<thought>literal</thought>tail");
+        assert.equal(result.reasoning, "");
+    });
+});

package/src/aiSdkTransport.ts

@@ -162,6 +162,38 @@ const recordOf = (value: unknown): Record<string, unknown> | null =>
         ? value as Record<string, unknown>
         : null;
 
+// {§google-thought-response} — Gemini behind an OpenAI-compatible endpoint returns its readable
+// thought summary as ordinary `content` wrapped `<thought>…</thought>` and flagged
+// `extra_content.google.thought`. Whole, the flagged message holds wrapper and answer; streamed,
+// the flagged deltas hold `<thought>` and the thought, and the first unflagged delta opens with
+// `</thought>` before the answer.
+const googleThoughtFlagged = (message: Record<string, unknown> | null): boolean =>
+    recordOf(recordOf(message?.extra_content)?.google)?.thought === true;
+
+const THOUGHT_OPEN = "<thought>";
+const THOUGHT_CLOSE = "</thought>";
+const splitGoogleThought = (content: string): { thought: string; answer: string } | null => {
+    if (!content.startsWith(THOUGHT_OPEN)) return null;
+    const close = content.indexOf(THOUGHT_CLOSE);
+    if (close === -1) return null;
+    return { thought: content.slice(THOUGHT_OPEN.length, close), answer: content.slice(close + THOUGHT_CLOSE.length) };
+};
+
+const unwrapThoughtDelta = (text: string): string => {
+    const opened = text.startsWith(THOUGHT_OPEN) ? text.slice(THOUGHT_OPEN.length) : text;
+    return opened.endsWith(THOUGHT_CLOSE) ? opened.slice(0, -THOUGHT_CLOSE.length) : opened;
+};
+
+const rawChunkThought = (value: unknown): boolean => {
+    const choices = recordOf(value)?.choices;
+    return Array.isArray(choices) && googleThoughtFlagged(recordOf(recordOf(choices[0])?.delta));
+};
+
+const wholeResponseThought = (values: readonly unknown[]): boolean => values.some((value) => {
+    const choices = recordOf(value)?.choices;
+    return Array.isArray(choices) && googleThoughtFlagged(recordOf(recordOf(choices[0])?.message));
+});
+
 const metadataOf = (values: readonly unknown[]): Record<string, unknown> => {
     const metadata: Record<string, unknown> = {};
     for (const value of values) {
@@ -413,6 +445,18 @@ const executeModelOnce = async (
             ? { role: "assistant", content: chatMessageText(message) }
             : { role: "system", content: chatMessageText(message) };
     });
+    // {§provider-connectivity} — a streamed attempt's deadline holds only until semantic content
+    // flows; after that, stream-idle catches a stall and the operation deadline bounds the whole.
+    // A healthy stream still producing (long reasoning) is never cut off and its tokens wasted.
+    const attemptDeadline = request.streaming && request.fetchTimeoutMs > 0 ? new AbortController() : null;
+    const attemptTimer = attemptDeadline === null ? null : setTimeout(
+        () => attemptDeadline.abort(new ProviderTimeoutError("attempt", request.fetchTimeoutMs)),
+        request.fetchTimeoutMs,
+    );
+    const liftAttemptDeadline = (): void => { if (attemptTimer !== null) clearTimeout(attemptTimer); };
+    const abortSignal = attemptDeadline === null
+        ? request.signal
+        : request.signal === undefined ? attemptDeadline.signal : AbortSignal.any([request.signal, attemptDeadline.signal]);
     const common = {
         model,
         ...(instructions.length === 0 ? {} : { instructions }),
@@ -422,10 +466,10 @@ const executeModelOnce = async (
         // AiSdkProvider owns retries so every physical request is independently
         // observed and accounted. The SDK transport executes exactly once.
         maxRetries: 0,
-        abortSignal: request.signal,
+        abortSignal,
         headers: request.headers,
         timeout: {
-            ...(request.fetchTimeoutMs > 0 ? { totalMs: request.fetchTimeoutMs } : {}),
+            ...(request.fetchTimeoutMs > 0 && !request.streaming ? { totalMs: request.fetchTimeoutMs } : {}),
             ...(request.streaming
                 && request.firstContentTimeoutMs !== undefined
                 && request.firstContentTimeoutMs > 0
@@ -451,9 +495,10 @@ const executeModelOnce = async (
         const accountingUsage = wireUsageEvidenceOf(values);
         const reasoningText = evidence.reasoning || result.reasoningText || "";
         const rawFinishReason = result.rawFinishReason;
+        const thought = wholeResponseThought(values) ? splitGoogleThought(result.text) : null;
         return {
             model: result.response.modelId,
-            content: result.text,
+            content: thought === null ? result.text : thought.answer,
             reasoning: reasoningText,
             reasoningProjected: evidence.reasoningProjected,
             finishReason: finishReasonOf(rawFinishReason),
@@ -490,15 +535,35 @@ const executeModelOnce = async (
     const rawChunks: unknown[] = [];
     let streamError: unknown;
     let outputObserved = false;
+    // The SDK enqueues each raw chunk before the deltas it yields, so the latest raw chunk's
+    // thought flag classifies the text deltas that follow ({§google-thought-response}).
+    let thoughtChunk = false;
+    let thoughtSeen = false;
+    let answer = "";
     try {
         for await (const part of result.fullStream) {
-            if (part.type === "raw") rawChunks.push(part.rawValue);
+            if (part.type === "raw") {
+                rawChunks.push(part.rawValue);
+                thoughtChunk = rawChunkThought(part.rawValue);
+            }
             if (part.type === "text-delta" && part.text.length > 0) {
                 outputObserved = true;
-                request.observeText?.(part.text);
+                liftAttemptDeadline();
+                if (thoughtChunk) {
+                    thoughtSeen = true;
+                    const thought = unwrapThoughtDelta(part.text);
+                    if (thought.length > 0) request.observeReasoning?.(thought);
+                } else {
+                    const text = thoughtSeen && answer.length === 0 && part.text.startsWith(THOUGHT_CLOSE)
+                        ? part.text.slice(THOUGHT_CLOSE.length)
+                        : part.text;
+                    answer += text;
+                    if (text.length > 0) request.observeText?.(text);
+                }
             }
             if (part.type === "reasoning-delta" && part.text.length > 0) {
                 outputObserved = true;
+                liftAttemptDeadline();
                 request.observeReasoning?.(part.text);
             }
             if (part.type === "error") streamError ??= part.error;
@@ -506,6 +571,8 @@ const executeModelOnce = async (
     } catch (error) {
         preserveStreamFailure(error, rawChunks, outputObserved);
         throw error;
+    } finally {
+        liftAttemptDeadline();
     }
     if (streamError !== undefined) {
         preserveStreamFailure(streamError, rawChunks, outputObserved);
@@ -513,7 +580,7 @@ const executeModelOnce = async (
     }
     const evidence = extractEvidence(rawChunks);
     const accountingUsage = wireUsageEvidenceOf(rawChunks);
-    const content = await result.text;
+    const content = thoughtSeen ? answer : await result.text;
     const reasoningText = evidence.reasoning || (await result.reasoningText) || "";
     const rawFinishReason = await result.rawFinishReason;
     const [response, providerMetadata, warnings] = await Promise.all([
@@ -671,13 +738,21 @@ const extractEvidence = (values: unknown[]): {
                     : { token: entry.token, logprob: entry.logprob, top });
             }
         }
-        const message = recordOf(choice.delta) ?? recordOf(choice.message) ?? {};
+        const delta = recordOf(choice.delta);
+        const message = delta ?? recordOf(choice.message) ?? {};
         for (const key of ["reasoning_content", "reasoning", "thinking"]) { // lexicon-allow: backend wire fields
             if (typeof message[key] === "string") {
                 reasoningProjected = true;
                 reasoning += message[key];
             }
         }
+        if (googleThoughtFlagged(message) && typeof message.content === "string") {
+            const thought = delta !== null ? unwrapThoughtDelta(message.content) : splitGoogleThought(message.content)?.thought;
+            if (thought !== undefined) {
+                reasoningProjected = true;
+                reasoning += thought;
+            }
+        }
         if (!Array.isArray(message.reasoning_details)) continue;
         for (const value of message.reasoning_details) {
             const detail = recordOf(value);

package/src/boundaries.test.ts

@@ -64,7 +64,7 @@ test("the OpenAI-compatible entrypoint excludes Node-owned provider machinery",
     ]));
 });
 
-test("the normalized-error entrypoint excludes transport and Node machinery", () => {
+test("{§provider-runtime-neutral-errors} the normalized-error entrypoint excludes transport and Node machinery", () => {
     assertRuntimeNeutralGraph("providerError.ts", new Set([
         "notices.ts",
         "providerError.ts",

package/src/capacity.test.ts

@@ -27,7 +27,7 @@ test("call-specific output tightening also tightens its reasoning subset", () =>
     );
 });
 
-test("capacity applies independent input and combined-context limits", () => {
+test("{§provider-capacity-admission} capacity applies independent input and combined-context limits", () => {
     assert.equal(effectiveInputCapacity({
         contextWindow: 100_000,
         maxInputTokens: 70_000,
@@ -61,7 +61,7 @@ test("a known combined context must leave positive input capacity", () => {
     );
 });
 
-test("only exact overflow rejects before provider I/O", () => {
+test("{§provider-capacity-admission} only exact overflow rejects before provider I/O", () => {
     const base = {
         contextWindow: 100,
         maxInputTokens: null,

package/src/catalogProvider.test.ts

@@ -865,7 +865,7 @@ test("cataloged unknown model fails unless its context is explicit", () => {
     assert.deepEqual(provider?.supportedReasoningPolicies, ["off", "adaptive"]);
 });
 
-test("Models.dev is the only fallback rate table", async () => {
+test("{§provider-monetary-evidence} Models.dev is the only fallback rate table", async () => {
     mock.method(globalThis, "fetch", async () => new Response([
         `data: ${JSON.stringify({
             id: "response",
@@ -963,3 +963,48 @@ test("(#458) declared efforts union into the supported set under the models.dev-
     // (#474) "max" joined the portable vocabulary; "off" still requires a declared "none".
     assert.deepEqual(provider?.supportedReasoningPolicies, ["adaptive", "low", "high", "max"]);
 });
+
+test("{§provider-reasoning-style} {§google-reasoning-request}: a route-level thinking_config style asks Gemini behind Cloudflare's gateway for readable thoughts", async () => {
+    const bodies: Record<string, unknown>[] = [];
+    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
+        bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+        return new Response([
+            `data: ${JSON.stringify({
+                id: "gateway-gemini",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "gemini-3.8-flash",
+                choices: [{ index: 0, delta: { content: "done" }, finish_reason: "stop" }],
+            })}`,
+            "data: [DONE]",
+        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+    });
+    const gatewayEnv = {
+        ...env,
+        CLOUDFLARE_ACCOUNT_ID: "account",
+        CLOUDFLARE_API_KEY: "token",
+        PLURNK_PROVIDERS_CONTEXT_WINDOW: "1048576",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_REASONING_STYLE: "effort_required",
+        PLURNK_PROVIDERS_REASONING_STYLE: "thinking_config",
+    };
+    const model = "google-ai-studio/gemini-3.8-flash";
+    const adaptive = catalogProviderFromEnv("cloudflare-workers-ai", { ...gatewayEnv, PLURNK_PROVIDERS_REASONING: "adaptive" }, model);
+    assert.deepEqual(adaptive?.supportedReasoningPolicies, ["adaptive", "low", "medium", "high"]);
+    await adaptive?.generate({ workerId: "gemini-adaptive", messages: [{ role: "user", content: "hello" }] });
+    const high = catalogProviderFromEnv("cloudflare-workers-ai", { ...gatewayEnv, PLURNK_PROVIDERS_REASONING: "high" }, model);
+    await high?.generate({ workerId: "gemini-high", messages: [{ role: "user", content: "hello" }] });
+
+    assert.deepEqual(bodies.map((body) => body.extra_body), [
+        { google: { thinking_config: { include_thoughts: true } } },
+        { google: { thinking_config: { include_thoughts: true, thinking_level: "high" } } },
+    ]);
+    assert.ok(bodies.every((body) => !("reasoning_effort" in body)), "Gemini refuses reasoning_effort beside a thinking_config");
+    assert.throws(
+        () => catalogProviderFromEnv("cloudflare-workers-ai", { ...gatewayEnv, PLURNK_PROVIDERS_REASONING: "off" }, model),
+        /reasoning policy 'off' is unsupported; supported policies: adaptive, low, medium, high/,
+    );
+    assert.throws(
+        () => catalogProviderFromEnv("cloudflare-workers-ai", { ...gatewayEnv, PLURNK_PROVIDERS_REASONING_STYLE: "gemini" }, model),
+        /cloudflare-workers-ai provider: PLURNK_PROVIDERS_REASONING_STYLE has invalid value "gemini"/,
+    );
+});

package/src/catalogProvider.ts

@@ -38,19 +38,25 @@ import type { LanguageModel } from "ai";
 import type { AiSdkProviderOptions, CacheAffinity } from "./AiSdkProvider.ts";
 import type { PluginAttribution, PluginAttributionContext } from "@plurnk/plurnk-meta";
 
+// {§provider-reasoning-style} — the provider-wide declaration, unless the bare knob (alias-scopable:
+// PLURNK_PROVIDERS_REASONING_STYLE_<alias>) names the wire for one route; one provider can serve
+// models whose reasoning controls differ (Cloudflare's gateway hosts `@cf/…` and Gemini alike).
 const reasoningStyleFromEnv = (
     env: NodeJS.ProcessEnv,
     name: string,
 ): ReasoningStyle | undefined => {
     const prefix = name.replaceAll(/[^a-zA-Z0-9]/g, "_").toUpperCase();
-    const value = env[`PLURNK_PROVIDERS_PROVIDER_${prefix}_REASONING_STYLE`];
+    const routeKey = "PLURNK_PROVIDERS_REASONING_STYLE";
+    const providerKey = `PLURNK_PROVIDERS_PROVIDER_${prefix}_REASONING_STYLE`;
+    const key = env[routeKey] !== undefined && env[routeKey].length > 0 ? routeKey : providerKey;
+    const value = env[key];
     if (value === undefined || value.length === 0) return undefined;
     const styles: readonly ReasoningStyle[] = [
         "none", "think", "include_reasoning", "effort",
-        "effort_explicit", "effort_required", "thinking_effort", "template", "anthropic",
+        "effort_explicit", "effort_required", "thinking_effort", "thinking_config", "template", "anthropic",
     ];
     if (!styles.includes(value as ReasoningStyle)) {
-        throw new Error(`${name} provider: PLURNK_PROVIDERS_PROVIDER_${prefix}_REASONING_STYLE has invalid value "${value}"`);
+        throw new Error(`${name} provider: ${key} has invalid value "${value}"`);
     }
     return value as ReasoningStyle;
 };
@@ -167,6 +173,9 @@ const supportedReasoningPolicies = ({
     // not, and a word the template does not know fails loudly on the first request.
     if (style === "template") return REASONING_POLICIES;
     if (info !== undefined && info.reasoning !== true) return activationPolicies;
+    // {§google-reasoning-request} — the declared wire's whole vocabulary: Gemini reasons
+    // unconditionally and takes exactly these levels.
+    if (style === "thinking_config") return reasoningWithoutOff;
     if (info?.reasoningOptions !== undefined) {
         return catalogSupportedReasoningPolicies({ info, native, style, declared });
     }

package/src/compatibleProvider.test.ts

@@ -44,7 +44,7 @@ test("an undifferentiated compatible endpoint receives no guessed prompt-cache f
         return streamedChatResponse("ok");
     });
 
-    const provider = await compatibleProviderFromEnv("openai", env, "local");
+    const provider = await compatibleProviderFromEnv(env, "local");
     await provider.generate({
         workerId: "worker-affinity",
         messages: [{ role: "user", content: "hello" }],
@@ -65,7 +65,7 @@ test("the server-wide DRY-off floor emits no DRY request fields", async () => {
         return streamedChatResponse("ok");
     });
 
-    const provider = await compatibleProviderFromEnv("openai", {
+    const provider = await compatibleProviderFromEnv({
         ...env,
         PLURNK_PROVIDERS_DRY_MULTIPLIER: "0",
         // Stale or independently supplied shape values cannot activate DRY.
@@ -90,7 +90,7 @@ test("(#483) a detected llama-server rail admits the operator's stated effort",
         if (url.endsWith("/props")) return new Response(JSON.stringify({ total_slots: 1 }));
         throw new Error(`unexpected request ${url}`);
     });
-    const provider = await compatibleProviderFromEnv("openai", { ...env, PLURNK_PROVIDERS_REASONING: "medium" }, "local");
+    const provider = await compatibleProviderFromEnv({ ...env, PLURNK_PROVIDERS_REASONING: "medium" }, "local");
     assert.ok(provider.supportedReasoningPolicies.includes("medium"), "the template governs: medium is admitted on a llama-server rail");
     assert.ok(provider.supportedReasoningPolicies.includes("low") && provider.supportedReasoningPolicies.includes("high"), "the whole policy vocabulary rides; the template refuses unknown words itself");
 });
@@ -118,7 +118,7 @@ test("detected llama-server measures the complete chat request through input_tok
         throw new Error(`unexpected request ${url}`);
     });
 
-    const provider = await compatibleProviderFromEnv("openai", env, "local");
+    const provider = await compatibleProviderFromEnv(env, "local");
     const messages = [
         { role: "system" as const, content: "system slot" },
         { role: "user" as const, content: "漢漢漢" },
@@ -134,7 +134,7 @@ test("detected llama-server measures the complete chat request through input_tok
     assert.deepEqual(countBody?.chat_template_kwargs, { enable_thinking: false });
 });
 
-test("a missing llama-server input-token endpoint degrades explicitly, never to a claimed bound", async () => {
+test("{§provider-prompt-measurement} a missing llama-server input-token endpoint degrades explicitly, never to a claimed bound", async () => {
     mock.method(globalThis, "fetch", async (input: string | URL | Request) => {
         const url = String(input);
         if (url.endsWith("/models")) {
@@ -147,7 +147,7 @@ test("a missing llama-server input-token endpoint degrades explicitly, never to
         throw new Error(`unexpected request ${url}`);
     });
 
-    const provider = await compatibleProviderFromEnv("openai", env, "local");
+    const provider = await compatibleProviderFromEnv(env, "local");
     assert.deepEqual(await provider.countPromptTokens([{ role: "user", content: "漢漢漢" }]), {
         kind: "estimate",
         tokens: 2,

package/src/compatibleProvider.ts

@@ -16,7 +16,6 @@ import {
     reasoningResponseStyleFromEnv,
 } from "./env.ts";
 import { providerSource } from "./notices.ts";
-import { plurnkCostNormalizer } from "./accounting.ts";
 import type { Provider } from "./types.ts";
 import { emitWarningOnce } from "./warnings.ts";
 
@@ -27,22 +26,16 @@ type EndpointProbe = {
     failed: boolean;
 };
 
-const chatUrl = (
-    provider: "openai" | "plurnk",
-    env: NodeJS.ProcessEnv,
-    override?: string,
-): string => {
-    const configured = override
-        ?? (provider === "openai"
-            ? env.OPENAI_BASE_URL ?? env.OPENAI_API_BASE
-            : env.PLURNK_BASE_URL);
+const provider = "openai";
+
+const chatUrl = (env: NodeJS.ProcessEnv, override?: string): string => {
+    const configured = override ?? env.OPENAI_BASE_URL ?? env.OPENAI_API_BASE;
     if (configured === undefined || configured.length === 0) {
-        throw new Error(`${provider} provider: ${provider === "openai" ? "OPENAI_BASE_URL or OPENAI_API_BASE" : "PLURNK_BASE_URL"} must be set`);
+        throw new Error(`${provider} provider: OPENAI_BASE_URL or OPENAI_API_BASE must be set`);
     }
     const base = configured.replace(/\/+$/, "");
     if (base.endsWith("/chat/completions")) return base;
-    if (provider === "openai") return `${base.replace(/\/v1$/, "")}/v1/chat/completions`;
-    return `${base}/chat/completions`;
+    return `${base.replace(/\/v1$/, "")}/v1/chat/completions`;
 };
 
 const probeModels = async (
@@ -114,18 +107,16 @@ const probeProps = async (
 };
 
 export const compatibleProviderFromEnv = async (
-    provider: "openai" | "plurnk",
     env: NodeJS.ProcessEnv,
     model: string,
     baseUrlOverride?: string,
 ): Promise<Provider> => {
-    // The knobs remain universal and fail hard when malformed, but this local /
-    // first-party compatible route declares no vendor cache projection. llama-server
-    // already owns slot affinity and the first-party endpoint receives worker metadata.
+    // The knobs remain universal and fail hard when malformed, but this local compatible
+    // route declares no vendor cache projection: llama-server already owns slot affinity.
     cacheAffinityFromEnv(env, provider);
     cacheWritePolicyFromEnv(env, provider);
-    const url = chatUrl(provider, env, baseUrlOverride);
-    const apiKey = provider === "openai" ? env.OPENAI_API_KEY : env.PLURNK_API_KEY;
+    const url = chatUrl(env, baseUrlOverride);
+    const apiKey = env.OPENAI_API_KEY;
     const headers: Record<string, string> = apiKey === undefined || apiKey.length === 0
         ? {}
         : { Authorization: `Bearer ${apiKey}` };
@@ -145,8 +136,8 @@ export const compatibleProviderFromEnv = async (
         throw new Error(`${provider} provider: PLURNK_PROVIDERS_LLAMA_SERVER must be "1", "0", or unset`);
     }
     const pinned = pinRaw === undefined || pinRaw === "" ? null : pinRaw === "1";
-    const llamaServer = provider === "openai" && (pinned ?? probe.llamaServer);
-    if (probe.failed && pinned === null && provider === "openai") {
+    const llamaServer = pinned ?? probe.llamaServer;
+    if (probe.failed && pinned === null) {
         emitWarningOnce(
             `${provider} provider: llama-server detection failed after ${attempts} attempts; pin PLURNK_PROVIDERS_LLAMA_SERVER=1 when this is a llama-server`,
             "PLURNK_PROBE_FAILED",
@@ -160,7 +151,7 @@ export const compatibleProviderFromEnv = async (
     }
 
     let grammarStyle: GrammarStyle = "none";
-    let reasoningStyle: ReasoningStyle = provider === "openai" ? "think" : "none";
+    let reasoningStyle: ReasoningStyle = "think";
     let slotCount: number | null = null;
     let eosText: string | undefined;
     let tokenizeUrl: string | undefined;
@@ -210,17 +201,11 @@ export const compatibleProviderFromEnv = async (
         dryBase: parseOptionalFloat(env.PLURNK_PROVIDERS_DRY_BASE, "PLURNK_PROVIDERS_DRY_BASE", provider, 0) ?? undefined,
         dryAllowedLength: parseOptionalInt(env.PLURNK_PROVIDERS_DRY_ALLOWED_LENGTH, "PLURNK_PROVIDERS_DRY_ALLOWED_LENGTH", provider) ?? undefined,
         repeatLastN: parseOptionalInt(env.PLURNK_PROVIDERS_REPEAT_LAST_N, "PLURNK_PROVIDERS_REPEAT_LAST_N", provider) ?? undefined,
-        tuningFloors: provider !== "plurnk",
         retryAttempts: parseRequiredInt(env.PLURNK_PROVIDERS_RETRY_ATTEMPTS, "PLURNK_PROVIDERS_RETRY_ATTEMPTS", provider),
         errorDetailLimit: parseRequiredInt(env.PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT, "PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT", provider),
         source: providerSource(provider),
         grammarStyle,
         ...dataCaptureFromEnv(env, provider),
-        firstPartyMetadata: provider === "plurnk",
-        normalizeCost: provider === "plurnk" ? plurnkCostNormalizer : undefined,
-        apiKeyRejectedMessage: provider === "plurnk"
-            ? "PLURNK_API_KEY was rejected by plurnk.ai (invalid or expired)."
-            : undefined,
         supportsSlotPinning: llamaServer,
         slotCount,
         eosText,

package/src/cost.test.ts

@@ -16,7 +16,7 @@ const usage: ProviderUsage = {
     totalTokens: 2,
 };
 
-test("direct charged evidence wins over a Models.dev estimate", () => {
+test("{§provider-monetary-evidence} direct charged evidence wins over a Models.dev estimate", () => {
     const charged = {
         kind: "charged",
         amount: { amount: "0.0000042", currency: "XMR" },
@@ -28,7 +28,7 @@ test("direct charged evidence wins over a Models.dev estimate", () => {
     assert.equal(providerCostUsd(charged), "0.73");
 });
 
-test("an exact zero estimate remains distinguishable from unknown cost", () => {
+test("{§provider-cost} an exact zero estimate remains distinguishable from unknown cost", () => {
     const zero = estimateProviderCost(usage, { input: 0, output: 0 }, "Models.dev");
     const unknown = estimateProviderCost(usage, null, "Models.dev");
     assert.deepEqual(zero, {
@@ -104,7 +104,7 @@ test("decimal aggregation is exact and becomes unknown if any request is unknown
     ]), null);
 });
 
-test("malformed charged money is rejected instead of coerced", () => {
+test("{§provider-cost} malformed charged money is rejected instead of coerced", () => {
     assert.throws(() => validateChargedCost({
         kind: "charged",
         amount: { amount: "1e3", currency: "usd" },

package/src/discover.test.ts

@@ -5,6 +5,11 @@ import os from "node:os";
 import path from "node:path";
 import { discover } from "./discover.ts";
 
+// This file's fixtures are third-party packages, so it exercises the operator who admitted them
+// ({§executor-trust}); the shipped panel admits only `@plurnk/*`. Tests of the gate itself state
+// their own value below and override this one.
+process.env.PLURNK_PLUGINS_TRUSTED_ONLY = "0";
+
 // Create a temp dir and register its removal on the test context, so it is
 // cleaned on a GREEN or RED run. A trailing rm after the assertions leaks the dir
 // whenever one throws — thousands accumulate on a shared box at drill frequency.
@@ -166,13 +171,17 @@ const trustFixture = (t: TestContext) => buildModules(t, {
     "@acme/acme-provider-foo": { name: "@acme/acme-provider-foo", plurnk: { kind: "provider", name: "foo" } },
 });
 
-test("trust gate OFF (unset/empty/0): every provider is trusted", async (t) => {
+test("trust gate OFF ('' or '0'): every provider is trusted; unset defers to the panel", async (t) => {
     const root = await trustFixture(t);
-    for (const gate of [undefined, "", "0"]) {
+    for (const gate of ["", "0"]) {
         const { registry, skipped } = await discover({ cwd: root, env: { PLURNK_PLUGINS_TRUSTED_ONLY: gate } as NodeJS.ProcessEnv });
         assert.deepEqual([...registry.keys()].sort(), ["foo", "native"]);
         assert.equal(skipped.size, 0);
     }
+    // An unset key is answered by @plurnk/plurnk-meta's own panel, which ships `1`.
+    const { registry, skipped } = await discover({ cwd: root, env: {} as NodeJS.ProcessEnv });
+    assert.deepEqual([...registry.keys()].sort(), ["native"], "only the first-party provider survives the shipped gate");
+    assert.equal(skipped.size, 1);
 });
 
 test("trust gate ON: @plurnk/* always trusted; third party declined → skipped, not registered", async (t) => {

package/src/env.test.ts

@@ -113,6 +113,7 @@ test("scopeEnvToAlias: suffixed knob wins, bare is the fallback, other aliases i
         PLURNK_PROVIDERS_REASONING_turboderp: "high",
         PLURNK_PROVIDERS_REASONING_BUDGET_TURBODERP: "4096", // case-folds like PLURNK_MODEL_ keys
         PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE_TURBODERP: "think-tags",
+        PLURNK_PROVIDERS_REASONING_STYLE_turboderp: "thinking_config",
         PLURNK_PROVIDERS_CONTEXT_WINDOW_turboderp: "8000",
         PLURNK_PROVIDERS_OUTPUT_BUDGET_turboderp: "4096",
         PLURNK_PROVIDERS_CONTEXT_WINDOW_other: "1",
@@ -121,9 +122,11 @@ test("scopeEnvToAlias: suffixed knob wins, bare is the fallback, other aliases i
     assert.equal(scoped.PLURNK_PROVIDERS_REASONING, "high");
     assert.equal(scoped.PLURNK_PROVIDERS_REASONING_BUDGET, "4096");
     assert.equal(scoped.PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE, "think-tags");
+    assert.equal(scoped.PLURNK_PROVIDERS_REASONING_STYLE, "thinking_config");
     assert.equal(scoped.PLURNK_PROVIDERS_CONTEXT_WINDOW, "8000");
     assert.equal(scoped.PLURNK_PROVIDERS_OUTPUT_BUDGET, "4096");
     assert.equal(scopeEnvToAlias(env, "plain").PLURNK_PROVIDERS_REASONING, "off"); // fallback intact
+    assert.equal(scopeEnvToAlias(env, "plain").PLURNK_PROVIDERS_REASONING_STYLE, undefined, "another alias's style never leaks");
 });
 
 test("scopeEnvToAlias: aliases with underscores resolve; a bare knob is never mistaken for a suffix", async () => {

package/src/env.ts

@@ -243,7 +243,7 @@ export const resolveGenerationEnvelopeFromEnv = (
 //   PLURNK_PROVIDERS_REASONING_BUDGET  optional reasoning subset of the total
 //     output budget, used for tier/budget mapping where the backend supports it.
 // The provider maps intent to the backend's mechanism; the consumer states
-// intent, never mechanism. TASK inventory is separate from provider reasoning.
+// intent, never mechanism. working memory is separate from provider reasoning.
 export type Reasoning = { mode: ReasoningPolicy; budget: number | null };
 
 export const parseReasoningPolicy = (value: unknown, label: string): ReasoningPolicy => {
@@ -294,6 +294,7 @@ export const PROVIDERS_KNOBS = Object.freeze([
     "PLURNK_PROVIDERS_COST",
     "PLURNK_PROVIDERS_OUTPUT_BUDGET",
     "PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE",
+    "PLURNK_PROVIDERS_REASONING_STYLE",
     "PLURNK_PROVIDERS_REASONING_BUDGET",
     "PLURNK_PROVIDERS_REASONING",
     "PLURNK_PROVIDERS_CONTEXT_WINDOW",