@steipete/oracle 0.6.1 → 0.7.1

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

@@ -0,0 +1,328 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+const MODEL_HEADER_NAME = 'x-goog-ext-525001261-jspb';
+const MODEL_HEADERS = {
+    'gemini-3-pro': '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
+    'gemini-2.5-pro': '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
+    'gemini-2.5-flash': '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]',
+};
+const GEMINI_APP_URL = 'https://gemini.google.com/app';
+const GEMINI_STREAM_GENERATE_URL = 'https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate';
+const GEMINI_UPLOAD_URL = 'https://content-push.googleapis.com/upload';
+const GEMINI_UPLOAD_PUSH_ID = 'feeds/mcudyrk2a4khkz';
+function getNestedValue(value, pathParts, fallback) {
+    let current = value;
+    for (const part of pathParts) {
+        if (current == null)
+            return fallback;
+        if (typeof part === 'number') {
+            if (!Array.isArray(current))
+                return fallback;
+            current = current[part];
+        }
+        else {
+            if (typeof current !== 'object')
+                return fallback;
+            current = current[part];
+        }
+    }
+    return current ?? fallback;
+}
+function buildCookieHeader(cookieMap) {
+    return Object.entries(cookieMap)
+        .filter(([, value]) => typeof value === 'string' && value.length > 0)
+        .map(([name, value]) => `${name}=${value}`)
+        .join('; ');
+}
+export async function fetchGeminiAccessToken(cookieMap, signal) {
+    const cookieHeader = buildCookieHeader(cookieMap);
+    const res = await fetch(GEMINI_APP_URL, {
+        redirect: 'follow',
+        signal,
+        headers: {
+            cookie: cookieHeader,
+            'user-agent': USER_AGENT,
+        },
+    });
+    const html = await res.text();
+    const tokens = ['SNlM0e', 'thykhd'];
+    for (const key of tokens) {
+        const match = html.match(new RegExp(`"${key}":"(.*?)"`));
+        if (match?.[1])
+            return match[1];
+    }
+    throw new Error('Unable to locate Gemini access token on gemini.google.com/app (missing SNlM0e/thykhd).');
+}
+function trimGeminiJsonEnvelope(text) {
+    const start = text.indexOf('[');
+    const end = text.lastIndexOf(']');
+    if (start === -1 || end === -1 || end <= start) {
+        throw new Error('Gemini response did not contain a JSON payload.');
+    }
+    return text.slice(start, end + 1);
+}
+function extractErrorCode(responseJson) {
+    const code = getNestedValue(responseJson, [0, 5, 2, 0, 1, 0], -1);
+    return typeof code === 'number' && code >= 0 ? code : undefined;
+}
+function extractGgdlUrls(rawText) {
+    const matches = rawText.match(/https:\/\/lh3\.googleusercontent\.com\/gg-dl\/[^\s"']+/g) ?? [];
+    const seen = new Set();
+    const urls = [];
+    for (const match of matches) {
+        if (seen.has(match))
+            continue;
+        seen.add(match);
+        urls.push(match);
+    }
+    return urls;
+}
+function ensureFullSizeImageUrl(url) {
+    if (url.includes('=s2048'))
+        return url;
+    if (url.includes('=s'))
+        return url;
+    return `${url}=s2048`;
+}
+async function fetchWithCookiePreservingRedirects(url, init, signal, maxRedirects = 10) {
+    let current = url;
+    for (let i = 0; i <= maxRedirects; i += 1) {
+        const res = await fetch(current, { ...init, redirect: 'manual', signal });
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get('location');
+            if (!location)
+                return res;
+            current = new URL(location, current).toString();
+            continue;
+        }
+        return res;
+    }
+    throw new Error(`Too many redirects while downloading image (>${maxRedirects}).`);
+}
+async function downloadGeminiImage(url, cookieMap, outputPath, signal) {
+    const cookieHeader = buildCookieHeader(cookieMap);
+    const res = await fetchWithCookiePreservingRedirects(ensureFullSizeImageUrl(url), {
+        headers: {
+            cookie: cookieHeader,
+            'user-agent': USER_AGENT,
+        },
+    }, signal);
+    if (!res.ok) {
+        throw new Error(`Failed to download image: ${res.status} ${res.statusText} (${res.url})`);
+    }
+    const data = new Uint8Array(await res.arrayBuffer());
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, data);
+}
+async function uploadGeminiFile(filePath, signal) {
+    const absPath = path.resolve(process.cwd(), filePath);
+    const data = await readFile(absPath);
+    const fileName = path.basename(absPath);
+    const form = new FormData();
+    form.append('file', new Blob([data]), fileName);
+    const res = await fetch(GEMINI_UPLOAD_URL, {
+        method: 'POST',
+        redirect: 'follow',
+        signal,
+        headers: {
+            'push-id': GEMINI_UPLOAD_PUSH_ID,
+            'user-agent': USER_AGENT,
+        },
+        body: form,
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`File upload failed: ${res.status} ${res.statusText} (${text.slice(0, 200)})`);
+    }
+    return { id: text, name: fileName };
+}
+function buildGeminiFReqPayload(prompt, uploaded, chatMetadata) {
+    const promptPayload = uploaded.length > 0
+        ? [
+            prompt,
+            0,
+            null,
+            // Matches gemini-webapi payload format: [[[fileId, 1]]] for a single attachment.
+            // Keep it extensible for multiple uploads by emitting one [[id, 1]] entry per file.
+            uploaded.map((file) => [[file.id, 1]]),
+        ]
+        : [prompt];
+    const innerList = [promptPayload, null, chatMetadata ?? null];
+    return JSON.stringify([null, JSON.stringify(innerList)]);
+}
+export function parseGeminiStreamGenerateResponse(rawText) {
+    const responseJson = JSON.parse(trimGeminiJsonEnvelope(rawText));
+    const errorCode = extractErrorCode(responseJson);
+    const parts = Array.isArray(responseJson) ? responseJson : [];
+    let bodyIndex = 0;
+    let body = null;
+    for (let i = 0; i < parts.length; i += 1) {
+        const partBody = getNestedValue(parts[i], [2], null);
+        if (!partBody)
+            continue;
+        try {
+            const parsed = JSON.parse(partBody);
+            const candidateList = getNestedValue(parsed, [4], []);
+            if (Array.isArray(candidateList) && candidateList.length > 0) {
+                bodyIndex = i;
+                body = parsed;
+                break;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const candidateList = getNestedValue(body, [4], []);
+    const firstCandidate = candidateList[0];
+    const textRaw = getNestedValue(firstCandidate, [1, 0], '');
+    const cardContent = /^http:\/\/googleusercontent\.com\/card_content\/\d+/.test(textRaw);
+    const text = cardContent
+        ? (getNestedValue(firstCandidate, [22, 0], null) ?? textRaw)
+        : textRaw;
+    const thoughts = getNestedValue(firstCandidate, [37, 0, 0], null);
+    const metadata = getNestedValue(body, [1], []);
+    const images = [];
+    const webImages = getNestedValue(firstCandidate, [12, 1], []);
+    for (const webImage of webImages) {
+        const url = getNestedValue(webImage, [0, 0, 0], null);
+        if (!url)
+            continue;
+        images.push({
+            kind: 'web',
+            url,
+            title: getNestedValue(webImage, [7, 0], undefined),
+            alt: getNestedValue(webImage, [0, 4], undefined),
+        });
+    }
+    const hasGenerated = Boolean(getNestedValue(firstCandidate, [12, 7, 0], null));
+    if (hasGenerated) {
+        let imgBody = null;
+        for (let i = bodyIndex; i < parts.length; i += 1) {
+            const partBody = getNestedValue(parts[i], [2], null);
+            if (!partBody)
+                continue;
+            try {
+                const parsed = JSON.parse(partBody);
+                const candidateImages = getNestedValue(parsed, [4, 0, 12, 7, 0], null);
+                if (candidateImages != null) {
+                    imgBody = parsed;
+                    break;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const imgCandidate = getNestedValue(imgBody ?? body, [4, 0], null);
+        const generated = getNestedValue(imgCandidate, [12, 7, 0], []);
+        for (const genImage of generated) {
+            const url = getNestedValue(genImage, [0, 3, 3], null);
+            if (!url)
+                continue;
+            images.push({
+                kind: 'generated',
+                url,
+                title: '[Generated Image]',
+                alt: '',
+            });
+        }
+    }
+    return { metadata, text, thoughts, images, errorCode };
+}
+export function isGeminiModelUnavailable(errorCode) {
+    return errorCode === 1052;
+}
+export async function runGeminiWebOnce(input) {
+    const cookieHeader = buildCookieHeader(input.cookieMap);
+    const at = await fetchGeminiAccessToken(input.cookieMap, input.signal);
+    const uploaded = [];
+    for (const file of input.files ?? []) {
+        if (input.signal?.aborted) {
+            throw new Error('Gemini web run aborted before upload.');
+        }
+        uploaded.push(await uploadGeminiFile(file, input.signal));
+    }
+    const fReq = buildGeminiFReqPayload(input.prompt, uploaded, input.chatMetadata ?? null);
+    const params = new URLSearchParams();
+    params.set('at', at);
+    params.set('f.req', fReq);
+    const res = await fetch(GEMINI_STREAM_GENERATE_URL, {
+        method: 'POST',
+        redirect: 'follow',
+        signal: input.signal,
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded;charset=utf-8',
+            origin: 'https://gemini.google.com',
+            referer: 'https://gemini.google.com/',
+            'x-same-domain': '1',
+            'user-agent': USER_AGENT,
+            cookie: cookieHeader,
+            [MODEL_HEADER_NAME]: MODEL_HEADERS[input.model],
+        },
+        body: params.toString(),
+    });
+    const rawResponseText = await res.text();
+    if (!res.ok) {
+        return {
+            rawResponseText,
+            text: '',
+            thoughts: null,
+            metadata: input.chatMetadata ?? null,
+            images: [],
+            errorMessage: `Gemini request failed: ${res.status} ${res.statusText}`,
+        };
+    }
+    try {
+        const parsed = parseGeminiStreamGenerateResponse(rawResponseText);
+        return {
+            rawResponseText,
+            text: parsed.text ?? '',
+            thoughts: parsed.thoughts,
+            metadata: parsed.metadata,
+            images: parsed.images,
+            errorCode: parsed.errorCode,
+        };
+    }
+    catch (error) {
+        let responseJson = null;
+        try {
+            responseJson = JSON.parse(trimGeminiJsonEnvelope(rawResponseText));
+        }
+        catch {
+            responseJson = null;
+        }
+        const errorCode = extractErrorCode(responseJson);
+        return {
+            rawResponseText,
+            text: '',
+            thoughts: null,
+            metadata: input.chatMetadata ?? null,
+            images: [],
+            errorCode: typeof errorCode === 'number' ? errorCode : undefined,
+            errorMessage: error instanceof Error ? error.message : String(error ?? ''),
+        };
+    }
+}
+export async function runGeminiWebWithFallback(input) {
+    const attempt = await runGeminiWebOnce(input);
+    if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== 'gemini-2.5-flash') {
+        const fallback = await runGeminiWebOnce({ ...input, model: 'gemini-2.5-flash' });
+        return { ...fallback, effectiveModel: 'gemini-2.5-flash' };
+    }
+    return { ...attempt, effectiveModel: input.model };
+}
+export async function saveFirstGeminiImageFromOutput(output, cookieMap, outputPath, signal) {
+    const generatedOrWeb = output.images.find((img) => img.kind === 'generated') ?? output.images[0];
+    if (generatedOrWeb?.url) {
+        await downloadGeminiImage(generatedOrWeb.url, cookieMap, outputPath, signal);
+        return { saved: true, imageCount: output.images.length };
+    }
+    const ggdl = extractGgdlUrls(output.rawResponseText);
+    if (ggdl[0]) {
+        await downloadGeminiImage(ggdl[0], cookieMap, outputPath, signal);
+        return { saved: true, imageCount: ggdl.length };
+    }
+    return { saved: false, imageCount: 0 };
+}

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

@@ -0,0 +1,224 @@
+import path from 'node:path';
+import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
+function estimateTokenCount(text) {
+    return Math.ceil(text.length / 4);
+}
+function resolveInvocationPath(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
+}
+function resolveGeminiWebModel(desiredModel, log) {
+    const desired = typeof desiredModel === 'string' ? desiredModel.trim() : '';
+    if (!desired)
+        return 'gemini-3-pro';
+    switch (desired) {
+        case 'gemini-3-pro':
+        case 'gemini-3.0-pro':
+            return 'gemini-3-pro';
+        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-')) {
+                log?.(`[gemini-web] Unsupported Gemini web model "${desired}". Falling back to gemini-3-pro.`);
+            }
+            return 'gemini-3-pro';
+    }
+}
+async function loadGeminiCookiesFromChrome(browserConfig, log) {
+    try {
+        const mod = (await import('chrome-cookies-secure'));
+        const chromeCookies = mod.default ??
+            mod;
+        const profile = typeof browserConfig?.chromeProfile === 'string' &&
+            browserConfig.chromeProfile.trim().length > 0
+            ? browserConfig.chromeProfile.trim()
+            : undefined;
+        const sources = [
+            'https://gemini.google.com',
+            'https://accounts.google.com',
+            'https://www.google.com',
+        ];
+        const wantNames = [
+            '__Secure-1PSID',
+            '__Secure-1PSIDTS',
+            '__Secure-1PSIDCC',
+            '__Secure-1PAPISID',
+            'NID',
+            'AEC',
+            'SOCS',
+            '__Secure-BUCKET',
+            '__Secure-ENID',
+            'SID',
+            'HSID',
+            'SSID',
+            'APISID',
+            'SAPISID',
+            '__Secure-3PSID',
+            '__Secure-3PSIDTS',
+            '__Secure-3PAPISID',
+            'SIDCC',
+        ];
+        const cookieMap = {};
+        for (const url of sources) {
+            const cookies = (await chromeCookies.getCookiesPromised(url, 'puppeteer', profile));
+            for (const name of wantNames) {
+                if (cookieMap[name])
+                    continue;
+                const matches = cookies.filter((cookie) => cookie.name === name);
+                if (matches.length === 0)
+                    continue;
+                const preferredDomain = matches.find((cookie) => cookie.domain === '.google.com' && (cookie.path ?? '/') === '/');
+                const googleDomain = matches.find((cookie) => (cookie.domain ?? '').endsWith('google.com'));
+                const value = (preferredDomain ?? googleDomain ?? matches[0])?.value;
+                if (value)
+                    cookieMap[name] = value;
+            }
+        }
+        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
+            return {};
+        }
+        log?.(`[gemini-web] Loaded Gemini cookies from Chrome (node): ${Object.keys(cookieMap).length} cookie(s).`);
+        return cookieMap;
+    }
+    catch (error) {
+        log?.(`[gemini-web] Failed to load Chrome cookies via node: ${error instanceof Error ? error.message : String(error ?? '')}`);
+        return {};
+    }
+}
+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 loadGeminiCookiesFromChrome(runOptions.config, log);
+        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
+            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 generateImagePath = resolveInvocationPath(geminiOptions.generateImage);
+        const editImagePath = resolveInvocationPath(geminiOptions.editImage);
+        const outputPath = resolveInvocationPath(geminiOptions.outputPath);
+        const attachmentPaths = (runOptions.attachments ?? []).map((attachment) => attachment.path);
+        let prompt = runOptions.prompt;
+        if (geminiOptions.aspectRatio && (generateImagePath || editImagePath)) {
+            prompt = `${prompt} (aspect ratio: ${geminiOptions.aspectRatio})`;
+        }
+        if (geminiOptions.youtube) {
+            prompt = `${prompt}\n\nYouTube video: ${geminiOptions.youtube}`;
+        }
+        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)'}`);
+                }
+            }
+            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,
+                };
+                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)'}`);
+                }
+            }
+            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,
+                };
+            }
+        }
+        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,
+        };
+    };
+}

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

@@ -0,0 +1 @@
+export { createGeminiWebExecutor } from './executor.js';

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

@@ -0,0 +1 @@
+export {};

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

@@ -129,7 +129,10 @@ export function registerConsultTool(server) {
         let browserConfig;
         if (resolvedEngine === 'browser') {
             const preferredLabel = (browserModelLabel ?? model)?.trim();
-            const desiredModelLabel = resolveBrowserModelLabel(preferredLabel, runOptions.model);
+            const isChatGptModel = runOptions.model.startsWith('gpt-') && !runOptions.model.includes('codex');
+            const desiredModelLabel = isChatGptModel
+                ? mapModelToBrowserLabel(runOptions.model)
+                : resolveBrowserModelLabel(preferredLabel, runOptions.model);
             // Keep the browser path minimal; only forward a desired model label for the ChatGPT picker.
             browserConfig = {
                 url: CHATGPT_URL,

package/dist/src/oracle/config.js

@@ -2,7 +2,7 @@ import { countTokens as countTokensGpt5 } from 'gpt-tokenizer/model/gpt-5';
 import { countTokens as countTokensGpt5Pro } from 'gpt-tokenizer/model/gpt-5-pro';
 import { countTokens as countTokensAnthropicRaw } from '@anthropic-ai/tokenizer';
 import { stringifyTokenizerInput } from './tokenStringifier.js';
-export const DEFAULT_MODEL = 'gpt-5.1-pro';
+export const DEFAULT_MODEL = 'gpt-5.2-pro';
 export const PRO_MODELS = new Set(['gpt-5.1-pro', 'gpt-5-pro', 'gpt-5.2-pro', 'claude-4.5-sonnet', 'claude-4.1-opus']);
 const countTokensAnthropic = (input) => countTokensAnthropicRaw(stringifyTokenizerInput(input));
 export const MODEL_CONFIGS = {

package/dist/src/oracle/run.js

@@ -191,7 +191,6 @@ export async function runOracle(options, deps = {}) {
         (options.model.startsWith('gemini')
             ? resolveGeminiModelId(options.model)
             : (modelConfig.apiModel ?? modelConfig.model));
-    const headerModelLabel = richTty ? chalk.cyan(modelConfig.model) : modelConfig.model;
     const requestBody = buildRequestBody({
         modelConfig,
         systemPrompt,
@@ -205,7 +204,13 @@ export async function runOracle(options, deps = {}) {
     const tokenLabel = formatTokenEstimate(estimatedInputTokens, (text) => (richTty ? chalk.green(text) : text));
     const fileLabel = richTty ? chalk.magenta(fileCount.toString()) : fileCount.toString();
     const filesPhrase = fileCount === 0 ? 'no files' : `${fileLabel} files`;
-    const headerLine = `Calling ${headerModelLabel} — ${tokenLabel} tokens, ${filesPhrase}.`;
+    const headerModelLabelBase = richTty ? chalk.cyan(modelConfig.model) : modelConfig.model;
+    const headerModelSuffix = effectiveModelId !== modelConfig.model
+        ? richTty
+            ? chalk.gray(` (API: ${effectiveModelId})`)
+            : ` (API: ${effectiveModelId})`
+        : '';
+    const headerLine = `Calling ${headerModelLabelBase}${headerModelSuffix} — ${tokenLabel} tokens, ${filesPhrase}.`;
     const shouldReportFiles = (options.filesReport || fileTokenInfo.totalTokens > inputTokenBudget) && fileTokenInfo.stats.length > 0;
     if (!isPreview) {
         if (!options.suppressHeader) {
@@ -213,9 +218,14 @@ export async function runOracle(options, deps = {}) {
         }
         const maskedKey = maskApiKey(apiKey);
         if (maskedKey && options.verbose) {
-            const resolvedSuffix = effectiveModelId !== modelConfig.model ? ` (resolved: ${effectiveModelId})` : '';
+            const resolvedSuffix = effectiveModelId !== modelConfig.model ? ` (API: ${effectiveModelId})` : '';
             log(dim(`Using ${envVar}=${maskedKey} for model ${modelConfig.model}${resolvedSuffix}`));
         }
+        if (!options.suppressHeader &&
+            modelConfig.model === 'gpt-5.1-pro' &&
+            effectiveModelId === 'gpt-5.2-pro') {
+            log(dim('Note: `gpt-5.1-pro` is a stable CLI alias; OpenAI API uses `gpt-5.2-pro`.'));
+        }
         if (baseUrl) {
             log(dim(`Base URL: ${formatBaseUrlForLog(baseUrl)}`));
         }
@@ -442,10 +452,11 @@ export async function runOracle(options, deps = {}) {
         if (response.id && response.status === 'in_progress') {
             const polishingStart = now();
             const pollIntervalMs = 2_000;
-            const maxWaitMs = 60_000;
+            const maxWaitMs = 180_000;
             log(chalk.dim('Response still in_progress; polling until completion...'));
             // Short polling loop — we don't want to hang forever, just catch late finalization.
             while (now() - polishingStart < maxWaitMs) {
+                throwIfTimedOut();
                 await wait(pollIntervalMs);
                 const refreshed = await clientInstance.responses.retrieve(response.id);
                 if (refreshed.status === 'completed') {