zames_pro 2.29.1 → 2.29.3

package/dist/browser.js

@@ -1,5 +1,5 @@
 import { chromium, } from 'playwright';
-import { extractAnswer, extractTokenUsage, dumpNetBody } from './net-capture.js';
+import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, } from './net-capture.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs/promises';
@@ -317,6 +317,10 @@ export class DeepSeekBrowser {
     page;
     _netCapture;
     _netCaptureAt;
+    // True when the LAST response body was a FINISHED turn with NO answer text
+    // (only reasoning). The DOM keeps showing reasoning/old text, so the loop
+    // must not wait it out — it clicks Continue / resends. Reset before a send.
+    _netNoAnswer;
     _netChatId;
     // The latest CONTEXT size (in tokens) DeepSeek reported in the current
     // chat. It is the `accumulated_token_usage` counter taken from the SSE
@@ -380,6 +384,7 @@ export class DeepSeekBrowser {
         this._stopped = false;
         this._netCapture = '';
         this._netCaptureAt = 0;
+        this._netNoAnswer = false;
         this._netChatId = null;
         this._lastTokenUsage = null;
         this._toggles = { deepThinking, webSearch };
@@ -543,6 +548,19 @@ export class DeepSeekBrowser {
             const extracted = extractAnswer(body);
             if (extracted) {
                 this._netCapture = extracted;
+                this._netNoAnswer = false;
+                const cid = url.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
+                if (cid)
+                    this._netChatId = cid[0];
+                this._netCaptureAt = Date.now();
+            }
+            else if (/chat\/(completion|continue)/i.test(url) &&
+                isFinishedWithoutAnswer(body)) {
+                // A FINISHED turn with NO RESPONSE fragment (only reasoning): the UI
+                // shows a Continue button. Record it with a fresh timestamp so the
+                // ask() loops do not wait out the timeout — they click Continue.
+                this._netNoAnswer = true;
+                this._netCapture = '';
                 const cid = url.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
                 if (cid)
                     this._netChatId = cid[0];
@@ -1063,6 +1081,35 @@ export class DeepSeekBrowser {
     async _isGenerating() {
         return await this._stopButtonVisible();
     }
+    // Is DeepSeek's "Continue" button currently visible? Used to BLOCK the
+    // "answer settled" early-return in the finish loop: while Continue is on
+    // screen the generation is PAUSED, not finished, so returning the partial
+    // text there is exactly the "agent stopped with a Continue button" bug.
+    async _continueButtonVisible() {
+        try {
+            return await this.page.evaluate(() => {
+                const labelOf = (b) => ((b.textContent || '') + ' ' + (b.getAttribute('aria-label') || ''))
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                const isExact = (t) => /^(continue|продолжить|продолжение)\s*[.!…]?$/i.test(t);
+                const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+                for (const e of cands) {
+                    if (!isExact(labelOf(e)))
+                        continue;
+                    const st = getComputedStyle(e);
+                    if (st.display === 'none' || st.visibility === 'hidden')
+                        continue;
+                    if (!e.offsetParent && st.position !== 'fixed')
+                        continue;
+                    return true;
+                }
+                return false;
+            });
+        }
+        catch {
+            return false;
+        }
+    }
     // Click the DeepSeek "Continue" button when it is visible (reasoning/answer
     // paused by the server). Returns true when a click happened.
     //
@@ -1091,6 +1138,27 @@ export class DeepSeekBrowser {
                         continue;
                     if (!e.offsetParent && st.position !== 'fixed')
                         continue;
+                    // DeepSeek's button is a React component listening for POINTER/mouse
+                    // events, not just a bare click(). A plain e.click() sometimes does
+                    // nothing; dispatching the full sequence is what a real press does.
+                    const rect = e.getBoundingClientRect();
+                    const cx = rect.left + rect.width / 2;
+                    const cy = rect.top + rect.height / 2;
+                    const opts = {
+                        bubbles: true,
+                        cancelable: true,
+                        composed: true,
+                        clientX: cx,
+                        clientY: cy,
+                        button: 0,
+                    };
+                    try {
+                        e.dispatchEvent(new PointerEvent('pointerdown', opts));
+                        e.dispatchEvent(new MouseEvent('mousedown', opts));
+                        e.dispatchEvent(new PointerEvent('pointerup', opts));
+                        e.dispatchEvent(new MouseEvent('mouseup', opts));
+                    }
+                    catch { }
                     e.click();
                     return true;
                 }
@@ -1583,6 +1651,7 @@ export class DeepSeekBrowser {
         }
         this._netCapture = '';
         this._netCaptureAt = 0;
+        this._netNoAnswer = false;
         // Align the DeepSeek chat toggles (deep thinking / web search) with the
         // configured state BEFORE typing. Doing it here (after the send-pause) it
         // does not flip toggles for a generation that is not going to happen.
@@ -1647,6 +1716,19 @@ export class DeepSeekBrowser {
                 isGenerationIncompleteText(this._netCapture)) {
                 throw new GenerationIncompleteError(this._netCapture.slice(-300));
             }
+            // A FINISHED turn with NO answer (only reasoning): the UI shows a
+            // Continue button. Click it (or, if autoContinue is off, keep waiting)
+            // instead of spinning to the deadline on an empty answer.
+            if (this._netNoAnswer && this._netCaptureAt >= this._lastSentAt) {
+                this._askDebug('START-loop net-no-answer');
+                if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                    this._askDebug('CLICKED Continue (net-no-answer, start-loop)');
+                    this._netNoAnswer = false;
+                    this._netCaptureAt = 0;
+                    await this.page.waitForTimeout(500);
+                    continue;
+                }
+            }
             // Reasoning-mode pause during the THINK phase: click Continue so the
             // generation resumes (the button appears before any RESPONSE text, so
             // the start-wait would otherwise spin until the deadline).
@@ -1688,7 +1770,10 @@ export class DeepSeekBrowser {
             // capture proves a new answer exists. If it stays equal, keep waiting.
             const notGenerating = !(await this._isGenerating());
             const differs = !!cur && normText(cur) !== normText(beforeText);
-            if (differs && cur === lastStartCur && notGenerating) {
+            // Do NOT accept a "settled" answer while Continue is on screen — that
+            // is a paused generation, not a finished one.
+            const paused = this.autoContinue && (await this._continueButtonVisible());
+            if (differs && cur === lastStartCur && notGenerating && !paused) {
                 settledTicks++;
                 if (settledTicks >= 2) {
                     this._askDebug('SETTLED-differs return len=' + cur.length);
@@ -1795,6 +1880,20 @@ export class DeepSeekBrowser {
                 isGenerationIncompleteText(this._netCapture)) {
                 throw new GenerationIncompleteError(this._netCapture.slice(-300));
             }
+            // A FINISHED turn with NO answer (only reasoning): the UI shows a
+            // Continue button. Click it and keep waiting — otherwise the loop spins
+            // to the deadline on an empty answer and the operator sees "Stopped".
+            if (this._netNoAnswer &&
+                this._netCaptureAt >= this._lastSentAt &&
+                this.autoContinue) {
+                if (await this._clickContinueIfVisible()) {
+                    this._askDebug('CLICKED Continue (net-no-answer, finish-loop)');
+                    this._netNoAnswer = false;
+                    this._netCaptureAt = 0;
+                    await this.page.waitForTimeout(500);
+                    continue;
+                }
+            }
             // Reasoning-mode pause: DeepSeek caps the THINK phase and shows a
             // Continue button; the model does not resume by itself. Click it so the
             // answer keeps flowing instead of waiting for the operator.
@@ -1829,7 +1928,17 @@ export class DeepSeekBrowser {
                 // so the FIN-loop always cost ~1.6s per answer. Defaults are now
                 // 2 checks x 400ms (~0.8s saved per turn) and the values are honored.
                 if (stable >= Math.max(1, this.stabilityChecks - 1)) {
-                    if (isNew || !(await this._isGenerating())) {
+                    // A PAUSED generation also looks "stable" (the text stops changing
+                    // while Continue is on screen), so the old check returned the
+                    // partial answer here — the "agent stopped with a Continue button"
+                    // symptom. Click Continue and keep waiting instead.
+                    if (this.autoContinue && (await this._continueButtonVisible())) {
+                        if (await this._clickContinueIfVisible()) {
+                            this._askDebug('CLICKED Continue (before early return)');
+                        }
+                        stable = 0;
+                    }
+                    else if (isNew || !(await this._isGenerating())) {
                         this._askDebug('RETURN stable curLen=' + cur.length);
                         return cur;
                     }
@@ -1854,7 +1963,21 @@ export class DeepSeekBrowser {
                 netFresh);
             await this.page.waitForTimeout(Math.max(0, this.stabilityDelayMs));
         }
+        // A FINISHED turn with NO answer text (only reasoning) must NOT be
+        // returned as a final answer, and must not hang until the timeout either.
+        // Treat it like a truncated turn: ask() resends the prompt (the same thing
+        // the Continue button does). Only if a real capture arrived in the
+        // meantime do we fall through to return it.
+        if (this._netNoAnswer &&
+            this._netCaptureAt >= this._lastSentAt &&
+            !this._netCapture) {
+            throw new GenerationIncompleteError('finished without answer');
+        }
         if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
+            // If Continue is STILL on screen, the turn is paused, not finished:
+            // click once more and report what we have rather than silently stopping.
+            if (this.autoContinue)
+                await this._clickContinueIfVisible();
             this._askDebug('RETURN last len=' + last.length);
             return last;
         }

package/dist/input.js

@@ -233,6 +233,10 @@ export class LineEditor {
     pendingText;
     rendered;
     cursorRowFromTop;
+    // Number of rows occupied by the status/spinner block above the input line,
+    // as computed by the last _writeBlock(). _renderInputOnly() uses it to keep
+    // cursorRowFromTop correct without repainting the status.
+    _statusTop;
     busy;
     onSubmit;
     onEscape;
@@ -309,6 +313,7 @@ export class LineEditor {
         this.pendingText = null;
         this.rendered = false;
         this.cursorRowFromTop = 0;
+        this._statusTop = 0;
         this.busy = false;
         this.onSubmit = null;
         this.onEscape = null;
@@ -642,6 +647,7 @@ export class LineEditor {
         // re-printing the whole block on every keystroke is what made the display
         // flicker on terminals like Tabby. `top` is recovered from the cache so the
         // cursor math stays correct.
+        this._statusTop = top;
         const statusBlock = statusOut;
         const statusUnchanged = this.rendered && statusBlock === this._lastStatusBlock;
         if (statusUnchanged) {
@@ -729,6 +735,52 @@ export class LineEditor {
         this._eraseBlock();
         this._writeBlock();
     }
+    // Repaint ONLY the input rows, leaving the status/spinner block untouched.
+    // Used for buffer/cursor changes (typing, arrows, backspace, …): the status
+    // line has its OWN animation timer, and repainting it on every keystroke
+    // made the whole block blink on terminals like Tabby. When nothing is drawn
+    // yet (rendered === false) fall back to a full render so the very first
+    // paint is correct.
+    _renderInputOnly() {
+        if (!this.rendered) {
+            this._render();
+            return;
+        }
+        const cols = process.stdout.columns || 80;
+        const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
+        const inputRows = lay.rows.length;
+        const sugg = this._suggestions();
+        const shown = sugg.slice(0, 8);
+        this._suggestCount = shown.length;
+        const linesBelow = shown.length
+            ? shown.length + (sugg.length > shown.length ? 1 : 0)
+            : 0;
+        this._eraseInputOnly(inputRows + linesBelow);
+        let out = lay.rows.map((r) => r.prefix + r.text).join(NL);
+        if (shown.length) {
+            const maxName = Math.max(...shown.map((c) => c.name.length));
+            const lines = shown.map((c) => {
+                const name = theme.prompt(c.name.padEnd(maxName));
+                const desc = theme.dim('  ' + c.description);
+                return '   ' + name + desc;
+            });
+            out += NL + lines.join(NL);
+            const hidden = sugg.length - shown.length;
+            if (hidden > 0)
+                out +=
+                    NL +
+                        theme.dim('   ' + translate(this.locale)('editor.more', { n: hidden }));
+        }
+        process.stdout.write(out);
+        const up = lay.rows.length - 1 - lay.cursorRow + linesBelow;
+        if (up > 0)
+            process.stdout.write(ESC + '[' + up + 'A');
+        process.stdout.write(CR);
+        if (lay.cursorCol > 0)
+            process.stdout.write(ESC + '[' + lay.cursorCol + 'C');
+        this.rendered = true;
+        this.cursorRowFromTop = this._statusTop + lay.cursorRow;
+    }
     // Print a block ABOVE the input line and put the input line back.
     printAbove(text) {
         this._stopDots();
@@ -1185,7 +1237,7 @@ export class LineEditor {
                     }
                     this._pasteBuf = '';
                 }
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             const pasteAt = s.indexOf(PASTE_START);
@@ -1196,7 +1248,7 @@ export class LineEditor {
                 this._pasteBuf = '';
                 if (before) {
                     this._insert(before);
-                    this._render();
+                    this._renderInputOnly();
                 }
                 continue;
             }
@@ -1205,31 +1257,31 @@ export class LineEditor {
             if (s.startsWith(ESC + '[13;2u')) {
                 this._insertNewline();
                 s = s.slice(7);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + '[13;5u')) {
                 this._insertNewline();
                 s = s.slice(7);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + '[27;2;13~')) {
                 this._insertNewline();
                 s = s.slice(10);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + '[27;5;13~')) {
                 this._insertNewline();
                 s = s.slice(10);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (s.startsWith(ESC + NL)) {
                 this._insertNewline();
                 s = s.slice(2);
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             const ch = s[0];
@@ -1243,7 +1295,7 @@ export class LineEditor {
                 const before = this.cursor > 0 ? Array.from(this.buf)[this.cursor - 1] : '';
                 if (before === '\\') {
                     this._insertNewline();
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 this._submit();
@@ -1251,7 +1303,7 @@ export class LineEditor {
             }
             if (code === 10) {
                 this._insertNewline();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 3) {
@@ -1266,24 +1318,24 @@ export class LineEditor {
             }
             if (code === 1) {
                 this._home();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 5) {
                 this._end();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 9) {
                 this._completeCommand();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 21) {
                 this.buf = '';
                 this.cursor = 0;
                 this.pastes = [];
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 22) {
@@ -1295,7 +1347,7 @@ export class LineEditor {
             }
             if (code === 23) {
                 this._deleteWordLeft();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 11) {
@@ -1306,12 +1358,12 @@ export class LineEditor {
                     e++;
                 arr.splice(this.cursor, e - this.cursor);
                 this.buf = arr.join('');
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 127 || code === 8) {
                 this._backspace();
-                this._render();
+                this._renderInputOnly();
                 continue;
             }
             if (code === 27) {
@@ -1320,25 +1372,25 @@ export class LineEditor {
                 if (s.startsWith('[1;5D') || s.startsWith('[5D')) {
                     this._wordLeft();
                     s = s.slice(s.startsWith('[1;5D') ? 5 : 3);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[1;5C') || s.startsWith('[5C')) {
                     this._wordRight();
                     s = s.slice(s.startsWith('[1;5C') ? 5 : 3);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[D')) {
                     this._left();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[C')) {
                     this._right();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[A')) {
@@ -1348,7 +1400,7 @@ export class LineEditor {
                     else
                         this._up();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[B')) {
@@ -1357,38 +1409,38 @@ export class LineEditor {
                     else
                         this._down();
                     s = s.slice(2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[H') || s.startsWith('[1~')) {
                     this._home();
                     s = s.slice(s.startsWith('[1~') ? 3 : 2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[F') || s.startsWith('[4~')) {
                     this._end();
                     s = s.slice(s.startsWith('[4~') ? 3 : 2);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('[3~')) {
                     this._delete();
                     s = s.slice(3);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 // Alt+B / Alt+F — word movement.
                 if (s.startsWith('b') || s.startsWith('B')) {
                     this._wordLeft();
                     s = s.slice(1);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 if (s.startsWith('f') || s.startsWith('F')) {
                     this._wordRight();
                     s = s.slice(1);
-                    this._render();
+                    this._renderInputOnly();
                     continue;
                 }
                 let j = 0;
@@ -1400,7 +1452,7 @@ export class LineEditor {
             if (code < 32)
                 continue;
             this._insert(ch);
-            this._render();
+            this._renderInputOnly();
         }
     }
 }

package/dist/net-capture.js

@@ -159,6 +159,32 @@ export function extractAnswer(body) {
         return sse;
     return extractFromJson(body);
 }
+// True when the SSE body shows a turn that ENDED (`quasi_status: FINISHED`)
+// but produced NO answer text — the reasoning (THINK fragment) was generated
+// and then the model stopped WITHOUT writing a RESPONSE fragment.
+//
+// This is the "Stopped + Continue button" case: DeepSeek finishes the turn
+// with only reasoning, the UI shows a Continue button, and extractAnswer()
+// returns '' (it only collects RESPONSE fragments). The old code then saw an
+// empty capture, ignored it, and the finish loop waited out the whole timeout
+// and threw ds.send_no_new_answer — to the operator the agent "hung on Stopped".
+// Unlike generation_err, `quasi_status` here is FINISHED, so
+// isGenerationIncompleteText() does NOT catch it.
+//
+export function isFinishedWithoutAnswer(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    const finished = /"quasi_status","v":"FINISHED"/i.test(b);
+    if (!finished)
+        return false;
+    // A RESPONSE fragment with actual content means the model DID answer.
+    if (/"type":"RESPONSE","content":"[^"]/.test(b))
+        return false;
+    // The turn carried reasoning (THINK) or was truncated mid-way; treat the
+    // absence of response content as "no answer produced".
+    return true;
+}
 // The CONTEXT size (in tokens) DeepSeek reports for the current answer.
 //
 // chat.deepseek.com does not expose prompt_tokens/completion_tokens the way

package/package.json

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