zames_pro 2.9.3 → 2.10.0

package/dist/agent-loop.js

@@ -72,6 +72,16 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     const MAX_MALFORMED_RETRIES = 3;
     let stallRetries = 0;
     const MAX_STALL_RETRIES = 5;
+    // SINGLE shared budget for "the answer is not a recognized tool call".
+    // Before, every guard had its own counter (3+5+3+5+6 = 22 re-asks), so a
+    // stuck answer hung the loop for ~20 iterations and then returned an
+    // "iteration limit" stub — the exact "agent stopped" symptom. All the
+    // guards below now also bump this counter, and once it is exhausted the
+    // loop asks for respond exactly once and then finishes with the model's
+    // own text (never a stub).
+    let unparsedRetries = 0;
+    const MAX_UNPARSED_RETRIES = 4;
+    let finalRespondAsked = false;
     // Guard against "the agent stalled": DeepSeek sometimes sends a final text
     // that merely DESCRIBES the next tool call (or cuts the answer off
     // mid-word), and the agent silently finishes the task even though the work
@@ -80,8 +90,6 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // chatty model.
     let looksDoneRetries = 0;
     const MAX_LOOKSDONE_RETRIES = 3;
-    let plainTextRetries = 0;
-    const MAX_PLAINTEXT_RETRIES = 5;
     // Watchdog against the agent emitting a tool call and then going silent.
     // After a tool result the expected next answer is a fresh tool call; if we
     // instead get an EMPTY answer or the EXACT same answer as the previous turn
@@ -90,16 +98,62 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     let justRanTool = false;
     let watchdogRetries = 0;
     const MAX_WATCHDOG_RETRIES = 3;
+    // Retry budget for a browser.ask() TIMEOUT (not for content): the send did
+    // not come back in time. This is separate from unparsedRetries because a
+    // timeout is an infrastructure failure, not a model protocol violation.
+    let afterToolRetries = 0;
+    const MAX_AFTER_TOOL_RETRIES = 6;
     for (let i = 0; i < maxIterations; i++) {
         onThinking();
         // 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.
         const isFirst = i === 0;
-        const rawResponse = await browser.ask(message, {
-            agent: !isFirst,
-            attachments: isFirst ? attachments : [],
-        });
+        // 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
+        // final answer. The deadline is generous enough for real long answers.
+        const askDeadlineMs = 240_000;
+        let rawResponse;
+        let askTimer = null;
+        try {
+            rawResponse = await Promise.race([
+                browser.ask(message, {
+                    agent: !isFirst,
+                    attachments: isFirst ? attachments : [],
+                }),
+                new Promise((_, reject) => {
+                    askTimer = setTimeout(() => reject(new Error('ask() watchdog timeout')), askDeadlineMs);
+                    if (askTimer && typeof askTimer.unref === 'function') {
+                        askTimer.unref();
+                    }
+                }),
+            ]);
+            if (askTimer)
+                clearTimeout(askTimer);
+        }
+        catch (e) {
+            if (askTimer)
+                clearTimeout(askTimer);
+            transcript?.log('ask_timeout', {
+                attempt: afterToolRetries,
+                error: e.message,
+            });
+            onWarning('browser.ask() не вернул ответ за ' +
+                Math.round(askDeadlineMs / 1000) +
+                'с — повторяю запрос.');
+            if (afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
+                afterToolRetries++;
+                await new Promise((r) => setTimeout(r, 1500));
+                continue;
+            }
+            transcript?.log('ask_timeout_exhausted', {
+                message: 'ask() не вернул ответ и лимит повторов исчерпан',
+            });
+            onWarning('browser.ask() перестал отвечать; лимит повторов исчерпан, ' +
+                'останавливаюсь. Ответа модели нет — проверьте чат DeepSeek вручную.');
+            return 'ask() watchdog: ответ модели не получен';
+        }
         await reportChat();
         transcript?.log('assistant_raw', { response: rawResponse });
         // The user aborted generation (Esc/Ctrl+C).
@@ -107,24 +161,47 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             transcript?.log('user_aborted');
             return rawResponse;
         }
-        // Watchdog: after a tool result we expect a FRESH tool call. If the answer
-        // is empty or identical to the previous turn (the new message was not
-        // sent), nudge instead of stopping.
+        // Watchdog: after a tool result we expect a FRESH tool call. DeepSeek
+        // regularly stops right here; the answer may be (a) empty, (b) an exact
+        // copy of the previous turn (the new message was not sent), or (c) a
+        // non-empty fragment that parses to nothing and is not a tool call (a
+        // 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();
-        const wdStale = justRanTool && lastRaw.trim() !== '' && rawResponse.trim() === lastRaw.trim();
-        if (!isFirst && (wdEmpty || wdStale) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
+        const wdStale = justRanTool &&
+            lastRaw.trim() !== '' &&
+            rawResponse.trim() === lastRaw.trim();
+        const wdNoCall = justRanTool &&
+            !wdEmpty &&
+            !wdStale &&
+            parseToolCall(rawResponse) === null &&
+            !responseLooksLikeToolCall(rawResponse);
+        if (!isFirst && (wdEmpty || wdStale || wdNoCall) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
             watchdogRetries++;
             transcript?.log('watchdog_nudge', {
                 attempt: watchdogRetries,
                 empty: wdEmpty,
                 stale: wdStale,
+                no_call: wdNoCall,
                 response: String(rawResponse || '').slice(0, 200),
             });
+            message =
+                'Ты остановился после результата инструмента. Продолжи работу: ' +
+                    'ответь РОВНО одним JSON-объектом вызова инструмента, без текста до и после, ' +
+                    'например: {"tool": "Bash", "args": {"command": "..."}}. ' +
+                    'Если задача действительно выполнена — вызови respond с итоговым сообщением.';
             await new Promise((r) => setTimeout(r, 1500));
             continue;
         }
         lastRaw = rawResponse;
         const parsed = parseToolCall(rawResponse);
+        // SILENT CONTRACT: pre-tool text around a valid call is NEVER shown to the
+        // operator. It is only handed to onAssistantThought, which is a no-op by
+        // default and is not wired to the UI in src/index.ts (so ui.assistant /
+        // the terminal never receives "Let me check..." / "Сейчас посмотрю").
+        // We cannot strip this text from DeepSeek's own chat output with code —
+        // that text is generated by the model. We can only (a) forbid it via the
+        // system-prompt ("ONLY TOOL CALLS") and (b) not print it here.
         if (parsed) {
             const thought = extractPreToolText(rawResponse);
             if (thought)
@@ -145,6 +222,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             const looksLikeToolCall = responseLooksLikeToolCall(rawResponse);
             if (looksLikeToolCall && malformedRetries < MAX_MALFORMED_RETRIES) {
                 malformedRetries++;
+                unparsedRetries++;
                 transcript?.log('malformed_toolcall', {
                     attempt: malformedRetries,
                     response: rawResponse,
@@ -176,6 +254,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     /(messages? too frequent|too many requests|rate limit|server (is )?busy|service (is )?unavailable|слишком часто|try again later)/i.test(trimmed));
             if (looksService && stallRetries < MAX_STALL_RETRIES) {
                 stallRetries++;
+                unparsedRetries++;
                 transcript?.log('stall_retry', {
                     attempt: stallRetries,
                     response: rawResponse,
@@ -200,6 +279,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // continue and to actually call a tool this time (or respond if truly done).
             if (looksLikeUnfinishedWork(trimmed) && looksDoneRetries < MAX_LOOKSDONE_RETRIES) {
                 looksDoneRetries++;
+                unparsedRetries++;
                 transcript?.log('unfinished_retry', {
                     attempt: looksDoneRetries,
                     response: rawResponse,
@@ -220,36 +300,75 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 continue;
             }
             // STRICT: only tool calls and respond reach the operator. Plain text is
-            // a protocol violation: re-ask for a tool call instead of printing it.
-            if (plainTextRetries < MAX_PLAINTEXT_RETRIES) {
-                plainTextRetries++;
+            // a protocol violation. The retries are bounded by the SINGLE
+            // unparsedRetries budget, so a chatty model cannot hang the loop for
+            // 20+ iterations (the old plainTextRetries + afterToolRetries combo).
+            if (unparsedRetries < MAX_UNPARSED_RETRIES) {
+                unparsedRetries++;
                 transcript?.log('plaintext_retry', {
-                    attempt: plainTextRetries,
+                    attempt: unparsedRetries,
                     response: rawResponse.slice(0, 500),
                 });
                 message =
-                    'Only call tools. Do not write plain text. ' +
-                        'If the task is done - call respond with the final message. ' +
-                        'Otherwise reply with EXACTLY one JSON tool-call object, no text around it.';
+                    (justRanTool
+                        ? 'Ты остановился после вызова инструмента и написал обычный текст. '
+                        : 'Ты написал обычный текст без вызова инструмента. ') +
+                        'Задача ещё не завершена. Ответь РОВНО одним JSON-объектом вызова ' +
+                        'инструмента, без текста до и после, например: ' +
+                        '{\"tool\": \"Bash\", \"args\": {\"command\": \"...\"}}. ' +
+                        'Если задача действительно выполнена — вызови respond с итоговым сообщением.';
                 continue;
             }
-            if (responseLooksLikeToolCall(rawResponse)) {
+            // Budget exhausted. Ask for respond EXACTLY once more; if the model
+            // still does not call it, surface its own text as the final answer
+            // (with a single warning) instead of looping to the iteration limit.
+            if (!finalRespondAsked) {
+                finalRespondAsked = true;
+                transcript?.log('final_respond_request', {
+                    response: rawResponse.slice(0, 500),
+                });
+                message =
+                    'Последний шаг: вызови инструмент respond с итоговым сообщением ' +
+                        'оператору. Не пиши обычный текст — только вызов respond, например: ' +
+                        '{\"tool\": \"respond\", \"args\": {\"message\": \"...\"}}';
+                continue;
+            }
+            const suspiciousFinal = responseLooksLikeToolCall(rawResponse) ||
+                !(rawResponse || '').trim();
+            if (suspiciousFinal) {
+                // The answer LOOKS like a call (or is empty) but could not be parsed
+                // even after all retries: warn the operator.
                 transcript?.log('suspicious_final', { response: rawResponse });
+                onWarning(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
+            // re-asks it is the best available result, and warning here only
+            // confused the operator in earlier sessions.
             transcript?.log('plaintext_final', { message: rawResponse });
-            onWarning(translate(locale)('msg.suspicious_stop'));
             return rawResponse;
         }
         const calls = Array.isArray(parsed) ? parsed : [parsed];
+        // A respond mixed with real tool calls must NOT short-circuit the tools.
+        // DeepSeek sometimes returns [{"tool":"Edit",...},{"tool":"respond",...}]
+        // in ONE answer; handling respond first would silently DROP the other
+        // call and the agent would look "stopped after a tool call". We only
+        // finish on respond when it is the SOLE call in the answer.
+        const realCalls = calls.filter((c) => c.tool !== 'respond');
         const respondCall = calls.find((c) => c.tool === 'respond');
-        if (respondCall) {
+        if (respondCall && realCalls.length > 0) {
+            transcript?.log('respond_mixed_with_tools', {
+                tools: realCalls.map((c) => c.tool),
+            });
+        }
+        if (respondCall && realCalls.length === 0) {
             const msg = typeof respondCall.args.message === 'string'
                 ? respondCall.args.message
                 : String(respondCall.args.message ?? '');
             // An empty respond is not final: the model called respond but wrote no
             // summary. Finishing like this would show the operator nothing and the
             // task would "hang". We ask it to continue (within stallRetries).
-            if (!msg.trim() && stallRetries < MAX_STALL_RETRIES) {
+            if (!isMeaningfulRespond(msg) && stallRetries < MAX_STALL_RETRIES) {
                 stallRetries++;
                 transcript?.log('empty_respond', { attempt: stallRetries });
                 if (debugLog) {
@@ -265,12 +384,27 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                         'продолжи работу вызовом инструмента.';
                 continue;
             }
+            // An EMPTY respond must NEVER be a silent final: the operator would see
+            // nothing and the task would look "stopped after a tool call". If the
+            // retry budget is exhausted, warn the operator and keep the run open
+            // instead of returning an empty string. Only a NON-empty respond ends
+            // the task normally.
+            if (!isMeaningfulRespond(msg)) {
+                transcript?.log('empty_respond_exhausted', { response: rawResponse });
+                onWarning('Модель вызвала respond без текста, и лимит повторов исчерпан. ' +
+                    'Проверьте чат DeepSeek вручную.');
+                return 'Модель не сформировала итоговое сообщение (пустой respond).';
+            }
             onAssistantMessage(msg);
             transcript?.log('assistant_final', { message: msg });
             return msg;
         }
         const results = [];
-        for (const call of calls) {
+        // When respond came together with real tools, skip respond here: its
+        // message must NOT be delivered before the tools' results are known.
+        // The model will get the tool results and can call respond again.
+        const callsToRun = realCalls.length > 0 ? realCalls : calls;
+        for (const call of callsToRun) {
             const tool = tools.find((t) => t.name === call.tool);
             if (!tool) {
                 const err = `Неизвестный инструмент: ${call.tool}`;
@@ -299,6 +433,13 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // Reset the watchdog so the next empty/repeated answer is nudged.
         justRanTool = 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.
+        afterToolRetries = 0;
+        // Real progress was made, so the "unparsed answer" budget is replenished:
+        // a long chain of tools must not run out of it because of earlier hiccups.
+        unparsedRetries = 0;
+        finalRespondAsked = false;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
@@ -340,6 +481,24 @@ export function responseLooksLikeToolCall(rawResponse) {
         /<\s*\|?\s*(DSML|invoke|parameter)/i.test(raw) ||
         /^\s*\[?\s*\{[^}]*$/.test(raw.trim()));
 }
+// A respond message is only a real FINAL answer when it carries some meaning.
+// DeepSeek sometimes finishes with a placeholder — "...", "-", "ok", "done",
+// "готово" — which looks like a stop with no report. Such a respond must not
+// end the task silently: it is treated like an empty one (re-ask).
+function isMeaningfulRespond(msg) {
+    const t = (msg || '').trim();
+    if (!t)
+        return false;
+    // Only punctuation/dots/ellipses: "...", "---", "…", "?" — not a report.
+    if (/^[.…–—_*?!/\s-]+$/.test(t))
+        return false;
+    // A bare acknowledgement with no content at all. NOTE: "ok"/"done"/
+    // "готово" are NOT in this list: a short "готово" is a legitimate final
+    // answer for a small task, and dropping it re-opened the loop.
+    if (/^(na|null|undefined)[.!]*$/i.test(t))
+        return false;
+    return true;
+}
 // 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

@@ -668,7 +668,13 @@ export class DeepSeekBrowser {
             // make us think the new answer had started when in fact nothing was sent
             // — and then the agent silently "stopped".
             const changed = cur && normText(cur) !== normText(beforeText);
-            if (changed || bodyLen > startBodyLen) {
+            // Network capture with a fresh timestamp is the STRONGEST proof that a
+            // new answer started: it is the raw SSE body for the CURRENT send. Right
+            // after a tool result the DOM may still show the previous answer, so
+            // 'changed' can stay false for a while — without this check ask() used
+            // to hang until the full timeout and the agent appeared to "stop".
+            const netStarted = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
+            if (changed || netStarted || bodyLen > startBodyLen) {
                 started = true;
                 break;
             }
@@ -703,12 +709,15 @@ export class DeepSeekBrowser {
                     }
                 }
             }
+            const netFresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
             const cur = await this._readLastAnswerTextClean().catch(() => '');
             // Ignore an "answer" that is identical to what was on the page BEFORE we
             // sent the message: that is the previous answer, not a new one. Returning
             // it would make the agent re-process the old tool call (or silently
-            // stop). We keep waiting instead.
-            const isNew = cur && normText(cur) !== normText(beforeText);
+            // stop). We keep waiting instead. A fresh network capture is exempt: it
+            // 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) {
                 stable++;
                 if (stable >= 2)
@@ -721,8 +730,12 @@ export class DeepSeekBrowser {
                 last = cur;
             await this.page.waitForTimeout(800);
         }
-        if (last && normText(last) !== normText(beforeText))
+        if (last && (normText(last) !== normText(beforeText) || this._netCapture)) {
             return last;
+        }
+        if (this._netCapture && this._netCaptureAt >= this._lastSentAt) {
+            return this._netCapture;
+        }
         throw new Error('Новый ответ не получен (на странице остался прежний текст). ' +
             'Возможно, сообщение не отправилось.');
     }

package/dist/i18n.js

@@ -283,6 +283,15 @@ const CATALOG = {
         en: 'IMPORTANT: reply to the operator in English. All text in the respond tool message field, and any explanations, must be in English.',
     },
     'prompt.tools_header': { ru: 'You have access to the following tools:', en: 'You have access to the following tools:' },
+    // The hard "ONLY TOOL CALLS" block. All prose around a tool call is a
+    // protocol violation: the operator never sees it (only tool calls and the
+    // final respond reach the terminal), so it is pure pollution. We cannot
+    // stop DeepSeek from generating it INSIDE its chat with code (that is the
+    // model's output); we can only forbid it by prompt and hide it here.
+    'prompt.only_tool_calls': {
+        ru: '## ТОЛЬКО ВЫЗОВЫ ИНСТРУМЕНТОВ (жёсткое правило)\n\nОбщайся с оператором ТОЛЬКО через вызовы инструментов. Любой обычный текст — объяснения, планы, рассуждения, комментарии, извинения, приветствия, заголовки, списки, markdown, эмодзи — ЗАПРЕЩЁН. Он не читается и считается ошибкой.\n\nТВОЙ ЕДИНСТВЕННЫЙ ВЫВОД — вызов инструмента. В каждом ответе ровно один JSON-объект вызова (или массив независимых вызовов), без единого слова до и после.\n\nНЕЛЬЗЯ писать: «сейчас сделаю», «давай посмотрим», «проверю», планы, объяснения, итоги между шагами.\n\nМОЖНО только вызов инструмента и, в самом конце, когда задача выполнена, respond с итогом.\n\nЕдинственное место, где допускается текст, — поле message внутри respond, и только в самом конце.',
+        en: '## ONLY TOOL CALLS (hard rule)\n\nTalk to the operator ONLY through tool calls. Any plain text — explanations, plans, reasoning, comments, apologies, greetings, headings, lists, markdown, emoji — is FORBIDDEN. It is not read and counts as an error.\n\nYOUR ONLY OUTPUT is a tool call. Each turn contains exactly one JSON tool-call object (or an array of independent calls), with not a single word before or after.\n\nYou MUST NOT write: "I will now...", "let us look...", "let me check", plans, explanations, progress notes between steps.\n\nALLOWED: only a tool call and, at the very end, when the task is done, respond with the summary.\n\nThe only place where text is allowed is the message field inside respond, and only at the very end.',
+    },
 };
 export function translate(locale) {
     const loc = isLocale(locale) ? locale : DEFAULT_LOCALE;

package/dist/system-prompt.js

@@ -45,7 +45,20 @@ stop. If you are still working, emit a tool call instead.
 
 So the pattern is: tool call, tool call, tool call, ..., then a single final
 respond. A bare text message without a tool call ends the task and the
-operator will not read it, so never use plain text.\n\nNO PROSE AROUND TOOL CALLS. Each turn must contain ONLY the JSON of the tool\ncall(s) — not a single word before or after, not even a short lead-in like\n"Let me check..." or "Now I'll fix it.". The JSON must be the entire response.\n\nWRONG: "Let me read the file first." then a Read call.\nWRONG: a Read call then "I'll analyze the result next."\nRIGHT: only the JSON of the tool call, nothing else.\n\nIf you feel the urge to explain, do not: put it in the final respond when the\ntask is done (or when you must ask the operator), not between tool calls.
+operator will not read it, so never use plain text.
+
+${t('prompt.only_tool_calls')}
+
+NO PROSE AROUND TOOL CALLS. Each turn must contain ONLY the JSON of the tool
+call(s) — not a single word before or after, not even a short lead-in like
+"Let me check..." or "Now I'll fix it.". The JSON must be the entire response.
+
+WRONG: "Let me read the file first." then a Read call.
+WRONG: a Read call then "I'll analyze the result next."
+RIGHT: only the JSON of the tool call, nothing else.
+
+If you feel the urge to explain, do not: put it in the final respond when the
+task is done (or when you must ask the operator), not between tool calls.
 
 You have access to the following tools:
 

package/package.json

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