zames_pro 2.43.0 → 2.45.0

package/dist/agent-loop.js

@@ -773,10 +773,20 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
 export function truncateToolResult(text, limit) {
     if (text.length <= limit)
         return text;
-    const omitted = text.length - limit;
-    return (text.slice(0, limit) +
-        String.fromCharCode(10) +
-        `[...truncated ${omitted} chars]`);
+    // Prefer a LINE boundary near the limit so the model does not read a line
+    // cut in half (a half line is easy to misread as the real content). We look
+    // for the last newline within the last 20% of the window; if none, fall back
+    // to the hard char cut.
+    let cut = limit;
+    const NL = String.fromCharCode(10);
+    const searchFrom = Math.floor(limit * 0.8);
+    const nl = text.lastIndexOf(NL, limit);
+    // Cut AFTER the newline (include it) so the kept part is a whole number of
+    // lines — a cut that EXCLUDED the newline left a half line before the marker.
+    if (nl >= searchFrom)
+        cut = nl + 1;
+    const omitted = text.length - cut;
+    return text.slice(0, cut) + NL + `[...truncated ${omitted} chars]`;
 }
 // The answer looks like a tool call, but parseToolCall() did not recognize it.
 // Used as a safeguard against "the agent called a tool and stopped": in that

package/dist/attachments.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { createHash } from 'crypto';
 import { execFileSync } from 'child_process';
 import { extractPathToken } from './path-token.js';
 export { extractPathToken };
@@ -15,6 +16,11 @@ export const IMAGE_EXTS = [
     '.ico',
 ];
 export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+// Stable content hash for de-duplicating identical attachments (a pasted image
+// is saved to a NEW temp file every time, so its path is not a stable identity).
+export function contentHash(data) {
+    return createHash('sha1').update(data).digest('hex');
+}
 function sanitize(name) {
     return (String(name || '')
         .replace(/[\u0000-\u001f\u007f]/g, '')
@@ -139,10 +145,10 @@ export class AttachmentStore {
         this.fileCount = 0;
     }
     add(item) {
-        // De-duplicate by real path: pasting the SAME file twice must reuse one
-        // attachment (one marker, one upload), not create [file#1] and [file#2].
-        // The operator saw exactly that when inserting the same file repeatedly.
-        const existing = this.items.find((a) => a.path === item.path);
+        // De-duplicate by real path (files/paths) OR by content hash (images and
+        // clipboard data, which are re-saved to a fresh temp file on every paste).
+        // The operator saw the SAME file become [file#1] and [file#2].
+        const existing = this.items.find((a) => a.path === item.path || (item.hash && a.hash && a.hash === item.hash));
         if (existing)
             return existing;
         const image = isImageName(item.name) || String(item.mime).startsWith('image/');
@@ -156,6 +162,7 @@ export class AttachmentStore {
             image,
             marker,
             size: Number(item.size) || 0,
+            hash: item.hash,
         };
         this.items.push(att);
         return att;

package/dist/browser.js

@@ -2124,28 +2124,70 @@ export class DeepSeekBrowser {
             finalPrompt = rewriteFailedAttachments(finalPrompt, failed);
         }
         await this._setInputText(input, finalPrompt);
-        // Send immediately: the input is already verified by _setInputText, and a
-        // clickable send button normally appears right away. The old code slept a
-        // fixed 50ms here, which only added latency (the button does not need it).
+        // Send: wait for the send button to become ENABLED first. After an
+        // attachment upload the button is DISABLED while the file is still
+        // uploading; a click on a disabled button silently does nothing, so the
+        // message stayed in the input and no generation started (the operator saw
+        // the text + the file in the box, but nothing was sent). We poll for an
+        // ENABLED button, then click; if none becomes enabled in time, fall back
+        // to Enter (which is also ignored while the send is disabled).
+        const sendDeadline = Date.now() + 8000;
         let sent = false;
-        for (const sel of SEND_SELECTORS) {
-            const btn = this.page.locator(sel).last();
-            try {
-                if ((await btn.count()) === 0)
-                    continue;
-                if (!(await btn.isVisible().catch(() => false)))
-                    continue;
-                await btn.click({ timeout: 1500 });
-                sent = true;
-                break;
+        while (!sent && Date.now() < sendDeadline) {
+            for (const sel of SEND_SELECTORS) {
+                const btn = this.page.locator(sel).last();
+                try {
+                    if ((await btn.count()) === 0)
+                        continue;
+                    if (!(await btn.isVisible().catch(() => false)))
+                        continue;
+                    // DeepSeek's send control is a div[role=button]; Playwright's
+                    // isEnabled() does NOT honor aria-disabled on a div, so read the
+                    // attribute (and a disabled class) directly — during an upload the
+                    // button is aria-disabled=true and a click is silently ignored.
+                    const enabled = await btn
+                        .evaluate((el) => {
+                        if (el.getAttribute('aria-disabled') === 'true')
+                            return false;
+                        const cls = (el.className || '').toString();
+                        if (/disabled|is-disabled/.test(cls))
+                            return false;
+                        return true;
+                    })
+                        .catch(() => true);
+                    if (!enabled)
+                        continue;
+                    await btn.click({ timeout: 1500 });
+                    sent = true;
+                    break;
+                }
+                catch { }
             }
-            catch { }
+            if (!sent)
+                await this.page.waitForTimeout(150);
         }
         if (!sent) {
             await this.page.keyboard.press('Enter');
         }
         this._lastSentAt = Date.now();
-        this._askDebug('SENT at=' + this._lastSentAt);
+        this._askDebug('SENT at=' + this._lastSentAt + ' viaButton=' + sent);
+        // Verify the send REALLY went out: DeepSeek clears the input when the
+        // message is accepted. If the text is still there a moment later, the
+        // click/Enter was ignored (a disabled button during upload, a lost
+        // keystroke) — press Enter once more so the message is not silently stuck
+        // in the box (exactly the operator's "text + file in the box, no send").
+        try {
+            await this.page.waitForTimeout(300);
+            const stillThere = await input
+                .evaluate((el) => (el.value || el.innerText || el.textContent || '').trim())
+                .catch(() => '');
+            if (stillThere) {
+                this._askDebug('SEND not cleared, pressing Enter again');
+                await this.page.keyboard.press('Enter');
+                this._lastSentAt = Date.now();
+            }
+        }
+        catch { }
         // Wait for the start: either Stop appeared, or the answer text changed,
         // or the page grew (a new answer node / longer last answer). In parallel we
         // catch the rate-limit toast (only toasts, not the whole body).

package/dist/index.js

@@ -9,7 +9,7 @@ import { createTools } from './tools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
 import { LineEditor, expandPastes, pasteReplacement, formatCompactTokens, } from './input.js';
-import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, } from './attachments.js';
+import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, contentHash, } from './attachments.js';
 import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, } from './config.js';
 import { runConfigMenu } from './config-menu.js';
 import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n.js';
@@ -1506,6 +1506,7 @@ async function main() {
                     name,
                     mime: image.mime,
                     size: image.data.length,
+                    hash: contentHash(image.data),
                 });
                 ed.printAbove(theme.system(t('msg.attached_image', {
                     marker: att.marker,
@@ -1579,6 +1580,7 @@ async function main() {
                 name,
                 mime,
                 size: res.data.length,
+                hash: contentHash(res.data),
             });
             ed.printAbove(theme.system(t('msg.attached_image', {
                 marker: att.marker,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.43.0",
+  "version": "2.45.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {