pi-webdesk 0.1.0

package/dist/packages/pi-bridge/src/rpc/runtime.js

@@ -0,0 +1,496 @@
+// packages/pi-bridge/src/rpc/runtime.ts
+import { fileURLToPath } from "node:url";
+import { extractToolCalls } from "../tool-activity.js";
+import { extractToolResult, ToolEventProjection } from "./tool-events.js";
+import path from "node:path";
+import { PiBridgeError } from "../errors.js";
+import { decodePolicyApproval } from "../policy-approval.js";
+import {
+  PITA_POLICY_STATUS_KEY,
+  PITA_POLICY_VERSION,
+  decodePolicyStatus,
+  isSupportedPolicyVersion
+} from "../handshake.js";
+import { PiRpcClient } from "./client.js";
+import {
+  extractEntryText,
+  getAvailableModelsDataSchema,
+  getEntriesDataSchema,
+  getStateDataSchema,
+  getTreeDataSchema,
+  rpcExtensionErrorEventSchema,
+  wireModelSchema
+} from "./wire.js";
+var DEFAULT_POLICY_EXTENSION_PATH = fileURLToPath(
+  new URL(import.meta.url.endsWith(".ts") ? "../../extensions/pita-policy.ts" : "../../extensions/pita-policy.js", import.meta.url)
+);
+var DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
+function createPiRpcRuntime(options) {
+  return new PiRpcRuntime(options);
+}
+var PiRpcRuntime = class {
+  #options;
+  #mode;
+  #client;
+  #listeners = /* @__PURE__ */ new Set();
+  #toolEvents = new ToolEventProjection();
+  #state = "created";
+  #startPromise = null;
+  #handshakeSettle = null;
+  constructor(options) {
+    if (options.sessionFile !== void 0) {
+      if ((options.sessionMode ?? "persistent") === "ephemeral") {
+        throw new PiBridgeError(
+          "PI_INVALID_CONFIGURATION",
+          "A Pi session file cannot be resumed in ephemeral mode."
+        );
+      }
+      if (!path.isAbsolute(options.sessionFile)) {
+        throw new PiBridgeError(
+          "PI_INVALID_CONFIGURATION",
+          "The Pi session file must be an absolute path."
+        );
+      }
+    }
+    this.#options = options;
+    this.#mode = options.mode ?? "supervised";
+    this.#client = new PiRpcClient({
+      executable: options.executable,
+      args: this.#buildArgs(),
+      cwd: options.cwd,
+      env: {
+        ...options.env ?? process.env,
+        PITA_RUNTIME_MODE: this.#mode
+      },
+      ...options.spawnProcess !== void 0 ? { spawnProcess: options.spawnProcess } : {},
+      ...options.requestTimeoutMs !== void 0 ? { requestTimeoutMs: options.requestTimeoutMs } : {},
+      ...options.maxRecordBytes !== void 0 ? { maxRecordBytes: options.maxRecordBytes } : {},
+      ...options.supervisorIgnoreEofForTests === true ? { supervisorIgnoreEofForTests: true } : {},
+      handlers: {
+        onEvent: (record) => this.#handleEvent(record),
+        onExtensionUiRequest: (record) => this.#handleExtensionUiRequest(record),
+        onProtocolIssue: (issue) => {
+          if (issue.fatal && this.#state !== "exited") this.#setState("failed");
+          this.#emit({ kind: "protocol-issue", ...issue });
+        },
+        onExit: (info) => this.#handleExit(info)
+      }
+    });
+  }
+  get lifecycleState() {
+    return this.#state;
+  }
+  start(options = {}) {
+    if (this.#startPromise !== null) return this.#startPromise;
+    this.#startPromise = this.#start(options);
+    return this.#startPromise;
+  }
+  async #start(options) {
+    this.#setState("starting");
+    const timeoutMs = this.#options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+    const handshakePromise = new Promise((resolve, reject) => {
+      this.#handshakeSettle = { resolve, reject };
+    });
+    void handshakePromise.catch(() => void 0);
+    const timer = setTimeout(() => {
+      this.#failStartup(
+        new PiBridgeError(
+          "PI_STARTUP_TIMEOUT",
+          `Did not receive the pita-policy handshake within ${timeoutMs}ms. Ensure the Webdesk policy extension is loaded with -e and that this Pi version emits extension_ui_request setStatus records in RPC mode.`,
+          { details: { timeoutMs } }
+        )
+      );
+    }, timeoutMs);
+    timer.unref?.();
+    try {
+      await this.#client.start();
+      const pid = this.#client.processId;
+      if (pid === null) {
+        throw new PiBridgeError(
+          "PI_SPAWN_FAILED",
+          "Pi spawned without a valid operating-system process id"
+        );
+      }
+      await options.onProcessStarted?.(pid);
+      this.#client.activateSupervisor();
+      const handshake = await handshakePromise;
+      this.#setState("ready");
+      return handshake;
+    } catch (error) {
+      if (this.#state !== "exited") this.#setState("failed");
+      try {
+        this.#client.kill("SIGKILL");
+      } catch {
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      this.#handshakeSettle = null;
+    }
+  }
+  async prompt(message, options) {
+    this.#requireReady("prompt");
+    await this.#client.request({
+      type: "prompt",
+      message,
+      ...options?.streamingBehavior !== void 0 ? { streamingBehavior: options.streamingBehavior } : {}
+    });
+  }
+  async steer(message) {
+    this.#requireReady("steer");
+    await this.#client.request({ type: "steer", message });
+  }
+  async followUp(message) {
+    this.#requireReady("follow_up");
+    await this.#client.request({ type: "follow_up", message });
+  }
+  async abort() {
+    this.#requireReady("abort");
+    await this.#client.request({ type: "abort" });
+  }
+  async getState() {
+    this.#requireReady("get_state");
+    const response = await this.#client.request({ type: "get_state" });
+    const data = this.#parseData(getStateDataSchema, response.data, "get_state");
+    return {
+      model: data.model === null || data.model === void 0 ? null : { id: data.model.id, provider: data.model.provider, name: data.model.name },
+      isStreaming: data.isStreaming,
+      messageCount: data.messageCount,
+      sessionFile: data.sessionFile ?? null,
+      sessionId: data.sessionId ?? null,
+      sessionName: data.sessionName ?? null
+    };
+  }
+  async getAvailableModels() {
+    this.#requireReady("get_available_models");
+    const response = await this.#client.request({ type: "get_available_models" });
+    const data = this.#parseData(
+      getAvailableModelsDataSchema,
+      response.data,
+      "get_available_models"
+    );
+    return data.models.map(mapModel);
+  }
+  async setModel(provider, modelId) {
+    this.#requireReady("set_model");
+    const response = await this.#client.request({
+      type: "set_model",
+      provider,
+      modelId
+    });
+    const model = this.#parseData(wireModelSchema, response.data, "set_model");
+    return mapModel(model);
+  }
+  async getEntries(since) {
+    this.#requireReady("get_entries");
+    const response = await this.#client.request({
+      type: "get_entries",
+      ...since !== void 0 ? { since } : {}
+    });
+    const data = this.#parseData(getEntriesDataSchema, response.data, "get_entries");
+    return {
+      entries: data.entries.map((entry) => mapEntrySummary(entry)),
+      leafId: data.leafId
+    };
+  }
+  async getTree() {
+    this.#requireReady("get_tree");
+    const response = await this.#client.request({ type: "get_tree" });
+    const data = this.#parseData(getTreeDataSchema, response.data, "get_tree");
+    return {
+      roots: data.tree.map((node) => mapTreeNode(node)),
+      leafId: data.leafId,
+      truncated: data.truncated
+    };
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  respondToDialog(reply) {
+    switch (reply.kind) {
+      case "confirm":
+        this.#client.sendExtensionUiResponse({
+          type: "extension_ui_response",
+          id: reply.requestId,
+          confirmed: reply.confirmed
+        });
+        return;
+      case "value":
+        this.#client.sendExtensionUiResponse({
+          type: "extension_ui_response",
+          id: reply.requestId,
+          value: reply.value
+        });
+        return;
+      case "cancel":
+        this.#client.sendExtensionUiResponse({
+          type: "extension_ui_response",
+          id: reply.requestId,
+          cancelled: true
+        });
+        return;
+    }
+  }
+  async dispose() {
+    if (this.#state === "created") {
+      this.#setState("exited");
+      return { code: null, signal: null };
+    }
+    const info = await this.#client.stop();
+    return info;
+  }
+  #buildArgs() {
+    return [
+      ...this.#options.prependArgs ?? [],
+      "--mode",
+      "rpc",
+      ...(this.#options.sessionMode ?? "persistent") === "ephemeral" ? ["--no-session"] : this.#options.sessionFile === void 0 ? [] : ["--session", path.normalize(this.#options.sessionFile)],
+      "-e",
+      this.#options.policyExtensionPath ?? DEFAULT_POLICY_EXTENSION_PATH,
+      ...this.#options.extraArgs ?? []
+    ];
+  }
+  #requireReady(operation) {
+    if (this.#state !== "ready") {
+      throw new PiBridgeError(
+        "PI_RUNTIME_NOT_READY",
+        `Cannot ${operation}: runtime is ${this.#state} (requires ready)`,
+        { details: { state: this.#state } }
+      );
+    }
+  }
+  #parseData(schema, value, commandType) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+      throw new PiBridgeError(
+        "PI_PROTOCOL_VIOLATION",
+        `Pi returned malformed ${commandType} data: ${result.error.message}`,
+        { details: { commandType } }
+      );
+    }
+    return result.data;
+  }
+  #handleExtensionUiRequest(record) {
+    if (record.method === "setStatus" && record.statusKey === PITA_POLICY_STATUS_KEY) {
+      this.#handlePolicyStatus(record);
+      return;
+    }
+    const request = mapDialogRequest(record);
+    if (request !== null) {
+      this.#emit({ kind: "dialog-requested", request });
+      return;
+    }
+    if (record.method === "notify") {
+      this.#emit({
+        kind: "notification",
+        message: record.message ?? "",
+        level: record.notifyType ?? "info"
+      });
+    }
+  }
+  #handlePolicyStatus(record) {
+    const decoded = decodePolicyStatus(record.statusText);
+    if (!decoded.ok) {
+      this.#failStartup(
+        new PiBridgeError(
+          "PI_POLICY_HANDSHAKE_INCOMPATIBLE",
+          `Webdesk policy handshake is invalid: ${decoded.reason}`
+        )
+      );
+      return;
+    }
+    if (!isSupportedPolicyVersion(decoded.status.version)) {
+      this.#failStartup(
+        new PiBridgeError(
+          "PI_POLICY_HANDSHAKE_INCOMPATIBLE",
+          `Webdesk policy extension announced version ${decoded.status.version}, but this bridge supports version ${PITA_POLICY_VERSION}`,
+          { details: { announced: decoded.status.version, supported: PITA_POLICY_VERSION } }
+        )
+      );
+      return;
+    }
+    if (decoded.status.mode !== this.#mode) {
+      this.#failStartup(
+        new PiBridgeError(
+          "PI_POLICY_HANDSHAKE_INCOMPATIBLE",
+          `Webdesk policy extension announced ${decoded.status.mode} mode, but this runtime requires ${this.#mode} mode`,
+          { details: { announced: decoded.status.mode, required: this.#mode } }
+        )
+      );
+      return;
+    }
+    this.#emit({ kind: "policy-status", status: decoded.status });
+    this.#handshakeSettle?.resolve({
+      version: decoded.status.version,
+      mode: decoded.status.mode
+    });
+  }
+  #handleEvent(record) {
+    for (const tool of this.#toolEvents.accept(record)) this.#emit({ kind: "tool-activity", tool });
+    if (record.type === "extension_error") {
+      const parsed = rpcExtensionErrorEventSchema.safeParse(record);
+      const message = parsed.success ? parsed.data.error ?? "unknown extension error" : "unknown extension error";
+      const extensionPath = parsed.success ? parsed.data.extensionPath ?? null : null;
+      if (this.#handshakeSettle !== null) {
+        this.#failStartup(
+          new PiBridgeError(
+            "PI_STARTUP_FAILED",
+            `Extension error during startup${extensionPath === null ? "" : ` (${extensionPath})`}: ${message}`
+          )
+        );
+        return;
+      }
+      this.#emit({ kind: "extension-error", message, extensionPath });
+      return;
+    }
+    switch (record.type) {
+      case "agent_start":
+        this.#emit({ kind: "agent-activity", phase: "agent-start" });
+        return;
+      case "agent_end":
+        this.#emit({ kind: "agent-activity", phase: "agent-end" });
+        return;
+      case "agent_settled":
+        this.#emit({ kind: "agent-activity", phase: "agent-settled" });
+        return;
+      case "turn_start":
+        this.#emit({ kind: "agent-activity", phase: "turn-start" });
+        return;
+      case "turn_end":
+        this.#emit({ kind: "agent-activity", phase: "turn-end" });
+        return;
+      case "message_update": {
+        const delta = extractTextDelta(record);
+        if (delta !== null) this.#emit({ kind: "assistant-delta", text: delta });
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  #handleExit(info) {
+    const exitedDuringStartup = this.#state === "starting";
+    if (this.#handshakeSettle !== null) {
+      const stderr = this.#client.stderrTail.trim();
+      this.#failStartup(
+        new PiBridgeError(
+          "PI_STARTUP_FAILED",
+          `Pi exited during startup (code ${info.code}, signal ${info.signal})` + (stderr === "" ? "" : `; stderr tail:
+${stderr}`),
+          { details: { code: info.code, signal: info.signal } }
+        )
+      );
+    }
+    if (exitedDuringStartup) {
+      this.#setState("failed");
+    } else if (this.#state !== "failed") {
+      this.#setState("exited");
+    }
+    this.#emit({ kind: "exited", code: info.code, signal: info.signal });
+  }
+  #failStartup(error) {
+    const settle = this.#handshakeSettle;
+    this.#handshakeSettle = null;
+    settle?.reject(error);
+  }
+  #setState(state) {
+    if (this.#state === state) return;
+    this.#state = state;
+    this.#emit({ kind: "lifecycle", state });
+  }
+  #emit(event) {
+    for (const listener of this.#listeners) listener(event);
+  }
+};
+function mapModel(model) {
+  return {
+    id: model.id,
+    ...model.provider === void 0 ? {} : { provider: model.provider },
+    ...model.name === void 0 ? {} : { name: model.name }
+  };
+}
+function mapDialogRequest(record) {
+  switch (record.method) {
+    case "confirm": {
+      const approval = decodePolicyApproval(record.title, record.message);
+      if (approval !== null) {
+        const transportTimeoutMs = Number.isSafeInteger(record.timeout) && (record.timeout ?? 0) > 0 ? record.timeout : approval.timeoutMs;
+        return {
+          requestId: record.id,
+          kind: "approval",
+          toolCallId: approval.toolCallId,
+          toolName: approval.toolName,
+          summary: approval.summary,
+          requestedAtMs: approval.requestedAtMs,
+          timeoutMs: Math.min(approval.timeoutMs, transportTimeoutMs)
+        };
+      }
+      return {
+        requestId: record.id,
+        kind: "confirm",
+        title: record.title ?? "",
+        message: record.message ?? "",
+        timeoutMs: record.timeout
+      };
+    }
+    case "select":
+      return {
+        requestId: record.id,
+        kind: "select",
+        title: record.title ?? "",
+        options: record.options ?? [],
+        timeoutMs: record.timeout
+      };
+    case "input":
+      return {
+        requestId: record.id,
+        kind: "input",
+        title: record.title ?? "",
+        placeholder: record.placeholder,
+        timeoutMs: record.timeout
+      };
+    case "editor":
+      return {
+        requestId: record.id,
+        kind: "editor",
+        title: record.title ?? "",
+        prefill: record.prefill
+      };
+    default:
+      return null;
+  }
+}
+function mapEntrySummary(entry) {
+  const text = entry.message === void 0 ? null : extractEntryText(entry.message.content);
+  const toolCalls = entry.message?.role === "assistant" ? extractToolCalls(entry.message.content) : [];
+  const toolResult = extractToolResult(entry.message);
+  return {
+    id: entry.id,
+    parentId: entry.parentId ?? null,
+    type: entry.type,
+    ...entry.message === void 0 ? {} : { role: entry.message.role },
+    ...text === null ? {} : { text },
+    ...toolCalls.length === 0 ? {} : { toolCalls },
+    ...toolResult === void 0 ? {} : { toolResult }
+  };
+}
+function mapTreeNode(node) {
+  return {
+    entry: mapEntrySummary(node.entry),
+    children: node.children.map((child) => mapTreeNode(child)),
+    label: node.label
+  };
+}
+function extractTextDelta(record) {
+  const event = record["assistantMessageEvent"];
+  if (typeof event !== "object" || event === null) return null;
+  const delta = event;
+  if (delta["type"] !== "text_delta") return null;
+  return typeof delta["delta"] === "string" ? delta["delta"] : null;
+}
+export {
+  DEFAULT_POLICY_EXTENSION_PATH,
+  PiRpcRuntime,
+  createPiRpcRuntime
+};

package/dist/packages/pi-bridge/src/rpc/supervisor.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+// packages/pi-bridge/src/rpc/supervisor.mjs
+import { execFileSync, spawn } from "node:child_process";
+import { constants as osConstants } from "node:os";
+var ACTIVATION_LINE = "PITA_ACTIVATE\n";
+var MAX_GATE_BYTES = 128;
+var SHUTDOWN_GRACE_MS = 3e3;
+var executable = process.env.PITA_SUPERVISOR_EXECUTABLE;
+var encodedArgs = process.env.PITA_SUPERVISOR_ARGS;
+var launchId = process.argv[2] === "--launch-id" ? process.argv[3] : void 0;
+if (executable === void 0 || encodedArgs === void 0 || launchId === void 0 || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+  launchId
+)) {
+  process.exit(70);
+}
+var args;
+try {
+  const parsed = JSON.parse(encodedArgs);
+  if (!Array.isArray(parsed) || !parsed.every((value) => typeof value === "string")) {
+    throw new Error("invalid args");
+  }
+  args = parsed;
+} catch {
+  process.exit(70);
+}
+var child = null;
+var gate = Buffer.alloc(0);
+var shuttingDown = false;
+var gracefulTimer = null;
+var exitCode = 0;
+function groupMembers() {
+  try {
+    const output = execFileSync("ps", ["-axo", "pid=,pgid=,stat="], {
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C", LANG: "C" },
+      timeout: 1e3,
+      maxBuffer: 1024 * 1024,
+      // Otherwise the ps probe inherits this supervisor's group and observes
+      // itself as the final live member forever.
+      detached: true
+    });
+    return output.split("\n").map((line) => line.trim().split(/\s+/)).filter(
+      ([pid, pgid, stat]) => Number(pid) !== process.pid && Number(pgid) === process.pid && stat !== void 0 && !stat.startsWith("Z")
+    ).map(([pid]) => Number(pid)).filter((pid) => Number.isSafeInteger(pid) && pid > 0);
+  } catch {
+    return [1];
+  }
+}
+function finishWhenGroupIsEmpty(deadline) {
+  if (groupMembers().length === 0) process.exit(exitCode);
+  if (Date.now() >= deadline) {
+    try {
+      process.kill(-process.pid, "SIGKILL");
+    } catch {
+      process.exit(1);
+    }
+    return;
+  }
+  setTimeout(() => finishWhenGroupIsEmpty(deadline), 25);
+}
+function shutdown(code = exitCode) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  exitCode = code;
+  if (gracefulTimer !== null) clearTimeout(gracefulTimer);
+  gracefulTimer = null;
+  if (child !== null) process.stdin.unpipe(child.stdin);
+  try {
+    process.kill(-process.pid, "SIGTERM");
+  } catch (error) {
+    if (error?.code !== "ESRCH") exitCode = 1;
+  }
+  finishWhenGroupIsEmpty(Date.now() + SHUTDOWN_GRACE_MS);
+}
+function beginGracefulShutdown() {
+  if (shuttingDown || gracefulTimer !== null) return;
+  if (child === null) process.exit(0);
+  process.stdin.unpipe(child.stdin);
+  child.stdin.end();
+  gracefulTimer = setTimeout(() => shutdown(), SHUTDOWN_GRACE_MS);
+}
+function childResult(code, signal) {
+  if (code !== null) return code;
+  const signalNumber = signal === null ? void 0 : osConstants.signals[signal];
+  return signalNumber === void 0 ? 1 : 128 + signalNumber;
+}
+process.on("SIGTERM", () => shutdown());
+process.on("SIGINT", () => shutdown());
+process.stdout.on("error", () => shutdown(1));
+process.stderr.on("error", () => shutdown(1));
+process.on("uncaughtException", () => shutdown(1));
+function activate(remainder) {
+  const childEnv = { ...process.env };
+  delete childEnv.PITA_SUPERVISOR_EXECUTABLE;
+  delete childEnv.PITA_SUPERVISOR_ARGS;
+  delete childEnv.PITA_SUPERVISOR_IGNORE_EOF;
+  child = spawn(executable, args, {
+    cwd: process.cwd(),
+    env: childEnv,
+    shell: false,
+    detached: false,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdout?.pipe(process.stdout);
+  child.stderr?.pipe(process.stderr);
+  child.stdin?.on("error", () => shutdown(72));
+  if (remainder.length > 0) child.stdin?.write(remainder);
+  process.stdin.pipe(child.stdin);
+  child.on("error", () => shutdown(71));
+  child.on("exit", (code, signal) => shutdown(childResult(code, signal)));
+}
+function onGateData(chunk) {
+  gate = Buffer.concat([gate, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+  if (gate.length > MAX_GATE_BYTES) process.exit(70);
+  const newline = gate.indexOf(10);
+  if (newline < 0) return;
+  process.stdin.off("data", onGateData);
+  const line = gate.subarray(0, newline + 1).toString("utf8");
+  if (line !== ACTIVATION_LINE) process.exit(70);
+  activate(gate.subarray(newline + 1));
+  gate = Buffer.alloc(0);
+}
+process.stdin.on("data", onGateData);
+process.stdin.on("end", () => {
+  if (child === null) process.exit(0);
+  if (process.env.PITA_SUPERVISOR_IGNORE_EOF !== "1") beginGracefulShutdown();
+});
+process.stdin.resume();

package/dist/packages/pi-bridge/src/rpc/tool-events.js

@@ -0,0 +1,78 @@
+// packages/pi-bridge/src/rpc/tool-events.ts
+import { z } from "zod";
+import { boundedToolText, extractToolCalls, toolCallProjection, toolResultText } from "../tool-activity.js";
+var resultMessageSchema = z.object({
+  role: z.literal("toolResult"),
+  toolCallId: z.string().min(1).max(500),
+  toolName: z.string().min(1).max(200),
+  content: z.unknown(),
+  isError: z.boolean()
+});
+function extractToolResult(message) {
+  const parsed = resultMessageSchema.safeParse(message);
+  if (!parsed.success) return void 0;
+  const output = toolResultText(parsed.data.content);
+  return {
+    toolCallId: parsed.data.toolCallId,
+    name: boundedToolText(parsed.data.toolName, 200).text,
+    output: output.text,
+    omittedChars: output.omitted,
+    isError: parsed.data.isError
+  };
+}
+var executionSchema = z.object({
+  type: z.enum(["tool_execution_start", "tool_execution_update", "tool_execution_end"]),
+  toolCallId: z.string().min(1).max(500),
+  toolName: z.string().min(1).max(200),
+  args: z.unknown().optional(),
+  partialResult: z.object({ content: z.unknown() }).optional(),
+  result: z.object({ content: z.unknown() }).optional(),
+  isError: z.boolean().optional()
+});
+var ToolEventProjection = class {
+  #pending = /* @__PURE__ */ new Map();
+  accept(record) {
+    if (record.type === "message_end") {
+      const message = z.object({ role: z.string(), content: z.unknown() }).safeParse(record.message);
+      if (message.success && message.data.role === "assistant") {
+        const calls = extractToolCalls(message.data.content);
+        for (const call3 of calls) this.#remember(call3);
+        return calls;
+      }
+      const result = extractToolResult(record.message);
+      const call2 = result && this.#pending.get(result.toolCallId);
+      if (call2 && result) {
+        this.#pending.delete(call2.toolCallId);
+        return [{ ...call2, status: result.isError ? "failed" : "succeeded", output: result.output, outputOmittedChars: result.omittedChars }];
+      }
+      return [];
+    }
+    if (record.type === "agent_end" || record.type === "agent_settled") {
+      const interrupted = [...this.#pending.values()].map((call2) => ({ ...call2, status: "incomplete" }));
+      this.#pending.clear();
+      return interrupted;
+    }
+    const parsed = executionSchema.safeParse(record);
+    if (!parsed.success) return [];
+    const event = parsed.data;
+    if (event.type === "tool_execution_end" && (event.result === void 0 || event.isError === void 0)) return [];
+    const call = this.#pending.get(event.toolCallId) ?? toolCallProjection(event.toolCallId, event.toolName, event.args);
+    const output = toolResultText((event.result ?? event.partialResult)?.content);
+    const next = {
+      ...call,
+      status: event.type === "tool_execution_end" ? event.isError ? "failed" : "succeeded" : "running",
+      ...event.result || event.partialResult ? { output: output.text, outputOmittedChars: output.omitted } : {}
+    };
+    if (event.type === "tool_execution_end") this.#pending.delete(call.toolCallId);
+    else this.#remember(next);
+    return [next];
+  }
+  #remember(call) {
+    this.#pending.set(call.toolCallId, call);
+    if (this.#pending.size > 200) this.#pending.delete(this.#pending.keys().next().value);
+  }
+};
+export {
+  ToolEventProjection,
+  extractToolResult
+};