@baique/pi-web-sky 0.1.54 → 0.1.56

package/lib/subagent-queue.ts

@@ -0,0 +1,74 @@
+export type SubagentQueueState = "queued" | "running";
+
+interface QueueItem<T> {
+  run: () => Promise<T>;
+  onState: (state: SubagentQueueState) => void;
+  onCancel?: () => void | Promise<void>;
+  resolve: (value: T) => void;
+  reject: (error: unknown) => void;
+  state: SubagentQueueState;
+  cancelled: boolean;
+}
+
+type ParentQueue<T> = {
+  limit: number;
+  active: number;
+  items: QueueItem<T>[];
+};
+
+export interface EnqueuedSubagent<T> {
+  promise: Promise<T>;
+  cancel(): boolean;
+}
+
+/** FIFO per parent session; separate parents do not block one another. */
+export class SubagentQueue<T> {
+  private readonly parents = new Map<string, ParentQueue<T>>();
+
+  enqueue(
+    parentId: string,
+    limit: number,
+    run: () => Promise<T>,
+    onState: (state: SubagentQueueState) => void,
+    onCancel?: () => void,
+  ): EnqueuedSubagent<T> {
+    const parent = this.parents.get(parentId) ?? { limit: 1, active: 0, items: [] };
+    parent.limit = Math.max(1, Math.floor(limit) || 1);
+    let item!: QueueItem<T>;
+    const promise = new Promise<T>((resolve, reject) => {
+      item = { run, onState, onCancel, resolve, reject, state: "queued", cancelled: false };
+    });
+    parent.items.push(item);
+    this.parents.set(parentId, parent);
+    onState("queued");
+    this.pump(parentId, parent);
+    return {
+      promise,
+      cancel: () => {
+        if (item.state !== "queued" || item.cancelled) return false;
+        item.cancelled = true;
+        Promise.resolve(item.onCancel?.()).then(
+          () => item.resolve(undefined as T),
+          (error) => item.reject(error),
+        );
+        this.pump(parentId, parent);
+        return true;
+      },
+    };
+  }
+
+  private pump(parentId: string, parent: ParentQueue<T>): void {
+    while (parent.active < parent.limit && parent.items.length > 0) {
+      const item = parent.items.shift()!;
+      if (item.cancelled) continue;
+      item.state = "running";
+      item.onState("running");
+      parent.active += 1;
+      void item.run().then(item.resolve, item.reject).finally(() => {
+        parent.active -= 1;
+        this.pump(parentId, parent);
+        if (parent.active === 0 && parent.items.length === 0) this.parents.delete(parentId);
+      });
+    }
+  }
+}

package/lib/subagent-runtime.test.mjs

@@ -0,0 +1,150 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const { createSubagentController } = await createJiti(import.meta.url).import("./subagent-runtime.ts");
+
+function completedRun() {
+  return {
+    sessionId: "child-session",
+    sessionPath: "/tmp/child.jsonl",
+    parentSessionId: "parent-session",
+    parentToolCallId: "tool-call",
+    profile: "Explore",
+    description: "Inspect parser",
+    task: "Find the parser",
+    runInBackground: true,
+    status: "completed",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    completedAt: "2026-01-01T00:01:00.000Z",
+    result: "Parser found",
+  };
+}
+
+test("completion notification reopens an idle parent and uses its current session", async () => {
+  const delivered = [];
+  const reopened = [];
+  let ready = false;
+  let parent;
+  const liveParent = {
+    cwd: "/tmp",
+    sessionFile: "/tmp/parent.jsonl",
+    isAlive: () => true,
+    isRunning: () => false,
+    waitUntilReady: async () => { ready = true; },
+    inner: {
+      sendCustomMessage: async (message, options) => delivered.push({ message, options }),
+    },
+  };
+  const controller = createSubagentController({
+    getSession: () => parent,
+    registerSession: () => {},
+    reopenSession: async (sessionId, sessionFile) => {
+      reopened.push([sessionId, sessionFile]);
+      parent = liveParent;
+      return liveParent;
+    },
+    resolveSessionPath: async () => "/tmp/parent.jsonl",
+    invalidateSessionList: () => {},
+  });
+
+  await controller.extensionRuntime.notifyParent(completedRun());
+
+  assert.deepEqual(reopened, [["parent-session", "/tmp/parent.jsonl"]]);
+  assert.equal(ready, true);
+  assert.equal(delivered.length, 1);
+  assert.equal(delivered[0].message.content, "Parser found");
+  assert.equal(delivered[0].message.details.sessionId, "child-session");
+  assert.deepEqual(delivered[0].options, { deliverAs: "followUp", triggerTurn: true });
+});
+
+test("disabled built-in subagents reject stale Agent calls before starting", async () => {
+  const controller = createSubagentController({
+    getSession: () => { throw new Error("must not inspect a parent"); },
+    registerSession: () => {},
+    reopenSession: async () => { throw new Error("unused"); },
+    resolveSessionPath: async () => null,
+    invalidateSessionList: () => {},
+    isBuiltInSubagentsEnabled: () => false,
+  });
+
+  await assert.rejects(
+    controller.extensionRuntime.start({
+      parentContext: { sessionManager: { getSessionId: () => "parent" } },
+      parentToolCallId: "call",
+      profile: "explore",
+      task: "Inspect",
+      description: "Inspect",
+    }),
+    /built-in sub-agents are disabled/,
+  );
+});
+
+test("resume reuses the persisted child session and keeps its session id", async () => {
+  const calls = [];
+  const entries = [
+    { type: "custom", customType: "pi-web:subagent", data: {
+      version: 1,
+      parentSessionId: "parent",
+      parentSessionPath: "/tmp/parent.jsonl",
+      parentToolCallId: "old-call",
+      profile: "explore",
+      description: "old task",
+      task: "old",
+      runInBackground: false,
+      createdAt: "2026-01-01T00:00:00.000Z",
+      resourceSnapshot: { version: 1, appendSystemPrompt: [], tools: [], loadSkills: false, loadExtensions: false },
+    } },
+    { type: "custom", customType: "pi-web:subagent-result", data: {
+      version: 1, status: "completed", completedAt: "2026-01-01T00:01:00.000Z", result: "old result",
+    } },
+  ];
+  const childInner = {
+    sessionId: "child",
+    sessionFile: "/tmp/child.jsonl",
+    sessionManager: { getEntries: () => entries, appendCustomEntry: (type, data) => entries.push({ type: "custom", customType: type, data }) },
+    prompt: async (task) => { calls.push(task); },
+    getLastAssistantText: () => "new result",
+    abort: async () => {},
+  };
+  const child = { inner: childInner, sessionFile: childInner.sessionFile, cwd: "/tmp", isAlive: () => true, isRunning: () => false, waitUntilReady: async () => {} };
+  const parent = { inner: { sessionManager: { getSessionId: () => "parent" } }, sessionFile: "/tmp/parent.jsonl", cwd: "/tmp", isAlive: () => true, isRunning: () => false, waitUntilReady: async () => {} };
+  const controller = createSubagentController({
+    getSession: (id) => id === "child" ? child : parent,
+    registerSession: () => {},
+    reopenSession: async () => child,
+    resolveSessionPath: async () => child.sessionFile,
+    invalidateSessionList: () => {},
+    isBuiltInSubagentsEnabled: () => true,
+  });
+  const execution = await controller.extensionRuntime.resume({
+    parentContext: parent.inner,
+    parentToolCallId: "new-call",
+    sessionId: "child",
+    task: "continue this",
+    description: "Continue task",
+  });
+  const result = await execution.completion;
+  assert.equal(execution.run.sessionId, "child");
+  assert.equal(result.sessionId, "child");
+  assert.equal(result.status, "completed");
+  assert.deepEqual(calls, ["continue this"]);
+});
+
+test("resume rejects a child owned by another parent", async () => {
+  const controller = createSubagentController({
+    getSession: (id) => id === "parent" ? { inner: { sessionManager: { getSessionId: () => "parent" } }, sessionFile: "/tmp/parent.jsonl", cwd: "/tmp", isAlive: () => true, isRunning: () => false, waitUntilReady: async () => {} } : undefined,
+    registerSession: () => {},
+    reopenSession: async () => { throw new Error("unused"); },
+    resolveSessionPath: async () => null,
+    invalidateSessionList: () => {},
+    isBuiltInSubagentsEnabled: () => true,
+  });
+  await assert.rejects(controller.extensionRuntime.resume({
+    parentContext: { sessionManager: { getSessionId: () => "parent" } },
+    parentToolCallId: "call",
+    sessionId: "missing",
+    task: "continue",
+    description: "Continue",
+  }), /Subagent not found/);
+});