zames_pro 2.29.4 → 2.29.6

package/dist/browser.js

@@ -1740,6 +1740,17 @@ export class DeepSeekBrowser {
             // code and the agent hung on "Stopped" until the timeout.
             if (this._netCaptureAt >= this._lastSentAt &&
                 isGenerationIncompleteText(this._netBody)) {
+                // PREFER the Continue button: it RESUMES the same truncated turn (a
+                // `chat/continue` request). Resending the prompt creates a NEW turn and
+                // duplicates the work. Only resend when there is no button to click.
+                if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                    this._askDebug('CLICKED Continue (incomplete, start-loop)');
+                    this._netBody = '';
+                    this._netCaptureAt = 0;
+                    this._netNoAnswer = false;
+                    await this.page.waitForTimeout(500);
+                    continue;
+                }
                 throw new GenerationIncompleteError(this._netBody.slice(-300));
             }
             // A FINISHED turn with NO answer (only reasoning): the UI shows a
@@ -1837,7 +1848,20 @@ export class DeepSeekBrowser {
             // treating this as "send failed" and hammering Enter.
             if (this._netCaptureAt >= this._lastSentAt &&
                 (isGenerationIncompleteText(this._netBody) || this._netNoAnswer)) {
-                throw new GenerationIncompleteError(this._netBody.slice(-300));
+                // Prefer Continue (resumes the same turn); resend only if unavailable.
+                if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                    this._askDebug('CLICKED Continue (incomplete, pre-loop)');
+                    this._netBody = '';
+                    this._netCaptureAt = 0;
+                    this._netNoAnswer = false;
+                    await this.page.waitForTimeout(500);
+                    started = true;
+                    // fall through to the finish loop by NOT returning here
+                    lastStartCur = cur;
+                }
+                else {
+                    throw new GenerationIncompleteError(this._netBody.slice(-300));
+                }
             }
             if (cur &&
                 cur.trim() &&
@@ -1905,30 +1929,32 @@ export class DeepSeekBrowser {
                     throw new ServerBusyError(pageText.slice(0, 300));
                 }
             }
-            // The server truncated the turn (generation_err / INCOMPLETE). The DOM
-            // keeps the partial answer, so without this check the loop waits out the
-            // whole timeout and throws ds.send_no_new_answer — the operator sees the
-            // agent "stop" with a Continue button in the chat. Retry the send.
-            // Runs on the RAW `_netBody` (a truncated body has no RESPONSE, so
-            // `_netCapture` is empty and the old guard was dead code).
-            if (this._netCaptureAt >= this._lastSentAt &&
-                isGenerationIncompleteText(this._netBody)) {
-                throw new GenerationIncompleteError(this._netBody.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) {
+            // The server truncated the turn (generation_err / INCOMPLETE) or ended
+            // it with only reasoning. PREFER the Continue button: it RESUMES the
+            // same turn (`chat/continue`). Resending the prompt creates a NEW turn
+            // and duplicates the work — only do that when there is no button to
+            // click. Runs on the RAW `_netBody` (a truncated body has no RESPONSE,
+            // so `_netCapture` is empty and the old guard was dead code).
+            const truncated = this._netCaptureAt >= this._lastSentAt &&
+                isGenerationIncompleteText(this._netBody);
+            const noAnswer = this._netNoAnswer && this._netCaptureAt >= this._lastSentAt;
+            if ((truncated || noAnswer) && this.autoContinue) {
                 if (await this._clickContinueIfVisible()) {
-                    this._askDebug('CLICKED Continue (net-no-answer, finish-loop)');
+                    this._askDebug('CLICKED Continue (finish-loop, truncated=' +
+                        truncated +
+                        ' noAnswer=' +
+                        noAnswer +
+                        ')');
+                    this._netBody = '';
                     this._netNoAnswer = false;
                     this._netCaptureAt = 0;
                     await this.page.waitForTimeout(500);
                     continue;
                 }
             }
+            if (truncated) {
+                throw new GenerationIncompleteError(this._netBody.slice(-300));
+            }
             // 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.

package/dist/commands.js

@@ -197,60 +197,115 @@ export function resolveExtraDir(input, workdir) {
     }
     return { path: abs };
 }
-/** How many characters of the dialogue are printed by default. */
+/** How many messages of the dialogue are printed by default. */
 export const RESTORED_HISTORY_LIMIT = 20;
 /**
- * Is this message worth showing to the operator as part of the dialogue?
+ * DeepSeek stores the assistant turn VERBATIM: either a raw tool-call JSON
+ * ({"tool":"Read","args":{...}}, frequently dirty/truncated) or a `respond`
+ * call that carries the real message for the operator
+ * ({"tool":"respond","args":{"message":"..."}}). The operator only wants the
+ * `respond` message (and plain-text answers) — a tool-call is protocol noise.
  *
- * The chat history contains a lot of protocol noise that is meaningless in
- * the terminal: the system-prompt (a huge REQUEST), tool results
- * ("Tool result for ..."), the agent's raw tool-calls (JSON / DSML), the
- * "You stopped after a tool result..." nudges, and the agent's <system> notes.
- * We keep only real user turns and real assistant answers.
+ * Returns the tool name and, for `respond`, the unwrapped message. Tolerant on
+ * purpose: the stored JSON is often dirty (a stray `}}`, a missing "args"
+ * wrapper), so a bare JSON.parse is not enough.
  */
-export function isDisplayableMessage(m) {
+export function parseAssistantToolCall(text) {
+    const t = String(text || '').trim();
+    if (!t)
+        return null;
+    // Broken heads like `<|tool": ...` or `tool": "Bash"` are tolerated.
+    const m = t.match(/tool"?\s*:\s*"([^"\s]+)"/);
+    if (!m)
+        return null;
+    const tool = m[1];
+    if (tool !== 'respond')
+        return { tool };
+    const greedy = t.match(/"message"\s*:\s*"([\s\S]*)"\s*\}*\s*$/);
+    let raw = greedy ? greedy[1] : '';
+    if (!greedy) {
+        const idx = t.indexOf('"message"');
+        if (idx >= 0)
+            raw = t.slice(idx + 9).replace(/^\s*:\s*"/, '');
+    }
+    return { tool, message: unescapeJsonString(raw) };
+}
+/** Decode the JSON escape sequences that appear inside a captured string. */
+export function unescapeJsonString(s) {
+    return String(s || '')
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_x, h) => String.fromCharCode(parseInt(h, 16)))
+        .replace(/\\n/g, NL)
+        .replace(/\\r/g, String.fromCharCode(13))
+        .replace(/\\t/g, String.fromCharCode(9))
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+}
+/**
+ * Normalize one restored message for display:
+ *  - USER: drop the protocol noise (system-prompt, tool results, nudges) — it
+ *    is not the operator's words.
+ *  - ASSISTANT: unwrap a `respond` call to its message; drop any other
+ *    tool-call (protocol noise); keep plain-text answers.
+ * Returns null when the message must not be shown.
+ */
+export function normalizeRestoredMessage(m) {
     const text = String((m && m.text) || '').trim();
     if (!text)
-        return false;
+        return null;
     if (text.length > 100_000)
-        return false; // the system-prompt / a giant blob
+        return null; // the system-prompt / a giant blob
     if (m.role === 'user') {
-        // Tool output, the system-prompt and the corrective nudges are not the
-        // operator's words.
         if (/^Tool result for /.test(text))
-            return false;
+            return null;
         if (/^You are a coding agent running in a terminal/.test(text))
-            return false;
+            return null;
         if (/^You stopped after a tool result/.test(text))
-            return false;
+            return null;
         if (/^\[system\]/.test(text))
-            return false;
+            return null;
         if (/^The user ran \//.test(text))
-            return false;
-        return true;
+            return null;
+        return { role: 'user', text };
     }
-    // Assistant: a tool-call (JSON or DSML) is not an answer to show. The
-    // DSML markers use FULL-WIDTH vertical bars (｜｜DSML), so the regex must
-    // match them, not the ASCII pipe.
     if (/DSML/i.test(text))
-        return false;
+        return null;
     if (/^<system>/i.test(text))
-        return false;
-    if (/"tool"\s*:/.test(text.slice(0, 600))) {
-        return false;
+        return null;
+    // The model sometimes emits its own safety-classification block as a plain
+    // "answer"; it is not for the operator.
+    if (/<ds_safety>/i.test(text))
+        return null;
+    if (/^Safe$/i.test(text))
+        return null;
+    const call = parseAssistantToolCall(text);
+    if (call) {
+        if (call.tool !== 'respond')
+            return null;
+        const msg = (call.message || '').trim();
+        if (!msg)
+            return null;
+        return { role: 'assistant', text: msg };
     }
-    if (/^\s*[\[{]/.test(text) && /"args"\s*:/.test(text.slice(0, 600))) {
-        return false;
-    }
-    return true;
+    // A plain-text answer (written without the respond wrapper) — show as-is.
+    return { role: 'assistant', text };
+}
+/** Back-compat predicate: is the message worth showing at all? */
+export function isDisplayableMessage(m) {
+    return normalizeRestoredMessage(m) !== null;
 }
 /**
- * Keep only the last `limit` messages and drop empties/service noise. The
- * source (network history or DOM) may contain protocol messages; they are
- * filtered out here so the terminal output stays readable.
+ * Keep only the last `limit` messages, dropping protocol noise and UNWRAPPING
+ * the assistant `respond` calls to their operator-facing text.
  */
 export function trimRestoredMessages(messages, limit = RESTORED_HISTORY_LIMIT) {
-    const clean = (messages || []).filter((m) => m && typeof m.text === 'string' && isDisplayableMessage(m));
+    const clean = [];
+    for (const m of messages || []) {
+        if (!m || typeof m.text !== 'string')
+            continue;
+        const n = normalizeRestoredMessage(m);
+        if (n)
+            clean.push(n);
+    }
     if (limit > 0 && clean.length > limit)
         return clean.slice(clean.length - limit);
     return clean;

package/dist/i18n.js

@@ -534,8 +534,8 @@ const CATALOG = {
         en: '⚠ No answer yet ({attempt}/{max}): {error} — retrying...',
     },
     'ds.incomplete_retry': {
-        ru: '⏳ DeepSeek оборвал ответ (кнопка Continue в чате) — повторяю отправку ({attempt}/{max})...',
-        en: '⏳ DeepSeek truncated the answer (the Continue button in the chat) — resending ({attempt}/{max})...',
+        ru: '⏳ DeepSeek оборвал ответ — жму «Continue», чтобы продолжить (повтор {attempt}/{max})...',
+        en: '⏳ DeepSeek truncated the answer — clicking Continue to resume (retry {attempt}/{max})...',
     },
     'ds.incomplete_give_up': {
         ru: '✖ DeepSeek {attempt} раз подряд оборвал ответ, не дойдя до конца. Возможно, включён режим размышления — попробуй выключить его (browser.deepThinking) или повтори позже.',

package/dist/index.js

@@ -828,6 +828,12 @@ async function printRestoredHistory(browser, ui, chatId = null) {
         all = await browser.readChatMessages().catch(() => []);
         domCount = all.length;
     }
+    // `all` is the raw history (mostly protocol noise). `displayable` is what
+    // survives normalization; `messages` is the last RESTORED_HISTORY_LIMIT of
+    // those. The "truncated" note must compare the DISPLAYABLE count with the
+    // limit (comparing `all.length` always fired, because tool-calls are
+    // dropped and the raw history is always longer).
+    const displayable = trimRestoredMessages(all, 0);
     const messages = trimRestoredMessages(all);
     // Always surface the diagnostic line when the history could not be turned
     // into anything printable — otherwise "the dialogue is empty" is a dead end
@@ -868,7 +874,7 @@ async function printRestoredHistory(browser, ui, chatId = null) {
                 NL);
         }
     }
-    if (all.length > messages.length) {
+    if (displayable.length > messages.length) {
         out(theme.dim(t('chats.history_truncated', { n: String(RESTORED_HISTORY_LIMIT) })));
     }
 }

package/package.json

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