@plurnk/plurnk-providers 1.10.1 → 1.12.0

package/src/aiSdkTransport.test.ts

@@ -2,7 +2,11 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { APICallError } from "ai";
 import { ProviderTimeoutError } from "./errors.ts";
-import { executeOpenAICompatible, normalizeRetryAttemptError } from "./aiSdkTransport.ts";
+import {
+    executeOpenAICompatible,
+    normalizeRetryAttemptError,
+    transportFailureOutputObserved,
+} from "./aiSdkTransport.ts";
 
 const request = {
     url: "https://example.test/v1/chat/completions",
@@ -41,6 +45,42 @@ test("the transport performs exactly one physical request", async () => {
     assert.equal(calls, 1);
 });
 
+test("stream failure evidence distinguishes semantic output from pre-output failure ({§provider-connectivity})", async (t) => {
+    const cases = [
+        { name: "text", delta: { content: "partial" }, expected: true },
+        { name: "reasoning", delta: { reasoning_content: "partial" }, expected: true },
+        { name: "empty", delta: {}, expected: false },
+    ] as const;
+    for (const specimen of cases) {
+        await t.test(specimen.name, async () => {
+            await assert.rejects(
+                executeOpenAICompatible({
+                    ...request,
+                    streaming: true,
+                    fetch: async () => new Response(new ReadableStream({
+                        start(controller) {
+                            controller.enqueue(new TextEncoder().encode(
+                                `data: ${JSON.stringify({
+                                    id: "interrupted",
+                                    object: "chat.completion.chunk",
+                                    created: 1,
+                                    model: "test-model",
+                                    choices: [{ index: 0, delta: specimen.delta, finish_reason: null }],
+                                })}\n\n`,
+                            ));
+                            setTimeout(() => controller.error(new TypeError("terminated")), 10);
+                        },
+                    }), { status: 200 }),
+                }),
+                (error) => {
+                    assert.equal(transportFailureOutputObserved(error), specimen.expected);
+                    return true;
+                },
+            );
+        });
+    }
+});
+
 test("the adapter preserves PLURNK request extensions and response evidence", async () => {
     let body: Record<string, unknown> | undefined;
     const responseBody = {

package/src/aiSdkTransport.ts

@@ -1,6 +1,6 @@
 import { createOpenAICompatible, type ProviderErrorStructure } from "@ai-sdk/openai-compatible";
 import { APICallError, generateText, streamText, type CallWarning, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
-import { z } from "zod/v4";
+import { z } from "zod";
 import type { ChatMessage, ProviderAttemptFinishReason, ProviderChargeEvidence, ProviderReasoningObserver, ProviderUsage, TokenLogprob } from "./types.ts";
 import { normalizeUsage, type RawUsage } from "./usage.ts";
 import { emitWarningOnce } from "./warnings.ts";
@@ -222,13 +222,36 @@ const transportTimeout = (
 };
 
 const streamFailureValues = new WeakMap<object, readonly unknown[]>();
+const streamFailureOutput = new WeakSet<object>();
 
 const retainStreamFailureValues = <T extends object>(source: object, target: T): T => {
     const values = streamFailureValues.get(source);
     if (values !== undefined) streamFailureValues.set(target, values);
+    if (streamFailureOutput.has(source)) streamFailureOutput.add(target);
     return target;
 };
 
+const preserveStreamFailure = (
+    error: unknown,
+    rawChunks: readonly unknown[],
+    outputObserved: boolean,
+): void => {
+    if (typeof error !== "object" || error === null) return;
+    streamFailureValues.set(error, [...rawChunks, error]);
+    if (outputObserved) streamFailureOutput.add(error);
+};
+
+export const transportFailureOutputObserved = (error: unknown): boolean => {
+    const seen = new Set<unknown>();
+    let current = error;
+    while (typeof current === "object" && current !== null && !seen.has(current)) {
+        if (streamFailureOutput.has(current)) return true;
+        seen.add(current);
+        current = (current as { cause?: unknown }).cause;
+    }
+    return false;
+};
+
 export const normalizeRetryAttemptError = (error: unknown): unknown => {
     if (!APICallError.isInstance(error)) {
         // Attempt, first-content, and stream-idle deadlines are retryable network
@@ -410,17 +433,23 @@ const executeModelOnce = async (
     });
     const rawChunks: unknown[] = [];
     let streamError: unknown;
-    for await (const part of result.fullStream) {
-        if (part.type === "raw") rawChunks.push(part.rawValue);
-        if (part.type === "reasoning-delta" && part.text.length > 0) {
-            request.observeReasoning?.(part.text);
+    let outputObserved = false;
+    try {
+        for await (const part of result.fullStream) {
+            if (part.type === "raw") rawChunks.push(part.rawValue);
+            if (part.type === "text-delta" && part.text.length > 0) outputObserved = true;
+            if (part.type === "reasoning-delta" && part.text.length > 0) {
+                outputObserved = true;
+                request.observeReasoning?.(part.text);
+            }
+            if (part.type === "error") streamError ??= part.error;
         }
-        if (part.type === "error") streamError ??= part.error;
+    } catch (error) {
+        preserveStreamFailure(error, rawChunks, outputObserved);
+        throw error;
     }
     if (streamError !== undefined) {
-        if (typeof streamError === "object" && streamError !== null) {
-            streamFailureValues.set(streamError, [...rawChunks, streamError]);
-        }
+        preserveStreamFailure(streamError, rawChunks, outputObserved);
         throw streamError;
     }
     const evidence = extractEvidence(rawChunks);

package/src/catalogProvider.test.ts

@@ -48,7 +48,7 @@ test("provider adapters advertise only reasoning policies they can preserve", ()
         PLURNK_PROVIDERS_REASONING: "adaptive",
         PLURNK_PROVIDERS_PROVIDER_DEEPSEEK_REASONING_STYLE: "thinking_effort",
     }, "deepseek-v4-flash");
-    assert.deepEqual(deepseek?.supportedReasoningPolicies, ["off", "adaptive", "high"]);
+    assert.deepEqual(deepseek?.supportedReasoningPolicies, ["off", "adaptive", "low", "high"]);
 
     assert.throws(
         () => catalogProviderFromEnv("deepseek", {
@@ -57,7 +57,7 @@ test("provider adapters advertise only reasoning policies they can preserve", ()
             PLURNK_PROVIDERS_REASONING: "medium",
             PLURNK_PROVIDERS_PROVIDER_DEEPSEEK_REASONING_STYLE: "thinking_effort",
         }, "deepseek-v4-flash"),
-        /reasoning policy 'medium' is unsupported; supported policies: off, adaptive, high/,
+        /reasoning policy 'medium' is unsupported; supported policies: off, adaptive, low, high/,
     );
 
     const mistral = catalogProviderFromEnv("mistral", {
@@ -82,6 +82,115 @@ test("provider adapters advertise only reasoning policies they can preserve", ()
     assert.deepEqual(gemini?.supportedReasoningPolicies, ["adaptive", "low", "medium", "high"], "Gemini 3's mandatory minimum is not advertised as off");
 });
 
+test("Models.dev controls Cloudflare's exact effort vocabulary", 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: "cloudflare-effort",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "@cf/qwen/qwen3.8-27b",
+                choices: [{ index: 0, delta: { content: "done" }, finish_reason: "stop" }],
+            })}`,
+            "data: [DONE]",
+        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+    });
+    const cloudflareEnv = {
+        ...env,
+        CLOUDFLARE_ACCOUNT_ID: "account",
+        CLOUDFLARE_API_KEY: "token",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_STYLE: "effort_required",
+    };
+    const low = catalogProviderFromEnv("cloudflare", {
+        ...cloudflareEnv,
+        PLURNK_PROVIDERS_REASONING: "low",
+    }, "@cf/qwen/qwen3.8-27b");
+    assert.deepEqual(low?.supportedReasoningPolicies, ["adaptive", "low", "medium"]);
+    await low?.generate({ workerId: "cloudflare-low", messages: [{ role: "user", content: "hello" }] });
+
+    const adaptive = catalogProviderFromEnv("cloudflare", {
+        ...cloudflareEnv,
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "@cf/qwen/qwen3.8-27b");
+    await adaptive?.generate({ workerId: "cloudflare-adaptive", messages: [{ role: "user", content: "hello" }] });
+
+    const nonReasoning = catalogProviderFromEnv("cloudflare", {
+        ...cloudflareEnv,
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "@cf/ibm-granite/granite-4.0-h-micro");
+    assert.deepEqual(nonReasoning?.supportedReasoningPolicies, ["off", "adaptive"]);
+    await nonReasoning?.generate({ workerId: "cloudflare-granite", messages: [{ role: "user", content: "hello" }] });
+
+    const ungradedReasoner = catalogProviderFromEnv("cloudflare", {
+        ...cloudflareEnv,
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "@cf/zai-org/glm-5.3-flash");
+    assert.deepEqual(ungradedReasoner?.supportedReasoningPolicies, ["adaptive"]);
+    await ungradedReasoner?.generate({ workerId: "cloudflare-ungraded", messages: [{ role: "user", content: "hello" }] });
+
+    assert.deepEqual(bodies.map((body) => body.reasoning_effort), ["low", "xhigh", undefined, undefined]);
+    assert.throws(
+        () => catalogProviderFromEnv("cloudflare", cloudflareEnv, "@cf/qwen/qwen3.8-27b"),
+        /reasoning policy 'off' is unsupported; supported policies: adaptive, low, medium/,
+    );
+    assert.throws(
+        () => catalogProviderFromEnv("cloudflare", {
+            ...cloudflareEnv,
+            PLURNK_PROVIDERS_REASONING: "high",
+        }, "@cf/qwen/qwen3.8-27b"),
+        /reasoning policy 'high' is unsupported; supported policies: adaptive, low, medium/,
+    );
+});
+
+test("an operator-declared effort vocabulary extends Models.dev's for a provider's reasoning routes (#439)", 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: "cloudflare-declared",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "@cf/zai-org/glm-5.3-flash",
+                choices: [{ index: 0, delta: { content: "done" }, finish_reason: "stop" }],
+            })}`,
+            "data: [DONE]",
+        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+    });
+    const declaredEnv = {
+        ...env,
+        CLOUDFLARE_ACCOUNT_ID: "account",
+        CLOUDFLARE_API_KEY: "token",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_STYLE: "effort_required",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_EFFORTS: "low, medium,high",
+    };
+    // Models.dev lists this route as reasoning with no effort vocabulary; the declaration supplies one.
+    const low = catalogProviderFromEnv("cloudflare", { ...declaredEnv, PLURNK_PROVIDERS_REASONING: "low" }, "@cf/zai-org/glm-5.3-flash");
+    assert.deepEqual(low?.supportedReasoningPolicies, ["adaptive", "low", "medium", "high"]);
+    await low?.generate({ workerId: "declared-low", messages: [{ role: "user", content: "hello" }] });
+    const adaptive = catalogProviderFromEnv("cloudflare", { ...declaredEnv, PLURNK_PROVIDERS_REASONING: "adaptive" }, "@cf/zai-org/glm-5.3-flash");
+    await adaptive?.generate({ workerId: "declared-adaptive", messages: [{ role: "user", content: "hello" }] });
+    assert.deepEqual(bodies.map((body) => body.reasoning_effort), ["low", "high"], "a fixed level keeps its name; adaptive takes the strongest declared effort");
+    // A declared `none` admits `off` on an effort transport; the catalog's own vocabulary stays in the union.
+    const withOff = catalogProviderFromEnv("cloudflare", {
+        ...declaredEnv,
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_EFFORTS: "none,high",
+    }, "@cf/qwen/qwen3.8-27b");
+    assert.deepEqual(withOff?.supportedReasoningPolicies, ["off", "adaptive", "low", "medium", "high"]);
+    // The declaration never turns a non-reasoning route into a reasoning one.
+    const nonReasoning = catalogProviderFromEnv("cloudflare", { ...declaredEnv, PLURNK_PROVIDERS_REASONING: "adaptive" }, "@cf/ibm-granite/granite-4.0-h-micro");
+    assert.deepEqual(nonReasoning?.supportedReasoningPolicies, ["off", "adaptive"]);
+    assert.throws(
+        () => catalogProviderFromEnv("cloudflare", {
+            ...declaredEnv,
+            PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_EFFORTS: "low,turbo",
+        }, "@cf/zai-org/glm-5.3-flash"),
+        /PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_EFFORTS has invalid value "turbo"; declarable efforts: none, minimal, low, medium, high, xhigh, max/,
+    );
+});
+
 test("an operator context window caps catalog physics and percentage output policy", () => {
     const provider = catalogProviderFromEnv("openai", {
         ...env,
@@ -153,7 +262,7 @@ 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 affirmatively requests adaptive high and caps the complete reasoning response", async () => {
+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 = {
@@ -206,7 +315,7 @@ test("xAI's native chat contract affirmatively requests adaptive high and caps t
     });
 
     assert.equal(call?.body.max_completion_tokens, 16);
-    assert.equal(call?.body.reasoning_effort, "high", "adaptive is affirmative on xAI's graded route");
+    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");
@@ -278,6 +387,50 @@ test("Cerebras explicit reasoning activation needs no operator effort or token b
     assert.equal(result?.accounting[0]?.usage?.outputTokenDetails?.reasoningTokens, 1);
 });
 
+test("Meta Muse adaptive reasoning is requested even when the endpoint returns no readable trace", async () => {
+    let body: Record<string, unknown> | undefined;
+    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
+        body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+        return new Response([
+            `data: ${JSON.stringify({
+                id: "chatcmpl-meta",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "muse-spark-1.2-contributor",
+                choices: [{ index: 0, delta: { content: "done" }, finish_reason: "stop" }],
+            })}`,
+            `data: ${JSON.stringify({
+                id: "chatcmpl-meta",
+                object: "chat.completion.chunk",
+                created: 2,
+                model: "muse-spark-1.2-contributor",
+                choices: [],
+                usage: {
+                    prompt_tokens: 2,
+                    completion_tokens: 38,
+                    total_tokens: 40,
+                    completion_tokens_details: { reasoning_tokens: 37 },
+                },
+            })}`,
+            "data: [DONE]",
+        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+    });
+
+    const provider = catalogProviderFromEnv("meta", {
+        ...env,
+        META_MODEL_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "muse-spark-1.2-contributor");
+    const result = await provider?.generate({
+        workerId: "worker",
+        messages: [{ role: "user", content: "hello" }],
+    });
+
+    assert.equal(body?.reasoning_effort, "xhigh");
+    assert.equal(result?.assistant.reasoning, null);
+    assert.equal(result?.accounting[0]?.usage?.outputTokenDetails?.reasoningTokens, 37);
+});
+
 test("Google adaptive reasoning requests and preserves readable thought summaries", async () => {
     const bodies: Array<{
         generationConfig?: { thinkingConfig?: { includeThoughts?: boolean; thinkingLevel?: string; thinkingBudget?: number } };
@@ -412,6 +565,7 @@ test("native Anthropic adaptive policy uses adaptive thinking rather than a fixe
             contextWindow: 16_384,
             maxOutputTokens: 8_192,
             reasoning: true,
+            reasoningOptions: [{ type: "toggle" }],
             attachment: true,
             toolCall: true,
             modalities: { input: ["text", "image"], output: ["text"] },
@@ -543,8 +697,10 @@ test("cataloged unknown model fails unless its context is explicit", () => {
         ...env,
         XAI_API_KEY: "test-key",
         PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
     }, "not-in-the-catalog");
     assert.equal(provider?.contextWindow, 8192);
+    assert.deepEqual(provider?.supportedReasoningPolicies, ["off", "adaptive"]);
 });
 
 test("Models.dev is the only fallback rate table", async () => {
@@ -570,6 +726,8 @@ test("Models.dev is the only fallback rate table", async () => {
     const cataloged = catalogProviderFromEnv("deepseek", {
         ...env,
         DEEPSEEK_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+        PLURNK_PROVIDERS_PROVIDER_DEEPSEEK_REASONING_STYLE: "thinking_effort",
     }, "deepseek-v4-flash");
     assert.notEqual(cataloged, null);
     const catalogedResponse = await cataloged!.generate({ workerId: "cataloged", messages: [] });
@@ -583,6 +741,7 @@ test("Models.dev is the only fallback rate table", async () => {
         ...env,
         XAI_API_KEY: "test-key",
         PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
     }, "not-in-the-catalog");
     const uncatalogedResponse = await uncataloged!.generate({ workerId: "uncataloged", messages: [] });
     assert.deepEqual(uncatalogedResponse.accounting[0]?.cost, {

package/src/catalogProvider.ts

@@ -1,4 +1,9 @@
-import { lookupProvider, resolveModel, type ModelInfo } from "@plurnk/plurnk-models";
+import {
+    lookupProvider,
+    resolveModel,
+    type ModelInfo,
+    type ModelReasoningEffort,
+} from "@plurnk/plurnk-models";
 import {
     contextWindowFromEnv,
     effectiveContextWindow,
@@ -12,7 +17,13 @@ import {
     reasoningFromEnv,
     reasoningResponseStyleFromEnv,
 } from "./env.ts";
-import AiSdkProvider, { type AiSdkProviderConfig, type GrammarStyle, type ReasoningStyle } from "./AiSdkProvider.ts";
+import AiSdkProvider, {
+    type AiSdkProviderConfig,
+    type CompatibleReasoningEffort,
+    type GrammarStyle,
+    type NativeReasoningEffort,
+    type ReasoningStyle,
+} from "./AiSdkProvider.ts";
 import { configuredProviderInfo, createSdkModel } from "./sdkModels.ts";
 import { providerSource } from "./notices.ts";
 import type { Provider, ProviderCostNormalizer } from "./types.ts";
@@ -32,7 +43,7 @@ const reasoningStyleFromEnv = (
     if (value === undefined || value.length === 0) return undefined;
     const styles: readonly ReasoningStyle[] = [
         "none", "think", "include_reasoning", "effort",
-        "effort_explicit", "thinking_effort", "template", "anthropic",
+        "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}"`);
@@ -40,23 +51,92 @@ const reasoningStyleFromEnv = (
     return value as ReasoningStyle;
 };
 
+// {§provider-reasoning-policy} — the operator's affirmative declaration of efforts a provider's
+// reasoning routes accept beyond Models.dev; the daemon adds none on its own (#439).
+const DECLARABLE_EFFORTS: ReadonlySet<ModelReasoningEffort> = new Set([
+    "none", "minimal", "low", "medium", "high", "xhigh", "max",
+]);
+const declaredEffortsFromEnv = (
+    env: NodeJS.ProcessEnv,
+    name: string,
+): readonly ModelReasoningEffort[] => {
+    const prefix = name.replaceAll(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+    const key = `PLURNK_PROVIDERS_PROVIDER_${prefix}_REASONING_EFFORTS`;
+    const value = env[key];
+    if (value === undefined || value.trim().length === 0) return [];
+    const efforts = value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+    const invalid = efforts.find((effort) => !DECLARABLE_EFFORTS.has(effort as ModelReasoningEffort));
+    if (invalid !== undefined) {
+        throw new Error(`${name} provider: ${key} has invalid value "${invalid}"; declarable efforts: ${[...DECLARABLE_EFFORTS].join(", ")}`);
+    }
+    return [...new Set(efforts as ModelReasoningEffort[])];
+};
 const activationPolicies = Object.freeze(["off", "adaptive"] as const);
 const deepSeekPolicies = Object.freeze(["off", "adaptive", "high"] as const);
-const adaptiveOnly = Object.freeze(["adaptive"] as const);
 const reasoningWithoutOff = Object.freeze(["adaptive", "low", "medium", "high"] as const);
 
-const mistralSupportsEffort = (model: string): boolean =>
-    model === "mistral-small-latest"
-    || model === "mistral-small-2603"
-    || model === "mistral-medium-3"
-    || model === "mistral-medium-3.5";
+const reasoningEffortOrder = Object.freeze([
+    "minimal", "low", "medium", "high", "xhigh", "max",
+] as const);
+const nativeReasoningEfforts = new Set<NativeReasoningEffort>([
+    "minimal", "low", "medium", "high", "xhigh",
+]);
+const compatibleReasoningEfforts = new Set<CompatibleReasoningEffort>(reasoningEffortOrder);
+const compatibleEffortStyles = new Set<ReasoningStyle>([
+    "effort", "effort_explicit", "effort_required", "thinking_effort",
+]);
+const compatibleToggleStyles = new Set<ReasoningStyle>([
+    "think", "include_reasoning", "effort_explicit", "thinking_effort", "template", "anthropic",
+]);
+
+const catalogEfforts = (
+    info: ModelInfo,
+    declared: readonly ModelReasoningEffort[] = [],
+): readonly ModelReasoningEffort[] => [
+    ...new Set([
+        ...(info.reasoningOptions
+            ?.filter((option) => option.type === "effort")
+            .flatMap((option) => option.values) ?? []),
+        ...declared,
+    ]),
+];
 
-const xaiReasoningIsModelFixed = (model: string): boolean =>
-    /^grok-4\.20(?:-\d{4})?-(?:non-)?reasoning$/.test(model);
+const strongestCatalogEffort = <T extends NativeReasoningEffort | CompatibleReasoningEffort>(
+    info: ModelInfo,
+    supported: ReadonlySet<T>,
+    declared: readonly ModelReasoningEffort[] = [],
+): T | undefined => {
+    const values = new Set(catalogEfforts(info, declared));
+    return reasoningEffortOrder.findLast((effort) => supported.has(effort as T) && values.has(effort)) as T | undefined;
+};
 
-const googleReasoningCannotBeOff = (model: string): boolean =>
-    /^gemini-2\.5-pro(?:-|$)/i.test(model)
-    || /^gemini-(?:[3-9]|\d{2})[.-]/i.test(model);
+const catalogSupportsToggle = (info: ModelInfo): boolean =>
+    info.reasoningOptions?.some((option) => option.type === "toggle") === true;
+
+const catalogSupportedReasoningPolicies = ({
+    info,
+    native,
+    style,
+    declared,
+}: {
+    info: ModelInfo;
+    native: boolean;
+    style: ReasoningStyle;
+    declared: readonly ModelReasoningEffort[];
+}): readonly ReasoningPolicy[] => {
+    if (!info.reasoning) return activationPolicies;
+    const efforts = new Set(catalogEfforts(info, declared));
+    const effortTransport = native || compatibleEffortStyles.has(style);
+    const off = native
+        ? efforts.has("none") || catalogSupportsToggle(info)
+        : (efforts.has("none") && compatibleEffortStyles.has(style))
+            || (catalogSupportsToggle(info) && compatibleToggleStyles.has(style));
+    return REASONING_POLICIES.filter((policy) => policy === "adaptive"
+        || policy === "off" && off
+        || (policy === "low" || policy === "medium" || policy === "high")
+            && effortTransport
+            && efforts.has(policy));
+};
 
 const anthropicSupportsAdaptiveThinking = (model: string): boolean =>
     /claude-(?:opus-(?:4-[678]|5)|sonnet-(?:4-6|5)|fable-5)/.test(model);
@@ -65,30 +145,20 @@ const supportedReasoningPolicies = ({
     info,
     native,
     style,
-    sdkPackage,
-    model,
+    declared,
 }: {
     info?: ModelInfo;
     native: boolean;
     style: ReasoningStyle;
-    sdkPackage?: string;
-    model: string;
+    declared: readonly ModelReasoningEffort[];
 }): readonly ReasoningPolicy[] => {
     if (info !== undefined && info.reasoning !== true) return activationPolicies;
-    if (native) {
-        if (sdkPackage === "@ai-sdk/mistral") {
-            return mistralSupportsEffort(model) ? deepSeekPolicies : adaptiveOnly;
-        }
-        if (sdkPackage === "@ai-sdk/xai") {
-            if (xaiReasoningIsModelFixed(model)) return adaptiveOnly;
-            if (model === "grok-4.6") return reasoningWithoutOff;
-        }
-        if (sdkPackage === "@ai-sdk/google" && googleReasoningCannotBeOff(model)) {
-            return reasoningWithoutOff;
-        }
-        return REASONING_POLICIES;
+    if (info?.reasoningOptions !== undefined) {
+        return catalogSupportedReasoningPolicies({ info, native, style, declared });
     }
+    if (native) return activationPolicies;
     if (style === "effort" || style === "effort_explicit") return REASONING_POLICIES;
+    if (style === "effort_required") return reasoningWithoutOff;
     if (style === "thinking_effort") return deepSeekPolicies;
     return activationPolicies;
 };
@@ -97,10 +167,14 @@ const adaptiveReasoningProjection = ({
     sdkPackage,
     model,
     reasoningCapable,
+    info,
+    declared,
 }: {
     sdkPackage?: string;
     model: string;
     reasoningCapable: boolean;
+    info?: ModelInfo;
+    declared: readonly ModelReasoningEffort[];
 }): Pick<AiSdkProviderConfig, "adaptiveReasoning" | "adaptiveReasoningProviderOptions"> => {
     if (!reasoningCapable) return { adaptiveReasoning: "provider-default" };
     if (sdkPackage === "@ai-sdk/google" && /^gemini-2\.5(?:-|$)/i.test(model)) {
@@ -127,13 +201,12 @@ const adaptiveReasoningProjection = ({
             },
         };
     }
-    if (sdkPackage === "@ai-sdk/mistral" && !mistralSupportsEffort(model)) {
-        return { adaptiveReasoning: "provider-default" };
-    }
-    if (sdkPackage === "@ai-sdk/xai" && xaiReasoningIsModelFixed(model)) {
-        return { adaptiveReasoning: "provider-default" };
+    if (info?.reasoningOptions !== undefined) {
+        return {
+            adaptiveReasoning: strongestCatalogEffort(info, nativeReasoningEfforts, declared) ?? "provider-default",
+        };
     }
-    return { adaptiveReasoning: "high" };
+    return { adaptiveReasoning: "provider-default" };
 };
 
 export const providerFromSdkModel = ({
@@ -189,13 +262,31 @@ export const providerFromSdkModel = ({
         maxOutputTokens,
     );
     const reasoning = reasoningFromEnv(env, name, envelope.reasoningBudget);
-    const reasoningStyle = reasoningStyleFromEnv(env, name) ?? "none";
     const reasoningCapable = info?.reasoning === true;
+    const declaredEfforts = declaredEffortsFromEnv(env, name);
+    const declaredReasoningStyle = info?.reasoning === false
+        ? "none"
+        : reasoningStyleFromEnv(env, name) ?? "none";
+    const reasoningStyle = info?.reasoningOptions !== undefined
+        && (declaredReasoningStyle === "effort" || declaredReasoningStyle === "effort_required")
+        && catalogEfforts(info, declaredEfforts).length === 0
+        ? "none"
+        : declaredReasoningStyle;
     const adaptiveReasoning = adaptiveReasoningProjection({
         sdkPackage,
         model,
         reasoningCapable,
+        info,
+        declared: declaredEfforts,
     });
+    const compatibleAdaptiveReasoning = languageModel !== undefined || info?.reasoningOptions === undefined
+        ? undefined
+        : strongestCatalogEffort(info, compatibleReasoningEfforts, declaredEfforts) ?? "provider-default";
+    const compatibleOffReasoning = languageModel !== undefined
+        || info === undefined
+        || !catalogEfforts(info, declaredEfforts).includes("none")
+        ? undefined
+        : "none" as const;
 
     const catalogCost = info?.cost;
     const rates = catalogCost === undefined ? null : {
@@ -232,10 +323,11 @@ export const providerFromSdkModel = ({
             info,
             native: languageModel !== undefined,
             style: reasoningStyle,
-            sdkPackage,
-            model,
+            declared: declaredEfforts,
         }),
         ...adaptiveReasoning,
+        ...(compatibleAdaptiveReasoning === undefined ? {} : { compatibleAdaptiveReasoning }),
+        ...(compatibleOffReasoning === undefined ? {} : { compatibleOffReasoning }),
         ...(additiveReasoningProvider === undefined || !reasoningCapable
             ? {}
             : { additiveReasoningProvider }),

package/src/discover.test.ts

@@ -30,7 +30,7 @@ test("discover: the node_modules scan is scope-agnostic — third-party scopes a
         "@acme/acme-provider-foo": { name: "@acme/acme-provider-foo", plurnk: { kind: "provider", name: "foo" } },
         "unscoped-provider-bar": { name: "unscoped-provider-bar", plurnk: { kind: "provider", name: "bar" } },
         "left-pad": { name: "left-pad" },                                   // no plurnk block → ignored
-        "@plurnk/plurnk-execs-git": { name: "@plurnk/plurnk-execs-git", plurnk: { kind: "exec", runtimes: [] } }, // wrong kind → ignored
+        "@acme/acme-execs-wrong-kind": { name: "@acme/acme-execs-wrong-kind", plurnk: { kind: "exec", runtimes: [] } }, // wrong kind → ignored
     });
     const { registry } = await discover({ cwd: root });
     assert.deepEqual([...registry.keys()].sort(), ["bar", "foo", "native"]);

package/src/index.ts

@@ -45,7 +45,8 @@ export {
     loadActiveProvider,
     resetDiscoveryCache,
 } from "./ProviderRegistry.ts";
-export { providerReadiness } from "./sdkModels.ts";
+export { createEmbeddingModel, providerReadiness } from "./sdkModels.ts";
+export type { EmbeddingModelResolution } from "./sdkModels.ts";
 
 // Scope-agnostic plugin discovery ({§plugin-family-kind}).
 export { discover } from "./discover.ts";

package/src/notices.ts

@@ -1,4 +1,4 @@
-export type ProviderNoticeKind = "grammar_unenforced" | "provider_warning";
+export type ProviderNoticeKind = "grammar_unenforced" | "provider_warning" | "provider_retry";
 
 // Observations about a completed model exchange. These never represent a
 // failed provider operation; transport failures throw ProviderError with an