agent.libx.js 0.93.17 → 0.93.19

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFil
 import { BodDB } from '@bod.ee/db';
 import { A as AgentTool, C as ChatLike, a as ChatOptions, b as ChatResponse, h as ToolCall, H as HostBridge, U as UserQuestion, e as MessageContent } from './tools-GPWp7oXq.js';
 export { c as ContentPart, d as HostEvent, M as Message, R as Role, S as SandboxJobRegistry, f as StreamChunk, T as TodoItem, g as Tool, i as ToolContext, j as bashTool, k as contentText, l as defaultTools, m as editTool, n as exitSessionTool, o as imagePart, p as makeContext, q as makeJobTools, r as readTool, t as toWireTools, s as todoWriteTool, u as toolRegistry, v as toolsByName } from './tools-GPWp7oXq.js';
-export { M as McpCall, a as McpImage, b as McpToolResult, c as McpToolSearchOptions, d as McpToolSpec, e as MountedMcpLike, m as makeMcpToolSearch, f as makeMcpToolSearchFromMounted, g as mcpToolToAgentTool, h as mcpToolsToAgentTools } from './mcp-DGWuuWJm.js';
+export { M as McpCall, a as McpImage, b as McpRoute, c as McpRouteResolver, d as McpToolResult, e as McpToolSearchOptions, f as McpToolSpec, g as MountedMcpLike, h as buildMcpCatalog, m as makeLazyMcpToolSearch, i as makeMcpToolSearch, j as makeMcpToolSearchFromMounted, k as mcpToolToAgentTool, l as mcpToolsToAgentTools } from './mcp-C5GuDinb.js';
 import * as libx_js_src_modules_log from 'libx.js/src/modules/log';
 export { log } from 'libx.js/src/modules/log';
 
@@ -660,6 +660,13 @@ declare class DuplexAgent {
     private seq;
     private pendingEvents;
     private flushQueued;
+    /** 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. */
+    private turnDispatched;
+    private turnBriefs;
+    private spokeThisTurn;
+    private nudging;
     /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
     readonly pendingAsks: Map<string, {
         question: string;
@@ -670,6 +677,19 @@ declare class DuplexAgent {
     constructor(options?: Partial<DuplexAgentOptions>);
     /** Resolve memory tools + inject index into voice system prompt (once). */
     private initMemory;
+    /** Clear the per-turn guards. Called at the head of every voice turn (user send + re-voice flush). */
+    private resetTurn;
+    /** 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. */
+    private dispatchGuard;
+    /** 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). */
+    private get silentDispatch();
+    /** 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. */
+    private ackIfSilent;
     /** One user turn: the voice agent streams the reply (and may Act/Think). Serialized with re-voice turns. */
     send(content: MessageContent): Promise<RunResult>;
     /** Resolve when all queued voice turns AND all in-flight worker tasks have settled (tests, graceful shutdown). */

package/dist/index.js

@@ -3675,6 +3675,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). */
@@ -3699,12 +3710,21 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
       this.answerTaskTool(),
       this.holdTool()
     ];
+    const host = o.host;
+    const voiceHost = host && {
+      ask: host.ask ? (q) => host.ask(q) : 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.
@@ -3714,7 +3734,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). */
@@ -3725,11 +3747,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) {
+      log7.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). */
@@ -3762,7 +3827,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", "");
     });
   }
@@ -3995,6 +4062,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.`;
       }
@@ -4013,6 +4082,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.`;
       }
@@ -4214,24 +4285,36 @@ function makeMcpToolSearch(specs, callTool, options = {}) {
   };
   return [searchTool, callMcpTool];
 }
-function makeMcpToolSearchFromMounted(mounted, options) {
+function buildMcpCatalog(servers) {
   const specs = [];
-  const callMap = /* @__PURE__ */ new Map();
-  for (const m of mounted) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const m of servers) {
     for (const s of m.specs) {
       const base = `mcp__${m.name}__${s.name}`.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
       let display = base;
-      for (let i = 2; callMap.has(display); i++) display = `${base.slice(0, 128 - String(i).length - 1)}_${i}`;
+      for (let i = 2; routes.has(display); i++) display = `${base.slice(0, 128 - String(i).length - 1)}_${i}`;
       specs.push({ name: display, description: s.description, inputSchema: s.inputSchema });
-      callMap.set(display, (_n, args) => m.client.callTool(s.name, args));
+      routes.set(display, { server: m.name, rawName: s.name });
     }
   }
+  return { specs, routes };
+}
+function searchOverCatalog(servers, specs, routes, resolve, options) {
   const tools = specs.length ? makeMcpToolSearch(specs, (name, args) => {
-    const call = callMap.get(name);
-    if (!call) throw new Error(`unknown MCP tool '${name}' \u2014 use ToolSearch to find valid names`);
-    return call(name, args ?? {});
+    const r = routes.get(name);
+    if (!r) throw new Error(`unknown MCP tool '${name}' \u2014 use ToolSearch to find valid names`);
+    return resolve(r.server, r.rawName, args ?? {});
   }, options) : [];
-  return { tools, serverNames: mounted.map((m) => m.name), toolCount: specs.length };
+  return { tools, serverNames: servers, toolCount: specs.length };
+}
+function makeMcpToolSearchFromMounted(mounted, options) {
+  const { specs, routes } = buildMcpCatalog(mounted);
+  const byName = new Map(mounted.map((m) => [m.name, m]));
+  return searchOverCatalog(mounted.map((m) => m.name), specs, routes, (server, rawName, args) => byName.get(server).client.callTool(rawName, args), options);
+}
+function makeLazyMcpToolSearch(servers, resolve, options) {
+  const { specs, routes } = buildMcpCatalog(servers);
+  return searchOverCatalog(servers.map((s) => s.name), specs, routes, resolve, options);
 }
 
 // src/hooks.ts
@@ -5030,6 +5113,7 @@ export {
   applyEditsTool,
   askUserQuestionTool,
   bashTool,
+  buildMcpCatalog,
   checkpointTool,
   checkpointTools,
   compileSynthesizedTool,
@@ -5057,6 +5141,7 @@ export {
   log,
   makeContext,
   makeJobTools,
+  makeLazyMcpToolSearch,
   makeMcpToolSearch,
   makeMcpToolSearchFromMounted,
   makeTaskBatchTool,