agent.libx.js 0.93.17 → 0.93.18

package/dist/cli.js

@@ -3575,6 +3575,17 @@ var DuplexAgent = class {
   seq = 0;
   pendingEvents = [];
   flushQueued = false;
+  /** Per-voice-turn guards (reset by resetTurn at each turn's start). The reflex is a weak model:
+   *  left unguarded it polls TaskStatus after a dispatch and/or dispatches silently (dead air).
+   *  Like CC's Task tool, a dispatch is "said my piece, now wait for the push" — these enforce that. */
+  turnDispatched = false;
+  // an Act/Think fired this turn
+  turnBriefs = /* @__PURE__ */ new Set();
+  // briefs dispatched this turn (detect identical re-dispatch)
+  spokeThisTurn = false;
+  // any non-empty text_delta streamed this turn
+  nudging = false;
+  // re-ack pass in flight: block ALL tools, prevent recursion
   /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
   pendingAsks = /* @__PURE__ */ new Map();
   /** Lazily resolved memory tools (async loadMemory runs in initMemory). */
@@ -3599,12 +3610,21 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       this.answerTaskTool(),
       this.holdTool()
     ];
+    const host = o.host;
+    const voiceHost = host && {
+      ask: host.ask ? (q2) => host.ask(q2) : void 0,
+      confirm: host.confirm ? (p, m) => host.confirm(p, m) : void 0,
+      notify: (ev) => {
+        if (ev?.kind === "text_delta" && typeof ev.message === "string" && ev.message.trim()) this.spokeThisTurn = true;
+        host.notify?.(ev);
+      }
+    };
     this.voice = new Agent({
       ai: o.ai,
       fs: new MemFilesystem2(),
       model: o.reflexModel,
       stream: true,
-      host: o.host,
+      host: voiceHost,
       // The reflex IS the conversational channel — it confirms ambiguity inline ("did you mean…?"),
       // never via the blocking AskUserQuestion tool (Agent auto-adds it whenever a host is set). Left in,
       // it stalls a voice turn until the kill-switch. Worker questions still reach the user via parkQuestion.
@@ -3614,7 +3634,9 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       maxSteps: 8,
       timeoutMs: 3e4,
       ...o.reflexOptions,
-      tools
+      tools,
+      // Composed AFTER the spread so the dispatch guard can't be dropped by reflexOptions.
+      hooks: composeHooks(this.dispatchGuard(), o.reflexOptions?.hooks)
     });
   }
   /** Resolve memory tools + inject index into voice system prompt (once). */
@@ -3625,11 +3647,54 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
     this.voice.options.tools.push(...mem.tools);
     if (mem.index) this.voice.options.systemPrompt += "\n\n" + mem.index;
   }
+  /** Clear the per-turn guards. Called at the head of every voice turn (user send + re-voice flush). */
+  resetTurn() {
+    this.turnDispatched = false;
+    this.turnBriefs.clear();
+    this.spokeThisTurn = false;
+  }
+  /** preToolUse guard on the reflex: once it has dispatched this turn, a dispatch is "said my piece,
+   *  now wait for the push" (CC's Task model). Block the temptations — TaskStatus polling and identical
+   *  re-dispatch — so the only remaining move is to voice a short ack and end. A genuinely NEW Act is
+   *  still allowed (parallel independent work). During a re-ack pass, block every tool. */
+  dispatchGuard() {
+    return {
+      preToolUse: (call) => {
+        if (this.nudging) return { block: true, reason: "Just say one short spoken acknowledgement \u2014 no tools this turn." };
+        if (!this.turnDispatched) return;
+        if (call.name === "TaskStatus")
+          return { block: true, reason: "You just dispatched a task this turn \u2014 do NOT poll. Give one short spoken acknowledgement and end your turn; the result arrives later as a [task \u2026] event." };
+        if ((call.name === "Act" || call.name === "Think") && this.turnBriefs.has(String(call.args?.brief ?? "")))
+          return { block: true, reason: "You already dispatched this exact task \u2014 acknowledge briefly and end your turn." };
+      }
+    };
+  }
+  /** True when the just-finished turn dispatched a task but voiced nothing — dead air to repair.
+   *  Requires a host: without one there's no stream to detect speech on (and no one to speak to). */
+  get silentDispatch() {
+    return !!this.options.host && this.turnDispatched && !this.spokeThisTurn;
+  }
+  /** A dispatch with no spoken text is dead air. Re-prompt the reflex ONCE so the LLM itself voices a
+   *  short ack (no template). If it STILL says nothing, fall back to a minimal line so silence never ships. */
+  async ackIfSilent() {
+    this.nudging = true;
+    try {
+      await this.voice.send("[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools.");
+    } catch (e) {
+      log6.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+    } finally {
+      this.nudging = false;
+    }
+    if (!this.spokeThisTurn) this.options.host?.notify?.({ kind: "text_delta", message: "Okay, on it." });
+  }
   /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns. */
   send(content) {
     return this.enqueue(async () => {
       await this.initMemory();
-      return this.voice.send(content);
+      this.resetTurn();
+      const res = await this.voice.send(content);
+      if (this.silentDispatch) await this.ackIfSilent();
+      return res;
     });
   }
   /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */
@@ -3662,7 +3727,9 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       this.flushQueued = false;
       const events = this.pendingEvents.splice(0);
       if (!events.length) return;
+      this.resetTurn();
       await this.voice.send(events.join("\n"));
+      if (this.silentDispatch) await this.ackIfSilent();
       this.notify("revoice_done", "");
     });
   }
@@ -3895,6 +3962,8 @@ Another agent just implemented the above. Independently check the CURRENT state
         }
       },
       run: async ({ brief, label }) => {
+        this.turnDispatched = true;
+        this.turnBriefs.add(String(brief ?? ""));
         const id = await this.dispatch(String(brief ?? ""), "act", label ? String(label) : void 0);
         return `Acting on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
       }
@@ -3913,6 +3982,8 @@ Another agent just implemented the above. Independently check the CURRENT state
         }
       },
       run: async ({ brief, label }) => {
+        this.turnDispatched = true;
+        this.turnBriefs.add(String(brief ?? ""));
         const id = await this.dispatch(String(brief ?? ""), "think", label ? String(label) : void 0);
         return `Thinking on task ${id}. Acknowledge briefly; the result will arrive as a [task ${id} completed] event.`;
       }
@@ -4781,6 +4852,7 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 // src/mcp.client.ts
 init_logging();
 import { spawn } from "child_process";
+import { createHash } from "crypto";
 var log10 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -4973,37 +5045,136 @@ var McpClient = class {
     await this.transport.close();
   }
 };
-async function mountMcpServer(name, cfg) {
-  const transport = cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs });
-  const client = new McpClient(transport);
-  const init = await client.connect();
-  const specs = await client.listTools();
-  const tools = mcpToolsToAgentTools(specs, (tool, a) => client.callTool(tool, a), `mcp__${name}__`);
-  return { name, client, tools, specs, serverInfo: init?.serverInfo };
-}
-async function mountMcpServers(servers = {}) {
-  const out = [];
-  for (const [name, cfg] of Object.entries(servers)) {
-    if (!cfg || cfg.disabled) continue;
+function buildTransport(cfg) {
+  return cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs });
+}
+function withTimeout(p, ms, label) {
+  if (!ms || ms <= 0) return p;
+  return new Promise((resolve4, reject) => {
+    const timer = setTimeout(() => reject(new Error(`MCP "${label}" mount exceeded ${ms}ms`)), ms);
+    timer.unref?.();
+    p.then((v) => {
+      clearTimeout(timer);
+      resolve4(v);
+    }, (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
+}
+async function mountWithDeadline(name, cfg, mountTimeoutMs) {
+  const client = new McpClient(buildTransport(cfg));
+  try {
+    return await withTimeout((async () => {
+      const init = await client.connect();
+      const specs = await client.listTools();
+      const tools = mcpToolsToAgentTools(specs, (tool, a) => client.callTool(tool, a), `mcp__${name}__`);
+      return { name, client, tools, specs, serverInfo: init?.serverInfo };
+    })(), mountTimeoutMs, name);
+  } catch (e) {
+    await client.close().catch((err2) => log10.debug(`close after failed mount of "${name}": ${err2}`));
+    throw e;
+  }
+}
+function mountMcpServer(name, cfg) {
+  return mountWithDeadline(name, cfg);
+}
+function validEntries(servers) {
+  return Object.entries(servers).filter(([name, cfg]) => {
+    if (!cfg || cfg.disabled) return false;
     if (!cfg.command && !cfg.url) {
       log10.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
-      continue;
-    }
-    try {
-      const m = await mountMcpServer(name, cfg);
-      out.push(m);
-      log10.info(`MCP "${name}" mounted \u2014 ${m.tools.length} tool(s)${m.serverInfo?.name ? ` from ${m.serverInfo.name}` : ""}`);
-    } catch (e) {
-      if (e instanceof McpAuthError) log10.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-      else log10.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+      return false;
     }
-  }
+    return true;
+  });
+}
+function logMountFailure(name, e) {
+  if (e instanceof McpAuthError) log10.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log10.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+}
+async function mountMcpServers(servers = {}, opts = {}) {
+  const entries = validEntries(servers);
+  const settled = await Promise.allSettled(entries.map(([name, cfg]) => mountWithDeadline(name, cfg, opts.mountTimeoutMs)));
+  const out = [];
+  settled.forEach((r, i) => {
+    const name = entries[i][0];
+    if (r.status === "fulfilled") {
+      out.push(r.value);
+      log10.info(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
+    } else logMountFailure(name, r.reason);
+  });
   return out;
 }
+var MemMcpCatalog = class {
+  constructor(ttlMs = 5 * 6e4) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  m = /* @__PURE__ */ new Map();
+  get(key) {
+    const e = this.m.get(key);
+    if (!e) return null;
+    if (Date.now() > e.exp) {
+      this.m.delete(key);
+      return null;
+    }
+    return e.specs;
+  }
+  set(key, specs) {
+    this.m.set(key, { specs, exp: Date.now() + this.ttlMs });
+  }
+};
+var McpPool = class {
+  constructor(ttlMs = 5 * 6e4) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  warm = /* @__PURE__ */ new Map();
+  get(key) {
+    const e = this.warm.get(key);
+    if (!e) return null;
+    this.arm(key, e);
+    return e.client;
+  }
+  put(key, client) {
+    const prev = this.warm.get(key);
+    if (prev) {
+      clearTimeout(prev.timer);
+      if (prev.client !== client) void prev.client.close().catch((err2) => log10.debug(`warm-pool replace close failed: ${err2}`));
+    }
+    const e = { client, timer: void 0 };
+    this.warm.set(key, e);
+    this.arm(key, e);
+  }
+  arm(key, e) {
+    clearTimeout(e.timer);
+    e.timer = setTimeout(() => {
+      void this.evict(key);
+    }, this.ttlMs);
+    e.timer.unref?.();
+  }
+  async evict(key) {
+    const e = this.warm.get(key);
+    if (!e) return;
+    this.warm.delete(key);
+    await e.client.close().catch((err2) => log10.debug(`warm-pool evict close failed: ${err2}`));
+  }
+  async closeAll() {
+    for (const e of this.warm.values()) {
+      clearTimeout(e.timer);
+      await e.client.close().catch(() => {
+      });
+    }
+    this.warm.clear();
+  }
+};
+var defaultCatalog = new MemMcpCatalog();
+var defaultPool = new McpPool();
 
 // cli/mcpOAuth.ts
 import { createServer } from "http";
-import { randomBytes, createHash } from "crypto";
+import { randomBytes, createHash as createHash2 } from "crypto";
 import { readFileSync, writeFileSync as writeFileSync2, mkdirSync, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var McpOAuthOptions = class {
@@ -5047,7 +5218,7 @@ var McpOAuth = class {
     const meta = await this.discover(serverUrl);
     const clientId = this.options.clientId ?? await this.registerClient(meta, serverUrl);
     const verifier = b64url(randomBytes(32));
-    const challenge = b64url(createHash("sha256").update(verifier).digest());
+    const challenge = b64url(createHash2("sha256").update(verifier).digest());
     const state = b64url(randomBytes(16));
     const { code, redirectUri } = await this.captureCode(meta.authorization_endpoint, clientId, challenge, state);
     const tok = await this.exchange(meta.token_endpoint, {