zames_pro 2.29.15 → 2.31.0

package/dist/agent-loop.js

@@ -4,7 +4,7 @@ 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 = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, }) {
     // 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
@@ -180,7 +180,16 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // paragraph that is neither a tool call nor a real respond) from a genuine
     // short answer. We key on the STRUCTURE (work already started), not words.
     let toolsRanInTask = 0;
-    const MAX_AFTER_TOOL_RETRIES = 6;
+    const MAX_AFTER_TOOL_RETRIES = Math.max(0, Math.floor(maxAfterToolRetries));
+    // Token count at which the last auto-compact fired. Re-arm only after
+    // the (fresh) chat grows past this plus a margin, so a chat that starts
+    // above the threshold does not compact on every tool call.
+    let lastAutoCompactTokens = -1;
+    // The message of a respond that arrived TOGETHER with real tool calls.
+    // It is not delivered immediately (the tools must run first), but if the
+    // model then stops without calling respond again, this is the best final
+    // message we have and must reach the operator.
+    let mixedRespondMsg = '';
     const iterCap = maxIterations > 0 ? maxIterations : 100000;
     for (let i = 0; i < iterCap; i++) {
         // NOTE: the spinner is NOT started here. browser.onSendStart fires it
@@ -199,15 +208,20 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // 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;
+        // Kept OUTSIDE the race so we can cancel it and wait for it to settle if
+        // the watchdog timer wins. Before, the losing ask() kept running (up to a
+        // 300s rate-limit wait or the finish loop) while the next iteration
+        // started a SECOND ask() against the same page — two sends / two Continue
+        // clicks.
+        const askPromise = browser.ask(message, {
+            agent: !isFirst,
+            attachments: isFirst ? attachments : [],
+        });
         try {
             rawResponse = await Promise.race([
-                browser.ask(message, {
-                    agent: !isFirst,
-                    attachments: isFirst ? attachments : [],
-                }),
+                askPromise,
                 new Promise((_, reject) => {
                     askTimer = setTimeout(() => reject(new Error('ask() watchdog timeout')), askDeadlineMs);
                     if (askTimer && typeof askTimer.unref === 'function') {
@@ -221,12 +235,27 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         catch (e) {
             if (askTimer)
                 clearTimeout(askTimer);
+            // The timer won: cancel the still-running ask() and AWAIT its settle
+            // before the next iteration starts another one. Without this the two
+            // asks race on the same page. The settle is bounded: a page stuck in a
+            // 30s Playwright evaluate must not hang the loop forever.
+            browser.cancelPendingAsk?.();
+            const settleTimer = new Promise((r) => {
+                const t = setTimeout(r, 60_000);
+                if (typeof t.unref === 'function')
+                    t.unref();
+            });
+            await Promise.race([askPromise.catch(() => { }), settleTimer]);
             transcript?.log('ask_timeout', {
                 attempt: afterToolRetries,
                 error: e.message,
             });
+            // Show how many watchdog retries remain, so the operator can tell a
+            // single hiccup from a genuine stall (the budget used to be invisible).
             safeWarning(translate(locale)('ds.answer_timeout', {
                 sec: Math.round(askDeadlineMs / 1000),
+                attempt: Math.min(afterToolRetries + 1, MAX_AFTER_TOOL_RETRIES),
+                max: MAX_AFTER_TOOL_RETRIES,
             }));
             if (afterToolRetries < MAX_AFTER_TOOL_RETRIES) {
                 afterToolRetries++;
@@ -469,13 +498,36 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // paragraph "Now let me analyze..." instead of calling a tool). We do not
             // match words here - the STRUCTURE (toolsRanInTask > 0) is the signal.
             if (toolsRanInTask > 0) {
+                // Before surfacing a reasoning paragraph as a report, make ONE
+                // explicit attempt to get a real respond (or a remembered mixed-respond
+                // message). This turns "ambiguous text" into an unambiguous final.
+                if (!finalRespondAsked) {
+                    finalRespondAsked = true;
+                    transcript?.log('final_respond_request', {
+                        response: rawResponse.slice(0, 500),
+                    });
+                    message =
+                        'You stopped mid-task without finishing. If the task is DONE — ' +
+                            'call the respond tool with the final message to the operator ' +
+                            '(and nothing else): ' +
+                            '{"tool": "respond", "args": {"message": "..."}}. ' +
+                            'If it is NOT done — reply with exactly one JSON tool-call object, ' +
+                            'no text before or after.';
+                    continue;
+                }
                 transcript?.log('protocol_violation_final', {
                     response: rawResponse.slice(0, 500),
                 });
                 safeWarning(translate(locale)('msg.suspicious_stop'));
-                // The model stopped calling tools mid-task. Surface the last text as
-                // a READABLE report, but say explicitly that the task may be incomplete:
-                // never let a reasoning paragraph masquerade as a finished result.
+                // The model stopped calling tools mid-task. If it left a real message
+                // in a mixed respond earlier, deliver THAT (it is a genuine final);
+                // otherwise surface the last text but say explicitly that the task may
+                // be incomplete: never let a reasoning paragraph masquerade as a result.
+                if (mixedRespondMsg) {
+                    safeAssistantMessage(mixedRespondMsg);
+                    transcript?.log('assistant_final', { message: mixedRespondMsg });
+                    return mixedRespondMsg;
+                }
                 const lastText = (rawResponse || '').trim();
                 return lastText
                     ? lastText +
@@ -513,6 +565,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             transcript?.log('respond_mixed_with_tools', {
                 tools: realCalls.map((c) => c.tool),
             });
+            // A respond mixed with real tools must NOT be dropped silently. Keep
+            // its message; if the model then stops WITHOUT calling respond again, we
+            // deliver this remembered message instead of a bare reasoning paragraph.
+            const m = typeof respondCall.args.message === 'string'
+                ? respondCall.args.message
+                : String(respondCall.args.message ?? '');
+            if (isMeaningfulRespond(m))
+                mixedRespondMsg = m;
         }
         if (respondCall && realCalls.length === 0) {
             const msg = typeof respondCall.args.message === 'string'
@@ -619,23 +679,89 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // 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;
+        // Reset ALL per-task retry counters after a successful tool, not just
+        // the three above. stallRetries/looksDoneRetries/malformedRetries used to
+        // live for the WHOLE task, so over a long chain of tools their budgets
+        // could be exhausted by earlier hiccups and the guards silently stopped
+        // protecting against "stopped after a tool call".
+        stallRetries = 0;
+        looksDoneRetries = 0;
+        malformedRetries = 0;
         finalRespondAsked = false;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
-            message = `Tool result for ${r.tool}:\n${resultStr.slice(0, 12_000)}`;
+            message = `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, 12_000)}`;
         }
         else {
             message = results
                 .map((r) => {
                 const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);
-                return `Tool result for ${r.tool}:\n${resultStr.slice(0, 8000)}`;
+                return `Tool result for ${r.tool}:\n${truncateToolResult(resultStr, 8000)}`;
             })
                 .join('\n\n');
         }
+        // Auto-compact at the ONLY safe seam — after a tool result and before
+        // the next send. Never mid-generation, never during a rate-limit wait, and
+        // never between the task and the first send (this block runs only after a
+        // tool really executed). The callback is awaited, so it serializes with the
+        // send throttle. When it returns a NEW chat id we refresh the message's
+        // chat and continue in the fresh chat.
+        if (onAutoCompact &&
+            getTokenUsage &&
+            !browser._abort &&
+            !browser._stopped) {
+            const tokens = getTokenUsage();
+            if (tokens !== null && Number.isFinite(tokens) && tokens > 0) {
+                const pct = (tokens / contextLimit) * 100;
+                const firedRecently = lastAutoCompactTokens >= 0;
+                // Re-arm only once the counter grows past the point we compacted at
+                // (plus a small margin), so a fresh chat does not compact again on
+                // every tool call.
+                const armed = !firedRecently || tokens > lastAutoCompactTokens + 1;
+                if (pct >= autoCompactPct && armed) {
+                    lastAutoCompactTokens = tokens;
+                    safeWarning(translate(locale)('compact.auto_trigger', {
+                        pct: String(Math.round(pct)),
+                        tokens: String(tokens),
+                    }));
+                    transcript?.log('auto_compact_trigger', { tokens, pct });
+                    try {
+                        const newChat = await onAutoCompact();
+                        if (newChat) {
+                            transcript?.log('auto_compact_done', { chatId: newChat });
+                            // Continue in the fresh chat. The next send is a tool-result
+                            // (agent: true), which is fine: the new chat already holds the
+                            // system prompt + carryover. `lastAutoCompactTokens` stays at the
+                            // count we compacted AT, so a chat that starts above the
+                            // threshold does not compact again until it GROWS past it.
+                        }
+                        else {
+                            transcript?.log('auto_compact_failed', {});
+                        }
+                    }
+                    catch (e) {
+                        transcript?.log('auto_compact_error', {
+                            error: e.message,
+                        });
+                    }
+                }
+            }
+        }
     }
     return 'Iteration limit reached.';
 }
+// Cap a tool result for the model, but make the truncation EXPLICIT: a bare
+// slice() silently hid the tail and the model had no idea it was looking at a
+// partial output (it would act on a half-read file/log).
+export function truncateToolResult(text, limit) {
+    if (text.length <= limit)
+        return text;
+    const omitted = text.length - limit;
+    return (text.slice(0, limit) +
+        String.fromCharCode(10) +
+        `[...truncated ${omitted} chars]`);
+}
 // The answer looks like a tool call, but parseToolCall() did not recognize it.
 // Used as a safeguard against "the agent called a tool and stopped": in that
 // case runAgentLoop asks the model to resend the call instead of finishing the