zames_pro 2.89.0 → 2.90.0

package/dist/agent-loop.js

@@ -3,12 +3,16 @@ import { isContextLimitText } from './browser-pure.js';
 import { providerLabel as providerHumanLabel } from './providers.js';
 import { loadProjectContext } from './context.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
-import { translate } from './i18n.js';
+import { translate, DEFAULT_LOCALE } from './i18n.js';
 import { substituteAttachmentMarkers } from './commands.js';
+import { needsCompletionNudge, COMPLETION_NUDGE, } from './completion-check.js';
 import { loadHooks, runPreToolUse, runPostToolUse, runLifecycleHooks, } from './hooks.js';
 import { loadPermissions, decidePermission, } from './permissions.js';
 import { shouldRunDiagnostics, runDiagnostics, } from './diagnostics.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, onContextLimit = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, onAskUser = null, }) {
+// The tools that WRITE/EDIT a file (and take a `path`). The completion nudge
+// only cares about these — `Bash`/`Git*` in MUTATING_TOOLS are not edits.
+const EDIT_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'ApplyPatch']);
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = DEFAULT_LOCALE, askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, onContextLimit = null, onProviderExhausted = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, onAskUser = null, }) {
     // Resolve the hook config ONCE per task: a read per tool call would be
     // wasteful, and a mid-task edit of hooks.json is not something to chase.
     // `undefined` means "read .zames/hooks.json"; an explicit null disables
@@ -58,6 +62,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         ;
         browser.onContextLimit = onContextLimit;
     }
+    if ('onProviderExhausted' in browser) {
+        ;
+        browser.onProviderExhausted = onProviderExhausted;
+    }
     const safeAssistantThought = safe(onAssistantThought);
     const safeToolCall = safe(onToolCall);
     const safeToolResult = safe(onToolResult);
@@ -79,8 +87,18 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         }
     };
     if (freshChat) {
-        await browser.newChat();
-        transcript?.log('new_chat');
+        // A RESUMED chat must win over "fresh": the caller marks a chat fresh only
+        // when it has no live id (a page restart dropped it). Sending into newChat()
+        // there opened a SECOND chat and the operator saw the dialogue vanish —
+        // the very regression this branch prevents. A provider that cannot navigate
+        // simply ignores the id.
+        const resumeId = browser.resumeChatId || null;
+        const reopened = resumeId && browser.openChat
+            ? await browser.openChat(resumeId).catch(() => false)
+            : false;
+        if (!reopened)
+            await browser.newChat();
+        transcript?.log(reopened ? 'reopen_chat' : 'new_chat', resumeId ? { id: resumeId } : undefined);
         // SessionStart hook: a fresh chat is the start of a session, so a
         // hook can inject context or set up state. Best-effort, output is logged.
         try {
@@ -268,6 +286,11 @@ 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;
+    // Ordered history of the tool calls in this task — feeds the post-edit
+    // "did you verify the artifact?" nudge (src/completion-check.ts).
+    const runSteps = [];
+    // The nudge is sent at most ONCE per task: it is a hint, not a guard.
+    let completionNudgeSent = false;
     const MAX_AFTER_TOOL_RETRIES = Math.max(0, Math.floor(maxAfterToolRetries));
     // One-time hint when the context nears full while auto-compact is OFF:
     // the operator is told about /compact instead of silently degrading. Set
@@ -745,6 +768,16 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     ' chat manually.');
                 return 'The model produced no final message (empty respond).';
             }
+            // A runnable code file was written/edited and NOTHING ran since: the
+            // model may be finishing on an INCOMPLETE artifact (a real case: a page
+            // with no game loop, reported DONE). Ask ONCE to verify it; the model
+            // can still finish with a confirmed respond.
+            if (!completionNudgeSent && needsCompletionNudge(runSteps)) {
+                completionNudgeSent = true;
+                transcript?.log('completion_nudge', { steps: runSteps.length });
+                message = COMPLETION_NUDGE;
+                continue;
+            }
             safeAssistantMessage(msg);
             transcript?.log('assistant_final', { message: msg });
             return msg;
@@ -1159,6 +1192,16 @@ ${diag}`;
         // Reset the watchdog so the next empty/repeated answer is nudged.
         justRanTool = true;
         toolsRanInTask++;
+        // Remember the calls (and whether they mutated a code file) for the
+        // post-edit completion nudge below.
+        for (const r of results) {
+            const callArgs = callsToRun.find((c) => c.tool === r.tool)?.args;
+            runSteps.push({
+                tool: r.tool,
+                mutating: EDIT_TOOLS.has(r.tool),
+                path: typeof callArgs?.path === 'string' ? callArgs.path : undefined,
+            });
+        }
         // The tool really executed on this turn. The NEXT iteration will treat
         // a repeat of this answer as stale only because of this flag (see NEXT,
         // not the current, justRanTool check).

package/dist/ask-retry.js

@@ -0,0 +1,49 @@
+// N1 stage 4: the retry POLICY of a provider's `ask()` as a PURE function.
+//
+// The three providers ran the same loop — call `_askOnce`, classify the thrown
+// error into a family (rate limit / server busy / incomplete / context limit /
+// provider-specific fatal), retry that family within its own budget, otherwise
+// fall through to a generic attempt counter — and each copy had its own order
+// of checks and its own wording. The loop itself (sends, throttling, aborts)
+// stays in the browser class; only the DECISION is here, so every branch is
+// unit-tested without a browser.
+/**
+ * Decide what to do after a failed attempt.
+ *
+ * `classify` maps the thrown error to a family; it lives in the provider
+ * because the backend-specific markers (guest limit, age gate, captcha) are
+ * provider knowledge. A `null` classification falls through to the generic
+ * attempt budget.
+ */
+export function decideRetry(family, state, budgets, waits) {
+    switch (family) {
+        case 'fatal':
+            return { kind: 'give-up', family };
+        case 'context-limit':
+            if (state.contextLimitRetries >= budgets.maxContextLimitRetries) {
+                return { kind: 'give-up', family };
+            }
+            return { kind: 'compact', family };
+        case 'rate-limit':
+            if (state.rateLimitRetries >= budgets.maxRateLimitRetries) {
+                return { kind: 'give-up', family };
+            }
+            return { kind: 'wait', family, waitMs: waits.rateLimitMs };
+        case 'server-busy':
+            if (state.serverBusyRetries >= budgets.maxServerBusyRetries) {
+                return { kind: 'give-up', family };
+            }
+            return { kind: 'wait', family, waitMs: waits.serverBusyMs };
+        case 'incomplete':
+            if (state.incompleteRetries >= budgets.maxIncompleteRetries) {
+                return { kind: 'give-up', family };
+            }
+            return { kind: 'wait', family, waitMs: waits.incompleteMs };
+        default:
+            // A generic failure is retried while the TOTAL attempt budget lasts.
+            if (state.attempt >= budgets.askRetries - 1) {
+                return { kind: 'give-up', family: 'generic' };
+            }
+            return { kind: 'generic', waitMs: 2000 * (state.attempt + 1) };
+    }
+}

package/dist/ask-state.js

@@ -0,0 +1,80 @@
+// N3: the PHASE DECISION of DeepSeek's `_askOnce()` as a pure state machine.
+//
+// `_askOnce` (src/browser.ts) is the most fragile function of the project: a
+// start-wait loop, a finish loop, the Continue button, the stability window
+// and four detectors (rate limit / context limit / truncated / finished
+// without answer). Until now it was covered only by live smoke runs, and a
+// wrong ordering of the checks kept reappearing (the "Stopped" hang, the
+// "agent stopped with a Continue button", the 15-minute spinner on a dead
+// turn). The Playwright part keeps COLLECTING an observation; the TRANSITION
+// below is pure and unit-tested against the real cases from DESIGN-NOTES.
+/** Grace ticks before a FINISHED-with-answer turn is returned (default 2). */
+export const NET_FINISHED_TICKS = 2;
+/** Ticks a dead (FINISHED, no answer, no Continue) turn waits before giving up. */
+export const DEAD_TURN_TICKS = 6;
+/**
+ * One transition of the ask() state machine.
+ *
+ * ORDER MATTERS and is the whole point of this function:
+ *  1. an abort wins over everything (the operator stopped);
+ *  2. the CONTEXT limit is checked BEFORE the rate limit — both look like a
+ *     toast, and retrying an exhausted chat is useless;
+ *  3. rate limit / server busy are retryable errors;
+ *  4. a truncated turn PREFERS the Continue button (it RESUMES the turn) and
+ *     only falls back to a resend when there is no button;
+ *  5. a PAUSED generation (`continueVisible`) is never "settled": the
+ *     stability early-return must be checked AFTER it, otherwise a partial
+ *     answer is returned with Continue still on screen.
+ */
+export function nextPhase(phase, o, opts) {
+    if (o.aborted)
+        return { kind: 'return', text: 'dom' };
+    if (o.contextLimit)
+        return { kind: 'throw', error: 'context-limit' };
+    if (o.rateLimited)
+        return { kind: 'throw', error: 'rate-limit' };
+    if (o.serverBusy)
+        return { kind: 'throw', error: 'server-busy' };
+    // A truncated / answer-less turn: click Continue when possible (it resumes
+    // the SAME turn); otherwise resend.
+    if (o.truncated || o.noAnswer) {
+        if (opts.autoContinue && o.continueVisible) {
+            return { kind: 'click-continue' };
+        }
+        return { kind: 'throw', error: 'incomplete' };
+    }
+    if (phase === 'start') {
+        if (o.isNew)
+            return { kind: 'started' };
+        if (o.hasText && o.notGenerating && !o.continueVisible) {
+            return { kind: 'return', text: 'dom' };
+        }
+        // A reasoning pause during the THINK phase: click Continue so the answer
+        // starts flowing instead of waiting for the start deadline.
+        if (opts.autoContinue && opts.deepThinking && o.continueVisible) {
+            return { kind: 'click-continue' };
+        }
+        return { kind: 'wait' };
+    }
+    // --- finish loop ---------------------------------------------------------
+    // The SSE body is ground truth: FINISHED with an answer, after a short grace
+    // window, is complete.
+    if (o.finishedWithAnswer && opts.netFinishedTicks >= NET_FINISHED_TICKS) {
+        return { kind: 'return', text: 'net' };
+    }
+    // A dead turn (the server ended it with nothing and there is no Continue to
+    // resume): give up quickly so ask() resends instead of a long spinner.
+    if (opts.deadTicks >= DEAD_TURN_TICKS && !o.continueVisible) {
+        return { kind: 'throw', error: 'incomplete' };
+    }
+    // A PAUSED generation looks stable: check it BEFORE the stability return.
+    if (opts.autoContinue && opts.deepThinking && o.continueVisible) {
+        return { kind: 'click-continue' };
+    }
+    if (o.isNew && opts.stableReached) {
+        if (o.notGenerating)
+            return { kind: 'return', text: 'dom' };
+        return { kind: 'wait' };
+    }
+    return { kind: 'wait' };
+}

package/dist/browser-base.js

@@ -0,0 +1,69 @@
+// N1 stage 1: the helpers that were byte-identical in DeepSeekBrowser,
+// QwenBrowser and GlmBrowser. Composition, not inheritance: every provider
+// class owns a page and calls these with it, so the provider-specific logic
+// stays where it is and only the shared mechanics live here.
+/** Best-effort: a page error while marking the tab title must never break a
+ *  send loop, so every failure is swallowed. */
+export async function setBusyTitle(page, busy, setInDom) {
+    try {
+        await page.evaluate(setInDom, busy);
+    }
+    catch { }
+}
+/**
+ * The first selector that has a VISIBLE element. `timeout` is a per-selector
+ * budget, not a total one (the providers rely on that: a login form is tried
+ * with a long budget while optional probes use a short one).
+ *
+ * Two probe styles exist in the providers (`waitFor({state:'visible'})` in
+ * DeepSeek/Qwen and `count()` + `isVisible()` in GLM). `style: 'wait'` keeps
+ * the first (it also covers a late-mounting element); `style: 'check'` keeps
+ * the second (no waiting state, a cheap poll).
+ */
+export async function findVisible(page, selectors, timeout = 1000, style = 'wait') {
+    for (const sel of selectors) {
+        const loc = page.locator(sel).last();
+        if (style === 'wait') {
+            try {
+                await loc.waitFor({ state: 'visible', timeout });
+                return loc;
+            }
+            catch { }
+            continue;
+        }
+        try {
+            if ((await loc.count()) === 0)
+                continue;
+            if (await loc.isVisible({ timeout }).catch(() => false))
+                return loc;
+        }
+        catch { }
+    }
+    return null;
+}
+/**
+ * Sleep in 100 ms chunks so Esc and the ask() watchdog stay responsive.
+ * Returns true when the wait was INTERRUPTED (abort / cancelled ask), so the
+ * caller can stop early. `onTick` fires about once a second with the time
+ * left — that is what animates the throttle countdown.
+ */
+export async function sleepInterruptible(page, ms, isInterrupted, onTick) {
+    const step = 100;
+    let left = ms;
+    let sinceTick = 0;
+    while (left > 0) {
+        if (isInterrupted())
+            return true;
+        const chunk = Math.min(step, left);
+        await page.waitForTimeout(chunk);
+        left -= chunk;
+        if (onTick) {
+            sinceTick += chunk;
+            if (sinceTick >= 1000) {
+                sinceTick = 0;
+                onTick(left);
+            }
+        }
+    }
+    return isInterrupted();
+}