zames_pro 2.9.2 → 2.9.4

package/dist/agent-loop.js

@@ -80,6 +80,8 @@ 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
@@ -88,16 +90,64 @@ 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.
+    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).
@@ -105,19 +155,35 @@ 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;
         }
@@ -217,16 +283,43 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                         'сообщением оператору.';
                 continue;
             }
-            // All re-ask attempts are exhausted, yet the answer still looks like a
-            // tool call. Most likely this is a silent stall: we show the operator a
-            // warning in the terminal (not only in the transcript) so they see the
-            // problem immediately instead of wondering why the agent stalled.
+            // 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++;
+                transcript?.log('plaintext_retry', {
+                    attempt: plainTextRetries,
+                    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.';
+                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,
+                    response: rawResponse.slice(0, 500),
+                });
+                message =
+                    'Ты остановился после вызова инструмента и написал обычный текст. ' +
+                        'Задача ещё не завершена. Ответь РОВНО одним JSON-объектом вызова ' +
+                        'инструмента, без текста до и после, например: ' +
+                        '{\"tool\": \"Bash\", \"args\": {\"command\": \"...\"}}. ' +
+                        'Если задача действительно выполнена — вызови respond с итоговым сообщением.';
+                continue;
+            }
             if (responseLooksLikeToolCall(rawResponse)) {
                 transcript?.log('suspicious_final', { response: rawResponse });
-                onWarning(translate(locale)('msg.suspicious_stop'));
             }
-            onAssistantMessage(rawResponse);
-            transcript?.log('assistant_final', { message: rawResponse });
+            transcript?.log('plaintext_final', { message: rawResponse });
+            onWarning(translate(locale)('msg.suspicious_stop'));
             return rawResponse;
         }
         const calls = Array.isArray(parsed) ? parsed : [parsed];
@@ -288,6 +381,9 @@ 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;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);

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/package.json

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