From 782bb22e900fc2eb70ff3411f06d2be3e9aefed5 Mon Sep 17 00:00:00 2001 From: ranxianglei Date: Tue, 6 Oct 2026 14:05:03 +0800 Subject: [PATCH] fix: pi-subagent-registry fake stores per-event handler arrays (#2234) The fake pi keyed handlers by event in a Map (last registration wins), but the real pi host awaits a per-event handler ARRAY in registration order (pi-coding-agent runner.js emit). On post-#2186+#2209 master, pi.ts's selfRegister session_start handler is registered before wirePiSubagents' wiring handler, so the Map kept only the wiring handler and the factory test lost its bySession entry. Same defect class as the issue2072 fake fixed earlier. --- tests/pi-subagent-registry.test.ts | 36 ++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/tests/pi-subagent-registry.test.ts b/tests/pi-subagent-registry.test.ts index 60e6f26dd1..73334d82f1 100644 --- a/tests/pi-subagent-registry.test.ts +++ b/tests/pi-subagent-registry.test.ts @@ -238,25 +238,43 @@ test("#2185: symlinked entry path is canonicalized to its realpath target", () = } }); +type FakePiHandler = (event: unknown, ctx: unknown) => unknown; + type FakePi = { - events: Map unknown>; - on(event: string, handler: (event: unknown, ctx: unknown) => unknown): void; + events: Map; + on(event: string, handler: FakePiHandler): void; registerTool(tool: unknown): void; registerCommand(name: string, options: unknown): void; registerProvider(name: string, config: { baseUrl: string }): void; }; +// The real pi host keeps a per-event handler ARRAY and awaits each in +// registration order (pi-coding-agent dist/core/extensions/runner.js emit(): +// `const handlers = ext.handlers.get(event.type); for (const handler of handlers)`) — +// #2234: a Map keyed by event (last registration wins) shadowed pi.ts's +// selfRegister handler behind wirePiSubagents' wiring handler and broke the +// factory test on post-#2186+#2209 master. function makeFakePi(): FakePi { - const events = new Map unknown>(); + const events = new Map(); return { events, - on: (event, handler) => { events.set(event, handler); }, + on: (event, handler) => { + const list = events.get(event); + if (list) list.push(handler); else events.set(event, [handler]); + }, registerTool: () => {}, registerCommand: () => {}, registerProvider: () => {}, }; } +async function firePiEvent(pi: FakePi, event: string, payload: unknown, ctx: unknown): Promise { + for (const handler of pi.events.get(event) ?? []) { + // Same await-per-handler contract as the real runner's emit(). + await handler(payload, ctx); + } +} + test("#2185: factory wiring — session_start self-registers, session_shutdown disposes", async () => { const prevProxy = process.env.BILLION_CONTEXT_PROXY; const prevKill1 = process.env.BILLION_CONTEXT_PLUGIN; @@ -270,13 +288,13 @@ test("#2185: factory wiring — session_start self-registers, session_shutdown d createBiliPlugin("pi")(pi as never); const start = pi.events.get("session_start"); const shutdown = pi.events.get("session_shutdown"); - assert.ok(start && shutdown, "both handlers must be registered"); - await start!({ type: "session_start", reason: "startup" }, { sessionManager: { getSessionId: () => sid } }); + assert.ok(start && start.length > 0 && shutdown && shutdown.length > 0, "both events must have handlers"); + await firePiEvent(pi, "session_start", { type: "session_start", reason: "startup" }, { sessionManager: { getSessionId: () => sid } }); assert.ok(registry()?.bySession.has(sid), "entry present after session_start"); const snap = registry()!.bySession.get(sid) as readonly Readonly<{ id: string; path: string }>[]; assert.equal(snap[0].id, SUBAGENT_EXTENSION_ID); assert.ok(fs.existsSync(snap[0].path), "registered path resolves to a real file"); - await shutdown!({ type: "session_shutdown", reason: "quit" }, undefined); + await firePiEvent(pi, "session_shutdown", { type: "session_shutdown", reason: "quit" }, undefined); assert.ok(!registry()?.bySession.has(sid), "entry gone after session_shutdown"); } finally { cleanup(sid); @@ -293,13 +311,13 @@ test("#2185: factory wiring — kill switch respected at session_start; omp neve process.env.BILLION_CONTEXT_PLUGIN = "0"; const pi = makeFakePi(); createBiliPlugin("pi")(pi as never); - await pi.events.get("session_start")!({ type: "session_start", reason: "startup" }, { sessionManager: { getSessionId: () => sid } }); + await firePiEvent(pi, "session_start", { type: "session_start", reason: "startup" }, { sessionManager: { getSessionId: () => sid } }); assert.ok(!registry()?.bySession.has(sid), "kill switch: no registration"); delete process.env.BILLION_CONTEXT_PLUGIN; const ompPi = makeFakePi(); createBiliPlugin("omp")(ompPi as never); - await ompPi.events.get("session_start")!({ type: "session_start", reason: "startup" }, { sessionManager: { getSessionId: () => sid } }); + await firePiEvent(ompPi, "session_start", { type: "session_start", reason: "startup" }, { sessionManager: { getSessionId: () => sid } }); assert.ok(!registry()?.bySession.has(sid), "omp lane must not touch the pi-subagents registry"); } finally { cleanup(sid);