@livx.cc/agentx 0.94.38

package/dist/mcp.client.js

@@ -0,0 +1,617 @@
+// src/mcp.client.ts
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+
+// src/logging.ts
+import { log } from "libx.js/src/modules/log";
+var forComponent = (name) => log.forComponent(name);
+
+// src/relevance.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "into",
+  "your",
+  "you",
+  "are",
+  "was",
+  "will",
+  "use",
+  "using",
+  "run",
+  "add",
+  "fix",
+  "make",
+  "file",
+  "files",
+  "code",
+  "please",
+  "need",
+  "want",
+  "should",
+  "all"
+]);
+function tokenize(s) {
+  const out = /* @__PURE__ */ new Set();
+  for (const w of String(s ?? "").toLowerCase().match(/[a-z0-9]+/g) ?? []) {
+    if (w.length >= 3 && !STOP.has(w)) out.add(w);
+  }
+  return out;
+}
+function idfWeights(corpus) {
+  const N = corpus.length;
+  if (N === 0) return /* @__PURE__ */ new Map();
+  const df = /* @__PURE__ */ new Map();
+  for (const doc of corpus) for (const t of tokenize(doc)) df.set(t, (df.get(t) ?? 0) + 1);
+  const idf = /* @__PURE__ */ new Map();
+  for (const [t, n] of df) idf.set(t, Math.log((N + 1) / (n + 1)) + 1);
+  return idf;
+}
+function relevanceScore(text, queryTokens, idf) {
+  if (queryTokens.size === 0) return 0;
+  const t = tokenize(text);
+  let score = 0;
+  for (const q of queryTokens) if (t.has(q)) score += idf?.get(q) ?? 1;
+  return score;
+}
+function topByRelevance(items, query, text, k, corpus) {
+  if (!Number.isInteger(k) || k < 1) return { kept: items, rest: [] };
+  if (items.length <= k || !query.trim()) return { kept: items, rest: [] };
+  const q = tokenize(query);
+  if (q.size === 0) return { kept: items.slice(0, k), rest: items.slice(k) };
+  const idf = corpus?.length ? idfWeights(corpus) : void 0;
+  const scored = items.map((x, i) => ({ i, s: relevanceScore(text(x), q, idf) }));
+  scored.sort((a, b) => b.s - a.s || a.i - b.i);
+  const keep = new Set(scored.slice(0, k).map((e) => e.i));
+  return { kept: items.filter((_, i) => keep.has(i)), rest: items.filter((_, i) => !keep.has(i)) };
+}
+
+// src/mcp.ts
+function toResult(result) {
+  if (result == null) return { text: "" };
+  if (typeof result === "string") return { text: result };
+  const content = result.content;
+  if (Array.isArray(content)) {
+    const texts = [];
+    const images = [];
+    for (const c of content) {
+      if (c?.type === "image" && typeof c.data === "string" && c.mimeType) {
+        images.push({ mimeType: c.mimeType, data: c.data });
+      } else if (typeof c?.text === "string") {
+        texts.push(c.text);
+      } else {
+        texts.push(JSON.stringify(c));
+      }
+    }
+    const text = texts.join("\n");
+    if (text || images.length) return { text, ...images.length ? { images } : {} };
+  }
+  return { text: JSON.stringify(result) };
+}
+function mcpToolToAgentTool(spec, callTool, prefix = "mcp__") {
+  return {
+    name: `${prefix}${spec.name}`,
+    description: spec.description ?? `MCP tool ${spec.name}`,
+    parameters: spec.inputSchema ?? { type: "object", properties: {} },
+    async run(args, _ctx) {
+      const r = toResult(await callTool(spec.name, args ?? {}));
+      return r.images?.length ? r : r.text;
+    }
+  };
+}
+function mcpToolsToAgentTools(specs, callTool, prefix = "mcp__", filter) {
+  return (filter ? specs.filter(filter) : specs).map((s) => mcpToolToAgentTool(s, callTool, prefix));
+}
+function describeSpec(s) {
+  const schema = s.inputSchema ? `
+   args: ${JSON.stringify(s.inputSchema)}` : "";
+  return `${s.name} \u2014 ${s.description ?? "(no description)"}${schema}`;
+}
+function makeMcpToolSearch(specs, callTool, options = {}) {
+  const maxResults = options.maxResults ?? 10;
+  const byName = new Map(specs.map((s) => [s.name, s]));
+  const catalogLine = `${specs.length} MCP tool(s) available \u2014 search by keyword, then call by exact name.`;
+  const searchTool = {
+    name: "ToolSearch",
+    description: `Search the available MCP tools by keyword (${catalogLine}). Returns matching tool names + their argument schemas; call one with \`McpCall\`.`,
+    parameters: { type: "object", required: ["query"], properties: { query: { type: "string", description: "keywords to match against tool name + description" } } },
+    async run({ query }) {
+      const q = String(query ?? "").trim();
+      if (!q) return catalogLine;
+      const { kept } = topByRelevance(specs, q, (s) => `${s.name} ${s.description ?? ""}`, maxResults);
+      if (!kept.length) return `(no MCP tool matches "${q}" \u2014 try broader keywords)`;
+      return kept.map(describeSpec).join("\n");
+    }
+  };
+  const callMcpTool = {
+    name: "McpCall",
+    description: "Call an MCP tool discovered via `ToolSearch`, by its exact name. Pass its arguments as `args`.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "exact tool name from ToolSearch" },
+        args: { type: "object", description: "arguments object for the tool (per its schema)" }
+      }
+    },
+    async run({ name, args }) {
+      const n = String(name ?? "");
+      if (!byName.has(n)) return `Error: unknown MCP tool '${n}'. Use ToolSearch to find valid names.`;
+      const r = toResult(await callTool(n, args ?? {}));
+      return r.images?.length ? r : r.text;
+    }
+  };
+  return [searchTool, callMcpTool];
+}
+function buildMcpCatalog(servers) {
+  const specs = [];
+  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; routes.has(display); i++) display = `${base.slice(0, 128 - String(i).length - 1)}_${i}`;
+      specs.push({ name: display, description: s.description, inputSchema: s.inputSchema });
+      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 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: 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/mcp.client.ts
+var log2 = forComponent("mcp");
+var PROTOCOL_VERSION = "2025-06-18";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var StdioTransport = class {
+  constructor(spec) {
+    this.spec = spec;
+  }
+  spec;
+  proc;
+  buf = "";
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  async start() {
+    const { command, args = [], env, cwd } = this.spec;
+    const proc = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...env }, cwd });
+    this.proc = proc;
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => this.onData(chunk));
+    proc.stderr.setEncoding("utf8");
+    proc.stderr.on("data", (chunk) => log2.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.on("exit", (code) => this.failAll(new Error(`MCP server "${command}" exited (code ${code})`)));
+    proc.on("error", (e) => this.failAll(e instanceof Error ? e : new Error(String(e))));
+  }
+  onData(chunk) {
+    this.buf += chunk;
+    let nl;
+    while ((nl = this.buf.indexOf("\n")) >= 0) {
+      const line = this.buf.slice(0, nl).trim();
+      this.buf = this.buf.slice(nl + 1);
+      if (!line) continue;
+      try {
+        this.dispatch(JSON.parse(line));
+      } catch (e) {
+        log2.debug("dropping non-JSON line from MCP server:", line, e);
+      }
+    }
+  }
+  dispatch(msg) {
+    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);
+    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.reject(e);
+    }
+    this.pending.clear();
+  }
+  write(msg) {
+    if (!this.proc?.stdin) throw new Error("MCP stdio transport not started");
+    this.proc.stdin.write(JSON.stringify(msg) + "\n");
+  }
+  request(method, params) {
+    const id = this.nextId++;
+    const timeoutMs = this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.write({ jsonrpc: "2.0", id, method, params });
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+  async notify(method, params) {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  async close() {
+    this.failAll(new Error("MCP transport closed"));
+    try {
+      this.proc?.stdin?.end();
+    } catch (e) {
+      log2.debug("stdin end failed", e);
+    }
+    this.proc?.kill();
+  }
+};
+var McpAuthError = class extends Error {
+  constructor(status, serverName) {
+    super(`MCP server${serverName ? ` "${serverName}"` : ""} requires authentication (HTTP ${status}) \u2014 set bearerToken or headers`);
+    this.status = status;
+    this.serverName = serverName;
+    this.name = "McpAuthError";
+  }
+  status;
+  serverName;
+  needsAuth = true;
+};
+var HttpTransport = class {
+  constructor(spec, fetchImpl) {
+    this.spec = spec;
+    this.fetchImpl = fetchImpl ?? fetch;
+  }
+  spec;
+  nextId = 1;
+  sessionId;
+  fetchImpl;
+  async start() {
+  }
+  request(method, params) {
+    return this.post({ jsonrpc: "2.0", id: this.nextId++, method, params }, false);
+  }
+  async notify(method, params) {
+    await this.post({ jsonrpc: "2.0", method, params }, true);
+  }
+  async post(msg, isNotify) {
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+      ...this.spec.bearerToken ? { authorization: `Bearer ${this.spec.bearerToken}` } : {},
+      ...this.spec.headers,
+      // explicit headers win — lets a caller override the bearer sugar if needed
+      ...this.sessionId ? { "mcp-session-id": this.sessionId } : {}
+    };
+    const resp = await this.fetchImpl(this.spec.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(msg),
+      signal: AbortSignal.timeout(this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+    const sid = resp.headers.get("mcp-session-id");
+    if (sid) this.sessionId = sid;
+    if (resp.status === 401 || resp.status === 403) throw new McpAuthError(resp.status);
+    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();
+    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);
+    }
+  }
+  return {};
+}
+var McpClient = class {
+  constructor(transport, clientInfo = { name: "agentx", version: "0" }) {
+    this.transport = transport;
+    this.clientInfo = clientInfo;
+  }
+  transport;
+  clientInfo;
+  /** `initialize` handshake → `notifications/initialized`. Returns the server's init result. */
+  async connect() {
+    await this.transport.start();
+    const result = await this.transport.request("initialize", {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: this.clientInfo
+    });
+    await this.transport.notify("notifications/initialized");
+    return result ?? {};
+  }
+  async listTools() {
+    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 ?? {} });
+  }
+  async listResources() {
+    const r = await this.transport.request("resources/list");
+    return Array.isArray(r?.resources) ? r.resources : [];
+  }
+  async readResource(uri) {
+    return this.transport.request("resources/read", { uri });
+  }
+  async close() {
+    await this.transport.close();
+  }
+};
+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((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`MCP "${label}" mount exceeded ${ms}ms`)), ms);
+    timer.unref?.();
+    p.then((v) => {
+      clearTimeout(timer);
+      resolve(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, config: cfg };
+    })(), mountTimeoutMs, name);
+  } catch (e) {
+    await client.close().catch((err) => log2.debug(`close after failed mount of "${name}": ${err}`));
+    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) {
+      log2.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      return false;
+    }
+    return true;
+  });
+}
+function logMountFailure(name, e) {
+  if (e instanceof McpAuthError) log2.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log2.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);
+      log2.debug(`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;
+}
+async function mountMcpDeferred(servers = {}, options) {
+  const mounted = await mountMcpServers(servers, { mountTimeoutMs: options?.mountTimeoutMs });
+  return { ...makeMcpToolSearchFromMounted(mounted, options), mounted };
+}
+function mcpConfigKey(cfg) {
+  const parts = cfg.url ? ["http", cfg.url, ...Object.keys(cfg.headers ?? {}).sort()] : ["stdio", cfg.command ?? "", ...cfg.args ?? [], cfg.cwd ?? "", ...Object.keys(cfg.env ?? {}).sort()];
+  return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+}
+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((err) => log2.debug(`warm-pool replace close failed: ${err}`));
+    }
+    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((err) => log2.debug(`warm-pool evict close failed: ${err}`));
+  }
+  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();
+var defaultFailures = /* @__PURE__ */ new Map();
+var bgInflight = /* @__PURE__ */ new Set();
+var DEFAULT_FAILURE_COOLDOWN_MS = 6e4;
+async function connectAndList(name, cfg, key, opts) {
+  const catalog = opts.catalog ?? defaultCatalog;
+  const pool = opts.pool ?? defaultPool;
+  const failures = opts.failures ?? defaultFailures;
+  const client = new McpClient(buildTransport(cfg));
+  try {
+    const specs = await withTimeout((async () => {
+      await client.connect();
+      return client.listTools();
+    })(), opts.mountTimeoutMs, name);
+    catalog.set(key, specs);
+    failures.delete(key);
+    if (opts.keepWarm && !cfg.url) pool.put(key, client);
+    else await client.close().catch(() => {
+    });
+    return { name, cfg, key, specs };
+  } catch (e) {
+    await client.close().catch(() => {
+    });
+    failures.set(key, Date.now() + (opts.failureCooldownMs ?? DEFAULT_FAILURE_COOLDOWN_MS));
+    logMountFailure(name, e);
+    return null;
+  }
+}
+async function discoverOne(name, cfg, opts) {
+  const catalog = opts.catalog ?? defaultCatalog;
+  const failures = opts.failures ?? defaultFailures;
+  const key = mcpConfigKey(cfg);
+  const cached = catalog.get(key);
+  if (cached) return { name, cfg, key, specs: cached };
+  const until = failures.get(key);
+  if (until && until > Date.now()) return null;
+  if (opts.discover === "cache-only") {
+    if (!bgInflight.has(key)) {
+      bgInflight.add(key);
+      void connectAndList(name, cfg, key, opts).finally(() => bgInflight.delete(key));
+    }
+    return null;
+  }
+  return connectAndList(name, cfg, key, opts);
+}
+async function mountMcpCatalog(servers = {}, opts = {}) {
+  const pool = opts.pool ?? defaultPool;
+  const discovered = (await Promise.all(validEntries(servers).map(([name, cfg]) => discoverOne(name, cfg, opts)))).filter(Boolean);
+  const byName = new Map(discovered.map((d) => [d.name, d]));
+  const inflight = /* @__PURE__ */ new Map();
+  const live = [];
+  const connect = (name) => {
+    let p = inflight.get(name);
+    if (p) return p;
+    p = (async () => {
+      const d = byName.get(name);
+      if (!d) throw new Error(`MCP server '${name}' is not in the catalog`);
+      const warmable = opts.keepWarm && !d.cfg.url;
+      if (warmable) {
+        const w = pool.get(d.key);
+        if (w) return w;
+      }
+      const client = new McpClient(buildTransport(d.cfg));
+      await client.connect();
+      if (warmable) pool.put(d.key, client);
+      else live.push(client);
+      return client;
+    })();
+    inflight.set(name, p);
+    return p;
+  };
+  const search = makeLazyMcpToolSearch(
+    discovered.map((d) => ({ name: d.name, specs: d.specs })),
+    async (server, rawName, args) => (await connect(server)).callTool(rawName, args),
+    opts
+  );
+  const close = async () => {
+    for (const c of live) await c.close().catch(() => {
+    });
+    live.length = 0;
+    inflight.clear();
+  };
+  return { ...search, connect, close };
+}
+async function warmMcpCatalog(servers = {}, opts = {}) {
+  const entries = validEntries(servers);
+  const discovered = (await Promise.all(entries.map(([name, cfg]) => discoverOne(name, cfg, { ...opts, discover: "connect" })))).filter(Boolean);
+  const warmedNames = new Set(discovered.map((d) => d.name));
+  return {
+    warmed: discovered.map((d) => d.name),
+    failed: entries.map(([n]) => n).filter((n) => !warmedNames.has(n)),
+    toolCount: discovered.reduce((s, d) => s + d.specs.length, 0)
+  };
+}
+export {
+  HttpTransport,
+  McpAuthError,
+  McpClient,
+  McpPool,
+  MemMcpCatalog,
+  StdioTransport,
+  mcpConfigKey,
+  mountMcpCatalog,
+  mountMcpDeferred,
+  mountMcpServer,
+  mountMcpServers,
+  warmMcpCatalog
+};
+//# sourceMappingURL=mcp.client.js.map