zames_pro 2.15.5 → 2.16.0

package/README.md

@@ -206,6 +206,8 @@ Examples:
 ```
 /config set maxIterations 20
 /config set confirmation.bash false
+/config set browser.deepThinking true   # DeepSeek Deep thinking (slow; reasoning is hidden)
+/config set browser.webSearch false     # DeepSeek Smart web search
 /config lang en
 ```
 

package/dist/browser.js

@@ -125,6 +125,11 @@ export class DeepSeekBrowser {
     maxRateLimitRetries;
     maxServerBusyRetries;
     serverBusyWaitMs;
+    // 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.
+    deepThinking;
+    webSearch;
     _lastSentAt;
     _abort;
     // The user pressed Esc/Ctrl+C — a "stop" for the WHOLE current batch of
@@ -144,7 +149,7 @@ export class DeepSeekBrowser {
     // a generation really begins, not during the pre-send phase (chat open,
     // throttle wait), which used to show a spinner with no work in flight.
     onSendStart;
-    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, } = {}) {
+    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, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -157,6 +162,8 @@ export class DeepSeekBrowser {
         this.maxRateLimitRetries = maxRateLimitRetries;
         this.maxServerBusyRetries = maxServerBusyRetries;
         this.serverBusyWaitMs = serverBusyWaitMs;
+        this.deepThinking = deepThinking;
+        this.webSearch = webSearch;
         this._lastSentAt = 0;
         this._abort = false;
         this._stopped = false;
@@ -329,11 +336,34 @@ export class DeepSeekBrowser {
             return this._netCapture;
         }
         return await this.page.evaluate((sels) => {
+            // DeepSeek stores the model's reasoning in .ds-think-content blocks.
+            // They are NOT the answer and must never be picked up as the answer
+            // (otherwise the terminal would show the long reasoning). We also
+            // prefer the first (most specific) selector with a hit.
+            const inThink = (e) => {
+                let n = e;
+                while (n) {
+                    const cls = (n.className || '').toString();
+                    if (/ds-think-content|thinking-content/i.test(cls))
+                        return true;
+                    n = n.parentElement;
+                }
+                return false;
+            };
             let el = null;
             for (const s of sels) {
                 const list = document.querySelectorAll(s);
-                if (list.length)
-                    el = list[list.length - 1];
+                if (!list.length)
+                    continue;
+                for (let i = list.length - 1; i >= 0; i--) {
+                    const cand = list[i];
+                    if (inThink(cand))
+                        continue;
+                    el = cand;
+                    break;
+                }
+                if (el)
+                    break;
             }
             if (!el)
                 return '';
@@ -411,6 +441,34 @@ export class DeepSeekBrowser {
     async _isGenerating() {
         return await this._stopButtonVisible();
     }
+    // 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
+    // aria-pressed. We click ONLY when the state differs, so a send does not
+    // flip a toggle the operator set by hand.
+    async _setToggle(labelRe, want) {
+        try {
+            const btns = this.page.locator('.ds-toggle-button');
+            const count = await btns.count().catch(() => 0);
+            for (let i = 0; i < count; i++) {
+                const b = btns.nth(i);
+                const txt = ((await b.textContent().catch(() => '')) || '').trim();
+                if (!labelRe.test(txt))
+                    continue;
+                const pressed = (await b.getAttribute('aria-pressed').catch(() => null)) === 'true';
+                if (pressed !== want) {
+                    await b.click({ timeout: 2000 }).catch(() => { });
+                    await this.page.waitForTimeout(150);
+                }
+                return;
+            }
+        }
+        catch { }
+    }
+    async _applyToggles() {
+        await this._setToggle(/глубок|deep\s*think/i, this.deepThinking);
+        await this._setToggle(/поиск|search/i, this.webSearch);
+    }
     async stopGeneration() {
         this._abort = true;
         this._stopped = true;
@@ -691,6 +749,10 @@ export class DeepSeekBrowser {
         }
         this._netCapture = '';
         this._netCaptureAt = 0;
+        // Align the DeepSeek chat toggles (deep thinking / web search) with the
+        // configured state BEFORE typing. Doing it here (after the send-pause) it
+        // does not flip toggles for a generation that is not going to happen.
+        await this._applyToggles();
         // Attach files/images FIRST (before the text): the DeepSeek upload widget
         // shows them above the input, and only then the message can be sent.
         if (attachments.length) {

package/dist/config.js

@@ -41,6 +41,8 @@ export const DEFAULTS = {
         minSendIntervalMs: 15000,
         rateLimitWaitMs: 300000,
         maxRateLimitRetries: 6,
+        deepThinking: false,
+        webSearch: true,
     },
     ui: {
         locale: DEFAULT_LOCALE,
@@ -94,6 +96,8 @@ export const CONFIG_SCHEMA = [
     { path: 'browser.minSendIntervalMs', type: 'number', min: 0, max: 600000, labelKey: 'cfg.f.browser_minSendIntervalMs', groupKey: 'cfg.group.browser' },
     { path: 'browser.rateLimitWaitMs', type: 'number', min: 0, max: 3600000, labelKey: 'cfg.f.browser_rateLimitWaitMs', groupKey: 'cfg.group.browser' },
     { path: 'browser.maxRateLimitRetries', type: 'number', min: 0, max: 100, labelKey: 'cfg.f.browser_maxRateLimitRetries', groupKey: 'cfg.group.browser' },
+    { path: 'browser.deepThinking', type: 'boolean', labelKey: 'cfg.f.browser_deepThinking', groupKey: 'cfg.group.browser' },
+    { path: 'browser.webSearch', type: 'boolean', labelKey: 'cfg.f.browser_webSearch', groupKey: 'cfg.group.browser' },
 ];
 export function getConfigField(path) {
     return CONFIG_SCHEMA.find((f) => f.path === path);

package/dist/i18n.js

@@ -293,6 +293,8 @@ const CATALOG = {
     'cfg.f.browser_minSendIntervalMs': { ru: 'Мин. пауза между отправками, мс', en: 'Min pause between sends, ms' },
     'cfg.f.browser_rateLimitWaitMs': { ru: 'Пауза при лимите частоты, мс', en: 'Wait on rate limit, ms' },
     'cfg.f.browser_maxRateLimitRetries': { ru: 'Число повторов при лимите', en: 'Rate-limit retry count' },
+    'cfg.f.browser_deepThinking': { ru: 'Глубокое мышление (долго; размышления не выводятся)', en: 'Deep thinking (slow; reasoning is hidden)' },
+    'cfg.f.browser_webSearch': { ru: 'Умный поиск в интернете', en: 'Smart web search' },
     'cfg.menu.title': { ru: '⚙ Настройки — выбери параметр', en: '⚙ Settings — choose a parameter' },
     'cfg.menu.hint': { ru: '↑/↓ — выбор, Enter — изменить, q/Esc — выйти', en: '↑/↓ select, Enter edit, q/Esc quit' },
     'cfg.menu.edit_hint': { ru: 'Введи значение и Enter (пусто — отмена)', en: 'Enter a value and press Enter (empty — cancel)' },

package/dist/index.js

@@ -1263,6 +1263,16 @@ async function main() {
                 editor.setPrompt(buildPrompt());
             }
         }
+        // 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.
+        if (path === 'browser.deepThinking' || path === 'browser.webSearch') {
+            const b = browser;
+            if (path === 'browser.deepThinking')
+                b.deepThinking = !!value;
+            else
+                b.webSearch = !!value;
+        }
     }
     function configSetRaw(field, raw) {
         const value = validateConfigValue(field, raw);

package/dist/net-capture.js

@@ -43,6 +43,12 @@ function parseDataLines(body) {
 //     incremental APPEND chunks response/fragments/-1/content.
 export function extractFromSse(body) {
     let out = '';
+    // Type of the CURRENT last fragment. When deep thinking is on, the
+    // stream first fills a THINK fragment (the reasoning) and only then a
+    // RESPONSE fragment (the answer), and BOTH use the same APPEND path
+    // response/fragments/-1/content. Without tracking this, the reasoning was
+    // concatenated into the answer and leaked to the terminal.
+    let lastType = '';
     for (const obj of parseDataLines(body)) {
         if (obj == null || typeof obj !== 'object')
             continue;
@@ -58,21 +64,43 @@ export function extractFromSse(body) {
             ? v.response
             : undefined;
         if (resp && Array.isArray(resp.fragments)) {
-            for (const fr of resp.fragments) {
+            const frags = resp.fragments;
+            for (const fr of frags) {
                 if (fr && fr.type === 'RESPONSE' && typeof fr.content === 'string') {
                     out += fr.content;
                 }
             }
+            const lastFrag = frags[frags.length - 1];
+            if (lastFrag && typeof lastFrag.type === 'string')
+                lastType = lastFrag.type;
+            continue;
+        }
+        // A NEW fragment is appended to response/fragments[]. The LAST fragment
+        // decides what the following content chunks belong to (THINK vs
+        // RESPONSE).
+        if (o.p === 'response/fragments' && Array.isArray(o.v)) {
+            const frags = o.v;
+            for (const fr of frags) {
+                if (fr && fr.type === 'RESPONSE' && typeof fr.content === 'string') {
+                    out += fr.content;
+                }
+            }
+            const lastFrag = frags[frags.length - 1];
+            if (lastFrag && typeof lastFrag.type === 'string')
+                lastType = lastFrag.type;
             continue;
         }
         // Incremental APPEND: p='response/fragments/-1/content' -> v=string;
-        // subsequent chunks come with a single v field.
+        // subsequent chunks come with a single v field. Append ONLY when the
+        // current fragment is RESPONSE; a THINK fragment is the reasoning.
         if (o.p === 'response/fragments/-1/content' && typeof o.v === 'string') {
-            out += o.v;
+            if (lastType === '' || lastType === 'RESPONSE')
+                out += o.v;
             continue;
         }
         if (o.p === undefined && typeof o.v === 'string') {
-            out += o.v;
+            if (lastType === '' || lastType === 'RESPONSE')
+                out += o.v;
         }
     }
     return out;

package/package.json

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