@ycodium-ai/agent-fake 0.2.3377 → 0.2.3389

package/README.md

@@ -61,14 +61,25 @@ Replay recorded conversations or drive multi-thread acceptance tests with
 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.
 
-A playbook instance accepts a steer, as a real provider does: a second `sendTurn` carrying the
-running turn's id returns that turn, and when the current batch finishes the next batch runs inside
-the same turn, one steer at a time in arrival order (each still subject to `expectInput`). A steer
-the playbook has no batch for is logged as `playbook has no step for a steered input` and noted in
-the reply. A steer whose target turn has already ended, or is not the running turn, is refused with
-an error carrying `code: "provider-rejected"`, so the host puts the message back in the queue. A plain
+A playbook instance accepts a steer only where the playbook says so: while the batch the thread is
+running ends with `awaitSteer`. Then a second `sendTurn` carrying the running turn's id returns that
+turn, and when the current batch finishes the next batch runs inside the same turn, one steer at a
+time in arrival order (each still subject to `expectInput`). A playbook derived from a recording has
+`awaitSteer` exactly where the recorded agent took a steer, so a steer elsewhere would shift every
+later batch by one; it is refused instead, and the host starts it as its own turn, as in the
+recording. A steer the playbook has no batch for is logged as `playbook has no step for a steered
+input` and noted in the reply. A steer the running batch does not await, or whose target turn has
+already ended or is not the running turn, is refused with an error carrying
+`code: "provider-rejected"`, so the host puts the message back in the queue. A plain
 `mcp-send` instance without a playbook still refuses a second turn while one is running.
 
+`{ "awaitSteer": { "timeoutMs": 60000, "continueOnTimeout": true } }` treats a steer that never
+arrives as already folded into the turn: on timeout it runs the next batch inside the same turn
+instead of ending it. Derived playbooks set it on member-machine sessions, where a steer can reach
+the host before the member's turn starts and be merged into that turn's input. The next batch then
+relies on its own `waitFor` steps; a steer that arrives later is refused like any other and starts
+a turn with no matching batch.
+
 This example assigns one script by thread ID and another by title:
 
 ```json
@@ -132,7 +143,9 @@ A `wait` polls `tools/list` on that MCP server every 250 ms for the tool name or
 `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 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
+with its optional `arguments` (none by default; `{{thread}}` and `{{step:…}}` placeholders are
+resolved as for calls, and an unresolvable one replies `mcp-send <tool> failed: <error>` without
+polling) 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`; any other value found there (for
 example one entry picked by a selector such as `items[title=<encodeURIComponent value>]`) counts
 as 1, and a tool error counts as not yet. Dots inside a selector's brackets do not split the path.

package/dist/index.js

@@ -897,10 +897,12 @@ function parseStep(value) {
     return onlyKeys(value, ["expectInput"]) && isName(value.expectInput) ? { expectInput: value.expectInput } : null;
   if (Object.hasOwn(value, "awaitSteer")) {
     const wait = value.awaitSteer;
-    if (!onlyKeys(value, ["awaitSteer"]) || !isRecord2(wait) || !onlyKeys(wait, ["timeoutMs"]))
+    if (!onlyKeys(value, ["awaitSteer"]) || !isRecord2(wait) || !onlyKeys(wait, ["timeoutMs", "continueOnTimeout"]) || Object.hasOwn(wait, "continueOnTimeout") && wait.continueOnTimeout !== true)
       return null;
     const timeoutMs = parseTimeout(wait.timeoutMs);
-    return timeoutMs === null ? null : { awaitSteer: { timeoutMs } };
+    if (timeoutMs === null) return null;
+    const onTimeout = wait.continueOnTimeout === true ? { continueOnTimeout: true } : {};
+    return { awaitSteer: { timeoutMs, ...onTimeout } };
   }
   if (Object.hasOwn(value, "wait")) {
     const wait = value.wait;
@@ -1135,13 +1137,13 @@ var waitForTool = (step, input, clients) => poll(step.wait.timeoutMs, input, asy
     (tool) => isRecord2(tool) && (tool.name === step.wait.tool || tool.name === `mcp__${step.wait.server ?? "ycodium"}__${step.wait.tool}`)
   );
 });
-async function waitForCount(step, input, clients) {
+async function waitForCount(step, args, input, clients) {
   let ready;
   const ok = await 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 ?? {} },
+      { name: step.waitFor.tool, arguments: args },
       signal
     );
     if (isRecord2(called) && called.isError === true) return false;
@@ -1207,6 +1209,16 @@ function createPlaybookRunner(input) {
   const clients = /* @__PURE__ */ new Map();
   let loaded;
   return {
+    /**
+     * 这个会话正在跑的那一批以 awaitSteer 结尾时才收插话：剧本照录像在收到插话的地方放 awaitSteer，
+     * 别处的插话录像里是另起一轮的，收了就会把后面的批次往前错一格。
+     */
+    expectsSteer: (threadId) => {
+      const playback = sessions.get(threadId);
+      const batch = playback?.current === void 0 ? void 0 : playback.line?.turns[playback.current];
+      const last = batch?.at(-1);
+      return last !== void 0 && "awaitSteer" in last;
+    },
     startSession: (session) => {
       titles.set(session.threadId, session.title);
     },
@@ -1248,6 +1260,7 @@ function createPlaybookRunner(input) {
       const batch = picked === void 0 ? void 0 : playback.line?.turns[picked];
       if (picked === void 0 || batch === void 0) return null;
       playback.consumed.add(picked);
+      playback.current = picked;
       let opened = clients.get(turn.threadId);
       if (opened === void 0) {
         opened = createPlaybookMcp({ fetch: turn.fetch, servers: turn.mcpServers });
@@ -1260,13 +1273,21 @@ function createPlaybookRunner(input) {
         }
       };
       const lines = [];
-      for (const step of batch) {
+      const queue = [...batch];
+      for (let step = queue.shift(); step !== void 0; step = queue.shift()) {
         if (turn.signal.aborted) break;
         if ("expectInput" in step) continue;
         if ("awaitSteer" in step) {
           const ready = await turn.awaitSteer?.(step.awaitSteer.timeoutMs, turn.signal) ?? false;
           if (turn.signal.aborted) break;
           lines.push(`mcp-send awaitSteer${ready ? ": ready" : " failed: timeout"}`);
+          const after = (playback.current ?? picked) + 1;
+          const following = playback.line?.turns[after];
+          if (!ready && step.awaitSteer.continueOnTimeout === true && following !== void 0 && !playback.consumed.has(after)) {
+            playback.consumed.add(after);
+            playback.current = after;
+            queue.push(...following);
+          }
         } else if ("wait" in step) {
           const missing = opened.missing(step.wait.server);
           if (step.wait.server !== void 0 && missing !== void 0) {
@@ -1282,7 +1303,19 @@ function createPlaybookRunner(input) {
             lines.push(`mcp-send ${step.waitFor.tool} failed: ${missing}`);
             continue;
           }
-          const ready = await waitForCount(step, safeTurn, opened);
+          let args;
+          try {
+            args = resolveArguments(
+              step.waitFor.arguments ?? {},
+              turn.threadId,
+              playback.results,
+              playback.history
+            );
+          } catch (error) {
+            lines.push(`mcp-send ${step.waitFor.tool} failed: ${String(error)}`);
+            continue;
+          }
+          const ready = await waitForCount(step, args, safeTurn, opened);
           if (turn.signal.aborted) break;
           const { id, tool, path: path2, atLeast } = step.waitFor;
           if (ready !== void 0 && id !== void 0) playback.results.set(id, ready.result);
@@ -1863,7 +1896,8 @@ ${more ?? "playbook: steered input not handled"}`;
       const steerable = script === "lane" || playbook !== void 0;
       const steered = acceptLaneSteer({
         running,
-        enabled: steerable,
+        // 剧本只在正在跑的那一批写明 awaitSteer 时收插话；其余照下面「目标轮已收口」一样拒，宿主另起一轮。
+        enabled: script === "lane" || (playbook?.expectsSteer(input.threadId) ?? false),
         expectedTurnId: input.expectedTurnId,
         text: input.input,
         threadId: input.threadId,
@@ -1956,7 +1990,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-fake",
-  apiVersion: 36,
+  apiVersion: 37,
   executors,
   activate(ctx) {
     ctx.log.info("fake executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-fake",
-  "version": "0.2.3377",
+  "version": "0.2.3389",
   "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.3377",
+    "@ycodium-ai/plugin-api": "0.2.3389",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {