kennel 0.2.24 → 0.2.26

package/dist/core/runtime.js

@@ -17078,9 +17078,6 @@ import { createHash as createHash5 } from "node:crypto";
 
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/core.js
 var _a;
-var NEVER = /* @__PURE__ */ Object.freeze({
-  status: "aborted"
-});
 function $constructor(name, initializer, params) {
   function init(inst, def) {
     if (!inst._zod) {
@@ -17160,9 +17157,6 @@ function getEnumValues(entries) {
   const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
   return values;
 }
-function joinValues(array, separator = "|") {
-  return array.map((val) => stringifyPrimitive(val)).join(separator);
-}
 function jsonStringifyReplacer(_, value) {
   if (typeof value === "bigint")
     return value.toString();
@@ -17313,13 +17307,6 @@ function normalizeParams(_params) {
     return { ...params, error: () => params.error };
   return params;
 }
-function stringifyPrimitive(value) {
-  if (typeof value === "bigint")
-    return value.toString() + "n";
-  if (typeof value === "string")
-    return `"${value}"`;
-  return `${value}`;
-}
 function optionalKeys(shape) {
   return Object.keys(shape).filter((k) => {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
@@ -17552,27 +17539,6 @@ function getLengthableOrigin(input) {
     return "string";
   return "unknown";
 }
-function parsedType(data) {
-  const t = typeof data;
-  switch (t) {
-    case "number": {
-      return Number.isNaN(data) ? "nan" : "number";
-    }
-    case "object": {
-      if (data === null) {
-        return "null";
-      }
-      if (Array.isArray(data)) {
-        return "array";
-      }
-      const obj = data;
-      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
-        return obj.constructor.name;
-      }
-    }
-  }
-  return t;
-}
 function issue(...args) {
   const [iss, input, inst] = args;
   if (typeof iss === "string") {
@@ -19609,116 +19575,6 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/locales/en.js
-var error = () => {
-  const Sizable = {
-    string: { unit: "characters", verb: "to have" },
-    file: { unit: "bytes", verb: "to have" },
-    array: { unit: "items", verb: "to have" },
-    set: { unit: "items", verb: "to have" },
-    map: { unit: "entries", verb: "to have" }
-  };
-  function getSizing(origin) {
-    return Sizable[origin] ?? null;
-  }
-  const FormatDictionary = {
-    regex: "input",
-    email: "email address",
-    url: "URL",
-    emoji: "emoji",
-    uuid: "UUID",
-    uuidv4: "UUIDv4",
-    uuidv6: "UUIDv6",
-    nanoid: "nanoid",
-    guid: "GUID",
-    cuid: "cuid",
-    cuid2: "cuid2",
-    ulid: "ULID",
-    xid: "XID",
-    ksuid: "KSUID",
-    datetime: "ISO datetime",
-    date: "ISO date",
-    time: "ISO time",
-    duration: "ISO duration",
-    ipv4: "IPv4 address",
-    ipv6: "IPv6 address",
-    mac: "MAC address",
-    cidrv4: "IPv4 range",
-    cidrv6: "IPv6 range",
-    base64: "base64-encoded string",
-    base64url: "base64url-encoded string",
-    json_string: "JSON string",
-    e164: "E.164 number",
-    jwt: "JWT",
-    template_literal: "input"
-  };
-  const TypeDictionary = {
-    nan: "NaN"
-  };
-  return (issue) => {
-    switch (issue.code) {
-      case "invalid_type": {
-        const expected = TypeDictionary[issue.expected] ?? issue.expected;
-        const receivedType = parsedType(issue.input);
-        const received = TypeDictionary[receivedType] ?? receivedType;
-        return `Invalid input: expected ${expected}, received ${received}`;
-      }
-      case "invalid_value":
-        if (issue.values.length === 1)
-          return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
-        return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
-      case "too_big": {
-        const adj = issue.inclusive ? "<=" : "<";
-        const sizing = getSizing(issue.origin);
-        if (sizing)
-          return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
-        return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
-      }
-      case "too_small": {
-        const adj = issue.inclusive ? ">=" : ">";
-        const sizing = getSizing(issue.origin);
-        if (sizing) {
-          return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
-        }
-        return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
-      }
-      case "invalid_format": {
-        const _issue = issue;
-        if (_issue.format === "starts_with") {
-          return `Invalid string: must start with "${_issue.prefix}"`;
-        }
-        if (_issue.format === "ends_with")
-          return `Invalid string: must end with "${_issue.suffix}"`;
-        if (_issue.format === "includes")
-          return `Invalid string: must include "${_issue.includes}"`;
-        if (_issue.format === "regex")
-          return `Invalid string: must match pattern ${_issue.pattern}`;
-        return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
-      }
-      case "not_multiple_of":
-        return `Invalid number: must be a multiple of ${issue.divisor}`;
-      case "unrecognized_keys":
-        return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
-      case "invalid_key":
-        return `Invalid key in ${issue.origin}`;
-      case "invalid_union":
-        if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) {
-          const opts = issue.options.map((o) => `'${o}'`).join(" | ");
-          return `Invalid discriminator value. Expected ${opts}`;
-        }
-        return "Invalid input";
-      case "invalid_element":
-        return `Invalid value in ${issue.origin}`;
-      default:
-        return `Invalid input`;
-    }
-  };
-};
-function en_default() {
-  return {
-    localeError: error()
-  };
-}
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/registries.js
 var _a2;
 var $output = Symbol("ZodOutput");
@@ -21244,9 +21100,6 @@ var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
   $ZodURL.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
-function url(params) {
-  return _url(ZodURL, params);
-}
 var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
   $ZodEmoji.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -21768,8 +21621,6 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
-// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
-config(en_default());
 // packages/schemas/src/data/contract.ts
 var issueSchema = object({ path: string2(), message: string2() });
 var coreRecordIconSchema = object({
@@ -21791,7 +21642,7 @@ var coreCollectionUiSchema = object({
   primaryField: string2(),
   secondaryField: string2().optional(),
   filters: array(string2()),
-  numericFilters: array(string2()),
+  numericFilters: array(string2()).default([]),
   sort: array(coreCollectionSortSchema).optional()
 });
 var collectionSummarySchema = object({
@@ -22009,7 +21860,6 @@ var routes = {
     method: "get",
     query: emptyQuery,
     response: object({
-      acp: boolean2(),
       download: boolean2(),
       hostActions: _enum(["local", "none"]),
       local: boolean2(),
@@ -22155,7 +22005,7 @@ import {
   sep as sep7
 } from "node:path";
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
 var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
 var import_react6 = __toESM(require_react(), 1);
 
@@ -22332,7 +22182,7 @@ var defaultSchema = {
     "var"
   ]
 };
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
 var runtime = __toESM(require_jsx_runtime(), 1);
 
 // node_modules/.bun/gemoji@8.1.0/node_modules/gemoji/index.js
@@ -35429,7 +35279,7 @@ var gemoji = [
   }
 ];
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/emoji.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/emoji.js
 var shortcodeToEmoji = new Map(gemoji.flatMap((entry) => entry.names.map((name) => [
   name,
   {
@@ -35438,36 +35288,36 @@ var shortcodeToEmoji = new Map(gemoji.flatMap((entry) => entry.names.map((name)
   }
 ])));
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/link.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/link.js
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/rehype-collapsible-headings.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/rehype-collapsible-headings.js
 var HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-collapsible-sections.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-collapsible-sections.js
 var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
 var import_react3 = __toESM(require_react(), 1);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-heading-copy.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-heading-copy.js
 var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
 var import_react = __toESM(require_react(), 1);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/use-copy-to-clipboard.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/use-copy-to-clipboard.js
 var import_react2 = __toESM(require_react(), 1);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/rehype-heading-lines.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/rehype-heading-lines.js
 var HEADING_TAGS2 = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-mermaid.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-mermaid.js
 var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
 var import_react4 = __toESM(require_react(), 1);
 var renderQueue = Promise.resolve();
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-media.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react-media.js
 var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
 var import_react5 = __toESM(require_react(), 1);
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/react.js
 var markdownSchema = {
   ...defaultSchema,
   tagNames: [
@@ -35567,7 +35417,7 @@ __exportCjs(exports_dist, {
 var composer = require_composer();
 var Document = require_Document();
 var Schema = require_Schema();
-var errors3 = require_errors();
+var errors2 = require_errors();
 var Alias = require_Alias();
 var identity = require_identity();
 var Pair = require_Pair();
@@ -35583,9 +35433,9 @@ var visit = require_visit();
 var $Composer = composer.Composer;
 var $Document = Document.Document;
 var $Schema = Schema.Schema;
-var $YAMLError = errors3.YAMLError;
-var $YAMLParseError = errors3.YAMLParseError;
-var $YAMLWarning = errors3.YAMLWarning;
+var $YAMLError = errors2.YAMLError;
+var $YAMLParseError = errors2.YAMLParseError;
+var $YAMLWarning = errors2.YAMLWarning;
 var $Alias = Alias.Alias;
 var $isAlias = identity.isAlias;
 var $isCollection = identity.isCollection;
@@ -35610,7 +35460,7 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
-// packages/markdown/src/metadata.ts
+// packages/ui/src/markdown/metadata.ts
 function frontmatter(content) {
   const match = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(content);
   if (!match)
@@ -35655,11 +35505,11 @@ function markdownMetadata(content) {
     title: metadata?.title ?? leadingHeading(body)
   };
 }
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/node.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/node.js
 import { readdir, readFile } from "node:fs/promises";
 import { relative, resolve as resolve2, sep } from "node:path";
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/documents.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/documents.js
 var extensions = new Set([
   ".htm",
   ".html",
@@ -35679,7 +35529,7 @@ function documentKind(path) {
   return;
 }
 
-// node_modules/.bun/@raggle-ai+barkdown@0.6.1+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/node.js
+// node_modules/.bun/@raggle-ai+barkdown@0.7.0+22117d1132b05fb8/node_modules/@raggle-ai/barkdown/dist/node.js
 var skipped = new Set([".git", ".turbo", "dist", "node_modules"]);
 async function readFolder(root) {
   const folder = resolve2(root);
@@ -35709,6 +35559,7 @@ async function readFolder(root) {
     documents: (await read(folder)).sort((left, right) => left.path.localeCompare(right.path))
   };
 }
+
 // packages/api/src/server/folder-metadata-plugin.ts
 import { execFile as execFile4 } from "node:child_process";
 
@@ -35971,8 +35822,11 @@ import { join } from "node:path";
 // packages/schemas/src/data/icon-image.ts
 import { constants } from "node:fs";
 import { open } from "node:fs/promises";
-import sharp from "sharp";
 var maxIconBytes = 512 * 1024;
+var importRuntime = new Function("specifier", "return import(specifier)");
+async function loadSharp() {
+  return (await importRuntime("sharp")).default;
+}
 async function readIconFile(path) {
   const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW).catch(() => {
     return;
@@ -36000,6 +35854,7 @@ async function normalizeIcon(data) {
   if (!data.length || data.length > maxIconBytes)
     return;
   try {
+    const sharp = await loadSharp();
     const image = sharp(data, {
       limitInputPixels: 1024 * 1024,
       failOn: "warning"
@@ -37664,7 +37519,7 @@ function createProjectDiscovery(load = discoverProjects) {
   };
 }
 
-// packages/kinds/src/kinds.ts
+// packages/api/src/shared/document-kinds.ts
 var previewTextKinds = new Set([
   "code",
   "eml",
@@ -37816,6 +37671,7 @@ function mediaRawMime(path) {
   const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
   return mediaMime[extension];
 }
+
 // packages/api/src/server/folder-metadata-plugin.ts
 var {
   applyProjectFavorites,
@@ -38339,7 +38195,6 @@ function createFolderApi({
           return;
         if (url.pathname === "/api/capabilities") {
           sendContract(response, url, {
-            acp: !remote,
             download: true,
             hostActions: remote ? "none" : "local",
             local: !remote,
@@ -38877,4485 +38732,6 @@ function createFolderApi({
   };
 }
 
-// packages/api/src/server/acp-live-plugin.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { Readable, Writable } from "node:stream";
-import localSessions from "@raggle-ai/local/sessions";
-
-// packages/api/src/server/acp/process-manager.ts
-import { spawn } from "node:child_process";
-
-class AcpProcessManager {
-  slots = new Map;
-  start(key, adapter) {
-    if (this.slots.has(key)) {
-      throw new DuplicateProcessError(key);
-    }
-    const stderrLimit = 256;
-    const stderrRing = [];
-    let exitResolver;
-    let exitCalled = false;
-    const onExit = new Promise((resolve) => {
-      exitResolver = resolve;
-    });
-    const child = spawn(adapter.command, adapter.args, {
-      env: process.env,
-      cwd: adapter.workingFolder,
-      shell: false,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const startedAt = new Date().toISOString();
-    const handle = {
-      stdin: child.stdin,
-      stdout: child.stdout,
-      stderr: child.stderr,
-      get state() {
-        return slot.state;
-      },
-      onExit
-    };
-    const slot = {
-      process: child,
-      handle,
-      state: "starting",
-      startedAt,
-      stderrRing,
-      stopResolver: null,
-      exitResolver
-    };
-    child.stderr.on("data", (chunk) => {
-      const text = chunk.toString("utf-8");
-      const lines = text.split(`
-`);
-      for (const line of lines) {
-        if (line.length === 0)
-          continue;
-        stderrRing.push(line);
-        if (stderrRing.length > stderrLimit) {
-          stderrRing.splice(0, stderrRing.length - stderrLimit);
-        }
-      }
-    });
-    child.on("spawn", () => {
-      slot.state = "running";
-    });
-    child.on("error", (err) => {
-      stderrRing.push(`[spawn-error] ${err.message}`);
-      if (slot.state !== "stopping" && slot.state !== "stopped") {
-        slot.state = "errored";
-      }
-      if (!exitCalled) {
-        exitCalled = true;
-        exitResolver({ code: 1, signal: null });
-        this.slots.delete(key);
-      }
-    });
-    child.on("exit", (code, signal) => {
-      if (slot.state === "stopping") {
-        slot.state = "stopped";
-      } else if (slot.state !== "stopped") {
-        slot.state = code === 0 ? "stopped" : "errored";
-      }
-      slot.stopResolver?.();
-      slot.stopResolver = null;
-      if (!exitCalled) {
-        exitCalled = true;
-        exitResolver({ code, signal });
-        this.slots.delete(key);
-      }
-    });
-    this.slots.set(key, slot);
-    return handle;
-  }
-  async stop(key, graceMs = 5000, killMs = 2000) {
-    const slot = this.slots.get(key);
-    if (!slot)
-      return;
-    if (slot.state === "stopping" || slot.state === "stopped" || slot.state === "errored")
-      return;
-    slot.state = "stopping";
-    return new Promise((resolve, reject) => {
-      slot.stopResolver = resolve;
-      const killed = slot.process.kill("SIGTERM");
-      if (!killed) {
-        resolve();
-        return;
-      }
-      const escalate = setTimeout(() => {
-        slot.process.kill("SIGKILL");
-        const force = setTimeout(() => {
-          reject(new Error(`Process ${key} did not exit after SIGKILL (${killMs} ms)`));
-        }, killMs);
-        slot.process.on("exit", () => clearTimeout(force));
-      }, graceMs);
-      slot.process.on("exit", () => clearTimeout(escalate));
-    });
-  }
-  status(key) {
-    const slot = this.slots.get(key);
-    if (!slot)
-      return null;
-    return {
-      key,
-      state: slot.state,
-      pid: slot.process.pid ?? null,
-      startedAt: slot.startedAt,
-      exitCode: slot.process.exitCode ?? null,
-      signal: slot.process.signalCode,
-      stderrLines: [...slot.stderrRing]
-    };
-  }
-  activeKeys() {
-    return [...this.slots.keys()];
-  }
-  async stopAll(graceMs = 5000, killMs = 2000) {
-    const keys = this.activeKeys();
-    await Promise.all(keys.map((key) => this.stop(key, graceMs, killMs)));
-  }
-}
-
-class DuplicateProcessError extends Error {
-  constructor(key) {
-    super(`Process slot "${key}" is already active. Stop it before starting a new one.`);
-    this.name = "DuplicateProcessError";
-  }
-}
-
-// packages/api/src/server/acp/registry.ts
-var adapters = new Map;
-adapters.set("pi", {
-  id: "pi",
-  displayName: "Pi Coding Agent",
-  command: "pi-acp",
-  args: [],
-  workingFolder: "/tmp",
-  capabilities: [
-    "acp:tool_call",
-    "acp:resource_read",
-    "acp:prompt",
-    "acp:completion",
-    "acp:session_resume"
-  ],
-  enabled: true
-});
-adapters.set("opencode", {
-  id: "opencode",
-  displayName: "OpenCode",
-  command: "opencode",
-  args: ["acp"],
-  workingFolder: "/tmp",
-  capabilities: ["acp:tool_call", "acp:prompt", "acp:session_resume"],
-  enabled: true
-});
-function findAdapter(id) {
-  return adapters.get(id);
-}
-
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
-var AGENT_METHODS = {
-  initialize: "initialize",
-  authenticate: "authenticate",
-  providers_list: "providers/list",
-  providers_set: "providers/set",
-  providers_disable: "providers/disable",
-  session_new: "session/new",
-  session_load: "session/load",
-  session_set_mode: "session/set_mode",
-  session_set_config_option: "session/set_config_option",
-  session_prompt: "session/prompt",
-  session_cancel: "session/cancel",
-  mcp_message: "mcp/message",
-  session_list: "session/list",
-  session_delete: "session/delete",
-  session_fork: "session/fork",
-  session_resume: "session/resume",
-  session_close: "session/close",
-  logout: "logout",
-  nes_start: "nes/start",
-  nes_suggest: "nes/suggest",
-  nes_accept: "nes/accept",
-  nes_reject: "nes/reject",
-  nes_close: "nes/close",
-  document_did_open: "document/didOpen",
-  document_did_change: "document/didChange",
-  document_did_close: "document/didClose",
-  document_did_save: "document/didSave",
-  document_did_focus: "document/didFocus"
-};
-var CLIENT_METHODS = {
-  session_request_permission: "session/request_permission",
-  session_update: "session/update",
-  fs_write_text_file: "fs/write_text_file",
-  fs_read_text_file: "fs/read_text_file",
-  terminal_create: "terminal/create",
-  terminal_output: "terminal/output",
-  terminal_release: "terminal/release",
-  terminal_wait_for_exit: "terminal/wait_for_exit",
-  terminal_kill: "terminal/kill",
-  mcp_connect: "mcp/connect",
-  mcp_message: "mcp/message",
-  mcp_disconnect: "mcp/disconnect",
-  elicitation_create: "elicitation/create",
-  elicitation_complete: "elicitation/complete"
-};
-var PROTOCOL_METHODS = {
-  cancel_request: "$/cancel_request"
-};
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/schema-deserialize.js
-var skippedItem = Symbol("skippedItem");
-function defaultOnError(schema, fallback) {
-  return schema.catch(fallback);
-}
-function requiredDefaultOnError(schema, fallback) {
-  const schemaWithCatch = schema.catch(fallback);
-  return unknown().transform((value, context) => {
-    if (value !== undefined)
-      return schemaWithCatch.parse(value);
-    context.addIssue({
-      code: "custom",
-      message: "Required value is missing"
-    });
-    return NEVER;
-  });
-}
-function stringTag(value, key) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return;
-  }
-  const tag = value[key];
-  return typeof tag === "string" ? tag : undefined;
-}
-function excludeKnownTags(schema, key, knownTags) {
-  return schema.superRefine((value, context) => {
-    const tag = stringTag(value, key);
-    if (tag !== undefined && knownTags.includes(tag)) {
-      context.addIssue({
-        code: "custom",
-        path: [key],
-        message: `${key} ${JSON.stringify(tag)} is reserved by a known variant, ` + `but the value does not match that variant's schema`
-      });
-    }
-  });
-}
-function preserveCustomPayload(schema, key, knownTags) {
-  return unknown().transform((value, context) => {
-    const result = schema.safeParse(value);
-    if (!result.success) {
-      for (const issue of result.error.issues) {
-        context.addIssue({ ...issue, input: value });
-      }
-      return NEVER;
-    }
-    const output = result.data;
-    const tag = stringTag(value, key);
-    if (tag !== undefined && !knownTags.includes(tag)) {
-      const raw = value;
-      for (const [property, rawValue] of Object.entries(raw)) {
-        if (property === "__proto__")
-          continue;
-        if (!Object.hasOwn(output, property))
-          output[property] = rawValue;
-      }
-    }
-    return output;
-  });
-}
-function vecSkipError(itemSchema) {
-  return array(itemSchema.catch(skippedItem)).transform((items) => items.filter((item) => item !== skippedItem));
-}
-
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/schema/zod.gen.js
-var zRequestId = union([number2(), string2()]).nullable();
-var zSessionId = string2();
-var zWriteTextFileRequest = object({
-  sessionId: zSessionId,
-  path: string2(),
-  content: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zReadTextFileRequest = object({
-  sessionId: zSessionId,
-  path: string2(),
-  line: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  limit: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zToolCallId = string2();
-var zToolKind = union([
-  literal("read"),
-  literal("edit"),
-  literal("delete"),
-  literal("move"),
-  literal("search"),
-  literal("execute"),
-  literal("think"),
-  literal("fetch"),
-  literal("switch_mode"),
-  literal("other")
-]);
-var zToolCallStatus = union([
-  literal("pending"),
-  literal("in_progress"),
-  literal("completed"),
-  literal("failed")
-]);
-var zRole = union([literal("assistant"), literal("user")]);
-var zAnnotations = object({
-  audience: defaultOnError(vecSkipError(zRole).nullish(), () => {
-    return;
-  }),
-  lastModified: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  priority: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTextContent = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => {
-    return;
-  }),
-  text: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zImageContent = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => {
-    return;
-  }),
-  data: string2(),
-  mimeType: string2(),
-  uri: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAudioContent = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => {
-    return;
-  }),
-  data: string2(),
-  mimeType: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zResourceLink = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => {
-    return;
-  }),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  mimeType: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  name: string2(),
-  size: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  uri: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTextResourceContents = object({
-  mimeType: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  text: string2(),
-  uri: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zBlobResourceContents = object({
-  blob: string2(),
-  mimeType: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  uri: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zEmbeddedResourceResource = union([
-  zTextResourceContents,
-  zBlobResourceContents
-]);
-var zEmbeddedResource = object({
-  annotations: defaultOnError(zAnnotations.nullish(), () => {
-    return;
-  }),
-  resource: zEmbeddedResourceResource,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zContentBlock = union([
-  zTextContent.and(object({
-    type: literal("text")
-  })),
-  zImageContent.and(object({
-    type: literal("image")
-  })),
-  zAudioContent.and(object({
-    type: literal("audio")
-  })),
-  zResourceLink.and(object({
-    type: literal("resource_link")
-  })),
-  zEmbeddedResource.and(object({
-    type: literal("resource")
-  }))
-]);
-var zContent = object({
-  content: zContentBlock,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDiff = object({
-  path: string2(),
-  oldText: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  newText: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTerminalId = string2();
-var zTerminal = object({
-  terminalId: zTerminalId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zToolCallContent = union([
-  zContent.and(object({
-    type: literal("content")
-  })),
-  zDiff.and(object({
-    type: literal("diff")
-  })),
-  zTerminal.and(object({
-    type: literal("terminal")
-  }))
-]);
-var zToolCallLocation = object({
-  path: string2(),
-  line: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zToolCallUpdate = object({
-  toolCallId: zToolCallId,
-  kind: defaultOnError(zToolKind.nullish(), () => {
-    return;
-  }),
-  status: defaultOnError(zToolCallStatus.nullish(), () => {
-    return;
-  }),
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  name: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  content: defaultOnError(vecSkipError(zToolCallContent).nullish(), () => {
-    return;
-  }),
-  locations: defaultOnError(vecSkipError(zToolCallLocation).nullish(), () => {
-    return;
-  }),
-  rawInput: defaultOnError(unknown().optional(), () => {
-    return;
-  }),
-  rawOutput: defaultOnError(unknown().optional(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPermissionOptionId = string2();
-var zPermissionOptionKind = union([
-  literal("allow_once"),
-  literal("allow_always"),
-  literal("reject_once"),
-  literal("reject_always")
-]);
-var zPermissionOption = object({
-  optionId: zPermissionOptionId,
-  name: string2(),
-  kind: zPermissionOptionKind,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zRequestPermissionRequest = object({
-  sessionId: zSessionId,
-  toolCall: zToolCallUpdate,
-  options: array(zPermissionOption),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zEnvVariable = object({
-  name: string2(),
-  value: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCreateTerminalRequest = object({
-  sessionId: zSessionId,
-  command: string2(),
-  args: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  env: defaultOnError(vecSkipError(zEnvVariable).optional(), () => []),
-  cwd: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  outputByteLimit: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTerminalOutputRequest = object({
-  sessionId: zSessionId,
-  terminalId: zTerminalId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zReleaseTerminalRequest = object({
-  sessionId: zSessionId,
-  terminalId: zTerminalId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zWaitForTerminalExitRequest = object({
-  sessionId: zSessionId,
-  terminalId: zTerminalId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zKillTerminalRequest = object({
-  sessionId: zSessionId,
-  terminalId: zTerminalId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationSessionScope = object({
-  sessionId: zSessionId,
-  toolCallId: defaultOnError(zToolCallId.nullish(), () => {
-    return;
-  })
-});
-var zElicitationRequestScope = object({
-  requestId: zRequestId
-});
-var zElicitationSchemaType = literal("object");
-var zStringFormat = union([
-  literal("email"),
-  literal("uri"),
-  literal("date"),
-  literal("date-time")
-]);
-var zEnumOption = object({
-  const: string2(),
-  title: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zStringPropertySchema = object({
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  minLength: int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(),
-  maxLength: int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(),
-  pattern: string2().nullish(),
-  format: zStringFormat.nullish(),
-  default: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  enum: array(string2()).nullish(),
-  oneOf: array(zEnumOption).nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNumberPropertySchema = object({
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  minimum: number2().nullish(),
-  maximum: number2().nullish(),
-  default: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zIntegerPropertySchema = object({
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  minimum: number2().nullish(),
-  maximum: number2().nullish(),
-  default: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zBooleanPropertySchema = object({
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  default: defaultOnError(boolean2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zStringMultiSelectItems = object({
-  enum: array(string2()),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTitledMultiSelectItems = object({
-  anyOf: array(zEnumOption),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMultiSelectItems = preserveCustomPayload(union([
-  zStringMultiSelectItems.and(object({
-    type: literal("string")
-  })),
-  excludeKnownTags(object({
-    type: string2()
-  }), "type", ["string"]),
-  zTitledMultiSelectItems
-]), "type", ["string"]);
-var zMultiSelectPropertySchema = object({
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  minItems: number2().nullish(),
-  maxItems: number2().nullish(),
-  items: zMultiSelectItems,
-  default: defaultOnError(vecSkipError(string2()).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationPropertySchema = preserveCustomPayload(union([
-  zStringPropertySchema.and(object({
-    type: literal("string")
-  })),
-  zNumberPropertySchema.and(object({
-    type: literal("number")
-  })),
-  zIntegerPropertySchema.and(object({
-    type: literal("integer")
-  })),
-  zBooleanPropertySchema.and(object({
-    type: literal("boolean")
-  })),
-  zMultiSelectPropertySchema.and(object({
-    type: literal("array")
-  })),
-  excludeKnownTags(object({
-    type: string2()
-  }), "type", ["array", "boolean", "integer", "number", "string"])
-]), "type", ["array", "boolean", "integer", "number", "string"]);
-var zElicitationSchema = object({
-  type: defaultOnError(zElicitationSchemaType.optional().default("object"), () => "object"),
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  properties: record(string2(), zElicitationPropertySchema).optional().default({}),
-  required: array(string2()).nullish(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationFormMode = intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
-  requestedSchema: zElicitationSchema
-}));
-var zElicitationId = string2();
-var zElicitationUrlMode = intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
-  elicitationId: zElicitationId,
-  url: url()
-}));
-var zCreateElicitationRequest = preserveCustomPayload(intersection(union([
-  zElicitationFormMode.and(object({
-    mode: literal("form")
-  })),
-  zElicitationUrlMode.and(object({
-    mode: literal("url")
-  })),
-  excludeKnownTags(intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
-    mode: string2()
-  })), "mode", ["form", "url"])
-]), object({
-  message: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-})), "mode", ["form", "url"]);
-var zMcpServerAcpId = string2();
-var zConnectMcpRequest = object({
-  serverId: zMcpServerAcpId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpConnectionId = string2();
-var zMessageMcpRequest = object({
-  connectionId: zMcpConnectionId,
-  method: string2(),
-  params: record(string2(), unknown()).nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDisconnectMcpRequest = object({
-  connectionId: zMcpConnectionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zExtRequest = unknown();
-var zAgentRequest = object({
-  id: zRequestId,
-  method: string2(),
-  params: union([
-    zWriteTextFileRequest,
-    zReadTextFileRequest,
-    zRequestPermissionRequest,
-    zCreateTerminalRequest,
-    zTerminalOutputRequest,
-    zReleaseTerminalRequest,
-    zWaitForTerminalExitRequest,
-    zKillTerminalRequest,
-    zCreateElicitationRequest,
-    zConnectMcpRequest,
-    zMessageMcpRequest,
-    zDisconnectMcpRequest,
-    zExtRequest
-  ]).nullish()
-});
-var zProtocolVersion = int().gte(0).lte(65535);
-var zPromptCapabilities = object({
-  image: defaultOnError(boolean2().optional().default(false), () => false),
-  audio: defaultOnError(boolean2().optional().default(false), () => false),
-  embeddedContext: defaultOnError(boolean2().optional().default(false), () => false),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpCapabilities = object({
-  http: defaultOnError(boolean2().optional().default(false), () => false),
-  sse: defaultOnError(boolean2().optional().default(false), () => false),
-  acp: defaultOnError(boolean2().optional().default(false), () => false),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionListCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionDeleteCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionAdditionalDirectoriesCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionForkCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionResumeCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionCloseCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionCapabilities = object({
-  list: defaultOnError(zSessionListCapabilities.nullish(), () => {
-    return;
-  }),
-  delete: defaultOnError(zSessionDeleteCapabilities.nullish(), () => {
-    return;
-  }),
-  additionalDirectories: defaultOnError(zSessionAdditionalDirectoriesCapabilities.nullish(), () => {
-    return;
-  }),
-  fork: defaultOnError(zSessionForkCapabilities.nullish(), () => {
-    return;
-  }),
-  resume: defaultOnError(zSessionResumeCapabilities.nullish(), () => {
-    return;
-  }),
-  close: defaultOnError(zSessionCloseCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zLogoutCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAgentAuthCapabilities = object({
-  logout: defaultOnError(zLogoutCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zProvidersCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDocumentDidOpenCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTextDocumentSyncKind = union([
-  literal("full"),
-  literal("incremental")
-]);
-var zNesDocumentDidChangeCapabilities = object({
-  syncKind: zTextDocumentSyncKind,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDocumentDidCloseCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDocumentDidSaveCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDocumentDidFocusCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDocumentEventCapabilities = object({
-  didOpen: defaultOnError(zNesDocumentDidOpenCapabilities.nullish(), () => {
-    return;
-  }),
-  didChange: defaultOnError(zNesDocumentDidChangeCapabilities.nullish(), () => {
-    return;
-  }),
-  didClose: defaultOnError(zNesDocumentDidCloseCapabilities.nullish(), () => {
-    return;
-  }),
-  didSave: defaultOnError(zNesDocumentDidSaveCapabilities.nullish(), () => {
-    return;
-  }),
-  didFocus: defaultOnError(zNesDocumentDidFocusCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesEventCapabilities = object({
-  document: defaultOnError(zNesDocumentEventCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRecentFilesCapabilities = object({
-  maxCount: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRelatedSnippetsCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesEditHistoryCapabilities = object({
-  maxCount: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesUserActionsCapabilities = object({
-  maxCount: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesOpenFilesCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDiagnosticsCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesContextCapabilities = object({
-  recentFiles: defaultOnError(zNesRecentFilesCapabilities.nullish(), () => {
-    return;
-  }),
-  relatedSnippets: defaultOnError(zNesRelatedSnippetsCapabilities.nullish(), () => {
-    return;
-  }),
-  editHistory: defaultOnError(zNesEditHistoryCapabilities.nullish(), () => {
-    return;
-  }),
-  userActions: defaultOnError(zNesUserActionsCapabilities.nullish(), () => {
-    return;
-  }),
-  openFiles: defaultOnError(zNesOpenFilesCapabilities.nullish(), () => {
-    return;
-  }),
-  diagnostics: defaultOnError(zNesDiagnosticsCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesCapabilities = object({
-  events: defaultOnError(zNesEventCapabilities.nullish(), () => {
-    return;
-  }),
-  context: defaultOnError(zNesContextCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPositionEncodingKind = union([
-  literal("utf-16"),
-  literal("utf-32"),
-  literal("utf-8")
-]);
-var zAgentCapabilities = object({
-  loadSession: defaultOnError(boolean2().optional().default(false), () => false),
-  promptCapabilities: defaultOnError(zPromptCapabilities.optional().default({
-    image: false,
-    audio: false,
-    embeddedContext: false
-  }), () => ({
-    image: false,
-    audio: false,
-    embeddedContext: false
-  })),
-  mcpCapabilities: defaultOnError(zMcpCapabilities.optional().default({
-    http: false,
-    sse: false,
-    acp: false
-  }), () => ({
-    http: false,
-    sse: false,
-    acp: false
-  })),
-  sessionCapabilities: defaultOnError(zSessionCapabilities.optional().default({}), () => ({})),
-  auth: defaultOnError(zAgentAuthCapabilities.optional().default({}), () => ({})),
-  providers: defaultOnError(zProvidersCapabilities.nullish(), () => {
-    return;
-  }),
-  nes: defaultOnError(zNesCapabilities.nullish(), () => {
-    return;
-  }),
-  positionEncoding: defaultOnError(zPositionEncodingKind.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthMethodId = string2();
-var zAuthEnvVar = object({
-  name: string2(),
-  label: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  secret: defaultOnError(boolean2().optional().default(true), () => true),
-  optional: defaultOnError(boolean2().optional().default(false), () => false),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthMethodEnvVar = object({
-  id: zAuthMethodId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  vars: requiredDefaultOnError(vecSkipError(zAuthEnvVar), () => []),
-  link: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthMethodTerminal = object({
-  id: zAuthMethodId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  args: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  env: defaultOnError(record(string2(), string2()).optional(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthMethodAgent = object({
-  id: zAuthMethodId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthMethod = union([
-  zAuthMethodEnvVar.and(object({
-    type: literal("env_var")
-  })),
-  zAuthMethodTerminal.and(object({
-    type: literal("terminal")
-  })),
-  zAuthMethodAgent
-]);
-var zImplementation = object({
-  name: string2(),
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  version: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zInitializeResponse = object({
-  protocolVersion: zProtocolVersion,
-  agentCapabilities: defaultOnError(zAgentCapabilities.optional().default({
-    loadSession: false,
-    promptCapabilities: {
-      image: false,
-      audio: false,
-      embeddedContext: false
-    },
-    mcpCapabilities: {
-      http: false,
-      sse: false,
-      acp: false
-    },
-    sessionCapabilities: {},
-    auth: {}
-  }), () => ({
-    loadSession: false,
-    promptCapabilities: {
-      image: false,
-      audio: false,
-      embeddedContext: false
-    },
-    mcpCapabilities: {
-      http: false,
-      sse: false,
-      acp: false
-    },
-    sessionCapabilities: {},
-    auth: {}
-  })),
-  authMethods: defaultOnError(vecSkipError(zAuthMethod).optional().default([]), () => []),
-  agentInfo: defaultOnError(zImplementation.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthenticateResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zProviderId = string2();
-var zLlmProtocol = union([
-  literal("anthropic"),
-  literal("openai"),
-  literal("azure"),
-  literal("vertex"),
-  literal("bedrock"),
-  string2()
-]);
-var zProviderCurrentConfig = object({
-  apiType: zLlmProtocol,
-  baseUrl: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zProviderInfo = object({
-  providerId: zProviderId,
-  supported: requiredDefaultOnError(vecSkipError(zLlmProtocol), () => []),
-  required: boolean2(),
-  current: zProviderCurrentConfig.nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zListProvidersResponse = object({
-  providers: array(zProviderInfo),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSetProviderResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDisableProviderResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zLogoutResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionModeId = string2();
-var zSessionMode = object({
-  id: zSessionModeId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionModeState = object({
-  currentModeId: zSessionModeId,
-  availableModes: requiredDefaultOnError(vecSkipError(zSessionMode), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionConfigId = string2();
-var zSessionConfigOptionCategory = union([
-  literal("mode"),
-  literal("model"),
-  literal("model_config"),
-  literal("thought_level"),
-  string2()
-]);
-var zSessionConfigValueId = string2();
-var zSessionConfigSelectOption = object({
-  value: zSessionConfigValueId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionConfigGroupId = string2();
-var zSessionConfigSelectGroup = object({
-  group: zSessionConfigGroupId,
-  name: string2(),
-  options: requiredDefaultOnError(vecSkipError(zSessionConfigSelectOption), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionConfigSelectOptions = union([
-  array(zSessionConfigSelectOption),
-  array(zSessionConfigSelectGroup)
-]);
-var zSessionConfigSelect = object({
-  currentValue: zSessionConfigValueId,
-  options: zSessionConfigSelectOptions
-});
-var zSessionConfigBoolean = object({
-  currentValue: boolean2()
-});
-var zSessionConfigOption = intersection(union([
-  zSessionConfigSelect.and(object({
-    type: literal("select")
-  })),
-  zSessionConfigBoolean.and(object({
-    type: literal("boolean")
-  }))
-]), object({
-  id: zSessionConfigId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  category: defaultOnError(zSessionConfigOptionCategory.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-}));
-var zNewSessionResponse = object({
-  sessionId: zSessionId,
-  modes: defaultOnError(zSessionModeState.nullish(), () => {
-    return;
-  }),
-  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zLoadSessionResponse = object({
-  modes: defaultOnError(zSessionModeState.nullish(), () => {
-    return;
-  }),
-  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionInfo = object({
-  sessionId: zSessionId,
-  cwd: string2(),
-  additionalDirectories: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  updatedAt: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zListSessionsResponse = object({
-  sessions: requiredDefaultOnError(vecSkipError(zSessionInfo), () => []),
-  nextCursor: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDeleteSessionResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zForkSessionResponse = object({
-  sessionId: zSessionId,
-  modes: defaultOnError(zSessionModeState.nullish(), () => {
-    return;
-  }),
-  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zResumeSessionResponse = object({
-  modes: defaultOnError(zSessionModeState.nullish(), () => {
-    return;
-  }),
-  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCloseSessionResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSetSessionModeResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSetSessionConfigOptionResponse = object({
-  configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zStopReason = union([
-  literal("end_turn"),
-  literal("max_tokens"),
-  literal("max_turn_requests"),
-  literal("refusal"),
-  literal("cancelled")
-]);
-var zUsage = object({
-  totalTokens: number2(),
-  inputTokens: number2(),
-  outputTokens: number2(),
-  thoughtTokens: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  cachedReadTokens: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  cachedWriteTokens: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPromptResponse = object({
-  stopReason: zStopReason,
-  usage: defaultOnError(zUsage.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zStartNesResponse = object({
-  sessionId: zSessionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesSuggestionId = string2();
-var zPosition = object({
-  line: int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }),
-  character: int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zRange = object({
-  start: zPosition,
-  end: zPosition,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesTextEdit = object({
-  range: zRange,
-  newText: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesEditSuggestion = object({
-  id: zNesSuggestionId,
-  uri: string2(),
-  edits: array(zNesTextEdit),
-  cursorPosition: defaultOnError(zPosition.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesJumpSuggestion = object({
-  id: zNesSuggestionId,
-  uri: string2(),
-  position: zPosition,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRenameSuggestion = object({
-  id: zNesSuggestionId,
-  uri: string2(),
-  position: zPosition,
-  newName: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesSearchAndReplaceSuggestion = object({
-  id: zNesSuggestionId,
-  uri: string2(),
-  search: string2(),
-  replace: string2(),
-  isRegex: boolean2().nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesSuggestion = union([
-  zNesEditSuggestion.and(object({
-    kind: literal("edit")
-  })),
-  zNesJumpSuggestion.and(object({
-    kind: literal("jump")
-  })),
-  zNesRenameSuggestion.and(object({
-    kind: literal("rename")
-  })),
-  zNesSearchAndReplaceSuggestion.and(object({
-    kind: literal("searchAndReplace")
-  }))
-]);
-var zSuggestNesResponse = object({
-  suggestions: array(zNesSuggestion),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCloseNesResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zExtResponse = unknown();
-var zMessageMcpResponse = unknown();
-var zErrorCode = union([
-  literal(-32700),
-  literal(-32600),
-  literal(-32601),
-  literal(-32602),
-  literal(-32603),
-  literal(-32800),
-  literal(-32000),
-  literal(-32002),
-  int().min(-2147483648, {
-    error: "Invalid value: Expected int32 to be >= -2147483648"
-  }).max(2147483647, {
-    error: "Invalid value: Expected int32 to be <= 2147483647"
-  })
-]);
-var zError = object({
-  code: zErrorCode,
-  message: string2(),
-  data: defaultOnError(unknown().optional(), () => {
-    return;
-  })
-});
-var zAgentResponse = union([
-  object({
-    id: zRequestId,
-    result: union([
-      zInitializeResponse,
-      zAuthenticateResponse,
-      zListProvidersResponse,
-      zSetProviderResponse,
-      zDisableProviderResponse,
-      zLogoutResponse,
-      zNewSessionResponse,
-      zLoadSessionResponse,
-      zListSessionsResponse,
-      zDeleteSessionResponse,
-      zForkSessionResponse,
-      zResumeSessionResponse,
-      zCloseSessionResponse,
-      zSetSessionModeResponse,
-      zSetSessionConfigOptionResponse,
-      zPromptResponse,
-      zStartNesResponse,
-      zSuggestNesResponse,
-      zCloseNesResponse,
-      zExtResponse,
-      zMessageMcpResponse
-    ])
-  }),
-  object({
-    id: zRequestId,
-    error: zError
-  })
-]);
-var zMessageId = string2();
-var zContentChunk = object({
-  content: zContentBlock,
-  messageId: defaultOnError(zMessageId.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zToolCall = object({
-  toolCallId: zToolCallId,
-  title: string2(),
-  name: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  kind: defaultOnError(zToolKind.optional(), () => {
-    return;
-  }),
-  status: defaultOnError(zToolCallStatus.optional(), () => {
-    return;
-  }),
-  content: defaultOnError(vecSkipError(zToolCallContent).optional(), () => []),
-  locations: defaultOnError(vecSkipError(zToolCallLocation).optional(), () => []),
-  rawInput: defaultOnError(unknown().optional(), () => {
-    return;
-  }),
-  rawOutput: defaultOnError(unknown().optional(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanEntryPriority = union([
-  literal("high"),
-  literal("medium"),
-  literal("low")
-]);
-var zPlanEntryStatus = union([
-  literal("pending"),
-  literal("in_progress"),
-  literal("completed")
-]);
-var zPlanEntry = object({
-  content: string2(),
-  priority: zPlanEntryPriority,
-  status: zPlanEntryStatus,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlan = object({
-  entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanId = string2();
-var zPlanItems = object({
-  planId: zPlanId,
-  entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanFile = object({
-  planId: zPlanId,
-  uri: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanMarkdown = object({
-  planId: zPlanId,
-  content: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanUpdateContent = union([
-  zPlanItems.and(object({
-    type: literal("items")
-  })),
-  zPlanFile.and(object({
-    type: literal("file")
-  })),
-  zPlanMarkdown.and(object({
-    type: literal("markdown")
-  }))
-]);
-var zPlanUpdate = object({
-  plan: zPlanUpdateContent,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanRemoved = object({
-  planId: zPlanId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zUnstructuredCommandInput = object({
-  hint: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAvailableCommandInput = zUnstructuredCommandInput;
-var zAvailableCommand = object({
-  name: string2(),
-  description: string2(),
-  input: defaultOnError(zAvailableCommandInput.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAvailableCommandsUpdate = object({
-  availableCommands: requiredDefaultOnError(vecSkipError(zAvailableCommand), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCurrentModeUpdate = object({
-  currentModeId: zSessionModeId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zConfigOptionUpdate = object({
-  configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionInfoUpdate = object({
-  title: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  updatedAt: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCost = object({
-  amount: number2(),
-  currency: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zUsageUpdate = object({
-  used: number2(),
-  size: number2(),
-  cost: defaultOnError(zCost.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionUpdate = union([
-  zContentChunk.and(object({
-    sessionUpdate: literal("user_message_chunk")
-  })),
-  zContentChunk.and(object({
-    sessionUpdate: literal("agent_message_chunk")
-  })),
-  zContentChunk.and(object({
-    sessionUpdate: literal("agent_thought_chunk")
-  })),
-  zToolCall.and(object({
-    sessionUpdate: literal("tool_call")
-  })),
-  zToolCallUpdate.and(object({
-    sessionUpdate: literal("tool_call_update")
-  })),
-  zPlan.and(object({
-    sessionUpdate: literal("plan")
-  })),
-  zPlanUpdate.and(object({
-    sessionUpdate: literal("plan_update")
-  })),
-  zPlanRemoved.and(object({
-    sessionUpdate: literal("plan_removed")
-  })),
-  zAvailableCommandsUpdate.and(object({
-    sessionUpdate: literal("available_commands_update")
-  })),
-  zCurrentModeUpdate.and(object({
-    sessionUpdate: literal("current_mode_update")
-  })),
-  zConfigOptionUpdate.and(object({
-    sessionUpdate: literal("config_option_update")
-  })),
-  zSessionInfoUpdate.and(object({
-    sessionUpdate: literal("session_info_update")
-  })),
-  zUsageUpdate.and(object({
-    sessionUpdate: literal("usage_update")
-  }))
-]);
-var zSessionNotification = object({
-  sessionId: zSessionId,
-  update: zSessionUpdate,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCompleteElicitationNotification = object({
-  elicitationId: zElicitationId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMessageMcpNotification = object({
-  connectionId: zMcpConnectionId,
-  method: string2(),
-  params: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zExtNotification = unknown();
-var zAgentNotification = object({
-  method: string2(),
-  params: union([
-    zSessionNotification,
-    zCompleteElicitationNotification,
-    zMessageMcpNotification,
-    zExtNotification
-  ]).nullish()
-});
-var zFileSystemCapabilities = object({
-  readTextFile: defaultOnError(boolean2().optional().default(false), () => false),
-  writeTextFile: defaultOnError(boolean2().optional().default(false), () => false),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zBooleanConfigOptionCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSessionConfigOptionsCapabilities = object({
-  boolean: defaultOnError(zBooleanConfigOptionCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zClientSessionCapabilities = object({
-  configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zPlanCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthCapabilities = object({
-  terminal: defaultOnError(boolean2().optional().default(false), () => false),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationFormCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationUrlCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationCapabilities = object({
-  form: defaultOnError(zElicitationFormCapabilities.nullish(), () => {
-    return;
-  }),
-  url: defaultOnError(zElicitationUrlCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesJumpCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRenameCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesSearchAndReplaceCapabilities = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zClientNesCapabilities = object({
-  jump: defaultOnError(zNesJumpCapabilities.nullish(), () => {
-    return;
-  }),
-  rename: defaultOnError(zNesRenameCapabilities.nullish(), () => {
-    return;
-  }),
-  searchAndReplace: defaultOnError(zNesSearchAndReplaceCapabilities.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zClientCapabilities = object({
-  fs: defaultOnError(zFileSystemCapabilities.optional().default({ readTextFile: false, writeTextFile: false }), () => ({ readTextFile: false, writeTextFile: false })),
-  terminal: defaultOnError(boolean2().optional().default(false), () => false),
-  session: defaultOnError(zClientSessionCapabilities.nullish(), () => {
-    return;
-  }),
-  plan: defaultOnError(zPlanCapabilities.nullish(), () => {
-    return;
-  }),
-  auth: defaultOnError(zAuthCapabilities.optional().default({ terminal: false }), () => ({ terminal: false })),
-  elicitation: defaultOnError(zElicitationCapabilities.nullish(), () => {
-    return;
-  }),
-  nes: defaultOnError(zClientNesCapabilities.nullish(), () => {
-    return;
-  }),
-  positionEncodings: defaultOnError(vecSkipError(zPositionEncodingKind).optional(), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zInitializeRequest = object({
-  protocolVersion: zProtocolVersion,
-  clientCapabilities: defaultOnError(zClientCapabilities.optional().default({
-    fs: { readTextFile: false, writeTextFile: false },
-    terminal: false,
-    auth: { terminal: false }
-  }), () => ({
-    fs: { readTextFile: false, writeTextFile: false },
-    terminal: false,
-    auth: { terminal: false }
-  })),
-  clientInfo: defaultOnError(zImplementation.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAuthenticateRequest = object({
-  methodId: zAuthMethodId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zListProvidersRequest = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSetProviderRequest = object({
-  providerId: zProviderId,
-  apiType: zLlmProtocol,
-  baseUrl: string2(),
-  headers: record(string2(), string2()).optional(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDisableProviderRequest = object({
-  providerId: zProviderId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zLogoutRequest = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zHttpHeader = object({
-  name: string2(),
-  value: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpServerHttp = object({
-  name: string2(),
-  url: string2(),
-  headers: array(zHttpHeader),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpServerSse = object({
-  name: string2(),
-  url: string2(),
-  headers: array(zHttpHeader),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpServerAcp = object({
-  name: string2(),
-  serverId: zMcpServerAcpId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpServerStdio = object({
-  name: string2(),
-  command: string2(),
-  args: array(string2()),
-  env: array(zEnvVariable),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zMcpServer = union([
-  zMcpServerHttp.and(object({
-    type: literal("http")
-  })),
-  zMcpServerSse.and(object({
-    type: literal("sse")
-  })),
-  zMcpServerAcp.and(object({
-    type: literal("acp")
-  })),
-  zMcpServerStdio
-]);
-var zNewSessionRequest = object({
-  cwd: string2(),
-  additionalDirectories: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zLoadSessionRequest = object({
-  mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
-  cwd: string2(),
-  additionalDirectories: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  sessionId: zSessionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zListSessionsRequest = object({
-  cwd: string2().nullish(),
-  cursor: string2().nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDeleteSessionRequest = object({
-  sessionId: zSessionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zForkSessionRequest = object({
-  sessionId: zSessionId,
-  cwd: string2(),
-  additionalDirectories: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zResumeSessionRequest = object({
-  sessionId: zSessionId,
-  cwd: string2(),
-  additionalDirectories: defaultOnError(vecSkipError(string2()).optional(), () => []),
-  mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCloseSessionRequest = object({
-  sessionId: zSessionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSetSessionModeRequest = object({
-  sessionId: zSessionId,
-  modeId: zSessionModeId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSetSessionConfigOptionRequest = intersection(union([
-  object({
-    value: boolean2(),
-    type: literal("boolean")
-  }),
-  object({
-    value: zSessionConfigValueId
-  })
-]), object({
-  sessionId: zSessionId,
-  configId: zSessionConfigId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-}));
-var zPromptRequest = object({
-  sessionId: zSessionId,
-  prompt: array(zContentBlock),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zWorkspaceFolder = object({
-  uri: string2(),
-  name: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRepository = object({
-  name: string2(),
-  owner: string2(),
-  remoteUrl: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zStartNesRequest = object({
-  workspaceUri: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  workspaceFolders: array(zWorkspaceFolder).nullish(),
-  repository: defaultOnError(zNesRepository.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesTriggerKind = union([
-  literal("automatic"),
-  literal("diagnostic"),
-  literal("manual")
-]);
-var zNesRecentFile = object({
-  uri: string2(),
-  languageId: string2(),
-  text: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesExcerpt = object({
-  startLine: int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }),
-  endLine: int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }),
-  text: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRelatedSnippet = object({
-  uri: string2(),
-  excerpts: array(zNesExcerpt),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesEditHistoryEntry = object({
-  uri: string2(),
-  diff: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesUserAction = object({
-  action: string2(),
-  uri: string2(),
-  position: zPosition,
-  timestampMs: number2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesOpenFile = object({
-  uri: string2(),
-  languageId: string2(),
-  visibleRange: defaultOnError(zRange.nullish(), () => {
-    return;
-  }),
-  lastFocusedMs: defaultOnError(number2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesDiagnosticSeverity = union([
-  literal("error"),
-  literal("warning"),
-  literal("information"),
-  literal("hint")
-]);
-var zNesDiagnostic = object({
-  uri: string2(),
-  range: zRange,
-  severity: zNesDiagnosticSeverity,
-  message: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesSuggestContext = object({
-  recentFiles: array(zNesRecentFile).nullish(),
-  relatedSnippets: array(zNesRelatedSnippet).nullish(),
-  editHistory: array(zNesEditHistoryEntry).nullish(),
-  userActions: array(zNesUserAction).nullish(),
-  openFiles: array(zNesOpenFile).nullish(),
-  diagnostics: array(zNesDiagnostic).nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSuggestNesRequest = object({
-  sessionId: zSessionId,
-  uri: string2(),
-  version: number2(),
-  position: zPosition,
-  selection: zRange.nullish(),
-  triggerKind: zNesTriggerKind,
-  context: zNesSuggestContext.nullish(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCloseNesRequest = object({
-  sessionId: zSessionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zClientRequest = object({
-  id: zRequestId,
-  method: string2(),
-  params: union([
-    zInitializeRequest,
-    zAuthenticateRequest,
-    zListProvidersRequest,
-    zSetProviderRequest,
-    zDisableProviderRequest,
-    zLogoutRequest,
-    zNewSessionRequest,
-    zLoadSessionRequest,
-    zListSessionsRequest,
-    zDeleteSessionRequest,
-    zForkSessionRequest,
-    zResumeSessionRequest,
-    zCloseSessionRequest,
-    zSetSessionModeRequest,
-    zSetSessionConfigOptionRequest,
-    zPromptRequest,
-    zStartNesRequest,
-    zSuggestNesRequest,
-    zCloseNesRequest,
-    zMessageMcpRequest,
-    zExtRequest
-  ]).nullish()
-});
-var zWriteTextFileResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zReadTextFileResponse = object({
-  content: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zSelectedPermissionOutcome = object({
-  optionId: zPermissionOptionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zRequestPermissionOutcome = union([
-  object({
-    outcome: literal("cancelled")
-  }),
-  zSelectedPermissionOutcome.and(object({
-    outcome: literal("selected")
-  }))
-]);
-var zRequestPermissionResponse = object({
-  outcome: zRequestPermissionOutcome,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zCreateTerminalResponse = object({
-  terminalId: zTerminalId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTerminalExitStatus = object({
-  exitCode: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  signal: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTerminalOutputResponse = object({
-  output: string2(),
-  truncated: boolean2(),
-  exitStatus: defaultOnError(zTerminalExitStatus.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zReleaseTerminalResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zWaitForTerminalExitResponse = object({
-  exitCode: defaultOnError(int().gte(0).max(4294967295, {
-    error: "Invalid value: Expected uint32 to be <= 4294967295"
-  }).nullish(), () => {
-    return;
-  }),
-  signal: defaultOnError(string2().nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zKillTerminalResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zElicitationContentValue = union([
-  string2(),
-  number2(),
-  number2(),
-  boolean2(),
-  array(string2())
-]);
-var zElicitationAcceptAction = object({
-  content: record(string2(), zElicitationContentValue).nullish()
-});
-var zCreateElicitationResponse = preserveCustomPayload(intersection(union([
-  zElicitationAcceptAction.and(object({
-    action: literal("accept")
-  })),
-  object({
-    action: literal("decline")
-  }),
-  object({
-    action: literal("cancel")
-  }),
-  excludeKnownTags(object({
-    action: string2()
-  }), "action", ["accept", "cancel", "decline"])
-]), object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-})), "action", ["accept", "cancel", "decline"]);
-var zConnectMcpResponse = object({
-  connectionId: zMcpConnectionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDisconnectMcpResponse = object({
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zClientResponse = union([
-  object({
-    id: zRequestId,
-    result: union([
-      zWriteTextFileResponse,
-      zReadTextFileResponse,
-      zRequestPermissionResponse,
-      zCreateTerminalResponse,
-      zTerminalOutputResponse,
-      zReleaseTerminalResponse,
-      zWaitForTerminalExitResponse,
-      zKillTerminalResponse,
-      zCreateElicitationResponse,
-      zConnectMcpResponse,
-      zDisconnectMcpResponse,
-      zMessageMcpResponse,
-      zExtResponse
-    ])
-  }),
-  object({
-    id: zRequestId,
-    error: zError
-  })
-]);
-var zCancelNotification = object({
-  sessionId: zSessionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDidOpenDocumentNotification = object({
-  sessionId: zSessionId,
-  uri: string2(),
-  languageId: string2(),
-  version: number2(),
-  text: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zTextDocumentContentChangeEvent = object({
-  range: zRange.nullish(),
-  text: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDidChangeDocumentNotification = object({
-  sessionId: zSessionId,
-  uri: string2(),
-  version: number2(),
-  contentChanges: requiredDefaultOnError(vecSkipError(zTextDocumentContentChangeEvent), () => []),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDidCloseDocumentNotification = object({
-  sessionId: zSessionId,
-  uri: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDidSaveDocumentNotification = object({
-  sessionId: zSessionId,
-  uri: string2(),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zDidFocusDocumentNotification = object({
-  sessionId: zSessionId,
-  uri: string2(),
-  version: number2(),
-  position: zPosition,
-  visibleRange: zRange,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zAcceptNesNotification = object({
-  sessionId: zSessionId,
-  id: zNesSuggestionId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zNesRejectReason = union([
-  literal("rejected"),
-  literal("ignored"),
-  literal("replaced"),
-  literal("cancelled")
-]);
-var zRejectNesNotification = object({
-  sessionId: zSessionId,
-  id: zNesSuggestionId,
-  reason: defaultOnError(zNesRejectReason.nullish(), () => {
-    return;
-  }),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-var zClientNotification = object({
-  method: string2(),
-  params: union([
-    zCancelNotification,
-    zDidOpenDocumentNotification,
-    zDidChangeDocumentNotification,
-    zDidCloseDocumentNotification,
-    zDidSaveDocumentNotification,
-    zDidFocusDocumentNotification,
-    zAcceptNesNotification,
-    zRejectNesNotification,
-    zMessageMcpNotification,
-    zExtNotification
-  ]).nullish()
-});
-var zCancelRequestNotification = object({
-  requestId: zRequestId,
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => {
-    return;
-  })
-});
-
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
-var CANCEL_REQUEST_METHOD = "$/cancel_request";
-function isRequestMessage(value) {
-  return isJsonRpcEnvelope(value) && "id" in value && typeof value["method"] === "string" && isJsonRpcId(value["id"]);
-}
-function isResponseMessage(value) {
-  if (!isJsonRpcEnvelope(value) || "method" in value) {
-    return false;
-  }
-  if (!("id" in value) || !isJsonRpcId(value["id"])) {
-    return false;
-  }
-  const hasResult = Object.hasOwn(value, "result");
-  const hasError = Object.hasOwn(value, "error");
-  if (hasResult === hasError) {
-    return false;
-  }
-  return !hasError || isErrorResponse(value["error"]);
-}
-function isNotificationMessage(value) {
-  return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function isJsonRpcEnvelope(value) {
-  return isRecord(value) && value["jsonrpc"] === "2.0";
-}
-function isJsonRpcId(value) {
-  return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
-}
-function isResponseShapedMessage(value) {
-  return isRecord(value) && !("method" in value) && (("id" in value) || ("result" in value) || ("error" in value));
-}
-function isResponseBatch(batch) {
-  let hasValidCall = false;
-  let hasValidResponse = false;
-  let hasCallShape = false;
-  let hasResponseShape = false;
-  for (const entry of batch) {
-    hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
-    hasValidResponse ||= isResponseMessage(entry);
-    if (!isRecord(entry)) {
-      continue;
-    }
-    hasCallShape ||= "method" in entry;
-    hasResponseShape ||= "result" in entry || "error" in entry;
-  }
-  if (hasValidCall) {
-    return false;
-  }
-  if (hasValidResponse) {
-    return true;
-  }
-  return hasResponseShape && !hasCallShape;
-}
-function cancelRequestId(params) {
-  if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
-    return;
-  }
-  return params["requestId"];
-}
-function isErrorResponse(value) {
-  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
-}
-var Handled = {
-  yes() {
-    return { handled: true };
-  },
-  no(message, retry = false) {
-    return { handled: false, message, retry };
-  }
-};
-function rejectedPromise(error) {
-  const promise = Promise.reject(error);
-  promise.catch(() => {});
-  return promise;
-}
-function errorDetails(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string") {
-    return error.message;
-  }
-  return;
-}
-function isZodError(error) {
-  return typeof error === "object" && error !== null && "name" in error && error.name === "ZodError" && "issues" in error && Array.isArray(error.issues) && "format" in error && typeof error.format === "function";
-}
-function errorToResult(error) {
-  if (error instanceof RequestError) {
-    return error.toResult();
-  }
-  if (isZodError(error)) {
-    return RequestError.invalidParams(error.format()).toResult();
-  }
-  const details = errorDetails(error);
-  try {
-    return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
-  } catch {
-    return RequestError.internalError({ details }).toResult();
-  }
-}
-function requestCancelledError(reason) {
-  if (reason instanceof RequestError && reason.code === -32800) {
-    return reason;
-  }
-  return RequestError.requestCancelled(reason);
-}
-function errorToRequestResult(error, signal) {
-  const requestCancelled = abortErrorToRequestCancelled(error, signal);
-  return requestCancelled ? requestCancelled.toResult() : errorToResult(error);
-}
-function abortErrorToRequestCancelled(error, signal) {
-  if (!signal.aborted || !isAbortError(error)) {
-    return;
-  }
-  return requestCancelledError(signal.reason);
-}
-function isAbortError(error) {
-  if (typeof error !== "object" || error === null) {
-    return false;
-  }
-  const maybeAbortError = error;
-  return maybeAbortError.name === "AbortError" || maybeAbortError.code === "ABORT_ERR";
-}
-
-class RequestResponder {
-  id;
-  sendResult;
-  signal;
-  finishRequest;
-  didRespond = false;
-  constructor(id, sendResult, signal = new AbortController().signal, finishRequest) {
-    this.id = id;
-    this.sendResult = sendResult;
-    this.signal = signal;
-    this.finishRequest = finishRequest;
-  }
-  get responded() {
-    return this.didRespond;
-  }
-  respond(response) {
-    return this.respondWithResult({ result: response ?? null });
-  }
-  respondWithError(error) {
-    const errorResponse = error instanceof RequestError ? error.toErrorResponse() : error;
-    return this.respondWithResult({ error: errorResponse });
-  }
-  respondWithResult(result) {
-    if (this.didRespond) {
-      return rejectedPromise(new Error("JSON-RPC request already responded"));
-    }
-    this.didRespond = true;
-    return this.sendResult(result).finally(() => {
-      this.finishRequest?.();
-    });
-  }
-}
-
-class HandlerRegistration {
-  disposeHandler;
-  active = true;
-  constructor(disposeHandler) {
-    this.disposeHandler = disposeHandler;
-  }
-  dispose() {
-    if (!this.active) {
-      return;
-    }
-    this.active = false;
-    this.disposeHandler();
-  }
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-  runIndefinitely() {
-    return this;
-  }
-}
-
-class ConnectionContext {
-  connection;
-  constructor(connection) {
-    this.connection = connection;
-  }
-  sendRequest(method, params, mapResponse, options) {
-    return this.connection.sendRequest(method, params, mapResponse, options);
-  }
-  sendNotification(method, params) {
-    return this.connection.sendNotification(method, params);
-  }
-  sendBatch(entries) {
-    return this.connection.sendBatch(entries);
-  }
-  sendCancelRequest(requestId) {
-    return this.connection.sendCancelRequest(requestId);
-  }
-  addDynamicHandler(handler) {
-    return this.connection.addDynamicHandler(handler);
-  }
-  get signal() {
-    return this.connection.signal;
-  }
-  get closed() {
-    return this.connection.closed;
-  }
-}
-
-class Connection {
-  pendingResponses = new Map;
-  incomingRequests = new Map;
-  nextRequestId = 0;
-  staticHandlers = [];
-  dynamicHandlers = new Set;
-  stream;
-  writeQueue = Promise.resolve();
-  abortController = new AbortController;
-  closedPromise;
-  retryQueue = [];
-  context = new ConnectionContext(this);
-  receiveReader;
-  allowBatches = true;
-  constructor(requestHandlerOrStream, notificationHandlerOrHandlers, streamOrOptions, options) {
-    if (typeof requestHandlerOrStream === "function") {
-      const requestHandler = requestHandlerOrStream;
-      const notificationHandler = notificationHandlerOrHandlers;
-      const stream = streamOrOptions;
-      this.initialize(stream, [
-        ...options?.handlers ?? [],
-        this.legacyHandler(requestHandler, notificationHandler)
-      ], options);
-      return;
-    }
-    const stream = requestHandlerOrStream;
-    const handlers = notificationHandlerOrHandlers;
-    const connectionOptions = streamOrOptions;
-    this.initialize(stream, [...connectionOptions?.handlers ?? [], ...handlers], connectionOptions);
-  }
-  static builder() {
-    return new ConnectionBuilder;
-  }
-  runUntil(op) {
-    let opSettled = false;
-    const opPromise = Promise.resolve().then(() => op(this.context)).finally(() => {
-      opSettled = true;
-    });
-    const closedPromise = this.closed.then(() => {
-      if (opSettled) {
-        return new Promise(() => {});
-      }
-      throw this.closedReason();
-    });
-    return Promise.race([opPromise, closedPromise]).finally(() => {
-      opSettled = true;
-      this.close();
-    });
-  }
-  addDynamicHandler(handler) {
-    this.dynamicHandlers.add(handler);
-    if (this.retryQueue.length > 0) {
-      for (const message of this.retryQueue.splice(0)) {
-        this.processIncomingMessage(message).catch((error) => this.close(error));
-      }
-    }
-    return new HandlerRegistration(() => {
-      this.dynamicHandlers.delete(handler);
-    });
-  }
-  get signal() {
-    return this.abortController.signal;
-  }
-  get closed() {
-    return this.closedPromise;
-  }
-  getContext() {
-    return this.context;
-  }
-  sendRequest(method, params, mapResponse, options = {}) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    const request = this.prepareRequest(method, params, mapResponse, options);
-    const requestSent = this.sendWireMessage(request.message);
-    requestSent.catch(() => {});
-    if (options.cancellationSignal?.aborted) {
-      request.cancel();
-    }
-    return request.response;
-  }
-  sendBatch(entries) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    if (!this.allowBatches) {
-      return rejectedPromise(new TypeError("JSON-RPC batches are not supported on this connection"));
-    }
-    if (entries.length === 0) {
-      return rejectedPromise(new TypeError("JSON-RPC batch must contain at least one entry"));
-    }
-    const messages = [];
-    const cancellations = [];
-    const outputs = [];
-    for (const entry of entries) {
-      if (entry.kind === "notification") {
-        messages.push({
-          jsonrpc: "2.0",
-          method: entry.method,
-          params: entry.params
-        });
-        outputs.push(Promise.resolve(undefined));
-        continue;
-      }
-      const request = this.prepareRequest(entry.method, entry.params, entry.mapResponse, entry.options);
-      messages.push(request.message);
-      outputs.push(request.response);
-      cancellations.push({
-        signal: entry.options?.cancellationSignal,
-        cancel: request.cancel
-      });
-    }
-    const batch = messages;
-    const batchSent = this.sendWireMessage(batch);
-    for (const cancellation of cancellations) {
-      if (cancellation.signal?.aborted) {
-        cancellation.cancel();
-      }
-    }
-    const response = Promise.all([batchSent, ...outputs]).then(([, ...resolved]) => resolved);
-    response.catch(() => {});
-    return response;
-  }
-  sendCancelRequest(requestId) {
-    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
-  }
-  sendNotification(method, params) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    return this.sendWireMessage({ jsonrpc: "2.0", method, params });
-  }
-  prepareRequest(method, params, mapResponse, options = {}) {
-    const id = this.nextRequestId++;
-    let cancel = () => {};
-    const response = new Promise((resolve, reject) => {
-      const pendingResponse = {
-        resolve: (value) => {
-          try {
-            resolve(mapResponse ? mapResponse(value) : value);
-          } catch (error) {
-            reject(error);
-          }
-        },
-        reject
-      };
-      cancel = () => {
-        if (pendingResponse.cancellationSent) {
-          return;
-        }
-        pendingResponse.cancellationSent = true;
-        pendingResponse.cleanup?.();
-        this.sendCancelRequest(id).catch(() => {});
-      };
-      options.cancellationSignal?.addEventListener("abort", cancel, {
-        once: true
-      });
-      pendingResponse.cleanup = () => {
-        options.cancellationSignal?.removeEventListener("abort", cancel);
-      };
-      this.pendingResponses.set(id, pendingResponse);
-    });
-    response.catch(() => {});
-    return {
-      message: { jsonrpc: "2.0", id, method, params },
-      response,
-      cancel: () => cancel()
-    };
-  }
-  close(error) {
-    if (this.abortController.signal.aborted) {
-      return;
-    }
-    const closeError = error ?? new Error("ACP connection closed");
-    this.abortController.abort(closeError);
-    for (const pendingResponse of this.pendingResponses.values()) {
-      pendingResponse.cleanup?.();
-      pendingResponse.reject(closeError);
-    }
-    this.pendingResponses.clear();
-    for (const controller of this.incomingRequests.values()) {
-      controller.abort(closeError);
-    }
-    this.incomingRequests.clear();
-    this.receiveReader?.cancel(closeError).catch(() => {});
-  }
-  initialize(stream, handlers, options) {
-    this.stream = stream;
-    this.staticHandlers = handlers;
-    this.allowBatches = options?.allowBatches ?? true;
-    this.closedPromise = new Promise((resolve) => {
-      this.abortController.signal.addEventListener("abort", () => resolve());
-    });
-    this.receive();
-  }
-  legacyHandler(requestHandler, notificationHandler) {
-    return {
-      handleMessage: async (message, cx) => {
-        if (message.kind === "request") {
-          const result = await requestHandler(message.method, message.params, cx);
-          await message.responder.respond(result);
-        } else {
-          await notificationHandler(message.method, message.params, cx);
-        }
-        return Handled.yes();
-      }
-    };
-  }
-  async receive() {
-    let closeError = undefined;
-    try {
-      const reader = this.stream.readable.getReader();
-      this.receiveReader = reader;
-      try {
-        while (!this.abortController.signal.aborted) {
-          const { value: message, done } = await reader.read();
-          if (this.abortController.signal.aborted) {
-            break;
-          }
-          if (done) {
-            break;
-          }
-          if (!message) {
-            continue;
-          }
-          this.receiveWireMessage(message);
-        }
-      } finally {
-        if (this.receiveReader === reader) {
-          this.receiveReader = undefined;
-        }
-        reader.releaseLock();
-      }
-    } catch (error) {
-      closeError = error;
-    } finally {
-      this.close(closeError);
-    }
-  }
-  receiveWireMessage(message) {
-    if (Array.isArray(message)) {
-      if (!this.allowBatches) {
-        this.close(new TypeError("JSON-RPC batches are not supported on this connection"));
-        return;
-      }
-      this.receiveBatch(message);
-      return;
-    }
-    if (!isRecord(message)) {
-      console.error("Invalid message", { message });
-      return;
-    }
-    this.receiveMessage(message);
-  }
-  receiveBatch(batch) {
-    if (batch.length === 0) {
-      this.sendWireMessage({
-        jsonrpc: "2.0",
-        id: null,
-        error: RequestError.invalidRequest(batch).toErrorResponse()
-      }).catch(() => {});
-      return;
-    }
-    const responseBatch = isResponseBatch(batch);
-    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
-    let remaining = responseCount;
-    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
-    let responseSent = false;
-    const responses = [];
-    const sendResponsesIfReady = async () => {
-      if (responseSent || remaining !== 0 || remainingNotifications !== 0 || responses.length === 0) {
-        return;
-      }
-      responseSent = true;
-      await this.sendWireMessage(responses);
-    };
-    const collectResponse = async (response) => {
-      responses.push(response);
-      remaining -= 1;
-      await sendResponsesIfReady();
-    };
-    for (const message of batch) {
-      if (responseBatch) {
-        if (isResponseShapedMessage(message)) {
-          this.receiveMessage(message);
-        }
-        continue;
-      }
-      if (!isRequestMessage(message) && !isNotificationMessage(message)) {
-        collectResponse({
-          jsonrpc: "2.0",
-          id: null,
-          error: RequestError.invalidRequest(message).toErrorResponse()
-        }).catch(() => {});
-        continue;
-      }
-      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : undefined);
-      if (isNotificationMessage(message)) {
-        processing.finally(() => {
-          remainingNotifications -= 1;
-          sendResponsesIfReady().catch((error) => this.close(error));
-        });
-      }
-    }
-  }
-  receiveMessage(message, sendResponse) {
-    if (this.abortController.signal.aborted) {
-      return Promise.resolve();
-    }
-    if (!isRecord(message)) {
-      console.error("Invalid message", { message });
-      return Promise.resolve();
-    }
-    if ("method" in message) {
-      if (!("id" in message)) {
-        this.handleProtocolNotification(message);
-      }
-      return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse)).catch((error) => this.close(error));
-    } else if ("id" in message) {
-      this.handleResponse(message);
-    } else {
-      console.error("Invalid message", { message });
-    }
-    return Promise.resolve();
-  }
-  async processIncomingMessage(message) {
-    if (this.abortController.signal.aborted) {
-      return;
-    }
-    let current = message;
-    let retry = false;
-    try {
-      for (const handler of [
-        ...this.staticHandlers,
-        ...this.dynamicHandlers.values()
-      ]) {
-        if (this.abortController.signal.aborted) {
-          return;
-        }
-        const result = await handler.handleMessage(current, this.context) ?? {
-          handled: true
-        };
-        if (result.handled) {
-          return;
-        }
-        current = result.message ?? current;
-        retry = retry || Boolean(result.retry);
-      }
-      if (retry) {
-        this.retryQueue.push(current);
-      } else if (current.kind === "request") {
-        await current.responder.respondWithError(RequestError.methodNotFound(current.method));
-      }
-    } catch (error) {
-      if (this.abortController.signal.aborted) {
-        return;
-      }
-      if (current.kind === "request" && !current.responder.responded) {
-        await current.responder.respondWithResult(errorToRequestResult(error, current.responder.signal));
-      } else {
-        const response = errorToResult(error);
-        if ("error" in response) {
-          console.error("Error handling notification", message.raw, response.error);
-        }
-      }
-    }
-  }
-  toIncomingMessage(message, sendResponse) {
-    if ("id" in message) {
-      const abortController = new AbortController;
-      this.incomingRequests.set(message.id, abortController);
-      const finishRequest = () => {
-        if (this.incomingRequests.get(message.id) === abortController) {
-          this.incomingRequests.delete(message.id);
-        }
-      };
-      return {
-        kind: "request",
-        method: message.method,
-        params: message.params,
-        raw: message,
-        signal: abortController.signal,
-        responder: new RequestResponder(message.id, (result) => {
-          const response = {
-            jsonrpc: "2.0",
-            id: message.id,
-            ...result
-          };
-          return sendResponse ? sendResponse(response) : this.sendWireMessage(response);
-        }, abortController.signal, finishRequest)
-      };
-    }
-    return {
-      kind: "notification",
-      method: message.method,
-      params: message.params,
-      raw: message
-    };
-  }
-  handleResponse(response) {
-    const pendingResponse = this.pendingResponses.get(response.id);
-    if (pendingResponse) {
-      this.pendingResponses.delete(response.id);
-      pendingResponse.cleanup?.();
-      if (!isResponseMessage(response)) {
-        pendingResponse.reject(RequestError.invalidRequest(response));
-      } else if ("result" in response) {
-        pendingResponse.resolve(response.result);
-      } else {
-        const { code, message, data } = response.error;
-        pendingResponse.reject(new RequestError(code, message, data));
-      }
-    } else {
-      console.error("Got response to unknown request", response.id);
-    }
-  }
-  handleProtocolNotification(message) {
-    if (message.method !== CANCEL_REQUEST_METHOD) {
-      return;
-    }
-    const requestId = cancelRequestId(message.params);
-    if (requestId === undefined) {
-      return;
-    }
-    const controller = this.incomingRequests.get(requestId);
-    if (!controller || controller.signal.aborted) {
-      return;
-    }
-    controller.abort(RequestError.requestCancelled({ requestId }));
-  }
-  closedReason() {
-    return this.abortController.signal.reason ?? new Error("ACP connection closed");
-  }
-  async sendWireMessage(message) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    this.writeQueue = this.writeQueue.then(async () => {
-      if (this.abortController.signal.aborted) {
-        throw this.closedReason();
-      }
-      const writer = this.stream.writable.getWriter();
-      try {
-        await writer.write(message);
-      } finally {
-        writer.releaseLock();
-      }
-    }).catch((error) => {
-      this.close(error);
-      throw error;
-    });
-    return this.writeQueue;
-  }
-}
-
-class ConnectionBuilder {
-  handlers = [];
-  connectionName;
-  name(name) {
-    this.connectionName = name;
-    return this;
-  }
-  withHandler(handler) {
-    this.handlers.push(handler);
-    return this;
-  }
-  onReceiveMessage(handler) {
-    return this.withHandler({
-      handleMessage: async (message, cx) => await handler(message, cx) ?? Handled.no(message),
-      describe: () => this.connectionName ?? "onReceiveMessage"
-    });
-  }
-  onReceiveRequest(method, parse, handler) {
-    return this.withHandler({
-      handleMessage: async (message, cx) => {
-        if (message.kind !== "request" || message.method !== method) {
-          return Handled.no(message);
-        }
-        const request = parse(message.params);
-        return await handler(request, message.responder, cx) ?? Handled.yes();
-      },
-      describe: () => `${this.connectionName ?? "request"}:${method}`
-    });
-  }
-  onReceiveNotification(method, parse, handler) {
-    return this.withHandler({
-      handleMessage: async (message, cx) => {
-        if (message.kind !== "notification" || message.method !== method) {
-          return Handled.no(message);
-        }
-        const notification = parse(message.params);
-        return await handler(notification, cx) ?? Handled.yes();
-      },
-      describe: () => `${this.connectionName ?? "notification"}:${method}`
-    });
-  }
-  connect(stream, options) {
-    return new Connection(stream, this.handlers, options);
-  }
-  connectWith(stream, op, options) {
-    return this.connect(stream, options).runUntil(op);
-  }
-}
-
-class RequestError extends Error {
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.name = "RequestError";
-    this.data = data;
-  }
-  static parseError(data, additionalMessage) {
-    return new RequestError(-32700, `Parse error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-  }
-  static invalidRequest(data, additionalMessage) {
-    return new RequestError(-32600, `Invalid request${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-  }
-  static methodNotFound(method) {
-    return new RequestError(-32601, `"Method not found": ${method}`, {
-      method
-    });
-  }
-  static invalidParams(data, additionalMessage) {
-    return new RequestError(-32602, `Invalid params${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-  }
-  static internalError(data, additionalMessage) {
-    return new RequestError(-32603, `Internal error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-  }
-  static requestCancelled(data, additionalMessage) {
-    return new RequestError(-32800, `Request cancelled${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-  }
-  static authRequired(data, additionalMessage) {
-    return new RequestError(-32000, `Authentication required${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-  }
-  static resourceNotFound(uri) {
-    return new RequestError(-32002, `Resource not found${uri ? `: ${uri}` : ""}`, uri && { uri });
-  }
-  toResult() {
-    return {
-      error: {
-        code: this.code,
-        message: this.message,
-        data: this.data
-      }
-    };
-  }
-  toErrorResponse() {
-    return {
-      code: this.code,
-      message: this.message,
-      data: this.data
-    };
-  }
-}
-
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/line-buffer.js
-var newline = 10;
-
-class LineBuffer {
-  #pending = [];
-  push(chunk) {
-    const lines = [];
-    let start = 0;
-    let newlineIndex = chunk.indexOf(newline, start);
-    while (newlineIndex !== -1) {
-      lines.push(this.#takeLine(chunk.subarray(start, newlineIndex)));
-      start = newlineIndex + 1;
-      newlineIndex = chunk.indexOf(newline, start);
-    }
-    if (start < chunk.byteLength) {
-      this.#pending.push(start === 0 ? chunk : new Uint8Array(chunk.subarray(start)));
-    }
-    return lines;
-  }
-  flush() {
-    if (this.#pending.length === 0) {
-      return;
-    }
-    return this.#takeLine(new Uint8Array(0));
-  }
-  #takeLine(tail) {
-    if (this.#pending.length === 0) {
-      return tail;
-    }
-    let total = tail.byteLength;
-    for (const part of this.#pending) {
-      total += part.byteLength;
-    }
-    const line = new Uint8Array(total);
-    let offset = 0;
-    for (const part of this.#pending) {
-      line.set(part, offset);
-      offset += part.byteLength;
-    }
-    line.set(tail, offset);
-    this.#pending = [];
-    return line;
-  }
-}
-
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/stream.js
-function ndJsonStream(output, input) {
-  const textEncoder = new TextEncoder;
-  const textDecoder = new TextDecoder;
-  let cancelled = false;
-  let inputReader;
-  const readable = new ReadableStream({
-    async start(controller) {
-      const lines = new LineBuffer;
-      const enqueueLine = (lineBytes) => {
-        const trimmedLine = textDecoder.decode(lineBytes).trim();
-        if (trimmedLine) {
-          try {
-            const message = JSON.parse(trimmedLine);
-            if (isRecord(message) || Array.isArray(message)) {
-              controller.enqueue(message);
-            } else {
-              console.warn("Skipping JSON line that is not an object:", trimmedLine);
-            }
-          } catch (err) {
-            console.error("Failed to parse JSON message:", trimmedLine, err);
-          }
-        }
-      };
-      const reader = input.getReader();
-      inputReader = reader;
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (cancelled) {
-            return;
-          }
-          if (done) {
-            break;
-          }
-          if (!value) {
-            continue;
-          }
-          for (const line of lines.push(value)) {
-            enqueueLine(line);
-            if (cancelled) {
-              return;
-            }
-          }
-        }
-        if (cancelled) {
-          return;
-        }
-        const lastLine = lines.flush();
-        if (lastLine) {
-          enqueueLine(lastLine);
-        }
-      } catch (err) {
-        if (cancelled) {
-          return;
-        }
-        controller.error(err);
-        return;
-      } finally {
-        if (inputReader === reader) {
-          inputReader = undefined;
-        }
-        reader.releaseLock();
-      }
-      if (cancelled) {
-        return;
-      }
-      controller.close();
-    },
-    cancel(reason) {
-      cancelled = true;
-      return inputReader?.cancel(reason);
-    }
-  });
-  const writable = new WritableStream({
-    async write(message) {
-      const content = JSON.stringify(message) + `
-`;
-      const writer = output.getWriter();
-      try {
-        await writer.write(textEncoder.encode(content));
-      } finally {
-        writer.releaseLock();
-      }
-    }
-  });
-  return { readable, writable };
-}
-
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/schema/guards.gen.js
-var zGuardCreateElicitationRequestForm = zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string2() }));
-var zGuardCreateElicitationRequestUrl = zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string2() }));
-var zGuardCreateElicitationRequestCustom = union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string2() }));
-var zGuardElicitationPropertySchemaString = zStringPropertySchema.and(object({ type: literal("string") }));
-var zGuardElicitationPropertySchemaNumber = zNumberPropertySchema.and(object({ type: literal("number") }));
-var zGuardElicitationPropertySchemaInteger = zIntegerPropertySchema.and(object({ type: literal("integer") }));
-var zGuardElicitationPropertySchemaBoolean = zBooleanPropertySchema.and(object({ type: literal("boolean") }));
-var zGuardElicitationPropertySchemaArray = zMultiSelectPropertySchema.and(object({ type: literal("array") }));
-var zGuardMultiSelectItemsString = zStringMultiSelectItems.and(object({ type: literal("string") }));
-var zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
-var zGuardCreateElicitationResponseDecline = object({
-  action: literal("decline")
-});
-var zGuardCreateElicitationResponseCancel = object({
-  action: literal("cancel")
-});
-// node_modules/.bun/@agentclientprotocol+sdk@1.3.0+68a1e3a0c4588df3/node_modules/@agentclientprotocol/sdk/dist/acp.js
-function ndJsonStream2(output, input) {
-  return ndJsonStream(output, input);
-}
-function emptyObjectResponse(response) {
-  return response ?? {};
-}
-function isStream(value) {
-  return typeof value === "object" && value !== null && "readable" in value && "writable" in value;
-}
-function memoryStreamPair() {
-  const leftToRight = new TransformStream;
-  const rightToLeft = new TransformStream;
-  return [
-    {
-      readable: rightToLeft.readable,
-      writable: leftToRight.writable
-    },
-    {
-      readable: leftToRight.readable,
-      writable: rightToLeft.writable
-    }
-  ];
-}
-var methods = {
-  agent: {
-    initialize: AGENT_METHODS.initialize,
-    authenticate: AGENT_METHODS.authenticate,
-    logout: AGENT_METHODS.logout,
-    providers: {
-      list: AGENT_METHODS.providers_list,
-      set: AGENT_METHODS.providers_set,
-      disable: AGENT_METHODS.providers_disable
-    },
-    session: {
-      new: AGENT_METHODS.session_new,
-      load: AGENT_METHODS.session_load,
-      list: AGENT_METHODS.session_list,
-      delete: AGENT_METHODS.session_delete,
-      fork: AGENT_METHODS.session_fork,
-      resume: AGENT_METHODS.session_resume,
-      close: AGENT_METHODS.session_close,
-      setMode: AGENT_METHODS.session_set_mode,
-      setConfigOption: AGENT_METHODS.session_set_config_option,
-      prompt: AGENT_METHODS.session_prompt,
-      cancel: AGENT_METHODS.session_cancel
-    },
-    nes: {
-      start: AGENT_METHODS.nes_start,
-      suggest: AGENT_METHODS.nes_suggest,
-      accept: AGENT_METHODS.nes_accept,
-      reject: AGENT_METHODS.nes_reject,
-      close: AGENT_METHODS.nes_close
-    },
-    document: {
-      didOpen: AGENT_METHODS.document_did_open,
-      didChange: AGENT_METHODS.document_did_change,
-      didClose: AGENT_METHODS.document_did_close,
-      didSave: AGENT_METHODS.document_did_save,
-      didFocus: AGENT_METHODS.document_did_focus
-    }
-  },
-  client: {
-    session: {
-      requestPermission: CLIENT_METHODS.session_request_permission,
-      update: CLIENT_METHODS.session_update
-    },
-    fs: {
-      writeTextFile: CLIENT_METHODS.fs_write_text_file,
-      readTextFile: CLIENT_METHODS.fs_read_text_file
-    },
-    terminal: {
-      create: CLIENT_METHODS.terminal_create,
-      output: CLIENT_METHODS.terminal_output,
-      release: CLIENT_METHODS.terminal_release,
-      waitForExit: CLIENT_METHODS.terminal_wait_for_exit,
-      kill: CLIENT_METHODS.terminal_kill
-    },
-    elicitation: {
-      create: CLIENT_METHODS.elicitation_create,
-      complete: CLIENT_METHODS.elicitation_complete
-    }
-  },
-  protocol: {
-    cancelRequest: PROTOCOL_METHODS.cancel_request
-  }
-};
-var startActiveSession = Symbol("startActiveSession");
-
-class AcpContext {
-  cx;
-  currentRequestId;
-  constructor(cx, currentRequestId) {
-    this.cx = cx;
-    this.currentRequestId = currentRequestId;
-  }
-  get requestId() {
-    return this.currentRequestId;
-  }
-  get connectionContext() {
-    return this.cx;
-  }
-  sendRequest(method, params, mapResponse, options) {
-    return this.cx.sendRequest(method, params, mapResponse, options);
-  }
-  sendNotification(method, params) {
-    return this.cx.sendNotification(method, params);
-  }
-  addDynamicHandler(handler) {
-    return this.cx.addDynamicHandler(handler);
-  }
-}
-
-class AgentContext extends AcpContext {
-  constructor(cx, requestId) {
-    super(cx, requestId);
-  }
-  static create(cx, requestId) {
-    return new AgentContext(cx, requestId);
-  }
-  request(method, params, options) {
-    const spec = clientRequestSpecsByMethod[method];
-    return this.sendRequest(method, params, spec?.mapResponse, options);
-  }
-  notify(method, params) {
-    return this.sendNotification(method, params);
-  }
-}
-
-class ClientContext extends AcpContext {
-  constructor(cx, requestId) {
-    super(cx, requestId);
-  }
-  static create(cx, requestId) {
-    return new ClientContext(cx, requestId);
-  }
-  [startActiveSession](params, options) {
-    return this.sendRequest(AGENT_METHODS.session_new, params, (response) => this.attachSession(response), options);
-  }
-  buildSession(cwdOrRequest) {
-    if (typeof cwdOrRequest === "string") {
-      return SessionBuilder.create(this, {
-        cwd: cwdOrRequest,
-        mcpServers: []
-      });
-    }
-    return SessionBuilder.create(this, cwdOrRequest);
-  }
-  attachSession(response) {
-    const updates = new AsyncQueue;
-    const closeSignal = this.connectionContext.signal;
-    const failUpdatesOnClose = () => {
-      updates.fail(closeSignal.reason ?? new Error("ACP connection closed"));
-    };
-    if (closeSignal.aborted) {
-      failUpdatesOnClose();
-    } else {
-      closeSignal.addEventListener("abort", failUpdatesOnClose);
-    }
-    const sessionRegistration = sessionUpdateRouter(this.connectionContext).attach(response, updates);
-    const closeRegistration = new HandlerRegistration(() => {
-      closeSignal.removeEventListener("abort", failUpdatesOnClose);
-    });
-    return ActiveSession.create(this, response, updates, [
-      sessionRegistration,
-      closeRegistration
-    ]);
-  }
-  request(method, params, options) {
-    const spec = agentRequestSpecsByMethod[method];
-    return this.sendRequest(method, params, spec?.mapResponse, options);
-  }
-  notify(method, params) {
-    return this.sendNotification(method, params);
-  }
-}
-
-class AcpConnectionHandle {
-  connection;
-  constructor(connection) {
-    this.connection = connection;
-  }
-  get signal() {
-    return this.connection.signal;
-  }
-  get closed() {
-    return this.connection.closed;
-  }
-  close(error) {
-    this.connection.close(error);
-  }
-}
-
-class AgentConnectionHandle extends AcpConnectionHandle {
-  connectHandlers;
-  client;
-  didStartConnectHandlers = false;
-  constructor(connection, connectHandlers = []) {
-    super(connection);
-    this.connectHandlers = connectHandlers;
-    this.client = AgentContext.create(connection.getContext());
-  }
-  startConnectHandlers() {
-    if (this.didStartConnectHandlers) {
-      return;
-    }
-    this.didStartConnectHandlers = true;
-    runConnectHandlers(this, this.connectHandlers);
-  }
-}
-
-class ClientConnectionHandle extends AcpConnectionHandle {
-  connectHandlers;
-  agent;
-  didStartConnectHandlers = false;
-  constructor(connection, connectHandlers = []) {
-    super(connection);
-    this.connectHandlers = connectHandlers;
-    this.agent = ClientContext.create(connection.getContext());
-  }
-  startConnectHandlers() {
-    if (this.didStartConnectHandlers) {
-      return;
-    }
-    this.didStartConnectHandlers = true;
-    runConnectHandlers(this, this.connectHandlers);
-  }
-}
-function agentConnection(connection, connectHandlers = []) {
-  return new AgentConnectionHandle(connection, connectHandlers);
-}
-function clientConnection(connection, connectHandlers = []) {
-  return new ClientConnectionHandle(connection, connectHandlers);
-}
-
-class AsyncQueue {
-  values = [];
-  waiters = [];
-  failed = false;
-  failure;
-  enqueue(value) {
-    if (this.failed) {
-      return;
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter.resolve(value);
-    } else {
-      this.values.push({ kind: "value", value });
-    }
-  }
-  reject(error) {
-    if (this.failed) {
-      return;
-    }
-    if (this.waiters.length > 0) {
-      for (const waiter of this.waiters.splice(0)) {
-        waiter.reject(error);
-      }
-      return;
-    }
-    this.values.push({ kind: "error", error });
-  }
-  clearErrors() {
-    this.values = this.values.filter((entry) => entry.kind === "value");
-  }
-  fail(error) {
-    if (this.failed) {
-      return;
-    }
-    this.failed = true;
-    this.failure = error;
-    for (const waiter of this.waiters.splice(0)) {
-      waiter.reject(error);
-    }
-  }
-  next() {
-    if (this.values.length > 0) {
-      const entry = this.values.shift();
-      if (entry.kind === "error") {
-        return Promise.reject(entry.error);
-      }
-      return Promise.resolve(entry.value);
-    }
-    if (this.failed) {
-      return Promise.reject(this.failure);
-    }
-    return new Promise((resolve, reject) => {
-      this.waiters.push({ resolve, reject });
-    });
-  }
-}
-function cloneNewSessionRequest(request) {
-  return {
-    ...request,
-    additionalDirectories: request.additionalDirectories ? [...request.additionalDirectories] : undefined,
-    mcpServers: [...request.mcpServers]
-  };
-}
-
-class SessionBuilder {
-  cx;
-  request;
-  constructor(cx, request) {
-    this.cx = cx;
-    this.request = cloneNewSessionRequest(request);
-  }
-  static create(cx, request) {
-    return new SessionBuilder(cx, request);
-  }
-  toRequest() {
-    return cloneNewSessionRequest(this.request);
-  }
-  withAdditionalDirectories(additionalDirectories) {
-    this.request = {
-      ...this.request,
-      additionalDirectories: [...additionalDirectories]
-    };
-    return this;
-  }
-  withMcpServer(mcpServer) {
-    this.request = {
-      ...this.request,
-      mcpServers: [...this.request.mcpServers, mcpServer]
-    };
-    return this;
-  }
-  async start(options) {
-    return this.cx[startActiveSession](this.toRequest(), options);
-  }
-  async withSession(op) {
-    const session = await this.start();
-    try {
-      return await op(session);
-    } finally {
-      session.dispose();
-    }
-  }
-}
-
-class ActiveSession {
-  cx;
-  sessionResponse;
-  updates;
-  registrations;
-  constructor(cx, sessionResponse, updates, registrations) {
-    this.cx = cx;
-    this.sessionResponse = sessionResponse;
-    this.updates = updates;
-    this.registrations = registrations;
-  }
-  static create(cx, sessionResponse, updates, registrations) {
-    return new ActiveSession(cx, sessionResponse, updates, registrations);
-  }
-  get sessionId() {
-    return this.sessionResponse.sessionId;
-  }
-  get modes() {
-    return this.sessionResponse.modes;
-  }
-  get meta() {
-    return this.sessionResponse._meta;
-  }
-  get newSessionResponse() {
-    return this.sessionResponse;
-  }
-  prompt(prompt, options) {
-    this.updates.clearErrors();
-    const response = this.cx.request(AGENT_METHODS.session_prompt, {
-      sessionId: this.sessionId,
-      prompt: this.promptBlocks(prompt)
-    }, options);
-    response.then((value) => {
-      this.updates.enqueue({
-        kind: "stop",
-        response: value,
-        stopReason: value.stopReason
-      });
-    }, (error) => {
-      this.updates.reject(error);
-    });
-    return response;
-  }
-  nextUpdate() {
-    return this.updates.next();
-  }
-  async readText() {
-    let output = "";
-    for (;; ) {
-      const message = await this.nextUpdate();
-      if (message.kind === "stop") {
-        return output;
-      }
-      const { update } = message;
-      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-        output += update.content.text;
-      }
-    }
-  }
-  dispose() {
-    for (const registration of this.registrations.splice(0)) {
-      registration.dispose();
-    }
-    this.updates.fail(new Error("Active session disposed"));
-  }
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-  promptBlocks(prompt) {
-    if (typeof prompt === "string") {
-      return [{ type: "text", text: prompt }];
-    }
-    if (Array.isArray(prompt)) {
-      return prompt;
-    }
-    return [prompt];
-  }
-}
-function parseParams(parser, params) {
-  if (!parser) {
-    return params;
-  }
-  if (typeof parser === "function") {
-    return parser(params);
-  }
-  return parser.parse(params);
-}
-function requestSpec(method, params, mapResponse) {
-  return { method, params, mapResponse };
-}
-function notificationSpec(method, params) {
-  return { method, params };
-}
-function registerAppRequest(builder, spec, context, handler) {
-  builder.onReceiveRequest(spec.method, (params) => parseParams(spec.params, params), async (params, responder, cx) => {
-    const response = await handler(context(params, cx, responder.signal, responder.id));
-    await responder.respond(spec.mapResponse ? spec.mapResponse(response) : response);
-  });
-}
-function registerAppNotification(builder, spec, context, handler) {
-  builder.onReceiveNotification(spec.method, (params) => parseParams(spec.params, params), (params, cx) => handler(context(params, cx, cx.signal)));
-}
-function specsByMethod(specs) {
-  const byMethod = {};
-  for (const spec of Object.values(specs)) {
-    byMethod[spec.method] = spec;
-  }
-  return byMethod;
-}
-var agentRequestSpecs = {
-  initialize: requestSpec(AGENT_METHODS.initialize, zInitializeRequest),
-  newSession: requestSpec(AGENT_METHODS.session_new, zNewSessionRequest),
-  loadSession: requestSpec(AGENT_METHODS.session_load, zLoadSessionRequest, emptyObjectResponse),
-  unstable_forkSession: requestSpec(AGENT_METHODS.session_fork, zForkSessionRequest),
-  listSessions: requestSpec(AGENT_METHODS.session_list, zListSessionsRequest),
-  deleteSession: requestSpec(AGENT_METHODS.session_delete, zDeleteSessionRequest, emptyObjectResponse),
-  resumeSession: requestSpec(AGENT_METHODS.session_resume, zResumeSessionRequest),
-  closeSession: requestSpec(AGENT_METHODS.session_close, zCloseSessionRequest, emptyObjectResponse),
-  setSessionMode: requestSpec(AGENT_METHODS.session_set_mode, zSetSessionModeRequest, emptyObjectResponse),
-  setSessionConfigOption: requestSpec(AGENT_METHODS.session_set_config_option, zSetSessionConfigOptionRequest),
-  authenticate: requestSpec(AGENT_METHODS.authenticate, zAuthenticateRequest, emptyObjectResponse),
-  unstable_listProviders: requestSpec(AGENT_METHODS.providers_list, zListProvidersRequest),
-  unstable_setProvider: requestSpec(AGENT_METHODS.providers_set, zSetProviderRequest, emptyObjectResponse),
-  unstable_disableProvider: requestSpec(AGENT_METHODS.providers_disable, zDisableProviderRequest, emptyObjectResponse),
-  logout: requestSpec(AGENT_METHODS.logout, zLogoutRequest, emptyObjectResponse),
-  prompt: requestSpec(AGENT_METHODS.session_prompt, zPromptRequest),
-  unstable_startNes: requestSpec(AGENT_METHODS.nes_start, zStartNesRequest),
-  unstable_suggestNes: requestSpec(AGENT_METHODS.nes_suggest, zSuggestNesRequest),
-  unstable_closeNes: requestSpec(AGENT_METHODS.nes_close, zCloseNesRequest, emptyObjectResponse)
-};
-var agentNotificationSpecs = {
-  cancel: notificationSpec(AGENT_METHODS.session_cancel, zCancelNotification),
-  unstable_didOpenDocument: notificationSpec(AGENT_METHODS.document_did_open, zDidOpenDocumentNotification),
-  unstable_didChangeDocument: notificationSpec(AGENT_METHODS.document_did_change, zDidChangeDocumentNotification),
-  unstable_didCloseDocument: notificationSpec(AGENT_METHODS.document_did_close, zDidCloseDocumentNotification),
-  unstable_didSaveDocument: notificationSpec(AGENT_METHODS.document_did_save, zDidSaveDocumentNotification),
-  unstable_didFocusDocument: notificationSpec(AGENT_METHODS.document_did_focus, zDidFocusDocumentNotification),
-  unstable_acceptNes: notificationSpec(AGENT_METHODS.nes_accept, zAcceptNesNotification),
-  unstable_rejectNes: notificationSpec(AGENT_METHODS.nes_reject, zRejectNesNotification)
-};
-var clientRequestSpecs = {
-  requestPermission: requestSpec(CLIENT_METHODS.session_request_permission, zRequestPermissionRequest),
-  writeTextFile: requestSpec(CLIENT_METHODS.fs_write_text_file, zWriteTextFileRequest, emptyObjectResponse),
-  readTextFile: requestSpec(CLIENT_METHODS.fs_read_text_file, zReadTextFileRequest),
-  createTerminal: requestSpec(CLIENT_METHODS.terminal_create, zCreateTerminalRequest),
-  terminalOutput: requestSpec(CLIENT_METHODS.terminal_output, zTerminalOutputRequest),
-  releaseTerminal: requestSpec(CLIENT_METHODS.terminal_release, zReleaseTerminalRequest, emptyObjectResponse),
-  waitForTerminalExit: requestSpec(CLIENT_METHODS.terminal_wait_for_exit, zWaitForTerminalExitRequest),
-  killTerminal: requestSpec(CLIENT_METHODS.terminal_kill, zKillTerminalRequest, emptyObjectResponse),
-  unstable_createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, zCreateElicitationRequest)
-};
-var clientNotificationSpecs = {
-  sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, zSessionNotification),
-  unstable_completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
-};
-var agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
-var agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
-var clientRequestSpecsByMethod = specsByMethod(clientRequestSpecs);
-var clientNotificationSpecsByMethod = specsByMethod(clientNotificationSpecs);
-function clientRequestContext(params, agent, signal, requestId) {
-  return {
-    params,
-    requestId,
-    signal,
-    agent
-  };
-}
-function clientNotificationContext(params, agent, signal) {
-  return {
-    params,
-    signal,
-    agent
-  };
-}
-
-class SessionUpdateRouter {
-  activeSessions = new Map;
-  handleMessage(message) {
-    if (message.kind !== "notification" || message.method !== CLIENT_METHODS.session_update) {
-      return Handled.no(message);
-    }
-    const notification = zSessionNotification.parse(message.params);
-    const update = {
-      kind: "session_update",
-      notification,
-      update: notification.update
-    };
-    const activeSessions = this.activeSessions.get(notification.sessionId);
-    if (activeSessions && activeSessions.size > 0) {
-      for (const session of activeSessions) {
-        session.enqueue(update);
-      }
-    }
-    return Handled.no(message);
-  }
-  attach(response, updates) {
-    const sessions = this.activeSessions.get(response.sessionId) ?? new Set;
-    sessions.add(updates);
-    this.activeSessions.set(response.sessionId, sessions);
-    return new HandlerRegistration(() => {
-      sessions.delete(updates);
-      if (sessions.size === 0) {
-        this.activeSessions.delete(response.sessionId);
-      }
-    });
-  }
-}
-var sessionUpdateRouters = new WeakMap;
-function sessionUpdateRouter(cx) {
-  let router = sessionUpdateRouters.get(cx);
-  if (!router) {
-    router = new SessionUpdateRouter;
-    sessionUpdateRouters.set(cx, router);
-  }
-  return router;
-}
-function runConnectHandlers(connection, handlers) {
-  for (const handler of handlers) {
-    let result;
-    try {
-      result = handler(connection);
-    } catch (error) {
-      connection.close(error);
-      throw error;
-    }
-    Promise.resolve(result).catch((error) => {
-      connection.close(error);
-    });
-  }
-}
-var appBuilder = Symbol("appBuilder");
-var runAgentConnectHandlers = Symbol("runAgentConnectHandlers");
-var runClientConnectHandlers = Symbol("runClientConnectHandlers");
-var stableConnectionOptions = { allowBatches: false };
-function client(options) {
-  return new ClientApp(options);
-}
-
-class ClientApp {
-  builder = Connection.builder();
-  connectHandlers = [];
-  constructor(options = {}) {
-    if (options.name) {
-      this.builder.name(options.name);
-    }
-    this.builder.withHandler({
-      handleMessage: (message, cx) => sessionUpdateRouter(cx).handleMessage(message),
-      describe: () => "client-session-update-router"
-    });
-  }
-  [appBuilder]() {
-    return this.builder;
-  }
-  [runClientConnectHandlers](connection) {
-    runConnectHandlers(connection, this.connectHandlers);
-  }
-  connect(target) {
-    return this.connectConnection(target).connection;
-  }
-  connectWith(target, op) {
-    const { rawConnection, connection } = this.connectConnection(target);
-    return rawConnection.runUntil(() => op(connection.agent));
-  }
-  onConnect(handler) {
-    this.connectHandlers.push(handler);
-    return this;
-  }
-  onRequest(method, handlerOrParams, handler) {
-    if (handler) {
-      return this.request({ method, params: handlerOrParams }, handler);
-    }
-    const spec = clientRequestSpecsByMethod[method];
-    if (!spec) {
-      throw new Error(`Unknown ACP request method '${method}'. Pass a params parser for custom methods.`);
-    }
-    return this.request(spec, handlerOrParams);
-  }
-  onNotification(method, handlerOrParams, handler) {
-    if (handler) {
-      return this.notification({ method, params: handlerOrParams }, handler);
-    }
-    const spec = clientNotificationSpecsByMethod[method];
-    if (!spec) {
-      throw new Error(`Unknown ACP notification method '${method}'. Pass a params parser for custom methods.`);
-    }
-    return this.notification(spec, handlerOrParams);
-  }
-  request(spec, handler) {
-    registerAppRequest(this.builder, spec, (params, cx, signal, requestId) => clientRequestContext(params, ClientContext.create(cx, requestId), signal, requestId), handler);
-    return this;
-  }
-  notification(spec, handler) {
-    registerAppNotification(this.builder, spec, (params, cx, signal) => clientNotificationContext(params, ClientContext.create(cx), signal), handler);
-    return this;
-  }
-  connectConnection(target) {
-    if (isStream(target)) {
-      const state = this.openStreamConnection(target);
-      this[runClientConnectHandlers](state.connection);
-      return state;
-    }
-    const [thisStream, peerStream] = memoryStreamPair();
-    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
-    const peerConnection = agentConnection(peerRawConnection);
-    const state = this.openStreamConnection(thisStream);
-    state.rawConnection.closed.then(() => peerConnection.close());
-    peerRawConnection.closed.then(() => state.connection.close());
-    try {
-      target[runAgentConnectHandlers](peerConnection);
-      this[runClientConnectHandlers](state.connection);
-    } catch (error) {
-      peerConnection.close(error);
-      state.connection.close(error);
-      throw error;
-    }
-    return state;
-  }
-  openStreamConnection(stream) {
-    const rawConnection = this.builder.connect(stream, stableConnectionOptions);
-    return {
-      rawConnection,
-      connection: clientConnection(rawConnection, this.connectHandlers)
-    };
-  }
-}
-var legacyAgentRequestMethods = new Set([
-  AGENT_METHODS.initialize,
-  AGENT_METHODS.authenticate,
-  AGENT_METHODS.providers_list,
-  AGENT_METHODS.providers_set,
-  AGENT_METHODS.providers_disable,
-  AGENT_METHODS.session_new,
-  AGENT_METHODS.session_load,
-  AGENT_METHODS.session_set_mode,
-  AGENT_METHODS.session_set_config_option,
-  AGENT_METHODS.session_prompt,
-  AGENT_METHODS.session_list,
-  AGENT_METHODS.session_delete,
-  AGENT_METHODS.session_fork,
-  AGENT_METHODS.session_resume,
-  AGENT_METHODS.session_close,
-  AGENT_METHODS.logout,
-  AGENT_METHODS.nes_start,
-  AGENT_METHODS.nes_suggest,
-  AGENT_METHODS.nes_close
-]);
-var legacyAgentNotificationMethods = new Set([
-  AGENT_METHODS.session_cancel,
-  AGENT_METHODS.nes_accept,
-  AGENT_METHODS.nes_reject,
-  AGENT_METHODS.document_did_open,
-  AGENT_METHODS.document_did_change,
-  AGENT_METHODS.document_did_close,
-  AGENT_METHODS.document_did_save,
-  AGENT_METHODS.document_did_focus
-]);
-var legacyClientRequestMethods = new Set([
-  CLIENT_METHODS.session_request_permission,
-  CLIENT_METHODS.fs_write_text_file,
-  CLIENT_METHODS.fs_read_text_file,
-  CLIENT_METHODS.terminal_create,
-  CLIENT_METHODS.terminal_output,
-  CLIENT_METHODS.terminal_release,
-  CLIENT_METHODS.terminal_wait_for_exit,
-  CLIENT_METHODS.terminal_kill,
-  CLIENT_METHODS.elicitation_create
-]);
-var legacyClientNotificationMethods = new Set([
-  CLIENT_METHODS.session_update,
-  CLIENT_METHODS.elicitation_complete
-]);
-
-// packages/api/src/server/acp/transport.ts
-function createAcpTransport(options) {
-  const stream = ndJsonStream2(options.output, options.input);
-  const app = client({ name: "kennel-acp" });
-  if (options.onSessionUpdate) {
-    app.onNotification("session/update", (ctx) => {
-      Promise.resolve(options.onSessionUpdate(ctx.params, ctx.agent));
-    });
-  }
-  const connection = app.connect(stream);
-  connection.closed.then(() => options.onClose?.(), (error) => options.onClose?.(error));
-  return {
-    agent: connection.agent,
-    closed: connection.closed,
-    signal: connection.signal,
-    close(error) {
-      connection.close(error);
-    }
-  };
-}
-
-// packages/api/src/server/acp-live-plugin.ts
-async function bodyJson(request) {
-  const chunks = [];
-  for await (const chunk of request)
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  const raw = Buffer.concat(chunks).toString("utf-8").trim();
-  return raw ? JSON.parse(raw) : {};
-}
-function reply(response, status, body, ct = "application/json; charset=utf-8") {
-  response.writeHead(status, {
-    "Content-Type": ct,
-    "Cache-Control": "no-store"
-  });
-  response.end(typeof body === "string" ? body : JSON.stringify(body));
-}
-function guardMutation(request, response) {
-  if (sameOrigin(request))
-    return false;
-  reply(response, 403, "Cross-origin mutations are not allowed", "text/plain");
-  return true;
-}
-function loopbackHost(value) {
-  if (!value)
-    return false;
-  try {
-    const parsed = new URL(value.includes("://") ? value : `http://${value}`);
-    const hostname = parsed.hostname.replace(/^\[|\]$/g, "").toLowerCase();
-    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1" || hostname === "::ffff:127.0.0.1" || hostname.startsWith("127.");
-  } catch {
-    return false;
-  }
-}
-function createAcpApi({
-  remoteAccess = false
-} = {}) {
-  const manager = new AcpProcessManager;
-  const sessions = new Map;
-  let closed = false;
-  function broadcast(s, event) {
-    for (const fn of s.subscribers)
-      fn(event);
-  }
-  async function loadSession(transport, adapter, resumeId) {
-    const stored = await localSessions.readLocalSession(resumeId).catch(() => {
-      return;
-    });
-    const native = stored ? stored.id.slice(stored.id.indexOf(":") + 1) : resumeId;
-    await transport.agent.request("session/load", {
-      cwd: stored?.folder ?? adapter.workingFolder,
-      mcpServers: [],
-      sessionId: native
-    });
-    return native;
-  }
-  async function startSession(client, resumeId) {
-    if (closed)
-      throw new Error("Core is shutting down");
-    const adapter = findAdapter(client ?? "pi");
-    if (!adapter?.enabled)
-      throw new Error(`No ACP adapter available for "${client ?? "pi"}"`);
-    const browserId = randomUUID3();
-    const processKey = `acp-${browserId.slice(0, 8)}`;
-    const handle = manager.start(processKey, adapter);
-    const transport = createAcpTransport({
-      input: Readable.toWeb(handle.stdout),
-      output: Writable.toWeb(handle.stdin),
-      onClose: (err) => {
-        const s = sessions.get(browserId);
-        if (s) {
-          s.error = err ? String(err) : null;
-          s.transport = null;
-        }
-      }
-    });
-    await transport.agent.request("initialize", {
-      protocolVersion: 1,
-      clientInfo: { name: "kennel", version: "1.0.0" },
-      capabilities: {}
-    });
-    const acpId = resumeId ? await loadSession(transport, adapter, resumeId) : (await transport.agent.request("session/new", {
-      cwd: adapter.workingFolder,
-      mcpServers: []
-    })).sessionId;
-    const session = {
-      adapter,
-      browserId,
-      acpId,
-      transport,
-      processKey,
-      subscribers: new Set,
-      error: null
-    };
-    sessions.set(browserId, session);
-    return session;
-  }
-  async function destroySession(s) {
-    s.transport?.close();
-    s.transport = null;
-    await manager.stop(s.processKey, 2000, 1000).catch(() => {});
-    s.subscribers.clear();
-    sessions.delete(s.browserId);
-  }
-  return {
-    async close() {
-      closed = true;
-      await Promise.all([...sessions.values()].map(destroySession));
-      await manager.stopAll(2000, 1000);
-    },
-    name: "kennel-acp-live",
-    attach(server) {
-      server.use(async (request, response, next) => {
-        const url = new URL(request.url ?? "/", "http://127.0.0.1");
-        const method = request.method ?? "GET";
-        if (!url.pathname.startsWith("/api/acp/"))
-          return next();
-        if (remoteAccess) {
-          reply(response, 403, "ACP live sessions are disabled for remote access", "text/plain");
-          return;
-        }
-        if (url.pathname.startsWith("/api/acp/") && !loopbackHost(request.headers.host)) {
-          reply(response, 403, "Untrusted Host header", "text/plain");
-          return;
-        }
-        const streamMatch = /^\/api\/acp\/stream\/([a-f0-9-]+)$/.exec(url.pathname);
-        if (streamMatch?.[1] && method === "GET") {
-          const s = sessions.get(streamMatch[1]);
-          if (!s)
-            return reply(response, 404, "Session not found", "text/plain");
-          response.writeHead(200, {
-            "Content-Type": "text/event-stream; charset=utf-8",
-            "Cache-Control": "no-store",
-            Connection: "keep-alive",
-            "X-Accel-Buffering": "no"
-          });
-          const onEvent = (event) => {
-            if (!response.writableEnded)
-              response.write(`data: ${JSON.stringify(event)}
-
-`);
-          };
-          s.subscribers.add(onEvent);
-          request.on("close", () => {
-            s.subscribers.delete(onEvent);
-            if (!response.writableEnded)
-              response.end();
-          });
-          return;
-        }
-        if (url.pathname === "/api/acp/connect" && method === "POST") {
-          if (guardMutation(request, response))
-            return;
-          try {
-            const { client, resumeId } = await bodyJson(request);
-            const s = await startSession(client ? String(client) : undefined, resumeId ? String(resumeId) : undefined);
-            return reply(response, 200, {
-              sessionId: s.browserId,
-              connectionState: "connected"
-            });
-          } catch (err) {
-            return reply(response, 500, {
-              error: err instanceof Error ? err.message : String(err)
-            });
-          }
-        }
-        if (url.pathname === "/api/acp/send" && method === "POST") {
-          if (guardMutation(request, response))
-            return;
-          const { sessionId, text } = await bodyJson(request);
-          if (!sessionId || !text)
-            return reply(response, 400, "Missing sessionId or text", "text/plain");
-          const s = sessions.get(String(sessionId));
-          if (!s?.transport || !s.acpId)
-            return reply(response, 404, "Session not found", "text/plain");
-          s.transport.agent.request("session/prompt", {
-            sessionId: s.acpId,
-            prompt: [{ type: "text", text }]
-          }).then((result) => {
-            const data = result;
-            if (data?.content) {
-              for (const block of data.content) {
-                if (block.type === "text" && block.text) {
-                  broadcast(s, { type: "text-delta", text: block.text });
-                } else if (block.type === "tool_call") {
-                  const callId = randomUUID3();
-                  broadcast(s, {
-                    type: "tool-call-start",
-                    callId,
-                    name: block.name ?? "unknown",
-                    input: block.input
-                  });
-                  broadcast(s, { type: "tool-call-end", callId });
-                }
-              }
-            }
-            if (data?.stopReason) {
-              broadcast(s, {
-                type: "done",
-                stopReason: data.stopReason,
-                usage: data.usage
-              });
-            }
-          }).catch((err) => {
-            broadcast(s, {
-              type: "error",
-              message: err instanceof Error ? err.message : String(err)
-            });
-          });
-          return reply(response, 202, { accepted: true });
-        }
-        if (url.pathname === "/api/acp/cancel" && method === "POST") {
-          if (guardMutation(request, response))
-            return;
-          const { sessionId } = await bodyJson(request);
-          const s = sessions.get(String(sessionId ?? ""));
-          if (!s?.transport)
-            return reply(response, 404, "Session not found", "text/plain");
-          try {
-            s.transport.agent.notify("$/cancel_request", {});
-          } catch {}
-          broadcast(s, { type: "cancelled" });
-          return reply(response, 200, { cancelled: true });
-        }
-        if (url.pathname === "/api/acp/disconnect" && method === "POST") {
-          if (guardMutation(request, response))
-            return;
-          const { sessionId } = await bodyJson(request);
-          const s = sessions.get(String(sessionId ?? ""));
-          if (!s)
-            return reply(response, 404, "Session not found", "text/plain");
-          await destroySession(s);
-          return reply(response, 200, { disconnected: true });
-        }
-        if (url.pathname === "/api/acp/resume" && method === "POST") {
-          if (guardMutation(request, response))
-            return;
-          const { sessionId, resumeId } = await bodyJson(request);
-          if (!resumeId)
-            return reply(response, 400, "Missing resumeId", "text/plain");
-          const s = sessions.get(String(sessionId ?? ""));
-          if (!s?.transport)
-            return reply(response, 404, "Session not found", "text/plain");
-          try {
-            s.acpId = await loadSession(s.transport, s.adapter, String(resumeId));
-            return reply(response, 200, {
-              sessionId: s.browserId,
-              resumed: true
-            });
-          } catch (err) {
-            return reply(response, 500, {
-              error: err instanceof Error ? err.message : String(err)
-            });
-          }
-        }
-        if (url.pathname === "/api/acp/reconnect" && method === "POST") {
-          if (guardMutation(request, response))
-            return;
-          const { sessionId } = await bodyJson(request);
-          const old = sessions.get(String(sessionId ?? ""));
-          if (!old)
-            return reply(response, 404, "Session not found", "text/plain");
-          await destroySession(old);
-          try {
-            const s = await startSession();
-            return reply(response, 200, {
-              sessionId: s.browserId,
-              connectionState: "connected"
-            });
-          } catch (err) {
-            return reply(response, 500, {
-              error: err instanceof Error ? err.message : String(err)
-            });
-          }
-        }
-        next();
-      });
-    }
-  };
-}
-
 // packages/api/src/server/index.ts
 var contentTypes = {
   ".html": "text/html",
@@ -43439,9 +38815,7 @@ data: ${JSON.stringify(event.data)}
     ...options,
     remoteAccess: remote
   });
-  const acp = createAcpApi({ remoteAccess: remote });
   folder.attach(host);
-  acp.attach(host);
   async function handle(request, response, next = () => {
     response.writeHead(404);
     response.end("Not found");
@@ -43550,8 +38924,7 @@ data: ${JSON.stringify(event.data)}
       await Promise.all([
         new Promise((done) => server.close(() => done())),
         watcher.close(),
-        folder.close(),
-        acp.close()
+        folder.close()
       ]);
     }
   };