@plurnk/plurnk-providers 1.13.0 → 1.14.0

package/src/aiSdkTransport.ts

@@ -282,6 +282,26 @@ export const normalizeRetryAttemptError = (error: unknown): unknown => {
         return error;
     }
     const directed = retryDirective(error.statusCode, error.responseHeaders ?? {});
+    // A 2xx APICallError with no explicit retry directive is a provider
+    // invalid-response: the exchange succeeded and the body was unusable (a
+    // serializer hiccup, a truncated frame). That is the same transient class as
+    // a transport failure and consumes the same bounded retry budget; an explicit
+    // `x-should-retry` directive outranks this default, and the terminal
+    // classification after the budget stays the non-retryable 502 (#446).
+    if (directed === null
+        && typeof error.statusCode === "number" && error.statusCode >= 200 && error.statusCode < 300
+        && error.isRetryable !== true) {
+        return retainStreamFailureValues(error, new APICallError({
+            message: error.message,
+            url: error.url,
+            requestBodyValues: error.requestBodyValues,
+            statusCode: error.statusCode,
+            responseHeaders: error.responseHeaders,
+            responseBody: error.responseBody,
+            cause: error,
+            isRetryable: true,
+        }));
+    }
     if (directed === null || directed === error.isRetryable) return error;
     return retainStreamFailureValues(error, new APICallError({
         message: error.message,

package/src/catalogProvider.test.ts

@@ -101,29 +101,29 @@ test("Models.dev controls Cloudflare's exact effort vocabulary", async () => {
         ...env,
         CLOUDFLARE_ACCOUNT_ID: "account",
         CLOUDFLARE_API_KEY: "token",
-        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_STYLE: "effort_required",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_REASONING_STYLE: "effort_required",
     };
-    const low = catalogProviderFromEnv("cloudflare", {
+    const low = catalogProviderFromEnv("cloudflare-workers-ai", {
         ...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", {
+    const adaptive = catalogProviderFromEnv("cloudflare-workers-ai", {
         ...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", {
+    const nonReasoning = catalogProviderFromEnv("cloudflare-workers-ai", {
         ...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", {
+    const ungradedReasoner = catalogProviderFromEnv("cloudflare-workers-ai", {
         ...cloudflareEnv,
         PLURNK_PROVIDERS_REASONING: "adaptive",
     }, "@cf/zai-org/glm-5.3-flash");
@@ -132,11 +132,11 @@ test("Models.dev controls Cloudflare's exact effort vocabulary", async () => {
 
     assert.deepEqual(bodies.map((body) => body.reasoning_effort), ["low", "xhigh", undefined, undefined]);
     assert.throws(
-        () => catalogProviderFromEnv("cloudflare", cloudflareEnv, "@cf/qwen/qwen3.8-27b"),
+        () => catalogProviderFromEnv("cloudflare-workers-ai", cloudflareEnv, "@cf/qwen/qwen3.8-27b"),
         /reasoning policy 'off' is unsupported; supported policies: adaptive, low, medium/,
     );
     assert.throws(
-        () => catalogProviderFromEnv("cloudflare", {
+        () => catalogProviderFromEnv("cloudflare-workers-ai", {
             ...cloudflareEnv,
             PLURNK_PROVIDERS_REASONING: "high",
         }, "@cf/qwen/qwen3.8-27b"),
@@ -163,31 +163,31 @@ test("an operator-declared effort vocabulary extends Models.dev's for a provider
         ...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",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_REASONING_STYLE: "effort_required",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_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");
+    const low = catalogProviderFromEnv("cloudflare-workers-ai", { ...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");
+    const adaptive = catalogProviderFromEnv("cloudflare-workers-ai", { ...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", {
+    const withOff = catalogProviderFromEnv("cloudflare-workers-ai", {
         ...declaredEnv,
-        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_EFFORTS: "none,high",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_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");
+    const nonReasoning = catalogProviderFromEnv("cloudflare-workers-ai", { ...declaredEnv, PLURNK_PROVIDERS_REASONING: "adaptive" }, "@cf/ibm-granite/granite-4.0-h-micro");
     assert.deepEqual(nonReasoning?.supportedReasoningPolicies, ["off", "adaptive"]);
     assert.throws(
-        () => catalogProviderFromEnv("cloudflare", {
+        () => catalogProviderFromEnv("cloudflare-workers-ai", {
             ...declaredEnv,
-            PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_REASONING_EFFORTS: "low,turbo",
+            PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_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/,
+        /PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_REASONING_EFFORTS has invalid value "turbo"; declarable efforts: none, minimal, low, medium, high, xhigh, max/,
     );
 });
 
@@ -686,6 +686,60 @@ test("native provider routes project their documented cache controls through the
             content: "changing user packet",
         });
     });
+
+    await t.test("{§provider-reasoning-policy} a resolved reasoning budget reaches the OpenRouter wire as max_tokens", async () => {
+        let call: { body: Record<string, unknown> } | undefined;
+        const server = createServer(async (request, response) => {
+            const chunks: Buffer[] = [];
+            for await (const chunk of request) chunks.push(Buffer.from(chunk));
+            call = { body: JSON.parse(Buffer.concat(chunks).toString("utf8")) as Record<string, unknown> };
+            response.writeHead(200, { "content-type": "text/event-stream" });
+            response.end([
+                `data: ${JSON.stringify({
+                    id: "response",
+                    object: "chat.completion.chunk",
+                    created: 1,
+                    model: "served",
+                    choices: [{ index: 0, delta: { content: "ok" }, finish_reason: "stop" }],
+                })}`,
+                "data: [DONE]",
+            ].join("\n\n"));
+        });
+        server.listen(0, "127.0.0.1");
+        await once(server, "listening");
+        t.after(() => new Promise<void>((resolve, reject) => {
+            server.close((error) => error === undefined ? resolve() : reject(error));
+        }));
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+            throw new Error("OpenRouter budget-capture server did not bind a TCP address");
+        }
+        const budgetEnv = {
+            ...env,
+            OPENROUTER_API_KEY: "test-key",
+            OPENROUTER_HTTP_REFERER: "https://github.com/plurnk/plurnk-service",
+            OPENROUTER_APP_TITLE: "Plurnk",
+            PLURNK_PROVIDERS_REASONING_BUDGET: "2048",
+        };
+        const adaptive = catalogProviderFromEnv("openrouter", {
+            ...budgetEnv,
+            PLURNK_PROVIDERS_REASONING: "adaptive",
+        }, "anthropic/claude-sonnet-4.6", `http://127.0.0.1:${address.port}/api/v1`);
+        await adaptive?.generate({
+            workerId: "openrouter-budget",
+            messages: [{ role: "user", content: "budgeted" }],
+        });
+        assert.deepEqual(call?.body.reasoning, { max_tokens: 2048 });
+        const fixed = catalogProviderFromEnv("openrouter", {
+            ...budgetEnv,
+            PLURNK_PROVIDERS_REASONING: "low",
+        }, "anthropic/claude-sonnet-4.6", `http://127.0.0.1:${address.port}/api/v1`);
+        await fixed?.generate({
+            workerId: "openrouter-budget",
+            messages: [{ role: "user", content: "budgeted" }],
+        });
+        assert.deepEqual(call?.body.reasoning, { effort: "low" }, "a fixed policy keeps the effort form");
+    });
 });
 
 test("cataloged unknown model fails unless its context is explicit", () => {
@@ -749,3 +803,51 @@ test("Models.dev is the only fallback rate table", async () => {
         reason: "Models.dev has no complete rate for this model",
     });
 });
+
+test("{§operator-cost-override} declared rates overlay the catalog and the source names the override", async () => {
+    mock.method(globalThis, "fetch", async () => new Response([
+        `data: ${JSON.stringify({
+            id: "response",
+            model: "served",
+            choices: [{ index: 0, delta: { content: "ok" }, finish_reason: "stop" }],
+        })}`,
+        `data: ${JSON.stringify({
+            id: "response",
+            model: "served",
+            choices: [],
+            usage: {
+                prompt_tokens: 1_000,
+                prompt_tokens_details: { cached_tokens: 400 },
+                completion_tokens: 100,
+                total_tokens: 1_150,
+            },
+        })}`,
+        "data: [DONE]",
+    ].join("\n\n"), { headers: { "content-type": "text/event-stream" } }));
+    const overridden = catalogProviderFromEnv("deepseek", {
+        ...env,
+        DEEPSEEK_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+        PLURNK_PROVIDERS_PROVIDER_DEEPSEEK_REASONING_STYLE: "thinking_effort",
+        PLURNK_PROVIDERS_COST: "input=0.22,output=0.66,cacheRead=0.007",
+    }, "deepseek-v4-flash");
+    const response = await overridden!.generate({ workerId: "overridden", messages: [] });
+    assert.deepEqual(response.accounting[0]?.cost, {
+        kind: "estimated",
+        amount: { amount: "0.0002148", currency: "USD" },
+        source: "operator PLURNK_PROVIDERS_COST override over Models.dev catalog rates",
+    });
+    mock.restoreAll();
+});
+
+test("(#458) declared efforts union into the supported set under the models.dev-id prefix", () => {
+    const provider = catalogProviderFromEnv("fireworks-ai", {
+        ...env,
+        FIREWORKS_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+        PLURNK_PROVIDERS_PROVIDER_FIREWORKS_AI_REASONING_STYLE: "effort_explicit",
+        PLURNK_PROVIDERS_PROVIDER_FIREWORKS_AI_REASONING_EFFORTS: "low,high,max",
+    }, "accounts/fireworks/models/glm-5p3-flash");
+    // "max" stays outside the portable wire vocabulary; "off" requires a declared "none".
+    assert.deepEqual(provider?.supportedReasoningPolicies, ["adaptive", "low", "high"]);
+});

package/src/catalogProvider.ts

@@ -5,6 +5,7 @@ import {
     type ModelReasoningEffort,
 } from "@plurnk/plurnk-models";
 import {
+    costOverrideFromEnv,
     contextWindowFromEnv,
     effectiveContextWindow,
     dataCaptureFromEnv,
@@ -289,7 +290,7 @@ export const providerFromSdkModel = ({
         : "none" as const;
 
     const catalogCost = info?.cost;
-    const rates = catalogCost === undefined ? null : {
+    const catalogRates = catalogCost === undefined ? null : {
         input: catalogCost.inputPer1M,
         output: catalogCost.outputPer1M,
         ...(catalogCost.reasoningPer1M === undefined
@@ -302,8 +303,23 @@ export const providerFromSdkModel = ({
             ? {}
             : { cacheWrite: catalogCost.cacheWritePer1M }),
     };
+    // {§operator-cost-override} (#461): the catalog is the starting point; a declared
+    // override merges over it, and the estimate's source names the overlay.
+    const costOverride = costOverrideFromEnv(env, name);
+    if (costOverride !== null && catalogRates === null
+        && (costOverride.input === undefined || costOverride.output === undefined)) {
+        throw new Error(
+            `${name} provider: PLURNK_PROVIDERS_COST without catalog rates must declare input and output`,
+        );
+    }
+    const rates = costOverride === null
+        ? catalogRates
+        : { ...(catalogRates ?? {}), ...costOverride } as NonNullable<typeof catalogRates>;
+    const rateSource = costOverride === null
+        ? "Models.dev catalog rates"
+        : "operator PLURNK_PROVIDERS_COST override over Models.dev catalog rates";
     const estimateCost = (usage: Parameters<typeof estimateProviderCost>[0]) =>
-        estimateProviderCost(usage, rates, "Models.dev catalog rates");
+        estimateProviderCost(usage, rates, rateSource);
     const affinityEnabled = cacheAffinityFromEnv(env, name);
     const cacheWritePolicy = cacheWritePolicyFromEnv(env, name);
 
@@ -319,6 +335,8 @@ export const providerFromSdkModel = ({
         maxOutputTokens,
         outputBudget: envelope.outputBudget,
         reasoningBudget: reasoning.budget,
+        // #457 — a catalog-declared toggle control makes `adaptive` an explicit enable.
+        reasoningToggle: info?.reasoningOptions?.some((option) => option.type === "toggle") === true,
         supportedReasoningPolicies: supportedReasoningPolicies({
             info,
             native: languageModel !== undefined,
@@ -377,9 +395,6 @@ export const catalogProviderFromEnv = (
         );
     }
     const wireModel = resolved?.id ?? model;
-    const sdk = createSdkModel(name, wireModel, env, baseUrlOverride, reasoningFromEnv(env, name).mode);
-    if (sdk === null) return null;
-
     const info = resolved?.info;
     const contextWindow = effectiveContextWindow(contextOverride, info?.contextWindow ?? null);
     if (contextWindow === null) {
@@ -387,6 +402,17 @@ export const catalogProviderFromEnv = (
             `${name} provider: context window unresolved for "${wireModel}" — set PLURNK_PROVIDERS_CONTEXT_WINDOW or update the Models.dev snapshot`,
         );
     }
+    const maxOutputTokens = info?.maxOutputTokens === undefined
+        ? null
+        : Math.min(info.maxOutputTokens, contextWindow);
+    const reasoning = reasoningFromEnv(
+        env,
+        name,
+        generationEnvelopeFromEnv(env, name, contextWindow, maxOutputTokens).reasoningBudget,
+    );
+    const sdk = createSdkModel(name, wireModel, env, baseUrlOverride, reasoning.mode, reasoning.budget);
+    if (sdk === null) return null;
+
     return providerFromSdkModel({
         name,
         env,

package/src/env.test.ts

@@ -1,6 +1,8 @@
 import test from "node:test";
 import { strict as assert } from "node:assert";
 import {
+    scopeEnvToAlias,
+    costOverrideFromEnv,
     cacheAffinityFromEnv,
     cacheWritePolicyFromEnv,
     generationEnvelopeFromEnv,
@@ -59,15 +61,15 @@ test("reasoningFromEnv: durable policy is independent from an optional explicit
 });
 
 test("{§provider-tagged-reasoning} response style is explicit and invalid values fail at the provider boundary", () => {
-    assert.equal(reasoningResponseStyleFromEnv({}, "cloudflare"), "verbatim");
+    assert.equal(reasoningResponseStyleFromEnv({}, "cloudflare-workers-ai"), "verbatim");
     assert.equal(reasoningResponseStyleFromEnv({
         PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE: "think-tags",
-    }, "cloudflare"), "think-tags");
+    }, "cloudflare-workers-ai"), "think-tags");
     assert.throws(
         () => reasoningResponseStyleFromEnv({
             PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE: "auto",
-        }, "cloudflare"),
-        /cloudflare provider: PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE must be "verbatim" or "think-tags" \(got "auto"\)/,
+        }, "cloudflare-workers-ai"),
+        /cloudflare-workers-ai provider: PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE must be "verbatim" or "think-tags" \(got "auto"\)/,
     );
 });
 
@@ -97,7 +99,7 @@ test("the generic prompt-cache-key knob is retired rather than retained as a com
         () => cacheAffinityFromEnv({
             PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
             PLURNK_PROVIDERS_CACHE_AFFINITY: "1",
-        }, "fireworks"),
+        }, "fireworks-ai"),
         /PLURNK_PROVIDERS_PROMPT_CACHE_KEY was renamed to PLURNK_PROVIDERS_CACHE_AFFINITY/,
     );
 });
@@ -312,3 +314,18 @@ test("a retired envelope knob is refused in its per-alias form too, naming the k
         /PLURNK_PROVIDERS_REASONING_RESERVE_rtxgemma is retired/,
     );
 });
+
+test("{§operator-cost-override} costOverrideFromEnv parses the catalog vocabulary and refuses drift", () => {
+    assert.equal(costOverrideFromEnv({}, "x"), null);
+    assert.deepEqual(
+        costOverrideFromEnv({ PLURNK_PROVIDERS_COST: "input=0.22, output=0.66,cacheRead=0.007" }, "x"),
+        { input: 0.22, output: 0.66, cacheRead: 0.007 },
+    );
+    assert.throws(() => costOverrideFromEnv({ PLURNK_PROVIDERS_COST: "cache_read=0.007" }, "x"), /key=value over input, output, reasoning, cacheRead, cacheWrite/);
+    assert.throws(() => costOverrideFromEnv({ PLURNK_PROVIDERS_COST: "input=" }, "x"), /non-negative per-1M-token USD rate/);
+    assert.throws(() => costOverrideFromEnv({ PLURNK_PROVIDERS_COST: "input=-1" }, "x"), /non-negative/);
+    assert.throws(() => costOverrideFromEnv({ PLURNK_PROVIDERS_COST: "input=0.1,input=0.2" }, "x"), /repeats input/);
+    // Alias-scoped like every provider knob.
+    const scoped = scopeEnvToAlias({ PLURNK_PROVIDERS_COST_deepdumb: "input=0.44,output=1.32" }, "deepdumb");
+    assert.deepEqual(costOverrideFromEnv(scoped, "x"), { input: 0.44, output: 1.32 });
+});

package/src/env.ts

@@ -291,6 +291,7 @@ export const reasoningFromEnv = (
 // facts (API keys, canonical endpoints) remain vendor-named; the per-alias
 // endpoint override stays PLURNK_BASEURL_<alias> (its existing precedent).
 export const PROVIDERS_KNOBS = Object.freeze([
+    "PLURNK_PROVIDERS_COST",
     "PLURNK_PROVIDERS_OUTPUT_BUDGET",
     "PLURNK_PROVIDERS_REASONING_RESPONSE_STYLE",
     "PLURNK_PROVIDERS_REASONING_BUDGET",
@@ -330,6 +331,34 @@ export const PROVIDERS_KNOBS = Object.freeze([
 // same parser — e.g. service loop policy or prompt projection — without
 // reimplementing the suffix/collision rules. Default stays the
 // providers-family list; provider call sites pass nothing.
+// {§operator-cost-override} (#461) — Models.dev is the rate starting point; the
+// operator overlays exact per-1M-token USD rates when a provider reprices ahead
+// of the catalog. Format: comma-separated key=value over the catalog vocabulary
+// (input, output, reasoning, cacheRead, cacheWrite). Alias-scoped like every
+// provider knob.
+const COST_OVERRIDE_KEYS = Object.freeze(["input", "output", "reasoning", "cacheRead", "cacheWrite"] as const);
+export type CostOverride = Partial<Record<(typeof COST_OVERRIDE_KEYS)[number], number>>;
+export const costOverrideFromEnv = (env: NodeJS.ProcessEnv, label: string): CostOverride | null => {
+    const name = "PLURNK_PROVIDERS_COST";
+    const raw = env[name];
+    if (raw === undefined || raw.trim().length === 0) return null;
+    const out: Partial<Record<string, number>> = {};
+    for (const part of raw.split(",")) {
+        const [key, value, ...rest] = part.split("=").map((piece) => piece.trim());
+        if (rest.length > 0 || key === undefined || value === undefined
+            || !(COST_OVERRIDE_KEYS as readonly string[]).includes(key)) {
+            throw new Error(`${label} provider: ${name} entries are key=value over ${COST_OVERRIDE_KEYS.join(", ")} (per-1M-token USD); got ${JSON.stringify(part)}`);
+        }
+        if (key in out) throw new Error(`${label} provider: ${name} repeats ${key}`);
+        const parsed = Number(value);
+        if (value.length === 0 || !Number.isFinite(parsed) || parsed < 0) {
+            throw new Error(`${label} provider: ${name} ${key} must be a non-negative per-1M-token USD rate; got ${JSON.stringify(value)}`);
+        }
+        out[key] = parsed;
+    }
+    return out as CostOverride;
+};
+
 export const scopeEnvToAlias = (env: NodeJS.ProcessEnv, alias: string, knobs: readonly string[] = PROVIDERS_KNOBS): NodeJS.ProcessEnv => {
     const folded = alias.toLowerCase();
     const out: NodeJS.ProcessEnv = { ...env };

package/src/providerDefaults.test.ts

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { lookupProvider, providerIdMap } from "@plurnk/plurnk-models";
+import { lookupProvider } from "@plurnk/plurnk-models";
 
 const defaultsPath = fileURLToPath(new URL("../.env.defaults", import.meta.url));
 const declarations = readFileSync(defaultsPath, "utf8")
@@ -19,16 +19,17 @@ const providerFact = (key: string): { provider: string; fact: string } | null =>
 };
 
 test("{§provider-fact-authority} package defaults never redefine cataloged provider facts", () => {
-    const ids = providerIdMap();
+    // (#459) the env prefix IS the Models.dev id, underscored; probe both spellings.
     for (const { key, value } of declarations) {
         const fact = providerFact(key);
         if (fact === null) continue;
-        const catalogId = ids[fact.provider] ?? fact.provider;
-        assert.equal(
-            lookupProvider(catalogId),
-            null,
-            `package default '${key}=${value}' redefines a Models.dev-cataloged provider fact (${catalogId})`,
-        );
+        for (const candidate of new Set([fact.provider, fact.provider.replaceAll("_", "-")])) {
+            assert.equal(
+                lookupProvider(candidate),
+                null,
+                `package default '${key}=${value}' redefines a Models.dev-cataloged provider fact (${candidate})`,
+            );
+        }
     }
 });
 

package/src/sdkModels.test.ts

@@ -37,21 +37,21 @@ test("{§model-catalog-readiness}: readiness uses the construction credential an
     });
     assert.doesNotMatch(JSON.stringify(providerReadiness("google", { GEMINI_API_KEY: "secret-value" })), /secret-value/);
 
-    assert.deepEqual(providerReadiness("cloudflare", { CLOUDFLARE_API_KEY: "key" }), {
+    assert.deepEqual(providerReadiness("cloudflare-workers-ai", { CLOUDFLARE_API_KEY: "key" }), {
         ready: false,
         causes: [{
             kind: "configuration",
             alternatives: [["CLOUDFLARE_ACCOUNT_ID"]],
         }],
     });
-    assert.deepEqual(providerReadiness("cloudflare", {
+    assert.deepEqual(providerReadiness("cloudflare-workers-ai", {
         CLOUDFLARE_ACCOUNT_ID: "account",
         CLOUDFLARE_API_KEY: "key",
     }), { ready: true, causes: [] });
 });
 
 test("{§model-catalog-readiness}: Bedrock reports its actual alternative authentication sets and region requirement", () => {
-    assert.deepEqual(providerReadiness("bedrock", {}), {
+    assert.deepEqual(providerReadiness("amazon-bedrock", {}), {
         ready: false,
         causes: [{
             kind: "credential",
@@ -63,11 +63,11 @@ test("{§model-catalog-readiness}: Bedrock reports its actual alternative authen
             ],
         }],
     });
-    assert.deepEqual(providerReadiness("bedrock", {
+    assert.deepEqual(providerReadiness("amazon-bedrock", {
         AWS_BEARER_TOKEN_BEDROCK: "bearer",
         AWS_REGION: "us-east-1",
     }), { ready: true, causes: [] });
-    assert.deepEqual(providerReadiness("bedrock", {
+    assert.deepEqual(providerReadiness("amazon-bedrock", {
         AWS_ACCESS_KEY_ID: "access",
         AWS_SECRET_ACCESS_KEY: "secret",
     }), {
@@ -129,14 +129,25 @@ test("{§provider-reasoning-policy} createSdkModel represents a fixed OpenRouter
         OPENROUTER_HTTP_REFERER: "https://github.com/plurnk/plurnk-service",
         OPENROUTER_APP_TITLE: "Plurnk",
     };
-    const settings = (reasoning?: "off" | "adaptive" | "low" | "medium" | "high"): unknown =>
-        (createSdkModel("openrouter", "z-ai/glm-5.3-flash", env, undefined, reasoning)?.languageModel as { settings?: { reasoning?: unknown } } | undefined)?.settings?.reasoning;
+    const settings = (reasoning?: "off" | "adaptive" | "low" | "medium" | "high", budget: number | null = null): unknown =>
+        (createSdkModel("openrouter", "z-ai/glm-5.3-flash", env, undefined, reasoning, budget)?.languageModel as { settings?: { reasoning?: unknown } } | undefined)?.settings?.reasoning;
     assert.deepEqual(settings("low"), { effort: "low" });
     assert.deepEqual(settings("medium"), { effort: "medium" });
     assert.deepEqual(settings("high"), { effort: "high" });
     assert.deepEqual(settings("off"), { effort: "none" });
-    assert.equal(settings("adaptive"), undefined);
-    assert.equal(settings(), undefined);
+    // #457 — adaptive on a reasoning-capable route declares the toggle on.
+    assert.deepEqual(settings("adaptive"), { enabled: true });
+    assert.equal(settings(), undefined, "no declared policy emits nothing");
+    // A resolved budget is the max_tokens form of the same dial; a fixed policy keeps effort.
+    assert.deepEqual(settings("adaptive", 2048), { max_tokens: 2048 });
+    assert.equal(settings(undefined, 2048), undefined, "a budget rides a policy, never replaces one");
+    assert.deepEqual(settings("low", 2048), { effort: "low" });
+    assert.deepEqual(settings("off", 2048), { effort: "none" });
+    // The budget_tokens-only motivating route (#466) and a non-reasoning route.
+    const qwen = (createSdkModel("openrouter", "qwen/qwen3.8-flash", env, undefined, "adaptive", null)?.languageModel as { settings?: { reasoning?: unknown } } | undefined)?.settings?.reasoning;
+    assert.deepEqual(qwen, { enabled: true });
+    const prose = (createSdkModel("openrouter", "tencent/hy-mt2-30b-a3b", env, undefined, "adaptive", null)?.languageModel as { settings?: { reasoning?: unknown } } | undefined)?.settings?.reasoning;
+    assert.equal(prose, undefined, "a non-reasoning route stays untouched");
 });
 
 test("{§openrouter-app-attribution} attribution rejects malformed URLs and the retired title name", () => {
@@ -183,7 +194,7 @@ test("createSdkModel attaches DeepInfra's documented response-cost normalizer",
 });
 
 test("{§provider-fact-authority} catalog credential names are law without any package or operator alias", () => {
-    const sdk = createSdkModel("cloudflare", "@cf/google/gemma-4-26b-a4b-it", {
+    const sdk = createSdkModel("cloudflare-workers-ai", "@cf/google/gemma-4-26b-a4b-it", {
         CLOUDFLARE_ACCOUNT_ID: "account",
         CLOUDFLARE_API_KEY: "key",
     });
@@ -196,10 +207,10 @@ test("{§provider-fact-authority} catalog credential names are law without any p
 });
 
 test("{§provider-fact-authority} an operator credential override holds one exact name", () => {
-    const sdk = createSdkModel("cloudflare", "@cf/google/gemma-4-26b-a4b-it", {
+    const sdk = createSdkModel("cloudflare-workers-ai", "@cf/google/gemma-4-26b-a4b-it", {
         CLOUDFLARE_ACCOUNT_ID: "account",
         MY_ORG_CLOUDFLARE_KEY: "key",
-        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_API_KEY_ENV: "MY_ORG_CLOUDFLARE_KEY",
+        PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_API_KEY_ENV: "MY_ORG_CLOUDFLARE_KEY",
     });
     assert.deepEqual(sdk?.compatible, {
         url: "https://api.cloudflare.com/client/v4/accounts/account/ai/v1/chat/completions",
@@ -209,10 +220,10 @@ test("{§provider-fact-authority} an operator credential override holds one exac
 
 test("{§provider-fact-authority} ordered credential fallbacks are rejected at construction", () => {
     assert.throws(
-        () => createSdkModel("cloudflare", "@cf/google/gemma-4-26b-a4b-it", {
+        () => createSdkModel("cloudflare-workers-ai", "@cf/google/gemma-4-26b-a4b-it", {
             CLOUDFLARE_ACCOUNT_ID: "account",
             CLOUDFLARE_API_TOKEN: "token",
-            PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_API_KEY_ENV: "CLOUDFLARE_API_TOKEN,CLOUDFLARE_API_KEY",
+            PLURNK_PROVIDERS_PROVIDER_CLOUDFLARE_WORKERS_AI_API_KEY_ENV: "CLOUDFLARE_API_TOKEN,CLOUDFLARE_API_KEY",
         }),
         /one exact name, never an ordered fallback/,
     );
@@ -239,7 +250,7 @@ test("catalog routes own their documented cache-affinity request projection", ()
         { target: "header", name: "x-session-id" },
     );
     assert.deepEqual(
-        createSdkModel("fireworks", "accounts/fireworks/models/test", { FIREWORKS_API_KEY: "key" })?.cacheAffinity,
+        createSdkModel("fireworks-ai", "accounts/fireworks/models/test", { FIREWORKS_API_KEY: "key" })?.cacheAffinity,
         { target: "body", name: "prompt_cache_key" },
     );
 });
@@ -292,19 +303,19 @@ test("createSdkModel fails clearly for a declared but unsupported SDK package",
 });
 
 test("{§provider-embedding-resolution} compatible catalog and declared routes share the standard embedding adapter", () => {
-    const cloudflare = createEmbeddingModel("cloudflare", "@cf/qwen/qwen3-embedding-0.6b", {
+    const cloudflare = createEmbeddingModel("cloudflare-workers-ai", "@cf/qwen/qwen3-embedding-0.6b", {
         CLOUDFLARE_ACCOUNT_ID: "account",
         CLOUDFLARE_API_KEY: "key",
     });
     assert.equal(cloudflare?.providerId, "cloudflare-workers-ai");
-    assert.equal(cloudflare?.embeddingModel.provider, "cloudflare.embedding");
+    assert.equal(cloudflare?.embeddingModel.provider, "cloudflare-workers-ai.embedding");
     assert.equal(cloudflare?.embeddingModel.modelId, "@cf/qwen/qwen3-embedding-0.6b");
 
-    const fireworks = createEmbeddingModel("fireworks", "fireworks/qwen3-embedding-8b", {
+    const fireworks = createEmbeddingModel("fireworks-ai", "fireworks/qwen3-embedding-8b", {
         FIREWORKS_API_KEY: "key",
     });
     assert.equal(fireworks?.providerId, "fireworks-ai");
-    assert.equal(fireworks?.embeddingModel.provider, "fireworks.embedding");
+    assert.equal(fireworks?.embeddingModel.provider, "fireworks-ai.embedding");
 
     const local = createEmbeddingModel("local-embed", "Qwen/Qwen3-Embedding-0.6B", {
         PLURNK_PROVIDERS_PROVIDER_LOCAL_EMBED_NPM: "@ai-sdk/openai-compatible",

package/src/sdkModels.ts

@@ -10,8 +10,9 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createTogetherAI } from "@ai-sdk/togetherai";
 import { createXai } from "@ai-sdk/xai";
 import type { EmbeddingModelV4, EmbeddingModelV4Result } from "@ai-sdk/provider";
-import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { createOpenRouter, type OpenRouterChatSettings } from "@openrouter/ai-sdk-provider";
 import {
+    resolveModel,
     isProviderCredentialName,
     lookup,
     lookupProvider,
@@ -310,14 +311,25 @@ const requireApiKey = (
 
 // {§provider-reasoning-policy} — the OpenRouter SDK builds its request from the model
 // settings alone (neither the generic `reasoning` call setting nor provider options reach
-// its body), so a fixed policy and `off` are represented there; `adaptive` leaves the
-// route's provider default.
+// its body), so a fixed policy and `off` are represented there. `adaptive` on a
+// reasoning-capable route declares the toggle on (`enabled` — #457: unconfigured
+// toggle routes ran reasoning-off and strike-spiralled; `off` stays the explicit
+// opt-out), and a resolved reasoning budget names the wire's `max_tokens` form —
+// the only dial a budget_tokens-only route understands; a fixed policy keeps the
+// `effort` form. `enabled` alone is documented OpenRouter wire; the SDK's settings
+// type under-models it (requires effort | max_tokens), hence the call-site cast.
 const openRouterReasoningSettings = (
     reasoning: ReasoningPolicy | undefined,
-): { reasoning?: { effort: "none" | "low" | "medium" | "high" } } =>
-    reasoning === undefined || reasoning === "adaptive"
-        ? {}
-        : { reasoning: { effort: reasoning === "off" ? "none" : reasoning } };
+    reasoningBudget: number | null,
+    reasoningCapable: boolean,
+): { reasoning?: { effort: "none" | "low" | "medium" | "high" } | { max_tokens: number } | { enabled: true } } => {
+    if (reasoning === undefined) return {};
+    if (reasoning === "adaptive") {
+        if (reasoningBudget !== null) return { reasoning: { max_tokens: reasoningBudget } };
+        return reasoningCapable ? { reasoning: { enabled: true } } : {};
+    }
+    return { reasoning: { effort: reasoning === "off" ? "none" : reasoning } };
+};
 
 const resolveSdkProvider = (
     provider: string,
@@ -339,6 +351,7 @@ export const createSdkModel = (
     env: NodeJS.ProcessEnv,
     baseUrlOverride?: string,
     reasoning?: ReasoningPolicy,
+    reasoningBudget: number | null = null,
 ): SdkModel | null => {
     const resolved = resolveSdkProvider(provider, env, baseUrlOverride);
     if (resolved === null) return null;
@@ -430,7 +443,11 @@ export const createSdkModel = (
                     apiKey: requireApiKey(provider, env, catalog),
                     baseURL: url,
                     headers: openRouterHeaders(provider, env, catalog),
-                }).languageModel(model, openRouterReasoningSettings(reasoning)),
+                }).languageModel(model, openRouterReasoningSettings(
+                    reasoning,
+                    reasoningBudget,
+                    resolveModel(provider, model)?.info.reasoning === true,
+                ) as OpenRouterChatSettings),
                 ...(catalog.id === "openrouter"
                     ? { cacheAffinity: { target: "header" as const, name: "x-session-id" } }
                     : {}),