zames_pro 2.10.7 → 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

package/package.json

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