zames_pro 2.28.2 → 2.29.1

package/dist/browser.js

@@ -160,6 +160,16 @@ const STOP_SELECTORS = [
     'button:has-text("Остановить")',
     'button[aria-label*="Stop" i]',
 ];
+// DeepSeek's "Continue" button. With the reasoning ("Deep thinking") toggle
+// on, the server caps the THINK phase: the reasoning stops mid-way and the UI
+// offers a Continue button (this is NOT the same as a truncated turn with
+// generation_err — there the answer failed; here the model simply paused).
+// The agent must click it so the reasoning/answer keeps flowing, otherwise the
+// turn sits idle until the operator presses Continue by hand.
+//
+// The button is found by scanning every div[role=button]/button and matching
+// an EXACT short label ("Continue" / "Продолжить"), because the class names
+// change and :has-text is not valid in a page-side querySelectorAll.
 // DeepSeek UI service statuses that are NOT the model's answer.
 // Otherwise the agent takes a status (Reading...) for an answer and breaks parsing.
 const STATUS_RE = /^(reading|thinking|searching|analyzing|generating|stop|остановить|читаю|думаю|поиск|анализ)[\s.…]*$/i;
@@ -177,6 +187,19 @@ const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|сл
 // rate limit, these usually clear in seconds, so we retry quickly instead of
 // waiting minutes. "Server busy", 503, "temporarily unavailable", etc.
 const SERVER_BUSY_RE = /(server (is )?busy|server error|service (is )?unavailable|temporarily unavailable|internal server error|502|503|504|server overloaded|сервер занят|сервер перегружен|сервис недоступен|внутренняя ошибка|попробуйте позже)/i;
+// DeepSeek turns a generation that FAILED mid-way into a truncated turn
+// (`quasi_status: INCOMPLETE` + `finish_reason: generation_err`) and shows a
+// "Continue" button in the UI. The failure is invisible to the answer text:
+// the DOM keeps the partial answer (often the previous one), so the finish
+// loop used to wait out the whole timeout and throw ds.send_no_new_answer.
+// The SSE body IS available (net-capture keeps it as `_netCapture`), so we
+// recognize the failed/truncated turn from it and retry instead of hanging.
+const GENERATION_ERR_RE = /"finish_reason":\s*"generation_err"/i;
+const INCOMPLETE_STATUS_RE = /"quasi_status","v":"INCOMPLETE"/i;
+export function isGenerationIncompleteText(text) {
+    const t = String(text || '');
+    return GENERATION_ERR_RE.test(t) || INCOMPLETE_STATUS_RE.test(t);
+}
 export function isRateLimitText(text) {
     return RATE_LIMIT_RE.test(String(text || ''));
 }
@@ -210,6 +233,20 @@ export class ServerBusyError extends Error {
         this.name = 'ServerBusyError';
     }
 }
+// The generation was truncated by the server (`generation_err` / INCOMPLETE).
+// Distinct from ServerBusyError: the DeepSeek backend answered, but the turn
+// did not finish, and the UI offers a "Continue" button. The agent retries the
+// same send (a new message into the chat) instead of waiting for an answer
+// that will never arrive. This is what the operator hit with the reasoning
+// (deep thinking) mode on: the long THINK phase makes the truncation far more
+// likely, so with thinking off everything worked and with it on the turn kept
+// stopping and showing "Continue".
+export class GenerationIncompleteError extends Error {
+    constructor(detail) {
+        super('Generation incomplete (server truncated the answer). ' + detail);
+        this.name = 'GenerationIncompleteError';
+    }
+}
 // ---------- profile cleanup ----------
 async function cleanSingletonFiles() {
     const names = ['SingletonLock', 'SingletonCookie', 'SingletonSocket'];
@@ -249,6 +286,12 @@ export class DeepSeekBrowser {
     maxRateLimitRetries;
     maxServerBusyRetries;
     serverBusyWaitMs;
+    // Retries for a turn the server truncated (generation_err / INCOMPLETE).
+    maxIncompleteRetries;
+    incompleteWaitMs;
+    // Click DeepSeek's "Continue" button automatically when the reasoning phase
+    // is paused by the server (deep thinking mode).
+    autoContinue;
     // Desired state of the DeepSeek chat toggles, applied before each send.
     // deepThinking: the "Deep thinking" toggle (reasoning; the reasoning text
     // is never read/shown). webSearch: the "Smart search" toggle.
@@ -307,7 +350,7 @@ export class DeepSeekBrowser {
     // must be stripped (DeepSeek's CDN answers 403 to it); computed in the
     // constructor, overridable by an explicit UA in the options/config.
     userAgent;
-    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
+    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, maxIncompleteRetries = 4, incompleteWaitMs = 2000, autoContinue = true, deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -320,6 +363,9 @@ export class DeepSeekBrowser {
         this.maxRateLimitRetries = maxRateLimitRetries;
         this.maxServerBusyRetries = maxServerBusyRetries;
         this.serverBusyWaitMs = serverBusyWaitMs;
+        this.maxIncompleteRetries = maxIncompleteRetries;
+        this.incompleteWaitMs = incompleteWaitMs;
+        this.autoContinue = autoContinue;
         this.deepThinking = deepThinking;
         this.webSearch = webSearch;
         this.auth = {
@@ -1017,6 +1063,45 @@ export class DeepSeekBrowser {
     async _isGenerating() {
         return await this._stopButtonVisible();
     }
+    // Click the DeepSeek "Continue" button when it is visible (reasoning/answer
+    // paused by the server). Returns true when a click happened.
+    //
+    // With the "Deep thinking" toggle on, DeepSeek caps the THINK phase and
+    // shows Continue; the model does NOT resume by itself. Without this, a long
+    // reasoning turn sat idle until the operator pressed Continue by hand. We
+    // only act on an EXACT short label so a random "Continue" in prose (a button
+    // inside a rendered answer, etc.) is never clicked.
+    async _clickContinueIfVisible() {
+        try {
+            const clicked = await this.page.evaluate(() => {
+                // Normalize a label: textContent + aria-label, whitespace collapsed.
+                const labelOf = (b) => ((b.textContent || '') + ' ' + (b.getAttribute('aria-label') || ''))
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                // The button must be a SHORT exact label, otherwise a paragraph or a
+                // rendered "Continue" inside the answer could be clicked by mistake.
+                const isExact = (t) => /^(continue|продолжить|продолжение)\s*[.!…]?$/i.test(t);
+                const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+                for (const e of cands) {
+                    const t = labelOf(e);
+                    if (!isExact(t))
+                        continue;
+                    const st = getComputedStyle(e);
+                    if (st.display === 'none' || st.visibility === 'hidden')
+                        continue;
+                    if (!e.offsetParent && st.position !== 'fixed')
+                        continue;
+                    e.click();
+                    return true;
+                }
+                return false;
+            });
+            return !!clicked;
+        }
+        catch {
+            return false;
+        }
+    }
     // DeepSeek exposes two toggle buttons above the input: "Deep thinking"
     // (reasoning) and "Smart search" (web search). Their labels are localized,
     // so we match by a loose regex on the visible text and read the state from
@@ -1051,6 +1136,14 @@ export class DeepSeekBrowser {
     getToggleStatesSync() {
         return this._toggles;
     }
+    // Update the cached toggle states (used by the status icons) without a send.
+    // Called from /config so the icons change immediately.
+    setToggleState(s) {
+        if (typeof s.deepThinking === 'boolean')
+            this._toggles.deepThinking = s.deepThinking;
+        if (typeof s.webSearch === 'boolean')
+            this._toggles.webSearch = s.webSearch;
+    }
     // The CURRENT state of the two DeepSeek toggles, read from the DOM
     // (aria-pressed) so the status line reflects what is actually on, not what
     // the config asked for. Falls back to the configured values when the buttons
@@ -1117,6 +1210,11 @@ export class DeepSeekBrowser {
         let attempt = 0;
         let rateLimitRetries = 0;
         let serverBusyRetries = 0;
+        // Bumped when DeepSeek truncated the turn (`generation_err`/INCOMPLETE).
+        // The retry does NOT consume a regular ask() attempt: it is a server-side
+        // hiccup, not a failed send, and it is more likely in the reasoning
+        // (deep thinking) mode, where the long THINK phase gets cut off.
+        let incompleteRetries = 0;
         while (attempt < this.askRetries) {
             attempt++;
             try {
@@ -1174,6 +1272,28 @@ export class DeepSeekBrowser {
                         return '(прервано пользователем)';
                     continue;
                 }
+                // The turn was TRUNCATED by the server (`generation_err`, INCOMPLETE):
+                // DeepSeek answered with a partial (often empty) answer and shows a
+                // "Continue" button. In reasoning mode this is much more likely. We
+                // resend the SAME prompt into the chat (that is what the Continue
+                // button does) instead of waiting for an answer that will never come.
+                if (e instanceof GenerationIncompleteError) {
+                    incompleteRetries++;
+                    if (incompleteRetries > this.maxIncompleteRetries) {
+                        console.error(theme.error(this._t('ds.incomplete_give_up', {
+                            attempt: incompleteRetries,
+                        })));
+                        throw e;
+                    }
+                    console.error(theme.warn(this._t('ds.incomplete_retry', {
+                        attempt: incompleteRetries,
+                        max: this.maxIncompleteRetries,
+                    })));
+                    const aborted = await this._sleepInterruptible(this.incompleteWaitMs);
+                    if (aborted)
+                        return '(прервано пользователем)';
+                    continue;
+                }
                 console.error('\n' +
                     theme.warn(this._t('ds.ask_retry', {
                         attempt,
@@ -1519,6 +1639,20 @@ export class DeepSeekBrowser {
             if (isServerBusyText(pageText)) {
                 throw new ServerBusyError(pageText.slice(0, 300));
             }
+            // The turn was truncated by the server: the SSE body carries
+            // finish_reason=generation_err / quasi_status=INCOMPLETE and the UI
+            // shows "Continue". Retry instead of waiting out the whole timeout.
+            if (this._netCapture &&
+                this._netCaptureAt >= this._lastSentAt &&
+                isGenerationIncompleteText(this._netCapture)) {
+                throw new GenerationIncompleteError(this._netCapture.slice(-300));
+            }
+            // Reasoning-mode pause during the THINK phase: click Continue so the
+            // generation resumes (the button appears before any RESPONSE text, so
+            // the start-wait would otherwise spin until the deadline).
+            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                this._askDebug('CLICKED Continue (start-loop)');
+            }
             const cur = await this._readLastAnswerTextCleanDom().catch(() => '');
             const bodyLen = await this.page
                 .evaluate(() => document.body.innerText.length)
@@ -1652,6 +1786,22 @@ export class DeepSeekBrowser {
                     throw new ServerBusyError(pageText.slice(0, 300));
                 }
             }
+            // The server truncated the turn (generation_err / INCOMPLETE). The DOM
+            // keeps the partial answer, so without this check the loop waits out the
+            // whole timeout and throws ds.send_no_new_answer — the operator sees the
+            // agent "stop" with a Continue button in the chat. Retry the send.
+            if (this._netCapture &&
+                this._netCaptureAt >= this._lastSentAt &&
+                isGenerationIncompleteText(this._netCapture)) {
+                throw new GenerationIncompleteError(this._netCapture.slice(-300));
+            }
+            // Reasoning-mode pause: DeepSeek caps the THINK phase and shows a
+            // Continue button; the model does not resume by itself. Click it so the
+            // answer keeps flowing instead of waiting for the operator.
+            if (this.autoContinue && (await this._clickContinueIfVisible())) {
+                this._askDebug('CLICKED Continue (finish-loop)');
+                continue;
+            }
             const netFresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;
             // The DOM may be empty while the answer is already in the network
             // capture (a resumed chat re-renders its history, the answer selector

package/dist/config.js

@@ -43,6 +43,9 @@ export const DEFAULTS = {
         minSendIntervalMs: 15000,
         rateLimitWaitMs: 300000,
         maxRateLimitRetries: 6,
+        maxIncompleteRetries: 4,
+        incompleteWaitMs: 2000,
+        autoContinue: true,
         deepThinking: false,
         webSearch: true,
         auth: {
@@ -230,6 +233,28 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.browser_maxRateLimitRetries',
         groupKey: 'cfg.group.browser',
     },
+    {
+        path: 'browser.maxIncompleteRetries',
+        type: 'number',
+        min: 0,
+        max: 100,
+        labelKey: 'cfg.f.browser_maxIncompleteRetries',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.incompleteWaitMs',
+        type: 'number',
+        min: 0,
+        max: 600000,
+        labelKey: 'cfg.f.browser_incompleteWaitMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.autoContinue',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_autoContinue',
+        groupKey: 'cfg.group.browser',
+    },
     {
         path: 'browser.deepThinking',
         type: 'boolean',

package/dist/i18n.js

@@ -533,6 +533,14 @@ const CATALOG = {
         ru: '⚠ Ответ не получен ({attempt}/{max}): {error} — повторяю...',
         en: '⚠ No answer yet ({attempt}/{max}): {error} — retrying...',
     },
+    'ds.incomplete_retry': {
+        ru: '⏳ DeepSeek оборвал ответ (кнопка Continue в чате) — повторяю отправку ({attempt}/{max})...',
+        en: '⏳ DeepSeek truncated the answer (the Continue button in the chat) — resending ({attempt}/{max})...',
+    },
+    'ds.incomplete_give_up': {
+        ru: '✖ DeepSeek {attempt} раз подряд оборвал ответ, не дойдя до конца. Возможно, включён режим размышления — попробуй выключить его (browser.deepThinking) или повтори позже.',
+        en: '✖ DeepSeek truncated the answer {attempt} times in a row. The reasoning mode (deep thinking) may be on — try turning it off (browser.deepThinking) or retry later.',
+    },
     'ds.ask_restart_browser': {
         ru: '⚠ Браузер потерял страницу — перезапускаю и вхожу заново...',
         en: '⚠ The browser lost the page — restarting and signing in again...',
@@ -858,6 +866,18 @@ const CATALOG = {
         ru: 'Число повторов при лимите',
         en: 'Rate-limit retry count',
     },
+    'cfg.f.browser_maxIncompleteRetries': {
+        ru: 'Повторы при обрыве ответа (Continue)',
+        en: 'Retries when the answer is truncated (Continue)',
+    },
+    'cfg.f.browser_incompleteWaitMs': {
+        ru: 'Пауза перед повтором после обрыва, мс',
+        en: 'Wait before retrying a truncated turn, ms',
+    },
+    'cfg.f.browser_autoContinue': {
+        ru: 'Автонажатие кнопки Continue (режим размышления)',
+        en: 'Auto-click Continue (reasoning mode)',
+    },
     'cfg.f.browser_deepThinking': {
         ru: 'Глубокое мышление (долго; размышления не выводятся)',
         en: 'Deep thinking (slow; reasoning is hidden)',

package/dist/index.js

@@ -1407,13 +1407,22 @@ async function main() {
         }
         // Reflect browser toggles on the LIVE browser object. The browser is
         // created once at startup, so without this a /config set browser.*
-        // change would only apply after a restart.
+        // change would only apply after a restart. We also update the cached
+        // toggle states (_toggles) that the status icons read, and repaint the
+        // editor, so the 🧠/🌐 icons change IMMEDIATELY (previously they only
+        // updated after the next send, when _applyToggles() ran).
         if (path === 'browser.deepThinking' || path === 'browser.webSearch') {
             const b = browser;
             if (path === 'browser.deepThinking')
                 b.deepThinking = !!value;
             else
                 b.webSearch = !!value;
+            b.setToggleState({
+                deepThinking: b.deepThinking,
+                webSearch: b.webSearch,
+            });
+            if (editor)
+                editor.refreshStatus();
         }
     }
     function configSetRaw(field, raw) {

package/dist/input.js

@@ -720,6 +720,11 @@ export class LineEditor {
         this.rendered = true;
         this.cursorRowFromTop = top + lay.cursorRow;
     }
+    // Public repaint hook: called when an external state that the status line
+    // reads (e.g. the toggle icons) changed, so it can be redrawn immediately.
+    refreshStatus() {
+        this._render();
+    }
     _render() {
         this._eraseBlock();
         this._writeBlock();

package/package.json

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