@psnext/slingcli 2.5.20260723-1 → 2.5.20260725-1

package/node_modules/@earendil-works/pi-ai/dist/api/openai-responses.js

@@ -5,6 +5,8 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
+import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
@@ -50,7 +52,10 @@ function getCompat(model) {
         supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
         sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
         supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+        supportsStrictMode: model.compat?.supportsStrictMode ?? false,
+        supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
         supportsToolSearch: model.compat?.supportsToolSearch ?? false,
+        supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false,
     };
 }
 function getPromptCacheRetention(compat, cacheRetention) {
@@ -88,8 +93,10 @@ export const stream = (model, context, options) => {
             const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+            const compat = getCompat(model);
+            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
             const client = createClient(model, context, apiKey, options?.headers, cacheSessionId);
-            let params = buildParams(model, context, options);
+            let params = buildParams(model, context, options, compat, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -97,13 +104,18 @@ export const stream = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                maxRetries: options?.maxRetries ?? 0,
+                maxRetries: 0,
             };
-            const { data: openaiStream, response } = await client.responses.create(params, requestOptions).withResponse();
+            const { data: openaiStream, response } = await retryProviderRequest(() => client.responses.create(params, requestOptions).withResponse(), {
+                maxRetries: options?.maxRetries,
+                maxRetryDelayMs: options?.maxRetryDelayMs,
+                signal: options?.signal,
+            });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             await processResponsesStream(openaiStream, output, stream, model, {
                 serviceTier: options?.serviceTier,
+                grammarToolInputProperties,
                 applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
             });
             if (options?.signal?.aborted) {
@@ -118,8 +130,9 @@ export const stream = (model, context, options) => {
         catch (error) {
             for (const block of output.content) {
                 delete block.index;
-                // partialJson is only a streaming scratch buffer; never persist it.
+                // Streaming scratch buffers are only used during parsing; never persist them.
                 delete block.partialJson;
+                delete block.customInput;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
             output.errorMessage = formatOpenAIResponsesError(error);
@@ -172,19 +185,25 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
         defaultHeaders: headers,
     });
 }
-function buildParams(model, context, options) {
-    const compat = getCompat(model);
+function buildParams(model, context, options, compat = getCompat(model), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
     const toolPlacement = splitDeferredTools(context, compat.supportsToolSearch);
     const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+        grammarToolInputProperties,
         deferredTools: toolPlacement.deferred,
+        toolOptions: {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        },
     });
     const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
+    const disableImplicitPromptCache = cacheRetention === "none" && compat.supportsExplicitPromptCacheMode;
     const params = {
         model: model.id,
         input: messages,
         stream: true,
         prompt_cache_key: cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey(options?.sessionId),
         prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
+        prompt_cache_options: disableImplicitPromptCache ? { mode: "explicit" } : undefined,
         store: false,
     };
     if (options?.maxTokens) {
@@ -197,7 +216,10 @@ function buildParams(model, context, options) {
         params.service_tier = options.serviceTier;
     }
     if (toolPlacement.immediate.length > 0) {
-        params.tools = convertResponsesTools(toolPlacement.immediate);
+        params.tools = convertResponsesTools(toolPlacement.immediate, {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        });
     }
     if (options?.toolChoice !== undefined) {
         params.tool_choice = options.toolChoice;

package/node_modules/@earendil-works/pi-ai/dist/api/openrouter-images.js

@@ -1,6 +1,7 @@
 import OpenAI from "openai";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 export const generateImages = async (model, context, options) => {
     const output = {
@@ -25,11 +26,15 @@ export const generateImages = async (model, context, options) => {
         const requestOptions = {
             ...(options?.signal ? { signal: options.signal } : {}),
             ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-            maxRetries: options?.maxRetries ?? 0,
+            maxRetries: 0,
         };
-        const { data: response, response: rawResponse } = await client.chat.completions
+        const { data: response, response: rawResponse } = await retryProviderRequest(() => client.chat.completions
             .create(params, requestOptions)
-            .withResponse();
+            .withResponse(), {
+            maxRetries: options?.maxRetries,
+            maxRetryDelayMs: options?.maxRetryDelayMs,
+            signal: options?.signal,
+        });
         await options?.onResponse?.({ status: rawResponse.status, headers: headersToRecord(rawResponse.headers) }, model);
         const imageResponse = response;
         output.responseId = imageResponse.id;

package/node_modules/@earendil-works/pi-ai/dist/auth/oauth/load.js

@@ -36,6 +36,11 @@ export const loadGitHubCopilotOAuth = async () => {
         return bundledLoaders.githubCopilot();
     return (await importOAuthModule("./github-copilot.ts")).githubCopilotOAuth;
 };
+export const loadOpenRouterOAuth = async () => {
+    if (bundledLoaders)
+        return bundledLoaders.openrouter();
+    return (await importOAuthModule("./openrouter.ts")).openRouterOAuth;
+};
 export const loadKimiCodingOAuth = async () => {
     if (bundledLoaders)
         return bundledLoaders.kimiCoding();

package/node_modules/@earendil-works/pi-ai/dist/auth/oauth/openrouter.js

@@ -0,0 +1,222 @@
+/**
+ * OpenRouter OAuth PKCE flow.
+ *
+ * OpenRouter exchanges an authorization code for a permanent, user-controlled
+ * API key rather than an expiring access/refresh token pair. The callback is
+ * handled by a one-shot loopback server on an ephemeral port.
+ *
+ * NOTE: This module uses Node.js http.createServer for the OAuth callback server.
+ * It is only intended for CLI use, not browser environments.
+ */
+import { createServer } from "node:http";
+import { getProviderEnvValue } from "../../utils/provider-env.js";
+import { oauthErrorHtml, oauthSuccessHtml } from "./oauth-page.js";
+import { generatePKCE } from "./pkce.js";
+const AUTHORIZE_URL = "https://openrouter.ai/auth";
+const TOKEN_URL = "https://openrouter.ai/api/v1/auth/keys";
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+const TOKEN_EXCHANGE_TIMEOUT_MS = 30_000;
+function getCallbackHost() {
+    return getProviderEnvValue("PI_OAUTH_CALLBACK_HOST") || "127.0.0.1";
+}
+function sendHtml(response, status, html) {
+    response.statusCode = status;
+    response.setHeader("content-type", "text/html; charset=utf-8");
+    response.setHeader("cache-control", "no-store");
+    response.end(html);
+}
+function errorDetail(body) {
+    if (typeof body.error_description === "string")
+        return body.error_description;
+    if (typeof body.message === "string")
+        return body.message;
+    if (typeof body.error === "string")
+        return body.error;
+    if (body.error && typeof body.error === "object" && !Array.isArray(body.error)) {
+        const message = body.error.message;
+        if (typeof message === "string")
+            return message;
+    }
+    return undefined;
+}
+async function exchangeAuthorizationCode(code, verifier, signal) {
+    if (signal?.aborted)
+        throw new Error("Login cancelled");
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal?.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const timeout = setTimeout(() => controller.abort(new Error("OpenRouter OAuth token exchange timed out")), TOKEN_EXCHANGE_TIMEOUT_MS);
+    let response;
+    let body = {};
+    try {
+        response = await fetch(TOKEN_URL, {
+            method: "POST",
+            headers: { accept: "application/json", "content-type": "application/json" },
+            body: JSON.stringify({ code, code_verifier: verifier, code_challenge_method: "S256" }),
+            signal: controller.signal,
+        });
+        try {
+            const parsed = (await response.json());
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                body = parsed;
+        }
+        catch {
+            if (response.ok)
+                throw new Error("OpenRouter OAuth returned invalid JSON");
+        }
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw new Error("Login cancelled");
+        if (controller.signal.aborted)
+            throw new Error("OpenRouter OAuth token exchange timed out");
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+    }
+    if (!response.ok) {
+        const detail = errorDetail(body);
+        throw new Error(`OpenRouter OAuth key exchange failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`);
+    }
+    if (typeof body.key !== "string" || body.key.length === 0) {
+        throw new Error('OpenRouter OAuth response carries no "key"');
+    }
+    return {
+        type: "oauth",
+        access: body.key,
+        refresh: "",
+        expires: Number.MAX_SAFE_INTEGER,
+    };
+}
+async function startCallbackServer(callbackPath, verifier, signal) {
+    if (signal?.aborted)
+        throw new Error("Login cancelled");
+    const callbackHost = getCallbackHost();
+    let resolveCredential = () => { };
+    let rejectCredential = () => { };
+    const credential = new Promise((resolve, reject) => {
+        resolveCredential = resolve;
+        rejectCredential = reject;
+    });
+    let server;
+    let claimed = false;
+    let settled = false;
+    let timeout;
+    let onAbort;
+    const finish = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        if (timeout)
+            clearTimeout(timeout);
+        if (onAbort)
+            signal?.removeEventListener("abort", onAbort);
+        server.close();
+        if ("credential" in result)
+            resolveCredential(result.credential);
+        else
+            rejectCredential(result.error);
+    };
+    server = createServer((request, response) => {
+        void (async () => {
+            const requestUrl = new URL(request.url ?? "/", `http://${callbackHost}`);
+            if (request.method !== "GET" || requestUrl.pathname !== callbackPath) {
+                sendHtml(response, 404, oauthErrorHtml("OAuth callback route not found."));
+                return;
+            }
+            if (claimed || settled) {
+                sendHtml(response, 409, oauthErrorHtml("This OAuth callback has already been used."));
+                return;
+            }
+            const oauthError = requestUrl.searchParams.get("error");
+            if (oauthError) {
+                const description = requestUrl.searchParams.get("error_description") ?? oauthError;
+                sendHtml(response, 400, oauthErrorHtml("OpenRouter authorization was denied.", description));
+                finish({ error: new Error(`OpenRouter authorization failed: ${description}`) });
+                return;
+            }
+            const code = requestUrl.searchParams.get("code");
+            if (!code) {
+                sendHtml(response, 400, oauthErrorHtml("OpenRouter returned no authorization code."));
+                return;
+            }
+            claimed = true;
+            try {
+                const result = await exchangeAuthorizationCode(code, verifier, signal);
+                sendHtml(response, 200, oauthSuccessHtml("Signed in to OpenRouter. You may now close this page."));
+                finish({ credential: result });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown token exchange error";
+                sendHtml(response, 502, oauthErrorHtml("OpenRouter key exchange failed.", message));
+                finish({ error: error instanceof Error ? error : new Error(message) });
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, callbackHost, () => {
+            server.removeListener("error", reject);
+            resolve();
+        });
+    });
+    server.on("error", (error) => finish({ error }));
+    onAbort = () => finish({ error: new Error("Login cancelled") });
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) {
+        signal.removeEventListener("abort", onAbort);
+        server.close();
+        throw new Error("Login cancelled");
+    }
+    timeout = setTimeout(() => finish({ error: new Error("OpenRouter OAuth login timed out") }), LOGIN_TIMEOUT_MS);
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        finish({ error: new Error("Could not determine the OpenRouter OAuth callback port") });
+        throw new Error("Could not determine the OpenRouter OAuth callback port");
+    }
+    return {
+        callbackUrl: `http://${callbackHost}:${address.port}${callbackPath}`,
+        credential,
+        close: () => finish({ error: new Error("Login cancelled") }),
+    };
+}
+async function loginOpenRouter(interaction) {
+    const { verifier, challenge } = await generatePKCE();
+    const callbackPath = `/oauth/callback/${crypto.randomUUID()}`;
+    const callback = await startCallbackServer(callbackPath, verifier, interaction.signal);
+    const authorizeUrl = new URL(AUTHORIZE_URL);
+    authorizeUrl.search = new URLSearchParams({
+        callback_url: callback.callbackUrl,
+        code_challenge: challenge,
+        code_challenge_method: "S256",
+    }).toString();
+    interaction.notify({
+        type: "progress",
+        message: `Listening for OpenRouter OAuth callback on ${callback.callbackUrl}`,
+    });
+    interaction.notify({
+        type: "auth_url",
+        url: authorizeUrl.toString(),
+        instructions: "Complete sign-in in your browser.",
+    });
+    try {
+        return await callback.credential;
+    }
+    finally {
+        callback.close();
+    }
+}
+export const openRouterOAuth = {
+    name: "OpenRouter OAuth",
+    loginLabel: "Sign in with OpenRouter",
+    login: loginOpenRouter,
+    async refresh(credential) {
+        return credential;
+    },
+    async toAuth(credential) {
+        return { apiKey: credential.access };
+    },
+};
+//# sourceMappingURL=openrouter.js.map

package/node_modules/@earendil-works/pi-ai/dist/bun-oauth.js

@@ -3,6 +3,7 @@ import { githubCopilotOAuth } from "./auth/oauth/github-copilot.js";
 import { kimiCodingOAuth } from "./auth/oauth/kimi-coding.js";
 import { registerBundledOAuthFlowLoaders } from "./auth/oauth/load.js";
 import { openaiCodexOAuth } from "./auth/oauth/openai-codex.js";
+import { openRouterOAuth } from "./auth/oauth/openrouter.js";
 import { createRadiusOAuth } from "./auth/oauth/radius.js";
 import { xaiOAuth } from "./auth/oauth/xai.js";
 /** Register OAuth flows statically embedded in the standalone Bun binary. */
@@ -11,6 +12,7 @@ export function registerBunOAuthFlows() {
         anthropic: () => anthropicOAuth,
         openaiCodex: () => openaiCodexOAuth,
         githubCopilot: () => githubCopilotOAuth,
+        openrouter: () => openRouterOAuth,
         kimiCoding: () => kimiCodingOAuth,
         xai: () => xaiOAuth,
         radius: createRadiusOAuth,

package/node_modules/@earendil-works/pi-ai/dist/env-api-keys.js

@@ -27,6 +27,9 @@ if (typeof process !== "undefined" && (process.versions?.node || process.version
     });
 }
 import { getProviderEnvValue } from "./utils/provider-env.js";
+export const ANTHROPIC_AUTH_TOKEN_ENV = "ANTHROPIC_AUTH_TOKEN";
+export const ANTHROPIC_OAUTH_TOKEN_ENV = "ANTHROPIC_OAUTH_TOKEN";
+export const ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY";
 let cachedVertexAdcCredentialsExists = null;
 function hasVertexAdcCredentials(env) {
     const explicitCredentialsPath = env?.GOOGLE_APPLICATION_CREDENTIALS;
@@ -61,9 +64,10 @@ function getApiKeyEnvVars(provider) {
     if (provider === "github-copilot") {
         return ["COPILOT_GITHUB_TOKEN"];
     }
-    // ANTHROPIC_OAUTH_TOKEN takes precedence over ANTHROPIC_API_KEY
+    // ANTHROPIC_AUTH_TOKEN participates in env discovery/status, but
+    // getEnvApiKey() skips it because requests must pass it as Authorization: Bearer.
     if (provider === "anthropic") {
-        return ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"];
+        return [ANTHROPIC_AUTH_TOKEN_ENV, ANTHROPIC_OAUTH_TOKEN_ENV, ANTHROPIC_API_KEY_ENV];
     }
     const envMap = {
         "ant-ling": "ANT_LING_API_KEY",
@@ -114,7 +118,9 @@ export function findEnvKeys(provider, env) {
 export function getEnvApiKey(provider, env) {
     const envKeys = findEnvKeys(provider, env);
     if (envKeys?.[0]) {
-        return getProviderEnvValue(envKeys[0], env);
+        const apiKeyEnv = provider === "anthropic" ? envKeys.find((key) => key !== ANTHROPIC_AUTH_TOKEN_ENV) : envKeys[0];
+        if (apiKeyEnv)
+            return getProviderEnvValue(apiKeyEnv, env);
     }
     // Vertex AI supports either an explicit API key or Application Default Credentials.
     // Auth is configured via `gcloud auth application-default login`.

package/node_modules/@earendil-works/pi-ai/dist/image-models.generated.js

@@ -227,6 +227,21 @@ export const IMAGE_MODELS = {
                 cacheWrite: 0,
             },
         },
+        "microsoft/mai-image-2.5-pro": {
+            id: "microsoft/mai-image-2.5-pro",
+            name: "Microsoft: MAI-Image-2.5 Pro",
+            api: "openrouter-images",
+            provider: "openrouter",
+            baseUrl: "https://openrouter.ai/api/v1",
+            input: ["text", "image"],
+            output: ["image"],
+            cost: {
+                input: 5,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+            },
+        },
         "openai/gpt-5-image": {
             id: "openai/gpt-5-image",
             name: "OpenAI: GPT-5 Image",

package/node_modules/@earendil-works/pi-ai/dist/model-catalog.js

@@ -0,0 +1,4 @@
+export function flattenModelCatalog(_provider, groups) {
+    return Object.assign({}, ...Object.values(groups));
+}
+//# sourceMappingURL=model-catalog.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/all.js

@@ -8,6 +8,7 @@ import { azureOpenAIResponsesProvider } from "./azure-openai-responses.js";
 import { cerebrasProvider } from "./cerebras.js";
 import { cloudflareAIGatewayProvider } from "./cloudflare-ai-gateway.js";
 import { cloudflareWorkersAIProvider } from "./cloudflare-workers-ai.js";
+import modelDataManifest from "./data/.manifest.json" with { type: "json" };
 import { deepseekProvider } from "./deepseek.js";
 import { fireworksProvider } from "./fireworks.js";
 import { githubCopilotProvider } from "./github-copilot.js";
@@ -49,9 +50,10 @@ export function getBuiltinModel(provider, modelId) {
 export function getBuiltinProviders() {
     return Object.keys(MODELS);
 }
-/** URL of a generated provider catalog, used to compare its mtime with remote catalogs during development. */
-export function getBuiltinModelDataUrl(provider) {
-    return new URL(`./data/${provider}.json`, import.meta.url);
+/** Generation timestamp shared by all built-in provider catalogs. */
+export function getBuiltinModelDataGeneratedAt() {
+    const generatedAt = Date.parse(modelDataManifest.generatedAt);
+    return Number.isNaN(generatedAt) ? undefined : generatedAt;
 }
 export function getBuiltinModels(provider) {
     const models = MODELS[provider];

package/node_modules/@earendil-works/pi-ai/dist/providers/amazon-bedrock.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/amazon-bedrock.json" with { type: "json" };
-export const AMAZON_BEDROCK_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const AMAZON_BEDROCK_MODELS = flattenModelCatalog("amazon-bedrock", values);
 //# sourceMappingURL=amazon-bedrock.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/ant-ling.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/ant-ling.json" with { type: "json" };
-export const ANT_LING_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const ANT_LING_MODELS = flattenModelCatalog("ant-ling", values);
 //# sourceMappingURL=ant-ling.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/anthropic.js

@@ -1,16 +1,43 @@
 import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.js";
-import { envApiKeyAuth, lazyOAuth } from "../auth/helpers.js";
+import { lazyOAuth } from "../auth/helpers.js";
 import { loadAnthropicOAuth } from "../auth/oauth/load.js";
+import { ANTHROPIC_API_KEY_ENV, ANTHROPIC_AUTH_TOKEN_ENV, ANTHROPIC_OAUTH_TOKEN_ENV } from "../env-api-keys.js";
 import { createProvider } from "../models.js";
 import { ANTHROPIC_MODELS } from "./anthropic.models.js";
+function anthropicApiKeyAuth() {
+    return {
+        name: "Anthropic API key",
+        login: async (interaction) => ({
+            type: "api_key",
+            key: await interaction.prompt({ type: "secret", message: "Enter Anthropic API key" }),
+        }),
+        resolve: async ({ ctx, credential }) => {
+            if (credential?.key) {
+                return { auth: { apiKey: credential.key }, env: credential.env, source: "stored credential" };
+            }
+            const authToken = await ctx.env(ANTHROPIC_AUTH_TOKEN_ENV);
+            if (authToken) {
+                return {
+                    auth: { headers: { Authorization: `Bearer ${authToken}` } },
+                    source: ANTHROPIC_AUTH_TOKEN_ENV,
+                };
+            }
+            for (const envVar of [ANTHROPIC_OAUTH_TOKEN_ENV, ANTHROPIC_API_KEY_ENV]) {
+                const apiKey = await ctx.env(envVar);
+                if (apiKey)
+                    return { auth: { apiKey }, source: envVar };
+            }
+            return undefined;
+        },
+    };
+}
 export function anthropicProvider() {
     return createProvider({
         id: "anthropic",
         name: "Anthropic",
         baseUrl: "https://api.anthropic.com",
         auth: {
-            // ANTHROPIC_OAUTH_TOKEN takes precedence over ANTHROPIC_API_KEY
-            apiKey: envApiKeyAuth("Anthropic API key", ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"]),
+            apiKey: anthropicApiKeyAuth(),
             oauth: lazyOAuth({ name: "Anthropic (Claude Pro/Max)", load: loadAnthropicOAuth }),
         },
         models: Object.values(ANTHROPIC_MODELS),

package/node_modules/@earendil-works/pi-ai/dist/providers/anthropic.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/anthropic.json" with { type: "json" };
-export const ANTHROPIC_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const ANTHROPIC_MODELS = flattenModelCatalog("anthropic", values);
 //# sourceMappingURL=anthropic.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/azure-openai-responses.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/azure-openai-responses.json" with { type: "json" };
-export const AZURE_OPENAI_RESPONSES_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const AZURE_OPENAI_RESPONSES_MODELS = flattenModelCatalog("azure-openai-responses", values);
 //# sourceMappingURL=azure-openai-responses.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/cerebras.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/cerebras.json" with { type: "json" };
-export const CEREBRAS_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const CEREBRAS_MODELS = flattenModelCatalog("cerebras", values);
 //# sourceMappingURL=cerebras.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/cloudflare-ai-gateway.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/cloudflare-ai-gateway.json" with { type: "json" };
-export const CLOUDFLARE_AI_GATEWAY_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const CLOUDFLARE_AI_GATEWAY_MODELS = flattenModelCatalog("cloudflare-ai-gateway", values);
 //# sourceMappingURL=cloudflare-ai-gateway.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/cloudflare-workers-ai.models.js

@@ -1,5 +1,6 @@
 // This file is auto-generated by scripts/generate-models.ts
 // Do not edit manually - run 'npm run generate-models' to update
 import values from "./data/cloudflare-workers-ai.json" with { type: "json" };
-export const CLOUDFLARE_WORKERS_AI_MODELS = values;
+import { flattenModelCatalog } from "../model-catalog.js";
+export const CLOUDFLARE_WORKERS_AI_MODELS = flattenModelCatalog("cloudflare-workers-ai", values);
 //# sourceMappingURL=cloudflare-workers-ai.models.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/data/.manifest.json

@@ -1 +1 @@
-{"schemaVersion":1,"structureHash":"948d1cb02b53150250941305b1032a95b1c1538d0803e9c35a02df3606578a70","files":{"amazon-bedrock.json":"5e0cf6a2985c99aa41093c3a68f0585d2b271baa7a229c805bdf2f1288cc530a","ant-ling.json":"cd4dbdca109e1c31dc7b81c8f8c358c65aee98abc9354c6cba1103c6d79228d2","anthropic.json":"bcf2011f93fcd4080b97f119bd3886dc4b1f2f821c07956f785ad87888eda706","azure-openai-responses.json":"fe6e2515f7eabb0d08e25ab7dae31fee015028b022b1c6a619667de9b7f6c564","cerebras.json":"8619ed9bd0fe2a1b113b6788ac647063557550dbb99d43c6baf5f5bfd01bc001","cloudflare-ai-gateway.json":"eca203979c16273452ebc14973ff3a199a3b002663831eaa9040b08f71f143de","cloudflare-workers-ai.json":"d253a1c502ce65ad2997e53673914bea5d97890c60a1f5400932d5a3fa1c5af7","deepseek.json":"2af04396431781c4b60ff990f9709aac9a73efcd81fd081efeb194de9ee5f71e","fireworks.json":"945066898ef5abf5c62dcf9a837bd91c2539018bbb7bee69187274222efca66b","github-copilot.json":"475d52b2ab0590aa832f3037ad2336cfee42bd8b5c470e0365b347ed95a12e05","google-vertex.json":"c8eaf862f1221580dc87bcdb632695398b67c847ca2d3292530c759107b83741","google.json":"395712ce72ed29b57b1ca1db43fe26e8c8486d6a000f03df901a1910624991e7","groq.json":"4c653340ebe62dce7b1a220db966dad6b0129a604cda1fab29963932ad152220","huggingface.json":"7b7b65b84141df34908a07e3f53434524277d50a92cb4f3003ea96266322e7ed","kimi-coding.json":"4dd5bbd99cce4b8a56a583eb2fcc58329d1d836a8b87757a552af990e2b96b21","minimax-cn.json":"328aa5ee5883ce0d12aa56e5455872eb0f4782a21b16b60822bcd4a3154bf042","minimax.json":"e8c94dc0856b5803815ac38b2b7c65e5bcbbe6db7a4010cefc94b9d36d0bd8d9","mistral.json":"9f4815a902b6aefa68b0568ac6479e38693632a234b98130b40243713bd54696","moonshotai-cn.json":"13c17c1430578e52aec5b6fc80ce3b24107342499a16ea3e68b2d3d09cfa912f","moonshotai.json":"00f03c532d75b90cb4e5c863221135be8d15fbc9134396b9adf61c0886f37112","nvidia.json":"5a2533834e0e3417c32f0105ca36975f67c76c74ae2a366be5b13b957eb48f75","openai-codex.json":"d328ec901afd11df831ddc9d77eb60c125bd39e14eb1714587597d65af8fd0c7","openai.json":"0fbd2572fe008178ad0d2706ea7b5bec0d8d19bde6808d7f8c837bebf8d5505f","opencode-go.json":"193ca7096916b66166d0ec46c215425adf199cd10de969b35e659f188181efe9","opencode.json":"a4bf7b56131565620105cd82a0c6c41b8bee5f74cab736e7092515937c6b1da8","openrouter.json":"6eb52b701ad3f0b1149826f605130f759f18646eaea2ead0a5b957cb8c666083","qwen-token-plan-cn.json":"f120d1f4578e417b3c52bf7c061667aa6dc4168fd43716c3de5885e327a75d57","qwen-token-plan.json":"4ea3d8e8f4de1d3368d7080a6de11fc35984eb7a49d35ba2e38a998a1f34c161","together.json":"1987bfac017995f7a645b1100b19f26e038f21c7e732daf7182db2d26f0b2731","vercel-ai-gateway.json":"ca40f98e75cdcc185e7148a7b182743f1776c21cc8ecca18f22e88ee22d2e04b","xai.json":"3c770da7852ae9994636ae81682b37d1d8c0d064e6b878a87e69e11fc04c66b9","xiaomi-token-plan-ams.json":"c6c246e77d6cff1a7f0ae5cdcf6beabd89eb7b5ff0a697c4120d070f120f91be","xiaomi-token-plan-cn.json":"e160f2805c63f7aeb86e53b6ca9c848ce04262757144cf3966f9590e6d89d212","xiaomi-token-plan-sgp.json":"c81874b2aa8b17edc5d8e75a09c735e833d4432f21671e1b716e2ea369218ccc","xiaomi.json":"2e69ba280bb332fdfd9a3be501b9b8fd40562c421a866894640c4d667dbab562","zai-coding-cn.json":"a19a0f5385de068576ee74feec2771a89caed121c9d70329b3712d0404588be0","zai.json":"03b7cd1d97a4af5e9b67264614fce0d439f32d24767cb5894311d4afb29c5d05"}}
+{"schemaVersion":3,"generatedAt":"2026-07-25T04:49:49.529Z","structureHash":"7da5294256e6c090a31898f6395e37190af6a91e1967ece9eb5bac23f88509d4","files":{"amazon-bedrock.json":"dcd1ea8bd2cd948f8f5b2e6dd1ea97dc9678848a32eac6c157a540ff164d05ef","ant-ling.json":"4979fe79d99ed97382d7ce40170c6132e932e77906de1eb54464c042e7d63633","anthropic.json":"830afd9b99a5f7306903858e4b6fb49f6e28573ab73338c7a876eff69dd0b269","azure-openai-responses.json":"2d13ecc23826b5be73f3628fca5f70cc2c5c15ff609b41e4acba8167cd40934b","cerebras.json":"3fd3e19b83ab4be07d27817e25e5be0ffe4158b1394f0311d6a22d9f03847728","cloudflare-ai-gateway.json":"9974b65a0c6dda063ea3a30f4a819cab7bf70f9a25e5e3ee2feaf85cfc167b9b","cloudflare-workers-ai.json":"03b19d69433c843512e953390d51d4578e9b91f19098a9b14ff820c001623598","deepseek.json":"0dcc807a4e5827b488c6ceac87884ff6e735e01cf4f2ddfec9dd812e6fde041b","fireworks.json":"0ea306d50e72343439f71995dcda0776473e0e43a8500c4ff42769f085fee09d","github-copilot.json":"62a6256926ef2cb44e717ad30031dfbe2c3777ed38fd0db24e48b01666254a6c","google-vertex.json":"99d0b89ac9d8dc460ed922236abffbe88c9381af4d35046d2ad3a8f08fa2560c","google.json":"bcf8a8d59ccbb75bc6fb4a261a37ac4b7c806f40ee7313b4411178964be5fa37","groq.json":"868c90a897f75f866e09a585f6aee5cb991e40a9c3281497b5842a23de7d9add","huggingface.json":"e001db7b5925939c5850f31cd08b323cd40eb586222e2f74d7890eb52a30f161","kimi-coding.json":"ba42a26a69e5cb2122c0b384ba572efae93f42239ad86f26c2b7320a14aa75a1","minimax-cn.json":"8ccd71ff838f4b78bb88809babb0dc32a4fcfaec2bc4f4083841000428df4f77","minimax.json":"253edd4c910a41c8bb252400ba099f3a4de0a8900ce154319288ab091b372987","mistral.json":"44531201e872713923b7544a1f75a048d31fa25292e3e1f9f896f608a52e412d","moonshotai-cn.json":"1e6146ff3477883636448c0f44222f0a52b3c4562ef8f4eecf7e941cdd59d12e","moonshotai.json":"d8d5209873058ddccd37c1f026833e2ea3f9476c3dc9628b4a940d407acc0b2e","nvidia.json":"f476e23d9c3743c8ed3bb24a7d43b33cf90d1539ebe61c070ea2323555853e25","openai-codex.json":"c3313710bc6910e6bbcb06d5867247e97ec3fa6c2af9bc780f8a3eefb03e32e1","openai.json":"8e3852ef3567b23d2ab03b0f52f1caeb77e6e776f248e6111f851ccbe0fca8b6","opencode-go.json":"57a677764bc885c83fbbba46ad5d418baabe012a062424a0f6d8d488352102ce","opencode.json":"080500ebc60933e415c05f6e1a4e5fcc1751571ec1a46fea3d0289445257866d","openrouter.json":"3be497ceaa7ec70a2689a73f505b2abce55385c09e09a648020b2cb93a56cfa0","qwen-token-plan-cn.json":"a1495ccc21835c51d438207652f948aa9ecf4a3d784e81deaf313e484bdab1ec","qwen-token-plan.json":"597fae649f549a8ffb0b6a28426ea6761b7ece41a78b6fdef49ca970ac029970","together.json":"1d46a57e99da9be6f7e78d8f98f5610adbb266df3de7b0a13652d6fa175086e7","vercel-ai-gateway.json":"d4802bd7cf1905103c03b5819c1cbc6b55dec57d76f8330bd76baff1189a0b58","xai.json":"4cbdbfbbf915246369b9bacbc6f1feeb56accdac9f3444456343f750547f2f38","xiaomi-token-plan-ams.json":"7ce8ed244672c45737d286ff3ca9c3a2686a5d4b2f0c5f71ab9348c14b14daf3","xiaomi-token-plan-cn.json":"684892b5fe6fa371d6040d2011c0fa33facd650d2eaf19f5dbee8efb33016200","xiaomi-token-plan-sgp.json":"b19e79b82ac4fdcb080e6d220106797504c885ed70b27fc2b3c1aa4810f32963","xiaomi.json":"810368d3828c8bb9498012a0d48639030c0c216b8c13e79da02daa515aa23448","zai-coding-cn.json":"28fcb04ce65b4c6612a6b866902e0c832e18b685e5374578c4e2872569131d39","zai.json":"474670a0cf1109f4c296ea93d2c5c6eb8f53541dc9c0bddbb0e6cb054b971ebe"}}