zames_pro 2.92.0 → 2.94.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.94.0] - 2026-11-02
+
+### Added
+
+- **dev:** dump unrecognized tool calls and hot-reload the parser
+
+## [2.93.0] - 2026-11-02
+
+### Fixed
+
+- **deepseek:** recognize every tool-call shape the chat returns
+
 ## [2.92.0] - 2026-11-01
 
 ### Changed

package/dist/agent-loop.js

@@ -13,7 +13,7 @@ import { shouldRunDiagnostics, runDiagnostics, } from './diagnostics.js';
 // 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, infiniteRetries = true, maxRetryWaitMs = 30 * 60_000, 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, }) {
+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, devDump = false, locale = DEFAULT_LOCALE, askDeadlineMs = 240_000, maxAfterToolRetries = 6, infiniteRetries = true, maxRetryWaitMs = 30 * 60_000, 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
@@ -513,6 +513,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // agent stalls even though the model tried to call a tool.
             const looksLikeToolCall = responseLooksLikeToolCall(rawResponse);
             if (looksLikeToolCall && malformedRetries < MAX_MALFORMED_RETRIES) {
+                if (devDump) {
+                    const dumped = await dumpUnparsedCall(rawResponse, {
+                        provider: providerLabel,
+                        where: 'loop:unparsed',
+                    });
+                    if (dumped)
+                        safeWarning('[dev] unparsed call saved: ' + dumped);
+                }
                 malformedRetries++;
                 unparsedRetries++;
                 transcript?.log('malformed_toolcall', {
@@ -1344,5 +1352,62 @@ ${diag}`;
 }
 // The pure helpers (tool-call parser + answer heuristics) live in
 // answer-parse.ts  and are imported here for runAgentLoop. They are
-// NOT re-exported: importers get them from answer-parse.js directly .
-import { parseToolCall, responseLooksLikeToolCall, truncateToolResult, normForStale, looksLikeUnfinishedWork, isMeaningfulRespond, extractPreToolText, } from './answer-parse.js';
+// NOT re-exported: importers get them from answer-parse.js directly.
+// parseToolCall and responseLooksLikeToolCall live in let bindings:
+// their modules (answer-parse.ts, xml-toolcall.ts) are NOT hot-reloadable,
+// so an edit to the parser was reported by the dev watcher and then
+// silently ignored for the whole run. /reload swaps them through
+// _setParserBindings().
+import { truncateToolResult, normForStale, looksLikeUnfinishedWork, isMeaningfulRespond, extractPreToolText, } from './answer-parse.js';
+import * as answerParse from './answer-parse.js';
+let parseToolCall = answerParse.parseToolCall;
+let responseLooksLikeToolCall = answerParse.responseLooksLikeToolCall;
+export function _setParserBindings(m) {
+    parseToolCall = m.parseToolCall;
+    responseLooksLikeToolCall = m.responseLooksLikeToolCall;
+}
+let unparsedDumps = 0;
+const UNPARSED_DUMP_MAX = 20;
+const UNPARSED_DUMP_BYTES = 64 * 1024;
+/** Dev mode: save an unrecognized (but call-looking) answer for analysis. */
+export async function dumpUnparsedCall(raw, meta) {
+    if (unparsedDumps >= UNPARSED_DUMP_MAX)
+        return '';
+    const text = String(raw || '');
+    if (!text.trim())
+        return '';
+    const fs = await import('node:fs/promises');
+    const p = await import('node:path');
+    const dir = p.join(meta.workdir || process.cwd(), '.zames', 'unparsed');
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        unparsedDumps++;
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const name = stamp + '-' + String(meta.where || 'x').replace(/[^a-z0-9_-]+/gi, '_');
+        const file = p.join(dir, name + '.txt');
+        const NL = String.fromCharCode(10);
+        const head = '# unparsed tool-call candidate' +
+            NL +
+            'when: ' +
+            new Date().toISOString() +
+            NL +
+            'provider: ' +
+            (meta.provider || '-') +
+            NL +
+            'where: ' +
+            meta.where +
+            NL +
+            'length: ' +
+            text.length +
+            NL +
+            NL +
+            '--- raw answer ---' +
+            NL +
+            NL;
+        await fs.writeFile(file, head + text.slice(0, UNPARSED_DUMP_BYTES), 'utf-8');
+        return file;
+    }
+    catch {
+        return '';
+    }
+}

package/dist/answer-parse.js

@@ -71,7 +71,12 @@ export function responseLooksLikeToolCall(rawResponse) {
         // colons like "path: ...".
         (/^\s*[\[\{]/.test(raw) &&
             /["']?(?:tool|args|command|path|old_string|content|content_base64)["']?\s*:/.test(raw)) ||
-        /<\s*\|?\s*(DSML|invoke|parameter)/i.test(raw) ||
+        /<\s*\|?\s*(DSML|invoke|parameter|tool_use|tool_call|function_call|antml)/i.test(raw) ||
+        // OpenAI-style call wrappers: {"function_call": {...}},
+        // {"tool_calls": [...]}, {"name": "Bash", "arguments": "..."}. A real
+        // shape from the live chat — without these markers the answer was taken
+        // as prose and the agent silently stopped instead of calling the tool.
+        /["'](?:function_call|tool_calls?|arguments|parameters)["']\s*:/.test(raw) ||
         /^\s*\[?\s*\{[^}]*$/.test(raw.trim()));
 }
 // A respond message is only a real FINAL answer when it carries some meaning.

package/dist/index.js

@@ -369,6 +369,19 @@ async function reloadModules() {
         mod.attach = loaded.get('attach-refs');
     if (pick('run-task', 'runTask'))
         mod.runTask = pick('run-task', 'runTask');
+    // answer-parse.ts and xml-toolcall.ts are NOT hot-reloadable: the loop
+    // keeps the parser functions in LIVE bindings, so /reload must push the
+    // freshly imported copy through it (a parser fix must not need a restart).
+    try {
+        const ap = (await import('./answer-parse.js'));
+        const loopMod = loaded.get('agent-loop');
+        const setter = loopMod ? loopMod['_setParserBindings'] : undefined;
+        if (typeof setter === 'function')
+            setter(ap);
+    }
+    catch (e) {
+        errors.push('answer-parse: ' + e.message);
+    }
     return { count: loaded.size, errors };
 }
 // Initial load so that mod.buildSystemPrompt and the rest are populated.
@@ -1016,6 +1029,7 @@ function runTaskDeps() {
         config,
         runAgentLoop: mod.runAgentLoop,
         createSpinner: mod.createSpinner,
+        devDump: devMode,
         onAssistantMessage: (msg) => {
             lastAssistantMessage = msg;
         },

package/dist/run-task.js

@@ -403,6 +403,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 },
                 onChatReady,
                 debugLog: debug,
+                devDump: deps.devDump === true,
                 locale,
                 askDeadlineMs: providerAskDeadlineMs(config),
                 maxAfterToolRetries: config.browser.maxAfterToolRetries,

package/dist/xml-toolcall.js

@@ -252,5 +252,46 @@ export function parseXmlToolCalls(text) {
     // name in such an answer, so the call can't be restored — but it also must
     // not be silently taken as the final answer: agent-loop will ask to retry
     // (looksLikeToolCall triggers on the word parameter/DSML).
-    return null;
+    //
+    // ONE exception is restorable: the tool name itself arrives as a parameter
+    // (a `name="tool"` parameter next to `name="args"`). A live answer used
+    // exactly this shape; before, it was dropped and the agent stalled after a
+    // call that never ran.
+    return parseBareDsmlCall(text);
+}
+// A call that arrived as a bare list of parameter tags with NO invoke wrapper:
+// the tool name is the `tool` (or `name`) parameter and the arguments are the
+// `args` parameter (JSON) or the remaining ones.
+function parseBareDsmlCall(text) {
+    if (!/<[^>]*?parameter/i.test(text))
+        return null;
+    const args = parseParameters(text);
+    const toolRaw = args['tool'] ?? args['tool_name'] ?? args['name'];
+    if (typeof toolRaw !== 'string' || !toolRaw.trim())
+        return null;
+    const tool = toolRaw.trim();
+    let finalArgs = {};
+    if ('args' in args) {
+        const a = args['args'];
+        if (a && typeof a === 'object' && !Array.isArray(a)) {
+            finalArgs = a;
+        }
+        else if (typeof a === 'string') {
+            try {
+                const parsed = JSON.parse(a);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    finalArgs = parsed;
+                }
+            }
+            catch { }
+        }
+    }
+    for (const k of Object.keys(args)) {
+        if (k === 'tool' || k === 'tool_name' || k === 'name' || k === 'args') {
+            continue;
+        }
+        if (!(k in finalArgs))
+            finalArgs[k] = args[k];
+    }
+    return { tool, args: finalArgs };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.92.0",
+  "version": "2.94.0",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen or GLM — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {