zames_pro 2.10.5 → 2.10.8

package/dist/agent-loop.js

@@ -117,6 +117,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // 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 = '';
+    // True when the PREVIOUS turn actually executed a tool. This is what
+    // makes a repeated answer "stale": the tool already ran, so running it
+    // again would duplicate side effects. If the previous answer looked like a
+    // call but was not recognized (e.g. a DSML/XML form the strict parser
+    // missed), the tool did NOT run and the echo is the only copy of the
+    // call — it must be executed, not discarded as stale.
+    // const ranToolLastTurn follows the previous turn's actual effect.
+    let lastTurnRanTool = false;
     let justRanTool = false;
     let watchdogRetries = 0;
     const MAX_WATCHDOG_RETRIES = 3;
@@ -131,6 +139,11 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // Subsequent ones (tool-result and resend requests) are agent sends:
         // throttled so we don't hit the rate limit.
         const isFirst = i === 0;
+        // Did the PREVIOUS turn actually execute a tool? Used by the stale
+        // check below. We take a snapshot and immediately clear it: it will be
+        // set again at the end of this iteration only if a tool really runs.
+        const ranToolPrevTurn = lastTurnRanTool;
+        lastTurnRanTool = false;
         // Safety net: browser.ask() has its own timeout, but a stuck send used to
         // block the whole loop and look like a silent stop. We race it against a
         // hard deadline and treat a timeout as a nudge (re-ask), never as a
@@ -194,18 +207,31 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // previous answer with different markdown emphasis (`**done**` vs `done`),
         // which defeated an exact match and made the loop run the SAME tool again —
         // the "stopped after a tool call" signature with a duplicate call.
-        const wdStale = justRanTool &&
+        //
+        // AN ECHO IS NOT ALWAYS STALE: the previous answer may have been a
+        // DSML/XML call that the strict parser missed and the loop never actually
+        // ran. In that case the echo is the ONLY copy of the call we can get,
+        // and discarding it as "stale" burns the watchdog budget and stalls the
+        // agent. So we first check whether the echo itself parses as a tool
+        // call (including the XML/DSML form); if it does, we do NOT treat it
+        // as stale — the call gets run below like any other.
+        // Stale means: the PREVIOUS turn actually ran a tool (lastTurnRanTool)
+        // and this answer is a repeat of the previous one. If the previous
+        // answer never ran a tool (unrecognized DSML call), the repeat is NOT
+        // stale — it is the only copy of the call and must be executed.
+        const staleCandidate = ranToolPrevTurn &&
             lastRaw.trim() !== '' &&
             (rawResponse.trim() === lastRaw.trim() ||
                 normForStale(rawResponse) === normForStale(lastRaw));
+        const wdStale = staleCandidate;
         const wdNoCall = justRanTool &&
             !wdEmpty &&
             !wdStale &&
             parseToolCall(rawResponse) === null &&
             !responseLooksLikeToolCall(rawResponse);
-        // A stale answer is discarded even when it parses to a valid call: it is a
-        // duplicate of the previous turn, and re-running the tool would repeat
-        // side effects and stall the loop.
+        // A stale answer is discarded only when it does NOT parse as a tool
+        // call (see wdStale above); an echo of a call that never ran is a real
+        // call and must be executed, not dropped.
         if (!isFirst && (wdEmpty || wdStale || wdNoCall) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
             watchdogRetries++;
             transcript?.log('watchdog_nudge', {
@@ -464,6 +490,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // 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;
+        // The tool really executed on this turn. The NEXT iteration will treat
+        // a repeat of this answer as stale only because of this flag (see NEXT,
+        // not the current, justRanTool check).
+        lastTurnRanTool = true;
         watchdogRetries = 0;
         // A fresh tool call just ran: reset the per-tool-result nudge budget so
         // a long chain of tools is not cut off by an earlier bad turn.

package/dist/browser.js

@@ -460,7 +460,11 @@ export class DeepSeekBrowser {
                         throw e;
                     }
                     console.error(theme.warn(`⏳ DeepSeek: «слишком часто». Жду ${Math.ceil(this.rateLimitWaitMs / 60000)} мин (${rateLimitRetries}/${this.maxRateLimitRetries}) и повторю...`));
-                    await this.page.waitForTimeout(this.rateLimitWaitMs);
+                    // Interruptible: Esc/Ctrl+C must cancel this long wait too,
+                    // otherwise "stop" stays frozen for up to 5 minutes.
+                    const aborted = await this._sleepInterruptible(this.rateLimitWaitMs);
+                    if (aborted)
+                        return '(прервано пользователем)';
                     continue;
                 }
                 console.error(`\n⚠ ask() попытка ${attempt}/${this.askRetries} провалилась: ${e.message}`);
@@ -605,6 +609,12 @@ export class DeepSeekBrowser {
     // 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.
+    //
+    // The wait is INTERRUPTIBLE: Esc/Ctrl+C sets _abort, and we check it every
+    // 100ms instead of one long page.waitForTimeout(gap). Before, Esc pressed
+    // during this pause did nothing to the pause itself — the send was still
+    // delayed by the remaining seconds, and the stop request only took effect
+    // after the pause. This is the main "Esc does not cancel the pause" bug.
     async _waitForSendSlot(agent) {
         if (!agent)
             return;
@@ -614,7 +624,21 @@ export class DeepSeekBrowser {
         if (gap <= 0)
             return;
         console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
-        await this.page.waitForTimeout(gap);
+        await this._sleepInterruptible(gap);
+    }
+    // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
+    // Returns true if the sleep was cut short by _abort.
+    async _sleepInterruptible(ms) {
+        const step = 100;
+        let left = ms;
+        while (left > 0) {
+            if (this._abort)
+                return true;
+            const chunk = Math.min(step, left);
+            await this.page.waitForTimeout(chunk);
+            left -= chunk;
+        }
+        return this._abort;
     }
     // DEBUG: append ask() phases to ~/.zames/ask-debug.log so a stall can be
     // diagnosed from the field (what the DOM/network looked like at each step).
@@ -630,7 +654,12 @@ export class DeepSeekBrowser {
     }
     async _askOnce(prompt, { timeout, agent, attachments = [], }) {
         // We reset the abort flag ONLY at the very start of the send.
+        // _stopped (Esc for the WHOLE batch) is NOT reset here: it may have been
+        // set while a previous send was waiting in the pause. If it is set, the
+        // user asked to stop and we must not start a new generation at all.
         this._abort = false;
+        if (this._stopped)
+            return '(прервано пользователем)';
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
         if (!input) {
             throw new Error('Не найдено поле ввода. Запустите /debug-dom и поправьте INPUT_SELECTORS.');
@@ -638,6 +667,9 @@ export class DeepSeekBrowser {
         const beforeText = await this._readLastAnswerTextClean().catch(() => '');
         this._askDebug('SEND agent=' + agent + ' len=' + prompt.length + ' beforeLen=' + beforeText.length + ' beforeHead=' + JSON.stringify(beforeText.slice(0, 60)));
         await this._waitForSendSlot(agent);
+        // Esc/Ctrl+C pressed during the pause — do not send anything.
+        if (this._abort)
+            return '(прервано пользователем)';
         this._netCapture = '';
         this._netCaptureAt = 0;
         // Attach files/images FIRST (before the text): the DeepSeek upload widget
@@ -669,7 +701,7 @@ export class DeepSeekBrowser {
         // Wait for the start: either Stop appeared, or the answer text changed,
         // or the total amount of text on the page grew. In parallel we catch
         // the rate-limit toast (only toasts, not the whole body).
-        const startDeadline = Date.now() + 15_000;
+        const startDeadline = Date.now() + 30_000;
         const startBodyLen = await this.page
             .evaluate(() => document.body.innerText.length)
             .catch(() => 0);
@@ -749,10 +781,36 @@ export class DeepSeekBrowser {
             if (fresh) {
                 return this._netCapture;
             }
-            // We NO LONGER check the limit over the whole page text — that caused
-            // false positives and 5-minute waits. We just report that
-            // generation did not start.
-            throw new Error('Ответ не начал генерироваться за 15с. Возможно, сообщение не отправилось.');
+            // The send did not start generation within 15s. The most common cause is
+            // that the message did not actually go out (Enter lost, button not
+            // clicked). Instead of throwing (which made ask() retry for minutes and
+            // looked like a stall), press Enter once more and give it another
+            // window. Only if that also fails do we throw.
+            this._askDebug('START-failed, resending');
+            await this.page.keyboard.press('Enter');
+            this._lastSentAt = Date.now();
+            const retryDeadline = Date.now() + 20_000;
+            while (Date.now() < retryDeadline) {
+                if (this._abort)
+                    return '(прервано пользователем)';
+                const cur2 = await this._readLastAnswerTextClean().catch(() => '');
+                const net2 = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
+                const grew2 = (await this.page
+                    .evaluate(() => document.body.innerText.length)
+                    .catch(() => 0)) > startBodyLen;
+                if (net2 ||
+                    grew2 ||
+                    (!!cur2 && normText(cur2) !== normText(beforeText))) {
+                    started = true;
+                    this._askDebug('STARTED-after-resend');
+                    break;
+                }
+                await this.page.waitForTimeout(300);
+            }
+        }
+        if (!started) {
+            throw new Error('Ответ не начал генерироваться за 35с даже после повторной отправки. ' +
+                'Проверьте чат DeepSeek вручную.');
         }
         // Wait until the answer stops changing. We check the "not generating"
         // condition via text growth, NOT via _isGenerating().
@@ -791,7 +849,7 @@ export class DeepSeekBrowser {
             // tool call" hang. If generation has clearly ENDED (no Stop button) and
             // the text is stable, accept it (even when it repeats the previous one).
             const sameAsBefore = !!cur && !isNew && normText(cur) === normText(beforeText);
-            if ((isNew || sameAsBefore) && cur === last) {
+            if (isNew && cur === last) {
                 stable++;
                 if (stable >= 2) {
                     if (isNew || !(await this._isGenerating())) {
@@ -803,7 +861,7 @@ export class DeepSeekBrowser {
             else {
                 stable = 0;
             }
-            if (isNew || sameAsBefore)
+            if (isNew)
                 last = cur;
             this._askDebug('FIN-loop isNew=' + isNew + ' sameAsBefore=' + sameAsBefore + ' stable=' + stable + ' curLen=' + cur.length + ' lastLen=' + last.length + ' netFresh=' + netFresh);
             await this.page.waitForTimeout(800);
@@ -812,10 +870,8 @@ export class DeepSeekBrowser {
             this._askDebug('RETURN last len=' + last.length);
             return last;
         }
-        // Fallback: the turn settled on a text identical to the previous answer.
-        if (last && !(await this._isGenerating())) {
-            return last;
-        }
+        // No fallback on a text equal to beforeText: returning it would re-run
+        // the previous tool call. Only a fresh network capture is accepted below.
         if (this._netCapture && this._netCaptureAt >= this._lastSentAt) {
             return this._netCapture;
         }

package/package.json

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