agent.libx.js 0.93.30 → 0.93.32

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-kWrJvtZM.js';
-export { C as ChatFragment, D as DEFAULT_MUTATING, b as Decision, P as PermissionOptions, c as PermissionPolicy, d as PermissionRule, e as PreToolUseDecision, R as ReasoningEffort, f as RecordingHooks, g as RecordingLifecycle, T as ToolUse, i as ToolUseMeta, j as composeHooks, p as planMode, r as reasoningToChatFragment } from './Agent-kWrJvtZM.js';
+import { a as AgentOptions, H as Hooks, h as RunResult, A as Agent } from './Agent-uWtu_WFY.js';
+export { C as ChatFragment, D as DEFAULT_MUTATING, b as Decision, P as PermissionOptions, c as PermissionPolicy, d as PermissionRule, e as PreToolUseDecision, R as ReasoningEffort, f as RecordingHooks, g as RecordingLifecycle, T as ToolUse, i as ToolUseMeta, j as composeHooks, p as planMode, r as reasoningToChatFragment } from './Agent-uWtu_WFY.js';
 import { IFilesystem, FileMetadata } from '@livx.cc/wcli/core';
 export { CommandExecutor, FileMetadata, IFilesystem, IndexedDbFilesystem, MemFilesystem, registerHeadlessCommands } from '@livx.cc/wcli/core';
 import { BodDB } from '@bod.ee/db';
@@ -418,6 +418,16 @@ declare class Scratch {
     capture(tool: AgentTool): AgentTool;
     /** Wrap many tools at once. */
     captureAll(tools: AgentTool[]): AgentTool[];
+    /**
+     * Spill an oversized tool result to a scratch file and return PAGE 1 + a recoverable, paginated stub.
+     * Drop-in for `Agent.capToolResult`: the agent sees usable content immediately and knows how to get
+     * the rest (refine the query, Read the file in pages with offset/limit, or Ask to extract specifics).
+     * Lossless — unlike a plain crop, the full output stays available on the scratch FS.
+     */
+    spill(full: string, info: {
+        tool: string;
+        args: any;
+    }, pageBytes?: number): Promise<string>;
 }
 interface AskOptions {
     /** The scratch filesystem to peek into (dedicated VFS holding only scratch files). */

package/dist/index.js

@@ -2688,6 +2688,14 @@ var AgentOptions = class {
   /** Token-aware backstop (~4 chars/token estimate). After note-taking, drop oldest messages from the
    *  sent context until the estimate is under this ceiling (pairing-safe). 0 = off. */
   maxContextTokens = 0;
+  /** Pagination ceiling for a SINGLE tool result (bytes). A result over this is cropped to page 1 with
+   *  a marker telling the model it was cropped (refine the query, or page further). Guards against one
+   *  Grep/Read/MCP call blowing the whole context window. 0 = off. Default 60k (~15k tokens). */
+  maxToolResultBytes = 6e4;
+  /** Hook to handle an oversized tool result instead of the default lossy crop: receives the FULL output
+   *  and returns the (cropped) string to put in context — e.g. spill to scratch and return a recoverable,
+   *  paginated stub. Called only when a result exceeds `maxToolResultBytes`. */
+  capToolResult;
   /** VFS dir(s) of skills (`<dir>/<id>/SKILL.md`). If set: inject a catalog + add the `Skill` tool. Multiple dirs are merged (first wins on name collisions). */
   skillsDir;
   /** VFS dir(s) of slash-command templates (`<dir>/<name>.md`). If set: inject a catalog + add the `SlashCommand` tool. Multiple dirs are merged (first wins). */
@@ -3103,6 +3111,11 @@ var Agent = class _Agent {
       this.ctx.emit = void 0;
     }
     if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
+    const cap = this.options.maxToolResultBytes ?? 0;
+    if (!threw && cap > 0 && result.length > cap) {
+      const info = { tool: tc.function.name, args };
+      result = this.options.capToolResult ? await this.options.capToolResult(result, info) : cropResult(result, cap);
+    }
     await hooks?.postToolUse?.(call, result, meta);
     this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: result, isError: threw });
     if (images?.length) {
@@ -3156,6 +3169,15 @@ function estimateTokens(m) {
   for (const x of m) chars += contentText(x.content).length + (x.tool_calls ? JSON.stringify(x.tool_calls).length : 0);
   return Math.ceil(chars / 4);
 }
+function cropResult(result, cap) {
+  const head = result.slice(0, cap);
+  const nl = head.lastIndexOf("\n");
+  const page = nl > cap * 0.5 ? head.slice(0, nl) : head;
+  const omitted = result.length - page.length;
+  return `${page}
+
+[output cropped \u2014 showing ${page.length} of ${result.length} bytes; ${omitted} omitted. This is page 1. Refine your query/command to narrow it, or call the tool again with a tighter scope to see more.]`;
+}
 function stubOldToolResults(messages, keep) {
   const meta = /* @__PURE__ */ new Map();
   for (const msg of messages)
@@ -3633,6 +3655,34 @@ To pull a specific detail, Grep/Read ${path}, or call Ask({ question: "\u2026",
   captureAll(tools) {
     return tools.map((t) => this.capture(t));
   }
+  /**
+   * Spill an oversized tool result to a scratch file and return PAGE 1 + a recoverable, paginated stub.
+   * Drop-in for `Agent.capToolResult`: the agent sees usable content immediately and knows how to get
+   * the rest (refine the query, Read the file in pages with offset/limit, or Ask to extract specifics).
+   * Lossless — unlike a plain crop, the full output stays available on the scratch FS.
+   */
+  async spill(full, info, pageBytes = 8e3) {
+    const { dir } = this.options;
+    const id = "a" + ++this.seq;
+    const path = `${dir}/${id}-${slug(info.tool)}.txt`;
+    const header = `# ${info.tool}(${shortArgs(info.args)}) \u2014 ${full.length} bytes
+`;
+    try {
+      await (this.dirReady ??= mkdirp(this.fs, dir));
+      await this.fs.writeFile(path, header + full);
+    } catch (e) {
+      log5.debug("scratch spill failed; cropping lossy", e);
+      return full.slice(0, pageBytes) + `
+
+[output cropped to ${pageBytes} of ${full.length} bytes; full output unavailable (scratch write failed) \u2014 refine your query]`;
+    }
+    const head = full.slice(0, pageBytes);
+    const nl = head.lastIndexOf("\n");
+    const page = nl > pageBytes * 0.5 ? head.slice(0, nl) : head;
+    return `${page}
+
+[output cropped \u2014 page 1 (${page.length} of ${full.length} bytes). Full output saved to ${path}. To see more: refine your query/command to narrow it, or Read ${path} with offset/limit to page through it, or Ask({ question: "\u2026", over: "${path}" }) to extract specifics.]`;
+  }
 };
 var ASK_PROMPT = "You are a retrieval-extraction step with Read, Grep and Glob over a scratch filesystem holding raw outputs from earlier tools. Find the information that answers the question and return it concisely, quoting values/facts verbatim. Do NOT add analysis or anything not grounded in the files. If the answer is not present, say so plainly.";
 function makeAskTool(o) {
@@ -3766,7 +3816,10 @@ var DuplexAgentOptions = class {
   ai;
   /** The WORKER's filesystem (act + think). If omitted the worker keeps Agent's jailed-disk-at-cwd default. */
   fs;
-  reflexModel = "groq/openai/gpt-oss-20b";
+  // The reflex IS the voice. 120b (not 20b) for channel discipline + instruction-following: the 20b
+  // mislabels gpt-oss harmony channels under load, leaking raw analysis into the spoken `final` channel
+  // (and misfiring Hold). 120b is the same price tier (~$0.15/$0.60) — the quality/cost trade is free.
+  reflexModel = "groq/openai/gpt-oss-120b";
   actModel = "anthropic/claude-sonnet-4-6";
   /** Premium reasoning model. Set to `false` to disable the Think tier entirely. */
   thinkModel = "anthropic/claude-opus-4-8";
@@ -3853,7 +3906,12 @@ var DuplexAgent = class {
     const canSearch = workerToolNames.some((n) => /WebSearch/i.test(n));
     const canFetch = workerToolNames.some((n) => /WebFetch/i.test(n));
     const workerWeb = canSearch ? `, and it CAN search the web and read web pages \u2014 so when the user gives you something specific to look up ("search for X", "find me\u2026", "what's the latest on\u2026"), route it to Act. But a bare capability QUESTION like "can you search the web?" just gets a short spoken "yes, I can" \u2014 do NOT dispatch and NEVER invent a query the user did not give you` : canFetch ? ", and it can fetch a specific web page URL (but cannot search the web)" : "";
-    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + `
+    const mcpNames = [
+      ...Object.keys(o.actOptions?.providerOptions?.mcpServers ?? {}),
+      ...new Set(workerToolNames.filter((n) => n.startsWith("mcp__")).map((n) => n.slice(5).split("__")[0]))
+    ];
+    const workerMcp = mcpNames.length ? `, and it can use these MCP servers: ${[...new Set(mcpNames)].join(", ")}` + (mcpNames.some((n) => /browser/i.test(n)) ? ' \u2014 including driving a REAL browser (open tabs, navigate, click, screenshot), so answer "yes" if asked whether you can control/drive a browser and route an actual browse to Act' : "") : "";
+    const prompt = VOICE_SYSTEM_PROMPT.replace("{{MEMORY_SLOT}}", memSlot).replace("{{THINK_SLOT}}", thinkSlot).replace("{{WORKER_WEB}}", workerWeb + workerMcp) + (o.voiceStyle === "conversational" ? "\n" + VOICE_STYLE_CONVERSATIONAL : "") + `
 Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`;
     const tools = [
       ...o.reflexOptions?.tools ?? [],
@@ -4288,8 +4346,10 @@ Another agent just implemented the above. Independently check the CURRENT state
             case "capabilities": {
               const actTools = this.options.actOptions?.tools ?? [];
               const names = actTools.map((t) => t.name);
+              const mcpServers = Object.keys(this.options.actOptions?.providerOptions?.mcpServers ?? {});
+              const mcpNote = mcpServers.length ? ` Plus MCP servers your worker can use: ${mcpServers.join(", ")} (e.g. browser-bridge \u2192 drive a real browser: open tabs, navigate, click, screenshot).` : "";
               if (!names.length)
-                return "Your worker uses Act's default local toolset (reading/editing files, running shell commands). No extra tools (e.g. web/internet) are configured; if a request is not a basic file or shell operation, assume you can't do it and say so.";
+                return "Your worker uses Act's default local toolset (reading/editing files, running shell commands). No extra tools (e.g. web/internet) are configured; if a request is not a basic file or shell operation, assume you can't do it and say so." + mcpNote;
               const hasFetch = names.some((n) => /WebFetch/i.test(n));
               const hasBrowser = names.some((n) => /browser.*(navigate|click|page|type)/i.test(n));
               const hasSearch = names.some((n) => /(^|_)WebSearch$|search/i.test(n) && !/WebFetch|browser/i.test(n));
@@ -4298,7 +4358,7 @@ Another agent just implemented the above. Independently check the CURRENT state
               if (hasBrowser) notes.push("The browser tools drive a real browser: you CAN open a site and, if needed, navigate to a search engine and search there \u2014 but it is manual and takes a moment, not an instant lookup.");
               else if (!hasSearch && hasFetch) notes.push('You have no general web-search tool, so for an instant "search the web" you can only fetch a URL they provide.');
               const webNote = notes.length ? " NOTE: " + notes.join(" ") : "";
-              return `Tools your background worker (Act) can actually use: ${names.join(", ")}. Read each name literally and match the request to a SPECIFIC tool; if none fits, you do NOT have that ability \u2014 say so honestly.` + webNote;
+              return `Tools your background worker (Act) can actually use: ${names.join(", ")}. Read each name literally and match the request to a SPECIFIC tool; if none fits, you do NOT have that ability \u2014 say so honestly.` + webNote + mcpNote;
             }
             case "time":
               return (/* @__PURE__ */ new Date()).toString();