@livx.cc/agentx 0.99.46 → 0.99.48

package/dist/{mcp-kgG6rtsd.d.ts → mcp-DjYZzGGW.d.ts}

@@ -1,4 +1,4 @@
-import { A as AgentTool } from './tools-BqL8Lk4J.js';
+import { A as AgentTool } from './tools-MNdqlJIa.js';
 
 /**
  * MCP bridge — adapt a Model Context Protocol tool list into the agent's AgentTool[],
@@ -14,8 +14,17 @@ interface McpToolSpec {
     /** JSON Schema for the tool's arguments (MCP's `inputSchema`). */
     inputSchema?: object;
 }
+/** Liveness + cancellation for one call: `onProgress` ⇒ the client requests MCP progress notifications. */
+interface McpCallOptions {
+    signal?: AbortSignal;
+    onProgress?: (p: {
+        progress?: number;
+        total?: number;
+        message?: string;
+    }) => void;
+}
 /** Perform an MCP tool call; return its textual result. Throw to surface an error to the model. */
-type McpCall = (name: string, args: any) => Promise<unknown>;
+type McpCall = (name: string, args: any, opts?: McpCallOptions) => Promise<unknown>;
 interface McpImage {
     mimeType: string;
     data: string;
@@ -54,7 +63,7 @@ interface MountedMcpLike {
     name: string;
     specs: McpToolSpec[];
     client: {
-        callTool(name: string, args: unknown): Promise<unknown>;
+        callTool(name: string, args: unknown, opts?: McpCallOptions): Promise<unknown>;
     };
 }
 /** A flattened catalog entry's origin: which server owns it + the un-prefixed raw tool name. */
@@ -73,7 +82,7 @@ declare function buildMcpCatalog(servers: {
     routes: Map<string, McpRoute>;
 };
 /** Resolve a routed MCP call to its result. Throw to surface an error to the model. */
-type McpRouteResolver = (server: string, rawName: string, args: any) => Promise<unknown>;
+type McpRouteResolver = (server: string, rawName: string, args: any, opts?: McpCallOptions) => Promise<unknown>;
 /**
  * Ergonomic deferred-mount over already-mounted MCP servers: flattens their specs into one
  * `mcp__<server>__<tool>` namespace and wires a single `ToolSearch`/`McpCall` pair that routes

package/dist/mcp.client.d.ts

@@ -1,11 +1,27 @@
-import { e as McpToolSearchOptions, f as McpToolSpec } from './mcp-kgG6rtsd.js';
-import { A as AgentTool } from './tools-BqL8Lk4J.js';
+import { e as McpToolSearchOptions, f as McpToolSpec } from './mcp-DjYZzGGW.js';
+import { A as AgentTool } from './tools-MNdqlJIa.js';
 import '@livx.cc/wcli/core';
 
+/** Hard cap for `tools/call`. NOT the 30s protocol timeout: a tool call is real work (an image render, a crawl)
+ *  that legitimately runs for minutes — the harness hands it to a job past its soft timeout and judges it by
+ *  progress/idle liveness (src/tools.jobs.ts). This only bounds a call nothing else ever stops. */
+declare const DEFAULT_CALL_TIMEOUT_MS: number;
+/** An MCP `notifications/progress` payload. */
+interface McpProgress {
+    progress?: number;
+    total?: number;
+    message?: string;
+}
+/** Per-request options: cancellation, progress (sends a `_meta.progressToken`), and a deadline override. */
+interface McpRequestOptions {
+    signal?: AbortSignal;
+    onProgress?: (p: McpProgress) => void;
+    timeoutMs?: number;
+}
 /** A JSON-RPC 2.0 transport: request (awaits a result), notify (fire-and-forget), close. */
 interface McpTransport {
     start(): Promise<void>;
-    request(method: string, params?: unknown): Promise<any>;
+    request(method: string, params?: unknown, opts?: McpRequestOptions): Promise<any>;
     notify(method: string, params?: unknown): Promise<void>;
     close(): Promise<void>;
 }
@@ -14,7 +30,10 @@ interface StdioServerSpec {
     args?: string[];
     env?: Record<string, string>;
     cwd?: string;
+    /** Protocol request deadline (initialize, tools/list, …). Default 30s. */
     timeoutMs?: number;
+    /** `tools/call` hard cap. Default max(30 min, timeoutMs). */
+    callTimeoutMs?: number;
 }
 declare class StdioTransport implements McpTransport {
     private spec;
@@ -28,7 +47,7 @@ declare class StdioTransport implements McpTransport {
     private dispatch;
     private failAll;
     private write;
-    request(method: string, params?: unknown): Promise<any>;
+    request(method: string, params?: unknown, opts?: McpRequestOptions): Promise<any>;
     notify(method: string, params?: unknown): Promise<void>;
     close(): Promise<void>;
 }
@@ -38,7 +57,10 @@ interface HttpServerSpec {
     /** Sugar over `headers` → `Authorization: Bearer <token>`. The headless-friendly path (no OAuth loopback);
      *  inject a static token (from env / VFS secret) per our CLAUDE.md rule preferring API keys for cron/edge. */
     bearerToken?: string;
+    /** Protocol request deadline (initialize, tools/list, …). Default 30s. */
     timeoutMs?: number;
+    /** `tools/call` hard cap. Default max(30 min, timeoutMs). */
+    callTimeoutMs?: number;
 }
 /** Thrown when an HTTP MCP server rejects auth (401/403). Carries `needsAuth` so callers can surface a hint
  *  ("set bearerToken / headers") instead of a generic mount failure — without attempting an interactive flow. */
@@ -55,7 +77,7 @@ declare class HttpTransport implements McpTransport {
     private fetchImpl;
     constructor(spec: HttpServerSpec, fetchImpl?: typeof fetch);
     start(): Promise<void>;
-    request(method: string, params?: unknown): Promise<any>;
+    request(method: string, params?: unknown, opts?: McpRequestOptions): Promise<any>;
     notify(method: string, params?: unknown): Promise<void>;
     private post;
     close(): Promise<void>;
@@ -76,7 +98,8 @@ declare class McpClient {
         capabilities?: any;
     }>;
     listTools(): Promise<McpToolSpec[]>;
-    callTool(name: string, args: unknown): Promise<unknown>;
+    /** `tools/call`. Pass `onProgress` to request progress notifications (liveness) and `signal` to cancel. */
+    callTool(name: string, args: unknown, opts?: McpRequestOptions): Promise<unknown>;
     listResources(): Promise<Array<{
         uri: string;
         name?: string;
@@ -98,7 +121,10 @@ interface McpServerConfig {
     /** Auth strategy for http servers. `'oauth'` → the CLI resolves a token via the attended OAuth flow
      *  (cli/mcpOAuth.ts) and injects it as `bearerToken` at mount; the core never runs the flow. Default none. */
     auth?: 'oauth' | 'none';
+    /** Protocol request deadline (initialize, tools/list, …). Default 30s. */
     timeoutMs?: number;
+    /** `tools/call` hard cap (the call is handed to a job long before; this bounds what nothing else stops). Default 30 min. */
+    callTimeoutMs?: number;
     disabled?: boolean;
 }
 interface MountedMcp {
@@ -225,4 +251,4 @@ declare function warmMcpCatalog(servers?: Record<string, McpServerConfig>, opts?
     toolCount: number;
 }>;
 
-export { type HttpServerSpec, HttpTransport, McpAuthError, type McpCatalogOptions, type McpCatalogStore, McpClient, McpPool, type McpServerConfig, type McpTransport, MemMcpCatalog, type MountedMcp, type StdioServerSpec, StdioTransport, mcpConfigKey, mountMcpCatalog, mountMcpDeferred, mountMcpServer, mountMcpServers, warmMcpCatalog };
+export { DEFAULT_CALL_TIMEOUT_MS, type HttpServerSpec, HttpTransport, McpAuthError, type McpCatalogOptions, type McpCatalogStore, McpClient, McpPool, type McpProgress, type McpRequestOptions, type McpServerConfig, type McpTransport, MemMcpCatalog, type MountedMcp, type StdioServerSpec, StdioTransport, mcpConfigKey, mountMcpCatalog, mountMcpDeferred, mountMcpServer, mountMcpServers, warmMcpCatalog };

package/dist/mcp.client.js

@@ -106,17 +106,42 @@ async function withDeadline(p, ms) {
   }
 }
 var mcpTimedOut = (name, ms = MCP_CALL_TIMEOUT_MS) => `[${name}] no response after ${ms / 1e3}s \u2014 the MCP server never answered. The call's outcome is UNKNOWN: do not assume it ran or that it failed. Verify the state (or pick a bounded/narrower call) before retrying.`;
+async function runMcpCall(name, call, ctx, timeoutMs) {
+  const jobs = ctx?.toolJobs;
+  const shape = (raw) => {
+    const r2 = toResult(raw);
+    return r2.images?.length ? r2 : r2.text;
+  };
+  if (!jobs) {
+    const raw = await withDeadline(call({}), timeoutMs);
+    return raw === TIMED_OUT ? mcpTimedOut(name, timeoutMs) : shape(raw);
+  }
+  const r = await jobs.runForeground(async ({ signal, touch, onChunk }) => {
+    const raw = await call({
+      signal,
+      onProgress: (p) => {
+        touch();
+        if (p?.message) onChunk(`[progress${p.progress != null ? ` ${p.progress}${p.total != null ? `/${p.total}` : ""}` : ""}] ${p.message}
+`);
+      }
+    });
+    const res = toResult(raw);
+    onChunk(res.text + (res.images?.length ? `
+[${res.images.length} image(s) in the result]` : ""));
+    return res;
+  }, { kind: "mcp", label: name, idleAfterActivity: true });
+  if (r.done) return r.value.images?.length ? r.value : r.value.text;
+  const soft = jobs.options.foregroundMs.mcp ?? 0;
+  return `[still running] MCP call ${name} is still working after ${soft >= 1e3 ? `${Math.round(soft / 1e3)}s` : `${soft}ms`}, so it was handed to background job ${r.id} \u2014 NOT cancelled, the server keeps going. Its result will be delivered to you when it finishes, so continue with other work; to block on it use JobWait({id:"${r.id}"}) instead of sleeping. JobStatus/JobOutput show its progress; JobKill({id:"${r.id}"}) cancels it. Do NOT re-issue the same call \u2014 that would run it twice.`;
+}
 function mcpToolToAgentTool(spec, callTool, prefix = "mcp__", timeoutMs = MCP_CALL_TIMEOUT_MS) {
   return {
     name: `${prefix}${spec.name}`,
     description: spec.description ?? `MCP tool ${spec.name}`,
     parameters: spec.inputSchema ?? { type: "object", properties: {} },
     maxDurationMs: timeoutMs,
-    async run(args, _ctx) {
-      const raw = await withDeadline(callTool(spec.name, args ?? {}), timeoutMs);
-      if (raw === TIMED_OUT) return mcpTimedOut(spec.name, timeoutMs);
-      const r = toResult(raw);
-      return r.images?.length ? r : r.text;
+    run(args, ctx) {
+      return runMcpCall(spec.name, (o) => callTool(spec.name, args ?? {}, o), ctx, timeoutMs);
     }
   };
 }
@@ -157,13 +182,10 @@ function makeMcpToolSearch(specs, callTool, options = {}) {
       }
     },
     maxDurationMs: callTimeoutMs,
-    async run({ name, args }) {
+    async run({ name, args }, ctx) {
       const n = String(name ?? "");
       if (!byName.has(n)) return `Error: unknown MCP tool '${n}'. Use ToolSearch to find valid names.`;
-      const raw = await withDeadline(callTool(n, args ?? {}), callTimeoutMs);
-      if (raw === TIMED_OUT) return mcpTimedOut(n, callTimeoutMs);
-      const r = toResult(raw);
-      return r.images?.length ? r : r.text;
+      return runMcpCall(n, (o) => callTool(n, args ?? {}, o), ctx, callTimeoutMs);
     }
   };
   return [searchTool, callMcpTool];
@@ -183,17 +205,17 @@ function buildMcpCatalog(servers) {
   return { specs, routes };
 }
 function searchOverCatalog(servers, specs, routes, resolve, options) {
-  const tools = specs.length ? makeMcpToolSearch(specs, (name, args) => {
+  const tools = specs.length ? makeMcpToolSearch(specs, (name, args, o) => {
     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 ?? {});
+    return resolve(r.server, r.rawName, args ?? {}, o);
   }, options) : [];
   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);
+  return searchOverCatalog(mounted.map((m) => m.name), specs, routes, (server, rawName, args, o) => byName.get(server).client.callTool(rawName, args, o), options);
 }
 function makeLazyMcpToolSearch(servers, resolve, options) {
   const { specs, routes } = buildMcpCatalog(servers);
@@ -204,6 +226,17 @@ function makeLazyMcpToolSearch(servers, resolve, options) {
 var log2 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_CALL_TIMEOUT_MS = 30 * 6e4;
+function deadlineFor(method, spec, opts) {
+  if (opts?.timeoutMs != null) return opts.timeoutMs;
+  if (method === "tools/call") return spec.callTimeoutMs ?? Math.max(DEFAULT_CALL_TIMEOUT_MS, spec.timeoutMs ?? 0);
+  return spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+}
+function withProgressToken(params, token) {
+  const p = params && typeof params === "object" ? params : {};
+  return { ...p, _meta: { ...p._meta ?? {}, progressToken: token } };
+}
+var abortError = (signal) => signal.reason instanceof Error ? signal.reason : Object.assign(new Error("MCP request cancelled"), { name: "AbortError" });
 var StdioTransport = class {
   constructor(spec) {
     this.spec = spec;
@@ -239,16 +272,27 @@ var StdioTransport = class {
     }
   }
   dispatch(msg) {
+    if (msg?.method === "notifications/progress") {
+      const p2 = this.pending.get(msg.params?.progressToken);
+      try {
+        p2?.onProgress?.(msg.params ?? {});
+      } catch (e) {
+        log2.debug("onProgress handler threw", e);
+      }
+      return;
+    }
     if (msg?.id == null || !this.pending.has(msg.id)) return;
     const p = this.pending.get(msg.id);
     this.pending.delete(msg.id);
     clearTimeout(p.timer);
+    p.done?.();
     if (msg.error) p.reject(new Error(msg.error?.message ?? JSON.stringify(msg.error)));
     else p.resolve(msg.result);
   }
   failAll(e) {
     for (const p of this.pending.values()) {
       clearTimeout(p.timer);
+      p.done?.();
       p.reject(e);
     }
     this.pending.clear();
@@ -257,19 +301,31 @@ var StdioTransport = class {
     if (!this.proc?.stdin) throw new Error("MCP stdio transport not started");
     this.proc.stdin.write(JSON.stringify(msg) + "\n");
   }
-  request(method, params) {
+  request(method, params, opts = {}) {
     const id = this.nextId++;
-    const timeoutMs = this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = deadlineFor(method, this.spec, opts);
+    const { signal, onProgress } = opts;
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
+      if (signal?.aborted) return reject(abortError(signal));
+      const timer = timeoutMs > 0 ? setTimeout(() => {
         this.pending.delete(id);
+        done();
         reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
+      }, timeoutMs) : void 0;
+      const onAbort = () => {
+        if (!this.pending.delete(id)) return;
+        clearTimeout(timer);
+        this.notify("notifications/cancelled", { requestId: id, reason: String(signal?.reason?.message ?? "cancelled") }).catch((e) => log2.debug("cancel notify failed", e));
+        reject(abortError(signal));
+      };
+      const done = () => signal?.removeEventListener("abort", onAbort);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.pending.set(id, { resolve, reject, timer, onProgress, done });
       try {
-        this.write({ jsonrpc: "2.0", id, method, params });
+        this.write({ jsonrpc: "2.0", id, method, params: onProgress ? withProgressToken(params, id) : params });
       } catch (e) {
         clearTimeout(timer);
+        done();
         this.pending.delete(id);
         reject(e);
       }
@@ -310,13 +366,24 @@ var HttpTransport = class {
   fetchImpl;
   async start() {
   }
-  request(method, params) {
-    return this.post({ jsonrpc: "2.0", id: this.nextId++, method, params }, false);
+  async request(method, params, opts = {}) {
+    const id = this.nextId++;
+    const deadline = AbortSignal.timeout(deadlineFor(method, this.spec, opts));
+    const signal = opts.signal ? AbortSignal.any([opts.signal, deadline]) : deadline;
+    try {
+      return await this.post({ jsonrpc: "2.0", id, method, params: opts.onProgress ? withProgressToken(params, id) : params }, false, signal, opts.onProgress);
+    } catch (e) {
+      if (opts.signal?.aborted) {
+        void this.notify("notifications/cancelled", { requestId: id, reason: String(opts.signal.reason?.message ?? "cancelled") }).catch((err) => log2.debug("cancel notify failed", err));
+        throw abortError(opts.signal);
+      }
+      throw e;
+    }
   }
   async notify(method, params) {
-    await this.post({ jsonrpc: "2.0", method, params }, true);
+    await this.post({ jsonrpc: "2.0", method, params }, true, AbortSignal.timeout(this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS));
   }
-  async post(msg, isNotify) {
+  async post(msg, isNotify, signal, onProgress) {
     const headers = {
       "content-type": "application/json",
       accept: "application/json, text/event-stream",
@@ -329,7 +396,7 @@ var HttpTransport = class {
       method: "POST",
       headers,
       body: JSON.stringify(msg),
-      signal: AbortSignal.timeout(this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+      signal
     });
     const sid = resp.headers.get("mcp-session-id");
     if (sid) this.sessionId = sid;
@@ -337,25 +404,63 @@ var HttpTransport = class {
     if (!resp.ok) throw new Error(`MCP HTTP ${resp.status} ${resp.statusText}`);
     if (isNotify) return;
     const ct = resp.headers.get("content-type") ?? "";
-    const data = ct.includes("text/event-stream") ? parseSseResponse(await resp.text()) : await resp.json();
+    const data = ct.includes("text/event-stream") ? await readSseResponse(resp, msg.id, onProgress) : await resp.json();
     if (data?.error) throw new Error(data.error?.message ?? JSON.stringify(data.error));
     return data?.result;
   }
   async close() {
   }
 };
-function parseSseResponse(body) {
-  for (const line of body.split("\n")) {
-    const trimmed = line.trimStart();
-    if (!trimmed.startsWith("data:")) continue;
-    try {
-      const obj = JSON.parse(trimmed.slice(5).trim());
-      if (obj && (obj.result !== void 0 || obj.error !== void 0)) return obj;
-    } catch (e) {
-      log2.debug("skipping unparseable SSE data line", e);
+function sseMessage(line) {
+  const trimmed = line.trimStart();
+  if (!trimmed.startsWith("data:")) return void 0;
+  try {
+    return JSON.parse(trimmed.slice(5).trim());
+  } catch (e) {
+    log2.debug("skipping unparseable SSE data line", e);
+    return void 0;
+  }
+}
+async function readSseResponse(resp, id, onProgress) {
+  const handle = (obj) => {
+    if (obj?.method === "notifications/progress") {
+      try {
+        onProgress?.(obj.params ?? {});
+      } catch (e) {
+        log2.debug("onProgress handler threw", e);
+      }
+      return void 0;
     }
+    if (obj && (obj.result !== void 0 || obj.error !== void 0) && (obj.id == null || id == null || obj.id === id)) return obj;
+    return void 0;
+  };
+  const reader = resp.body?.getReader?.();
+  if (!reader) {
+    for (const l of (await resp.text()).split("\n")) {
+      const r = handle(sseMessage(l));
+      if (r) return r;
+    }
+    return {};
+  }
+  const dec = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      buf += done ? dec.decode() : dec.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0 || done && buf) {
+        const line = nl >= 0 ? buf.slice(0, nl) : buf;
+        buf = nl >= 0 ? buf.slice(nl + 1) : "";
+        const r = handle(sseMessage(line));
+        if (r) return r;
+      }
+      if (done) return {};
+    }
+  } finally {
+    reader.cancel().catch(() => {
+    });
   }
-  return {};
 }
 var McpClient = class {
   constructor(transport, clientInfo = { name: "agentx", version: "0" }) {
@@ -379,8 +484,9 @@ var McpClient = class {
     const r = await this.transport.request("tools/list");
     return Array.isArray(r?.tools) ? r.tools : [];
   }
-  async callTool(name, args) {
-    return this.transport.request("tools/call", { name, arguments: args ?? {} });
+  /** `tools/call`. Pass `onProgress` to request progress notifications (liveness) and `signal` to cancel. */
+  async callTool(name, args, opts) {
+    return this.transport.request("tools/call", { name, arguments: args ?? {} }, opts);
   }
   async listResources() {
     const r = await this.transport.request("resources/list");
@@ -394,7 +500,7 @@ var McpClient = class {
   }
 };
 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 });
+  return cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs, callTimeoutMs: cfg.callTimeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs, callTimeoutMs: cfg.callTimeoutMs });
 }
 function withTimeout(p, ms, label) {
   if (!ms || ms <= 0) return p;
@@ -416,7 +522,7 @@ async function mountWithDeadline(name, cfg, mountTimeoutMs) {
     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}__`);
+      const tools = mcpToolsToAgentTools(specs, (tool, a, o) => client.callTool(tool, a, o), `mcp__${name}__`);
       return { name, client, tools, specs, serverInfo: init?.serverInfo, config: cfg };
     })(), mountTimeoutMs, name);
   } catch (e) {
@@ -599,7 +705,7 @@ async function mountMcpCatalog(servers = {}, opts = {}) {
   };
   const search = makeLazyMcpToolSearch(
     discovered.map((d) => ({ name: d.name, specs: d.specs })),
-    async (server, rawName, args) => (await connect(server)).callTool(rawName, args),
+    async (server, rawName, args, o) => (await connect(server)).callTool(rawName, args, o),
     opts
   );
   const close = async () => {
@@ -621,6 +727,7 @@ async function warmMcpCatalog(servers = {}, opts = {}) {
   };
 }
 export {
+  DEFAULT_CALL_TIMEOUT_MS,
   HttpTransport,
   McpAuthError,
   McpClient,