zames_pro 2.29.2 → 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];
@@ -1633,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.
@@ -1697,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).
@@ -1848,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.
@@ -1917,6 +1963,16 @@ 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.

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.2",
+  "version": "2.29.3",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {