@steipete/oracle 0.8.6 → 0.9.0

package/dist/src/gemini-web/executor.js

@@ -1,6 +1,11 @@
 import path from 'node:path';
 import { getCookies } from '@steipete/sweet-cookie';
+import { runProviderDomFlow } from '../browser/providerDomFlow.js';
+import { delay } from '../browser/utils.js';
 import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
+import { geminiDeepThinkDomProvider } from '../browser/providers/index.js';
+import { openGeminiBrowserSession } from './browserSessionManager.js';
+import { selectGeminiExecutionMode } from './executionMode.js';
 const GEMINI_COOKIE_NAMES = [
     '__Secure-1PSID',
     '__Secure-1PSIDTS',
@@ -37,16 +42,21 @@ function resolveGeminiWebModel(desiredModel, log) {
     const desired = typeof desiredModel === 'string' ? desiredModel.trim() : '';
     if (!desired)
         return 'gemini-3-pro';
-    switch (desired) {
+    const normalized = desired.toLowerCase().replace(/[_\s]+/g, '-');
+    switch (normalized) {
         case 'gemini-3-pro':
         case 'gemini-3.0-pro':
             return 'gemini-3-pro';
+        case 'gemini-3-deep-think':
+        case 'gemini-3-pro-deep-think':
+        case 'gemini-3-pro-deepthink':
+            return 'gemini-3-pro-deep-think';
         case 'gemini-2.5-pro':
             return 'gemini-2.5-pro';
         case 'gemini-2.5-flash':
             return 'gemini-2.5-flash';
         default:
-            if (desired.startsWith('gemini-')) {
+            if (normalized.startsWith('gemini-') || normalized.includes('gemini')) {
                 log?.(`[gemini-web] Unsupported Gemini web model "${desired}". Falling back to gemini-3-pro.`);
             }
             return 'gemini-3-pro';
@@ -91,10 +101,97 @@ function buildGeminiCookieMap(cookies) {
 function hasRequiredGeminiCookies(cookieMap) {
     return GEMINI_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
 }
+const GEMINI_CDP_COOKIE_URLS = [
+    'https://gemini.google.com',
+    'https://accounts.google.com',
+    'https://www.google.com',
+];
+async function loadGeminiCookiesFromCDP(browserConfig, log) {
+    const session = await openGeminiBrowserSession({
+        browserConfig,
+        keepBrowserDefault: false,
+        purpose: 'Gemini manual-login cookie extraction (no keychain)',
+        log,
+    });
+    try {
+        const client = session.client;
+        const { Network, Page } = client;
+        await Network.enable({});
+        await Page.enable();
+        log?.('[gemini-web] Navigating to gemini.google.com for sign-in/cookie capture...');
+        await Page.navigate({ url: 'https://gemini.google.com' });
+        await delay(2_000);
+        const pollTimeoutMs = 5 * 60_000;
+        const pollIntervalMs = 2_000;
+        const deadline = Date.now() + pollTimeoutMs;
+        let lastNotice = 0;
+        let cookieMap = {};
+        while (Date.now() < deadline) {
+            const { cookies } = await Network.getCookies({ urls: GEMINI_CDP_COOKIE_URLS });
+            cookieMap = buildGeminiCookieMap(cookies);
+            if (hasRequiredGeminiCookies(cookieMap)) {
+                log?.(`[gemini-web] Extracted ${Object.keys(cookieMap).length} Gemini cookie(s) via CDP.`);
+                return { cookieMap, warnings: [] };
+            }
+            const now = Date.now();
+            if (now - lastNotice > 10_000) {
+                log?.('[gemini-web] Waiting for Google sign-in... please sign in in the opened Chrome window.');
+                lastNotice = now;
+            }
+            await delay(pollIntervalMs);
+        }
+        throw new Error('Timed out waiting for Google sign-in (5 minutes). Please sign in and retry.');
+    }
+    finally {
+        await session.close();
+    }
+}
+async function runGeminiDeepThinkViaBrowser(prompt, browserConfig, log) {
+    const session = await openGeminiBrowserSession({
+        browserConfig,
+        keepBrowserDefault: true,
+        purpose: 'Gemini Deep Think',
+        log,
+    });
+    try {
+        const client = session.client;
+        const { Runtime, Page } = client;
+        if (!Runtime || typeof Runtime.enable !== 'function' || typeof Runtime.evaluate !== 'function') {
+            throw new Error('Chrome Runtime domain unavailable for Gemini Deep Think DOM automation.');
+        }
+        if (!Page || typeof Page.enable !== 'function' || typeof Page.navigate !== 'function') {
+            throw new Error('Chrome Page domain unavailable for Gemini Deep Think DOM automation.');
+        }
+        await Runtime.enable();
+        await Page.enable();
+        const evaluate = async (expression) => {
+            const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+            return result?.value;
+        };
+        log?.('[gemini-web] Navigating to gemini.google.com...');
+        await Page.navigate({ url: 'https://gemini.google.com/app' });
+        await delay(3_000);
+        const domResult = await runProviderDomFlow(geminiDeepThinkDomProvider, {
+            prompt,
+            evaluate,
+            delay,
+            log,
+            state: {
+                inputTimeoutMs: browserConfig?.inputTimeoutMs,
+                timeoutMs: browserConfig?.timeoutMs,
+            },
+        });
+        log?.(`[gemini-web] Deep Think response received (${domResult.text.length} chars).`);
+        return domResult;
+    }
+    finally {
+        await session.close();
+    }
+}
 async function loadGeminiCookiesFromInline(browserConfig, log) {
     const inline = browserConfig?.inlineCookies;
     if (!inline || inline.length === 0)
-        return {};
+        return { cookieMap: {}, warnings: [] };
     const cookieMap = buildGeminiCookieMap(inline.filter((cookie) => Boolean(cookie?.name && typeof cookie.value === 'string')));
     if (Object.keys(cookieMap).length > 0) {
         const source = browserConfig?.inlineCookiesSource ?? 'inline';
@@ -103,7 +200,7 @@ async function loadGeminiCookiesFromInline(browserConfig, log) {
     else {
         log?.('[gemini-web] Inline cookie payload provided but no Gemini cookies matched.');
     }
-    return cookieMap;
+    return { cookieMap, warnings: [] };
 }
 async function loadGeminiCookiesFromChrome(browserConfig, log) {
     try {
@@ -131,47 +228,52 @@ async function loadGeminiCookiesFromChrome(browserConfig, log) {
         }
         const cookieMap = buildGeminiCookieMap(cookies);
         log?.(`[gemini-web] Loaded Gemini cookies from Chrome (node): ${Object.keys(cookieMap).length} cookie(s).`);
-        return cookieMap;
+        return { cookieMap, warnings };
     }
     catch (error) {
         log?.(`[gemini-web] Failed to load Chrome cookies via node: ${error instanceof Error ? error.message : String(error ?? '')}`);
-        return {};
+        return { cookieMap: {}, warnings: [] };
+    }
+}
+function formatGeminiCookieError(warnings) {
+    const base = 'Gemini browser mode requires Chrome cookies for google.com (missing __Secure-1PSID/__Secure-1PSIDTS).';
+    const guidance = 'Try --browser-manual-login or --browser-inline-cookies-file if local cookie extraction is unavailable.';
+    if (warnings.length === 0) {
+        return `${base} ${guidance}`;
     }
+    return `${base}\nCookie read warnings:\n- ${warnings.join('\n- ')}\n${guidance}`;
 }
-async function loadGeminiCookies(browserConfig, log) {
-    const inlineMap = await loadGeminiCookiesFromInline(browserConfig, log);
-    const hasInlineRequired = hasRequiredGeminiCookies(inlineMap);
-    if (hasInlineRequired && browserConfig?.cookieSync === false) {
-        return inlineMap;
+async function loadGeminiCookies(browserConfig, log, options) {
+    const inlineResult = await loadGeminiCookiesFromInline(browserConfig, log);
+    const hasInlineRequired = hasRequiredGeminiCookies(inlineResult.cookieMap);
+    if (hasInlineRequired) {
+        return inlineResult;
+    }
+    const manualNoKeychain = Boolean(browserConfig?.manualLogin) || Boolean(options?.preferManualNoKeychain);
+    if (manualNoKeychain) {
+        log?.('[gemini-web] Using manual-login cookie extraction path (no keychain cookie read).');
+        const cdpResult = await loadGeminiCookiesFromCDP(browserConfig, log);
+        return {
+            cookieMap: { ...cdpResult.cookieMap, ...inlineResult.cookieMap },
+            warnings: [...inlineResult.warnings, ...cdpResult.warnings],
+        };
     }
     if (browserConfig?.cookieSync === false && !hasInlineRequired) {
         log?.('[gemini-web] Cookie sync disabled and inline cookies missing Gemini auth tokens.');
-        return inlineMap;
+        return inlineResult;
     }
-    const chromeMap = await loadGeminiCookiesFromChrome(browserConfig, log);
-    const merged = { ...chromeMap, ...inlineMap };
-    return merged;
+    const chromeResult = await loadGeminiCookiesFromChrome(browserConfig, log);
+    return {
+        cookieMap: { ...chromeResult.cookieMap, ...inlineResult.cookieMap },
+        warnings: [...inlineResult.warnings, ...chromeResult.warnings],
+    };
 }
 export function createGeminiWebExecutor(geminiOptions) {
     return async (runOptions) => {
         const startTime = Date.now();
         const log = runOptions.log;
         log?.('[gemini-web] Starting Gemini web executor (TypeScript)');
-        const cookieMap = await loadGeminiCookies(runOptions.config, log);
-        if (!hasRequiredGeminiCookies(cookieMap)) {
-            throw new Error('Gemini browser mode requires Chrome cookies for google.com (missing __Secure-1PSID/__Secure-1PSIDTS).');
-        }
-        const configTimeout = typeof runOptions.config?.timeoutMs === 'number' && Number.isFinite(runOptions.config.timeoutMs)
-            ? Math.max(1_000, runOptions.config.timeoutMs)
-            : null;
-        const defaultTimeoutMs = geminiOptions.youtube
-            ? 240_000
-            : geminiOptions.generateImage || geminiOptions.editImage
-                ? 300_000
-                : 120_000;
-        const timeoutMs = Math.min(configTimeout ?? defaultTimeoutMs, 600_000);
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const model = resolveGeminiWebModel(runOptions.config?.desiredModel, log);
         const generateImagePath = resolveInvocationPath(geminiOptions.generateImage);
         const editImagePath = resolveInvocationPath(geminiOptions.editImage);
         const outputPath = resolveInvocationPath(geminiOptions.outputPath);
@@ -186,100 +288,151 @@ export function createGeminiWebExecutor(geminiOptions) {
         if (generateImagePath && !editImagePath) {
             prompt = `Generate an image: ${prompt}`;
         }
-        const model = resolveGeminiWebModel(runOptions.config?.desiredModel, log);
-        let response;
-        try {
-            if (editImagePath) {
-                const intro = await runGeminiWebWithFallback({
-                    prompt: 'Here is an image to edit',
-                    files: [editImagePath],
-                    model,
-                    cookieMap,
-                    chatMetadata: null,
-                    signal: controller.signal,
-                });
-                const editPrompt = `Use image generation tool to ${prompt}`;
-                const out = await runGeminiWebWithFallback({
-                    prompt: editPrompt,
-                    files: attachmentPaths,
-                    model,
-                    cookieMap,
-                    chatMetadata: intro.metadata,
-                    signal: controller.signal,
-                });
-                response = {
-                    text: out.text ?? null,
-                    thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-                    has_images: false,
-                    image_count: 0,
-                };
-                const resolvedOutputPath = outputPath ?? generateImagePath ?? 'generated.png';
-                const imageSave = await saveFirstGeminiImageFromOutput(out, cookieMap, resolvedOutputPath, controller.signal);
-                response.has_images = imageSave.saved;
-                response.image_count = imageSave.imageCount;
-                if (!imageSave.saved) {
-                    throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
+        const modeSelection = selectGeminiExecutionMode({
+            model,
+            attachmentPaths,
+            generateImagePath,
+            editImagePath,
+        });
+        const domClient = {
+            mode: 'dom',
+            execute: async () => {
+                log?.('[gemini-web] Using browser DOM automation for Deep Think.');
+                const browserResult = await runGeminiDeepThinkViaBrowser(prompt, runOptions.config, log);
+                const tookMs = Date.now() - startTime;
+                let answerMarkdown = browserResult.text;
+                if (geminiOptions.showThoughts && browserResult.thoughts) {
+                    answerMarkdown = `## Thinking\n\n${browserResult.thoughts}\n\n## Response\n\n${browserResult.text}`;
                 }
-            }
-            else if (generateImagePath) {
-                const out = await runGeminiWebWithFallback({
-                    prompt,
-                    files: attachmentPaths,
-                    model,
-                    cookieMap,
-                    chatMetadata: null,
-                    signal: controller.signal,
-                });
-                response = {
-                    text: out.text ?? null,
-                    thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-                    has_images: false,
-                    image_count: 0,
+                log?.(`[gemini-web] Completed in ${tookMs}ms`);
+                return {
+                    answerText: browserResult.text,
+                    answerMarkdown,
+                    tookMs,
+                    answerTokens: estimateTokenCount(browserResult.text),
+                    answerChars: browserResult.text.length,
                 };
-                const imageSave = await saveFirstGeminiImageFromOutput(out, cookieMap, generateImagePath, controller.signal);
-                response.has_images = imageSave.saved;
-                response.image_count = imageSave.imageCount;
-                if (!imageSave.saved) {
-                    throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
+            },
+        };
+        const httpClient = {
+            mode: 'http',
+            execute: async () => {
+                const useNoKeychainPath = Boolean(runOptions.config?.manualLogin);
+                const cookieResult = await loadGeminiCookies(runOptions.config, log, { preferManualNoKeychain: useNoKeychainPath });
+                if (!hasRequiredGeminiCookies(cookieResult.cookieMap)) {
+                    throw new Error(formatGeminiCookieError(cookieResult.warnings));
                 }
-            }
-            else {
-                const out = await runGeminiWebWithFallback({
-                    prompt,
-                    files: attachmentPaths,
-                    model,
-                    cookieMap,
-                    chatMetadata: null,
-                    signal: controller.signal,
-                });
-                response = {
-                    text: out.text ?? null,
-                    thoughts: geminiOptions.showThoughts ? out.thoughts : null,
-                    has_images: out.images.length > 0,
-                    image_count: out.images.length,
+                const configTimeout = typeof runOptions.config?.timeoutMs === 'number' && Number.isFinite(runOptions.config.timeoutMs)
+                    ? Math.max(1_000, runOptions.config.timeoutMs)
+                    : null;
+                const defaultTimeoutMs = geminiOptions.youtube
+                    ? 240_000
+                    : geminiOptions.generateImage || geminiOptions.editImage
+                        ? 300_000
+                        : 120_000;
+                const timeoutMs = Math.min(configTimeout ?? defaultTimeoutMs, 600_000);
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), timeoutMs);
+                let response;
+                try {
+                    if (editImagePath) {
+                        const intro = await runGeminiWebWithFallback({
+                            prompt: 'Here is an image to edit',
+                            files: [editImagePath],
+                            model,
+                            cookieMap: cookieResult.cookieMap,
+                            chatMetadata: null,
+                            signal: controller.signal,
+                        });
+                        const editPrompt = `Use image generation tool to ${prompt}`;
+                        const out = await runGeminiWebWithFallback({
+                            prompt: editPrompt,
+                            files: attachmentPaths,
+                            model,
+                            cookieMap: cookieResult.cookieMap,
+                            chatMetadata: intro.metadata,
+                            signal: controller.signal,
+                        });
+                        response = {
+                            text: out.text ?? null,
+                            thoughts: geminiOptions.showThoughts ? out.thoughts : null,
+                            has_images: false,
+                            image_count: 0,
+                        };
+                        const resolvedOutputPath = outputPath ?? generateImagePath ?? 'generated.png';
+                        const imageSave = await saveFirstGeminiImageFromOutput(out, cookieResult.cookieMap, resolvedOutputPath, controller.signal);
+                        response.has_images = imageSave.saved;
+                        response.image_count = imageSave.imageCount;
+                        if (!imageSave.saved) {
+                            throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
+                        }
+                    }
+                    else if (generateImagePath) {
+                        const out = await runGeminiWebWithFallback({
+                            prompt,
+                            files: attachmentPaths,
+                            model,
+                            cookieMap: cookieResult.cookieMap,
+                            chatMetadata: null,
+                            signal: controller.signal,
+                        });
+                        response = {
+                            text: out.text ?? null,
+                            thoughts: geminiOptions.showThoughts ? out.thoughts : null,
+                            has_images: false,
+                            image_count: 0,
+                        };
+                        const imageSave = await saveFirstGeminiImageFromOutput(out, cookieResult.cookieMap, generateImagePath, controller.signal);
+                        response.has_images = imageSave.saved;
+                        response.image_count = imageSave.imageCount;
+                        if (!imageSave.saved) {
+                            throw new Error(`No images generated. Response text:\n${out.text || '(empty response)'}`);
+                        }
+                    }
+                    else {
+                        const out = await runGeminiWebWithFallback({
+                            prompt,
+                            files: attachmentPaths,
+                            model,
+                            cookieMap: cookieResult.cookieMap,
+                            chatMetadata: null,
+                            signal: controller.signal,
+                        });
+                        response = {
+                            text: out.text ?? null,
+                            thoughts: geminiOptions.showThoughts ? out.thoughts : null,
+                            has_images: out.images.length > 0,
+                            image_count: out.images.length,
+                        };
+                    }
+                }
+                finally {
+                    clearTimeout(timeout);
+                }
+                const answerText = response.text ?? '';
+                let answerMarkdown = answerText;
+                if (geminiOptions.showThoughts && response.thoughts) {
+                    answerMarkdown = `## Thinking\n\n${response.thoughts}\n\n## Response\n\n${answerText}`;
+                }
+                if (response.has_images && response.image_count > 0) {
+                    const imagePath = generateImagePath || outputPath || 'generated.png';
+                    answerMarkdown += `\n\n*Generated ${response.image_count} image(s). Saved to: ${imagePath}*`;
+                }
+                const tookMs = Date.now() - startTime;
+                log?.(`[gemini-web] Completed in ${tookMs}ms`);
+                return {
+                    answerText,
+                    answerMarkdown,
+                    tookMs,
+                    answerTokens: estimateTokenCount(answerText),
+                    answerChars: answerText.length,
                 };
-            }
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        const answerText = response.text ?? '';
-        let answerMarkdown = answerText;
-        if (geminiOptions.showThoughts && response.thoughts) {
-            answerMarkdown = `## Thinking\n\n${response.thoughts}\n\n## Response\n\n${answerText}`;
-        }
-        if (response.has_images && response.image_count > 0) {
-            const imagePath = generateImagePath || outputPath || 'generated.png';
-            answerMarkdown += `\n\n*Generated ${response.image_count} image(s). Saved to: ${imagePath}*`;
-        }
-        const tookMs = Date.now() - startTime;
-        log?.(`[gemini-web] Completed in ${tookMs}ms`);
-        return {
-            answerText,
-            answerMarkdown,
-            tookMs,
-            answerTokens: estimateTokenCount(answerText),
-            answerChars: answerText.length,
+            },
         };
+        if (model === 'gemini-3-pro-deep-think' && modeSelection.mode === 'http') {
+            log?.(`[gemini-web] Deep Think DOM path skipped (${modeSelection.reasons.join(', ')} requested); using HTTP/header fallback path.`);
+        }
+        const executionClient = modeSelection.mode === 'dom' ? domClient : httpClient;
+        return executionClient.execute();
     };
 }

package/dist/src/mcp/tools/consult.js

@@ -139,6 +139,31 @@ export function summarizeModelRunsForConsult(runs) {
         };
     });
 }
+export function buildConsultBrowserConfig({ userConfig, env, runModel, inputModel, browserModelLabel, browserThinkingTime, browserKeepBrowser, }) {
+    const configuredBrowser = userConfig.browser ?? {};
+    const envProfileDir = (env.ORACLE_BROWSER_PROFILE_DIR ?? '').trim();
+    const hasProfileDir = envProfileDir.length > 0;
+    const preferredLabel = (browserModelLabel ?? inputModel)?.trim();
+    const isChatGptModel = runModel.startsWith('gpt-') && !runModel.includes('codex');
+    const desiredModelLabel = isChatGptModel
+        ? mapModelToBrowserLabel(runModel)
+        : resolveBrowserModelLabel(preferredLabel, runModel);
+    const configuredUrl = configuredBrowser.chatgptUrl ?? configuredBrowser.url ?? CHATGPT_URL;
+    const manualLogin = hasProfileDir ? true : configuredBrowser.manualLogin ?? false;
+    return {
+        ...configuredBrowser,
+        url: configuredUrl,
+        chatgptUrl: configuredUrl,
+        cookieSync: !manualLogin,
+        headless: configuredBrowser.headless ?? false,
+        hideWindow: configuredBrowser.hideWindow ?? false,
+        keepBrowser: browserKeepBrowser ?? configuredBrowser.keepBrowser ?? false,
+        manualLogin,
+        manualLoginProfileDir: manualLogin ? ((envProfileDir || configuredBrowser.manualLoginProfileDir) ?? null) : null,
+        thinkingTime: browserThinkingTime ?? configuredBrowser.thinkingTime,
+        desiredModel: desiredModelLabel || mapModelToBrowserLabel(runModel),
+    };
+}
 export function registerConsultTool(server) {
     server.registerTool('consult', {
         title: 'Run an oracle session',
@@ -185,27 +210,15 @@ export function registerConsultTool(server) {
         }
         let browserConfig;
         if (resolvedEngine === 'browser') {
-            const envProfileDir = (process.env.ORACLE_BROWSER_PROFILE_DIR ?? '').trim();
-            const hasProfileDir = envProfileDir.length > 0;
-            const preferredLabel = (browserModelLabel ?? model)?.trim();
-            const isChatGptModel = runOptions.model.startsWith('gpt-') && !runOptions.model.includes('codex');
-            const desiredModelLabel = isChatGptModel
-                ? mapModelToBrowserLabel(runOptions.model)
-                : resolveBrowserModelLabel(preferredLabel, runOptions.model);
-            const configuredUrl = userConfig.browser?.chatgptUrl ?? userConfig.browser?.url ?? undefined;
-            // Default to manual-login when a persistent profile dir is provided (common for Codex/Claude).
-            const manualLogin = hasProfileDir;
-            browserConfig = {
-                url: configuredUrl ?? CHATGPT_URL,
-                cookieSync: !manualLogin,
-                headless: false,
-                hideWindow: false,
-                keepBrowser: browserKeepBrowser ?? false,
-                manualLogin,
-                manualLoginProfileDir: manualLogin ? envProfileDir : null,
-                thinkingTime: browserThinkingTime,
-                desiredModel: desiredModelLabel || mapModelToBrowserLabel(runOptions.model),
-            };
+            browserConfig = buildConsultBrowserConfig({
+                userConfig,
+                env: process.env,
+                runModel: runOptions.model,
+                inputModel: model,
+                browserModelLabel,
+                browserThinkingTime,
+                browserKeepBrowser,
+            });
         }
         const notifications = resolveNotificationSettings({
             cliNotify: undefined,

package/dist/src/oracle/client.js

@@ -1,34 +1,63 @@
-import OpenAI, { AzureOpenAI } from 'openai';
+import OpenAI from 'openai';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { createGeminiClient } from './gemini.js';
 import { createClaudeClient } from './claude.js';
 import { isOpenRouterBaseUrl } from './modelResolver.js';
+/**
+ * Known native API base URLs that should still use their dedicated SDKs.
+ * Any other custom base URL is treated as an OpenAI-compatible proxy and
+ * all models are routed through the chat/completions adapter.
+ */
+const NATIVE_API_HOSTS = [
+    'api.openai.com',
+    'api.anthropic.com',
+    'generativelanguage.googleapis.com',
+    'api.x.ai',
+];
+export function isCustomBaseUrl(baseUrl) {
+    if (!baseUrl)
+        return false;
+    try {
+        const url = new URL(baseUrl);
+        return !NATIVE_API_HOSTS.some((host) => url.hostname === host || url.hostname.endsWith(`.${host}`));
+    }
+    catch {
+        return false;
+    }
+}
+export function buildAzureResponsesBaseUrl(endpoint) {
+    return `${endpoint.replace(/\/+$/, '')}/openai/v1`;
+}
 export function createDefaultClientFactory() {
     const customFactory = loadCustomClientFactory();
     if (customFactory)
         return customFactory;
     return (key, options) => {
-        if (options?.model?.startsWith('gemini')) {
-            // Gemini client uses its own SDK; allow passing the already-resolved id for transparency/logging.
-            return createGeminiClient(key, options.model, options.resolvedModelId);
-        }
-        if (options?.model?.startsWith('claude')) {
-            return createClaudeClient(key, options.model, options.resolvedModelId, options.baseUrl);
+        const openRouter = isOpenRouterBaseUrl(options?.baseUrl);
+        const customProxy = isCustomBaseUrl(options?.baseUrl);
+        // When using any custom/proxy base URL (OpenRouter, LiteLLM, vLLM, Together, etc.),
+        // route ALL models through the OpenAI chat/completions adapter instead of native SDKs
+        // which would reject the proxy's API key.
+        if (!openRouter && !customProxy) {
+            if (options?.model?.startsWith('gemini')) {
+                // Gemini client uses its own SDK; allow passing the already-resolved id for transparency/logging.
+                return createGeminiClient(key, options.model, options.resolvedModelId);
+            }
+            if (options?.model?.startsWith('claude')) {
+                return createClaudeClient(key, options.model, options.resolvedModelId, options.baseUrl);
+            }
         }
         let instance;
-        const openRouter = isOpenRouterBaseUrl(options?.baseUrl);
         const defaultHeaders = openRouter ? buildOpenRouterHeaders() : undefined;
         const httpTimeoutMs = typeof options?.httpTimeoutMs === 'number' && Number.isFinite(options.httpTimeoutMs) && options.httpTimeoutMs > 0
             ? options.httpTimeoutMs
             : 20 * 60 * 1000;
         if (options?.azure?.endpoint) {
-            instance = new AzureOpenAI({
+            instance = new OpenAI({
                 apiKey: key,
-                endpoint: options.azure.endpoint,
-                apiVersion: options.azure.apiVersion,
-                deployment: options.azure.deployment,
                 timeout: httpTimeoutMs,
+                baseURL: buildAzureResponsesBaseUrl(options.azure.endpoint),
             });
         }
         else {
@@ -39,7 +68,7 @@ export function createDefaultClientFactory() {
                 defaultHeaders,
             });
         }
-        if (openRouter) {
+        if (openRouter || customProxy) {
             return buildOpenRouterCompletionClient(instance);
         }
         return {