lazy-gravity 0.0.2 → 0.0.3

package/dist/services/responseMonitor.js

@@ -0,0 +1,645 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseMonitor = exports.RESPONSE_SELECTORS = void 0;
+const logger_1 = require("../utils/logger");
+/** Lean DOM selectors for response extraction */
+exports.RESPONSE_SELECTORS = {
+    /** Scored selector approach for extracting response text.
+     *  Tie-breaking: newest wins (first found in reverse iteration).
+     *  DOM is normal order: index 0 = oldest, N-1 = newest.
+     *  Reverse iteration (N-1→0) visits newest first; strict > keeps it. */
+    RESPONSE_TEXT: `(() => {
+        const panel = document.querySelector('.antigravity-agent-side-panel');
+        const scopes = [panel, document].filter(Boolean);
+
+        const selectors = [
+            { sel: '.rendered-markdown', score: 10 },
+            { sel: '.leading-relaxed.select-text', score: 9 },
+            { sel: '.flex.flex-col.gap-y-3', score: 8 },
+            { sel: '[data-message-author-role="assistant"]', score: 7 },
+            { sel: '[data-message-role="assistant"]', score: 6 },
+            { sel: '[class*="assistant-message"]', score: 5 },
+            { sel: '[class*="message-content"]', score: 4 },
+            { sel: '[class*="markdown-body"]', score: 3 },
+            { sel: '.prose', score: 2 },
+        ];
+
+        const looksLikeActivityLog = (text) => {
+            const normalized = (text || '').trim().toLowerCase();
+            if (!normalized) return false;
+            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+            if (activityPattern.test(normalized) && normalized.length <= 220) return true;
+            if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
+            if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
+            return false;
+        };
+
+        const looksLikeFeedbackFooter = (text) => {
+            const normalized = (text || '').trim().toLowerCase().replace(/\\s+/g, ' ');
+            if (!normalized) return false;
+            return normalized === 'good bad' || normalized === 'good' || normalized === 'bad';
+        };
+
+        const isInsideExcludedContainer = (node) => {
+            if (node.closest('details')) return true;
+            if (node.closest('[class*="feedback"], footer')) return true;
+            return false;
+        };
+
+        const looksLikeToolOutput = (text) => {
+            const first = (text || '').trim().split('\\n')[0] || '';
+            if (/^[a-z0-9._-]+\\s*\\/\\s*[a-z0-9._-]+$/i.test(first)) return true;
+            if (/^full output written to\\b/i.test(first)) return true;
+            if (/^output\\.[a-z0-9._-]+(?:#l\\d+(?:-\\d+)?)?$/i.test(first)) return true;
+            var lower = (text || '').trim().toLowerCase();
+            if (/^title:\\s/.test(lower) && /\\surl:\\s/.test(lower) && /\\ssnippet:\\s/.test(lower)) return true;
+            if (/^(json|javascript|typescript|python|bash|sh|html|css|xml|yaml|yml|toml|sql|graphql|markdown|text|plaintext|log|ruby|go|rust|java|c|cpp|csharp|php|swift|kotlin)$/i.test(first)) return true;
+            return false;
+        };
+
+        const combinedSelector = selectors.map((s) => s.sel).join(', ');
+        const seen = new Set();
+
+        for (const scope of scopes) {
+            const nodes = scope.querySelectorAll(combinedSelector);
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const node = nodes[i];
+                if (!node || seen.has(node)) continue;
+                seen.add(node);
+                if (isInsideExcludedContainer(node)) continue;
+                const text = (node.innerText || node.textContent || '').replace(/\\r/g, '').trim();
+                if (!text || text.length < 2) continue;
+                if (looksLikeActivityLog(text)) continue;
+                if (looksLikeFeedbackFooter(text)) continue;
+                if (looksLikeToolOutput(text)) continue;
+                // Prefer recency first: return the newest acceptable node.
+                return text;
+            }
+        }
+
+        return null;
+    })()`,
+    /** Stop button detection via tooltip-id + text fallback */
+    STOP_BUTTON: `(() => {
+        const panel = document.querySelector('.antigravity-agent-side-panel');
+        const scopes = [panel, document].filter(Boolean);
+
+        for (const scope of scopes) {
+            const el = scope.querySelector('[data-tooltip-id="input-send-button-cancel-tooltip"]');
+            if (el) return { isGenerating: true };
+        }
+
+        const normalize = (value) => (value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+        const STOP_PATTERNS = [
+            /^stop$/,
+            /^stop generating$/,
+            /^stop response$/,
+            /^停止$/,
+            /^生成を停止$/,
+            /^応答を停止$/,
+        ];
+        const isStopLabel = (value) => {
+            const normalized = normalize(value);
+            if (!normalized) return false;
+            return STOP_PATTERNS.some((re) => re.test(normalized));
+        };
+        for (const scope of scopes) {
+            const buttons = scope.querySelectorAll('button, [role="button"]');
+            for (let i = 0; i < buttons.length; i++) {
+                const btn = buttons[i];
+                const labels = [
+                    btn.textContent || '',
+                    btn.getAttribute('aria-label') || '',
+                    btn.getAttribute('title') || '',
+                ];
+                if (labels.some(isStopLabel)) {
+                    return { isGenerating: true };
+                }
+            }
+        }
+
+        return { isGenerating: false };
+    })()`,
+    /** Click stop button via tooltip-id + text fallback */
+    CLICK_STOP_BUTTON: `(() => {
+        const panel = document.querySelector('.antigravity-agent-side-panel');
+        const scopes = [panel, document].filter(Boolean);
+
+        for (const scope of scopes) {
+            const el = scope.querySelector('[data-tooltip-id="input-send-button-cancel-tooltip"]');
+            if (el && typeof el.click === 'function') {
+                el.click();
+                return { ok: true, method: 'tooltip-id' };
+            }
+        }
+
+        const normalize = (value) => (value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+        const STOP_PATTERNS = [
+            /^stop$/,
+            /^stop generating$/,
+            /^stop response$/,
+            /^停止$/,
+            /^生成を停止$/,
+            /^応答を停止$/,
+        ];
+        const isStopLabel = (value) => {
+            const normalized = normalize(value);
+            if (!normalized) return false;
+            return STOP_PATTERNS.some((re) => re.test(normalized));
+        };
+        for (const scope of scopes) {
+            const buttons = scope.querySelectorAll('button, [role="button"]');
+            for (let i = 0; i < buttons.length; i++) {
+                const btn = buttons[i];
+                const labels = [
+                    btn.textContent || '',
+                    btn.getAttribute('aria-label') || '',
+                    btn.getAttribute('title') || '',
+                ];
+                if (labels.some(isStopLabel) && typeof btn.click === 'function') {
+                    btn.click();
+                    return { ok: true, method: 'text-fallback' };
+                }
+            }
+        }
+
+        return { ok: false, error: 'Stop button not found' };
+    })()`,
+    /** Diagnostic: dump ALL candidate text nodes with filter classification */
+    DUMP_ALL_TEXTS: `(() => {
+        const panel = document.querySelector('.antigravity-agent-side-panel');
+        const scopes = [panel, document].filter(Boolean);
+
+        const selectors = [
+            { sel: '.rendered-markdown', score: 10 },
+            { sel: '.leading-relaxed.select-text', score: 9 },
+            { sel: '.flex.flex-col.gap-y-3', score: 8 },
+            { sel: '[data-message-author-role="assistant"]', score: 7 },
+            { sel: '[data-message-role="assistant"]', score: 6 },
+            { sel: '[class*="assistant-message"]', score: 5 },
+            { sel: '[class*="message-content"]', score: 4 },
+            { sel: '[class*="markdown-body"]', score: 3 },
+            { sel: '.prose', score: 2 },
+        ];
+
+        const looksLikeActivityLog = (text) => {
+            const normalized = (text || '').trim().toLowerCase();
+            if (!normalized) return false;
+            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+            if (activityPattern.test(normalized) && normalized.length <= 220) return true;
+            if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
+            if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
+            return false;
+        };
+        const looksLikeFeedbackFooter = (text) => {
+            const normalized = (text || '').trim().toLowerCase().replace(/\\s+/g, ' ');
+            if (!normalized) return false;
+            return normalized === 'good bad' || normalized === 'good' || normalized === 'bad';
+        };
+        const isInsideExcludedContainer = (node) => {
+            if (node.closest('details')) return true;
+            if (node.closest('[class*="feedback"], footer')) return true;
+            return false;
+        };
+        const looksLikeToolOutput = (text) => {
+            const first = (text || '').trim().split('\\n')[0] || '';
+            if (/^[a-z0-9._-]+\\s*\\/\\s*[a-z0-9._-]+$/i.test(first)) return true;
+            if (/^full output written to\\b/i.test(first)) return true;
+            if (/^output\\.[a-z0-9._-]+(?:#l\\d+(?:-\\d+)?)?$/i.test(first)) return true;
+            var lower = (text || '').trim().toLowerCase();
+            if (/^title:\\s/.test(lower) && /\\surl:\\s/.test(lower) && /\\ssnippet:\\s/.test(lower)) return true;
+            if (/^(json|javascript|typescript|python|bash|sh|html|css|xml|yaml|yml|toml|sql|graphql|markdown|text|plaintext|log|ruby|go|rust|java|c|cpp|csharp|php|swift|kotlin)$/i.test(first)) return true;
+            return false;
+        };
+
+        const results = [];
+        const seen = new Set();
+
+        for (const scope of scopes) {
+            for (const { sel, score } of selectors) {
+                const nodes = scope.querySelectorAll(sel);
+                for (let i = nodes.length - 1; i >= 0; i--) {
+                    const node = nodes[i];
+                    if (!node || seen.has(node)) continue;
+                    seen.add(node);
+                    const text = (node.innerText || node.textContent || '').replace(/\\r/g, '').trim();
+                    let skip = null;
+                    if (!text || text.length < 2) skip = 'too-short';
+                    else if (isInsideExcludedContainer(node)) skip = 'excluded-container';
+                    else if (looksLikeActivityLog(text)) skip = 'activity-log';
+                    else if (looksLikeFeedbackFooter(text)) skip = 'feedback-footer';
+                    else if (looksLikeToolOutput(text)) skip = 'tool-output';
+                    const classes = (node.className || '').toString().slice(0, 80);
+                    results.push({
+                        sel,
+                        score,
+                        skip,
+                        len: text.length,
+                        classes,
+                        preview: text.slice(0, 120),
+                    });
+                }
+            }
+        }
+        return results;
+    })()`,
+    /** Extract process log entries (activity messages + tool output) from DOM */
+    PROCESS_LOGS: `(() => {
+        const panel = document.querySelector('.antigravity-agent-side-panel');
+        const scopes = [panel, document].filter(Boolean);
+
+        const selectors = [
+            { sel: '.rendered-markdown', score: 10 },
+            { sel: '.leading-relaxed.select-text', score: 9 },
+            { sel: '.flex.flex-col.gap-y-3', score: 8 },
+            { sel: '[data-message-author-role="assistant"]', score: 7 },
+            { sel: '[data-message-role="assistant"]', score: 6 },
+            { sel: '[class*="assistant-message"]', score: 5 },
+            { sel: '[class*="message-content"]', score: 4 },
+            { sel: '[class*="markdown-body"]', score: 3 },
+            { sel: '.prose', score: 2 },
+        ];
+
+        const looksLikeActivityLog = (text) => {
+            const normalized = (text || '').trim().toLowerCase();
+            if (!normalized) return false;
+            const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+            if (activityPattern.test(normalized) && normalized.length <= 220) return true;
+            if (/^initiating\\s/i.test(normalized) && normalized.length <= 500) return true;
+            if (/^thought for\\s/i.test(normalized) && normalized.length <= 500) return true;
+            return false;
+        };
+
+        const looksLikeToolOutput = (text) => {
+            const first = (text || '').trim().split('\\n')[0] || '';
+            if (/^[a-z0-9._-]+\\s*\\/\\s*[a-z0-9._-]+$/i.test(first)) return true;
+            if (/^full output written to\\b/i.test(first)) return true;
+            if (/^output\\.[a-z0-9._-]+(?:#l\\d+(?:-\\d+)?)?$/i.test(first)) return true;
+            var lower = (text || '').trim().toLowerCase();
+            if (/^title:\\s/.test(lower) && /\\surl:\\s/.test(lower) && /\\ssnippet:\\s/.test(lower)) return true;
+            if (/^(json|javascript|typescript|python|bash|sh|html|css|xml|yaml|yml|toml|sql|graphql|markdown|text|plaintext|log|ruby|go|rust|java|c|cpp|csharp|php|swift|kotlin)$/i.test(first)) return true;
+            return false;
+        };
+
+        const isInsideExcludedContainer = (node) => {
+            if (node.closest('details')) return true;
+            if (node.closest('[class*="feedback"], footer')) return true;
+            return false;
+        };
+
+        const results = [];
+        const seen = new Set();
+
+        for (const scope of scopes) {
+            for (const { sel } of selectors) {
+                const nodes = scope.querySelectorAll(sel);
+                for (let i = 0; i < nodes.length; i++) {
+                    const node = nodes[i];
+                    if (!node || seen.has(node)) continue;
+                    seen.add(node);
+                    if (isInsideExcludedContainer(node)) continue;
+                    const text = (node.innerText || node.textContent || '').replace(/\\r/g, '').trim();
+                    if (!text || text.length < 4) continue;
+                    if (looksLikeActivityLog(text) || looksLikeToolOutput(text)) {
+                        results.push(text.slice(0, 300));
+                    }
+                }
+            }
+        }
+
+        return results;
+    })()`,
+    /** Quota error detection */
+    QUOTA_ERROR: `(() => {
+        const panel = document.querySelector('.antigravity-agent-side-panel');
+        const scope = panel || document;
+
+        const errorSelectors = [
+            '[role="alert"]',
+            '[class*="error"]',
+            '[class*="warning"]',
+            '[class*="toast"]',
+            '[class*="banner"]',
+            '[class*="notification"]',
+            '[class*="alert"]',
+            '[class*="quota"]',
+            '[class*="rate-limit"]',
+        ];
+        const errorElements = scope.querySelectorAll(errorSelectors.join(', '));
+        for (const el of errorElements) {
+            if (el.closest('.rendered-markdown, .prose, pre, code, [data-message-author-role="assistant"], [data-message-role="assistant"], [class*="message-content"]')) {
+                continue;
+            }
+            const text = (el.textContent || '').trim().toLowerCase();
+            if (text.includes('model quota reached') || text.includes('rate limit') || text.includes('quota exceeded')) {
+                return true;
+            }
+        }
+        return false;
+    })()`,
+};
+/**
+ * Lean AI response monitor.
+ *
+ * Each poll makes exactly 3 CDP calls: stop button, quota, text extraction.
+ * Completion: stop button gone N consecutive times -> complete.
+ * Simple baseline suppression via string comparison.
+ * NO network event subscription.
+ */
+class ResponseMonitor {
+    cdpService;
+    pollIntervalMs;
+    maxDurationMs;
+    stopGoneConfirmCount;
+    onProgress;
+    onComplete;
+    onTimeout;
+    onPhaseChange;
+    onProcessLog;
+    pollTimer = null;
+    timeoutTimer = null;
+    isRunning = false;
+    lastText = null;
+    baselineText = null;
+    generationStarted = false;
+    currentPhase = 'waiting';
+    stopGoneCount = 0;
+    quotaDetected = false;
+    seenProcessLogKeys = new Set();
+    constructor(options) {
+        this.cdpService = options.cdpService;
+        this.pollIntervalMs = options.pollIntervalMs ?? 2000;
+        this.maxDurationMs = options.maxDurationMs ?? 300000;
+        this.stopGoneConfirmCount = options.stopGoneConfirmCount ?? 3;
+        this.onProgress = options.onProgress;
+        this.onComplete = options.onComplete;
+        this.onTimeout = options.onTimeout;
+        this.onPhaseChange = options.onPhaseChange;
+        this.onProcessLog = options.onProcessLog;
+    }
+    /** Start monitoring */
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lastText = null;
+        this.baselineText = null;
+        this.generationStarted = false;
+        this.currentPhase = 'waiting';
+        this.stopGoneCount = 0;
+        this.quotaDetected = false;
+        this.seenProcessLogKeys = new Set();
+        // Always fire callback on start, even though phase is already 'waiting'
+        this.onPhaseChange?.('waiting', null);
+        // Capture baseline text
+        try {
+            const baseResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
+            const rawValue = baseResult?.result?.value;
+            this.baselineText = typeof rawValue === 'string' ? rawValue.trim() || null : null;
+        }
+        catch {
+            this.baselineText = null;
+        }
+        // Capture baseline process logs as already-seen keys
+        try {
+            const logResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.PROCESS_LOGS));
+            const logEntries = logResult?.result?.value;
+            if (Array.isArray(logEntries)) {
+                this.seenProcessLogKeys = new Set(logEntries
+                    .map((s) => (s || '').replace(/\r/g, '').trim())
+                    .filter((s) => s.length > 0)
+                    .map((s) => s.slice(0, 200)));
+            }
+        }
+        catch {
+            // baseline capture only
+        }
+        // Set timeout timer
+        if (this.maxDurationMs > 0) {
+            this.timeoutTimer = setTimeout(async () => {
+                const lastText = this.lastText ?? '';
+                this.setPhase('timeout', lastText);
+                await this.stop();
+                try {
+                    await Promise.resolve(this.onTimeout?.(lastText));
+                }
+                catch (error) {
+                    logger_1.logger.error('[ResponseMonitor] timeout callback failed:', error);
+                }
+            }, this.maxDurationMs);
+        }
+        logger_1.logger.info(`── Monitoring started | poll=${this.pollIntervalMs}ms timeout=${this.maxDurationMs / 1000}s baseline=${this.baselineText?.length ?? 0}ch`);
+        // Start polling
+        this.schedulePoll();
+    }
+    /** Stop monitoring */
+    async stop() {
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = null;
+        }
+    }
+    /** Get current phase */
+    getPhase() {
+        return this.currentPhase;
+    }
+    /** Whether quota error was detected */
+    getQuotaDetected() {
+        return this.quotaDetected;
+    }
+    /** Whether monitoring is active */
+    isActive() {
+        return this.isRunning;
+    }
+    /** Get last extracted text */
+    getLastText() {
+        return this.lastText;
+    }
+    /** Click the stop button to interrupt LLM generation */
+    async clickStopButton() {
+        try {
+            const result = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.CLICK_STOP_BUTTON));
+            const value = result?.result?.value;
+            if (this.isRunning) {
+                await this.stop();
+            }
+            return value ?? { ok: false, error: 'CDP evaluation returned empty' };
+        }
+        catch (error) {
+            return { ok: false, error: error.message || 'Failed to click stop button' };
+        }
+    }
+    setPhase(phase, text) {
+        if (this.currentPhase !== phase) {
+            this.currentPhase = phase;
+            const len = text?.length ?? 0;
+            switch (phase) {
+                case 'thinking':
+                    logger_1.logger.phase('Thinking');
+                    break;
+                case 'generating':
+                    logger_1.logger.phase(`Generating (${len} chars)`);
+                    break;
+                case 'complete':
+                    logger_1.logger.done(`Complete (${len} chars)`);
+                    break;
+                case 'timeout':
+                    logger_1.logger.warn(`Timeout (${len} chars captured)`);
+                    break;
+                case 'quotaReached':
+                    logger_1.logger.warn('Quota Reached');
+                    break;
+                default:
+                    logger_1.logger.phase(`${phase}`);
+            }
+            this.onPhaseChange?.(phase, text);
+        }
+    }
+    schedulePoll() {
+        if (!this.isRunning)
+            return;
+        this.pollTimer = setTimeout(async () => {
+            await this.poll();
+            if (this.isRunning) {
+                this.schedulePoll();
+            }
+        }, this.pollIntervalMs);
+    }
+    buildEvaluateParams(expression) {
+        const params = {
+            expression,
+            returnByValue: true,
+            awaitPromise: true,
+        };
+        const contextId = this.cdpService.getPrimaryContextId?.();
+        if (contextId !== null && contextId !== undefined) {
+            params.contextId = contextId;
+        }
+        return params;
+    }
+    /**
+     * Single poll: exactly 4 CDP calls.
+     * 1. Stop button check
+     * 2. Quota error check
+     * 3. Text extraction
+     * 4. Process log extraction
+     */
+    async poll() {
+        try {
+            // 1. Stop button check
+            const stopResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.STOP_BUTTON));
+            const stopValue = stopResult?.result?.value;
+            const isGenerating = !!(stopValue && typeof stopValue === 'object' && stopValue.isGenerating);
+            // 2. Quota error check
+            const quotaResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.QUOTA_ERROR));
+            const quotaDetected = quotaResult?.result?.value === true;
+            // 3. Text extraction
+            const textResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.RESPONSE_TEXT));
+            const rawText = textResult?.result?.value;
+            const exceptionDetail = textResult?.result?.exceptionDetails ?? textResult?.exceptionDetails;
+            if (exceptionDetail) {
+                logger_1.logger.warn('[ResponseMonitor:poll] RESPONSE_TEXT threw:', exceptionDetail.text ?? JSON.stringify(exceptionDetail).slice(0, 200));
+            }
+            const currentText = typeof rawText === 'string' ? rawText.trim() || null : null;
+            // 4. Process log extraction
+            try {
+                const logResult = await this.cdpService.call('Runtime.evaluate', this.buildEvaluateParams(exports.RESPONSE_SELECTORS.PROCESS_LOGS));
+                const logEntries = logResult?.result?.value;
+                if (Array.isArray(logEntries)) {
+                    const newEntries = [];
+                    for (const raw of logEntries) {
+                        const normalized = (raw || '').replace(/\r/g, '').trim();
+                        if (!normalized)
+                            continue;
+                        const key = normalized.slice(0, 200);
+                        if (this.seenProcessLogKeys.has(key))
+                            continue;
+                        this.seenProcessLogKeys.add(key);
+                        newEntries.push(normalized.slice(0, 300));
+                    }
+                    if (newEntries.length > 0) {
+                        try {
+                            this.onProcessLog?.(newEntries.join('\n\n'));
+                        }
+                        catch {
+                            // callback error
+                        }
+                    }
+                }
+            }
+            catch {
+                // process log extraction is best-effort
+            }
+            // Handle stop button appearing
+            if (isGenerating) {
+                if (!this.generationStarted) {
+                    this.generationStarted = true;
+                    this.setPhase('thinking', null);
+                }
+                this.stopGoneCount = 0;
+            }
+            // Handle quota detection
+            if (quotaDetected) {
+                const hasText = !!(this.lastText && this.lastText.trim().length > 0);
+                logger_1.logger.warn(`[ResponseMonitor] quota detected hasText=${hasText}`);
+                if (hasText) {
+                    this.quotaDetected = true;
+                }
+                else {
+                    this.setPhase('quotaReached', '');
+                    await this.stop();
+                    try {
+                        await Promise.resolve(this.onComplete?.(''));
+                    }
+                    catch (error) {
+                        logger_1.logger.error('[ResponseMonitor] complete callback failed:', error);
+                    }
+                    return;
+                }
+            }
+            // Baseline suppression: do not emit progress for pre-existing text.
+            // IMPORTANT: do not early-return here; completion logic must still run.
+            const effectiveText = (currentText !== null &&
+                this.baselineText !== null &&
+                currentText === this.baselineText &&
+                this.lastText === null) ? null : currentText;
+            // Text change handling
+            const textChanged = effectiveText !== null && effectiveText !== this.lastText;
+            if (textChanged) {
+                this.lastText = effectiveText;
+                if (this.currentPhase === 'waiting' || this.currentPhase === 'thinking') {
+                    this.setPhase('generating', effectiveText);
+                    if (!this.generationStarted) {
+                        this.generationStarted = true;
+                    }
+                }
+                this.onProgress?.(effectiveText);
+            }
+            // Completion: stop button gone N consecutive times
+            if (!isGenerating && this.generationStarted) {
+                this.stopGoneCount++;
+                if (this.stopGoneCount >= this.stopGoneConfirmCount) {
+                    const finalText = this.lastText ?? '';
+                    this.setPhase('complete', finalText);
+                    await this.stop();
+                    try {
+                        await Promise.resolve(this.onComplete?.(finalText));
+                    }
+                    catch (error) {
+                        logger_1.logger.error('[ResponseMonitor] complete callback failed:', error);
+                    }
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('[ResponseMonitor] poll error:', error);
+        }
+    }
+}
+exports.ResponseMonitor = ResponseMonitor;