@ycodium-ai/agent-fake 0.2.3074 → 0.2.3078

package/README.md

@@ -82,12 +82,18 @@ then that text. A whole-string placeholder preserves types; interpolation JSON-s
 non-strings. Unresolved references skip that call and reply
 `mcp-send <tool> failed: unresolved placeholder <placeholder>`, then continue.
 
+Calls, `wait` and `waitFor` accept an optional `server` alongside `tool` (for example,
+`{ "server": "ycodium-home", "tool": "work_list_items" }`); it selects the named HTTP server
+from `startSession.mcpServers`, defaults to the built-in server, and gives tool events the
+`mcp__<server>__<tool>` prefix (`mcp__ycodium__<tool>` by default). Clients are reused within
+the session and closed when it ends; events and replies use server names and redact server URLs.
+
 A `wait` polls `tools/list` on that MCP server every 250 ms for the tool name or its
-`mcp__ycodium__` prefix, defaulting to a 30000 ms timeout. It replies
+`mcp__<server>__` prefix, defaulting to a 30000 ms timeout. It replies
 `mcp-send wait <tool>: ready` or `mcp-send wait <tool> failed: timeout`, then continues, with no
 tool items. A `waitFor`, such as
 `{ "waitFor": { "tool": "message_inbox_peek", "path": "items", "atLeast": 2 } }`, calls that tool
-with no arguments every 250 ms on one session until the value at the dot `path` of its result is
+with its optional `arguments` (none by default; placeholders are not resolved there) every 250 ms on one session until the value at the dot `path` of its result is
 an array at least `atLeast` long, or a number at least `atLeast`; a tool error counts as not yet.
 Point it only at read-only tools, since every poll is a real call. It also defaults to 30000 ms,
 replies `mcp-send waitFor <tool> <path> >= <atLeast>: ready` or `… failed: timeout`, emits no tool

package/dist/index.js

@@ -469,8 +469,8 @@ async function callMcpTool(input) {
   return session.request("tools/call", { name: input.name, arguments: input.arguments });
 }
 async function openMcpSession(input) {
-  const post = async (headers, body) => {
-    input.signal?.throwIfAborted();
+  const post = async (headers, body, signal = input.signal) => {
+    signal?.throwIfAborted();
     const response = await input.fetch(input.server.transport.url, {
       method: "POST",
       headers: {
@@ -479,14 +479,18 @@ async function openMcpSession(input) {
         ...headers
       },
       body: JSON.stringify({ jsonrpc: "2.0", ...body }),
-      ...input.signal === void 0 ? {} : { signal: input.signal }
+      ...signal === void 0 ? {} : { signal }
     });
     const text = await response.text();
     if (!response.ok)
       throw new Error(
-        `MCP ${String(body.method)} failed: HTTP ${response.status} ${text.slice(0, 200)}`
+        `MCP ${String(body.method)} failed: HTTP ${response.status} ${text.replaceAll(input.server.transport.url, input.server.name).slice(0, 200)}`
       );
-    return { response, message: parseMessage(text) };
+    try {
+      return { response, message: parseMessage(text) };
+    } catch {
+      throw new Error(`MCP ${String(body.method)} failed: invalid response`);
+    }
   };
   const base = { ...input.server.transport.headers };
   const initialized = await post(base, {
@@ -504,16 +508,36 @@ async function openMcpSession(input) {
     "mcp-protocol-version": PROTOCOL_VERSION,
     ...sessionId === null ? {} : { "mcp-session-id": sessionId }
   };
-  await post(session, { method: "notifications/initialized" });
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    if (sessionId === null) return;
+    const response = await input.fetch(input.server.transport.url, {
+      method: "DELETE",
+      headers: session,
+      signal: AbortSignal.timeout(1e3)
+    });
+    await response.body?.cancel();
+  };
+  try {
+    await post(session, { method: "notifications/initialized" });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
   let nextId = 2;
   return {
-    request: async (method, params) => {
-      const called = await post(session, { id: nextId++, method, params });
+    request: async (method, params, signal) => {
+      if (closed) throw new Error("MCP session closed");
+      const called = await post(session, { id: nextId++, method, params }, signal);
       const label = method === "tools/call" ? `tools/call ${String(params.name)}` : method;
       if (called.message?.error !== void 0)
         throw new Error(`MCP ${label} failed: ${called.message.error.message ?? "error"}`);
       return called.message?.result;
-    }
+    },
+    close
   };
 }
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -571,6 +595,66 @@ function hold(ms, signal) {
   });
 }
 
+// src/playbookMcp.ts
+function redactMcpUrls(value, servers) {
+  if (typeof value === "string") {
+    let text = value;
+    for (const server of servers ?? []) {
+      if (server.transport.type !== "stdio")
+        text = text.replaceAll(server.transport.url, server.name);
+    }
+    return text;
+  }
+  if (Array.isArray(value)) return value.map((entry) => redactMcpUrls(entry, servers));
+  if (typeof value === "object" && value !== null)
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        redactMcpUrls(key, servers),
+        redactMcpUrls(entry, servers)
+      ])
+    );
+  return value;
+}
+function createPlaybookMcp(input) {
+  const sessions = /* @__PURE__ */ new Map();
+  const lifetime = new AbortController();
+  const serverFor = (name) => name === void 0 ? builtinMcpServer(input.servers) : input.servers?.find((server) => server.name === name) ?? null;
+  return {
+    missing: (name) => serverFor(name) === null ? name === void 0 ? "Error: no MCP server was handed to this session" : `no MCP server ${name}` : void 0,
+    request: async (name, method, params, signal) => {
+      const server = serverFor(name);
+      if (server === null) throw new Error("MCP server missing");
+      if (server.transport.type !== "http")
+        throw new Error(`unsupported MCP transport ${server.transport.type} for ${server.name}`);
+      const requestSignal = AbortSignal.any([lifetime.signal, signal]);
+      requestSignal.throwIfAborted();
+      let pending = sessions.get(server.name);
+      if (pending === void 0) {
+        pending = openMcpSession({
+          fetch: input.fetch,
+          server: { ...server, transport: { ...server.transport, type: "http" } },
+          signal: requestSignal
+        });
+        sessions.set(server.name, pending);
+        const opening = pending;
+        void pending.catch(() => {
+          if (sessions.get(server.name) === opening) sessions.delete(server.name);
+        });
+      }
+      const session = await pending;
+      requestSignal.throwIfAborted();
+      return session.request(method, params, requestSignal);
+    },
+    close: async () => {
+      lifetime.abort();
+      await Promise.allSettled(
+        [...sessions.values()].map(async (pending) => (await pending).close())
+      );
+      sessions.clear();
+    }
+  };
+}
+
 // src/playbook.ts
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isName = (value) => typeof value === "string" && value.length > 0;
@@ -584,25 +668,43 @@ function parseStep(value) {
   if (Object.hasOwn(value, "wait")) {
     const wait = value.wait;
     if (!onlyKeys(value, ["wait"]) || !isRecord2(wait) || !isName(wait.tool)) return null;
-    if (!onlyKeys(wait, ["tool", "timeoutMs"])) return null;
+    if (!onlyKeys(wait, ["server", "tool", "timeoutMs"]) || wait.server !== void 0 && !isName(wait.server))
+      return null;
     const timeoutMs = parseTimeout(wait.timeoutMs);
-    return timeoutMs === null ? null : { wait: { tool: wait.tool, timeoutMs } };
+    return timeoutMs === null ? null : {
+      wait: {
+        tool: wait.tool,
+        timeoutMs,
+        ...wait.server === void 0 ? {} : { server: wait.server }
+      }
+    };
   }
   if (Object.hasOwn(value, "waitFor")) {
     const wait = value.waitFor;
     if (!onlyKeys(value, ["waitFor"]) || !isRecord2(wait) || !isName(wait.tool)) return null;
-    if (!onlyKeys(wait, ["tool", "path", "atLeast", "timeoutMs"]) || !isName(wait.path))
+    if (!onlyKeys(wait, ["server", "tool", "arguments", "path", "atLeast", "timeoutMs"]) || !isName(wait.path) || wait.arguments !== void 0 && !isRecord2(wait.arguments) || wait.server !== void 0 && !isName(wait.server))
       return null;
     if (typeof wait.atLeast !== "number" || !Number.isInteger(wait.atLeast) || wait.atLeast < 0)
       return null;
     const timeoutMs = parseTimeout(wait.timeoutMs);
-    return timeoutMs === null ? null : { waitFor: { tool: wait.tool, path: wait.path, atLeast: wait.atLeast, timeoutMs } };
+    return timeoutMs === null ? null : {
+      waitFor: {
+        tool: wait.tool,
+        path: wait.path,
+        atLeast: wait.atLeast,
+        timeoutMs,
+        ...wait.server === void 0 ? {} : { server: wait.server },
+        ...wait.arguments === void 0 ? {} : { arguments: wait.arguments }
+      }
+    };
   }
-  if (!onlyKeys(value, ["id", "tool", "arguments"]) || !isName(value.tool)) return null;
+  if (!onlyKeys(value, ["id", "server", "tool", "arguments"]) || !isName(value.tool) || value.server !== void 0 && !isName(value.server))
+    return null;
   if (value.id !== void 0 && typeof value.id !== "string") return null;
   if (value.arguments !== void 0 && !isRecord2(value.arguments)) return null;
   return {
     tool: value.tool,
+    ...value.server === void 0 ? {} : { server: value.server },
     ...value.id === void 0 ? {} : { id: value.id },
     ...value.arguments === void 0 ? {} : { arguments: value.arguments }
   };
@@ -753,7 +855,6 @@ function stepResult(result) {
   }
 }
 async function poll(timeoutMs, input, ready) {
-  const server = builtinMcpServer(input.mcpServers);
   const deadline = Date.now() + timeoutMs;
   const controller = new AbortController();
   const abort = () => controller.abort();
@@ -761,20 +862,12 @@ async function poll(timeoutMs, input, ready) {
   if (input.signal.aborted) abort();
   const timer = setTimeout(abort, timeoutMs);
   try {
-    let session;
     while (!controller.signal.aborted && Date.now() < deadline) {
       try {
-        if (server !== null)
-          session ??= await openMcpSession({
-            fetch: input.fetch,
-            server,
-            signal: controller.signal
-          });
-        const done = session !== void 0 && await ready(session);
+        const done = await ready(controller.signal);
         if (controller.signal.aborted || Date.now() >= deadline) return false;
         if (done) return true;
       } catch {
-        session = void 0;
         if (controller.signal.aborted) return false;
       }
       await hold(Math.min(250, Math.max(0, deadline - Date.now())), controller.signal);
@@ -785,20 +878,25 @@ async function poll(timeoutMs, input, ready) {
     input.signal.removeEventListener("abort", abort);
   }
 }
-var waitForTool = (step, input) => poll(step.wait.timeoutMs, input, async (session) => {
-  const listed = await session.request("tools/list", {});
+var waitForTool = (step, input, clients) => poll(step.wait.timeoutMs, input, async (signal) => {
+  const listed = await clients.request(step.wait.server, "tools/list", {}, signal);
   return isRecord2(listed) && Array.isArray(listed.tools) && listed.tools.some(
-    (tool) => isRecord2(tool) && (tool.name === step.wait.tool || tool.name === `mcp__ycodium__${step.wait.tool}`)
+    (tool) => isRecord2(tool) && (tool.name === step.wait.tool || tool.name === `mcp__${step.wait.server ?? "ycodium"}__${step.wait.tool}`)
   );
 });
-var waitForCount = (step, input) => poll(step.waitFor.timeoutMs, input, async (session) => {
-  const called = await session.request("tools/call", { name: step.waitFor.tool, arguments: {} });
+var waitForCount = (step, input, clients) => poll(step.waitFor.timeoutMs, input, async (signal) => {
+  const called = await clients.request(
+    step.waitFor.server,
+    "tools/call",
+    { name: step.waitFor.tool, arguments: step.waitFor.arguments ?? {} },
+    signal
+  );
   if (isRecord2(called) && called.isError === true) return false;
   const value = valueAt(stepResult(called), step.waitFor.path.split("."));
   const count = Array.isArray(value) ? value.length : value;
   return typeof count === "number" && count >= step.waitFor.atLeast;
 });
-async function runCall(step, playback, input) {
+async function runCall(step, playback, input, clients) {
   let args = step.arguments ?? {};
   let failure;
   try {
@@ -806,22 +904,20 @@ async function runCall(step, playback, input) {
   } catch (error) {
     failure = error instanceof UnresolvedPlaceholder ? error.message : String(error);
   }
-  const toolName = `mcp__ycodium__${step.tool}`;
+  const toolName = `mcp__${step.server ?? "ycodium"}__${step.tool}`;
   const extra = { turnId: input.turnId, itemId: input.nextItemId() };
   const payload = { itemType: "mcp_tool_call", title: toolName, data: { toolName, input: args } };
   input.emit("item.started", input.threadId, { ...payload, status: "inProgress" }, extra);
   let result;
+  failure ??= clients.missing(step.server);
   if (failure === void 0) {
     try {
-      const server = builtinMcpServer(input.mcpServers);
-      if (server === null) throw new Error("no MCP server was handed to this session");
-      result = await callMcpTool({
-        fetch: input.fetch,
-        server,
-        name: step.tool,
-        arguments: args,
-        signal: input.signal
-      });
+      result = await clients.request(
+        step.server,
+        "tools/call",
+        { name: step.tool, arguments: args },
+        input.signal
+      );
     } catch (error) {
       failure = String(error);
     }
@@ -850,11 +946,22 @@ function createPlaybookRunner(input) {
   const titles = /* @__PURE__ */ new Map();
   const claimed = /* @__PURE__ */ new Set();
   const sessions = /* @__PURE__ */ new Map();
+  const clients = /* @__PURE__ */ new Map();
   let loaded;
   return {
     startSession: (session) => {
       titles.set(session.threadId, session.title);
     },
+    stopSession: async (threadId) => {
+      const opened = clients.get(threadId);
+      clients.delete(threadId);
+      await opened?.close();
+    },
+    dispose: async () => {
+      const opened = [...clients.values()];
+      clients.clear();
+      await Promise.all(opened.map((client) => client.close()));
+    },
     runTurn: async (turn) => {
       if (turn.signal.aborted) return "";
       loaded ??= NodeFSP.readFile(path, "utf8").then(
@@ -882,25 +989,46 @@ function createPlaybookRunner(input) {
       const batch = playback.line?.turns[playback.cursor];
       if (batch === void 0) return null;
       playback.cursor += 1;
+      let opened = clients.get(turn.threadId);
+      if (opened === void 0) {
+        opened = createPlaybookMcp({ fetch: turn.fetch, servers: turn.mcpServers });
+        clients.set(turn.threadId, opened);
+      }
+      const safeTurn = {
+        ...turn,
+        emit: (...args) => {
+          turn.emit(args[0], args[1], redactMcpUrls(args[2], turn.mcpServers), args[3]);
+        }
+      };
       const lines = [];
       for (const step of batch) {
         if (turn.signal.aborted) break;
         if ("wait" in step) {
-          const ready = await waitForTool(step, turn);
+          const missing = opened.missing(step.wait.server);
+          if (step.wait.server !== void 0 && missing !== void 0) {
+            lines.push(`mcp-send ${step.wait.tool} failed: ${missing}`);
+            continue;
+          }
+          const ready = await waitForTool(step, safeTurn, opened);
           if (turn.signal.aborted) break;
           lines.push(`mcp-send wait ${step.wait.tool}${ready ? ": ready" : " failed: timeout"}`);
         } else if ("waitFor" in step) {
-          const ready = await waitForCount(step, turn);
+          const missing = opened.missing(step.waitFor.server);
+          if (step.waitFor.server !== void 0 && missing !== void 0) {
+            lines.push(`mcp-send ${step.waitFor.tool} failed: ${missing}`);
+            continue;
+          }
+          const ready = await waitForCount(step, safeTurn, opened);
           if (turn.signal.aborted) break;
           const { tool, path: path2, atLeast } = step.waitFor;
           lines.push(
             `mcp-send waitFor ${tool} ${path2} >= ${String(atLeast)}${ready ? ": ready" : " failed: timeout"}`
           );
         } else {
-          lines.push(await runCall(step, playback, turn));
+          lines.push(await runCall(step, playback, safeTurn, opened));
         }
       }
-      return lines.join("\n");
+      return redactMcpUrls(lines.join("\n"), turn.mcpServers);
     }
   };
 }
@@ -1489,6 +1617,7 @@ var createFakeInstance = (config, host) => {
     stopSession: async (threadId) => {
       inflight.get(threadId)?.abort();
       threads.delete(threadId);
+      await playbook?.stopSession(threadId);
     },
     readThread: async (threadId) => {
       const booked = requireThread(threadId);
@@ -1503,6 +1632,7 @@ var createFakeInstance = (config, host) => {
       for (const settle of pendingDecisions.values()) settle("cancel");
       pendingDecisions.clear();
       threads.clear();
+      await playbook?.dispose();
       events.close();
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-fake",
-  "version": "0.2.3074",
+  "version": "0.2.3078",
   "description": "Minimal fake executor for plugin authors and host orchestration tests.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3074",
-    "ycodium-executor-testing": "0.0.0"
+    "ycodium-executor-testing": "0.0.0",
+    "@ycodium-ai/plugin-api": "0.2.3078"
   },
   "ycodium": {
     "plugin": "./dist/index.js",