zames_pro 2.6.0 → 2.8.0

package/dist/attachments.js

@@ -0,0 +1,267 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { execFileSync } from 'child_process';
+export const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg', '.ico'];
+export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function sanitize(name) {
+    return String(name || '')
+        .replace(/[\u0000-\u001f\u007f]/g, '')
+        .replace(/[\\/:*?"<>|]/g, '_')
+        .replace(/\s+/g, '_')
+        .slice(0, 80) || 'file';
+}
+export function guessMime(name) {
+    const ext = path.extname(String(name || '')).toLowerCase();
+    const map = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.bmp': 'image/bmp',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.txt': 'text/plain',
+        '.md': 'text/markdown',
+        '.json': 'application/json',
+        '.js': 'text/javascript',
+        '.ts': 'text/plain',
+        '.css': 'text/css',
+        '.html': 'text/html',
+        '.pdf': 'application/pdf',
+        '.zip': 'application/zip',
+        '.csv': 'text/csv',
+        '.log': 'text/plain',
+    };
+    return map[ext] || 'application/octet-stream';
+}
+export function extForMime(mime) {
+    const m = String(mime || '').toLowerCase();
+    if (m.includes('png'))
+        return '.png';
+    if (m.includes('jpeg') || m.includes('jpg'))
+        return '.jpg';
+    if (m.includes('gif'))
+        return '.gif';
+    if (m.includes('webp'))
+        return '.webp';
+    if (m.includes('svg'))
+        return '.svg';
+    if (m.includes('text/plain'))
+        return '.txt';
+    if (m.includes('json'))
+        return '.json';
+    if (m.includes('pdf'))
+        return '.pdf';
+    return '';
+}
+export function formatSize(bytes) {
+    const n = Number(bytes) || 0;
+    if (n < 1024)
+        return n + ' B';
+    if (n < 1024 * 1024)
+        return (n / 1024).toFixed(1) + ' KB';
+    return (n / (1024 * 1024)).toFixed(1) + ' MB';
+}
+export function isImageName(name) {
+    return IMAGE_EXTS.includes(path.extname(String(name || '')).toLowerCase());
+}
+export function parseDataUrl(text) {
+    const m = String(text || '').match(/^data:([^;,]*);base64,([\s\S]*)$/);
+    if (!m)
+        return null;
+    try {
+        return { mime: m[1] || 'application/octet-stream', data: Buffer.from(m[2].replace(/\s+/g, ''), 'base64') };
+    }
+    catch {
+        return null;
+    }
+}
+export function sniffMime(data) {
+    if (!data || data.length < 4)
+        return '';
+    const b = data;
+    if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47)
+        return 'image/png';
+    if (b[0] === 0xff && b[1] === 0xd8)
+        return 'image/jpeg';
+    if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46)
+        return 'image/gif';
+    if (b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46)
+        return 'image/webp';
+    if (b[0] === 0x42 && b[1] === 0x4d)
+        return 'image/bmp';
+    return '';
+}
+export function parseImagePaste(raw) {
+    const text = String(raw || '').trim();
+    if (!text)
+        return null;
+    const dataUrl = parseDataUrl(text);
+    if (dataUrl)
+        return dataUrl;
+    const onlyB64 = /^[A-Za-z0-9+/\s=]+$/;
+    if (onlyB64.test(text) && text.length >= 64) {
+        try {
+            const data = Buffer.from(text.replace(/\s+/g, ''), 'base64');
+            const mime = sniffMime(data);
+            if (mime && mime.startsWith('image/'))
+                return { mime, data };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export class AttachmentStore {
+    items = [];
+    imageCount = 0;
+    fileCount = 0;
+    reset() {
+        this.items = [];
+        this.imageCount = 0;
+        this.fileCount = 0;
+    }
+    add(item) {
+        const image = isImageName(item.name) || String(item.mime).startsWith('image/');
+        const index = image ? ++this.imageCount : ++this.fileCount;
+        const marker = image ? '[image#' + index + ']' : '[file#' + index + ']';
+        const att = {
+            index,
+            path: item.path,
+            name: item.name,
+            mime: item.mime,
+            image,
+            marker,
+            size: Number(item.size) || 0,
+        };
+        this.items.push(att);
+        return att;
+    }
+}
+// True if the pasted text is a single file path (e.g. '/tmp/a.png', './img.jpg',
+// 'C:\\pics\\a.png' or a bare 'photo.png'). We do NOT require the file to
+// exist yet — the caller checks that.
+export function looksLikeFilePath(text) {
+    const s = String(text || '').trim();
+    if (!s || s.length > 500)
+        return false;
+    if (/[\r\n]/.test(s))
+        return false;
+    // A bare file name with an image/known extension.
+    if (looksLikeFileName(s))
+        return true;
+    // A path with separators and an extension.
+    if (/[\\/]/.test(s) && /\.[A-Za-z0-9]{1,8}$/.test(s))
+        return true;
+    return false;
+}
+export function looksLikeFileName(name) {
+    const n = String(name || '').trim();
+    if (!n)
+        return false;
+    if (/[\r\n]/.test(n))
+        return false;
+    return /^[\w.\- ]+\.[A-Za-z0-9]{1,8}$/.test(n);
+}
+export async function saveToTemp(tmpDir, name, data) {
+    await fs.mkdir(tmpDir, { recursive: true });
+    const base = sanitize(name);
+    let target = path.join(tmpDir, base);
+    if (await fs.stat(target).catch(() => null)) {
+        const ext = path.extname(base);
+        const stem = base.slice(0, base.length - ext.length);
+        let i = 1;
+        while (await fs.stat(target).catch(() => null)) {
+            target = path.join(tmpDir, stem + '-' + i + ext);
+            i++;
+        }
+    }
+    await fs.writeFile(target, data);
+    return target;
+}
+// Read an image from the OS clipboard. Tries, in order, every known tool for
+// the current platform. Returns the raw bytes plus a short note about which
+// tool was used (or the reason nothing was found) — the caller shows that note
+// to the user so a failed paste is never silent.
+export function readClipboardImageDetailed() {
+    if (process.platform === 'linux' || process.platform === 'freebsd' || process.platform === 'openbsd') {
+        const wayland = process.env.WAYLAND_DISPLAY;
+        const x11 = process.env.DISPLAY;
+        const attempts = [];
+        if (wayland || !x11)
+            attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
+        if (x11 || !wayland) {
+            attempts.push({ bin: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], via: 'xclip' });
+            attempts.push({ bin: 'xsel', args: ['--clipboard', '--output'], via: 'xsel' });
+        }
+        // Even if the session env is missing, try the other family as a fallback.
+        attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
+        attempts.push({ bin: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], via: 'xclip' });
+        const tried = [];
+        for (const a of attempts) {
+            if (tried.includes(a.via))
+                continue;
+            tried.push(a.via);
+            const data = tryCommand(a.bin, a.args);
+            if (data && sniffMime(data).startsWith('image/'))
+                return { data, via: a.via };
+            if (data && data.length)
+                return { data, via: a.via };
+        }
+        return { data: null, via: 'no-tool:' + tried.join(',') };
+    }
+    if (process.platform === 'darwin') {
+        const data = tryCommand('pngpaste', ['-']);
+        return { data: data && data.length ? data : null, via: data ? 'pngpaste' : 'no-tool:pngpaste' };
+    }
+    if (process.platform === 'win32') {
+        // PowerShell reads the clipboard image and writes raw PNG bytes to stdout.
+        const ps = 'Add-Type -AssemblyName System.Windows.Forms,System.Drawing; ' +
+            '$img=[System.Windows.Forms.Clipboard]::GetImage(); ' +
+            'if($img){$ms=New-Object System.IO.MemoryStream; ' +
+            '$img.Save($ms,[System.Drawing.Imaging.ImageFormat]::Png); ' +
+            '[Console]::OpenStandardOutput().Write($ms.ToArray(),0,$ms.Length)}';
+        const data = tryCommand('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps]);
+        return { data: data && data.length ? data : null, via: data ? 'powershell' : 'no-tool:powershell' };
+    }
+    return { data: null, via: 'unsupported-platform' };
+}
+// Backwards-compatible wrapper used elsewhere.
+export function readClipboardImage() {
+    return readClipboardImageDetailed().data;
+}
+function tryCommand(bin, args) {
+    try {
+        const out = execFileSync(bin, args, {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: MAX_ATTACHMENT_BYTES,
+            timeout: 8000,
+            windowsHide: true,
+        });
+        if (!out || !out.length)
+            return null;
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+export async function findFileByName(workdir, name) {
+    const candidate = path.resolve(workdir, name);
+    if (await fs.stat(candidate).catch(() => null))
+        return candidate;
+    try {
+        const { glob } = await import('fs/promises');
+        for await (const f of glob('**/' + name, { cwd: workdir })) {
+            const abs = path.resolve(workdir, f);
+            const rel = path.relative(workdir, abs);
+            if (rel.startsWith('..') || path.isAbsolute(rel))
+                continue;
+            return abs;
+        }
+    }
+    catch { }
+    return null;
+}

package/dist/browser.js

@@ -25,10 +25,9 @@ const SEND_SELECTORS = [
     'button[aria-label*="send" i]',
     'button[aria-label*="отправ" i]',
 ];
-// ВАЖНО: сюда НЕЛЬЗЯ добавлять общий 'div[role="button"][class*="ds-button--primary"]'
-// — под него попадает кнопка отправки, которая видна всегда, и тогда
-// _isGenerating() вечно возвращает true, из-за чего ответ никогда не
-// считается готовым.
+// IMPORTANT: you MUST NOT add the generic 'div[role="button"][class*="ds-button--primary"]'
+// here — it matches the send button, which is always visible, and then
+// _isGenerating() always returns true, so the answer is never considered ready.
 const STOP_SELECTORS = [
     'div[role="button"][aria-label*="stop" i]',
     'div[role="button"][aria-label*="останов" i]',
@@ -36,16 +35,24 @@ const STOP_SELECTORS = [
     'button:has-text("Остановить")',
     'button[aria-label*="Stop" i]',
 ];
-// Служебные статусы интерфейса DeepSeek, которые НЕ являются ответом модели.
-// Иначе агент принимает статус (Reading...) за ответ и ломает разбор.
+// DeepSeek UI service statuses that are NOT the model's answer.
+// Otherwise the agent takes a status (Reading...) for an answer and breaks parsing.
 const STATUS_RE = /^(reading|thinking|searching|analyzing|generating|stop|остановить|читаю|думаю|поиск|анализ)[\s.…]*$/i;
-// Ответ DeepSeek при превышении лимита частоты.
+// DeepSeek's answer when the rate limit is exceeded.
 const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|слишком часто|повторите позже|try again later)/i;
 export function isRateLimitText(text) {
     return RATE_LIMIT_RE.test(String(text || ''));
 }
-// Ошибка «слишком часто»: отличается от прочих, чтобы ask() ждал долго
-// (лимиты DeepSeek сбрасываются за минуты) и повторял отправку сам.
+// Normalize text for comparison: collapse whitespace so that tiny DOM
+// differences (nbsp, trailing spaces) don't count as "a new answer".
+export function normText(s) {
+    return String(s || '')
+        .replace(/\u00a0/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// The "too frequent" error: distinct from others so ask() waits a long time
+// (DeepSeek limits reset over minutes) and retries the send itself.
 export class RateLimitError extends Error {
     constructor(detail) {
         super('Messages too frequent. Try again later. ' + detail);
@@ -100,9 +107,9 @@ export class DeepSeekBrowser {
     maxRateLimitRetries;
     _lastSentAt;
     _abort;
-    // Пользователь нажал Esc/Ctrl+C — «стоп» для ВСЕЙ текущей пачки задач
-    // (включая очередь). В отличие от _abort (сбрасывается на каждую
-    // отправку), этот флаг живёт до явного запуска новой задачи с промпта.
+    // The user pressed Esc/Ctrl+C — a "stop" for the WHOLE current batch of
+    // tasks (including the queue). Unlike _abort (reset on every send), this
+    // flag lives until a new task is explicitly started from the prompt.
     _stopped;
     context;
     page;
@@ -284,9 +291,9 @@ export class DeepSeekBrowser {
         return null;
     }
     async _readLastAnswerText() {
-        // Если удалось перехватить сырой текст ответа по сети (без рендер-
-        // искажений DeepSeek) и он относится к текущему ответу — отдаём его.
-        // Это защищает $, экранированные переводы строк и т.п. в аргументах.
+        // If we managed to intercept the raw answer text over the network
+        // (without DeepSeek's render distortions) and it belongs to the current
+        // answer — we return it. This protects $, escaped newlines, etc. in arguments.
         if (this._netCapture && this._netCaptureAt >= this._lastSentAt) {
             return this._netCapture;
         }
@@ -304,9 +311,9 @@ export class DeepSeekBrowser {
             return out.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
         }, ANSWER_SELECTORS);
     }
-    // Читаем ТОЛЬКО видимые тосты/уведомления/ошибки, а не весь текст
-    // страницы. Иначе ловим «try again later» из служебных/скрытых блоков
-    // и уходим в ложное ожидание лимита на 5 минут.
+    // We read ONLY visible toasts/notifications/errors, not the whole page
+    // text. Otherwise we catch "try again later" from service/hidden blocks
+    // and go into a false 5-minute rate-limit wait.
     async _readPageText() {
         return await this.page
             .evaluate(() => {
@@ -340,9 +347,9 @@ export class DeepSeekBrowser {
             return '';
         return raw;
     }
-    // Найти кнопку Stop в интерфейсе DeepSeek. Полагаться только на класс
-    // нельзя: во время генерации кнопка отправки (та же circle-кнопка)
-    // меняет иконку на «квадрат» (stop), сохраняя классы.
+    // Find the Stop button in the DeepSeek UI. We can't rely on the class
+    // alone: during generation the send button (the same circle button)
+    // changes its icon to a "square" (stop) while keeping the classes.
     async _stopButtonVisible() {
         const explicit = await this._findVisible(STOP_SELECTORS, 250);
         if (explicit)
@@ -361,7 +368,7 @@ export class DeepSeekBrowser {
                     (b.textContent || '')).toLowerCase();
                 if (/stop|останов/.test(label))
                     return true;
-                // Иконка-квадрат = кнопка Stop; стрелка (path без rect) = отправка.
+                // A square icon = Stop button; an arrow (path without rect) = send.
                 const svg = b.querySelector('svg');
                 if (svg && svg.querySelector('rect'))
                     return true;
@@ -409,20 +416,20 @@ export class DeepSeekBrowser {
         catch { }
         return false;
     }
-    async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, } = {}) {
+    async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, attachments = [], } = {}) {
         let lastErr = null;
         let attempt = 0;
         let rateLimitRetries = 0;
         while (attempt < this.askRetries) {
             attempt++;
             try {
-                return await this._askOnce(prompt, { timeout, agent });
+                return await this._askOnce(prompt, { timeout, agent, attachments });
             }
             catch (e) {
                 lastErr = e;
-                // Лимит частоты: DeepSeek не принял сообщение. Ждём долго и
-                // повторяем отправку в ТОТ ЖЕ чат (без newChat — иначе теряется
-                // контекст). Паузы не расходуют обычные попытки ask().
+                // Rate limit: DeepSeek did not accept the message. We wait a long time
+                // and resend into the SAME chat (without newChat — otherwise the
+                // context is lost). The waits don't consume the regular ask() attempts.
                 if (e instanceof RateLimitError) {
                     rateLimitRetries++;
                     if (rateLimitRetries > this.maxRateLimitRetries) {
@@ -495,9 +502,72 @@ export class DeepSeekBrowser {
             await this.page.keyboard.insertText(text);
         }
     }
-    // Пауза между отправками. Применяется ТОЛЬКО к сообщениям агента
-    // (tool-result, system-prompt), чтобы не упираться в лимит частоты.
-    // Пользовательский ввод отправляется без задержки.
+    // Attach files/images to the chat via the hidden <input type=file> of the
+    // DeepSeek upload widget. The element is not visible, so we set the files
+    // programmatically (Playwright setInputFiles works on hidden inputs too).
+    async _attachFiles(files) {
+        const bufPayload = [];
+        for (const f of files) {
+            try {
+                const buffer = await fs.readFile(f.path);
+                bufPayload.push({ name: f.name, mimeType: f.mime, buffer });
+            }
+            catch (e) {
+                console.error(theme.warn('⚠ не удалось прочитать вложение ' +
+                    f.name +
+                    ': ' +
+                    e.message));
+            }
+        }
+        if (!bufPayload.length)
+            return;
+        // Preferred path: click the attach button and let the file chooser event
+        // carry the files. This is how a real user attaches a file and it reliably
+        // triggers DeepSeek's upload handler.
+        const ATTACH_SELECTORS = [
+            'div[role="button"][aria-label*="attach" i]',
+            'div[role="button"][aria-label*="влож" i]',
+            'button[aria-label*="attach" i]',
+            'button[aria-label*="влож" i]',
+            '[class*="upload"]',
+            '[class*="attach"]',
+        ];
+        for (const sel of ATTACH_SELECTORS) {
+            const btn = this.page.locator(sel).last();
+            try {
+                if ((await btn.count()) === 0)
+                    continue;
+                if (!(await btn.isVisible().catch(() => false)))
+                    continue;
+                const [chooser] = await Promise.all([
+                    this.page.waitForEvent('filechooser', { timeout: 3000 }),
+                    btn.click({ timeout: 1500 }),
+                ]);
+                await chooser.setFiles(bufPayload);
+                await this.page.waitForTimeout(2500);
+                return;
+            }
+            catch { }
+        }
+        // Fallback: set the files directly on the hidden <input type=file>.
+        const input = this.page.locator('input[type="file"]').first();
+        if ((await input.count()) === 0) {
+            console.error(theme.warn('⚠ не найдено поле загрузки файлов на странице — вложения не прикреплены'));
+            return;
+        }
+        try {
+            await input.setInputFiles(bufPayload, { timeout: 15_000 });
+        }
+        catch (e) {
+            console.error(theme.warn('⚠ не удалось прикрепить файлы: ' + e.message));
+            return;
+        }
+        // Wait for the upload to finish (the attach preview to appear).
+        await this.page.waitForTimeout(2000);
+    }
+    // Pause between sends. Applied ONLY to agent messages
+    // (tool-result, system-prompt) so we don't hit the rate limit.
+    // User input is sent without delay.
     async _waitForSendSlot(agent) {
         if (!agent)
             return;
@@ -509,8 +579,8 @@ export class DeepSeekBrowser {
         console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
         await this.page.waitForTimeout(gap);
     }
-    async _askOnce(prompt, { timeout, agent }) {
-        // Сбрасываем флаг прерывания ТОЛЬКО в самом начале отправки.
+    async _askOnce(prompt, { timeout, agent, attachments = [], }) {
+        // We reset the abort flag ONLY at the very start of the send.
         this._abort = false;
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
         if (!input) {
@@ -520,6 +590,11 @@ export class DeepSeekBrowser {
         await this._waitForSendSlot(agent);
         this._netCapture = '';
         this._netCaptureAt = 0;
+        // Attach files/images FIRST (before the text): the DeepSeek upload widget
+        // shows them above the input, and only then the message can be sent.
+        if (attachments.length) {
+            await this._attachFiles(attachments);
+        }
         await this._setInputText(input, prompt);
         await this.page.waitForTimeout(200);
         let sent = false;
@@ -540,9 +615,9 @@ export class DeepSeekBrowser {
             await this.page.keyboard.press('Enter');
         }
         this._lastSentAt = Date.now();
-        // Ждём старта: либо появился Stop, либо изменился текст ответа,
-        // либо вырос общий объём текста на странице. Параллельно ловим
-        // тост о превышении лимита частоты (только тосты, не весь body).
+        // Wait for the start: either Stop appeared, or the answer text changed,
+        // or the total amount of text on the page grew. In parallel we catch
+        // the rate-limit toast (only toasts, not the whole body).
         const startDeadline = Date.now() + 15_000;
         const startBodyLen = await this.page
             .evaluate(() => document.body.innerText.length)
@@ -555,27 +630,34 @@ export class DeepSeekBrowser {
             if (isRateLimitText(pageText)) {
                 throw new RateLimitError(pageText.slice(0, 300));
             }
-            const gen = await this._isGenerating();
             const cur = await this._readLastAnswerTextClean().catch(() => '');
             const bodyLen = await this.page
                 .evaluate(() => document.body.innerText.length)
                 .catch(() => 0);
-            if (gen || (cur && cur !== beforeText) || bodyLen > startBodyLen) {
+            // A NEW answer is the only reliable sign that the message was actually
+            // sent: the text on the page must differ from what was there before the
+            // send, OR the page must have grown. The Stop-button heuristic
+            // (_isGenerating) is NOT used here: right after a tool result the stop
+            // button may briefly linger from the previous generation, which used to
+            // make us think the new answer had started when in fact nothing was sent
+            // — and then the agent silently "stopped".
+            const changed = cur && normText(cur) !== normText(beforeText);
+            if (changed || bodyLen > startBodyLen) {
                 started = true;
                 break;
             }
             await this.page.waitForTimeout(300);
         }
         if (!started) {
-            // Больше НЕ проверяем лимит по всему тексту страницы — это давало
-            // ложные срабатывания и 5-минутные паузы. Просто сообщаем, что
-            // генерация не началась.
+            // We NO LONGER check the limit over the whole page text — that caused
+            // false positives and 5-minute waits. We just report that
+            // generation did not start.
             throw new Error('Ответ не начал генерироваться за 15с. Возможно, сообщение не отправилось.');
         }
-        // Ждём, пока ответ перестанет меняться. Условие "не генерируется"
-        // проверяем через рост текста, а НЕ через _isGenerating().
-        // Параллельно ловим тост лимита частоты, если он всплывёт во время
-        // генерации (читаем только тосты, ложных срабатываний нет).
+        // Wait until the answer stops changing. We check the "not generating"
+        // condition via text growth, NOT via _isGenerating().
+        // In parallel we catch the rate-limit toast if it pops up during
+        // generation (we read only toasts, so there are no false positives).
         const deadline = Date.now() + timeout;
         let last = '';
         let stable = 0;
@@ -584,8 +666,8 @@ export class DeepSeekBrowser {
             if (this._abort) {
                 return last || '(прервано пользователем)';
             }
-            // Тост лимита проверяем не каждый тик, а раз в ~5 тиков, чтобы не
-            // дёргать DOM лишний раз.
+            // We check the limit toast not every tick but about once per 5 ticks,
+            // so we don't poke the DOM unnecessarily.
             if (tick++ % 5 === 0) {
                 const pageText = await this._readPageText();
                 if (isRateLimitText(pageText)) {
@@ -593,7 +675,12 @@ export class DeepSeekBrowser {
                 }
             }
             const cur = await this._readLastAnswerTextClean().catch(() => '');
-            if (cur && cur === last) {
+            // Ignore an "answer" that is identical to what was on the page BEFORE we
+            // sent the message: that is the previous answer, not a new one. Returning
+            // it would make the agent re-process the old tool call (or silently
+            // stop). We keep waiting instead.
+            const isNew = cur && normText(cur) !== normText(beforeText);
+            if (isNew && cur === last) {
                 stable++;
                 if (stable >= 2)
                     return cur;
@@ -601,12 +688,14 @@ export class DeepSeekBrowser {
             else {
                 stable = 0;
             }
-            last = cur;
+            if (isNew)
+                last = cur;
             await this.page.waitForTimeout(800);
         }
-        if (last)
+        if (last && normText(last) !== normText(beforeText))
             return last;
-        throw new Error('Таймаут ожидания ответа. Попробуйте /debug-dom.');
+        throw new Error('Новый ответ не получен (на странице остался прежний текст). ' +
+            'Возможно, сообщение не отправилось.');
     }
     async dumpDom(filePath) {
         if (!this.page)