@steipete/oracle 1.2.0 → 1.3.0

package/dist/src/oracle/gemini.js

@@ -0,0 +1,161 @@
+import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold, } from '@google/generative-ai';
+const MODEL_ID_MAP = {
+    'gemini-3-pro': 'gemini-3-pro-preview',
+    'gpt-5-pro': 'gpt-5-pro', // unused, normalize TS map
+    'gpt-5.1': 'gpt-5.1',
+};
+export function resolveGeminiModelId(modelName) {
+    // Map our logical Gemini names to the exact model ids expected by the SDK.
+    return MODEL_ID_MAP[modelName] ?? modelName;
+}
+export function createGeminiClient(apiKey, modelName = 'gemini-3-pro', resolvedModelId) {
+    const genAI = new GoogleGenerativeAI(apiKey);
+    const modelId = resolvedModelId ?? resolveGeminiModelId(modelName);
+    const model = genAI.getGenerativeModel({ model: modelId });
+    const adaptBodyToGemini = (body) => {
+        const contents = body.input.map((inputItem) => ({
+            role: inputItem.role === 'user' ? 'user' : 'model',
+            parts: inputItem.content
+                .map((contentPart) => {
+                if (contentPart.type === 'input_text') {
+                    return { text: contentPart.text };
+                }
+                return null;
+            })
+                .filter((part) => part !== null),
+        }));
+        const tools = body.tools
+            ?.map((tool) => {
+            if (tool.type === 'web_search_preview') {
+                return {
+                    googleSearch: {},
+                };
+            }
+            return {};
+        })
+            .filter((t) => Object.keys(t).length > 0);
+        const generationConfig = {
+            maxOutputTokens: body.max_output_tokens,
+        };
+        const safetySettings = [
+            {
+                category: HarmCategory.HARM_CATEGORY_HARASSMENT,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+            {
+                category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+            {
+                category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+            {
+                category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+        ];
+        const systemInstruction = body.instructions || undefined;
+        return { systemInstruction, contents, tools, generationConfig, safetySettings };
+    };
+    const adaptGeminiResponseToOracle = (geminiResponse) => {
+        const outputText = [];
+        const output = [];
+        geminiResponse.candidates?.forEach((candidate) => {
+            candidate.content?.parts?.forEach((part) => {
+                if (part.text) {
+                    outputText.push(part.text);
+                    output.push({ type: 'text', text: part.text });
+                }
+            });
+        });
+        const usage = {
+            input_tokens: geminiResponse.usageMetadata?.promptTokenCount || 0,
+            output_tokens: geminiResponse.usageMetadata?.candidatesTokenCount || 0,
+            total_tokens: (geminiResponse.usageMetadata?.promptTokenCount || 0) + (geminiResponse.usageMetadata?.candidatesTokenCount || 0),
+        };
+        return {
+            id: `gemini-${Date.now()}`, // Gemini doesn't always provide a stable ID in the response object
+            status: 'completed',
+            output_text: outputText,
+            output,
+            usage,
+        };
+    };
+    const enrichGeminiError = (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('404')) {
+            return new Error(`Gemini model not available to this API key/region. Confirm preview access and model ID (${modelId}). Original: ${message}`);
+        }
+        return error instanceof Error ? error : new Error(message);
+    };
+    return {
+        responses: {
+            stream: (body) => {
+                const geminiBody = adaptBodyToGemini(body);
+                let finalResponsePromise = null;
+                const collectChunkText = (chunk) => {
+                    const parts = [];
+                    chunk.candidates?.forEach((candidate) => {
+                        candidate.content?.parts?.forEach((part) => {
+                            if (part.text) {
+                                parts.push(part.text);
+                            }
+                        });
+                    });
+                    return parts.join('');
+                };
+                async function* iterator() {
+                    let streamingResp;
+                    try {
+                        streamingResp = await model.generateContentStream(geminiBody);
+                    }
+                    catch (error) {
+                        throw enrichGeminiError(error);
+                    }
+                    for await (const chunk of streamingResp.stream) {
+                        const text = collectChunkText(chunk);
+                        if (text) {
+                            yield { type: 'chunk', delta: text };
+                        }
+                    }
+                    finalResponsePromise = streamingResp.response.then(adaptGeminiResponseToOracle);
+                }
+                const generator = iterator();
+                return {
+                    [Symbol.asyncIterator]: () => generator,
+                    finalResponse: async () => {
+                        // Ensure the stream has been consumed or at least started to get the promise
+                        if (!finalResponsePromise) {
+                            // In case the user calls finalResponse before iterating, we need to consume the stream
+                            // This is a bit edge-casey but safe.
+                            for await (const _ of generator) { }
+                        }
+                        if (!finalResponsePromise) {
+                            throw new Error('Response promise not initialized');
+                        }
+                        return finalResponsePromise;
+                    }
+                };
+            },
+            create: async (body) => {
+                const geminiBody = adaptBodyToGemini(body);
+                let result;
+                try {
+                    result = await model.generateContent(geminiBody);
+                }
+                catch (error) {
+                    throw enrichGeminiError(error);
+                }
+                return adaptGeminiResponseToOracle(result.response);
+            },
+            retrieve: async (id) => {
+                return {
+                    id,
+                    status: 'error',
+                    error: { message: 'Retrieve by ID not supported for Gemini API yet.' },
+                };
+            },
+        },
+    };
+}

package/dist/src/oracle/logging.js

@@ -0,0 +1,36 @@
+export function maskApiKey(key) {
+    if (!key)
+        return null;
+    if (key.length <= 8)
+        return `${key[0] ?? ''}***${key[key.length - 1] ?? ''}`;
+    const prefix = key.slice(0, 4);
+    const suffix = key.slice(-4);
+    return `${prefix}****${suffix}`;
+}
+export function formatBaseUrlForLog(raw) {
+    if (!raw)
+        return '';
+    try {
+        const parsed = new URL(raw);
+        const segments = parsed.pathname.split('/').filter(Boolean);
+        let path = '';
+        if (segments.length > 0) {
+            path = `/${segments[0]}`;
+            if (segments.length > 1) {
+                path += '/...';
+            }
+        }
+        const allowedQueryKeys = ['api-version'];
+        const maskedQuery = allowedQueryKeys
+            .filter((key) => parsed.searchParams.has(key))
+            .map((key) => `${key}=***`);
+        const query = maskedQuery.length > 0 ? `?${maskedQuery.join('&')}` : '';
+        return `${parsed.protocol}//${parsed.host}${path}${query}`;
+    }
+    catch {
+        const trimmed = raw.trim();
+        if (trimmed.length <= 64)
+            return trimmed;
+        return `${trimmed.slice(0, 32)}…${trimmed.slice(-8)}`;
+    }
+}

package/dist/src/oracle/oscProgress.js

@@ -29,11 +29,17 @@ export function supportsOscProgress(env = process.env, isTty = process.stdout.is
     return false;
 }
 export function startOscProgress(options = {}) {
-    const { label = 'Waiting for OpenAI', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text) } = options;
+    const { label = 'Waiting for API', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text), indeterminate = false, } = options;
     if (!supportsOscProgress(options.env, options.isTty)) {
         return () => { };
     }
     const cleanLabel = sanitizeLabel(label);
+    if (indeterminate) {
+        write(`${OSC}3;;${cleanLabel}${ST}`);
+        return () => {
+            write(`${OSC}0;0;${cleanLabel}${ST}`);
+        };
+    }
     const target = Math.max(targetMs, 1_000);
     const send = (state, percent) => {
         const clamped = Math.max(0, Math.min(100, Math.round(percent)));

package/dist/src/oracle/run.js

@@ -13,30 +13,26 @@ import { formatElapsed, formatUSD } from './format.js';
 import { getFileTokenStats, printFileTokenStats } from './tokenStats.js';
 import { OracleResponseError, OracleTransportError, PromptValidationError, describeTransportError, toTransportError, } from './errors.js';
 import { createDefaultClientFactory } from './client.js';
+import { formatBaseUrlForLog, maskApiKey } from './logging.js';
 import { startHeartbeat } from '../heartbeat.js';
 import { startOscProgress } from './oscProgress.js';
 import { getCliVersion } from '../version.js';
 import { createFsAdapter } from './fsAdapter.js';
-const isTty = process.stdout.isTTY;
+import { resolveGeminiModelId } from './gemini.js';
+const isTty = process.stdout.isTTY && chalk.level > 0;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
 const BACKGROUND_MAX_WAIT_MS = 30 * 60 * 1000;
 const BACKGROUND_POLL_INTERVAL_MS = 5000;
 const BACKGROUND_RETRY_BASE_MS = 3000;
 const BACKGROUND_RETRY_MAX_MS = 15000;
+const DEFAULT_TIMEOUT_NON_PRO_MS = 30_000;
+const DEFAULT_TIMEOUT_PRO_MS = 20 * 60 * 1000;
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
 export async function runOracle(options, deps = {}) {
-    const { apiKey = options.apiKey ?? process.env.OPENAI_API_KEY, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write = (text) => process.stdout.write(text), now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
-    const maskApiKey = (key) => {
-        if (!key)
-            return null;
-        if (key.length <= 8)
-            return `${key[0] ?? ''}***${key[key.length - 1] ?? ''}`;
-        const prefix = key.slice(0, 4);
-        const suffix = key.slice(-4);
-        return `${prefix}****${suffix}`;
-    };
+    const { apiKey: optionsApiKey = options.apiKey, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write = (text) => process.stdout.write(text), now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
+    const baseUrl = options.baseUrl?.trim() || process.env.OPENAI_BASE_URL?.trim();
     const logVerbose = (message) => {
         if (options.verbose) {
             log(dim(`[verbose] ${message}`));
@@ -44,15 +40,22 @@ export async function runOracle(options, deps = {}) {
     };
     const previewMode = resolvePreviewMode(options.previewMode ?? options.preview);
     const isPreview = Boolean(previewMode);
+    const getApiKeyForModel = (model) => {
+        if (model.startsWith('gpt')) {
+            return optionsApiKey ?? process.env.OPENAI_API_KEY;
+        }
+        if (model.startsWith('gemini')) {
+            return optionsApiKey ?? process.env.GEMINI_API_KEY;
+        }
+        return undefined;
+    };
+    const envVar = options.model.startsWith('gpt') ? 'OPENAI_API_KEY' : 'GEMINI_API_KEY';
+    const apiKey = getApiKeyForModel(options.model);
     if (!apiKey) {
-        throw new PromptValidationError('Missing OPENAI_API_KEY. Set it via the environment or a .env file.', {
-            env: 'OPENAI_API_KEY',
+        throw new PromptValidationError(`Missing ${envVar}. Set it via the environment or a .env file.`, {
+            env: envVar,
         });
     }
-    const maskedKey = maskApiKey(apiKey);
-    if (maskedKey) {
-        log(dim(`Using OPENAI_API_KEY=${maskedKey}`));
-    }
     const modelConfig = MODEL_CONFIGS[options.model];
     if (!modelConfig) {
         throw new PromptValidationError(`Unsupported model "${options.model}". Choose one of: ${Object.keys(MODEL_CONFIGS).join(', ')}`, { model: options.model });
@@ -62,6 +65,8 @@ export async function runOracle(options, deps = {}) {
     const files = await readFiles(options.file ?? [], { cwd, fsModule });
     const searchEnabled = options.search !== false;
     logVerbose(`cwd: ${cwd}`);
+    let pendingNoFilesTip = null;
+    let pendingShortPromptTip = null;
     if (files.length > 0) {
         const displayPaths = files
             .map((file) => path.relative(cwd, file.path) || file.path)
@@ -73,9 +78,15 @@ export async function runOracle(options, deps = {}) {
     else {
         logVerbose('No files attached.');
         if (!isPreview) {
-            log(dim('Tip: no files attached — Oracle works best with project context. Add files via --file path/to/code or docs.'));
+            pendingNoFilesTip =
+                'Tip: no files attached — Oracle works best with project context. Add files via --file path/to/code or docs.';
         }
     }
+    const shortPrompt = (options.prompt?.trim().length ?? 0) < 80;
+    if (!isPreview && shortPrompt) {
+        pendingShortPromptTip =
+            'Tip: brief prompts often yield generic answers — aim for 6–30 sentences and attach key files.';
+    }
     const fileTokenInfo = getFileTokenStats(files, {
         cwd,
         tokenizer: modelConfig.tokenizer,
@@ -89,6 +100,15 @@ export async function runOracle(options, deps = {}) {
     const fileCount = files.length;
     const cliVersion = getCliVersion();
     const richTty = process.stdout.isTTY && chalk.level > 0;
+    const timeoutSeconds = options.timeoutSeconds === undefined || options.timeoutSeconds === 'auto'
+        ? options.model === 'gpt-5-pro'
+            ? DEFAULT_TIMEOUT_PRO_MS / 1000
+            : DEFAULT_TIMEOUT_NON_PRO_MS / 1000
+        : options.timeoutSeconds;
+    const timeoutMs = timeoutSeconds * 1000;
+    // Track the concrete model id we dispatch to (especially for Gemini preview aliases)
+    const effectiveModelId = options.effectiveModelId ??
+        (options.model.startsWith('gemini') ? resolveGeminiModelId(options.model) : modelConfig.model);
     const headerModelLabel = richTty ? chalk.cyan(modelConfig.model) : modelConfig.model;
     const requestBody = buildRequestBody({
         modelConfig,
@@ -102,10 +122,25 @@ export async function runOracle(options, deps = {}) {
     const estimatedInputTokens = estimateRequestTokens(requestBody, modelConfig);
     const tokenLabel = richTty ? chalk.green(estimatedInputTokens.toLocaleString()) : estimatedInputTokens.toLocaleString();
     const fileLabel = richTty ? chalk.magenta(fileCount.toString()) : fileCount.toString();
-    const headerLine = `oracle (${cliVersion}) consulting ${headerModelLabel}'s crystal ball with ${tokenLabel} tokens and ${fileLabel} files...`;
+    const filesPhrase = fileCount === 0 ? 'no files' : `${fileLabel} files`;
+    const headerLine = `🧿 oracle (${cliVersion}) summons ${headerModelLabel} — ${tokenLabel} tokens, ${filesPhrase}`;
     const shouldReportFiles = (options.filesReport || fileTokenInfo.totalTokens > inputTokenBudget) && fileTokenInfo.stats.length > 0;
     if (!isPreview) {
         log(headerLine);
+        const maskedKey = maskApiKey(apiKey);
+        if (maskedKey) {
+            const resolvedSuffix = options.model.startsWith('gemini') && effectiveModelId !== modelConfig.model ? ` (resolved: ${effectiveModelId})` : '';
+            log(dim(`Using ${envVar}=${maskedKey} for model ${modelConfig.model}${resolvedSuffix}`));
+        }
+        if (baseUrl) {
+            log(dim(`Base URL: ${formatBaseUrlForLog(baseUrl)}`));
+        }
+        if (pendingNoFilesTip) {
+            log(dim(pendingNoFilesTip));
+        }
+        if (pendingShortPromptTip) {
+            log(dim(pendingShortPromptTip));
+        }
         if (options.model === 'gpt-5-pro') {
             log(dim('Pro is thinking, this can take up to 30 minutes...'));
         }
@@ -138,11 +173,22 @@ export async function runOracle(options, deps = {}) {
             inputTokenBudget,
         };
     }
-    const openAiClient = client ?? clientFactory(apiKey);
-    logVerbose('Dispatching request to OpenAI Responses API...');
+    const apiEndpoint = modelConfig.model.startsWith('gemini') ? undefined : baseUrl;
+    const clientInstance = client ??
+        clientFactory(apiKey, {
+            baseUrl: apiEndpoint,
+            azure: options.azure,
+            model: options.model,
+            resolvedModelId: effectiveModelId,
+        });
+    logVerbose('Dispatching request to API...');
+    if (options.verbose) {
+        log(''); // ensure verbose section is separated from Answer stream
+    }
     const stopOscProgress = startOscProgress({
-        label: useBackground ? 'Waiting for OpenAI (background)' : 'Waiting for OpenAI',
-        targetMs: useBackground ? BACKGROUND_MAX_WAIT_MS : 10 * 60_000,
+        label: useBackground ? 'Waiting for API (background)' : 'Waiting for API',
+        targetMs: useBackground ? timeoutMs : Math.min(timeoutMs, 10 * 60_000),
+        indeterminate: true,
         write,
     });
     const runStart = now();
@@ -150,6 +196,12 @@ export async function runOracle(options, deps = {}) {
     let elapsedMs = 0;
     let sawTextDelta = false;
     let answerHeaderPrinted = false;
+    const timeoutExceeded = () => now() - runStart >= timeoutMs;
+    const throwIfTimedOut = () => {
+        if (timeoutExceeded()) {
+            throw new OracleTransportError('client-timeout', `Timed out waiting for API response after ${formatElapsed(timeoutMs)}.`);
+        }
+    };
     const ensureAnswerHeader = () => {
         if (!options.silent && !answerHeaderPrinted) {
             log('');
@@ -160,17 +212,18 @@ export async function runOracle(options, deps = {}) {
     try {
         if (useBackground) {
             response = await executeBackgroundResponse({
-                client: openAiClient,
+                client: clientInstance,
                 requestBody,
                 log,
                 wait,
                 heartbeatIntervalMs: options.heartbeatIntervalMs,
                 now,
+                maxWaitMs: timeoutMs,
             });
             elapsedMs = now() - runStart;
         }
         else {
-            const stream = await openAiClient.responses.stream(requestBody);
+            const stream = await clientInstance.responses.stream(requestBody);
             let heartbeatActive = false;
             let stopHeartbeat = null;
             const stopHeartbeatNow = () => {
@@ -189,13 +242,16 @@ export async function runOracle(options, deps = {}) {
                     isActive: () => heartbeatActive,
                     makeMessage: (elapsedMs) => {
                         const elapsedText = formatElapsed(elapsedMs);
-                        return `API connection active — ${elapsedText} elapsed. Expect up to ~10 min before GPT-5 responds.`;
+                        const timeoutLabel = Math.round(timeoutMs / 60000);
+                        return `API connection active — ${elapsedText} elapsed. Timeout in ~${timeoutLabel} min if no response.`;
                     },
                 });
             }
             try {
                 for await (const event of stream) {
-                    if (event.type === 'response.output_text.delta') {
+                    throwIfTimedOut();
+                    const isTextDelta = event.type === 'chunk' || event.type === 'response.output_text.delta';
+                    if (isTextDelta) {
                         stopOscProgress();
                         stopHeartbeatNow();
                         sawTextDelta = true;
@@ -205,17 +261,17 @@ export async function runOracle(options, deps = {}) {
                         }
                     }
                 }
+                throwIfTimedOut();
             }
             catch (streamError) {
-                if (typeof stream.abort === 'function') {
-                    stream.abort();
-                }
+                // stream.abort() is not available on the interface
                 stopHeartbeatNow();
                 const transportError = toTransportError(streamError);
                 log(chalk.yellow(describeTransportError(transportError)));
                 throw transportError;
             }
             response = await stream.finalResponse();
+            throwIfTimedOut();
             stopHeartbeatNow();
             elapsedMs = now() - runStart;
         }
@@ -224,11 +280,16 @@ export async function runOracle(options, deps = {}) {
         stopOscProgress();
     }
     if (!response) {
-        throw new Error('OpenAI did not return a response.');
+        throw new Error('API did not return a response.');
+    }
+    // biome-ignore lint/nursery/noUnnecessaryConditions: we only add spacing when any streamed text was printed
+    if (sawTextDelta && !options.silent) {
+        write('\n');
+        log('');
     }
     logVerbose(`Response status: ${response.status ?? 'completed'}`);
     if (response.status && response.status !== 'completed') {
-        // OpenAI can reply `in_progress` even after the stream closes; give it a brief grace poll.
+        // API can reply `in_progress` even after the stream closes; give it a brief grace poll.
         if (response.id && response.status === 'in_progress') {
             const polishingStart = now();
             const pollIntervalMs = 2_000;
@@ -237,7 +298,7 @@ export async function runOracle(options, deps = {}) {
             // Short polling loop — we don't want to hang forever, just catch late finalization.
             while (now() - polishingStart < maxWaitMs) {
                 await wait(pollIntervalMs);
-                const refreshed = await openAiClient.responses.retrieve(response.id);
+                const refreshed = await clientInstance.responses.retrieve(response.id);
                 if (refreshed.status === 'completed') {
                     response = refreshed;
                     break;
@@ -246,7 +307,7 @@ export async function runOracle(options, deps = {}) {
         }
         if (response.status !== 'completed') {
             const detail = response.error?.message || response.incomplete_details?.reason || response.status;
-            log(chalk.yellow(`OpenAI ended the run early (status=${response.status}${response.incomplete_details?.reason ? `, reason=${response.incomplete_details.reason}` : ''}).`));
+            log(chalk.yellow(`API ended the run early (status=${response.status}${response.incomplete_details?.reason ? `, reason=${response.incomplete_details.reason}` : ''}).`));
             throw new OracleResponseError(`Response did not complete: ${detail}`, response);
         }
     }
@@ -254,7 +315,7 @@ export async function runOracle(options, deps = {}) {
     if (!options.silent) {
         // biome-ignore lint/nursery/noUnnecessaryConditions: flips true when streaming events arrive
         if (sawTextDelta) {
-            write('\n\n');
+            write('\n');
         }
         else {
             ensureAnswerHeader();
@@ -276,7 +337,8 @@ export async function runOracle(options, deps = {}) {
     const tokensDisplay = [inputTokens, outputTokens, reasoningTokens, totalTokens]
         .map((value, index) => formatTokenValue(value, usage, index))
         .join('/');
-    statsParts.push(`tok(i/o/r/t)=${tokensDisplay}`);
+    const tokensLabel = options.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
+    statsParts.push(`${tokensLabel}=${tokensDisplay}`);
     const actualInput = usage.input_tokens;
     if (actualInput !== undefined) {
         const delta = actualInput - estimatedInputTokens;
@@ -289,7 +351,8 @@ export async function runOracle(options, deps = {}) {
     if (files.length > 0) {
         statsParts.push(`files=${files.length}`);
     }
-    log(chalk.blue(`Finished in ${elapsedDisplay} (${statsParts.join(' | ')})`));
+    const sessionPrefix = options.sessionId ? `${options.sessionId} ` : '';
+    log(chalk.blue(`Finished ${sessionPrefix}in ${elapsedDisplay} (${statsParts.join(' | ')})`));
     return {
         mode: 'live',
         response,
@@ -338,13 +401,13 @@ export function extractTextOutput(response) {
     return '';
 }
 async function executeBackgroundResponse(params) {
-    const { client, requestBody, log, wait, heartbeatIntervalMs, now } = params;
+    const { client, requestBody, log, wait, heartbeatIntervalMs, now, maxWaitMs } = params;
     const initialResponse = await client.responses.create(requestBody);
     if (!initialResponse || !initialResponse.id) {
-        throw new OracleResponseError('OpenAI did not return a response ID for the background run.', initialResponse);
+        throw new OracleResponseError('API did not return a response ID for the background run.', initialResponse);
     }
     const responseId = initialResponse.id;
-    log(dim(`OpenAI scheduled background response ${responseId} (status=${initialResponse.status ?? 'unknown'}). Monitoring up to ${Math.round(BACKGROUND_MAX_WAIT_MS / 60000)} minutes for completion...`));
+    log(dim(`API scheduled background response ${responseId} (status=${initialResponse.status ?? 'unknown'}). Monitoring up to ${Math.round(BACKGROUND_MAX_WAIT_MS / 60000)} minutes for completion...`));
     let heartbeatActive = false;
     let stopHeartbeat = null;
     const stopHeartbeatNow = () => {
@@ -363,7 +426,7 @@ async function executeBackgroundResponse(params) {
             isActive: () => heartbeatActive,
             makeMessage: (elapsedMs) => {
                 const elapsedText = formatElapsed(elapsedMs);
-                return `OpenAI background run still in progress — ${elapsedText} elapsed.`;
+                return `API background run still in progress — ${elapsedText} elapsed.`;
             },
         });
     }
@@ -375,7 +438,7 @@ async function executeBackgroundResponse(params) {
             log,
             wait,
             now,
-            maxWaitMs: BACKGROUND_MAX_WAIT_MS,
+            maxWaitMs,
         });
     }
     finally {
@@ -394,10 +457,10 @@ async function pollBackgroundResponse(params) {
         // biome-ignore lint/nursery/noUnnecessaryConditions: guard only for first iteration
         if (firstCycle) {
             firstCycle = false;
-            log(dim(`OpenAI background response status=${status}. We'll keep retrying automatically.`));
+            log(dim(`API background response status=${status}. We'll keep retrying automatically.`));
         }
         else if (status !== lastStatus && status !== 'completed') {
-            log(dim(`OpenAI background response status=${status}.`));
+            log(dim(`API background response status=${status}.`));
         }
         lastStatus = status;
         if (status === 'completed') {
@@ -408,11 +471,11 @@ async function pollBackgroundResponse(params) {
             throw new OracleResponseError(`Response did not complete: ${detail}`, response);
         }
         if (now() - startMark >= maxWaitMs) {
-            throw new OracleTransportError('client-timeout', 'Timed out waiting for OpenAI background response to finish.');
+            throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
         }
         await wait(BACKGROUND_POLL_INTERVAL_MS);
         if (now() - startMark >= maxWaitMs) {
-            throw new OracleTransportError('client-timeout', 'Timed out waiting for OpenAI background response to finish.');
+            throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
         }
         const { response: nextResponse, reconnected } = await retrieveBackgroundResponseWithRetry({
             client,
@@ -425,7 +488,7 @@ async function pollBackgroundResponse(params) {
         });
         if (reconnected) {
             const nextStatus = nextResponse.status ?? 'in_progress';
-            log(dim(`Reconnected to OpenAI background response (status=${nextStatus}). OpenAI is still working...`));
+            log(dim(`Reconnected to API background response (status=${nextStatus}). API is still working...`));
         }
         response = nextResponse;
     }
@@ -449,7 +512,7 @@ async function retrieveBackgroundResponseWithRetry(params) {
             log(chalk.yellow(`${describeTransportError(transportError)} Retrying in ${formatElapsed(delay)}...`));
             await wait(delay);
             if (now() - startMark >= maxWaitMs) {
-                throw new OracleTransportError('client-timeout', 'Timed out waiting for OpenAI background response to finish.');
+                throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
             }
         }
     }

package/dist/src/oracle.js

@@ -7,3 +7,4 @@ export { getFileTokenStats, printFileTokenStats } from './oracle/tokenStats.js';
 export { OracleResponseError, OracleTransportError, OracleUserError, FileValidationError, BrowserAutomationError, PromptValidationError, describeTransportError, extractResponseMetadata, asOracleUserError, toTransportError, } from './oracle/errors.js';
 export { createDefaultClientFactory } from './oracle/client.js';
 export { runOracle, extractTextOutput } from './oracle/run.js';
+export { resolveGeminiModelId } from './oracle/gemini.js';

package/dist/src/sessionManager.js

@@ -104,6 +104,8 @@ export async function initializeSession(options, cwd, notifications) {
             browserBundleFiles: options.browserBundleFiles,
             background: options.background,
             search: options.search,
+            baseUrl: options.baseUrl,
+            azure: options.azure,
         },
     };
     await fs.writeFile(metaPath(sessionId), JSON.stringify(metadata, null, 2), 'utf8');