pi-webdesk 0.1.0

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

@@ -0,0 +1,263 @@
+// packages/pi-bridge/src/rpc/wire.ts
+import { z } from "zod";
+import { PiBridgeError } from "../errors.js";
+var rpcResponseSchema = z.looseObject({
+  type: z.literal("response"),
+  id: z.string().optional(),
+  command: z.string(),
+  success: z.boolean(),
+  data: z.unknown().optional(),
+  error: z.string().optional()
+});
+var rpcExtensionUiRequestSchema = z.looseObject({
+  type: z.literal("extension_ui_request"),
+  id: z.string(),
+  method: z.string().min(1),
+  title: z.string().optional(),
+  message: z.string().optional(),
+  options: z.array(z.string()).optional(),
+  placeholder: z.string().optional(),
+  prefill: z.string().optional(),
+  timeout: z.number().optional(),
+  notifyType: z.enum(["info", "warning", "error"]).optional(),
+  statusKey: z.string().optional(),
+  statusText: z.string().optional()
+});
+var rpcEventSchema = z.looseObject({
+  type: z.string().min(1)
+});
+var rpcExtensionErrorEventSchema = z.looseObject({
+  type: z.literal("extension_error"),
+  extensionPath: z.string().optional(),
+  event: z.string().optional(),
+  error: z.string().optional()
+});
+function classifyRpcRecord(value) {
+  const base = rpcEventSchema.safeParse(value);
+  if (!base.success) {
+    throw new PiBridgeError(
+      "PI_PROTOCOL_VIOLATION",
+      "Pi RPC record is not an object with a string `type`",
+      { details: { record: value } }
+    );
+  }
+  if (base.data.type === "response") {
+    const response = rpcResponseSchema.safeParse(value);
+    if (!response.success) {
+      throw new PiBridgeError(
+        "PI_PROTOCOL_VIOLATION",
+        `Pi RPC response record is malformed: ${response.error.message}`
+      );
+    }
+    return { kind: "response", record: response.data };
+  }
+  if (base.data.type === "extension_ui_request") {
+    const request = rpcExtensionUiRequestSchema.safeParse(value);
+    if (!request.success) {
+      throw new PiBridgeError(
+        "PI_PROTOCOL_VIOLATION",
+        `Pi RPC extension_ui_request record is malformed: ${request.error.message}`
+      );
+    }
+    return { kind: "extension_ui_request", record: request.data };
+  }
+  return { kind: "event", record: base.data };
+}
+var getStateDataSchema = z.looseObject({
+  model: z.looseObject({
+    id: z.string(),
+    name: z.string().optional(),
+    provider: z.string().optional()
+  }).nullable().optional(),
+  isStreaming: z.boolean(),
+  messageCount: z.number().int().min(0),
+  sessionFile: z.string().nullable().optional(),
+  sessionId: z.string().nullable().optional(),
+  sessionName: z.string().optional()
+});
+var wireModelSchema = z.looseObject({
+  id: z.string().min(1),
+  name: z.string().optional(),
+  provider: z.string().optional()
+});
+var getAvailableModelsDataSchema = z.looseObject({
+  models: z.array(wireModelSchema)
+});
+var entryMessageSchema = z.looseObject({
+  role: z.string().min(1).max(100),
+  content: z.unknown().optional()
+});
+var entrySchema = z.looseObject({
+  type: z.string().min(1).max(100),
+  id: z.string().min(1).max(500),
+  parentId: z.string().min(1).max(500).nullable().optional(),
+  message: entryMessageSchema.optional()
+});
+function extractEntryText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  let text = "";
+  for (const block of content) {
+    if (typeof block === "object" && block !== null && block["type"] === "text" && typeof block["text"] === "string") {
+      text += block["text"];
+    }
+  }
+  return text === "" ? null : text;
+}
+var getEntriesDataSchema = z.looseObject({
+  entries: z.array(entrySchema),
+  leafId: z.string().nullable()
+});
+var MAX_WIRE_SESSION_TREE_NODES = 500;
+var MAX_WIRE_SESSION_TREE_DEPTH = 64;
+var MAX_WIRE_SESSION_TREE_SCAN_NODES = 1e5;
+var treeEnvelopeSchema = z.looseObject({
+  tree: z.array(z.unknown()),
+  leafId: z.string().min(1).max(500).nullable()
+});
+var shallowTreeNodeSchema = z.looseObject({
+  entry: entrySchema,
+  children: z.array(z.unknown()),
+  label: z.string().max(500).optional()
+});
+var getTreeDataSchema = {
+  safeParse(value) {
+    const envelope = treeEnvelopeSchema.safeParse(value);
+    if (!envelope.success) return envelope;
+    const flat = [];
+    const rootIndexes = [];
+    const byId = /* @__PURE__ */ new Map();
+    const pending = [];
+    let maxDepth = 0;
+    for (let index = envelope.data.tree.length - 1; index >= 0; index--) {
+      pending.push({
+        raw: envelope.data.tree[index],
+        parentIndex: null,
+        depth: 0
+      });
+    }
+    while (pending.length > 0 && flat.length < MAX_WIRE_SESSION_TREE_SCAN_NODES) {
+      const next = pending.pop();
+      const parsed = shallowTreeNodeSchema.safeParse(next.raw);
+      if (!parsed.success) {
+        return { success: false, error: { message: parsed.error.message } };
+      }
+      const nodeIndex = flat.length;
+      flat.push({
+        entry: parsed.data.entry,
+        children: [],
+        ...parsed.data.label === void 0 ? {} : { label: parsed.data.label },
+        depth: next.depth
+      });
+      maxDepth = Math.max(maxDepth, next.depth);
+      if (!byId.has(parsed.data.entry.id)) byId.set(parsed.data.entry.id, nodeIndex);
+      if (next.parentIndex === null) {
+        rootIndexes.push(nodeIndex);
+      } else {
+        flat[next.parentIndex].children.push(nodeIndex);
+      }
+      for (let index = parsed.data.children.length - 1; index >= 0; index--) {
+        pending.push({
+          raw: parsed.data.children[index],
+          parentIndex: nodeIndex,
+          depth: next.depth + 1
+        });
+      }
+    }
+    const completeAndBounded = pending.length === 0 && flat.length <= MAX_WIRE_SESSION_TREE_NODES && maxDepth < MAX_WIRE_SESSION_TREE_DEPTH;
+    const makeNode = (index) => {
+      const source = flat[index];
+      return {
+        entry: source.entry,
+        children: [],
+        ...source.label === void 0 ? {} : { label: source.label }
+      };
+    };
+    const project = (indexes) => {
+      const roots2 = indexes.map(makeNode);
+      const work = indexes.map((index, position) => ({
+        index,
+        target: roots2[position]
+      }));
+      while (work.length > 0) {
+        const { index, target } = work.pop();
+        target.children = flat[index].children.map(makeNode);
+        for (let child = 0; child < flat[index].children.length; child++) {
+          work.push({
+            index: flat[index].children[child],
+            target: target.children[child]
+          });
+        }
+      }
+      return roots2;
+    };
+    let roots;
+    if (completeAndBounded) {
+      roots = project(rootIndexes);
+    } else {
+      const activePath = [];
+      const visited = /* @__PURE__ */ new Set();
+      let cursor = envelope.data.leafId;
+      while (cursor !== null && !visited.has(cursor)) {
+        visited.add(cursor);
+        const index = byId.get(cursor);
+        if (index === void 0) break;
+        activePath.push(index);
+        cursor = flat[index].entry.parentId ?? null;
+      }
+      activePath.reverse();
+      const retainedPath = activePath.slice(-MAX_WIRE_SESSION_TREE_DEPTH);
+      if (retainedPath.length > 0) {
+        roots = [makeNode(retainedPath[0])];
+        let target = roots[0];
+        for (let index = 1; index < retainedPath.length; index++) {
+          const child = makeNode(retainedPath[index]);
+          target.children = [child];
+          target = child;
+        }
+      } else {
+        roots = [];
+        const work = rootIndexes.slice().reverse().map((index) => ({ index, target: roots, depth: 0 }));
+        let emitted = 0;
+        while (work.length > 0 && emitted < MAX_WIRE_SESSION_TREE_NODES) {
+          const { index, target, depth } = work.pop();
+          const node = makeNode(index);
+          target.push(node);
+          emitted++;
+          if (depth + 1 >= MAX_WIRE_SESSION_TREE_DEPTH) continue;
+          const children = flat[index].children;
+          for (let child = children.length - 1; child >= 0; child--) {
+            work.push({
+              index: children[child],
+              target: node.children,
+              depth: depth + 1
+            });
+          }
+        }
+      }
+    }
+    return {
+      success: true,
+      data: {
+        tree: roots,
+        leafId: envelope.data.leafId,
+        truncated: !completeAndBounded
+      }
+    };
+  }
+};
+export {
+  MAX_WIRE_SESSION_TREE_DEPTH,
+  MAX_WIRE_SESSION_TREE_NODES,
+  classifyRpcRecord,
+  extractEntryText,
+  getAvailableModelsDataSchema,
+  getEntriesDataSchema,
+  getStateDataSchema,
+  getTreeDataSchema,
+  rpcEventSchema,
+  rpcExtensionErrorEventSchema,
+  rpcExtensionUiRequestSchema,
+  rpcResponseSchema,
+  wireModelSchema
+};

package/dist/packages/pi-bridge/src/sessions-child.mjs

@@ -0,0 +1,38 @@
+// packages/pi-bridge/src/sessions-child.mjs
+import process from "node:process";
+import {
+  forkPiSessionInProcess,
+  inspectPiSessionsInProcess
+} from "./sessions.js";
+var MAX_REQUEST_BYTES = 16 * 1024;
+var input = "";
+process.stdin.setEncoding("utf8");
+for await (const chunk of process.stdin) {
+  input += chunk;
+  if (Buffer.byteLength(input, "utf8") > MAX_REQUEST_BYTES) {
+    process.exitCode = 1;
+    break;
+  }
+}
+if (process.exitCode !== 1) {
+  try {
+    const request = JSON.parse(input);
+    if (request?.operation === "list") {
+      process.stdout.write(JSON.stringify(await inspectPiSessionsInProcess()));
+    } else if (request?.operation === "fork" && typeof request.sourcePath === "string" && typeof request.targetCwd === "string" && (request.sessionId === void 0 || typeof request.sessionId === "string")) {
+      process.stdout.write(
+        JSON.stringify(
+          await forkPiSessionInProcess({
+            sourcePath: request.sourcePath,
+            targetCwd: request.targetCwd,
+            ...request.sessionId === void 0 ? {} : { sessionId: request.sessionId }
+          })
+        )
+      );
+    } else {
+      throw new Error("invalid operation");
+    }
+  } catch {
+    process.exitCode = 1;
+  }
+}

package/dist/packages/pi-bridge/src/sessions.js

@@ -0,0 +1,314 @@
+// packages/pi-bridge/src/sessions.ts
+import { spawn } from "node:child_process";
+import { open } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  SessionManager,
+  SettingsManager,
+  getAgentDir,
+  parseSessionEntries
+} from "@earendil-works/pi-coding-agent";
+import { z } from "zod";
+import { PiBridgeError } from "./errors.js";
+var DEFAULT_LIST_TIMEOUT_MS = 15e3;
+var DEFAULT_FORK_TIMEOUT_MS = 3e4;
+var MAX_CHILD_OUTPUT_BYTES = 2 * 1024 * 1024;
+var MAX_CHILD_ERROR_BYTES = 64 * 1024;
+var MAX_CATALOG_SERIALIZED_ENTRY_BYTES = 14e5;
+var MAX_SOURCE_SESSION_BYTES = 128 * 1024 * 1024;
+var MAX_SOURCE_HEADER_BYTES = 64 * 1024;
+var MAX_PI_SESSION_CATALOG_ENTRIES = 200;
+var PI_SESSION_DIRECTORY_ENV = "PI_CODING_AGENT_SESSION_DIR";
+var catalogEntrySchema = z.object({
+  path: z.string().min(1).max(4096).refine(path.isAbsolute),
+  id: z.string().min(1).max(500),
+  cwd: z.string().min(1).max(4096).refine(path.isAbsolute),
+  name: z.string().min(1).max(200).nullable(),
+  createdAtMs: z.number().int().nonnegative(),
+  modifiedAtMs: z.number().int().nonnegative(),
+  messageCount: z.number().int().nonnegative(),
+  firstMessage: z.string().max(500)
+}).strict();
+var sourceHeaderSchema = z.object({
+  type: z.literal("session"),
+  version: z.literal(3),
+  id: z.string().min(1).max(500),
+  cwd: z.string().min(1).max(4096).refine(path.isAbsolute)
+}).passthrough();
+var catalogInspectionSchema = z.object({
+  sessionsRoot: z.string(),
+  sessions: z.array(catalogEntrySchema).max(MAX_PI_SESSION_CATALOG_ENTRIES),
+  omitted: z.number().int().nonnegative()
+}).strict();
+var forkResultSchema = z.object({
+  sessionFile: z.string(),
+  sessionId: z.string(),
+  cwd: z.string(),
+  parentSession: z.string().nullable(),
+  sourceSessionId: z.string(),
+  sourceCwd: z.string()
+}).strict();
+function expandHome(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith(`~${path.sep}`)) return path.join(os.homedir(), value.slice(2));
+  return value;
+}
+function configuredSessionDir(explicit, env = process.env, cwd = process.cwd(), agentDir = getAgentDir()) {
+  const explicitDirectory = explicit?.trim() ? explicit : void 0;
+  const environmentDirectory = env[PI_SESSION_DIRECTORY_ENV]?.trim() ? env[PI_SESSION_DIRECTORY_ENV] : void 0;
+  const configured = explicitDirectory ?? environmentDirectory ?? SettingsManager.create(cwd, agentDir).getSessionDir();
+  return configured === void 0 || configured.trim() === "" ? void 0 : path.resolve(cwd, expandHome(configured));
+}
+function sessionsRoot(sessionDir) {
+  return sessionDir ?? path.join(getAgentDir(), "sessions");
+}
+async function inspectPiSessionsInProcess(options = {}) {
+  const sessionDir = configuredSessionDir(
+    options.sessionDir,
+    options.env,
+    options.cwd,
+    options.agentDir
+  );
+  const all = await SessionManager.listAll(sessionDir);
+  const selected = [];
+  let serializedEntryBytes = 0;
+  for (const session of all.slice(0, MAX_PI_SESSION_CATALOG_ENTRIES)) {
+    try {
+      await inspectSourceHeaderReadOnly(path.normalize(session.path));
+      const createdAtMs = session.created.getTime();
+      const modifiedAtMs = session.modified.getTime();
+      if (!Number.isSafeInteger(createdAtMs) || createdAtMs < 0 || !Number.isSafeInteger(modifiedAtMs) || modifiedAtMs < 0 || !Number.isSafeInteger(session.messageCount) || session.messageCount < 0) {
+        continue;
+      }
+      const parsed = catalogEntrySchema.safeParse({
+        path: path.normalize(session.path),
+        id: session.id,
+        cwd: path.normalize(session.cwd),
+        name: session.name === void 0 || session.name === null ? null : session.name.slice(0, 200) || null,
+        createdAtMs,
+        modifiedAtMs,
+        messageCount: session.messageCount,
+        firstMessage: session.firstMessage.slice(0, 500)
+      });
+      if (!parsed.success) continue;
+      const entryBytes = Buffer.byteLength(JSON.stringify(parsed.data), "utf8");
+      if (serializedEntryBytes + entryBytes > MAX_CATALOG_SERIALIZED_ENTRY_BYTES) continue;
+      serializedEntryBytes += entryBytes;
+      selected.push(parsed.data);
+    } catch {
+    }
+  }
+  return {
+    sessionsRoot: path.normalize(sessionsRoot(sessionDir)),
+    sessions: selected,
+    omitted: Math.max(0, all.length - selected.length)
+  };
+}
+async function inspectSourceHeaderReadOnly(sourcePath) {
+  const handle = await open(sourcePath, "r");
+  try {
+    const details = await handle.stat();
+    if (!details.isFile() || details.size > MAX_SOURCE_SESSION_BYTES) {
+      throw new PiBridgeError(
+        "PI_INVALID_CONFIGURATION",
+        "Pi source session is not a bounded regular file"
+      );
+    }
+    const buffer = Buffer.alloc(Math.min(MAX_SOURCE_HEADER_BYTES, Math.max(1, details.size)));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const entries = parseSessionEntries(buffer.subarray(0, bytesRead).toString("utf8"));
+    const parsed = sourceHeaderSchema.safeParse(entries[0]);
+    if (!parsed.success) {
+      throw new PiBridgeError(
+        "PI_PROTOCOL_VIOLATION",
+        "Pi source session is not in the supported current format",
+        { cause: parsed.error }
+      );
+    }
+    return { id: parsed.data.id, cwd: path.normalize(parsed.data.cwd) };
+  } finally {
+    await handle.close();
+  }
+}
+async function forkPiSessionInProcess(options) {
+  if (!path.isAbsolute(options.sourcePath) || !path.isAbsolute(options.targetCwd)) {
+    throw new PiBridgeError(
+      "PI_INVALID_CONFIGURATION",
+      "Pi session continuation requires absolute source and target paths"
+    );
+  }
+  const sessionDir = configuredSessionDir(
+    options.sessionDir,
+    options.env,
+    options.cwd,
+    options.agentDir
+  );
+  const source = await inspectSourceHeaderReadOnly(path.normalize(options.sourcePath));
+  const manager = SessionManager.forkFrom(
+    path.normalize(options.sourcePath),
+    path.normalize(options.targetCwd),
+    sessionDir,
+    options.sessionId === void 0 ? void 0 : { id: options.sessionId }
+  );
+  const sessionFile = manager.getSessionFile();
+  if (sessionFile === void 0) {
+    throw new PiBridgeError(
+      "PI_PROTOCOL_VIOLATION",
+      "Pi did not return a persistent child session file"
+    );
+  }
+  const header = manager.getHeader();
+  return {
+    sessionFile: path.normalize(sessionFile),
+    sessionId: manager.getSessionId(),
+    cwd: manager.getCwd(),
+    parentSession: header?.parentSession ?? null,
+    sourceSessionId: source.id,
+    sourceCwd: source.cwd
+  };
+}
+function validateTimeout(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 6e4) {
+    throw new PiBridgeError("PI_INVALID_CONFIGURATION", `${label} timeout is invalid`);
+  }
+}
+function killChild(child) {
+  try {
+    child.kill("SIGKILL");
+  } catch {
+  }
+}
+function runChild(options) {
+  return new Promise((resolve, reject) => {
+    const child = options.spawnProcess(process.execPath, [options.childPath], {
+      env: { ...options.env, PI_OFFLINE: "1" },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = Buffer.alloc(0);
+    let stderrBytes = 0;
+    let settled = false;
+    const finish = (operation) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      operation();
+    };
+    const timer = setTimeout(() => {
+      killChild(child);
+      finish(
+        () => reject(new PiBridgeError("PI_REQUEST_TIMEOUT", `${options.operation} timed out`))
+      );
+    }, options.timeoutMs);
+    timer.unref?.();
+    child.stdout.on("data", (chunk) => {
+      if (settled) return;
+      if (stdout.length + chunk.length > MAX_CHILD_OUTPUT_BYTES) {
+        killChild(child);
+        finish(
+          () => reject(
+            new PiBridgeError(
+              "PI_PROTOCOL_VIOLATION",
+              `${options.operation} exceeded its output bound`
+            )
+          )
+        );
+        return;
+      }
+      stdout = Buffer.concat([stdout, chunk]);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrBytes += chunk.length;
+      if (stderrBytes > MAX_CHILD_ERROR_BYTES) killChild(child);
+    });
+    child.on("error", (error) => {
+      finish(
+        () => reject(
+          new PiBridgeError("PI_SPAWN_FAILED", `${options.operation} could not start`, {
+            cause: error
+          })
+        )
+      );
+    });
+    child.on("close", (code, signal) => {
+      finish(() => {
+        if (code !== 0 || signal !== null) {
+          reject(
+            new PiBridgeError("PI_RUNTIME_EXITED", `${options.operation} did not complete`, {
+              details: { code, signal }
+            })
+          );
+          return;
+        }
+        let decoded;
+        try {
+          decoded = JSON.parse(stdout.toString("utf8"));
+        } catch (error) {
+          reject(
+            new PiBridgeError("PI_PROTOCOL_VIOLATION", `${options.operation} returned invalid JSON`, {
+              cause: error
+            })
+          );
+          return;
+        }
+        const parsed = options.schema.safeParse(decoded);
+        if (!parsed.success) {
+          reject(
+            new PiBridgeError(
+              "PI_PROTOCOL_VIOLATION",
+              `${options.operation} returned incompatible data`,
+              { cause: parsed.error }
+            )
+          );
+          return;
+        }
+        resolve(parsed.data);
+      });
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(JSON.stringify(options.request));
+  });
+}
+function createPiSessionCatalog(options = {}) {
+  const listTimeoutMs = options.listTimeoutMs ?? DEFAULT_LIST_TIMEOUT_MS;
+  const forkTimeoutMs = options.forkTimeoutMs ?? DEFAULT_FORK_TIMEOUT_MS;
+  validateTimeout(listTimeoutMs, "Pi session discovery");
+  validateTimeout(forkTimeoutMs, "Pi session continuation");
+  const childPath = options.childPath ?? fileURLToPath(new URL("./sessions-child.mjs", import.meta.url));
+  const spawnProcess = options.spawnProcess ?? spawn;
+  const env = options.env ?? process.env;
+  return {
+    list: () => runChild({
+      childPath,
+      spawnProcess,
+      env,
+      timeoutMs: listTimeoutMs,
+      request: { operation: "list" },
+      schema: catalogInspectionSchema,
+      operation: "Pi session discovery"
+    }),
+    fork: (sourcePath, targetCwd, sessionId) => runChild({
+      childPath,
+      spawnProcess,
+      env,
+      timeoutMs: forkTimeoutMs,
+      request: {
+        operation: "fork",
+        sourcePath: path.normalize(sourcePath),
+        targetCwd: path.normalize(targetCwd),
+        ...sessionId === void 0 ? {} : { sessionId }
+      },
+      schema: forkResultSchema,
+      operation: "Pi session continuation"
+    })
+  };
+}
+export {
+  MAX_PI_SESSION_CATALOG_ENTRIES,
+  PI_SESSION_DIRECTORY_ENV,
+  createPiSessionCatalog,
+  forkPiSessionInProcess,
+  inspectPiSessionsInProcess
+};

package/dist/packages/pi-bridge/src/tool-activity.js

@@ -0,0 +1,56 @@
+// packages/pi-bridge/src/tool-activity.ts
+import { z } from "zod";
+import { sanitizeApprovalDisplayText } from "./policy-approval.js";
+var callSchema = z.object({
+  type: z.literal("toolCall"),
+  id: z.string().min(1).max(500),
+  name: z.string().min(1).max(200),
+  arguments: z.unknown().optional()
+});
+function boundedToolText(raw, limit = 2e4) {
+  const prefix = raw.slice(0, limit);
+  const safe = sanitizeApprovalDisplayText(prefix);
+  return { text: safe.slice(0, limit), omitted: raw.length - prefix.length + Math.max(0, safe.length - limit) };
+}
+function toolCallProjection(id, name, args) {
+  const input = boundedToolText(JSON.stringify(args ?? {}, null, 2));
+  const path = args !== null && typeof args === "object" && "path" in args && typeof args.path === "string" ? boundedToolText(args.path, 4096).text : void 0;
+  return {
+    toolCallId: id,
+    name: boundedToolText(name, 200).text,
+    status: "queued",
+    input: input.text,
+    output: "",
+    inputOmittedChars: input.omitted,
+    outputOmittedChars: 0,
+    ...path === void 0 ? {} : { path }
+  };
+}
+function extractToolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((block) => {
+    const call = callSchema.safeParse(block);
+    return call.success ? [toolCallProjection(call.data.id, call.data.name, call.data.arguments)] : [];
+  });
+}
+function toolResultText(content) {
+  if (typeof content === "string") return boundedToolText(content);
+  if (!Array.isArray(content)) return { text: "", omitted: 0 };
+  let text = "";
+  let omitted = 0;
+  for (const block of content) {
+    if (block === null || typeof block !== "object") continue;
+    const value = block.type === "text" && typeof block.text === "string" ? block.text : block.type === "image" ? "[Image result]" : "";
+    if (!value) continue;
+    const projected = boundedToolText(`${text || omitted ? "\n" : ""}${value}`, Math.max(0, 2e4 - text.length));
+    text += projected.text;
+    omitted += projected.omitted;
+  }
+  return { text, omitted };
+}
+export {
+  boundedToolText,
+  extractToolCalls,
+  toolCallProjection,
+  toolResultText
+};