zames_pro 2.7.0 → 2.9.0

package/README.md

@@ -41,6 +41,27 @@ While the agent is working you can keep typing: press Enter to queue a message
 abort the current generation. This mirrors typing during generation on the
 DeepSeek website.
 
+### Images and files
+
+You can paste an image or a file into the input line (Ctrl+Shift+V / Shift+Insert
+or the terminal's own paste). zames saves it under `<project>/tmp` and shows a
+marker in the line - `[image#1]` for images, `[file#1]` for other files - then
+uploads the real file to the chat together with your message. These are the
+same formats the DeepSeek web chat accepts (PNG, JPEG, GIF, WEBP, BMP, SVG and
+the usual document types).
+
+Pasting an image works when the terminal sends it as a `data:` URL or as a
+base64 blob with a recognizable image signature. You can also paste a path to a
+local file (drag a file into the terminal or copy its path); if the file exists
+it is attached, otherwise the text is inserted as usual.
+
+Press Ctrl+V (or use an empty paste) and zames reads the image straight from
+the clipboard: Linux via wl-paste (Wayland) or xclip/xsel (X11), macOS
+via pngpaste, Windows via PowerShell. The needed Linux tools are installed
+automatically on npm install (best-effort, through the detected package
+manager). If no image is found, zames says so and reports which tool it tried,
+instead of staying silent.
+
 ### Options
 
 ```

package/dist/agent-loop.js

@@ -2,7 +2,7 @@ import { buildSystemPrompt } from './system-prompt.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
@@ -48,6 +48,25 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         await reportChat();
     }
     let message = task;
+    if (attachments.length) {
+        // Tell the model what the markers mean even when the system-prompt is not
+        // (re)sent (resumed chat). The files are uploaded to the chat by the
+        // browser; this note just explains the [image#N] / [file#N] markers.
+        const markers = attachments.map((a, i) => {
+            const ext = String(a.name || '');
+            const isImg = /\.(png|jpe?g|gif|webp|bmp|svg|ico)$/i.test(ext);
+            return (isImg ? '[image#' : '[file#') + (i + 1) + ']';
+        });
+        message =
+            task +
+                String.fromCharCode(10) +
+                String.fromCharCode(10) +
+                '(The user attached ' +
+                attachments.length +
+                ' file(s) to this message: ' +
+                markers.join(', ') +
+                '. Look at the uploaded images in the chat; file copies are in <project>/tmp.)';
+    }
     transcript?.log('task', { task });
     let malformedRetries = 0;
     const MAX_MALFORMED_RETRIES = 3;
@@ -61,13 +80,24 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // chatty model.
     let looksDoneRetries = 0;
     const MAX_LOOKSDONE_RETRIES = 3;
+    // Watchdog against the agent emitting a tool call and then going silent.
+    // After a tool result the expected next answer is a fresh tool call; if we
+    // instead get an EMPTY answer or the EXACT same answer as the previous turn
+    // (a sign the new message was not sent), we nudge instead of stopping.
+    let lastRaw = '';
+    let justRanTool = false;
+    let watchdogRetries = 0;
+    const MAX_WATCHDOG_RETRIES = 3;
     for (let i = 0; i < maxIterations; i++) {
         onThinking();
         // The first message (task) is user input: no throttle.
         // Subsequent ones (tool-result and resend requests) are agent sends:
         // throttled so we don't hit the rate limit.
         const isFirst = i === 0;
-        const rawResponse = await browser.ask(message, { agent: !isFirst });
+        const rawResponse = await browser.ask(message, {
+            agent: !isFirst,
+            attachments: isFirst ? attachments : [],
+        });
         await reportChat();
         transcript?.log('assistant_raw', { response: rawResponse });
         // The user aborted generation (Esc/Ctrl+C).
@@ -75,6 +105,23 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             transcript?.log('user_aborted');
             return rawResponse;
         }
+        // Watchdog: after a tool result we expect a FRESH tool call. If the answer
+        // is empty or identical to the previous turn (the new message was not
+        // sent), nudge instead of stopping.
+        const wdEmpty = !String(rawResponse || '').trim();
+        const wdStale = justRanTool && lastRaw.trim() !== '' && rawResponse.trim() === lastRaw.trim();
+        if (!isFirst && (wdEmpty || wdStale) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
+            watchdogRetries++;
+            transcript?.log('watchdog_nudge', {
+                attempt: watchdogRetries,
+                empty: wdEmpty,
+                stale: wdStale,
+                response: String(rawResponse || '').slice(0, 200),
+            });
+            await new Promise((r) => setTimeout(r, 1500));
+            continue;
+        }
+        lastRaw = rawResponse;
         const parsed = parseToolCall(rawResponse);
         if (parsed) {
             const thought = extractPreToolText(rawResponse);
@@ -237,6 +284,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             });
             results.push({ tool: call.tool, result });
         }
+        // A tool just ran — the next answer is expected to be a fresh tool call.
+        // Reset the watchdog so the next empty/repeated answer is nudged.
+        justRanTool = true;
+        watchdogRetries = 0;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);

package/dist/attachments.js

@@ -0,0 +1,332 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+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.
+// True when running inside WSL. There the X11 clipboard is a SEPARATE
+// clipboard from the Windows one: the user copies an image in Windows, so we
+// must read it through powershell.exe, not xclip.
+export function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
+        return true;
+    try {
+        const rel = os.release().toLowerCase();
+        if (rel.includes('microsoft') || rel.includes('wsl'))
+            return true;
+    }
+    catch { }
+    return false;
+}
+// PowerShell one-liner: write the clipboard image as raw PNG bytes to stdout.
+const PS_GET_IMAGE = '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)}';
+// PowerShell one-liner: write the clipboard file paths (CF_HDROP) to stdout.
+const PS_GET_FILE_DROP = 'Add-Type -AssemblyName System.Windows.Forms; ' +
+    '$d=[System.Windows.Forms.Clipboard]::GetDataObject(); ' +
+    'if($d -and $d.GetDataPresent([System.Windows.Forms.DataFormats]::FileDrop)){' +
+    '$f=$d.GetData([System.Windows.Forms.DataFormats]::FileDrop); $f -join [Environment]::NewLine}';
+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 = [];
+        // On WSL the Windows clipboard is what the user copies into — read it first.
+        if (isWsl()) {
+            attempts.push({ bin: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-Command', PS_GET_IMAGE], via: 'powershell.exe' });
+        }
+        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;
+}
+// Read file paths from the Windows clipboard (copied files, CF_HDROP) and
+// translate them to WSL paths. On WSL the user often copies a FILE, not an
+// image. Returns [] on non-WSL / when nothing is there.
+export function readWindowsClipboardFiles() {
+    if (!isWsl())
+        return [];
+    const out = tryCommand('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', PS_GET_FILE_DROP]);
+    if (!out)
+        return [];
+    const text = out.toString('utf-8');
+    return text
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map(winPathToWsl)
+        .filter((p) => !!p);
+}
+// Convert a Windows path (C:\\Users\\me\\a.png) into a WSL path
+// (/mnt/c/Users/me/a.png). Leaves already-POSIX paths untouched.
+export function winPathToWsl(winPath) {
+    let p = String(winPath || '').trim();
+    if (p.startsWith('"') && p.endsWith('"'))
+        p = p.slice(1, -1);
+    if (!p)
+        return null;
+    if (p.startsWith('/'))
+        return p;
+    if (p.charAt(1) !== ':' || (p.charAt(2) !== '/' && p.charAt(2) !== '\\'))
+        return null;
+    const drive = p.charAt(0).toLowerCase();
+    const rest = p.slice(3).split('\\').join('/');
+    return '/mnt/' + drive + '/' + rest;
+}

package/dist/browser.js

@@ -43,6 +43,14 @@ const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|сл
 export function isRateLimitText(text) {
     return RATE_LIMIT_RE.test(String(text || ''));
 }
+// 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 {
@@ -408,14 +416,14 @@ 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;
@@ -494,6 +502,69 @@ export class DeepSeekBrowser {
             await this.page.keyboard.insertText(text);
         }
     }
+    // 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.
@@ -508,7 +579,7 @@ 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);
@@ -519,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;
@@ -554,12 +630,19 @@ 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;
             }
@@ -592,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;
@@ -600,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)

package/dist/i18n.js

@@ -59,6 +59,10 @@ const CATALOG = {
     'help.key.slash': { ru: '/ + Tab                  подсказка и автодополнение slash-команд', en: '/ + Tab                   slash-command hints and completion' },
     'help.key.newline': { ru: 'Ctrl+J / Ctrl+Enter      новая строка (Shift+Enter в терминалах с поддержкой)', en: 'Ctrl+J / Ctrl+Enter       new line (Shift+Enter in capable terminals)' },
     'help.key.backslash': { ru: '\\ + Enter                тоже новая строка', en: '\\ + Enter                also a new line' },
+    'help.key.attach': {
+        ru: 'Ctrl+Shift+V картинки      вставить изображение/файл (сохранится в tmp)',
+        en: 'Ctrl+Shift+V image         paste an image/file (saved to tmp)',
+    },
     'help.key.esc': { ru: 'Esc, Ctrl+C              прервать текущую генерацию', en: 'Esc, Ctrl+C               abort current generation' },
     'help.commands': { ru: 'Обычные команды:', en: 'Commands:' },
     'help.cmd.new': { ru: '/new, /clear             новый чат (сброс контекста)', en: '/new, /clear             new chat (reset context)' },
@@ -133,6 +137,22 @@ const CATALOG = {
     'msg.abort_gen': { ru: '⏹ Esc — прерываю генерацию...', en: '⏹ Esc — aborting generation...' },
     'msg.abort_ctrlc': { ru: '⏹ Ctrl+C — прерываю генерацию...', en: '⏹ Ctrl+C — aborting generation...' },
     'msg.queued': { ru: '📨 В очередь ({n}): ', en: '📨 Queued ({n}): ' },
+    'msg.attached_image': {
+        ru: '🖼 Вложено изображение {marker} ({size}) — сохранено в tmp',
+        en: '🖼 Attached image {marker} ({size}) — saved to tmp',
+    },
+    'msg.attached_file': {
+        ru: '📎 Вложен файл {marker} {name} ({size}) — сохранён в tmp',
+        en: '📎 Attached file {marker} {name} ({size}) — saved to tmp',
+    },
+    'msg.clip_empty': {
+        ru: '⚠ В буфере обмена нет картинки (проверено: {via}).',
+        en: '⚠ No image found in the clipboard (tried: {via}).',
+    },
+    'msg.clip_hint': {
+        ru: '   Установите утилиту клипборда: Linux/X11 — xclip или xsel, Wayland — wl-clipboard; Windows/macOS — работает из коробки. Либо вставьте путь к файлу.',
+        en: '   Install a clipboard tool: Linux/X11 — xclip or xsel, Wayland — wl-clipboard; Windows/macOS — works out of the box. Or paste a file path.',
+    },
     'msg.from_queue': { ru: '▶ Из очереди: ', en: '▶ From queue: ' },
     'msg.agent_error': { ru: '✖ Ошибка агента:', en: '✖ Agent error:' },
     'msg.suspicious_stop': {