zames_pro 2.9.4 → 2.10.1

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,11 +98,9 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     let justRanTool = false;
     let watchdogRetries = 0;
     const MAX_WATCHDOG_RETRIES = 3;
-    // After a tool_result the model MUST produce a fresh tool call (or respond).
-    // DeepSeek regularly "hangs" right here: the answer comes back empty, or a
-    // stale copy of the previous turn, or a fragment that does not parse. This
-    // counter collects all such turns so that a single bad turn never becomes a
-    // silent finish: at the limit we warn the operator and log the event.
+    // 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++) {
@@ -189,6 +195,13 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         }
         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)
@@ -209,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,
@@ -240,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,
@@ -264,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,
@@ -284,54 +300,77 @@ 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;
             }
-            // NO SILENT FINISH: we just ran a tool, so the work is NOT done —
-            // the model must call another tool or respond. Plain text here is a
-            // protocol violation, not a final answer. Re-ask ROWNO one tool-call
-            // request (within afterToolRetries) instead of returning to the operator.
-            if (justRanTool && afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
-                afterToolRetries++;
-                transcript?.log('after_tool_retry', {
-                    attempt: afterToolRetries,
+            // 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 =
-                    'Ты остановился после вызова инструмента и написал обычный текст. ' +
-                        'Задача ещё не завершена. Ответь РОВНО одним JSON-объектом вызова ' +
-                        'инструмента, без текста до и после, например: ' +
-                        '{\"tool\": \"Bash\", \"args\": {\"command\": \"...\"}}. ' +
-                        'Если задача действительно выполнена — вызови respond с итоговым сообщением.';
+                    'Последний шаг: вызови инструмент respond с итоговым сообщением ' +
+                        'оператору. Не пиши обычный текст — только вызов respond, например: ' +
+                        '{\"tool\": \"respond\", \"args\": {\"message\": \"...\"}}';
                 continue;
             }
-            if (responseLooksLikeToolCall(rawResponse)) {
+            const suspiciousFinal = responseLooksLikeToolCall(rawResponse) ||
+                looksLikeUnfinishedWork((rawResponse || '').trim()) ||
+                !(rawResponse || '').trim();
+            if (suspiciousFinal) {
+                // The answer LOOKS like a call / promises work / is empty, but could
+                // 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'));
             }
+            // 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) {
@@ -347,12 +386,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}`;
@@ -384,6 +438,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // 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);
@@ -425,6 +483,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/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.4",
+  "version": "2.10.1",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {