zames_pro 2.10.1 → 2.10.4

package/dist/agent-loop.js

@@ -2,7 +2,29 @@ import { buildSystemPrompt } from './system-prompt.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
+import { normText } from './browser.js';
 export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
+    // UI callbacks must NEVER break the agent loop. A rendering error (a huge
+    // tool result, a broken markdown frame, a closed terminal) used to throw
+    // out of the loop right after a tool call — the session looked "stopped
+    // after a tool call", with a tool_call but no tool_result in the log. We
+    // wrap every callback so a UI failure is swallowed and the loop continues.
+    const safe = (fn) => {
+        return (...a) => {
+            try {
+                fn(...a);
+            }
+            catch {
+                // Intentionally ignored: the loop must survive UI failures.
+            }
+        };
+    };
+    const safeThinking = safe(onThinking);
+    const safeAssistantThought = safe(onAssistantThought);
+    const safeToolCall = safe(onToolCall);
+    const safeToolResult = safe(onToolResult);
+    const safeAssistantMessage = safe(onAssistantMessage);
+    const safeWarning = safe(onWarning);
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
@@ -42,7 +64,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             length: systemPrompt.length,
             gitContext: gitText,
         });
-        onThinking();
+        safeThinking();
         // system-prompt is an agent send: throttled (agent: true).
         await browser.ask(systemPrompt, { timeout: 60_000, agent: true });
         await reportChat();
@@ -104,7 +126,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     let afterToolRetries = 0;
     const MAX_AFTER_TOOL_RETRIES = 6;
     for (let i = 0; i < maxIterations; i++) {
-        onThinking();
+        safeThinking();
         // The first message (task) is user input: no throttle.
         // Subsequent ones (tool-result and resend requests) are agent sends:
         // throttled so we don't hit the rate limit.
@@ -139,7 +161,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 attempt: afterToolRetries,
                 error: e.message,
             });
-            onWarning('browser.ask() не вернул ответ за ' +
+            safeWarning('browser.ask() не вернул ответ за ' +
                 Math.round(askDeadlineMs / 1000) +
                 'с — повторяю запрос.');
             if (afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
@@ -150,7 +172,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             transcript?.log('ask_timeout_exhausted', {
                 message: 'ask() не вернул ответ и лимит повторов исчерпан',
             });
-            onWarning('browser.ask() перестал отвечать; лимит повторов исчерпан, ' +
+            safeWarning('browser.ask() перестал отвечать; лимит повторов исчерпан, ' +
                 'останавливаюсь. Ответа модели нет — проверьте чат DeepSeek вручную.');
             return 'ask() watchdog: ответ модели не получен';
         }
@@ -168,14 +190,22 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // cut-off "Stale. Let me ..." or a truncated JSON). All three mean the
         // turn is unfinished: nudge instead of stopping.
         const wdEmpty = !String(rawResponse || '').trim();
+        // STALE is compared on NORMALIZED text: DeepSeek often echoes the
+        // 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 &&
             lastRaw.trim() !== '' &&
-            rawResponse.trim() === lastRaw.trim();
+            (rawResponse.trim() === lastRaw.trim() ||
+                normForStale(rawResponse) === normForStale(lastRaw));
         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.
         if (!isFirst && (wdEmpty || wdStale || wdNoCall) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
             watchdogRetries++;
             transcript?.log('watchdog_nudge', {
@@ -205,7 +235,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         if (parsed) {
             const thought = extractPreToolText(rawResponse);
             if (thought)
-                onAssistantThought(thought);
+                safeAssistantThought(thought);
         }
         const parsedCalls = Array.isArray(parsed) ? parsed : parsed ? [parsed] : [];
         if (parsedCalls.some((p) => p && p._permissive)) {
@@ -341,7 +371,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 // not be turned into a tool call even after all retries: warn the
                 // operator instead of silently printing e.g. "Stale. Let me verify".
                 transcript?.log('suspicious_final', { response: rawResponse });
-                onWarning(translate(locale)('msg.suspicious_stop'));
+                safeWarning(translate(locale)('msg.suspicious_stop'));
             }
             // A meaningful plain-text answer (e.g. a final report the model forgot to
             // wrap in respond) is surfaced as-is WITHOUT a warning: after the bounded
@@ -393,11 +423,11 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // the task normally.
             if (!isMeaningfulRespond(msg)) {
                 transcript?.log('empty_respond_exhausted', { response: rawResponse });
-                onWarning('Модель вызвала respond без текста, и лимит повторов исчерпан. ' +
+                safeWarning('Модель вызвала respond без текста, и лимит повторов исчерпан. ' +
                     'Проверьте чат DeepSeek вручную.');
                 return 'Модель не сформировала итоговое сообщение (пустой respond).';
             }
-            onAssistantMessage(msg);
+            safeAssistantMessage(msg);
             transcript?.log('assistant_final', { message: msg });
             return msg;
         }
@@ -410,12 +440,12 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             const tool = tools.find((t) => t.name === call.tool);
             if (!tool) {
                 const err = `Неизвестный инструмент: ${call.tool}`;
-                onToolResult(err);
+                safeToolResult(err);
                 transcript?.log('tool_error', { tool: call.tool, error: err });
                 results.push({ tool: call.tool, result: err });
                 continue;
             }
-            onToolCall(call.tool, call.args);
+            safeToolCall(call.tool, call.args);
             transcript?.log('tool_call', { tool: call.tool, args: call.args });
             let result;
             try {
@@ -424,7 +454,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             catch (e) {
                 result = `Ошибка: ${e.message}`;
             }
-            onToolResult(result);
+            safeToolResult(result);
             transcript?.log('tool_result', {
                 tool: call.tool,
                 result: String(result),
@@ -501,6 +531,16 @@ function isMeaningfulRespond(msg) {
         return false;
     return true;
 }
+// Normalize an answer for STALE comparison: collapse whitespace AND strip
+// markdown emphasis/code markers. DeepSeek echoes the previous turn with a
+// different emphasis (`**done**` vs `done`), which defeated an exact match and
+// made the loop re-run the same tool ("stopped after a tool call").
+function normForStale(s) {
+    return normText(s)
+        .replace(/[*_`#>]+/g, '')
+        .replace(/[ \t]+/g, ' ')
+        .trim();
+}
 // Text that promises a tool call in the future tense but contains no call
 // itself. DeepSeek regularly "hangs" like this: it writes
 // "Now update README to mention …", "Let me run the tests", "I'll check now"

package/dist/browser.js

@@ -646,15 +646,23 @@ export class DeepSeekBrowser {
             .evaluate(() => document.body.innerText.length)
             .catch(() => 0);
         let started = false;
+        // A stale/echo answer (the model repeats the previous text, or the answer
+        // legitimately equals it) does NOT change `cur`. In that case the old loop
+        // either threw "did not start" after 15s or hung until the full timeout —
+        // the operator saw the agent "stop after a tool call". We now also accept
+        // the answer when the generation has clearly SETTLED: no Stop button and
+        // the text has been stable for a couple of ticks.
+        let settledTicks = 0;
+        let lastStartCur = '';
         while (Date.now() < startDeadline) {
             if (this._abort)
                 return '(прервано пользователем)';
             const pageText = await this._readPageText();
             if (isRateLimitText(pageText)) {
                 throw new RateLimitError(pageText.slice(0, 300));
-                if (isServerBusyText(pageText)) {
-                    throw new ServerBusyError(pageText.slice(0, 300));
-                }
+            }
+            if (isServerBusyText(pageText)) {
+                throw new ServerBusyError(pageText.slice(0, 300));
             }
             const cur = await this._readLastAnswerTextClean().catch(() => '');
             const bodyLen = await this.page
@@ -678,9 +686,30 @@ export class DeepSeekBrowser {
                 started = true;
                 break;
             }
+            // Fallback for an echo/stale answer: the send happened (lastSentAt was
+            // just updated), the Stop button is gone and the text stopped changing.
+            // Two stable ticks in a row mean the turn is over even if it equals the
+            // previous text — return it instead of hanging/throwing.
+            const notGenerating = !(await this._isGenerating());
+            if (cur && cur === lastStartCur && notGenerating && cur.trim()) {
+                settledTicks++;
+                if (settledTicks >= 2) {
+                    return cur;
+                }
+            }
+            else {
+                settledTicks = 0;
+            }
+            lastStartCur = cur;
             await this.page.waitForTimeout(300);
         }
         if (!started) {
+            // Last chance: the answer may have arrived and settled exactly at the
+            // deadline. Return the current text instead of a hard error.
+            const cur = await this._readLastAnswerTextClean().catch(() => '');
+            if (cur && cur.trim() && !(await this._isGenerating())) {
+                return cur;
+            }
             // 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.
@@ -718,21 +747,32 @@ export class DeepSeekBrowser {
             // belongs to the CURRENT send even if the DOM still shows the old text.
             const isNew = !!cur &&
                 (netFresh || normText(cur) !== normText(beforeText));
-            if (isNew && cur === last) {
+            // An echo/stale answer equals beforeText, so isNew stays false and the
+            // old loop waited until the full timeout — the "agent stopped after a
+            // 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) {
                 stable++;
-                if (stable >= 2)
-                    return cur;
+                if (stable >= 2) {
+                    if (isNew || !(await this._isGenerating()))
+                        return cur;
+                }
             }
             else {
                 stable = 0;
             }
-            if (isNew)
+            if (isNew || sameAsBefore)
                 last = cur;
             await this.page.waitForTimeout(800);
         }
         if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
             return last;
         }
+        // Fallback: the turn settled on a text identical to the previous answer.
+        if (last && !(await this._isGenerating())) {
+            return last;
+        }
         if (this._netCapture && this._netCaptureAt >= this._lastSentAt) {
             return this._netCapture;
         }

package/package.json

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