@ycodium-ai/agent-fake 0.2.3034 → 0.2.3054

package/README.md

@@ -4,7 +4,7 @@ A minimal executor plugin. It starts no CLI and replays a fixed event script:
 
 - `startSession` emits `session.started`
 - `sendTurn` emits `turn.started`, one `content.delta`, then `turn.completed` (the host binds the turn by `turn.started`)
-- `config.script` picks the script: `plain` (default), `approval-tool` (two approvals before the reply), `async-question` (on a thread's first turn, the reply plus one non-blocking `user-input.requested` with `responseMode: "message"`), `stream` (a Markdown answer in `config.streamChunks` deltas, default 200, one every `config.streamIntervalMs`, default 30; the UI probe `interaction-table.ts` measures streaming with it), `mcp-send` (real calls through the built-in MCP server the host handed to `startSession`, the same path a real agent takes: a turn whose input is a JSON object is passed as the arguments of one `send_message` call, and a JSON array of `{ "tool": "…", "arguments": { … } }` is called step by step, for example `ycodium_plugin_define`, then `ycodium_plugin_run`, then a tool the mounted plugin contributes; the reply has one line per call with its result or error, and any other input gets the plain reply), `visualize` (emits one in-progress builtin tool row, holds for `config.previewHoldMs` milliseconds so the input preview can paint, then one real `visualize_visualize` call on that same server; the tool row’s result is the MCP confirmation text, and the reply is “The figure is in the card above.”), or `lane` (the UI probe `lane1-journey.ts` script: the user message's `lane:stream|plain|approve|question|attach|hold` picks the turn; `hold` accepts a second `sendTurn` with the in-flight turn id as a steer and folds that text into the reply; `config.holdMs` is how long `hold` waits, default 15000)
+- `config.script` picks the script: `plain` (default), `approval-tool` (two approvals before the reply), `async-question` (on a thread's first turn, the reply plus one non-blocking `user-input.requested` with `responseMode: "message"`), `stream` (a Markdown answer in `config.streamChunks` deltas, default 200, one every `config.streamIntervalMs`, default 30; the UI probe `interaction-table.ts` measures streaming with it), `mcp-send` (real calls through the built-in MCP server the host handed to `startSession`, the same path a real agent takes: a turn whose input is a JSON object is passed as the arguments of one `send_message` call, and a JSON array of `{ "tool": "…", "arguments": { … } }` is called step by step, for example `ycodium_plugin_define`, then `ycodium_plugin_run`, then a tool the mounted plugin contributes; the reply has one line per call with its result or error, and any other input gets the plain reply; see [Playbook mode](#playbook-mode) for per-thread scripts that ignore turn input), `visualize` (emits one in-progress builtin tool row, holds for `config.previewHoldMs` milliseconds so the input preview can paint, then one real `visualize_visualize` call on that same server; the tool row’s result is the MCP confirmation text, and the reply is “The figure is in the card above.”), or `lane` (the UI probe `lane1-journey.ts` script: the user message's `lane:stream|plain|approve|question|attach|hold` picks the turn; `hold` accepts a second `sendTurn` with the in-flight turn id as a steer and folds that text into the reply; `config.holdMs` is how long `hold` waits, default 15000)
 - `interruptTurn` (or an aborted `AbortSignal`) ends the in-flight turn as `interrupted`
 - `readThread` returns the bookkeeping the instance recorded
 - `probe` reports two models, `fake` (default) and `fake-large`
@@ -23,6 +23,82 @@ This package is **not** in the default bundle and **not** a first-party add-grid
 
 Develop with `vp run --filter @ycodium-ai/agent-fake typecheck`, `build`, and `test`.
 
+## Playbook mode
+
+Replay recorded conversations or drive multi-thread acceptance tests with
+`config.script: "mcp-send"` and `config.playbookPath` pointing to a JSON file on the executor's
+machine. Use an absolute path. This option is outside the settings form and applies only to
+`mcp-send`. Each turn runs the next batch, ignoring its input, including host wake-ups and follow-ups.
+
+This example assigns one script by thread ID and another by title:
+
+```json
+{
+  "version": 1,
+  "threads": [
+    {
+      "match": { "threadId": "^team-member:[^:]+:[^:]+:B$" },
+      "turns": [
+        [{ "id": "list", "tool": "work_list_items" }],
+        [
+          {
+            "tool": "work_claim_item",
+            "arguments": { "workItemId": "{{step:list.items.0.workItemId}}" }
+          }
+        ]
+      ]
+    },
+    {
+      "match": { "title": "Coordinator" },
+      "turns": [
+        [
+          {
+            "tool": "send_message",
+            "arguments": { "threadId": "team-member:demo:run:B", "text": "Continue" }
+          }
+        ],
+        [
+          { "wait": { "tool": "my-plugin_hello", "timeoutMs": 30000 } },
+          { "tool": "my-plugin_hello" }
+        ]
+      ]
+    }
+  ]
+}
+```
+
+`version` must be `1`. Matches need a `threadId` regex (supply `^…$` for whole-ID matching)
+or a case-sensitive `title` substring. Both conditions must hold if both exist; missing titles
+cannot match. On its first turn, a thread claims the first unclaimed matching line in file order.
+Claims, cursors and results survive `stopSession` within the instance. The file is read once
+on first use, including failures: an unreadable or invalid file yields `playbook: <reason>`
+every turn without tools. A new instance is required to reload it.
+
+Each batch runs steps in order. Calls take `tool`, optional `id`, and object `arguments`
+(default `{}`). String values at any depth support `{{thread}}` and `{{step:<id>.<path>}}`.
+References can cross turns; dot paths use numeric array indexes, and omitting the path takes
+the whole value. Results prefer `structuredContent`, then JSON parsed from `content[0].text`,
+then that text. A whole-string placeholder preserves types; interpolation JSON-stringifies
+non-strings. Unresolved references skip that call and reply
+`mcp-send <tool> failed: unresolved placeholder <placeholder>`, then continue.
+
+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-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
+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
+items and continues. Calls reply `mcp-send <tool>: <JSON result>` or `mcp-send <tool> failed: <error>` and
+emit paired `item.started` / `item.completed` events carrying the prefixed tool name, resolved
+input, raw result and status. Abort stops before the next step and ends the turn as `interrupted`.
+
+Threads with no matching line, or with all batches consumed, use the original `mcp-send`
+input handling: JSON requests call tools and ordinary text gets `replyText`. Omitting
+`playbookPath` keeps the existing scripts and output unchanged.
+
 ## License
 
 UNLICENSED.

package/dist/index.js

@@ -60,6 +60,8 @@ var FAKE_CARD = {
       holdMs: { type: "integer", minimum: 0 },
       // stream 脚本循环切片的源文本；性能探针用它换上可控的长回复，不进设置表单。
       streamText: { type: "string" },
+      // mcp-send 的逐轮剧本文件路径；不进设置表单。
+      playbookPath: { type: "string" },
       // 额度与用量怎么答（见 fakeUsage.ts）；不进设置表单，开发与验收时手改实例配置。
       usageScript: {
         type: "string",
@@ -463,7 +465,12 @@ function parseMessage(text) {
   return json.length === 0 ? null : JSON.parse(json);
 }
 async function callMcpTool(input) {
+  const session = await openMcpSession(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 response = await input.fetch(input.server.transport.url, {
       method: "POST",
       headers: {
@@ -471,7 +478,8 @@ async function callMcpTool(input) {
         accept: "application/json, text/event-stream",
         ...headers
       },
-      body: JSON.stringify({ jsonrpc: "2.0", ...body })
+      body: JSON.stringify({ jsonrpc: "2.0", ...body }),
+      ...input.signal === void 0 ? {} : { signal: input.signal }
     });
     const text = await response.text();
     if (!response.ok)
@@ -497,16 +505,16 @@ async function callMcpTool(input) {
     ...sessionId === null ? {} : { "mcp-session-id": sessionId }
   };
   await post(session, { method: "notifications/initialized" });
-  const called = await post(session, {
-    id: 2,
-    method: "tools/call",
-    params: { name: input.name, arguments: input.arguments }
-  });
-  if (called.message?.error !== void 0)
-    throw new Error(
-      `MCP tools/call ${input.name} failed: ${called.message.error.message ?? "error"}`
-    );
-  return called.message?.result;
+  let nextId = 2;
+  return {
+    request: async (method, params) => {
+      const called = await post(session, { id: nextId++, method, params });
+      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;
+    }
+  };
 }
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function parseMcpSendInput(input) {
@@ -545,6 +553,299 @@ async function runMcpCalls(input) {
   return lines.join("\n");
 }
 
+// src/playbook.ts
+import * as NodeFSP from "node:fs/promises";
+
+// src/hold.ts
+function hold(ms, signal) {
+  if (ms === 0 || signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    let timer;
+    const finish = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+
+// src/playbook.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isName = (value) => typeof value === "string" && value.length > 0;
+var onlyKeys = (value, keys) => Object.keys(value).every((key) => keys.includes(key));
+var parseTimeout = (value) => {
+  const timeoutMs = value === void 0 ? 3e4 : value;
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs >= 0 ? timeoutMs : null;
+};
+function parseStep(value) {
+  if (!isRecord2(value)) return null;
+  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;
+    const timeoutMs = parseTimeout(wait.timeoutMs);
+    return timeoutMs === null ? null : { wait: { tool: wait.tool, timeoutMs } };
+  }
+  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))
+      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 } };
+  }
+  if (!onlyKeys(value, ["id", "tool", "arguments"]) || !isName(value.tool)) 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.id === void 0 ? {} : { id: value.id },
+    ...value.arguments === void 0 ? {} : { arguments: value.arguments }
+  };
+}
+function parsePlaybook(text) {
+  try {
+    const value = JSON.parse(text);
+    if (!isRecord2(value) || value.version !== 1) return { ok: false, reason: "version must be 1" };
+    if (!onlyKeys(value, ["version", "threads"]) || !Array.isArray(value.threads))
+      return { ok: false, reason: "threads must be an array" };
+    const threads = [];
+    for (const [index, line] of value.threads.entries()) {
+      if (!isRecord2(line) || !onlyKeys(line, ["match", "turns"]) || !isRecord2(line.match))
+        return { ok: false, reason: `threads[${index}] must have match and turns` };
+      const match = line.match;
+      if (!onlyKeys(match, ["threadId", "title"]) || match.threadId === void 0 && match.title === void 0 || match.threadId !== void 0 && typeof match.threadId !== "string" || match.title !== void 0 && typeof match.title !== "string")
+        return { ok: false, reason: `threads[${index}].match needs threadId or title` };
+      if (!Array.isArray(line.turns))
+        return { ok: false, reason: `threads[${index}].turns must be an array` };
+      const turns = [];
+      for (const [turn, batch] of line.turns.entries()) {
+        if (!Array.isArray(batch))
+          return { ok: false, reason: `threads[${index}].turns[${turn}] must be an array` };
+        const steps = [];
+        for (const entry of batch) {
+          const step = parseStep(entry);
+          if (step === null)
+            return { ok: false, reason: `threads[${index}].turns[${turn}] has an invalid step` };
+          steps.push(step);
+        }
+        turns.push(steps);
+      }
+      threads.push({
+        match: {
+          ...typeof match.threadId === "string" ? { threadId: new RegExp(match.threadId) } : {},
+          ...typeof match.title === "string" ? { title: match.title } : {}
+        },
+        turns
+      });
+    }
+    return { ok: true, threads };
+  } catch (error) {
+    return { ok: false, reason: String(error) };
+  }
+}
+var UnresolvedPlaceholder = class extends Error {
+};
+function placeholderValue(raw, threadId, results) {
+  if (raw === "{{thread}}") return threadId;
+  const [id, ...path] = raw.slice(7, -2).split(".");
+  const value = id === void 0 || !results.has(id) ? void 0 : valueAt(results.get(id), path);
+  if (value === void 0) throw new UnresolvedPlaceholder(`unresolved placeholder ${raw}`);
+  return value;
+}
+function valueAt(start, path) {
+  let value = start;
+  for (const part of path) {
+    if (Array.isArray(value) && /^\d+$/.test(part) && Object.hasOwn(value, Number(part))) {
+      value = value[Number(part)];
+    } else if (isRecord2(value) && Object.hasOwn(value, part)) {
+      value = value[part];
+    } else {
+      return void 0;
+    }
+  }
+  return value;
+}
+function resolveValue(value, threadId, results) {
+  if (typeof value === "string") {
+    const placeholders = [...value.matchAll(/\{\{(?:thread|step:[^{}]*)\}\}/g)];
+    if (placeholders.length === 1 && placeholders[0]?.[0] === value)
+      return placeholderValue(value, threadId, results);
+    return value.replace(/\{\{(?:thread|step:[^{}]*)\}\}/g, (raw) => {
+      const resolved = placeholderValue(raw, threadId, results);
+      return typeof resolved === "string" ? resolved : JSON.stringify(resolved);
+    });
+  }
+  if (Array.isArray(value)) return value.map((entry) => resolveValue(entry, threadId, results));
+  if (isRecord2(value)) return resolveArguments(value, threadId, results);
+  return value;
+}
+function resolveArguments(args, threadId, results) {
+  return Object.fromEntries(
+    Object.entries(args).map(([key, value]) => [key, resolveValue(value, threadId, results)])
+  );
+}
+function stepResult(result) {
+  if (!isRecord2(result)) return void 0;
+  if (Object.hasOwn(result, "structuredContent")) return result.structuredContent;
+  const first = Array.isArray(result.content) ? result.content[0] : void 0;
+  if (!isRecord2(first) || typeof first.text !== "string") return void 0;
+  try {
+    return JSON.parse(first.text);
+  } catch {
+    return first.text;
+  }
+}
+async function poll(timeoutMs, input, ready) {
+  const server = builtinMcpServer(input.mcpServers);
+  const deadline = Date.now() + timeoutMs;
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  input.signal.addEventListener("abort", abort, { once: true });
+  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);
+        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);
+    }
+    return false;
+  } finally {
+    clearTimeout(timer);
+    input.signal.removeEventListener("abort", abort);
+  }
+}
+var waitForTool = (step, input) => poll(step.wait.timeoutMs, input, async (session) => {
+  const listed = await session.request("tools/list", {});
+  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}`)
+  );
+});
+var waitForCount = (step, input) => poll(step.waitFor.timeoutMs, input, async (session) => {
+  const called = await session.request("tools/call", { name: step.waitFor.tool, arguments: {} });
+  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) {
+  let args = step.arguments ?? {};
+  let failure;
+  try {
+    args = resolveArguments(args, input.threadId, playback.results);
+  } catch (error) {
+    failure = error instanceof UnresolvedPlaceholder ? error.message : String(error);
+  }
+  const toolName = `mcp__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;
+  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
+      });
+    } catch (error) {
+      failure = String(error);
+    }
+  }
+  if (failure !== void 0) result = { isError: true, content: [{ type: "text", text: failure }] };
+  if (step.id !== void 0) playback.results.set(step.id, stepResult(result));
+  const failed = failure !== void 0 || isRecord2(result) && result.isError === true;
+  input.emit(
+    "item.completed",
+    input.threadId,
+    {
+      ...payload,
+      status: failed ? "failed" : "completed",
+      data: { ...payload.data, result }
+    },
+    extra
+  );
+  return failure === void 0 ? `mcp-send ${step.tool}: ${JSON.stringify(result)}` : `mcp-send ${step.tool} failed: ${failure}`;
+}
+function createPlaybookRunner(input) {
+  const config = isRecord2(input) && isRecord2(input.config) ? input.config : void 0;
+  const path = config?.playbookPath;
+  if (typeof path !== "string") return void 0;
+  const titles = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Set();
+  const sessions = /* @__PURE__ */ new Map();
+  let loaded;
+  return {
+    startSession: (session) => {
+      titles.set(session.threadId, session.title);
+    },
+    runTurn: async (turn) => {
+      if (turn.signal.aborted) return "";
+      loaded ??= NodeFSP.readFile(path, "utf8").then(
+        parsePlaybook,
+        (error) => ({ ok: false, reason: String(error) })
+      );
+      const parsed = await loaded;
+      if (turn.signal.aborted) return "";
+      if (!parsed.ok) return `playbook: ${parsed.reason}`;
+      let playback = sessions.get(turn.threadId);
+      if (playback === void 0) {
+        const title = titles.get(turn.threadId);
+        const index = parsed.threads.findIndex(
+          (line, index2) => !claimed.has(index2) && (line.match.threadId === void 0 || line.match.threadId.test(turn.threadId)) && (line.match.title === void 0 || title !== void 0 && title.includes(line.match.title))
+        );
+        if (index >= 0) claimed.add(index);
+        playback = { line: parsed.threads[index] ?? null, cursor: 0, results: /* @__PURE__ */ new Map() };
+        sessions.set(turn.threadId, playback);
+      }
+      const batch = playback.line?.turns[playback.cursor];
+      if (batch === void 0) return null;
+      playback.cursor += 1;
+      const lines = [];
+      for (const step of batch) {
+        if (turn.signal.aborted) break;
+        if ("wait" in step) {
+          const ready = await waitForTool(step, turn);
+          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);
+          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));
+        }
+      }
+      return lines.join("\n");
+    }
+  };
+}
+
 // src/streamScript.ts
 var FAKE_STREAM_TEXT = [
   "Here is the plan for the change, step by step.\n\n",
@@ -589,19 +890,6 @@ function confirmationText(result) {
   }
   return chunks.join("\n");
 }
-function hold(ms, signal) {
-  if (ms === 0 || signal.aborted) return Promise.resolve();
-  return new Promise((resolve) => {
-    let timer;
-    const finish = () => {
-      if (timer !== void 0) clearTimeout(timer);
-      signal.removeEventListener("abort", finish);
-      resolve();
-    };
-    timer = setTimeout(finish, ms);
-    signal.addEventListener("abort", finish, { once: true });
-  });
-}
 async function runVisualizeTurn(input) {
   const args = JSON.stringify({ action: "create", title: TITLE, fragment: FRAGMENT });
   const tool = (status, result) => ({
@@ -728,6 +1016,7 @@ var createFakeInstance = (config, host) => {
   const events = new EventBus();
   const threads = /* @__PURE__ */ new Map();
   const script = parseScript(config);
+  const playbook = script === "mcp-send" ? createPlaybookRunner(config) : void 0;
   const replyText = parseReplyText(config);
   const failStartSession = parseFailStartSession(config);
   const streamOptions = parseStreamOptions(config);
@@ -910,7 +1199,16 @@ var createFakeInstance = (config, host) => {
       finishTurn(booked, turnId, "interrupted", []);
       return;
     }
-    const failure = parseFailInput(input);
+    const playbookText = playbook === void 0 ? null : await playbook.runTurn({
+      threadId,
+      turnId,
+      signal,
+      fetch: host.fetch,
+      mcpServers: booked.mcpServers,
+      emit,
+      nextItemId: () => nextId("item")
+    });
+    const failure = playbookText === null ? parseFailInput(input) : void 0;
     if (failure !== void 0) {
       const { category, message } = failure;
       emit("runtime.error", threadId, { message, failureCategory: category }, { turnId });
@@ -958,7 +1256,7 @@ var createFakeInstance = (config, host) => {
       return;
     }
     if (script === "mcp-send") {
-      const text = await runMcpSendScript(booked, input);
+      const text = playbookText ?? await runMcpSendScript(booked, input);
       emit("content.delta", threadId, { streamKind: "assistant_text", delta: text }, { turnId });
       await yieldTick();
       finishTurn(booked, turnId, aborted() ? "interrupted" : "completed", [
@@ -1057,6 +1355,7 @@ var createFakeInstance = (config, host) => {
         ...input.bindingGeneration === void 0 ? {} : { bindingGeneration: input.bindingGeneration }
       };
       threads.set(input.threadId, { session, turns: [], mcpServers: input.mcpServers });
+      playbook?.startSession(input);
       emit(
         "session.started",
         input.threadId,
@@ -1163,7 +1462,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-fake",
-  apiVersion: 9,
+  apiVersion: 11,
   executors,
   activate(ctx) {
     ctx.log.info("fake executor ready");

package/package.json

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