@ycodium-ai/agent-pi 0.0.0-stage → 0.2.3576

package/dist/index.js

@@ -0,0 +1,1388 @@
+// src/index.ts
+import { definePlugin } from "@ycodium-ai/plugin-api";
+
+// src/config.ts
+import * as NodeCrypto from "node:crypto";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+// src/protocol.ts
+var PI_API_PROTOCOLS = [
+  "openai-completions",
+  "openai-responses",
+  "anthropic-messages"
+];
+var DEFAULT_PI_API_PROTOCOL = "openai-completions";
+function isPiApiProtocol(value) {
+  return PI_API_PROTOCOLS.some((protocol) => protocol === value);
+}
+function readPiApiProtocol(value) {
+  if (value === void 0) return DEFAULT_PI_API_PROTOCOL;
+  if (isPiApiProtocol(value)) return value;
+  throw new Error("Unsupported Pi API protocol.");
+}
+
+// src/config.ts
+var PI_API_KEY_ENV = "YCODIUM_PI_API_KEY";
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+var string = (value) => typeof value === "string" ? value : "";
+function parseConfig(value, instanceId) {
+  const envelope = record(value);
+  const config = record(envelope.config ?? value);
+  const environment = Object.fromEntries(
+    (Array.isArray(envelope.environment) ? envelope.environment : []).map((row) => {
+      const entry = record(row);
+      return [string(entry.name), string(entry.value)];
+    }).filter(([name]) => name)
+  );
+  const configuredHome = string(config.homePath).trim();
+  const homePath = configuredHome.startsWith("~/") || configuredHome.startsWith("~\\") ? NodePath.join(NodeOS.homedir(), configuredHome.slice(2)) : configuredHome;
+  return {
+    binaryPath: string(config.binaryPath).trim() || "pi",
+    apiBaseUrl: string(config.apiBaseUrl).trim() || environment.YCODIUM_PI_API_BASE_URL?.trim() || "",
+    apiProtocol: readPiApiProtocol(config.apiProtocol),
+    model: string(config.model).trim(),
+    environment,
+    homePath: homePath ? NodePath.resolve(homePath) : NodePath.join(NodeOS.homedir(), ".pi", "ycodium", identifier(instanceId))
+  };
+}
+var identifier = (value) => NodeCrypto.createHash("sha256").update(value).digest("hex").slice(0, 32);
+function nativeApiBaseUrl(baseUrl, apiProtocol) {
+  const url = new URL(baseUrl.trim());
+  url.pathname = url.pathname.replace(/\/+$/, "");
+  if (apiProtocol === "anthropic-messages") url.pathname = url.pathname.replace(/\/v1$/, "");
+  return url.toString().replace(/\/$/, "");
+}
+function validateConnection(config) {
+  let url;
+  try {
+    url = new URL(config.apiBaseUrl);
+  } catch {
+    throw new Error("Pi API base URL is required and must be an HTTP(S) URL.");
+  }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+    throw new Error("Pi API base URL must be HTTP(S), without credentials, query or fragment.");
+  if (!config.model) throw new Error("Pi model ID is required.");
+  if (!config.environment[PI_API_KEY_ENV]?.trim()) throw new Error("Pi API key is required.");
+}
+function redact(config, value) {
+  let text = value instanceof Error ? value.message : String(value);
+  for (const secret of Object.values(config.environment).filter(Boolean).sort((a, b) => b.length - a.length))
+    text = text.replaceAll(secret, "[redacted]");
+  return text;
+}
+
+// src/card.ts
+var PI_CARD = {
+  driverKind: "pi",
+  displayName: "Pi",
+  iconUrl: "./assets/icon.svg",
+  commandName: "pi",
+  launchArgs: "",
+  homeEnvVar: "",
+  environment: [],
+  install: { kind: "npm" },
+  signIn: [],
+  deviceCodeSignInArgs: [],
+  npmPackage: "@earendil-works/pi-coding-agent",
+  homebrewFormula: "",
+  selfUpdateArgs: [],
+  docsUrl: "https://pi.dev",
+  setupNote: "setupNote",
+  defaultModel: "",
+  customModelIdExample: "",
+  modelSlugAliases: null,
+  mcpTransports: ["stdio", "http"],
+  pluginManaged: true,
+  verifiedSkills: false,
+  everydayHarness: false,
+  capabilities: {
+    sessionModelSwitch: "unsupported",
+    runtimeModeSwitch: "next-turn",
+    contextCompaction: "native",
+    turnSteering: true
+  },
+  credentialSources: [],
+  diagnostics: [],
+  configSchema: {
+    type: "object",
+    additionalProperties: true,
+    "x-ycodium-form-order": ["apiProtocol", "apiBaseUrl", "model", "binaryPath", "homePath"],
+    properties: {
+      apiProtocol: {
+        type: "string",
+        enum: PI_API_PROTOCOLS,
+        default: DEFAULT_PI_API_PROTOCOL,
+        "x-ycodium-form": {
+          titleKey: "form.apiProtocol.title",
+          descriptionKey: "form.apiProtocol.description"
+        }
+      },
+      ...Object.fromEntries(
+        ["apiBaseUrl", "model", "binaryPath", "homePath"].map((key) => [
+          key,
+          {
+            type: "string",
+            "x-ycodium-form": {
+              titleKey: `form.${key}.title`,
+              descriptionKey: `form.${key}.description`,
+              ...key === "binaryPath" ? { control: "executable-path" } : {}
+            }
+          }
+        ])
+      )
+    }
+  },
+  modelConnectivity: {
+    dialects: ["openai-chat-completions", "openai-responses", "anthropic-messages"],
+    acceptsExternalEndpoints: true,
+    baseUrlEnvKey: "YCODIUM_PI_API_BASE_URL",
+    credentialEnvKey: PI_API_KEY_ENV
+  }
+};
+
+// src/instance.ts
+import * as NodeCrypto5 from "node:crypto";
+import {
+  describeExecutorSpawnFailure,
+  ExecutorSpawnAbortedError,
+  ExecutorSpawnRefusedError,
+  isExecutorSpawnFailure
+} from "@ycodium-ai/plugin-api/executor";
+import { runProcessOperation } from "@ycodium-ai/plugin-api/process-operation";
+
+// src/connection.ts
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath2 from "node:path";
+import * as NodeCrypto2 from "node:crypto";
+import {
+  isOperationCleanupError,
+  withProcessOperation
+} from "@ycodium-ai/plugin-api/process-operation";
+
+// src/rpc.ts
+var PiResponseError = class extends Error {
+};
+var PiRpc = class {
+  pending = /* @__PURE__ */ new Map();
+  nextId = 0;
+  failure;
+  failureResult = Promise.withResolvers();
+  failed = this.failureResult.promise;
+  drained;
+  process;
+  constructor(process, onEvent) {
+    this.process = process;
+    const read = async () => {
+      const decoder = new TextDecoder("utf-8", { fatal: true });
+      let fragments = [];
+      let length = 0;
+      const consume = async (text) => {
+        let start = 0;
+        for (let end = text.indexOf("\n"); end !== -1; end = text.indexOf("\n", start)) {
+          fragments.push(text.slice(start, end));
+          length += end - start;
+          if (length > 16 * 1024 * 1024) throw new Error("Pi protocol record is too large.");
+          const line = fragments.join("");
+          fragments = [];
+          length = 0;
+          start = end + 1;
+          if (!line.trim()) continue;
+          const event = record(JSON.parse(line));
+          if (!string(event.type)) throw new Error("Invalid Pi protocol record.");
+          if (event.type === "response") {
+            const id = string(event.id), pending = this.pending.get(id);
+            if (!pending) continue;
+            this.pending.delete(id);
+            if (event.success === true) pending.resolve(event.data);
+            else
+              pending.reject(
+                new PiResponseError(string(event.error) || "Pi rejected the command.")
+              );
+          } else await onEvent(event);
+        }
+        if (start < text.length) {
+          fragments.push(text.slice(start));
+          length += text.length - start;
+          if (length > 16 * 1024 * 1024) throw new Error("Pi protocol record is too large.");
+        }
+      };
+      for await (const chunk of process.stdout)
+        await consume(decoder.decode(chunk, { stream: true }));
+      await consume(decoder.decode());
+      if (fragments.join("").trim())
+        throw new Error("Pi ended with an incomplete protocol record.");
+      this.fail(new Error("Pi protocol stream ended."));
+    };
+    const stderr = async () => {
+      for await (const _ of process.stderr) {
+      }
+    };
+    const stdout = read();
+    const readers = [stdout, stderr()].map(
+      (task) => task.catch((cause) => {
+        this.fail(cause);
+        throw cause;
+      })
+    );
+    this.drained = Promise.allSettled(readers).then((results) => {
+      const failure = results.find((result) => result.status === "rejected");
+      if (failure?.status === "rejected") throw failure.reason;
+    });
+    void this.drained.catch(() => {
+    });
+    void process.exited.then(
+      async (code) => {
+        let timer;
+        try {
+          await Promise.race([
+            stdout.catch(() => {
+            }),
+            new Promise((resolve3) => {
+              timer = setTimeout(resolve3, 1e3);
+            })
+          ]);
+          this.fail(new Error(`Pi process exited (${String(code)}).`));
+        } finally {
+          if (timer !== void 0) clearTimeout(timer);
+        }
+      },
+      (cause) => this.fail(cause)
+    ).catch((cause) => this.fail(cause));
+  }
+  fail(cause) {
+    if (this.failure) return;
+    this.failure = cause instanceof Error ? cause : new Error(String(cause));
+    this.failureResult.resolve(this.failure);
+    for (const pending of this.pending.values()) pending.reject(this.failure);
+    this.pending.clear();
+  }
+  async request(type, data = {}, signal, timeoutMs = 3e4) {
+    signal?.throwIfAborted();
+    if (this.failure) throw this.failure;
+    const id = String(++this.nextId), result = Promise.withResolvers();
+    this.pending.set(id, result);
+    const abort = () => result.reject(signal?.reason ?? new Error("Pi request cancelled."));
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    const timer = setTimeout(
+      () => result.reject(new Error(`Pi ${type} response timed out.`)),
+      timeoutMs
+    );
+    try {
+      const write = Promise.resolve().then(() => {
+        signal?.throwIfAborted();
+        return this.process.writeStdin(JSON.stringify({ ...data, type, id }) + "\n");
+      });
+      await Promise.race([write, result.promise]);
+      return await result.promise;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      this.pending.delete(id);
+    }
+  }
+  async respond(data) {
+    if (this.failure) throw this.failure;
+    let timer;
+    try {
+      await Promise.race([
+        Promise.resolve().then(
+          () => this.process.writeStdin(
+            JSON.stringify({ ...data, type: "extension_ui_response" }) + "\n"
+          )
+        ),
+        this.failed.then((cause) => {
+          throw cause;
+        }),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Pi UI response timed out.")), 3e4);
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+};
+
+// src/connection.ts
+function resumeCursor(config, input) {
+  const stored = record(input.discardResumeCursor ? void 0 : input.resumeCursor);
+  const sessionId = string(stored.sessionId);
+  const sessionDirectory = string(stored.sessionDirectory);
+  if (sessionId && sessionDirectory) {
+    if (!/^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$/.test(sessionId) || !NodePath2.isAbsolute(sessionDirectory) || NodePath2.resolve(sessionDirectory) !== NodePath2.resolve(config.homePath, "sessions"))
+      throw new Error("Invalid Pi session resume cursor.");
+    const sessionFile = string(stored.sessionFile);
+    const fileRelative = NodePath2.relative(sessionDirectory, sessionFile);
+    if (sessionFile && (!NodePath2.isAbsolute(sessionFile) || !fileRelative || fileRelative.startsWith("..") || NodePath2.isAbsolute(fileRelative)))
+      throw new Error("Invalid Pi session resume cursor.");
+    return { sessionId, sessionDirectory, ...sessionFile ? { sessionFile } : {} };
+  }
+  if (Object.keys(stored).length) throw new Error("Invalid Pi session resume cursor.");
+  return {
+    sessionId: `ycodium-${identifier(input.threadId)}${input.discardResumeCursor ? `-${identifier(NodeCrypto2.randomUUID())}` : ""}`,
+    sessionDirectory: NodePath2.join(config.homePath, "sessions")
+  };
+}
+function initializeResumeCursor(cursor, state) {
+  const sessionFile = string(state.sessionFile);
+  if (!sessionFile || !NodePath2.isAbsolute(sessionFile)) return;
+  const relative2 = NodePath2.relative(cursor.sessionDirectory, sessionFile);
+  if (!relative2 || relative2.startsWith("..") || NodePath2.isAbsolute(relative2))
+    throw new Error("Invalid Pi session file location.");
+  if (cursor.sessionFile && NodePath2.resolve(cursor.sessionFile) !== NodePath2.resolve(sessionFile))
+    throw new Error("Pi resumed a different session file.");
+  cursor.sessionFile = sessionFile;
+}
+async function createLaunch(config, input, cursor) {
+  const apiProtocol = config.apiProtocol;
+  const baseUrl = nativeApiBaseUrl(config.apiBaseUrl, apiProtocol);
+  await NodeFSP.mkdir(config.homePath, { recursive: true });
+  const directory = await NodeFSP.mkdtemp(NodePath2.join(config.homePath, "launch-"));
+  try {
+    await NodeFSP.writeFile(
+      NodePath2.join(directory, "models.json"),
+      JSON.stringify({
+        providers: {
+          ycodium: {
+            baseUrl,
+            api: apiProtocol,
+            apiKey: `\${${PI_API_KEY_ENV}}`,
+            models: [{ id: config.model }]
+          }
+        }
+      }),
+      { mode: 384 }
+    );
+    const servers = Object.fromEntries(
+      (input?.mcpServers ?? []).map((server) => {
+        const t = server.transport;
+        if (t.type === "sse") throw new Error("Pi does not support legacy SSE MCP servers.");
+        return [
+          server.name,
+          t.type === "stdio" ? {
+            command: t.command,
+            args: t.args ?? [],
+            env: t.env ?? {},
+            cwd: input?.cwd,
+            exposure: "deferred"
+          } : { url: t.url, headers: t.headers ?? {}, exposure: "deferred" }
+        ];
+      })
+    );
+    await NodeFSP.writeFile(
+      NodePath2.join(directory, "mcp.json"),
+      JSON.stringify({ mcpServers: servers }),
+      { mode: 384 }
+    );
+    const args = [
+      "--mode",
+      "rpc",
+      "--no-approve",
+      "--model",
+      `ycodium/${config.model}`,
+      "--no-extensions",
+      "--no-skills"
+    ];
+    if (cursor) {
+      await NodeFSP.mkdir(cursor.sessionDirectory, { recursive: true });
+      args.push("--session-dir", cursor.sessionDirectory, "--session-id", cursor.sessionId);
+    } else args.push("--no-session", "--no-prompt-templates", "--no-context-files");
+    if (input?.mcpServers?.length) args.push("-e", "builtin:mcp", "-e", "builtin:tool-search");
+    if (input?.skills)
+      for (const name of input.skills.names) {
+        const skill = NodePath2.resolve(input.skills.skillsDir, name);
+        const relative2 = NodePath2.relative(NodePath2.resolve(input.skills.skillsDir), skill);
+        if (!relative2 || relative2.startsWith("..") || NodePath2.isAbsolute(relative2))
+          throw new Error("Invalid Pi skill path.");
+        args.push("--skill", skill);
+      }
+    return {
+      directory,
+      args,
+      env: {
+        ...config.environment,
+        PI_CODING_AGENT_DIR: directory,
+        PI_OFFLINE: "1",
+        PI_SKIP_VERSION_CHECK: "1"
+      }
+    };
+  } catch (cause) {
+    await NodeFSP.rm(directory, { recursive: true, force: true });
+    throw cause;
+  }
+}
+async function openConnection(input) {
+  input.signal?.throwIfAborted();
+  if (input.start?.resumeCursor && !input.start.discardResumeCursor && !input.cursor?.sessionFile)
+    throw Object.assign(new Error("The Pi session file no longer exists."), {
+      code: "resume-thread-missing"
+    });
+  if (input.cursor?.sessionFile) {
+    try {
+      if (!(await NodeFSP.stat(input.cursor.sessionFile)).isFile())
+        throw Object.assign(new Error("Invalid Pi session file."), { code: "ENOENT" });
+    } catch (cause) {
+      if (record(cause).code !== "ENOENT") throw cause;
+      throw Object.assign(new Error("The Pi session file no longer exists."), {
+        code: "resume-thread-missing"
+      });
+    }
+  }
+  const launch = await createLaunch(input.config, input.start, input.cursor);
+  const controller = new AbortController();
+  const forward = () => controller.abort(input.signal?.reason);
+  input.signal?.addEventListener("abort", forward, { once: true });
+  if (input.signal?.aborted) forward();
+  const ready = Promise.withResolvers();
+  const close = Promise.withResolvers();
+  void close.promise.catch(() => {
+  });
+  let requestedStop = false;
+  let didStart = false;
+  const completed = withProcessOperation(
+    input.host,
+    { signal: controller.signal },
+    async (operation) => {
+      const handle = await operation.spawn({
+        program: input.config.binaryPath,
+        args: launch.args,
+        cwd: input.cwd,
+        env: launch.env,
+        owner: { bindingId: input.host.bindingId }
+      });
+      let startupFailure;
+      const rpc = new PiRpc(handle, (event) => {
+        if (!didStart && (event.type === "extension_error" || input.start?.mcpServers?.length && event.type === "extension_ui_request" && event.method === "notify" && (event.notifyType === "error" || event.notifyType === "warning")))
+          startupFailure = new Error("Pi MCP servers could not initialize.");
+        return input.onEvent(event);
+      });
+      operation.track(rpc.drained);
+      operation.defer(() => handle.closeStdin());
+      const abort = () => {
+        rpc.fail(operation.signal.reason);
+        close.resolve();
+      };
+      operation.signal.addEventListener("abort", abort, { once: true });
+      if (operation.signal.aborted) abort();
+      const failed = rpc.failed.then((cause) => {
+        if (!requestedStop) {
+          if (didStart) input.onExit?.(cause);
+          close.reject(cause);
+        }
+      });
+      operation.track(failed);
+      try {
+        const state = record(await rpc.request("get_state", {}, operation.signal));
+        if (input.start?.mcpServers?.length) {
+          const inventory = record(await rpc.request("get_commands", {}, operation.signal));
+          const commands = Array.isArray(inventory.commands) ? inventory.commands : [];
+          if (!commands.some((command) => record(command).name === "mcp"))
+            throw new Error("Pi MCP command is unavailable.");
+          const response = record(
+            await rpc.request("prompt", { message: "/mcp" }, operation.signal)
+          );
+          if (response.disposition !== "handled")
+            throw new Error("Pi MCP initialization was not handled.");
+        }
+        if (startupFailure) throw startupFailure;
+        didStart = true;
+        ready.resolve({ rpc, state });
+        await close.promise;
+      } finally {
+        operation.signal.removeEventListener("abort", abort);
+      }
+    }
+  ).catch((cause) => {
+    ready.reject(cause);
+    throw cause;
+  }).finally(() => {
+    input.signal?.removeEventListener("abort", forward);
+  });
+  const cleaned = completed.then(
+    async () => {
+      await NodeFSP.rm(launch.directory, { recursive: true, force: true });
+    },
+    async (cause) => {
+      if (!isOperationCleanupError(cause))
+        await NodeFSP.rm(launch.directory, { recursive: true, force: true });
+      throw cause;
+    }
+  );
+  void cleaned.catch(() => {
+  });
+  try {
+    const established = await ready.promise;
+    input.signal?.removeEventListener("abort", forward);
+    input.signal?.throwIfAborted();
+    let stopping;
+    return {
+      ...established,
+      completed: cleaned,
+      stop: () => {
+        stopping ??= (async () => {
+          requestedStop = true;
+          close.resolve();
+          await cleaned;
+        })();
+        return stopping;
+      }
+    };
+  } catch (cause) {
+    requestedStop = true;
+    close.resolve();
+    controller.abort(cause);
+    try {
+      await cleaned;
+    } catch (cleanupCause) {
+      if (isOperationCleanupError(cleanupCause)) throw cleanupCause;
+    }
+    throw cause;
+  }
+}
+
+// src/events.ts
+import * as NodeCrypto3 from "node:crypto";
+var EventQueue = class {
+  queue = [];
+  waiters = [];
+  closed = false;
+  push(event) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter.resolve({ done: false, value: event });
+    else this.queue.push(event);
+  }
+  close() {
+    this.closed = true;
+    for (const waiter of this.waiters.splice(0)) waiter.resolve({ done: true, value: void 0 });
+  }
+  [Symbol.asyncIterator]() {
+    const owner = {};
+    let returned = false;
+    return {
+      next: () => {
+        if (returned) return Promise.resolve({ done: true, value: void 0 });
+        const value = this.queue.shift();
+        if (value) return Promise.resolve({ done: false, value });
+        if (this.closed) return Promise.resolve({ done: true, value: void 0 });
+        return new Promise((resolve3) => this.waiters.push({ owner, resolve: resolve3 }));
+      },
+      return: () => {
+        returned = true;
+        const pending = this.waiters.filter((waiter) => waiter.owner === owner);
+        this.waiters = this.waiters.filter((waiter) => waiter.owner !== owner);
+        for (const waiter of pending) waiter.resolve({ done: true, value: void 0 });
+        return Promise.resolve({ done: true, value: void 0 });
+      }
+    };
+  }
+};
+function emitter(host, events, session) {
+  return (type, payload, refs = {}) => {
+    events.push({
+      eventId: NodeCrypto3.randomUUID(),
+      provider: "pi",
+      providerInstanceId: host.instanceId,
+      threadId: session.threadId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      payload,
+      ...refs,
+      ...session.bindingGeneration === void 0 ? {} : { originBindingGeneration: session.bindingGeneration },
+      ...session.resumeCursor === void 0 ? {} : { originResumeCursor: session.resumeCursor }
+    });
+  };
+}
+
+// src/permission.ts
+var PI_FULL_ACCESS_MODE_ID = "full-access";
+var PI_NATIVE_MODE_REPORT = {
+  nativeModes: [{ id: PI_FULL_ACCESS_MODE_ID, name: "Full access" }],
+  currentNativeModeId: PI_FULL_ACCESS_MODE_ID
+};
+function piNativeModeFor(runtimeMode, nativeModeId) {
+  if (nativeModeId && nativeModeId !== PI_FULL_ACCESS_MODE_ID)
+    throw new Error("Pi only supports full access mode.");
+  if (!nativeModeId && runtimeMode !== PI_FULL_ACCESS_MODE_ID)
+    throw new Error("Pi does not provide the requested approval mode. Select full access.");
+  return PI_FULL_ACCESS_MODE_ID;
+}
+
+// src/turn.ts
+import * as NodeCrypto4 from "node:crypto";
+var count = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+var toolType = (name) => name === "bash" || name === "powershell" ? "command_execution" : name === "edit" || name === "write" ? "file_change" : name.startsWith("mcp__") ? "mcp_tool_call" : "dynamic_tool_call";
+var TOOL_SNAPSHOT_CHARS = 16384;
+function snapshot(value) {
+  if (value === void 0) return void 0;
+  const json = JSON.stringify(value);
+  return json.length <= TOOL_SNAPSHOT_CHARS ? value : { truncated: true, preview: json.slice(0, TOOL_SNAPSHOT_CHARS) };
+}
+function resultText(value) {
+  const content = record(value).content;
+  if (!Array.isArray(content))
+    return typeof value === "string" ? value.slice(0, TOOL_SNAPSHOT_CHARS) : "";
+  let text = "";
+  for (const entry of content) {
+    const part = record(entry);
+    if (part.type === "text") text += string(part.text).slice(0, TOOL_SNAPSHOT_CHARS - text.length);
+    if (text.length >= TOOL_SNAPSHOT_CHARS) break;
+  }
+  return text;
+}
+var PiTurn = class {
+  id = NodeCrypto4.randomUUID();
+  settled = Promise.withResolvers();
+  completed = false;
+  started = false;
+  messageId = NodeCrypto4.randomUUID();
+  messageEnded = false;
+  blocks = /* @__PURE__ */ new Map();
+  tools = /* @__PURE__ */ new Map();
+  lastError;
+  aborted = false;
+  tokens = {
+    uncachedInputTokens: 0,
+    cachedInputTokens: 0,
+    cacheCreationTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0
+  };
+  hasUsage = false;
+  emit;
+  model;
+  sessionId;
+  onFinish;
+  constructor(emit, model, sessionId, onFinish) {
+    this.emit = emit;
+    this.model = model;
+    this.sessionId = sessionId;
+    this.onFinish = onFinish;
+  }
+  start() {
+    if (this.started || this.completed) return;
+    this.started = true;
+    this.emit("turn.started", { model: this.model }, { turnId: this.id });
+  }
+  finish(state, errorMessage) {
+    if (this.completed) return;
+    this.completed = true;
+    this.completeBlocks(state === "failed" ? "failed" : "completed");
+    for (const tool of this.tools.values()) this.emitTool("item.completed", tool, "failed");
+    this.tools.clear();
+    this.emit(
+      "turn.completed",
+      {
+        state,
+        ...errorMessage?.trim() ? { errorMessage } : {},
+        ...this.hasUsage ? {
+          tokenUsage: {
+            provider: "pi",
+            model: this.model,
+            sessionId: this.sessionId,
+            totals: { ...this.tokens }
+          }
+        } : {}
+      },
+      { turnId: this.id }
+    );
+    try {
+      this.onFinish();
+    } finally {
+      this.settled.resolve();
+    }
+  }
+  block(index, kind) {
+    let block = this.blocks.get(index);
+    if (!block) {
+      block = { id: `${this.id}:${this.messageId}:${index}`, kind, text: "" };
+      this.blocks.set(index, block);
+      this.emit(
+        "item.started",
+        { itemType: kind, status: "inProgress" },
+        { turnId: this.id, itemId: block.id }
+      );
+    }
+    return block;
+  }
+  completeBlock(block, status) {
+    this.emit(
+      "item.completed",
+      {
+        itemType: block.kind,
+        status,
+        ...block.text.trim() ? { detail: block.text } : {}
+      },
+      { turnId: this.id, itemId: block.id }
+    );
+  }
+  completeBlocks(status) {
+    for (const block of this.blocks.values()) this.completeBlock(block, status);
+    this.blocks.clear();
+  }
+  endMessage(message) {
+    if (this.messageEnded) return;
+    this.messageEnded = true;
+    const failed = message.stopReason === "error";
+    const content = Array.isArray(message.content) ? message.content : [];
+    content.forEach((value, index) => {
+      const part = record(value);
+      if (part.type !== "text" && part.type !== "thinking") return;
+      const full = string(part.type === "text" ? part.text : part.thinking);
+      if (!full && !this.blocks.has(index)) return;
+      const kind = part.type === "text" ? "assistant_message" : "reasoning";
+      const block = this.block(index, kind);
+      if (full.startsWith(block.text) && full.length > block.text.length)
+        this.emit(
+          "content.delta",
+          {
+            streamKind: kind === "reasoning" ? "reasoning_text" : "assistant_text",
+            delta: full.slice(block.text.length)
+          },
+          { turnId: this.id, itemId: block.id }
+        );
+      block.text = full;
+      this.completeBlock(block, failed ? "failed" : "completed");
+      this.blocks.delete(index);
+    });
+    this.completeBlocks(failed ? "failed" : "completed");
+    this.lastError = failed ? string(message.errorMessage).trim() || "Pi model request failed." : void 0;
+    this.aborted = message.stopReason === "aborted";
+    const usage = record(message.usage);
+    if (![usage.input, usage.output, usage.cacheRead, usage.cacheWrite].some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    ))
+      return;
+    this.hasUsage = true;
+    const input = count(usage.input), cacheRead = count(usage.cacheRead), cacheWrite = count(usage.cacheWrite), output = count(usage.output);
+    this.tokens.uncachedInputTokens += input;
+    this.tokens.cachedInputTokens += cacheRead;
+    this.tokens.cacheCreationTokens += cacheWrite;
+    this.tokens.outputTokens += output;
+    this.tokens.reasoningTokens += count(usage.reasoning);
+    this.emit(
+      "thread.token-usage.updated",
+      {
+        usage: {
+          usedTokens: input + cacheRead + cacheWrite + output,
+          inputTokens: input,
+          cachedInputTokens: cacheRead + cacheWrite,
+          outputTokens: output
+        }
+      },
+      { turnId: this.id }
+    );
+  }
+  emitTool(type, tool, status) {
+    this.emit(
+      type,
+      {
+        itemType: toolType(tool.name),
+        title: tool.name,
+        status,
+        ...tool.detail?.trim() ? { detail: tool.detail } : {},
+        data: {
+          tool: tool.name,
+          state: status === "inProgress" ? "running" : status,
+          ...tool.args === void 0 ? {} : { input: tool.args },
+          ...tool.output === void 0 ? {} : { output: tool.output }
+        }
+      },
+      { turnId: this.id, itemId: tool.id }
+    );
+  }
+  event(event) {
+    if (this.completed) return;
+    const message = record(event.message);
+    if (event.type === "message_start" && message.role === "assistant") {
+      this.completeBlocks("failed");
+      this.messageId = NodeCrypto4.randomUUID();
+      this.messageEnded = false;
+    }
+    if (event.type === "message_update" && !this.messageEnded) {
+      const update = record(event.assistantMessageEvent);
+      if ((update.type === "text_delta" || update.type === "thinking_delta") && string(update.delta)) {
+        const kind = update.type === "text_delta" ? "assistant_message" : "reasoning";
+        const block = this.block(count(update.contentIndex), kind);
+        const delta = string(update.delta);
+        block.text += delta;
+        this.emit(
+          "content.delta",
+          { streamKind: kind === "reasoning" ? "reasoning_text" : "assistant_text", delta },
+          { turnId: this.id, itemId: block.id }
+        );
+      }
+    }
+    if (event.type === "message_end" && message.role === "assistant") this.endMessage(message);
+    if (event.type === "tool_execution_start") {
+      const nativeId = string(event.toolCallId), name = string(event.toolName) || "tool";
+      if (!nativeId || this.tools.has(nativeId)) return;
+      const tool = { id: `${this.id}:tool:${nativeId}`, name, args: snapshot(event.args) };
+      this.tools.set(nativeId, tool);
+      this.emitTool("item.started", tool, "inProgress");
+    }
+    if (event.type === "tool_execution_update" || event.type === "tool_execution_end") {
+      const nativeId = string(event.toolCallId), tool = this.tools.get(nativeId);
+      if (tool) {
+        const done = event.type === "tool_execution_end";
+        const result = done ? event.result : event.partialResult;
+        tool.output = snapshot(result);
+        tool.detail = resultText(result);
+        const update = JSON.stringify([tool.output, tool.detail]);
+        if (done || update !== tool.lastUpdate)
+          this.emitTool(
+            done ? "item.completed" : "item.updated",
+            tool,
+            done ? event.isError ? "failed" : "completed" : "inProgress"
+          );
+        tool.lastUpdate = update;
+        if (done) this.tools.delete(nativeId);
+      }
+    }
+    if (event.type === "auto_retry_end" && event.success === false)
+      this.lastError = string(event.finalError).trim() || "Pi retries failed.";
+    if (event.type === "agent_settled")
+      this.finish(
+        event.aborted || this.aborted ? "interrupted" : this.lastError ? "failed" : "completed",
+        this.lastError
+      );
+  }
+};
+
+// src/instance.ts
+function createPiInstance(value, host) {
+  const config = parseConfig(value, host.instanceId);
+  const events = new EventQueue();
+  const threads = /* @__PURE__ */ new Map();
+  const probes = /* @__PURE__ */ new Set();
+  const starts = /* @__PURE__ */ new Map();
+  const startEpochs = /* @__PURE__ */ new Map();
+  const disposed = new AbortController();
+  const now = () => (/* @__PURE__ */ new Date()).toISOString();
+  const nativeMode = PI_NATIVE_MODE_REPORT;
+  const validateModel = (selection) => {
+    const model = string(record(selection).model).trim();
+    if (model && model !== config.model && model !== `ycodium/${config.model}`)
+      throw Object.assign(new Error("Pi can only run the model configured for this instance."), {
+        code: "provider-rejected"
+      });
+  };
+  const safeError = (cause) => {
+    if (cause instanceof ExecutorSpawnRefusedError || cause instanceof ExecutorSpawnAbortedError)
+      return cause;
+    return Object.assign(
+      new Error(redact(config, cause)),
+      record(cause).code === "resume-thread-missing" ? { code: "resume-thread-missing" } : cause instanceof PiResponseError || record(cause).code === "provider-rejected" ? { code: "provider-rejected" } : {}
+    );
+  };
+  const ensureActive = () => {
+    if (disposed.signal.aborted) throw new Error("Pi executor is disposed.");
+  };
+  const requireThread = (id) => {
+    const value2 = threads.get(id);
+    if (!value2) throw new Error("Pi session is not running.");
+    return value2;
+  };
+  const connection = (booked) => {
+    if (!booked.connection || booked.exited || booked.closing)
+      throw new Error("Pi session is not ready.");
+    return booked.connection;
+  };
+  const endQuestions = (booked) => {
+    for (const id of booked.questions.keys())
+      booked.emit("user-input.resolved", { decision: "cancelled" }, { requestId: id });
+    booked.questions.clear();
+  };
+  const exited = (booked, cause) => {
+    if (booked.exited) return;
+    booked.turn?.finish(
+      cause ? "failed" : "interrupted",
+      cause ? redact(config, cause) : void 0
+    );
+    endQuestions(booked);
+    booked.exited = true;
+    booked.session.status = "stopped";
+    booked.emit("session.exited", { reason: cause ? redact(config, cause) : "stopped" });
+  };
+  const onEvent = (booked, event) => {
+    if (booked.exited) return;
+    if (event.type === "extension_ui_request") {
+      const method = string(event.method), nativeId = string(event.id);
+      if (["select", "confirm", "input", "editor"].includes(method) && nativeId) {
+        const requestId = NodeCrypto5.randomUUID();
+        const options = method === "confirm" ? ["Yes", "No"] : Array.isArray(event.options) ? event.options.filter((v) => typeof v === "string") : [];
+        booked.questions.set(requestId, { nativeId, method, options });
+        const title = string(event.title) || "Pi";
+        booked.emit(
+          "user-input.requested",
+          {
+            questions: [
+              {
+                id: "value",
+                header: title,
+                question: string(event.message) || title,
+                options: options.map((label) => ({ label, description: "" })),
+                allowFreeform: method === "input" || method === "editor",
+                multiSelect: false
+              }
+            ]
+          },
+          { requestId, ...booked.turn ? { turnId: booked.turn.id } : {} }
+        );
+      }
+      return;
+    }
+    if (event.type === "compaction_start")
+      booked.compaction = {
+        compactionId: NodeCrypto5.randomUUID(),
+        trigger: event.reason === "manual" ? "manual" : "automatic",
+        startedAt: Date.now()
+      };
+    if (event.type === "compaction_end") {
+      const snapshot2 = booked.compaction ?? {
+        compactionId: NodeCrypto5.randomUUID(),
+        trigger: event.reason === "manual" ? "manual" : "automatic",
+        startedAt: Date.now()
+      };
+      booked.compaction = void 0;
+      if (!event.aborted && !event.errorMessage && event.result) {
+        const result = record(event.result), summary = string(result.summary);
+        booked.emit("thread.state.changed", {
+          state: "compacted",
+          compaction: {
+            compactionId: snapshot2.compactionId,
+            trigger: snapshot2.trigger,
+            durationMs: Math.max(0, Date.now() - snapshot2.startedAt),
+            ...typeof result.tokensBefore === "number" && Number.isFinite(result.tokensBefore) && result.tokensBefore >= 0 ? { preTokens: result.tokensBefore } : {},
+            ...summary ? { summary: summary.slice(0, 16e3), summaryTruncated: summary.length > 16e3 } : {}
+          }
+        });
+      } else if (event.errorMessage)
+        booked.emit("runtime.warning", { message: redact(config, event.errorMessage) });
+    }
+    const message = record(event.message);
+    const mapped = event.type === "message_end" && typeof message.errorMessage === "string" ? { ...event, message: { ...message, errorMessage: redact(config, message.errorMessage) } } : event.type === "auto_retry_end" && typeof event.finalError === "string" ? { ...event, finalError: redact(config, event.finalError) } : event;
+    booked.turn?.event(mapped);
+    if (event.type === "agent_settled") endQuestions(booked);
+  };
+  const waitForSettled = async (booked, turn, signal) => {
+    let timer;
+    let abort = () => {
+    };
+    try {
+      await Promise.race([
+        turn.settled.promise,
+        booked.connection.rpc.failed.then((cause) => {
+          throw cause;
+        }),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Pi did not settle after abort.")), 1e4);
+          abort = () => reject(signal?.reason ?? new Error("Pi abort cancelled."));
+          signal?.addEventListener("abort", abort, { once: true });
+          if (signal?.aborted) abort();
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+    }
+  };
+  const abortTurn = async (booked, signal) => {
+    const turn = booked.turn, conn = booked.connection;
+    if (!turn || turn.completed || !conn) return;
+    await conn.rpc.request("clear_queue", {}, signal, 1e4);
+    await conn.rpc.request("abort", {}, signal, 1e4);
+    await waitForSettled(booked, turn, signal);
+  };
+  const close = async (booked) => {
+    if (booked.closing) return booked.closing;
+    booked.startup.abort(new Error("Pi session is stopping."));
+    booked.closing = (async () => {
+      await booked.starting?.catch(() => {
+      });
+      try {
+        if (!booked.exited) await abortTurn(booked, AbortSignal.timeout(2e3)).catch(() => {
+        });
+        await booked.connection?.stop();
+        exited(booked);
+        if (threads.get(booked.session.threadId) === booked)
+          threads.delete(booked.session.threadId);
+      } catch (cause) {
+        exited(booked, cause);
+        throw cause;
+      }
+    })();
+    return booked.closing;
+  };
+  const startOne = async (input, signal) => {
+    ensureActive();
+    validateConnection(config);
+    validateModel(input.modelSelection);
+    signal?.throwIfAborted();
+    const nativeModeId = piNativeModeFor(input.runtimeMode, input.nativeModeId);
+    const existing = threads.get(input.threadId);
+    if (existing) await close(existing);
+    ensureActive();
+    signal?.throwIfAborted();
+    const cwd = input.cwd ?? host.workspacePath(input.threadId);
+    if (!cwd) throw new Error("Pi workspace is missing.");
+    const cursor = resumeCursor(config, input);
+    const session = {
+      provider: "pi",
+      providerInstanceId: host.instanceId,
+      threadId: input.threadId,
+      cwd,
+      runtimeMode: input.runtimeMode,
+      nativeModeId,
+      status: "starting",
+      model: config.model,
+      createdAt: now(),
+      updatedAt: now(),
+      resumeCursor: cursor,
+      ...input.bindingGeneration === void 0 ? {} : { bindingGeneration: input.bindingGeneration }
+    };
+    const booked = {
+      session,
+      emit: emitter(host, events, session),
+      startup: new AbortController(),
+      questions: /* @__PURE__ */ new Map(),
+      exited: false,
+      stopping: false
+    };
+    threads.set(input.threadId, booked);
+    const task = (async () => {
+      try {
+        booked.connection = await openConnection({
+          config,
+          host,
+          cwd,
+          start: { ...input, cwd },
+          cursor,
+          signal: AbortSignal.any([
+            ...signal ? [signal] : [],
+            disposed.signal,
+            booked.startup.signal
+          ]),
+          onEvent: (event) => onEvent(booked, event),
+          onExit: (cause) => exited(booked, cause)
+        });
+        if (booked.exited || booked.startup.signal.aborted || disposed.signal.aborted) {
+          await booked.connection.stop();
+          throw new Error("Pi startup was cancelled.");
+        }
+        initializeResumeCursor(cursor, booked.connection.state);
+        session.status = "idle";
+        booked.emit("session.started", {});
+        return { ...session };
+      } catch (cause) {
+        let failure = cause;
+        if (booked.connection) {
+          try {
+            await booked.connection.stop();
+          } catch (cleanupCause) {
+            failure = cleanupCause;
+          }
+        }
+        exited(booked, failure);
+        throw safeError(failure);
+      }
+    })();
+    booked.starting = task;
+    return task;
+  };
+  const start = (input, signal) => {
+    const previous = starts.get(input.threadId);
+    const epoch = startEpochs.get(input.threadId) ?? 0;
+    const task = (previous ? previous.catch(() => {
+    }) : Promise.resolve()).then(() => {
+      if ((startEpochs.get(input.threadId) ?? 0) !== epoch)
+        throw new Error("Pi startup was cancelled.");
+      return startOne(input, signal);
+    });
+    starts.set(input.threadId, task);
+    void task.finally(() => {
+      if (starts.get(input.threadId) === task) starts.delete(input.threadId);
+    }).catch(() => {
+    });
+    return task;
+  };
+  const instance = {
+    probe: async (signal) => {
+      ensureActive();
+      const task = (async () => {
+        const combined = signal ? AbortSignal.any([signal, disposed.signal]) : disposed.signal;
+        let version = null;
+        try {
+          const check = await runProcessOperation(host, {
+            program: config.binaryPath,
+            args: ["--version"],
+            owner: { bindingId: host.bindingId },
+            signal: combined,
+            timeoutMs: 1e4
+          });
+          if (check.exitCode !== 0) throw new Error("Pi version check failed.");
+          version = check.stdout.trim();
+          const match = version.match(/(?:^|\s)v?(\d+)\.(\d+)\.(\d+)(?:\s|$)/);
+          if (!match || Number(match[1]) < 1 || Number(match[1]) === 1 && Number(match[2]) < 4)
+            return {
+              ...nativeMode,
+              installed: true,
+              version,
+              readiness: "error",
+              auth: { status: "unknown" },
+              tooOld: { minimumVersion: "1.4.0" },
+              detail: "Pi 1.4.0 or newer is required."
+            };
+          validateConnection(config);
+          const conn = await openConnection({
+            config,
+            host,
+            cwd: config.homePath,
+            signal: combined,
+            onEvent: () => {
+            }
+          });
+          try {
+            const result = record(await conn.rpc.request("get_available_models", {}, combined));
+            const models = (Array.isArray(result.models) ? result.models : []).map(record).filter((m) => m.provider === "ycodium" && m.id === config.model).map((m) => ({
+              slug: config.model,
+              name: string(m.name) || config.model,
+              isDefault: true
+            }));
+            if (!models.length) throw new Error("The configured Pi model is unavailable.");
+            return {
+              installed: true,
+              version,
+              readiness: "ready",
+              auth: { status: "unknown" },
+              models,
+              ...nativeMode,
+              notice: { messageKey: "connectionNotVerified" }
+            };
+          } finally {
+            await conn.stop();
+          }
+        } catch (cause) {
+          combined.throwIfAborted();
+          if (cause instanceof ExecutorSpawnRefusedError || cause instanceof ExecutorSpawnAbortedError)
+            throw cause;
+          if (isExecutorSpawnFailure(cause)) {
+            const failure = describeExecutorSpawnFailure(cause);
+            return {
+              ...nativeMode,
+              installed: failure.readiness !== "not-installed",
+              version,
+              readiness: failure.readiness,
+              auth: { status: "unknown" },
+              detail: redact(config, failure.detail)
+            };
+          }
+          return {
+            ...nativeMode,
+            installed: true,
+            version,
+            readiness: "error",
+            auth: { status: "unknown" },
+            detail: redact(config, cause)
+          };
+        }
+      })();
+      probes.add(task);
+      try {
+        return await task;
+      } finally {
+        probes.delete(task);
+      }
+    },
+    startSession: start,
+    sendTurn: async (input, signal) => {
+      signal?.throwIfAborted();
+      validateModel(input.modelSelection);
+      const booked = requireThread(input.threadId), conn = connection(booked);
+      if (booked.stopping) throw new Error("Pi is stopping the current turn.");
+      if (input.expectedTurnId !== void 0) {
+        if (!booked.turn || booked.turn.id !== input.expectedTurnId || booked.turn.completed)
+          throw Object.assign(new Error("The target Pi turn has ended."), {
+            code: "provider-rejected"
+          });
+        try {
+          await conn.rpc.request("steer", { message: input.input ?? "" }, signal);
+        } catch (cause) {
+          if (!(cause instanceof PiResponseError)) await close(booked);
+          throw safeError(cause);
+        }
+        return {
+          threadId: input.threadId,
+          turnId: input.expectedTurnId,
+          resumeCursor: booked.session.resumeCursor
+        };
+      }
+      if (booked.turn) throw new Error("Pi already has an active turn.");
+      const cursor = record(booked.session.resumeCursor);
+      const turn = new PiTurn(booked.emit, config.model, string(cursor.sessionId), () => {
+        if (booked.turn === turn) booked.turn = void 0;
+        booked.session.status = "idle";
+        booked.session.updatedAt = now();
+      });
+      booked.turn = turn;
+      booked.session.status = "running";
+      turn.start();
+      try {
+        const response = record(
+          await conn.rpc.request("prompt", { message: input.input ?? "" }, signal)
+        );
+        if (response.disposition === "handled") turn.finish("completed");
+        return {
+          threadId: input.threadId,
+          turnId: turn.id,
+          resumeCursor: booked.session.resumeCursor
+        };
+      } catch (cause) {
+        turn.finish("failed", redact(config, cause));
+        if (!(cause instanceof PiResponseError)) await close(booked);
+        throw safeError(cause);
+      }
+    },
+    interruptTurn: async (threadId, turnId, signal) => {
+      const booked = requireThread(threadId), turn = booked.turn;
+      if (!turn || turnId !== void 0 && turn.id !== turnId) return;
+      booked.stopping = true;
+      try {
+        await abortTurn(booked, signal);
+      } catch (cause) {
+        await close(booked);
+        throw safeError(cause);
+      } finally {
+        booked.stopping = false;
+      }
+    },
+    respondToRequest: async () => {
+      throw new Error("Pi does not expose native tool approvals.");
+    },
+    respondToUserInput: async (threadId, requestId, answers) => {
+      const booked = requireThread(threadId), question = booked.questions.get(requestId);
+      if (!question) return;
+      const data = record(answers), entry = record(record(data.answers ?? data).value);
+      const candidates = Array.isArray(entry.answers) ? entry.answers : [];
+      const value2 = string(candidates[0]) || string(record(data.answers ?? data).value);
+      const response = !value2 ? { cancelled: true } : question.method === "confirm" ? { confirmed: value2 === "Yes" } : { value: value2 };
+      try {
+        await connection(booked).rpc.respond({ id: question.nativeId, ...response });
+      } catch (cause) {
+        await close(booked);
+        throw safeError(cause);
+      }
+      booked.questions.delete(requestId);
+      booked.emit(
+        "user-input.resolved",
+        { decision: value2 ? "answered" : "cancelled" },
+        { requestId }
+      );
+    },
+    compactContext: async (threadId) => {
+      const booked = requireThread(threadId);
+      try {
+        await connection(booked).rpc.request("compact", {}, void 0, 12e4);
+      } catch (cause) {
+        if (!(cause instanceof PiResponseError)) await close(booked);
+        throw safeError(cause);
+      }
+    },
+    stopSession: async (threadId) => {
+      startEpochs.set(threadId, (startEpochs.get(threadId) ?? 0) + 1);
+      const starting = starts.get(threadId), booked = threads.get(threadId);
+      if (booked) {
+        try {
+          await close(booked);
+        } catch (cause) {
+          throw safeError(cause);
+        }
+      }
+      await starting?.catch(() => {
+      });
+      const late = threads.get(threadId);
+      if (late) {
+        try {
+          await close(late);
+        } catch (cause) {
+          throw safeError(cause);
+        }
+      }
+    },
+    readThread: async (threadId) => {
+      const booked = requireThread(threadId);
+      let result;
+      try {
+        result = record(await connection(booked).rpc.request("get_messages"));
+      } catch (cause) {
+        throw safeError(cause);
+      }
+      return {
+        threadId,
+        turns: [
+          {
+            id: booked.turn?.id ?? string(record(booked.session.resumeCursor).sessionId),
+            items: Array.isArray(result.messages) ? result.messages : []
+          }
+        ]
+      };
+    },
+    events,
+    listLiveProcesses: async () => [...threads.values()].filter((b) => b.connection && !b.exited).map((b) => ({
+      pid: b.connection.rpc.process.pid,
+      threadId: b.session.threadId,
+      bindingId: host.bindingId,
+      command: config.binaryPath
+    })),
+    dispose: async () => {
+      disposed.abort();
+      const closing = [...threads.values()].map(close);
+      await Promise.allSettled([...probes, ...starts.values()]);
+      const results = await Promise.allSettled(closing);
+      events.close();
+      const failure = results.find((result) => result.status === "rejected");
+      if (failure?.status === "rejected") throw new Error(redact(config, failure.reason));
+    },
+    forceStop: async () => {
+      await Promise.all(
+        [.../* @__PURE__ */ new Set([...threads.keys(), ...starts.keys()])].map((id) => instance.stopSession(id))
+      );
+    }
+  };
+  const safely = (method) => async (...args) => {
+    try {
+      return await method(...args);
+    } catch (cause) {
+      throw safeError(cause);
+    }
+  };
+  return {
+    ...instance,
+    startSession: safely(instance.startSession),
+    sendTurn: safely(instance.sendTurn),
+    interruptTurn: safely(instance.interruptTurn),
+    respondToUserInput: safely(instance.respondToUserInput),
+    compactContext: safely(instance.compactContext),
+    stopSession: safely(instance.stopSession),
+    readThread: safely(instance.readThread),
+    dispose: safely(instance.dispose),
+    forceStop: safely(instance.forceStop)
+  };
+}
+
+// src/index.ts
+var index_default = definePlugin({
+  id: "agent-pi",
+  apiVersion: 47,
+  executors: [
+    { card: PI_CARD, createInstance: async (config, host) => createPiInstance(config, host) }
+  ],
+  activate(ctx) {
+    ctx.log.info("Pi executor ready");
+  }
+});
+export {
+  index_default as default
+};