@steipete/oracle 0.11.1 → 0.12.0

package/dist/src/oracle/providerRoutePlan.js

@@ -0,0 +1,281 @@
+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 buildProviderRoutePlan(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,
+            isAzureOpenAI,
+            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,
+        isAzureOpenAI,
+        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 };
+    }
+    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 };
+        }
+    }
+    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;
+}