@huyuan-ai/cli 1.0.4 → 1.2.0

package/vendor/opencli/dist/clis/gemini/deep-research.js

@@ -0,0 +1,98 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { GEMINI_DEEP_RESEARCH_DEFAULT_CONFIRM_LABELS, GEMINI_DEEP_RESEARCH_DEFAULT_TOOL_LABELS, GEMINI_APP_URL, GEMINI_DOMAIN, getCurrentGeminiUrl, getLatestGeminiAssistantResponse, parseGeminiPositiveInt, readGeminiSnapshot, resolveGeminiLabels, selectGeminiTool, sendGeminiMessage, startNewGeminiChat, waitForGeminiSubmission, waitForGeminiConfirmButton, } from './utils.js';
+function isGeminiRootAppUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.origin + parsed.pathname.replace(/\/+$/, '') === GEMINI_APP_URL;
+    }
+    catch {
+        return false;
+    }
+}
+function parseDeepResearchProgress(text) {
+    const isResearching = /\bresearching(?:\s+websites?)?\b|research in progress|working on your research|正在研究|研究中/i.test(text);
+    const waitingForStart = /\bstart(?:\s+deep)?\s+research\b|begin\s+research|generate(?:\s+deep)?\s+research\s+plan|开始研究|开始深度研究|开始调研|生成研究计划|生成调研计划|try again without deep research/i.test(text);
+    return { isResearching, waitingForStart };
+}
+export const deepResearchCommand = cli({
+    site: 'gemini',
+    name: 'deep-research',
+    description: 'Start a Gemini Deep Research run and confirm it',
+    domain: GEMINI_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    defaultFormat: 'plain',
+    timeoutSeconds: 180,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for confirm (default: 30)', default: 30 },
+        { name: 'tool', required: false, help: 'Override tool label (default: Deep Research)' },
+        { name: 'confirm', required: false, help: 'Override confirm button label (default: Start research)' },
+    ],
+    columns: ['status', 'url'],
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const timeout = parseGeminiPositiveInt(kwargs.timeout, 30);
+        const submitTimeout = Math.min(Math.max(timeout, 6), 20);
+        await startNewGeminiChat(page);
+        const toolLabels = resolveGeminiLabels(kwargs.tool, GEMINI_DEEP_RESEARCH_DEFAULT_TOOL_LABELS);
+        const confirmLabels = resolveGeminiLabels(kwargs.confirm, GEMINI_DEEP_RESEARCH_DEFAULT_CONFIRM_LABELS);
+        const toolMatched = await selectGeminiTool(page, toolLabels);
+        if (!toolMatched) {
+            const url = await getCurrentGeminiUrl(page);
+            return [{ status: 'tool-not-found', url }];
+        }
+        let baseline = await readGeminiSnapshot(page);
+        await sendGeminiMessage(page, prompt);
+        let submitted = await waitForGeminiSubmission(page, baseline, submitTimeout);
+        if (!submitted) {
+            // Retry once when submit did not stick (e.g. composer swallowed Enter/click in this UI state).
+            await selectGeminiTool(page, toolLabels);
+            baseline = await readGeminiSnapshot(page);
+            await sendGeminiMessage(page, prompt);
+            submitted = await waitForGeminiSubmission(page, baseline, submitTimeout);
+        }
+        if (!submitted) {
+            const url = await getCurrentGeminiUrl(page);
+            return [{ status: 'submit-not-found', url }];
+        }
+        const confirmed = await waitForGeminiConfirmButton(page, confirmLabels, timeout);
+        let url = await getCurrentGeminiUrl(page);
+        if (confirmed && !isGeminiRootAppUrl(url)) {
+            return [{ status: 'started', url }];
+        }
+        // false-positive confirm click can happen on generic buttons while still at /app root.
+        {
+            // Retry once when we are still at the root app URL, which usually means submit did not stick.
+            if (isGeminiRootAppUrl(url)) {
+                await selectGeminiTool(page, toolLabels);
+                // Avoid resending prompt here: it can create a duplicate conversation thread.
+                const confirmedRetry = await waitForGeminiConfirmButton(page, confirmLabels, timeout);
+                url = await getCurrentGeminiUrl(page);
+                if (confirmedRetry && !isGeminiRootAppUrl(url)) {
+                    return [{ status: 'started', url }];
+                }
+            }
+            let response = await getLatestGeminiAssistantResponse(page);
+            let { isResearching, waitingForStart } = parseDeepResearchProgress(response);
+            // Some UIs render the plan card first; click confirm one more time without resending prompt.
+            if (!isResearching && waitingForStart) {
+                const fallbackConfirmLabels = Array.from(new Set([
+                    ...confirmLabels,
+                    ...GEMINI_DEEP_RESEARCH_DEFAULT_CONFIRM_LABELS,
+                ]));
+                const confirmedFallback = await waitForGeminiConfirmButton(page, fallbackConfirmLabels, Math.min(timeout, 8));
+                if (confirmedFallback) {
+                    url = await getCurrentGeminiUrl(page);
+                    response = await getLatestGeminiAssistantResponse(page);
+                    ({ isResearching, waitingForStart } = parseDeepResearchProgress(response));
+                }
+            }
+            if (isResearching && !waitingForStart) {
+                return [{ status: 'started', url }];
+            }
+            return [{ status: 'confirm-not-found', url }];
+        }
+    },
+});

package/vendor/opencli/dist/clis/gemini/deep-research.test.js

@@ -0,0 +1,184 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockGetCurrentGeminiUrl, mockReadGeminiSnapshot, mockSelectGeminiTool, mockSendGeminiMessage, mockStartNewGeminiChat, mockWaitForGeminiSubmission, mockWaitForGeminiConfirmButton, mockGetLatestGeminiAssistantResponse, } = vi.hoisted(() => ({
+    mockGetCurrentGeminiUrl: vi.fn(),
+    mockReadGeminiSnapshot: vi.fn(),
+    mockSelectGeminiTool: vi.fn(),
+    mockSendGeminiMessage: vi.fn(),
+    mockStartNewGeminiChat: vi.fn(),
+    mockWaitForGeminiSubmission: vi.fn(),
+    mockWaitForGeminiConfirmButton: vi.fn(),
+    mockGetLatestGeminiAssistantResponse: vi.fn(),
+}));
+vi.mock('./utils.js', () => ({
+    GEMINI_DOMAIN: 'gemini.google.com',
+    GEMINI_APP_URL: 'https://gemini.google.com/app',
+    GEMINI_DEEP_RESEARCH_DEFAULT_TOOL_LABELS: ['Deep Research', 'Deep research', '\u6df1\u5ea6\u7814\u7a76'],
+    GEMINI_DEEP_RESEARCH_DEFAULT_CONFIRM_LABELS: [
+        'Start research',
+        'Start Research',
+        'Start deep research',
+        'Start Deep Research',
+        'Generate research plan',
+        'Generate Research Plan',
+        'Generate deep research plan',
+        'Generate Deep Research Plan',
+        '\u5f00\u59cb\u7814\u7a76',
+        '\u5f00\u59cb\u6df1\u5ea6\u7814\u7a76',
+        '\u5f00\u59cb\u8c03\u7814',
+        '\u751f\u6210\u7814\u7a76\u8ba1\u5212',
+        '\u751f\u6210\u8c03\u7814\u8ba1\u5212',
+    ],
+    parseGeminiPositiveInt: (value, fallback) => {
+        const parsed = Number.parseInt(String(value ?? ''), 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    },
+    resolveGeminiLabels: (value, fallback) => {
+        const label = String(value ?? '').trim();
+        return label ? [label] : fallback;
+    },
+    getCurrentGeminiUrl: mockGetCurrentGeminiUrl,
+    getLatestGeminiAssistantResponse: mockGetLatestGeminiAssistantResponse,
+    readGeminiSnapshot: mockReadGeminiSnapshot,
+    selectGeminiTool: mockSelectGeminiTool,
+    sendGeminiMessage: mockSendGeminiMessage,
+    startNewGeminiChat: mockStartNewGeminiChat,
+    waitForGeminiSubmission: mockWaitForGeminiSubmission,
+    waitForGeminiConfirmButton: mockWaitForGeminiConfirmButton,
+}));
+import { deepResearchCommand } from './deep-research.js';
+describe('gemini/deep-research', () => {
+    const page = {};
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGetCurrentGeminiUrl.mockResolvedValue('https://gemini.google.com/app/chat');
+        mockReadGeminiSnapshot.mockResolvedValue({
+            turns: [],
+            transcriptLines: [],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: true,
+        });
+        mockSelectGeminiTool.mockResolvedValue('Deep Research');
+        mockSendGeminiMessage.mockResolvedValue();
+        mockStartNewGeminiChat.mockResolvedValue();
+        mockWaitForGeminiSubmission.mockResolvedValue({
+            snapshot: { turns: [], transcriptLines: [], composerHasText: false, isGenerating: false, structuredTurnsTrusted: true },
+            preSendAssistantCount: 0,
+            userAnchorTurn: null,
+            reason: 'user_turn',
+        });
+        mockWaitForGeminiConfirmButton.mockResolvedValue('Start research');
+        mockGetLatestGeminiAssistantResponse.mockResolvedValue('');
+    });
+    it('starts a new chat by default, then sends prompt and confirms deep research', async () => {
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(mockStartNewGeminiChat).toHaveBeenCalledTimes(1);
+        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(1);
+        expect(mockSendGeminiMessage).toHaveBeenCalledWith(page, 'research this topic');
+        expect(mockWaitForGeminiSubmission).toHaveBeenCalledTimes(1);
+        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledWith(page, expect.arrayContaining(['Start research', 'Start deep research', 'Generate research plan', '\u751f\u6210\u7814\u7a76\u8ba1\u5212']), 30);
+        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/chat' }]);
+    });
+    it('returns tool-not-found when the tool cannot be selected', async () => {
+        mockSelectGeminiTool.mockResolvedValue('');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(result).toEqual([{ status: 'tool-not-found', url: 'https://gemini.google.com/app/chat' }]);
+        expect(mockSendGeminiMessage).not.toHaveBeenCalled();
+        expect(mockWaitForGeminiSubmission).not.toHaveBeenCalled();
+        expect(mockWaitForGeminiConfirmButton).not.toHaveBeenCalled();
+    });
+    it('retries send once when first submission cannot be confirmed', async () => {
+        mockWaitForGeminiSubmission.mockResolvedValueOnce(null).mockResolvedValueOnce({
+            snapshot: { turns: [], transcriptLines: [], composerHasText: false, isGenerating: false, structuredTurnsTrusted: true },
+            preSendAssistantCount: 0,
+            userAnchorTurn: null,
+            reason: 'user_turn',
+        });
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
+        expect(mockReadGeminiSnapshot).toHaveBeenCalledTimes(2);
+        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(2);
+        expect(mockWaitForGeminiSubmission).toHaveBeenCalledTimes(2);
+        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/chat' }]);
+    });
+    it('returns submit-not-found when submission cannot be confirmed after retry', async () => {
+        mockWaitForGeminiSubmission.mockResolvedValue(null);
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
+        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(2);
+        expect(mockWaitForGeminiConfirmButton).not.toHaveBeenCalled();
+        expect(result).toEqual([{ status: 'submit-not-found', url: 'https://gemini.google.com/app/chat' }]);
+    });
+    it('returns confirm-not-found when no confirm button is found', async () => {
+        mockWaitForGeminiConfirmButton.mockResolvedValue('');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(result).toEqual([{ status: 'confirm-not-found', url: 'https://gemini.google.com/app/chat' }]);
+    });
+    it('returns started when confirm is missing but research appears to be running', async () => {
+        mockWaitForGeminiConfirmButton.mockResolvedValue('');
+        mockGetCurrentGeminiUrl.mockResolvedValue('https://gemini.google.com/app/abc123');
+        mockGetLatestGeminiAssistantResponse.mockResolvedValue('Researching websites now');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/abc123' }]);
+    });
+    it('does not treat conversation url alone as started when confirm is missing', async () => {
+        mockWaitForGeminiConfirmButton.mockResolvedValue('');
+        mockGetCurrentGeminiUrl.mockResolvedValue('https://gemini.google.com/app/abc999');
+        mockGetLatestGeminiAssistantResponse.mockResolvedValue('I drafted a plan. Start research');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic' });
+        expect(result).toEqual([{ status: 'confirm-not-found', url: 'https://gemini.google.com/app/abc999' }]);
+    });
+    it('retries once when stuck on root app URL and starts successfully on second confirm', async () => {
+        mockWaitForGeminiConfirmButton.mockResolvedValueOnce('').mockResolvedValueOnce('Start research');
+        mockGetCurrentGeminiUrl.mockResolvedValueOnce('https://gemini.google.com/app').mockResolvedValueOnce('https://gemini.google.com/app/retry123');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic', timeout: '20' });
+        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
+        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
+        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledTimes(2);
+        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/retry123' }]);
+    });
+    it('treats root-url confirm as false-positive and retries', async () => {
+        mockWaitForGeminiConfirmButton.mockResolvedValueOnce('Start research').mockResolvedValueOnce('Start research');
+        mockGetCurrentGeminiUrl.mockResolvedValueOnce('https://gemini.google.com/app').mockResolvedValueOnce('https://gemini.google.com/app/retry456');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic', timeout: '20' });
+        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
+        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
+        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/retry456' }]);
+    });
+    it('does not resend prompt during root-url retry to avoid duplicate chats', async () => {
+        mockWaitForGeminiConfirmButton.mockResolvedValueOnce('Start research').mockResolvedValueOnce('');
+        mockGetCurrentGeminiUrl.mockResolvedValueOnce('https://gemini.google.com/app').mockResolvedValueOnce('https://gemini.google.com/app');
+        mockGetLatestGeminiAssistantResponse.mockResolvedValue('');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic', timeout: '20' });
+        expect(mockSelectGeminiTool).toHaveBeenCalledTimes(2);
+        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
+        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledTimes(2);
+        expect(result).toEqual([{ status: 'confirm-not-found', url: 'https://gemini.google.com/app' }]);
+    });
+    it('attempts one more confirm click when still waiting for start research', async () => {
+        mockWaitForGeminiConfirmButton
+            .mockResolvedValueOnce('')
+            .mockResolvedValueOnce('Start research');
+        mockGetCurrentGeminiUrl
+            .mockResolvedValueOnce('https://gemini.google.com/app/xyz123')
+            .mockResolvedValueOnce('https://gemini.google.com/app/xyz123');
+        mockGetLatestGeminiAssistantResponse
+            .mockResolvedValueOnce('I drafted a plan. Start research')
+            .mockResolvedValueOnce('Researching websites now');
+        const result = await deepResearchCommand.func(page, { prompt: 'research this topic', timeout: '20' });
+        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledTimes(2);
+        expect(mockWaitForGeminiConfirmButton).toHaveBeenNthCalledWith(2, page, expect.arrayContaining(['Start research', 'Start deep research', '开始研究', '开始深度研究']), 8);
+        expect(mockSendGeminiMessage).toHaveBeenCalledTimes(1);
+        expect(result).toEqual([{ status: 'started', url: 'https://gemini.google.com/app/xyz123' }]);
+    });
+    it('uses custom tool/confirm labels when provided', async () => {
+        await deepResearchCommand.func(page, {
+            prompt: 'research this topic',
+            tool: 'Custom Tool',
+            confirm: 'Custom Confirm',
+            timeout: '42',
+        });
+        expect(mockSelectGeminiTool).toHaveBeenCalledWith(page, ['Custom Tool']);
+        expect(mockWaitForGeminiConfirmButton).toHaveBeenCalledWith(page, ['Custom Confirm'], 42);
+    });
+});

package/vendor/opencli/dist/clis/gemini/image.d.ts

@@ -1 +1 @@
-export declare const imageCommand: import("../../registry.js").CliCommand;
+export declare const imageCommand: import("@jackwener/opencli/registry").CliCommand;

package/vendor/opencli/dist/clis/gemini/image.js

@@ -1,7 +1,7 @@
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { cli, Strategy } from '../../registry.js';
-import { saveBase64ToFile } from '../../utils.js';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { saveBase64ToFile } from '@jackwener/opencli/utils';
 import { GEMINI_DOMAIN, exportGeminiImages, getGeminiVisibleImageUrls, sendGeminiMessage, startNewGeminiChat, waitForGeminiImages } from './utils.js';
 function extFromMime(mime) {
     if (mime.includes('png'))

package/vendor/opencli/dist/clis/gemini/new.d.ts

@@ -1 +1 @@
-export declare const newCommand: import("../../registry.js").CliCommand;
+export declare const newCommand: import("@jackwener/opencli/registry").CliCommand;

package/vendor/opencli/dist/clis/gemini/new.js

@@ -1,4 +1,4 @@
-import { cli, Strategy } from '../../registry.js';
+import { cli, Strategy } from '@jackwener/opencli/registry';
 import { GEMINI_DOMAIN, startNewGeminiChat } from './utils.js';
 export const newCommand = cli({
     site: 'gemini',

package/vendor/opencli/dist/clis/gemini/reply-state.test.js

@@ -287,6 +287,36 @@ describe('Gemini submission state', () => {
         }), 2);
         expect(result).toBeNull();
     });
+    it('does not confirm transcript-only submission while url remains /app root', async () => {
+        const page = createPageMock();
+        const evaluate = vi.mocked(page.evaluate);
+        evaluate
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            url: 'https://gemini.google.com/app',
+            turns: [],
+            transcriptLines: ['baseline', 'prompt'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: false,
+        })
+            .mockResolvedValueOnce('https://gemini.google.com/app')
+            .mockResolvedValueOnce({
+            url: 'https://gemini.google.com/app',
+            turns: [],
+            transcriptLines: ['baseline', 'prompt'],
+            composerHasText: false,
+            isGenerating: false,
+            structuredTurnsTrusted: false,
+        });
+        const result = await waitForGeminiSubmission(page, snapshot({
+            url: 'https://gemini.google.com/app',
+            transcriptLines: ['baseline'],
+            composerHasText: true,
+            structuredTurnsTrusted: false,
+        }), 2);
+        expect(result).toBeNull();
+    });
     it('keeps polling past ten seconds when the overall timeout budget still allows submission confirmation', async () => {
         const page = createPageMock();
         const evaluate = vi.mocked(page.evaluate);

package/vendor/opencli/dist/clis/gemini/utils.d.ts

@@ -1,6 +1,8 @@
-import type { IPage } from '../../types.js';
+import type { IPage } from '@jackwener/opencli/types';
 export declare const GEMINI_DOMAIN = "gemini.google.com";
 export declare const GEMINI_APP_URL = "https://gemini.google.com/app";
+export declare const GEMINI_DEEP_RESEARCH_DEFAULT_TOOL_LABELS: string[];
+export declare const GEMINI_DEEP_RESEARCH_DEFAULT_CONFIRM_LABELS: string[];
 export interface GeminiPageState {
     url: string;
     title: string;
@@ -12,7 +14,13 @@ export interface GeminiTurn {
     Role: 'User' | 'Assistant' | 'System';
     Text: string;
 }
+export interface GeminiConversation {
+    Title: string;
+    Url: string;
+}
+export type GeminiTitleMatchMode = 'contains' | 'exact';
 export interface GeminiSnapshot {
+    url?: string;
     turns: GeminiTurn[];
     transcriptLines: string[];
     composerHasText: boolean;
@@ -31,6 +39,13 @@ export interface GeminiSubmissionBaseline {
     userAnchorTurn: GeminiTurn | null;
     reason: 'user_turn' | 'composer_generating' | 'composer_transcript';
 }
+export declare function resolveGeminiLabels(value: unknown, fallback: string[]): string[];
+export declare function parseGeminiPositiveInt(value: unknown, fallback: number): number;
+export declare function parseGeminiTitleMatchMode(value: unknown, fallback?: GeminiTitleMatchMode): GeminiTitleMatchMode | null;
+export declare function parseGeminiConversationUrl(value: unknown): string | null;
+export declare function normalizeGeminiTitle(value: string): string;
+export declare function pickGeminiConversationByTitle(conversations: GeminiConversation[], query: string, mode?: GeminiTitleMatchMode): GeminiConversation | null;
+export declare function resolveGeminiConversationForQuery(conversations: GeminiConversation[], query: string, mode: GeminiTitleMatchMode): GeminiConversation | null;
 export declare function sanitizeGeminiResponseText(value: string, promptText: string): string;
 export declare function collectGeminiTranscriptAdditions(beforeLines: string[], currentLines: string[], promptText: string): string;
 export declare function collapseAdjacentGeminiTurns(turns: GeminiTurn[]): GeminiTurn[];
@@ -43,13 +58,27 @@ declare function submitComposerScript(): string;
 declare function clickNewChatScript(): string;
 export declare function isOnGemini(page: IPage): Promise<boolean>;
 export declare function ensureGeminiPage(page: IPage): Promise<void>;
+export declare function getCurrentGeminiUrl(page: IPage): Promise<string>;
+export declare function openGeminiToolsMenu(page: IPage): Promise<boolean>;
+export declare function selectGeminiTool(page: IPage, labels: string[]): Promise<string>;
+export declare function waitForGeminiConfirmButton(page: IPage, labels: string[], timeoutSeconds: number): Promise<string>;
 export declare function getGeminiPageState(page: IPage): Promise<GeminiPageState>;
 export declare function startNewGeminiChat(page: IPage): Promise<'clicked' | 'navigate'>;
+export declare function getGeminiConversationList(page: IPage): Promise<GeminiConversation[]>;
+export declare function clickGeminiConversationByTitle(page: IPage, query: string): Promise<boolean>;
 export declare function getGeminiVisibleTurns(page: IPage): Promise<GeminiTurn[]>;
 export declare function getGeminiTranscriptLines(page: IPage): Promise<string[]>;
+export declare function waitForGeminiTranscript(page: IPage, attempts?: number): Promise<string[]>;
+export declare function getLatestGeminiAssistantResponse(page: IPage): Promise<string>;
 export declare function readGeminiSnapshot(page: IPage): Promise<GeminiSnapshot>;
 export declare function waitForGeminiSubmission(page: IPage, before: GeminiSnapshot, timeoutSeconds: number): Promise<GeminiSubmissionBaseline | null>;
 export declare function sendGeminiMessage(page: IPage, text: string): Promise<'button' | 'enter'>;
+export interface GeminiDeepResearchExportResult {
+    url: string;
+    source: 'network' | 'window-open' | 'anchor' | 'performance' | 'blob' | 'tab' | 'none';
+}
+export declare function pickGeminiDeepResearchExportUrl(rawUrls: string[], currentUrl: string): GeminiDeepResearchExportResult;
+export declare function exportGeminiDeepResearchReport(page: IPage, timeoutSeconds?: number): Promise<GeminiDeepResearchExportResult>;
 export declare const __test__: {
     GEMINI_COMPOSER_SELECTORS: string[];
     GEMINI_COMPOSER_MARKER_ATTR: string;