@plurnk/plurnk-providers 1.18.0 → 1.19.1

package/src/catalogProvider.test.ts

@@ -106,12 +106,6 @@ test("provider adapters advertise only reasoning policies they can preserve", ()
     }, "mistral-small-latest");
     assert.deepEqual(mistral?.supportedReasoningPolicies, ["off", "adaptive", "high"], "Mistral's low/medium coercion is not advertised as exact support");
 
-    const grok = catalogProviderFromEnv("xai", {
-        ...env,
-        XAI_API_KEY: "test-key",
-        PLURNK_PROVIDERS_REASONING: "adaptive",
-    }, "grok-4.6");
-    assert.deepEqual(grok?.supportedReasoningPolicies, ["adaptive", "low", "medium", "high", "xhigh"], "Grok 4.6 cannot disable reasoning");
 
     const gemini = catalogProviderFromEnv("google", {
         ...env,
@@ -368,79 +362,6 @@ test("official AI SDK provider owns the native request while PLURNK owns call se
     assert.equal(calls[0]?.body.prompt_cache_key, "worker", "the official OpenAI SDK projects the documented affinity key");
 });
 
-test("xAI's native chat contract requests its strongest cataloged effort and caps the complete reasoning response", async () => {
-    let call: { headers: Headers; body: Record<string, unknown> } | undefined;
-    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
-        call = {
-            headers: new Headers(init?.headers),
-            body: JSON.parse(String(init?.body)) as Record<string, unknown>,
-        };
-        return new Response([
-            `data: ${JSON.stringify({
-                id: "response-xai",
-                object: "chat.completion.chunk",
-                created: 1,
-                model: "grok-4.6",
-                choices: [{ index: 0, delta: { reasoning_content: "consider" }, finish_reason: null }],
-            })}`,
-            `data: ${JSON.stringify({
-                id: "response-xai",
-                object: "chat.completion.chunk",
-                created: 2,
-                model: "grok-4.6",
-                choices: [{ index: 0, delta: { content: "OK" }, finish_reason: "stop" }],
-            })}`,
-            `data: ${JSON.stringify({
-                id: "response-xai",
-                object: "chat.completion.chunk",
-                created: 3,
-                model: "grok-4.6",
-                choices: [],
-                usage: {
-                    prompt_tokens: 5,
-                    completion_tokens: 4,
-                    total_tokens: 9,
-                    prompt_tokens_details: { cached_tokens: 2 },
-                    completion_tokens_details: { reasoning_tokens: 3 },
-                    cost_in_usd_ticks: 1_230_000,
-                },
-            })}`,
-            "data: [DONE]",
-        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
-    });
-
-    const provider = catalogProviderFromEnv("xai", {
-        ...env,
-        XAI_API_KEY: "test-key",
-        PLURNK_PROVIDERS_REASONING: "adaptive",
-    }, "grok-4.6");
-    const result = await provider?.generate({
-        workerId: "xai-worker",
-        messages: [{ role: "user", content: "hello" }],
-        maxOutputTokens: 16,
-    });
-
-    assert.equal(call?.body.max_completion_tokens, 16);
-    assert.equal(call?.body.reasoning_effort, "xhigh", "adaptive uses the strongest route-advertised generic effort");
-    assert.equal("max_tokens" in (call?.body ?? {}), false);
-    assert.equal(call?.headers.get("x-grok-conv-id"), "xai-worker");
-    assert.equal(result?.assistant.reasoning, "consider");
-    assert.equal(result?.assistant.content, "OK");
-    assert.deepEqual(result?.accounting[0]?.usage, {
-        inputTokens: 5,
-        outputTokens: 4,
-        totalTokens: 9,
-        inputTokenDetails: { cacheReadTokens: 2 },
-        outputTokenDetails: { textTokens: 1, reasoningTokens: 3 },
-    });
-    assert.deepEqual(result?.accounting[0]?.cost, {
-        kind: "charged",
-        amount: { amount: "1230000", currency: "USDTICK" },
-        usdEquivalent: "0.000123",
-        source: "xAI response usage.cost_in_usd_ticks",
-    });
-});
-
 test("Cerebras explicit and adaptive reasoning do not invent a token budget", async () => {
     let body: Record<string, unknown> | undefined;
     mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
@@ -852,12 +773,12 @@ test("native provider routes project their documented cache controls through the
 
 test("cataloged unknown model fails unless its context is explicit", () => {
     assert.throws(
-        () => catalogProviderFromEnv("xai", env, "not-in-the-catalog"),
+        () => catalogProviderFromEnv("groq", env, "not-in-the-catalog"),
         /context window unresolved/,
     );
-    const provider = catalogProviderFromEnv("xai", {
+    const provider = catalogProviderFromEnv("groq", {
         ...env,
-        XAI_API_KEY: "test-key",
+        GROQ_API_KEY: "test-key",
         PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192",
         PLURNK_PROVIDERS_REASONING: "adaptive",
     }, "not-in-the-catalog");
@@ -865,7 +786,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",
@@ -901,9 +822,9 @@ test("Models.dev is the only fallback rate table", async () => {
         source: "Models.dev catalog rates",
     });
 
-    const uncataloged = catalogProviderFromEnv("xai", {
+    const uncataloged = catalogProviderFromEnv("groq", {
         ...env,
-        XAI_API_KEY: "test-key",
+        GROQ_API_KEY: "test-key",
         PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192",
         PLURNK_PROVIDERS_REASONING: "adaptive",
     }, "not-in-the-catalog");
@@ -963,3 +884,4 @@ 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"]);
 });
+

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",
     ];
     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,8 @@ 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;
+    // The declared wire's whole vocabulary: a route that reasons unconditionally still
+    // admits only the levels the catalog advertises for it.
     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",

package/src/errors.test.ts

@@ -15,7 +15,7 @@ const apiError = (statusCode: number, responseBody = "body") => new APICallError
 
 const SOURCE_PATTERN = /^[a-z]+(:[a-z][a-z0-9-]*)?$/;
 
-test("HTTP request rejection preserves its cause without becoming a response-contract strike", () => {
+test("{§provider-request-rejection} HTTP request rejection preserves its cause without becoming a response-contract strike", () => {
     for (const status of [400, 404, 405, 422]) {
         const message = "The requested model is not available on this endpoint.";
         const cause = apiError(status, JSON.stringify({ error: { message } }));
@@ -54,7 +54,7 @@ test("classifyProviderError maps HTTP status to kind", () => {
     assert.equal(k(404), "request_rejected");
 });
 
-test("capacity normalization prefers structured provider codes and keeps generic 400s distinct", () => {
+test("{§provider-capacity-failure} capacity normalization prefers structured provider codes and keeps generic 400s distinct", () => {
     const openai = apiError(400, JSON.stringify({
         error: {
             type: "invalid_request_error",

package/src/index.ts

@@ -9,7 +9,7 @@ export type {
     AiSdkProviderPlugin,
     ProviderOptions,
     ProviderResponse,
-    ProviderEncryptedReasoningItem,
+
     ProviderAccounting,
     ProviderCost,
     ProviderCostNormalizer,
@@ -78,7 +78,6 @@ export {
 } from "./cost.ts";
 export {
     aggregateProviderAccounting,
-    plurnkCostNormalizer,
     providerCostNormalizer,
     validateProviderRequestAccounting,
 } from "./accounting.ts";

package/src/inputModalities.test.ts

@@ -16,6 +16,7 @@ const parts: ChatMessage = {
         { type: "text", text: "look at this" },
         { type: "file", data: PNG, mediaType: "image/png" },
         { type: "file", data: PDF, mediaType: "application/pdf" },
+        { type: "file", data: new Uint8Array([82, 73, 70, 70]), mediaType: "audio/wav" },
     ],
 };
 
@@ -37,7 +38,7 @@ test("{§provider-input-modalities} the Mock declares modalities by option and r
     const seeing = new Mock({ contextWindow: 200000, responses: [], inputModalities: ["image", "pdf"] });
     assert.ok(seeing.inputModalities.has("image") && seeing.inputModalities.has("pdf") && !seeing.inputModalities.has("audio"));
     assert.equal(tokensOf(await seeing.countPromptTokens([parts])), Math.ceil("look at this".length / 2));
-    await assert.rejects(seeing.generate({ messages: [parts], maxOutputTokens: 16, workerId: "1", primaryWorkerId: "1", callKind: "bare" } as never));
+    await assert.rejects(seeing.generate({ messages: [parts], maxOutputTokens: 16, workerId: "1", callKind: "bare" } as never));
     assert.equal(seeing.received.length, 1, "the request was recorded before the empty queue refused it");
     const received = seeing.received[0]?.[0]?.content;
     assert.ok(Array.isArray(received) && received[1]?.type === "file" && received[1].mediaType === "image/png" && received[2]?.type === "file" && received[2].mediaType === "application/pdf");

package/src/sdkModels.test.ts

@@ -103,16 +103,6 @@ test("{§model-catalog-readiness}: an authenticated operator declaration reports
     );
 });
 
-test("createSdkModel uses Models.dev provider facts and operator credentials", () => {
-    const sdk = createSdkModel("xai", "grok-build-0.1", { XAI_API_KEY: "test-key" });
-    assert.notEqual(sdk, null);
-    assert.equal(sdk?.catalog?.npm, "@ai-sdk/xai");
-    assert.notEqual(sdk?.languageModel, undefined);
-    assert.equal(sdk?.compatible, undefined);
-    assert.deepEqual(sdk?.cacheAffinity, { target: "header", name: "x-grok-conv-id" });
-    assert.notEqual(sdk?.normalizeCost, undefined);
-});
-
 test("createSdkModel constructs Cerebras from Models.dev facts", () => {
     const sdk = createSdkModel("cerebras", "gemma-4-31b", {
         CEREBRAS_API_KEY: "test-key",

package/src/sdkModels.ts

@@ -7,7 +7,6 @@ import { createGroq } from "@ai-sdk/groq";
 import { createMistral } from "@ai-sdk/mistral";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createTogetherAI } from "@ai-sdk/togetherai";
-import { createXai } from "@ai-sdk/xai";
 import { createOpenRouter, type OpenRouterChatSettings } from "@openrouter/ai-sdk-provider";
 import {
     resolveModel,
@@ -393,15 +392,6 @@ export const createSdkModel = (
                 },
                 catalog,
             };
-        case "@ai-sdk/xai":
-            return {
-                languageModel: createXai({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).chat(model),
-                ...(catalog.id === "xai"
-                    ? { cacheAffinity: { target: "header" as const, name: "x-grok-conv-id" } }
-                    : {}),
-                ...(normalizeCost === undefined ? {} : { normalizeCost }),
-                catalog,
-            };
         case "@ai-sdk/anthropic":
             return {
                 languageModel: createAnthropic({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),

package/src/types.ts

@@ -163,20 +163,9 @@ export interface TokenLogprob {
     readonly top?: readonly TokenAlternative[];
 }
 
-// {§provider-encrypted-reasoning} `id` is provider detail identity; `subtype`
-// is the provider's evidence-backed classification. Neither is a client entity
-// correlation, so consumers must not substitute `id` for a message/tool-call ID.
-export interface ProviderEncryptedReasoningItem {
-    readonly id: string | null;
-    readonly subtype: string;
-    readonly encrypted: ReadonlyArray<{ data: string; format: string | null }>;
-}
-
 export interface ProviderAssistant<TFinish extends ProviderAttemptFinishReason = FinishReason> {
     readonly content: string;
     readonly reasoning: string | null;
-    // Encrypted reasoning remains distinct from readable `reasoning`.
-    readonly reasoningEncrypted?: ReadonlyArray<ProviderEncryptedReasoningItem>;
     readonly finishReason: TFinish;
     readonly model: string;
     // Per-token logprobs, present only when PLURNK_PROVIDERS_TOP_LOGPROBS is set
@@ -230,16 +219,13 @@ export type ProviderAttempt = ProviderResponse<ProviderAttemptFinishReason>;
 export interface ProviderGenerateArgs {
     readonly messages: ChatMessage[];
     readonly workerId: string;
-    readonly primaryWorkerId?: string;
     readonly signal?: AbortSignal;
     readonly grammar?: string;
     readonly maxOutputTokens?: number;
-    readonly attributions?: string[];
-    readonly client?: string;
-    readonly strikes?: number;
+    // The workspace this call serves: ordinary call context for an adapter that
+    // fronts more than one workspace. It is never transported to a backend and
+    // never model-facing.
     readonly workspaceId?: string;
-    readonly loop?: number;
-    readonly turn?: number;
     readonly sampling?: Record<string, unknown>;
     readonly observeRequest?: ProviderRequestObserver;
     readonly observeReasoning?: ProviderReasoningObserver;
@@ -265,42 +251,18 @@ export interface Provider {
     // its content. The consumer never sees or chooses backend resources
     // (slot integers, connections); the mechanism is the provider's.
     //
-    // `attributions` is opaque consumer-supplied creator telemetry; the consumer
-    // owns what contribution that set claims ({§attribution}). `client` is the
-    // consumer's workspace-stable, self-identified frontend. They are forwarded ONLY by a
-    // provider whose spec opts in (the first-party `plurnk` endpoint, via
-    // `Plurnk-Attribution` / `Plurnk-Client` headers); every other provider DROPS
-    // them — the gate is structural so first-party metadata can never leak to a
-    // third-party backend.
-    //
     // `sampling` is an optional bag of standard OpenAI-compat sampling params
     // (temperature, top_p, top_k, min_p, penalties, stop, seed, …) forwarded into
     // the request body UNDER the provider's managed fields — model/messages/grammar/
     // reasoning/max_tokens/slot always win, and transport/protocol keys (stream,
     // response_format, grammar, id_slot) are stripped, so it carries sampling intent
     // only and can't bypass grammar transport ({§provider-request-authority}). A
-    // proxy consumer (the
-    // plurnk endpoint fronting its own backends) uses it to pass its caller's sampling
-    // knobs through; a direct consumer typically leaves it unset.
-    //
-    // `strikes` is the worker's CURRENT rail-strike streak at time-of-generate
-    // (0 = clean; a clean turn zeroes it; every loop starts at 0 — contract
-    // {§strikes-first-party-metadata}). Forwarded as a `Plurnk-Strikes` header ONLY under the
-    // same firstPartyMetadata gate as attributions/client; dropped everywhere
-    // else. Headers only — the packet NEVER carries strike state (the model must
-    // not see engine accounting; it would become a metric to game).
-    //
-    // `workspaceId`/`loop`/`turn` are the turn coordinate ({§lifecycle-terms}) — the
-    // daemon-side sequence of the turn being generated, which the endpoint can
-    // never scrape from the wire. Forwarded as `Plurnk-Workspace-Id`/`Plurnk-Loop`/
-    // `Plurnk-Turn` ONLY under the same firstPartyMetadata gate; dropped
-    // everywhere else. Coordinates are 1-based: absent/0 emits no header (no
-    // strikes-style zero exception). Headers only, never the packet.
+    // proxy consumer fronting its own backends uses it to pass its caller's
+    // sampling knobs through; a direct consumer typically leaves it unset.
     //
-    // `callKind` is the caller's explicit output contract. It is transported as
-    // `Plurnk-Call-Kind` only under the first-party metadata gate and never
-    // inferred from the request shape. Generic callers may omit it; Core always
-    // supplies `emission` or `bare`.
+    // `callKind` is the caller's explicit output contract, never inferred from
+    // the request shape. Generic callers may omit it; Core always supplies
+    // `emission` or `bare`.
     generate(args: ProviderGenerateArgs): Promise<ProviderResponse>;
     // {§model-fact-resolution} — effective total context envelope in tokens,
     // including any stricter operator cap. `null` means unknown; under