@steipete/oracle 0.11.1 → 0.12.1

package/dist/src/oracle/multiModelRunner.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from "../oracle.js";
+import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
 import { sessionStore } from "../sessionStore.js";
 import { findOscProgressSequences, OSC_PROGRESS_PREFIX } from "osc-progress";
 function forwardOscProgress(chunk, shouldForward) {
@@ -113,6 +113,13 @@ function startModelExecution({ sessionMeta, runOptions, model, cwd, store, runOr
     })()
         .catch(async (error) => {
         const userError = asOracleUserError(error);
+        const providerFailure = classifyProviderFailure(error, {
+            model,
+            providerMode: runOptions.provider,
+            azure: runOptions.azure,
+            baseUrl: runOptions.baseUrl,
+            apiKey: runOptions.apiKey,
+        });
         const responseMetadata = error instanceof OracleResponseError ? error.metadata : undefined;
         const transportMetadata = error instanceof OracleTransportError ? { reason: error.reason } : undefined;
         await store.updateModelRun(sessionMeta.id, model, {
@@ -126,7 +133,18 @@ function startModelExecution({ sessionMeta, runOptions, model, cwd, store, runOr
                     message: userError.message,
                     details: userError.details,
                 }
-                : undefined,
+                : providerFailure
+                    ? {
+                        category: providerFailure.category,
+                        message: providerFailure.label,
+                        details: {
+                            provider: providerFailure.provider,
+                            keyEnv: providerFailure.keyEnv,
+                            providerMessage: providerFailure.providerMessage,
+                            fix: providerFailure.fix,
+                        },
+                    }
+                    : undefined,
             log: await describeLog(sessionMeta.id, logWriter.logPath, store),
         });
         throw error;

package/dist/src/oracle/providerFailures.js

@@ -0,0 +1,204 @@
+import { OracleTransportError, asOracleUserError } from "./errors.js";
+import { buildProviderRoutePlan } from "./providerRoutePlan.js";
+export function classifyProviderFailure(error, context) {
+    const userError = asOracleUserError(error);
+    if (userError) {
+        return null;
+    }
+    const normalizedContext = normalizeContext(context);
+    const route = inferFailureRoute(normalizedContext);
+    const rawProviderMessage = extractProviderMessage(error);
+    const lower = rawProviderMessage.toLowerCase();
+    const category = classifyMessage(lower, error);
+    if (!category) {
+        return null;
+    }
+    const providerMessage = sanitizeProviderMessage(rawProviderMessage);
+    return {
+        category,
+        label: labelForCategory(category),
+        provider: route.provider,
+        keyEnv: route.keySource,
+        providerMessage,
+        fix: fixForCategory(category, route.provider, normalizedContext.model, route.keySource),
+    };
+}
+function classifyMessage(lower, error) {
+    if (isLocalPermissionError(error, lower)) {
+        return null;
+    }
+    if (lower.includes("expired") &&
+        (lower.includes("api key") || lower.includes("credential") || lower.includes("token"))) {
+        return "auth-expired";
+    }
+    if (lower.includes("invalid x-api-key") ||
+        lower.includes("invalid api key") ||
+        lower.includes("api key is invalid") ||
+        lower.includes("api key not valid") ||
+        lower.includes("incorrect api key") ||
+        lower.includes("unauthorized") ||
+        lower.includes("unauthenticated") ||
+        hasStatusCode(lower, "401")) {
+        return "auth-failed";
+    }
+    if (lower.includes("insufficient_quota") ||
+        lower.includes("quota exceeded") ||
+        lower.includes("billing") ||
+        lower.includes("resource_exhausted")) {
+        return "quota-exceeded";
+    }
+    if (lower.includes("rate limit") || lower.includes("rate_limit") || hasStatusCode(lower, "429")) {
+        return "rate-limited";
+    }
+    if (error instanceof OracleTransportError && error.reason === "model-unavailable") {
+        return "model-unavailable";
+    }
+    if (lower.includes("model not available") ||
+        lower.includes("model_not_found") ||
+        lower.includes("unknown model") ||
+        lower.includes("does not exist")) {
+        return "model-unavailable";
+    }
+    return null;
+}
+function hasStatusCode(lower, status) {
+    return new RegExp(`(^|\\D)${status}(\\D|$)`).test(lower);
+}
+function isLocalPermissionError(error, lower) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code).toUpperCase()
+        : "";
+    return (code === "EACCES" ||
+        code === "EPERM" ||
+        lower.includes("eacces:") ||
+        lower.includes("eperm:") ||
+        /permission denied, (open|scandir|mkdir|access|unlink|rename)\b/.test(lower));
+}
+function extractProviderMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function sanitizeProviderMessage(message) {
+    return message
+        .replace(/\bBearer\s+[A-Za-z0-9._\-+/=]+/gi, "Bearer [redacted]")
+        .replace(/\b(api[-_ ]?key\s+provided)(\s*[:=]?\s*)["']?[^"',;\s]+/gi, "$1$2[redacted]")
+        .replace(/\b(api[-_ ]?key|x-api-key|authorization|token)(\s*[:=]\s*)["']?[^"',;\s]+/gi, "$1$2[redacted]")
+        .replace(/\bsk-(?:ant-|or-)?[A-Za-z0-9_-]{8,}\b/g, "sk-...[redacted]")
+        .replace(/\bxai-[A-Za-z0-9_-]{8,}\b/g, "xai-...[redacted]")
+        .replace(/\bAIza[0-9A-Za-z_-]{8,}\b/g, "AIza...[redacted]");
+}
+function normalizeContext(context) {
+    if (typeof context === "string") {
+        return { model: context };
+    }
+    return context ?? {};
+}
+function inferFailureRoute(context) {
+    if (context.model) {
+        const plan = buildProviderRoutePlan({
+            model: context.model,
+            providerMode: context.providerMode,
+            azure: context.azure,
+            baseUrl: context.baseUrl,
+            apiKey: context.apiKey,
+            env: context.env,
+        });
+        const keySource = normalizeKeySource(plan.keySource);
+        if (plan.providerLabel === "OpenRouter" || plan.keySource.includes("OPENROUTER_API_KEY")) {
+            return { provider: "openrouter", keySource };
+        }
+        if (plan.provider === "azure")
+            return { provider: "azure", keySource };
+        if (plan.provider === "google")
+            return { provider: "gemini", keySource };
+        return { provider: plan.provider, keySource };
+    }
+    const normalized = context.model?.toLowerCase() ?? "";
+    const baseUrl = context.baseUrl?.toLowerCase() ?? "";
+    if (baseUrl.includes("openrouter.ai") || (normalized.includes("/") && !baseUrl)) {
+        return { provider: "openrouter", keySource: keyEnvForProvider("openrouter") };
+    }
+    if (context.azure?.endpoint?.trim() &&
+        context.providerMode !== "openai" &&
+        (normalized.startsWith("gpt") || normalized.startsWith("openai/") || !normalized.includes("/"))) {
+        return { provider: "azure", keySource: keyEnvForProvider("azure") };
+    }
+    if (normalized.startsWith("anthropic/"))
+        return providerRoute("anthropic");
+    if (normalized.startsWith("google/"))
+        return providerRoute("gemini");
+    if (normalized.startsWith("xai/"))
+        return providerRoute("xai");
+    if (normalized.startsWith("openai/"))
+        return providerRoute("openai");
+    if (normalized.startsWith("claude"))
+        return providerRoute("anthropic");
+    if (normalized.startsWith("gemini"))
+        return providerRoute("gemini");
+    if (normalized.startsWith("grok"))
+        return providerRoute("xai");
+    return providerRoute("openai");
+}
+function providerRoute(provider) {
+    return { provider, keySource: keyEnvForProvider(provider) };
+}
+function normalizeKeySource(keySource) {
+    if (!keySource || keySource.includes("|")) {
+        return undefined;
+    }
+    return keySource;
+}
+function keyEnvForProvider(provider) {
+    switch (provider) {
+        case "anthropic":
+            return "ANTHROPIC_API_KEY";
+        case "gemini":
+            return "GEMINI_API_KEY";
+        case "xai":
+            return "XAI_API_KEY";
+        case "azure":
+            return "AZURE_OPENAI_API_KEY";
+        case "openrouter":
+            return "OPENROUTER_API_KEY";
+        case "openai":
+            return "OPENAI_API_KEY";
+        default:
+            return undefined;
+    }
+}
+function doctorCommand(model) {
+    return model ? `oracle doctor --providers --models ${model}` : "oracle doctor --providers";
+}
+function labelForCategory(category) {
+    switch (category) {
+        case "auth-failed":
+            return "auth failed";
+        case "auth-expired":
+            return "auth expired";
+        case "quota-exceeded":
+            return "quota exceeded";
+        case "rate-limited":
+            return "rate limited";
+        case "model-unavailable":
+            return "model unavailable";
+    }
+}
+function fixForCategory(category, provider, model, keySource) {
+    const doctor = doctorCommand(model);
+    const key = keySource ?? keyEnvForProvider(provider) ?? "the provider API key";
+    switch (category) {
+        case "auth-failed":
+            return key === "apiKey option"
+                ? `check --api-key value or run \`${doctor}\``
+                : `refresh ${key} or run \`${doctor}\``;
+        case "auth-expired":
+            return key === "apiKey option"
+                ? "replace --api-key value, then rerun the failed model"
+                : `rotate ${key}, then rerun the failed model`;
+        case "quota-exceeded":
+            return `check ${provider} billing/quota, then rerun the failed model`;
+        case "rate-limited":
+            return "retry later or reduce parallel model fan-out";
+        case "model-unavailable":
+            return `check model access/ID with \`${doctor}\``;
+    }
+}

package/dist/src/oracle/providerRoutePlan.js

@@ -0,0 +1,308 @@
+import { isCustomBaseUrl } from "./baseUrl.js";
+import { formatBaseUrlForLog, maskApiKey } from "./logging.js";
+import { defaultOpenRouterBaseUrl, isOpenRouterBaseUrl, normalizeOpenRouterBaseUrl, } from "./modelResolver.js";
+import { resolveProviderRoutingState, validateProviderRouting } from "./providerRouting.js";
+const DEFAULT_PROVIDER_HOSTS = {
+    anthropic: "api.anthropic.com",
+    google: "generativelanguage.googleapis.com",
+    openai: "api.openai.com",
+    xai: "api.x.ai",
+};
+export function resolveProviderRoute(input) {
+    return buildResolvedProviderRoute(input);
+}
+export function buildProviderRoutePlan(input) {
+    const { apiKey: _apiKey, baseUrl: _baseUrl, nativeProvider: _nativeProvider, openRouterFallback: _openRouterFallback, azureEndpoint: _azureEndpoint, ...plan } = buildResolvedProviderRoute(input);
+    return plan;
+}
+function buildResolvedProviderRoute(input) {
+    const env = input.env ?? process.env;
+    const providerMode = input.providerMode ?? "auto";
+    const azureConfigured = Boolean(input.azure?.endpoint?.trim());
+    try {
+        validateProviderRouting({
+            model: input.model,
+            providerMode,
+            azure: input.azure,
+        });
+    }
+    catch (error) {
+        const state = tryResolveProviderRoutingState({
+            model: input.model,
+            providerMode,
+            azure: input.azure,
+        });
+        const provider = state?.provider ??
+            (providerMode === "openai" ? "openai" : inferProviderFromModel(input.model));
+        const isAzureOpenAI = state?.isAzureOpenAI ?? providerMode === "azure";
+        const key = getKeyForRoute({
+            model: input.model,
+            provider,
+            providerMode,
+            isAzureOpenAI,
+            baseUrl: input.baseUrl,
+            openRouterFallback: false,
+            apiKey: input.apiKey,
+            env,
+        });
+        return {
+            model: input.model,
+            ok: false,
+            provider: isAzureOpenAI ? "azure" : provider,
+            providerLabel: isAzureOpenAI ? "Azure OpenAI" : providerLabel(provider),
+            base: isAzureOpenAI
+                ? formatRouteTargetForLog(state?.azureEndpoint ?? input.azure?.endpoint)
+                : formatRouteTargetForLog(input.baseUrl, DEFAULT_PROVIDER_HOSTS[provider]),
+            keySource: key.source,
+            keyPreview: key.preview,
+            keyPresent: key.present,
+            apiKey: key.value,
+            nativeProvider: provider,
+            baseUrl: input.baseUrl,
+            openRouterFallback: false,
+            isAzureOpenAI,
+            azureEndpoint: state?.azureEndpoint ?? input.azure?.endpoint,
+            azureConfigured,
+            azureDeploymentName: state?.azureDeploymentName,
+            azureNote: azureNote(providerMode, azureConfigured, isAzureOpenAI),
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const state = resolveProviderRoutingState({
+        model: input.model,
+        providerMode,
+        azure: input.azure,
+    });
+    const provider = state.provider;
+    const isAzureOpenAI = state.isAzureOpenAI;
+    let baseUrl = input.baseUrl?.trim();
+    const providerQualifiedOpenRouterCandidate = !isAzureOpenAI && providerMode !== "openai" && input.model.includes("/");
+    if (baseUrl &&
+        providerQualifiedOpenRouterCandidate &&
+        !isOpenRouterBaseUrl(baseUrl) &&
+        !isCustomBaseUrl(baseUrl)) {
+        baseUrl = undefined;
+    }
+    if (!baseUrl) {
+        let envBaseUrl;
+        if (input.model.startsWith("grok")) {
+            envBaseUrl = env.XAI_BASE_URL?.trim() || "https://api.x.ai/v1";
+        }
+        else if (provider === "anthropic") {
+            envBaseUrl = env.ANTHROPIC_BASE_URL?.trim();
+        }
+        else {
+            envBaseUrl = env.OPENAI_BASE_URL?.trim();
+        }
+        if (!providerQualifiedOpenRouterCandidate || (envBaseUrl && isCustomBaseUrl(envBaseUrl))) {
+            baseUrl = envBaseUrl;
+        }
+    }
+    const nativeKey = getNativeKey({
+        model: input.model,
+        provider,
+        providerMode,
+        isAzureOpenAI,
+        apiKey: input.apiKey,
+        env,
+    });
+    const providerQualifiedOpenRouterRoute = providerQualifiedOpenRouterCandidate && !baseUrl;
+    const providerKeyMissing = !isAzureOpenAI &&
+        (providerQualifiedOpenRouterRoute
+            ? true
+            : providerMode === "openai"
+                ? !nativeKey.present
+                : (provider === "openai" && !nativeKey.present) ||
+                    (provider === "anthropic" && !nativeKey.present) ||
+                    (provider === "google" && !nativeKey.present) ||
+                    (provider === "xai" && !nativeKey.present) ||
+                    provider === "other");
+    const openRouterKey = readKey(["OPENROUTER_API_KEY"], env);
+    const openRouterFallback = !baseUrl &&
+        (providerQualifiedOpenRouterRoute ||
+            (providerMode !== "openai" &&
+                providerKeyMissing &&
+                (provider === "other" || openRouterKey.present)));
+    if (openRouterFallback) {
+        baseUrl = defaultOpenRouterBaseUrl();
+    }
+    if (baseUrl && isOpenRouterBaseUrl(baseUrl)) {
+        baseUrl = normalizeOpenRouterBaseUrl(baseUrl);
+    }
+    const key = getKeyForRoute({
+        model: input.model,
+        provider,
+        providerMode,
+        isAzureOpenAI,
+        baseUrl,
+        openRouterFallback,
+        apiKey: input.apiKey,
+        env,
+    });
+    const routeProvider = routeProviderLabel({
+        provider,
+        baseUrl,
+        openRouterFallback,
+        isAzureOpenAI,
+    });
+    const fallbackHost = DEFAULT_PROVIDER_HOSTS[provider] ?? DEFAULT_PROVIDER_HOSTS.openai;
+    return {
+        model: input.model,
+        ok: key.present,
+        provider: isAzureOpenAI ? "azure" : provider,
+        providerLabel: routeProvider,
+        base: isAzureOpenAI
+            ? formatRouteTargetForLog(state.azureEndpoint)
+            : formatRouteTargetForLog(baseUrl, fallbackHost),
+        keySource: key.source,
+        keyPreview: key.preview,
+        keyPresent: key.present,
+        apiKey: key.value,
+        nativeProvider: provider,
+        baseUrl,
+        openRouterFallback,
+        isAzureOpenAI,
+        azureEndpoint: state.azureEndpoint,
+        azureConfigured,
+        azureDeploymentName: state.azureDeploymentName,
+        azureNote: azureNote(providerMode, azureConfigured, isAzureOpenAI),
+        error: key.present ? undefined : `Missing ${key.source}.`,
+    };
+}
+function getNativeKey({ model, provider, providerMode, isAzureOpenAI, apiKey, env, }) {
+    return getKeyForRoute({
+        model,
+        provider,
+        providerMode,
+        isAzureOpenAI,
+        baseUrl: undefined,
+        openRouterFallback: false,
+        apiKey,
+        env,
+    });
+}
+function getKeyForRoute({ model, provider, providerMode, isAzureOpenAI, baseUrl, openRouterFallback, apiKey, env, }) {
+    if (apiKey) {
+        return {
+            source: "apiKey option",
+            preview: maskApiKey(apiKey) ?? "set",
+            present: true,
+            value: apiKey,
+        };
+    }
+    if (isAzureOpenAI) {
+        return readKey(["AZURE_OPENAI_API_KEY", "OPENAI_API_KEY"], env);
+    }
+    if (providerMode === "openai") {
+        return readKey(["OPENAI_API_KEY"], env);
+    }
+    if (isOpenRouterBaseUrl(baseUrl) || openRouterFallback) {
+        return readKey(["OPENROUTER_API_KEY"], env);
+    }
+    if (model.includes("/")) {
+        return readKey(["OPENROUTER_API_KEY"], env);
+    }
+    if (model.startsWith("gpt")) {
+        return readKey(["OPENAI_API_KEY"], env);
+    }
+    if (model.startsWith("gemini")) {
+        return readKey(["GEMINI_API_KEY"], env);
+    }
+    if (model.startsWith("claude")) {
+        return readKey(["ANTHROPIC_API_KEY"], env);
+    }
+    if (model.startsWith("grok")) {
+        return readKey(["XAI_API_KEY"], env);
+    }
+    if (provider === "other") {
+        return readKey(["OPENROUTER_API_KEY"], env);
+    }
+    return readKey(["OPENAI_API_KEY"], env);
+}
+function readKey(names, env) {
+    for (const name of names) {
+        const value = env[name]?.trim();
+        if (value) {
+            return {
+                source: name,
+                preview: `${name}=${maskApiKey(value) ?? "set"}`,
+                present: true,
+                value,
+            };
+        }
+    }
+    return { source: names.join("|"), preview: "missing", present: false };
+}
+function routeProviderLabel({ provider, baseUrl, openRouterFallback, isAzureOpenAI, }) {
+    if (isAzureOpenAI)
+        return "Azure OpenAI";
+    if (isOpenRouterBaseUrl(baseUrl) || openRouterFallback)
+        return "OpenRouter";
+    if (baseUrl && isCustomBaseUrl(baseUrl))
+        return "OpenAI-compatible";
+    return providerLabel(provider);
+}
+function providerLabel(provider) {
+    if (provider === "anthropic")
+        return "Anthropic";
+    if (provider === "google")
+        return "Google Gemini";
+    if (provider === "xai")
+        return "xAI";
+    return "OpenAI";
+}
+function tryResolveProviderRoutingState(input) {
+    try {
+        return resolveProviderRoutingState(input);
+    }
+    catch {
+        return undefined;
+    }
+}
+function inferProviderFromModel(model) {
+    const prefix = model.includes("/") ? model.split("/", 1)[0] : undefined;
+    if (prefix === "openai")
+        return "openai";
+    if (prefix === "anthropic")
+        return "anthropic";
+    if (prefix === "google")
+        return "google";
+    if (prefix === "xai")
+        return "xai";
+    if (model.startsWith("claude"))
+        return "anthropic";
+    if (model.startsWith("gemini"))
+        return "google";
+    if (model.startsWith("grok"))
+        return "xai";
+    return "other";
+}
+function azureNote(providerMode, azureConfigured, isAzureOpenAI) {
+    if (!azureConfigured)
+        return undefined;
+    if (providerMode === "openai")
+        return "ignored, --provider openai/--no-azure is active";
+    if (isAzureOpenAI)
+        return "active because Azure endpoint is configured";
+    return "configured, not used for this model";
+}
+export function formatRouteTargetForLog(raw, fallbackHost = "") {
+    if (!raw)
+        return fallbackHost;
+    try {
+        const parsed = new URL(raw);
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        let routePath = "";
+        if (segments.length > 0) {
+            routePath = `/${segments[0]}`;
+            if (segments.length > 1) {
+                routePath += "/...";
+            }
+        }
+        return `${parsed.host}${routePath}`;
+    }
+    catch {
+        const formatted = formatBaseUrlForLog(raw).replace(/^https?:\/\//u, "");
+        return formatted || fallbackHost;
+    }
+}

package/dist/src/oracle/providerRouting.js

@@ -0,0 +1,92 @@
+import { MODEL_CONFIGS } from "./config.js";
+import { PromptValidationError } from "./errors.js";
+import { isKnownModel } from "./modelResolver.js";
+export const AZURE_DEPLOYMENT_REQUIRED_MESSAGE = "Azure mode requires --azure-deployment unless your deployment is literally gpt-5.5-pro. Pass --azure-deployment <deployment> (or set AZURE_OPENAI_DEPLOYMENT), or rerun with --provider openai/--no-azure to use api.openai.com.";
+export function resolveProviderRoutingState({ model, providerMode = "auto", azure, }) {
+    const knownModelConfig = isKnownModel(model) ? MODEL_CONFIGS[model] : undefined;
+    const provider = knownModelConfig?.provider ?? inferNativeProviderFromModelId(model) ?? "other";
+    const azureEndpoint = azure?.endpoint?.trim();
+    const azureDeploymentOption = azure?.deployment?.trim();
+    const isNonOpenAIModel = provider !== "openai" && provider !== "other";
+    const isProviderQualifiedModelId = model.includes("/");
+    if (providerMode === "azure" && !azureEndpoint) {
+        throw new PromptValidationError("--provider azure requires --azure-endpoint or AZURE_OPENAI_ENDPOINT.", {
+            provider: "azure",
+            endpoint: "none",
+        });
+    }
+    if (providerMode === "azure" && isNonOpenAIModel) {
+        throw new PromptValidationError(`Azure OpenAI provider cannot run ${model}. Choose an OpenAI/Azure deployment model, or rerun without --provider azure for the model's native provider.`, {
+            provider: "azure",
+            model,
+            modelProvider: provider,
+        });
+    }
+    if (providerMode === "openai" && isNonOpenAIModel) {
+        throw new PromptValidationError(`OpenAI provider cannot run ${model}. Choose an OpenAI model, or rerun without --provider openai/--no-azure for the model's native provider.`, {
+            provider: "openai",
+            model,
+            modelProvider: provider,
+        });
+    }
+    const isOpenAIFamilyModel = provider === "openai" || model.startsWith("gpt");
+    const isCustomAzureModelId = provider === "other" && !model.includes("/");
+    const isAzureOpenAI = Boolean(azureEndpoint &&
+        providerMode !== "openai" &&
+        !isNonOpenAIModel &&
+        (providerMode === "azure" ||
+            (!isProviderQualifiedModelId &&
+                (isOpenAIFamilyModel || Boolean(azureDeploymentOption) || isCustomAzureModelId))));
+    const implicitAzureDeploymentName = isAzureOpenAI &&
+        !azureDeploymentOption &&
+        (knownModelConfig?.apiModel ?? knownModelConfig?.model) === "gpt-5.5-pro"
+        ? "gpt-5.5-pro"
+        : undefined;
+    return {
+        knownModelConfig,
+        provider,
+        providerMode,
+        azureEndpoint,
+        azureDeploymentOption,
+        isNonOpenAIModel,
+        isAzureOpenAI,
+        azureDeploymentName: azureDeploymentOption ?? implicitAzureDeploymentName,
+    };
+}
+function inferNativeProviderFromModelId(model) {
+    const providerPrefix = model.includes("/") ? model.split("/", 1)[0] : undefined;
+    if (providerPrefix === "openai")
+        return "openai";
+    if (providerPrefix === "anthropic")
+        return "anthropic";
+    if (providerPrefix === "google")
+        return "google";
+    if (providerPrefix === "xai")
+        return "xai";
+    if (model.startsWith("claude"))
+        return "anthropic";
+    if (model.startsWith("gemini"))
+        return "google";
+    if (model.startsWith("grok"))
+        return "xai";
+    return undefined;
+}
+export function isAzureOpenAICandidateModel(model) {
+    const knownModelConfig = isKnownModel(model) ? MODEL_CONFIGS[model] : undefined;
+    const provider = knownModelConfig?.provider ?? inferNativeProviderFromModelId(model) ?? "other";
+    return (provider === "openai" ||
+        model.startsWith("gpt") ||
+        (provider === "other" && !model.includes("/")));
+}
+export function validateProviderRouting(input, hooks = {}) {
+    const state = resolveProviderRoutingState(input);
+    if (state.isAzureOpenAI && !state.azureDeploymentName) {
+        hooks.onAzureDeploymentMissing?.(state);
+        throw new PromptValidationError(AZURE_DEPLOYMENT_REQUIRED_MESSAGE, {
+            provider: "azure",
+            endpoint: state.azureEndpoint ?? "none",
+            deployment: "none",
+        });
+    }
+    return state;
+}