@plurnk/plurnk-providers 1.19.0 → 1.19.2

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");
@@ -901,9 +822,9 @@ test("{§provider-monetary-evidence} Models.dev is the only fallback rate table"
         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");
@@ -964,47 +885,3 @@ test("(#458) declared efforts union into the supported set under the models.dev-
     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

@@ -53,7 +53,7 @@ const reasoningStyleFromEnv = (
     if (value === undefined || value.length === 0) return undefined;
     const styles: readonly ReasoningStyle[] = [
         "none", "think", "include_reasoning", "effort",
-        "effort_explicit", "effort_required", "thinking_effort", "thinking_config", "template", "anthropic",
+        "effort_explicit", "effort_required", "thinking_effort", "template", "anthropic",
     ];
     if (!styles.includes(value as ReasoningStyle)) {
         throw new Error(`${name} provider: ${key} has invalid value "${value}"`);
@@ -173,9 +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;
-    // {§google-reasoning-request} — the declared wire's whole vocabulary: Gemini reasons
-    // unconditionally and takes exactly these levels.
-    if (style === "thinking_config") return reasoningWithoutOff;
+    // 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/index.ts

@@ -9,7 +9,7 @@ export type {
     AiSdkProviderPlugin,
     ProviderOptions,
     ProviderResponse,
-    ProviderEncryptedReasoningItem,
+
     ProviderAccounting,
     ProviderCost,
     ProviderCostNormalizer,

package/src/sdkModels.test.ts

@@ -103,16 +103,6 @@ test("{§model-catalog-readiness}: an authenticated operator declaration reports
     );
 });
 
-test("{§provider-sdk-boundary} 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