pelulu-cli 1.1.0 → 1.2.0

package/src/core/http-client.js

@@ -0,0 +1,285 @@
+/**
+ * Shared HTTP engine for all tools.
+ *
+ * Why this exists: previously every tool re-implemented raw http.request with
+ * subtle differences and NONE of them decompressed responses. Real-world
+ * servers (Cloudflare, nginx gzip, brotli via CDNs) return compressed bodies,
+ * so body-based detection silently failed everywhere. This module centralizes:
+ *   - transparent gzip / deflate / br decompression
+ *   - accurate wall-clock timing (duration_ms) for time-based detection
+ *   - real redirect following with a recorded chain + loop protection
+ *   - bounded retries with backoff for transient network errors
+ *   - a global concurrency limiter so batch scans don't self-DoS the target
+ *   - a hard body-size cap to stay memory-safe on huge responses
+ */
+import https from 'https';
+import http from 'http';
+import zlib from 'zlib';
+import { URL } from 'url';
+
+export const DEFAULT_UA =
+  'Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36';
+
+const DEFAULT_TIMEOUT = 15000;
+const DEFAULT_MAX_BODY = 2 * 1024 * 1024; // 2 MB
+const DEFAULT_MAX_REDIRECTS = 5;
+const DEFAULT_RETRIES = 1;
+
+// ---------------------------------------------------------------------------
+// Global concurrency limiter (shared across every tool in the process).
+// Keeps aggressive batch scanning from opening hundreds of sockets at once.
+// ---------------------------------------------------------------------------
+let MAX_CONCURRENCY = 8;
+let active = 0;
+const queue = [];
+
+export function setMaxConcurrency(n) {
+  MAX_CONCURRENCY = Math.max(1, n | 0);
+}
+
+function acquire() {
+  if (active < MAX_CONCURRENCY) {
+    active++;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => queue.push(resolve));
+}
+
+function release() {
+  active--;
+  const next = queue.shift();
+  if (next) {
+    active++;
+    next();
+  }
+}
+
+function decompress(buffer, encoding) {
+  if (!buffer || buffer.length === 0) return '';
+  try {
+    const enc = (encoding || '').toLowerCase();
+    if (enc.includes('br')) return zlib.brotliDecompressSync(buffer).toString('utf8');
+    if (enc.includes('gzip')) return zlib.gunzipSync(buffer).toString('utf8');
+    if (enc.includes('deflate')) {
+      try {
+        return zlib.inflateSync(buffer).toString('utf8');
+      } catch {
+        return zlib.inflateRawSync(buffer).toString('utf8');
+      }
+    }
+  } catch {
+    // Corrupt / partial compressed stream — fall back to raw bytes.
+  }
+  return buffer.toString('utf8');
+}
+
+function normalizeHeaders(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw || {})) {
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : v;
+  }
+  return out;
+}
+
+/** Return set-cookie always as an array (Node gives array or string). */
+function rawSetCookies(headers) {
+  const sc = headers['set-cookie'];
+  if (!sc) return [];
+  return Array.isArray(sc) ? sc : [sc];
+}
+
+function singleRequest(rawUrl, opts) {
+  const {
+    method = 'GET',
+    headers = {},
+    body = null,
+    timeout = DEFAULT_TIMEOUT,
+    maxBody = DEFAULT_MAX_BODY,
+  } = opts;
+
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(rawUrl);
+    } catch {
+      return reject(new Error(`Invalid URL: ${rawUrl}`));
+    }
+    const lib = parsed.protocol === 'https:' ? https : http;
+
+    const outHeaders = {
+      'User-Agent': DEFAULT_UA,
+      'Accept': '*/*',
+      'Accept-Encoding': 'gzip, deflate, br',
+      'Connection': 'close',
+      ...headers,
+    };
+    if (body && !outHeaders['Content-Length'] && !outHeaders['content-length']) {
+      outHeaders['Content-Length'] = Buffer.byteLength(body);
+    }
+
+    const reqOpts = {
+      protocol: parsed.protocol,
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: method.toUpperCase(),
+      headers: outHeaders,
+      timeout,
+      rejectUnauthorized: false,
+    };
+
+    const start = Date.now();
+    const req = lib.request(reqOpts, (res) => {
+      const chunks = [];
+      let size = 0;
+      let truncated = false;
+      res.on('data', (c) => {
+        size += c.length;
+        if (size <= maxBody) chunks.push(c);
+        else truncated = true;
+      });
+      res.on('end', () => {
+        const headersLower = normalizeHeaders(res.headers);
+        const buf = Buffer.concat(chunks);
+        const decoded = decompress(buf, headersLower['content-encoding']);
+        resolve({
+          status: res.statusCode,
+          headers: headersLower,
+          setCookies: rawSetCookies(headersLower),
+          body: decoded,
+          bytes: size,
+          truncated,
+          duration_ms: Date.now() - start,
+          url: rawUrl,
+          finalUrl: rawUrl,
+          location: headersLower['location'] || null,
+        });
+      });
+      res.on('error', reject);
+    });
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Timeout after ${timeout}ms`));
+    });
+    if (body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(reqOpts.method)) req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * Perform an HTTP request with retries, redirect following and decompression.
+ *
+ * @param {string} url
+ * @param {object} [options]
+ * @param {string} [options.method='GET']
+ * @param {object} [options.headers]
+ * @param {string} [options.body]
+ * @param {number} [options.timeout=15000]
+ * @param {boolean} [options.followRedirects=false]
+ * @param {number} [options.maxRedirects=5]
+ * @param {number} [options.retries=1]
+ * @param {number} [options.maxBody]
+ * @returns {Promise<object>} normalized response with duration_ms, redirectChain, etc.
+ */
+export async function request(url, options = {}) {
+  const {
+    followRedirects = false,
+    maxRedirects = DEFAULT_MAX_REDIRECTS,
+    retries = DEFAULT_RETRIES,
+  } = options;
+
+  await acquire();
+  try {
+    let attempt = 0;
+    let lastErr;
+    let res;
+    // Retry loop for transient failures (ECONNRESET / timeouts / etc).
+    while (attempt <= retries) {
+      try {
+        res = await singleRequest(url, options);
+        break;
+      } catch (err) {
+        lastErr = err;
+        attempt++;
+        if (attempt > retries) throw lastErr;
+        await new Promise((r) => setTimeout(r, 150 * attempt));
+      }
+    }
+
+    const redirectChain = [];
+    const visited = new Set([url]);
+    let current = res;
+    let hops = 0;
+    let currentUrl = url;
+    while (
+      followRedirects &&
+      current.status >= 300 &&
+      current.status < 400 &&
+      current.location &&
+      hops < maxRedirects
+    ) {
+      let nextUrl;
+      try {
+        nextUrl = new URL(current.location, currentUrl).href;
+      } catch {
+        break;
+      }
+      redirectChain.push({ status: current.status, from: currentUrl, to: nextUrl });
+      if (visited.has(nextUrl)) break; // loop guard: already fetched this absolute URL
+      visited.add(nextUrl);
+      // Per RFC, 303 (and commonly 301/302) downgrade to GET without a body.
+      const nextMethod = [301, 302, 303].includes(current.status) ? 'GET' : options.method || 'GET';
+      const nextBody = nextMethod === 'GET' ? null : options.body;
+      current = await singleRequest(nextUrl, { ...options, method: nextMethod, body: nextBody });
+      currentUrl = nextUrl;
+      hops++;
+    }
+
+    current.redirectChain = redirectChain;
+    current.finalUrl = currentUrl;
+    current.requestedUrl = url;
+    return current;
+  } finally {
+    release();
+  }
+}
+
+/** Convenience GET. */
+export function get(url, options = {}) {
+  return request(url, { ...options, method: 'GET' });
+}
+
+/**
+ * Run an async mapper over items with bounded parallelism.
+ * (The global limiter also applies, but this keeps result ordering + batching.)
+ */
+export async function mapLimit(items, limit, mapper) {
+  const results = new Array(items.length);
+  let idx = 0;
+  const workers = new Array(Math.min(limit, items.length || 1)).fill(0).map(async () => {
+    while (idx < items.length) {
+      const i = idx++;
+      try {
+        results[i] = await mapper(items[i], i);
+      } catch (err) {
+        results[i] = { __error: err?.message || String(err) };
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+/** Parse a "key:value|key:value" header string into an object. */
+export function parseHeaderString(headerStr) {
+  const headers = {};
+  if (!headerStr) return headers;
+  for (const pair of headerStr.split('|')) {
+    const idx = pair.indexOf(':');
+    if (idx > 0) headers[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+  }
+  return headers;
+}
+
+export default { request, get, mapLimit, setMaxConcurrency, parseHeaderString, DEFAULT_UA };

package/src/core/job-manager.js

@@ -0,0 +1,192 @@
+/**
+ * JobManager — universal async job layer for ALL tools.
+ *
+ * WHY: XiaoZhi aborts any MCP tool call that runs longer than ~30s and then
+ * assumes the tool "timed out" — even though it is still working. That is the
+ * root cause of the "system timeout padahal berjalan" bug. Instead of making
+ * every one of the tools background-aware by hand, we wrap the tool dispatch
+ * boundary in a single job layer:
+ *
+ *   - Fast actions (finish within `graceMs`) return their result inline, exactly
+ *     as before — no behaviour change for reads/config/etc.
+ *   - Slow actions keep running in the BACKGROUND and immediately return a
+ *     job handle. The AI (or the user) then polls the `jobs` tool for progress
+ *     and the final result, so the agent never stalls or hallucinates a failure.
+ *
+ * Every job streams lifecycle events on the bus (job:started / job:progress /
+ * job:done) so the TUI can show continuous, inline feedback for ANY tool.
+ */
+import { randomUUID } from 'crypto';
+import { bus } from './event-bus.js';
+import { debug } from './logger.js';
+
+const MAX_JOBS = 40;          // ring-buffer cap so memory never grows unbounded
+const DEFAULT_GRACE_MS = 8000; // < XiaoZhi's ~30s timeout, with wide margin
+
+class JobManager {
+  #jobs = new Map();   // id -> job
+  #order = [];         // insertion order for pruning + "latest"
+
+  /**
+   * Run `executor(job)` under a job. Resolves as soon as we know whether the
+   * work finished quickly or had to be backgrounded.
+   *
+   * @returns {Promise<{done:boolean, job:object, result?:any, error?:Error}>}
+   *   done=true  -> finished within the grace window (result/error populated)
+   *   done=false -> still running in the background (poll via the `jobs` tool)
+   */
+  async dispatch({ tool, action, label } = {}, executor, { graceMs = DEFAULT_GRACE_MS } = {}) {
+    const job = this.#create({ tool, action, label });
+
+    // Kick off the actual work. We attach terminal handlers up-front so the job
+    // is always finalized regardless of whether we returned inline or backgrounded.
+    const work = Promise.resolve()
+      .then(() => executor(job))
+      .then((result) => { this.#finish(job, result); return { kind: 'result', result }; })
+      .catch((error) => { this.#fail(job, error); return { kind: 'error', error }; });
+
+    const raced = await Promise.race([
+      work,
+      new Promise((res) => setTimeout(() => res({ kind: 'timeout' }), graceMs)),
+    ]);
+
+    if (raced.kind === 'result') return { done: true, job, result: raced.result };
+    if (raced.kind === 'error') return { done: true, job, error: raced.error };
+
+    // Timed out the grace window -> run in background, let the AI poll.
+    job.backgrounded = true;
+    debug('job', `${tool}.${action || ''} backgrounded as ${job.id}`);
+    bus.emit('job:backgrounded', this.snapshot(job));
+    return { done: false, job };
+  }
+
+  /** Append a human-readable progress line to a running job (streamed to TUI). */
+  progress(jobId, message, extra = {}) {
+    const job = this.#jobs.get(jobId);
+    if (!job || job.status !== 'running') return;
+    const entry = { at: Date.now(), message, ...extra };
+    job.progress.push(entry);
+    if (job.progress.length > 100) job.progress.shift();
+    bus.emit('job:progress', { id: job.id, tool: job.tool, action: job.action, message, ...extra });
+  }
+
+  get(id) { return this.#jobs.get(id) || null; }
+
+  /** Most recent job (running preferred), for "status" with no explicit id. */
+  latest() {
+    for (let i = this.#order.length - 1; i >= 0; i--) {
+      const job = this.#jobs.get(this.#order[i]);
+      if (job && job.status === 'running') return job;
+    }
+    const lastId = this.#order[this.#order.length - 1];
+    return lastId ? this.#jobs.get(lastId) : null;
+  }
+
+  list() { return this.#order.map((id) => this.#jobs.get(id)).filter(Boolean); }
+
+  running() { return this.list().filter((j) => j.status === 'running'); }
+
+  /**
+   * Cooperative cancel: flag the job so cancel-aware executors can bail out.
+   * Non-cooperative work keeps running but its result is discarded.
+   */
+  cancel(id) {
+    const job = this.#jobs.get(id);
+    if (!job || job.status !== 'running') return false;
+    job.cancelRequested = true;
+    return true;
+  }
+
+  /** Wait up to `timeoutMs` for a job to leave the running state. */
+  async wait(id, timeoutMs = 20000) {
+    const job = this.#jobs.get(id);
+    if (!job) return null;
+    if (job.status !== 'running') return job;
+    return new Promise((resolve) => {
+      const done = () => { clearInterval(poll); clearTimeout(timer); bus.off('job:done', onDone); resolve(job); };
+      const onDone = (snap) => { if (snap.id === id) done(); };
+      const poll = setInterval(() => { if (job.status !== 'running') done(); }, 200);
+      const timer = setTimeout(() => { clearInterval(poll); bus.off('job:done', onDone); resolve(job); }, timeoutMs);
+      bus.on('job:done', onDone);
+    });
+  }
+
+  /** Plain, serializable view of a job for tool results / events. */
+  snapshot(job) {
+    if (!job) return null;
+    const now = job.finishedAt || Date.now();
+    return {
+      id: job.id,
+      tool: job.tool,
+      action: job.action,
+      label: job.label,
+      status: job.status,
+      backgrounded: !!job.backgrounded,
+      elapsed_s: Math.round((now - job.startedAt) / 1000),
+      progress: job.progress.slice(-5).map((p) => p.message),
+      error: job.error || undefined,
+    };
+  }
+
+  // ─── internals ───────────────────────────────────────────
+  #create({ tool, action, label }) {
+    const job = {
+      id: `job_${randomUUID().slice(0, 8)}`,
+      tool, action,
+      label: label || `${tool}${action ? `.${action}` : ''}`,
+      status: 'running',
+      startedAt: Date.now(),
+      finishedAt: null,
+      progress: [],
+      result: undefined,
+      error: null,
+      backgrounded: false,
+      cancelRequested: false,
+    };
+    this.#jobs.set(job.id, job);
+    this.#order.push(job.id);
+    this.#prune();
+    bus.emit('job:started', this.snapshot(job));
+    return job;
+  }
+
+  #finish(job, result) {
+    if (job.status !== 'running') return;
+    job.status = job.cancelRequested ? 'cancelled' : 'done';
+    job.finishedAt = Date.now();
+    job.result = this.#normalizeResult(result);
+    bus.emit('job:done', { ...this.snapshot(job), result: job.result });
+  }
+
+  #fail(job, error) {
+    if (job.status !== 'running') return;
+    job.status = 'error';
+    job.finishedAt = Date.now();
+    job.error = error?.message || String(error);
+    bus.emit('job:done', { ...this.snapshot(job), error: job.error });
+  }
+
+  /**
+   * Tool results come back in MCP shape ({ isError, content:[{text}] }). Unwrap
+   * to the raw payload so polling the `jobs` tool returns clean data.
+   */
+  #normalizeResult(result) {
+    if (result && Array.isArray(result.content) && result.content[0]?.type === 'text') {
+      const text = result.content[0].text;
+      try { return JSON.parse(text); } catch { return text; }
+    }
+    return result;
+  }
+
+  #prune() {
+    while (this.#order.length > MAX_JOBS) {
+      const oldest = this.#order.shift();
+      const job = this.#jobs.get(oldest);
+      // Never evict a job that is still running.
+      if (job && job.status === 'running') { this.#order.push(oldest); break; }
+      this.#jobs.delete(oldest);
+    }
+  }
+}
+
+export const jobManager = new JobManager();

package/src/core/tool-registry.js

@@ -51,6 +51,26 @@ export class ToolRegistry {
   }
 
   toMcpTools() {
+    // Trimmed descriptions to stay under XiaoZhi broker 8KB limit
+    const desc = {
+      agent: 'Agent: spawn, list, status',
+      ai: 'Code analysis, summarize, diff',
+      config: 'Config: get, set, list, reset',
+      diff: 'File comparison: compare, patch',
+      env: 'Env variables: get, set, list',
+      file: 'File ops: read, write, edit, delete, copy',
+      git: 'Git: init, clone, status, diff, commit, push',
+      history: 'Tool history: list, clear, stats',
+      jobs: 'Poll background jobs: list, status, wait, result, cancel',
+      network: 'Network: fetch, download, ping',
+      process: 'Process: list, info, kill, top',
+      project: 'Project: init, build, test, lint',
+      search: 'Search: grep, find, web fetch',
+      shell: 'Shell: exec, background, ps, kill',
+      snippet: 'Snippets: save, load, list, delete',
+      template: 'Templates: list, create, info',
+      watch: 'File watch: start, stop, status',
+    };
     return this.all().map(t => {
       const schema = t.inputSchema || { type: 'object', properties: {} };
       const compact = { type: 'object', properties: {} };
@@ -62,7 +82,18 @@ export class ToolRegistry {
           compact.properties[k] = prop;
         }
       }
-      return { name: t.name, description: t.description, inputSchema: compact };
+      // Include per-action required fields in the description so the AI
+      // knows exactly which params each action needs (MCP schema only
+      // supports a flat required array, not conditional per-action).
+      let description = desc[t.name] || t.description;
+      if (t.actions?.length) {
+        const actionReqs = t.actions
+          .filter(a => a.required?.length)
+          .map(a => `${a.name}→${a.required.join(',')}`)
+          .join('; ');
+        if (actionReqs) description += ` [required: ${actionReqs}]`;
+      }
+      return { name: t.name, description, inputSchema: compact };
     });
   }
 
@@ -70,13 +101,33 @@ export class ToolRegistry {
     const tool = this.#tools.get(name);
     if (!tool) return { isError: true, content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
     try {
-      const result = await tool.handler(args);
+      const result = await tool.handler(args, this._toolsRef());
       return { isError: false, content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }] };
     } catch (e) {
       return { isError: true, content: [{ type: 'text', text: e.message }] };
     }
   }
 
+  /** Call a tool and return parsed result (for internal tool-to-tool calls) */
+  async callParsed(name, args = {}) {
+    const tool = this.#tools.get(name);
+    if (!tool) throw new Error(`Unknown tool: ${name}`);
+    return await tool.handler(args, this._toolsRef());
+  }
+
+  /**
+   * The reference handed to every tool handler. Beyond `call`, it exposes tool
+   * discovery (`has` / `names`) so orchestrator tools can adapt dynamically to
+   * whatever tools are actually loaded instead of hardcoding a fixed pipeline.
+   */
+  _toolsRef() {
+    return {
+      call: (toolName, toolArgs) => this.callParsed(toolName, toolArgs),
+      has: (toolName) => this.#tools.has(toolName),
+      names: () => [...this.#tools.keys()],
+    };
+  }
+
   async shutdown() {
     for (const tool of this.#tools.values()) {
       if (tool.shutdown) await tool.shutdown();

package/src/index.js

@@ -13,10 +13,12 @@ import { dirname, join } from 'path';
 import { readFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
-import { loadConfig, saveConfig } from './core/config.js';
+import { existsSync } from 'fs';
+import { loadConfig, saveConfig, expand } from './core/config.js';
 import { log, setDebug, debug, setInkMode, initFileLog, flushLogs, getLogFile, writeRawToLog } from './core/logger.js';
 import { bus } from './core/event-bus.js';
 import { ToolRegistry } from './core/tool-registry.js';
+import { jobManager } from './core/job-manager.js';
 import { Sandbox } from './core/sandbox.js';
 import { SessionState } from './core/session.js';
 import { Stats } from './core/stats.js';
@@ -177,24 +179,84 @@ async function main() {
 
   // 10. Register MCP tool handler (for XiaoZhi direct tool calls)
   // Agent calls are auto-approved — XiaoZhi controls the flow, no y/N prompts
+  // File tool actions that mutate the filesystem — tracked + surfaced in chat
+  const FILE_MUTATIONS = ['write', 'edit', 'delete', 'mkdir', 'copy', 'move'];
+
   mqtt.registerToolHandler(
     async (name, args) => {
       sandbox.validate(name, args);
 
       thinking.set('tool_call');
       const start = Date.now();
-      try {
-        const result = await registry.call(name, args);
+
+      // Capture pre-state so we can report created vs modified accurately
+      const trackedPath = args?.to || args?.path;
+      let preExisted = false;
+      if (name === 'file' && FILE_MUTATIONS.includes(args?.action) && trackedPath) {
+        try { preExisted = existsSync(expand(trackedPath)); } catch {}
+      }
+
+      // Post-processing shared by the inline and background completion paths:
+      // record stats, track file mutations, and surface the result in the TUI.
+      const finalize = (result) => {
         stats.record(name, args.action, !result.isError, Date.now() - start);
         session.addToolCall(name, args, result);
 
-        if (name === 'file' && (args.action === 'write' || args.action === 'edit') && args.path) {
-          autoFormat(args.path).catch(() => {});
+        // Track file changes and broadcast them so the TUI can show tracking in chat
+        if (name === 'file' && !result.isError && FILE_MUTATIONS.includes(args.action) && trackedPath) {
+          const change =
+            args.action === 'delete' ? 'deleted'
+            : (args.action === 'edit' || preExisted) ? 'modified'
+            : 'created';
+          fileTracker.track(trackedPath, change);
+          bus.emit('files:changed', { path: trackedPath, change, changes: fileTracker.getChanges() });
+
+          if (args.action === 'write' || args.action === 'edit') {
+            autoFormat(trackedPath).catch(() => {});
+          }
         }
 
-        thinking.set('idle');
         bus.emit('tool:called', { name, result, args });
-        return result;
+      };
+
+      try {
+        // Route EVERY tool action through the job layer. Fast actions resolve
+        // inline (unchanged UX); slow ones background themselves and return a
+        // pollable job handle so XiaoZhi never assumes a timeout while the tool
+        // is still working. The AI polls progress/results with the `jobs` tool.
+        const dispatched = await jobManager.dispatch(
+          { tool: name, action: args.action, label: `${name}${args.action ? `.${args.action}` : ''}` },
+          () => registry.call(name, args),
+        );
+
+        if (dispatched.done) {
+          if (dispatched.error) throw dispatched.error;
+          finalize(dispatched.result);
+          thinking.set('idle');
+          return dispatched.result;
+        }
+
+        // Backgrounded: tell XiaoZhi it's running and how to follow up. Finalize
+        // the real result once the background work completes.
+        const job = dispatched.job;
+        jobManager.wait(job.id, 3_600_000).then(() => {
+          if (job.status === 'done' && job.result) {
+            const wrapped = { isError: false, content: [{ type: 'text', text: typeof job.result === 'string' ? job.result : JSON.stringify(job.result) }] };
+            finalize(wrapped);
+          }
+        }).catch(() => {});
+
+        thinking.set('idle');
+        return {
+          isError: false,
+          content: [{ type: 'text', text: JSON.stringify({
+            status: 'running',
+            job_id: job.id,
+            tool: name,
+            action: args.action,
+            message: `"${name}${args.action ? `.${args.action}` : ''}" is running in the background (job ${job.id}). It is NOT an error or timeout. Poll it with the jobs tool: {"action":"wait","id":"${job.id}"} to wait, or {"action":"status","id":"${job.id}"} to check progress.`,
+          }) }],
+        };
       } catch (e) {
         stats.record(name, args.action, false, Date.now() - start, e.message);
         thinking.set('idle');