@spekn/cli 1.0.0 → 1.0.1

package/dist/chunk-3PAYRI4G.mjs

@@ -1,2428 +0,0 @@
-// Bundled TUI entry (ESM) — loaded via dynamic import() from CJS main.js
-import { createRequire as __createRequire } from 'module';
-const require = __createRequire(import.meta.url);
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
-var AGENT_METHODS, CLIENT_METHODS, PROTOCOL_VERSION;
-var init_schema = __esm({
-  "../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js"() {
-    "use strict";
-    AGENT_METHODS = {
-      authenticate: "authenticate",
-      initialize: "initialize",
-      session_cancel: "session/cancel",
-      session_fork: "session/fork",
-      session_list: "session/list",
-      session_load: "session/load",
-      session_new: "session/new",
-      session_prompt: "session/prompt",
-      session_resume: "session/resume",
-      session_set_config_option: "session/set_config_option",
-      session_set_mode: "session/set_mode",
-      session_set_model: "session/set_model"
-    };
-    CLIENT_METHODS = {
-      fs_read_text_file: "fs/read_text_file",
-      fs_write_text_file: "fs/write_text_file",
-      session_request_permission: "session/request_permission",
-      session_update: "session/update",
-      terminal_create: "terminal/create",
-      terminal_kill: "terminal/kill",
-      terminal_output: "terminal/output",
-      terminal_release: "terminal/release",
-      terminal_wait_for_exit: "terminal/wait_for_exit"
-    };
-    PROTOCOL_VERSION = 1;
-  }
-});
-
-// ../../node_modules/@agentclientprotocol/sdk/dist/schema/zod.gen.js
-import { z } from "zod/v4";
-var zAuthMethod, zAuthenticateRequest, zAuthenticateResponse, zBlobResourceContents, zCost, zCreateTerminalResponse, zDiff, zEnvVariable, zErrorCode, zError, zExtNotification, zExtRequest, zExtResponse, zFileSystemCapability, zClientCapabilities, zHttpHeader, zImplementation, zKillTerminalCommandResponse, zListSessionsRequest, zMcpCapabilities, zMcpServerHttp, zMcpServerSse, zMcpServerStdio, zMcpServer, zModelId, zModelInfo, zNewSessionRequest, zPermissionOptionId, zPermissionOptionKind, zPermissionOption, zPlanEntryPriority, zPlanEntryStatus, zPlanEntry, zPlan, zPromptCapabilities, zProtocolVersion, zInitializeRequest, zReadTextFileResponse, zReleaseTerminalResponse, zRequestId, zCancelRequestNotification, zRole, zAnnotations, zAudioContent, zImageContent, zResourceLink, zSelectedPermissionOutcome, zRequestPermissionOutcome, zRequestPermissionResponse, zSessionConfigGroupId, zSessionConfigId, zSessionConfigOptionCategory, zSessionConfigValueId, zSessionConfigSelectOption, zSessionConfigSelectGroup, zSessionConfigSelectOptions, zSessionConfigSelect, zSessionConfigOption, zConfigOptionUpdate, zSessionForkCapabilities, zSessionId, zCancelNotification, zClientNotification, zCreateTerminalRequest, zForkSessionRequest, zKillTerminalCommandRequest, zLoadSessionRequest, zReadTextFileRequest, zReleaseTerminalRequest, zResumeSessionRequest, zSessionInfo, zListSessionsResponse, zSessionInfoUpdate, zSessionListCapabilities, zSessionModeId, zCurrentModeUpdate, zSessionMode, zSessionModeState, zSessionModelState, zForkSessionResponse, zLoadSessionResponse, zNewSessionResponse, zResumeSessionResponse, zSessionResumeCapabilities, zSessionCapabilities, zAgentCapabilities, zInitializeResponse, zSetSessionConfigOptionRequest, zSetSessionConfigOptionResponse, zSetSessionModeRequest, zSetSessionModeResponse, zSetSessionModelRequest, zSetSessionModelResponse, zStopReason, zTerminal, zTerminalExitStatus, zTerminalOutputRequest, zTerminalOutputResponse, zTextContent, zTextResourceContents, zEmbeddedResourceResource, zEmbeddedResource, zContentBlock, zContent, zContentChunk, zPromptRequest, zClientRequest, zToolCallContent, zToolCallId, zToolCallLocation, zToolCallStatus, zToolKind, zToolCall, zToolCallUpdate, zRequestPermissionRequest, zUnstructuredCommandInput, zAvailableCommandInput, zAvailableCommand, zAvailableCommandsUpdate, zUsage, zPromptResponse, zAgentResponse, zUsageUpdate, zSessionUpdate, zSessionNotification, zAgentNotification, zWaitForTerminalExitRequest, zWaitForTerminalExitResponse, zWriteTextFileRequest, zAgentRequest, zWriteTextFileResponse, zClientResponse;
-var init_zod_gen = __esm({
-  "../../node_modules/@agentclientprotocol/sdk/dist/schema/zod.gen.js"() {
-    "use strict";
-    zAuthMethod = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      description: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      id: z.string(),
-      name: z.string()
-    });
-    zAuthenticateRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      methodId: z.string()
-    });
-    zAuthenticateResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zBlobResourceContents = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      blob: z.string(),
-      mimeType: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      uri: z.string()
-    });
-    zCost = z.object({
-      amount: z.number(),
-      currency: z.string()
-    });
-    zCreateTerminalResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      terminalId: z.string()
-    });
-    zDiff = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      newText: z.string(),
-      oldText: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      path: z.string()
-    });
-    zEnvVariable = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      name: z.string(),
-      value: z.string()
-    });
-    zErrorCode = z.union([
-      z.literal(-32700),
-      z.literal(-32600),
-      z.literal(-32601),
-      z.literal(-32602),
-      z.literal(-32603),
-      z.literal(-32800),
-      z.literal(-32e3),
-      z.literal(-32002),
-      z.number().int().min(-2147483648, {
-        message: "Invalid value: Expected int32 to be >= -2147483648"
-      }).max(2147483647, {
-        message: "Invalid value: Expected int32 to be <= 2147483647"
-      })
-    ]);
-    zError = z.object({
-      code: zErrorCode,
-      data: z.unknown().optional(),
-      message: z.string()
-    });
-    zExtNotification = z.unknown();
-    zExtRequest = z.unknown();
-    zExtResponse = z.unknown();
-    zFileSystemCapability = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      readTextFile: z.boolean().optional().default(false),
-      writeTextFile: z.boolean().optional().default(false)
-    });
-    zClientCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      fs: zFileSystemCapability.optional().default({
-        readTextFile: false,
-        writeTextFile: false
-      }),
-      terminal: z.boolean().optional().default(false)
-    });
-    zHttpHeader = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      name: z.string(),
-      value: z.string()
-    });
-    zImplementation = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      name: z.string(),
-      title: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      version: z.string()
-    });
-    zKillTerminalCommandResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zListSessionsRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cursor: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      cwd: z.union([
-        z.string(),
-        z.null()
-      ]).optional()
-    });
-    zMcpCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      http: z.boolean().optional().default(false),
-      sse: z.boolean().optional().default(false)
-    });
-    zMcpServerHttp = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      headers: z.array(zHttpHeader),
-      name: z.string(),
-      url: z.string()
-    });
-    zMcpServerSse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      headers: z.array(zHttpHeader),
-      name: z.string(),
-      url: z.string()
-    });
-    zMcpServerStdio = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      args: z.array(z.string()),
-      command: z.string(),
-      env: z.array(zEnvVariable),
-      name: z.string()
-    });
-    zMcpServer = z.union([
-      zMcpServerHttp.and(z.object({
-        type: z.literal("http")
-      })),
-      zMcpServerSse.and(z.object({
-        type: z.literal("sse")
-      })),
-      zMcpServerStdio
-    ]);
-    zModelId = z.string();
-    zModelInfo = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      description: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      modelId: zModelId,
-      name: z.string()
-    });
-    zNewSessionRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cwd: z.string(),
-      mcpServers: z.array(zMcpServer)
-    });
-    zPermissionOptionId = z.string();
-    zPermissionOptionKind = z.union([
-      z.literal("allow_once"),
-      z.literal("allow_always"),
-      z.literal("reject_once"),
-      z.literal("reject_always")
-    ]);
-    zPermissionOption = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      kind: zPermissionOptionKind,
-      name: z.string(),
-      optionId: zPermissionOptionId
-    });
-    zPlanEntryPriority = z.union([
-      z.literal("high"),
-      z.literal("medium"),
-      z.literal("low")
-    ]);
-    zPlanEntryStatus = z.union([
-      z.literal("pending"),
-      z.literal("in_progress"),
-      z.literal("completed")
-    ]);
-    zPlanEntry = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: z.string(),
-      priority: zPlanEntryPriority,
-      status: zPlanEntryStatus
-    });
-    zPlan = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      entries: z.array(zPlanEntry)
-    });
-    zPromptCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      audio: z.boolean().optional().default(false),
-      embeddedContext: z.boolean().optional().default(false),
-      image: z.boolean().optional().default(false)
-    });
-    zProtocolVersion = z.number().int().gte(0).lte(65535);
-    zInitializeRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      clientCapabilities: zClientCapabilities.optional().default({
-        fs: {
-          readTextFile: false,
-          writeTextFile: false
-        },
-        terminal: false
-      }),
-      clientInfo: z.union([
-        zImplementation,
-        z.null()
-      ]).optional(),
-      protocolVersion: zProtocolVersion
-    });
-    zReadTextFileResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: z.string()
-    });
-    zReleaseTerminalResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zRequestId = z.union([
-      z.null(),
-      z.number(),
-      z.string()
-    ]);
-    zCancelRequestNotification = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      requestId: zRequestId
-    });
-    zRole = z.enum([
-      "assistant",
-      "user"
-    ]);
-    zAnnotations = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      audience: z.union([
-        z.array(zRole),
-        z.null()
-      ]).optional(),
-      lastModified: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      priority: z.union([
-        z.number(),
-        z.null()
-      ]).optional()
-    });
-    zAudioContent = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      annotations: z.union([
-        zAnnotations,
-        z.null()
-      ]).optional(),
-      data: z.string(),
-      mimeType: z.string()
-    });
-    zImageContent = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      annotations: z.union([
-        zAnnotations,
-        z.null()
-      ]).optional(),
-      data: z.string(),
-      mimeType: z.string(),
-      uri: z.union([
-        z.string(),
-        z.null()
-      ]).optional()
-    });
-    zResourceLink = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      annotations: z.union([
-        zAnnotations,
-        z.null()
-      ]).optional(),
-      description: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      mimeType: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      name: z.string(),
-      size: z.union([
-        z.number(),
-        z.null()
-      ]).optional(),
-      title: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      uri: z.string()
-    });
-    zSelectedPermissionOutcome = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      optionId: zPermissionOptionId
-    });
-    zRequestPermissionOutcome = z.union([
-      z.object({
-        outcome: z.literal("cancelled")
-      }),
-      zSelectedPermissionOutcome.and(z.object({
-        outcome: z.literal("selected")
-      }))
-    ]);
-    zRequestPermissionResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      outcome: zRequestPermissionOutcome
-    });
-    zSessionConfigGroupId = z.string();
-    zSessionConfigId = z.string();
-    zSessionConfigOptionCategory = z.union([
-      z.literal("mode"),
-      z.literal("model"),
-      z.literal("thought_level"),
-      z.string()
-    ]);
-    zSessionConfigValueId = z.string();
-    zSessionConfigSelectOption = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      description: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      name: z.string(),
-      value: zSessionConfigValueId
-    });
-    zSessionConfigSelectGroup = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      group: zSessionConfigGroupId,
-      name: z.string(),
-      options: z.array(zSessionConfigSelectOption)
-    });
-    zSessionConfigSelectOptions = z.union([
-      z.array(zSessionConfigSelectOption),
-      z.array(zSessionConfigSelectGroup)
-    ]);
-    zSessionConfigSelect = z.object({
-      currentValue: zSessionConfigValueId,
-      options: zSessionConfigSelectOptions
-    });
-    zSessionConfigOption = zSessionConfigSelect.and(z.object({
-      type: z.literal("select")
-    })).and(z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      category: z.union([
-        zSessionConfigOptionCategory,
-        z.null()
-      ]).optional(),
-      description: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      id: zSessionConfigId,
-      name: z.string()
-    }));
-    zConfigOptionUpdate = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configOptions: z.array(zSessionConfigOption)
-    });
-    zSessionForkCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zSessionId = z.string();
-    zCancelNotification = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId
-    });
-    zClientNotification = z.object({
-      method: z.string(),
-      params: z.union([
-        z.union([
-          zCancelNotification,
-          zExtNotification
-        ]),
-        z.null()
-      ]).optional()
-    });
-    zCreateTerminalRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      args: z.array(z.string()).optional(),
-      command: z.string(),
-      cwd: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      env: z.array(zEnvVariable).optional(),
-      outputByteLimit: z.union([
-        z.number(),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId
-    });
-    zForkSessionRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cwd: z.string(),
-      mcpServers: z.array(zMcpServer).optional(),
-      sessionId: zSessionId
-    });
-    zKillTerminalCommandRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId,
-      terminalId: z.string()
-    });
-    zLoadSessionRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cwd: z.string(),
-      mcpServers: z.array(zMcpServer),
-      sessionId: zSessionId
-    });
-    zReadTextFileRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      limit: z.union([
-        z.number().int().gte(0).max(4294967295, {
-          message: "Invalid value: Expected uint32 to be <= 4294967295"
-        }),
-        z.null()
-      ]).optional(),
-      line: z.union([
-        z.number().int().gte(0).max(4294967295, {
-          message: "Invalid value: Expected uint32 to be <= 4294967295"
-        }),
-        z.null()
-      ]).optional(),
-      path: z.string(),
-      sessionId: zSessionId
-    });
-    zReleaseTerminalRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId,
-      terminalId: z.string()
-    });
-    zResumeSessionRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cwd: z.string(),
-      mcpServers: z.array(zMcpServer).optional(),
-      sessionId: zSessionId
-    });
-    zSessionInfo = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cwd: z.string(),
-      sessionId: zSessionId,
-      title: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      updatedAt: z.union([
-        z.string(),
-        z.null()
-      ]).optional()
-    });
-    zListSessionsResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      nextCursor: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      sessions: z.array(zSessionInfo)
-    });
-    zSessionInfoUpdate = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      title: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      updatedAt: z.union([
-        z.string(),
-        z.null()
-      ]).optional()
-    });
-    zSessionListCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zSessionModeId = z.string();
-    zCurrentModeUpdate = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      currentModeId: zSessionModeId
-    });
-    zSessionMode = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      description: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      id: zSessionModeId,
-      name: z.string()
-    });
-    zSessionModeState = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      availableModes: z.array(zSessionMode),
-      currentModeId: zSessionModeId
-    });
-    zSessionModelState = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      availableModels: z.array(zModelInfo),
-      currentModelId: zModelId
-    });
-    zForkSessionResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configOptions: z.union([
-        z.array(zSessionConfigOption),
-        z.null()
-      ]).optional(),
-      models: z.union([
-        zSessionModelState,
-        z.null()
-      ]).optional(),
-      modes: z.union([
-        zSessionModeState,
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId
-    });
-    zLoadSessionResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configOptions: z.union([
-        z.array(zSessionConfigOption),
-        z.null()
-      ]).optional(),
-      models: z.union([
-        zSessionModelState,
-        z.null()
-      ]).optional(),
-      modes: z.union([
-        zSessionModeState,
-        z.null()
-      ]).optional()
-    });
-    zNewSessionResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configOptions: z.union([
-        z.array(zSessionConfigOption),
-        z.null()
-      ]).optional(),
-      models: z.union([
-        zSessionModelState,
-        z.null()
-      ]).optional(),
-      modes: z.union([
-        zSessionModeState,
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId
-    });
-    zResumeSessionResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configOptions: z.union([
-        z.array(zSessionConfigOption),
-        z.null()
-      ]).optional(),
-      models: z.union([
-        zSessionModelState,
-        z.null()
-      ]).optional(),
-      modes: z.union([
-        zSessionModeState,
-        z.null()
-      ]).optional()
-    });
-    zSessionResumeCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zSessionCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      fork: z.union([
-        zSessionForkCapabilities,
-        z.null()
-      ]).optional(),
-      list: z.union([
-        zSessionListCapabilities,
-        z.null()
-      ]).optional(),
-      resume: z.union([
-        zSessionResumeCapabilities,
-        z.null()
-      ]).optional()
-    });
-    zAgentCapabilities = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      loadSession: z.boolean().optional().default(false),
-      mcpCapabilities: zMcpCapabilities.optional().default({
-        http: false,
-        sse: false
-      }),
-      promptCapabilities: zPromptCapabilities.optional().default({
-        audio: false,
-        embeddedContext: false,
-        image: false
-      }),
-      sessionCapabilities: zSessionCapabilities.optional().default({})
-    });
-    zInitializeResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      agentCapabilities: zAgentCapabilities.optional().default({
-        loadSession: false,
-        mcpCapabilities: {
-          http: false,
-          sse: false
-        },
-        promptCapabilities: {
-          audio: false,
-          embeddedContext: false,
-          image: false
-        },
-        sessionCapabilities: {}
-      }),
-      agentInfo: z.union([
-        zImplementation,
-        z.null()
-      ]).optional(),
-      authMethods: z.array(zAuthMethod).optional().default([]),
-      protocolVersion: zProtocolVersion
-    });
-    zSetSessionConfigOptionRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configId: zSessionConfigId,
-      sessionId: zSessionId,
-      value: zSessionConfigValueId
-    });
-    zSetSessionConfigOptionResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      configOptions: z.array(zSessionConfigOption)
-    });
-    zSetSessionModeRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      modeId: zSessionModeId,
-      sessionId: zSessionId
-    });
-    zSetSessionModeResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zSetSessionModelRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      modelId: zModelId,
-      sessionId: zSessionId
-    });
-    zSetSessionModelResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zStopReason = z.union([
-      z.literal("end_turn"),
-      z.literal("max_tokens"),
-      z.literal("max_turn_requests"),
-      z.literal("refusal"),
-      z.literal("cancelled")
-    ]);
-    zTerminal = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      terminalId: z.string()
-    });
-    zTerminalExitStatus = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      exitCode: z.union([
-        z.number().int().gte(0).max(4294967295, {
-          message: "Invalid value: Expected uint32 to be <= 4294967295"
-        }),
-        z.null()
-      ]).optional(),
-      signal: z.union([
-        z.string(),
-        z.null()
-      ]).optional()
-    });
-    zTerminalOutputRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId,
-      terminalId: z.string()
-    });
-    zTerminalOutputResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      exitStatus: z.union([
-        zTerminalExitStatus,
-        z.null()
-      ]).optional(),
-      output: z.string(),
-      truncated: z.boolean()
-    });
-    zTextContent = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      annotations: z.union([
-        zAnnotations,
-        z.null()
-      ]).optional(),
-      text: z.string()
-    });
-    zTextResourceContents = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      mimeType: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      text: z.string(),
-      uri: z.string()
-    });
-    zEmbeddedResourceResource = z.union([
-      zTextResourceContents,
-      zBlobResourceContents
-    ]);
-    zEmbeddedResource = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      annotations: z.union([
-        zAnnotations,
-        z.null()
-      ]).optional(),
-      resource: zEmbeddedResourceResource
-    });
-    zContentBlock = z.union([
-      zTextContent.and(z.object({
-        type: z.literal("text")
-      })),
-      zImageContent.and(z.object({
-        type: z.literal("image")
-      })),
-      zAudioContent.and(z.object({
-        type: z.literal("audio")
-      })),
-      zResourceLink.and(z.object({
-        type: z.literal("resource_link")
-      })),
-      zEmbeddedResource.and(z.object({
-        type: z.literal("resource")
-      }))
-    ]);
-    zContent = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: zContentBlock
-    });
-    zContentChunk = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: zContentBlock
-    });
-    zPromptRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      prompt: z.array(zContentBlock),
-      sessionId: zSessionId
-    });
-    zClientRequest = z.object({
-      id: zRequestId,
-      method: z.string(),
-      params: z.union([
-        z.union([
-          zInitializeRequest,
-          zAuthenticateRequest,
-          zNewSessionRequest,
-          zLoadSessionRequest,
-          zListSessionsRequest,
-          zForkSessionRequest,
-          zResumeSessionRequest,
-          zSetSessionModeRequest,
-          zSetSessionConfigOptionRequest,
-          zPromptRequest,
-          zSetSessionModelRequest,
-          zExtRequest
-        ]),
-        z.null()
-      ]).optional()
-    });
-    zToolCallContent = z.union([
-      zContent.and(z.object({
-        type: z.literal("content")
-      })),
-      zDiff.and(z.object({
-        type: z.literal("diff")
-      })),
-      zTerminal.and(z.object({
-        type: z.literal("terminal")
-      }))
-    ]);
-    zToolCallId = z.string();
-    zToolCallLocation = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      line: z.union([
-        z.number().int().gte(0).max(4294967295, {
-          message: "Invalid value: Expected uint32 to be <= 4294967295"
-        }),
-        z.null()
-      ]).optional(),
-      path: z.string()
-    });
-    zToolCallStatus = z.union([
-      z.literal("pending"),
-      z.literal("in_progress"),
-      z.literal("completed"),
-      z.literal("failed")
-    ]);
-    zToolKind = z.union([
-      z.literal("read"),
-      z.literal("edit"),
-      z.literal("delete"),
-      z.literal("move"),
-      z.literal("search"),
-      z.literal("execute"),
-      z.literal("think"),
-      z.literal("fetch"),
-      z.literal("switch_mode"),
-      z.literal("other")
-    ]);
-    zToolCall = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: z.array(zToolCallContent).optional(),
-      kind: zToolKind.optional(),
-      locations: z.array(zToolCallLocation).optional(),
-      rawInput: z.unknown().optional(),
-      rawOutput: z.unknown().optional(),
-      status: zToolCallStatus.optional(),
-      title: z.string(),
-      toolCallId: zToolCallId
-    });
-    zToolCallUpdate = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: z.union([
-        z.array(zToolCallContent),
-        z.null()
-      ]).optional(),
-      kind: z.union([
-        zToolKind,
-        z.null()
-      ]).optional(),
-      locations: z.union([
-        z.array(zToolCallLocation),
-        z.null()
-      ]).optional(),
-      rawInput: z.unknown().optional(),
-      rawOutput: z.unknown().optional(),
-      status: z.union([
-        zToolCallStatus,
-        z.null()
-      ]).optional(),
-      title: z.union([
-        z.string(),
-        z.null()
-      ]).optional(),
-      toolCallId: zToolCallId
-    });
-    zRequestPermissionRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      options: z.array(zPermissionOption),
-      sessionId: zSessionId,
-      toolCall: zToolCallUpdate
-    });
-    zUnstructuredCommandInput = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      hint: z.string()
-    });
-    zAvailableCommandInput = zUnstructuredCommandInput;
-    zAvailableCommand = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      description: z.string(),
-      input: z.union([
-        zAvailableCommandInput,
-        z.null()
-      ]).optional(),
-      name: z.string()
-    });
-    zAvailableCommandsUpdate = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      availableCommands: z.array(zAvailableCommand)
-    });
-    zUsage = z.object({
-      cachedReadTokens: z.union([
-        z.number(),
-        z.null()
-      ]).optional(),
-      cachedWriteTokens: z.union([
-        z.number(),
-        z.null()
-      ]).optional(),
-      inputTokens: z.number(),
-      outputTokens: z.number(),
-      thoughtTokens: z.union([
-        z.number(),
-        z.null()
-      ]).optional(),
-      totalTokens: z.number()
-    });
-    zPromptResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      stopReason: zStopReason,
-      usage: z.union([
-        zUsage,
-        z.null()
-      ]).optional()
-    });
-    zAgentResponse = z.union([
-      z.object({
-        id: zRequestId,
-        result: z.union([
-          zInitializeResponse,
-          zAuthenticateResponse,
-          zNewSessionResponse,
-          zLoadSessionResponse,
-          zListSessionsResponse,
-          zForkSessionResponse,
-          zResumeSessionResponse,
-          zSetSessionModeResponse,
-          zSetSessionConfigOptionResponse,
-          zPromptResponse,
-          zSetSessionModelResponse,
-          zExtResponse
-        ])
-      }),
-      z.object({
-        error: zError,
-        id: zRequestId
-      })
-    ]);
-    zUsageUpdate = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      cost: z.union([
-        zCost,
-        z.null()
-      ]).optional(),
-      size: z.number(),
-      used: z.number()
-    });
-    zSessionUpdate = z.union([
-      zContentChunk.and(z.object({
-        sessionUpdate: z.literal("user_message_chunk")
-      })),
-      zContentChunk.and(z.object({
-        sessionUpdate: z.literal("agent_message_chunk")
-      })),
-      zContentChunk.and(z.object({
-        sessionUpdate: z.literal("agent_thought_chunk")
-      })),
-      zToolCall.and(z.object({
-        sessionUpdate: z.literal("tool_call")
-      })),
-      zToolCallUpdate.and(z.object({
-        sessionUpdate: z.literal("tool_call_update")
-      })),
-      zPlan.and(z.object({
-        sessionUpdate: z.literal("plan")
-      })),
-      zAvailableCommandsUpdate.and(z.object({
-        sessionUpdate: z.literal("available_commands_update")
-      })),
-      zCurrentModeUpdate.and(z.object({
-        sessionUpdate: z.literal("current_mode_update")
-      })),
-      zConfigOptionUpdate.and(z.object({
-        sessionUpdate: z.literal("config_option_update")
-      })),
-      zSessionInfoUpdate.and(z.object({
-        sessionUpdate: z.literal("session_info_update")
-      })),
-      zUsageUpdate.and(z.object({
-        sessionUpdate: z.literal("usage_update")
-      }))
-    ]);
-    zSessionNotification = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId,
-      update: zSessionUpdate
-    });
-    zAgentNotification = z.object({
-      method: z.string(),
-      params: z.union([
-        z.union([
-          zSessionNotification,
-          zExtNotification
-        ]),
-        z.null()
-      ]).optional()
-    });
-    zWaitForTerminalExitRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      sessionId: zSessionId,
-      terminalId: z.string()
-    });
-    zWaitForTerminalExitResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      exitCode: z.union([
-        z.number().int().gte(0).max(4294967295, {
-          message: "Invalid value: Expected uint32 to be <= 4294967295"
-        }),
-        z.null()
-      ]).optional(),
-      signal: z.union([
-        z.string(),
-        z.null()
-      ]).optional()
-    });
-    zWriteTextFileRequest = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional(),
-      content: z.string(),
-      path: z.string(),
-      sessionId: zSessionId
-    });
-    zAgentRequest = z.object({
-      id: zRequestId,
-      method: z.string(),
-      params: z.union([
-        z.union([
-          zWriteTextFileRequest,
-          zReadTextFileRequest,
-          zRequestPermissionRequest,
-          zCreateTerminalRequest,
-          zTerminalOutputRequest,
-          zReleaseTerminalRequest,
-          zWaitForTerminalExitRequest,
-          zKillTerminalCommandRequest,
-          zExtRequest
-        ]),
-        z.null()
-      ]).optional()
-    });
-    zWriteTextFileResponse = z.object({
-      _meta: z.union([
-        z.record(z.string(), z.unknown()),
-        z.null()
-      ]).optional()
-    });
-    zClientResponse = z.union([
-      z.object({
-        id: zRequestId,
-        result: z.union([
-          zWriteTextFileResponse,
-          zReadTextFileResponse,
-          zRequestPermissionResponse,
-          zCreateTerminalResponse,
-          zTerminalOutputResponse,
-          zReleaseTerminalResponse,
-          zWaitForTerminalExitResponse,
-          zKillTerminalCommandResponse,
-          zExtResponse
-        ])
-      }),
-      z.object({
-        error: zError,
-        id: zRequestId
-      })
-    ]);
-  }
-});
-
-// ../../node_modules/@agentclientprotocol/sdk/dist/stream.js
-function ndJsonStream(output, input) {
-  const textEncoder = new TextEncoder();
-  const textDecoder = new TextDecoder();
-  const readable = new ReadableStream({
-    async start(controller) {
-      let content = "";
-      const reader = input.getReader();
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) {
-            break;
-          }
-          if (!value) {
-            continue;
-          }
-          content += textDecoder.decode(value, {
-            stream: true
-          });
-          const lines = content.split("\n");
-          content = lines.pop() || "";
-          for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine) {
-              try {
-                const message = JSON.parse(trimmedLine);
-                controller.enqueue(message);
-              } catch (err) {
-                console.error("Failed to parse JSON message:", trimmedLine, err);
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-        controller.close();
-      }
-    }
-  });
-  const writable = new WritableStream({
-    async write(message) {
-      const content = JSON.stringify(message) + "\n";
-      const writer = output.getWriter();
-      try {
-        await writer.write(textEncoder.encode(content));
-      } finally {
-        writer.releaseLock();
-      }
-    }
-  });
-  return {
-    readable,
-    writable
-  };
-}
-var init_stream = __esm({
-  "../../node_modules/@agentclientprotocol/sdk/dist/stream.js"() {
-    "use strict";
-    __name(ndJsonStream, "ndJsonStream");
-  }
-});
-
-// ../../node_modules/@agentclientprotocol/sdk/dist/acp.js
-var acp_exports = {};
-__export(acp_exports, {
-  AGENT_METHODS: () => AGENT_METHODS,
-  AgentSideConnection: () => AgentSideConnection,
-  CLIENT_METHODS: () => CLIENT_METHODS,
-  ClientSideConnection: () => ClientSideConnection,
-  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
-  RequestError: () => RequestError,
-  TerminalHandle: () => TerminalHandle,
-  ndJsonStream: () => ndJsonStream
-});
-import { z as z2 } from "zod";
-var AgentSideConnection, TerminalHandle, ClientSideConnection, Connection, RequestError;
-var init_acp = __esm({
-  "../../node_modules/@agentclientprotocol/sdk/dist/acp.js"() {
-    init_schema();
-    init_zod_gen();
-    init_schema();
-    init_stream();
-    AgentSideConnection = class {
-      static {
-        __name(this, "AgentSideConnection");
-      }
-      #connection;
-      /**
-       * Creates a new agent-side connection to a client.
-       *
-       * This establishes the communication channel from the agent's perspective
-       * following the ACP specification.
-       *
-       * @param toAgent - A function that creates an Agent handler to process incoming client requests
-       * @param stream - The bidirectional message stream for communication. Typically created using
-       *                 {@link ndJsonStream} for stdio-based connections.
-       *
-       * See protocol docs: [Communication Model](https://agentclientprotocol.com/protocol/overview#communication-model)
-       */
-      constructor(toAgent, stream) {
-        const agent = toAgent(this);
-        const requestHandler = /* @__PURE__ */ __name(async (method, params) => {
-          switch (method) {
-            case AGENT_METHODS.initialize: {
-              const validatedParams = zInitializeRequest.parse(params);
-              return agent.initialize(validatedParams);
-            }
-            case AGENT_METHODS.session_new: {
-              const validatedParams = zNewSessionRequest.parse(params);
-              return agent.newSession(validatedParams);
-            }
-            case AGENT_METHODS.session_load: {
-              if (!agent.loadSession) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zLoadSessionRequest.parse(params);
-              return agent.loadSession(validatedParams);
-            }
-            case AGENT_METHODS.session_list: {
-              if (!agent.unstable_listSessions) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zListSessionsRequest.parse(params);
-              return agent.unstable_listSessions(validatedParams);
-            }
-            case AGENT_METHODS.session_fork: {
-              if (!agent.unstable_forkSession) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zForkSessionRequest.parse(params);
-              return agent.unstable_forkSession(validatedParams);
-            }
-            case AGENT_METHODS.session_resume: {
-              if (!agent.unstable_resumeSession) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zResumeSessionRequest.parse(params);
-              return agent.unstable_resumeSession(validatedParams);
-            }
-            case AGENT_METHODS.session_set_mode: {
-              if (!agent.setSessionMode) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zSetSessionModeRequest.parse(params);
-              const result = await agent.setSessionMode(validatedParams);
-              return result ?? {};
-            }
-            case AGENT_METHODS.authenticate: {
-              const validatedParams = zAuthenticateRequest.parse(params);
-              const result = await agent.authenticate(validatedParams);
-              return result ?? {};
-            }
-            case AGENT_METHODS.session_prompt: {
-              const validatedParams = zPromptRequest.parse(params);
-              return agent.prompt(validatedParams);
-            }
-            case AGENT_METHODS.session_set_model: {
-              if (!agent.unstable_setSessionModel) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zSetSessionModelRequest.parse(params);
-              const result = await agent.unstable_setSessionModel(validatedParams);
-              return result ?? {};
-            }
-            case AGENT_METHODS.session_set_config_option: {
-              if (!agent.setSessionConfigOption) {
-                throw RequestError.methodNotFound(method);
-              }
-              const validatedParams = zSetSessionConfigOptionRequest.parse(params);
-              return agent.setSessionConfigOption(validatedParams);
-            }
-            default:
-              if (agent.extMethod) {
-                return agent.extMethod(method, params);
-              }
-              throw RequestError.methodNotFound(method);
-          }
-        }, "requestHandler");
-        const notificationHandler = /* @__PURE__ */ __name(async (method, params) => {
-          switch (method) {
-            case AGENT_METHODS.session_cancel: {
-              const validatedParams = zCancelNotification.parse(params);
-              return agent.cancel(validatedParams);
-            }
-            default:
-              if (agent.extNotification) {
-                return agent.extNotification(method, params);
-              }
-              throw RequestError.methodNotFound(method);
-          }
-        }, "notificationHandler");
-        this.#connection = new Connection(requestHandler, notificationHandler, stream);
-      }
-      /**
-       * Handles session update notifications from the agent.
-       *
-       * This is a notification endpoint (no response expected) that sends
-       * real-time updates about session progress, including message chunks,
-       * tool calls, and execution plans.
-       *
-       * Note: Clients SHOULD continue accepting tool call updates even after
-       * sending a `session/cancel` notification, as the agent may send final
-       * updates before responding with the cancelled stop reason.
-       *
-       * See protocol docs: [Agent Reports Output](https://agentclientprotocol.com/protocol/prompt-turn#3-agent-reports-output)
-       */
-      async sessionUpdate(params) {
-        return await this.#connection.sendNotification(CLIENT_METHODS.session_update, params);
-      }
-      /**
-       * Requests permission from the user for a tool call operation.
-       *
-       * Called by the agent when it needs user authorization before executing
-       * a potentially sensitive operation. The client should present the options
-       * to the user and return their decision.
-       *
-       * If the client cancels the prompt turn via `session/cancel`, it MUST
-       * respond to this request with `RequestPermissionOutcome::Cancelled`.
-       *
-       * See protocol docs: [Requesting Permission](https://agentclientprotocol.com/protocol/tool-calls#requesting-permission)
-       */
-      async requestPermission(params) {
-        return await this.#connection.sendRequest(CLIENT_METHODS.session_request_permission, params);
-      }
-      /**
-       * Reads content from a text file in the client's file system.
-       *
-       * Only available if the client advertises the `fs.readTextFile` capability.
-       * Allows the agent to access file contents within the client's environment.
-       *
-       * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
-       */
-      async readTextFile(params) {
-        return await this.#connection.sendRequest(CLIENT_METHODS.fs_read_text_file, params);
-      }
-      /**
-       * Writes content to a text file in the client's file system.
-       *
-       * Only available if the client advertises the `fs.writeTextFile` capability.
-       * Allows the agent to create or modify files within the client's environment.
-       *
-       * See protocol docs: [Client](https://agentclientprotocol.com/protocol/overview#client)
-       */
-      async writeTextFile(params) {
-        return await this.#connection.sendRequest(CLIENT_METHODS.fs_write_text_file, params) ?? {};
-      }
-      /**
-       * Executes a command in a new terminal.
-       *
-       * Returns a `TerminalHandle` that can be used to get output, wait for exit,
-       * kill the command, or release the terminal.
-       *
-       * The terminal can also be embedded in tool calls by using its ID in
-       * `ToolCallContent` with type "terminal".
-       *
-       * @param params - The terminal creation parameters
-       * @returns A handle to control and monitor the terminal
-       */
-      async createTerminal(params) {
-        const response = await this.#connection.sendRequest(CLIENT_METHODS.terminal_create, params);
-        return new TerminalHandle(response.terminalId, params.sessionId, this.#connection);
-      }
-      /**
-       * Extension method
-       *
-       * Allows the Agent to send an arbitrary request that is not part of the ACP spec.
-       */
-      async extMethod(method, params) {
-        return await this.#connection.sendRequest(method, params);
-      }
-      /**
-       * Extension notification
-       *
-       * Allows the Agent to send an arbitrary notification that is not part of the ACP spec.
-       */
-      async extNotification(method, params) {
-        return await this.#connection.sendNotification(method, params);
-      }
-      /**
-       * AbortSignal that aborts when the connection closes.
-       *
-       * This signal can be used to:
-       * - Listen for connection closure: `connection.signal.addEventListener('abort', () => {...})`
-       * - Check connection status synchronously: `if (connection.signal.aborted) {...}`
-       * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
-       *
-       * The connection closes when the underlying stream ends, either normally or due to an error.
-       *
-       * @example
-       * ```typescript
-       * const connection = new AgentSideConnection(agent, stream);
-       *
-       * // Listen for closure
-       * connection.signal.addEventListener('abort', () => {
-       *   console.log('Connection closed - performing cleanup');
-       * });
-       *
-       * // Check status
-       * if (connection.signal.aborted) {
-       *   console.log('Connection is already closed');
-       * }
-       *
-       * // Pass to other APIs
-       * fetch(url, { signal: connection.signal });
-       * ```
-       */
-      get signal() {
-        return this.#connection.signal;
-      }
-      /**
-       * Promise that resolves when the connection closes.
-       *
-       * The connection closes when the underlying stream ends, either normally or due to an error.
-       * Once closed, the connection cannot send or receive any more messages.
-       *
-       * This is useful for async/await style cleanup:
-       *
-       * @example
-       * ```typescript
-       * const connection = new AgentSideConnection(agent, stream);
-       * await connection.closed;
-       * console.log('Connection closed - performing cleanup');
-       * ```
-       */
-      get closed() {
-        return this.#connection.closed;
-      }
-    };
-    TerminalHandle = class {
-      static {
-        __name(this, "TerminalHandle");
-      }
-      id;
-      #sessionId;
-      #connection;
-      constructor(id, sessionId, conn) {
-        this.id = id;
-        this.#sessionId = sessionId;
-        this.#connection = conn;
-      }
-      /**
-       * Gets the current terminal output without waiting for the command to exit.
-       */
-      async currentOutput() {
-        return await this.#connection.sendRequest(CLIENT_METHODS.terminal_output, {
-          sessionId: this.#sessionId,
-          terminalId: this.id
-        });
-      }
-      /**
-       * Waits for the terminal command to complete and returns its exit status.
-       */
-      async waitForExit() {
-        return await this.#connection.sendRequest(CLIENT_METHODS.terminal_wait_for_exit, {
-          sessionId: this.#sessionId,
-          terminalId: this.id
-        });
-      }
-      /**
-       * Kills the terminal command without releasing the terminal.
-       *
-       * The terminal remains valid after killing, allowing you to:
-       * - Get the final output with `currentOutput()`
-       * - Check the exit status
-       * - Release the terminal when done
-       *
-       * Useful for implementing timeouts or cancellation.
-       */
-      async kill() {
-        return await this.#connection.sendRequest(CLIENT_METHODS.terminal_kill, {
-          sessionId: this.#sessionId,
-          terminalId: this.id
-        }) ?? {};
-      }
-      /**
-       * Releases the terminal and frees all associated resources.
-       *
-       * If the command is still running, it will be killed.
-       * After release, the terminal ID becomes invalid and cannot be used
-       * with other terminal methods.
-       *
-       * Tool calls that already reference this terminal will continue to
-       * display its output.
-       *
-       * **Important:** Always call this method when done with the terminal.
-       */
-      async release() {
-        return await this.#connection.sendRequest(CLIENT_METHODS.terminal_release, {
-          sessionId: this.#sessionId,
-          terminalId: this.id
-        }) ?? {};
-      }
-      async [Symbol.asyncDispose]() {
-        await this.release();
-      }
-    };
-    ClientSideConnection = class {
-      static {
-        __name(this, "ClientSideConnection");
-      }
-      #connection;
-      /**
-       * Creates a new client-side connection to an agent.
-       *
-       * This establishes the communication channel between a client and agent
-       * following the ACP specification.
-       *
-       * @param toClient - A function that creates a Client handler to process incoming agent requests
-       * @param stream - The bidirectional message stream for communication. Typically created using
-       *                 {@link ndJsonStream} for stdio-based connections.
-       *
-       * See protocol docs: [Communication Model](https://agentclientprotocol.com/protocol/overview#communication-model)
-       */
-      constructor(toClient, stream) {
-        const client = toClient(this);
-        const requestHandler = /* @__PURE__ */ __name(async (method, params) => {
-          switch (method) {
-            case CLIENT_METHODS.fs_write_text_file: {
-              const validatedParams = zWriteTextFileRequest.parse(params);
-              return client.writeTextFile?.(validatedParams);
-            }
-            case CLIENT_METHODS.fs_read_text_file: {
-              const validatedParams = zReadTextFileRequest.parse(params);
-              return client.readTextFile?.(validatedParams);
-            }
-            case CLIENT_METHODS.session_request_permission: {
-              const validatedParams = zRequestPermissionRequest.parse(params);
-              return client.requestPermission(validatedParams);
-            }
-            case CLIENT_METHODS.terminal_create: {
-              const validatedParams = zCreateTerminalRequest.parse(params);
-              return client.createTerminal?.(validatedParams);
-            }
-            case CLIENT_METHODS.terminal_output: {
-              const validatedParams = zTerminalOutputRequest.parse(params);
-              return client.terminalOutput?.(validatedParams);
-            }
-            case CLIENT_METHODS.terminal_release: {
-              const validatedParams = zReleaseTerminalRequest.parse(params);
-              const result = await client.releaseTerminal?.(validatedParams);
-              return result ?? {};
-            }
-            case CLIENT_METHODS.terminal_wait_for_exit: {
-              const validatedParams = zWaitForTerminalExitRequest.parse(params);
-              return client.waitForTerminalExit?.(validatedParams);
-            }
-            case CLIENT_METHODS.terminal_kill: {
-              const validatedParams = zKillTerminalCommandRequest.parse(params);
-              const result = await client.killTerminal?.(validatedParams);
-              return result ?? {};
-            }
-            default:
-              if (client.extMethod) {
-                return client.extMethod(method, params);
-              }
-              throw RequestError.methodNotFound(method);
-          }
-        }, "requestHandler");
-        const notificationHandler = /* @__PURE__ */ __name(async (method, params) => {
-          switch (method) {
-            case CLIENT_METHODS.session_update: {
-              const validatedParams = zSessionNotification.parse(params);
-              return client.sessionUpdate(validatedParams);
-            }
-            default:
-              if (client.extNotification) {
-                return client.extNotification(method, params);
-              }
-              throw RequestError.methodNotFound(method);
-          }
-        }, "notificationHandler");
-        this.#connection = new Connection(requestHandler, notificationHandler, stream);
-      }
-      /**
-       * Establishes the connection with a client and negotiates protocol capabilities.
-       *
-       * This method is called once at the beginning of the connection to:
-       * - Negotiate the protocol version to use
-       * - Exchange capability information between client and agent
-       * - Determine available authentication methods
-       *
-       * The agent should respond with its supported protocol version and capabilities.
-       *
-       * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
-       */
-      async initialize(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.initialize, params);
-      }
-      /**
-       * Creates a new conversation session with the agent.
-       *
-       * Sessions represent independent conversation contexts with their own history and state.
-       *
-       * The agent should:
-       * - Create a new session context
-       * - Connect to any specified MCP servers
-       * - Return a unique session ID for future requests
-       *
-       * May return an `auth_required` error if the agent requires authentication.
-       *
-       * See protocol docs: [Session Setup](https://agentclientprotocol.com/protocol/session-setup)
-       */
-      async newSession(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_new, params);
-      }
-      /**
-       * Loads an existing session to resume a previous conversation.
-       *
-       * This method is only available if the agent advertises the `loadSession` capability.
-       *
-       * The agent should:
-       * - Restore the session context and conversation history
-       * - Connect to the specified MCP servers
-       * - Stream the entire conversation history back to the client via notifications
-       *
-       * See protocol docs: [Loading Sessions](https://agentclientprotocol.com/protocol/session-setup#loading-sessions)
-       */
-      async loadSession(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_load, params) ?? {};
-      }
-      /**
-       * **UNSTABLE**
-       *
-       * This capability is not part of the spec yet, and may be removed or changed at any point.
-       *
-       * Forks an existing session to create a new independent session.
-       *
-       * Creates a new session based on the context of an existing one, allowing
-       * operations like generating summaries without affecting the original session's history.
-       *
-       * This method is only available if the agent advertises the `session.fork` capability.
-       *
-       * @experimental
-       */
-      async unstable_forkSession(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_fork, params);
-      }
-      /**
-       * **UNSTABLE**
-       *
-       * This capability is not part of the spec yet, and may be removed or changed at any point.
-       *
-       * Lists existing sessions from the agent.
-       *
-       * This method is only available if the agent advertises the `listSessions` capability.
-       *
-       * Returns a list of sessions with metadata like session ID, working directory,
-       * title, and last update time. Supports filtering by working directory and
-       * cursor-based pagination.
-       *
-       * @experimental
-       */
-      async unstable_listSessions(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_list, params);
-      }
-      /**
-       * **UNSTABLE**
-       *
-       * This capability is not part of the spec yet, and may be removed or changed at any point.
-       *
-       * Resumes an existing session without returning previous messages.
-       *
-       * This method is only available if the agent advertises the `session.resume` capability.
-       *
-       * The agent should resume the session context, allowing the conversation to continue
-       * without replaying the message history (unlike `session/load`).
-       *
-       * @experimental
-       */
-      async unstable_resumeSession(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_resume, params);
-      }
-      /**
-       * Sets the operational mode for a session.
-       *
-       * Allows switching between different agent modes (e.g., "ask", "architect", "code")
-       * that affect system prompts, tool availability, and permission behaviors.
-       *
-       * The mode must be one of the modes advertised in `availableModes` during session
-       * creation or loading. Agents may also change modes autonomously and notify the
-       * client via `current_mode_update` notifications.
-       *
-       * This method can be called at any time during a session, whether the Agent is
-       * idle or actively generating a turn.
-       *
-       * See protocol docs: [Session Modes](https://agentclientprotocol.com/protocol/session-modes)
-       */
-      async setSessionMode(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_set_mode, params) ?? {};
-      }
-      /**
-       * **UNSTABLE**
-       *
-       * This capability is not part of the spec yet, and may be removed or changed at any point.
-       *
-       * Select a model for a given session.
-       *
-       * @experimental
-       */
-      async unstable_setSessionModel(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_set_model, params) ?? {};
-      }
-      /**
-       * Set a configuration option for a given session.
-       *
-       * The response contains the full set of configuration options and their current values,
-       * as changing one option may affect the available values or state of other options.
-       */
-      async setSessionConfigOption(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_set_config_option, params);
-      }
-      /**
-       * Authenticates the client using the specified authentication method.
-       *
-       * Called when the agent requires authentication before allowing session creation.
-       * The client provides the authentication method ID that was advertised during initialization.
-       *
-       * After successful authentication, the client can proceed to create sessions with
-       * `newSession` without receiving an `auth_required` error.
-       *
-       * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
-       */
-      async authenticate(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.authenticate, params) ?? {};
-      }
-      /**
-       * Processes a user prompt within a session.
-       *
-       * This method handles the whole lifecycle of a prompt:
-       * - Receives user messages with optional context (files, images, etc.)
-       * - Processes the prompt using language models
-       * - Reports language model content and tool calls to the Clients
-       * - Requests permission to run tools
-       * - Executes any requested tool calls
-       * - Returns when the turn is complete with a stop reason
-       *
-       * See protocol docs: [Prompt Turn](https://agentclientprotocol.com/protocol/prompt-turn)
-       */
-      async prompt(params) {
-        return await this.#connection.sendRequest(AGENT_METHODS.session_prompt, params);
-      }
-      /**
-       * Cancels ongoing operations for a session.
-       *
-       * This is a notification sent by the client to cancel an ongoing prompt turn.
-       *
-       * Upon receiving this notification, the Agent SHOULD:
-       * - Stop all language model requests as soon as possible
-       * - Abort all tool call invocations in progress
-       * - Send any pending `session/update` notifications
-       * - Respond to the original `session/prompt` request with `StopReason::Cancelled`
-       *
-       * See protocol docs: [Cancellation](https://agentclientprotocol.com/protocol/prompt-turn#cancellation)
-       */
-      async cancel(params) {
-        return await this.#connection.sendNotification(AGENT_METHODS.session_cancel, params);
-      }
-      /**
-       * Extension method
-       *
-       * Allows the Client to send an arbitrary request that is not part of the ACP spec.
-       */
-      async extMethod(method, params) {
-        return await this.#connection.sendRequest(method, params);
-      }
-      /**
-       * Extension notification
-       *
-       * Allows the Client to send an arbitrary notification that is not part of the ACP spec.
-       */
-      async extNotification(method, params) {
-        return await this.#connection.sendNotification(method, params);
-      }
-      /**
-       * AbortSignal that aborts when the connection closes.
-       *
-       * This signal can be used to:
-       * - Listen for connection closure: `connection.signal.addEventListener('abort', () => {...})`
-       * - Check connection status synchronously: `if (connection.signal.aborted) {...}`
-       * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
-       *
-       * The connection closes when the underlying stream ends, either normally or due to an error.
-       *
-       * @example
-       * ```typescript
-       * const connection = new ClientSideConnection(client, stream);
-       *
-       * // Listen for closure
-       * connection.signal.addEventListener('abort', () => {
-       *   console.log('Connection closed - performing cleanup');
-       * });
-       *
-       * // Check status
-       * if (connection.signal.aborted) {
-       *   console.log('Connection is already closed');
-       * }
-       *
-       * // Pass to other APIs
-       * fetch(url, { signal: connection.signal });
-       * ```
-       */
-      get signal() {
-        return this.#connection.signal;
-      }
-      /**
-       * Promise that resolves when the connection closes.
-       *
-       * The connection closes when the underlying stream ends, either normally or due to an error.
-       * Once closed, the connection cannot send or receive any more messages.
-       *
-       * This is useful for async/await style cleanup:
-       *
-       * @example
-       * ```typescript
-       * const connection = new ClientSideConnection(client, stream);
-       * await connection.closed;
-       * console.log('Connection closed - performing cleanup');
-       * ```
-       */
-      get closed() {
-        return this.#connection.closed;
-      }
-    };
-    Connection = class Connection2 {
-      static {
-        __name(this, "Connection");
-      }
-      #pendingResponses = /* @__PURE__ */ new Map();
-      #nextRequestId = 0;
-      #requestHandler;
-      #notificationHandler;
-      #stream;
-      #writeQueue = Promise.resolve();
-      #abortController = new AbortController();
-      #closedPromise;
-      constructor(requestHandler, notificationHandler, stream) {
-        this.#requestHandler = requestHandler;
-        this.#notificationHandler = notificationHandler;
-        this.#stream = stream;
-        this.#closedPromise = new Promise((resolve) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve());
-        });
-        this.#receive();
-      }
-      /**
-       * AbortSignal that aborts when the connection closes.
-       *
-       * This signal can be used to:
-       * - Listen for connection closure via event listeners
-       * - Check connection status synchronously with `signal.aborted`
-       * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
-       */
-      get signal() {
-        return this.#abortController.signal;
-      }
-      /**
-       * Promise that resolves when the connection closes.
-       *
-       * The connection closes when the underlying stream ends, either normally
-       * or due to an error. Once closed, the connection cannot send or receive
-       * any more messages.
-       *
-       * @example
-       * ```typescript
-       * const connection = new ClientSideConnection(client, stream);
-       * await connection.closed;
-       * console.log('Connection closed - performing cleanup');
-       * ```
-       */
-      get closed() {
-        return this.#closedPromise;
-      }
-      async #receive() {
-        const reader = this.#stream.readable.getReader();
-        try {
-          while (true) {
-            const { value: message, done } = await reader.read();
-            if (done) {
-              break;
-            }
-            if (!message) {
-              continue;
-            }
-            try {
-              this.#processMessage(message);
-            } catch (err) {
-              console.error("Unexpected error during message processing:", message, err);
-              if ("id" in message && message.id !== void 0) {
-                this.#sendMessage({
-                  jsonrpc: "2.0",
-                  id: message.id,
-                  error: {
-                    code: -32700,
-                    message: "Parse error"
-                  }
-                });
-              }
-            }
-          }
-        } finally {
-          reader.releaseLock();
-          this.#abortController.abort();
-        }
-      }
-      async #processMessage(message) {
-        if ("method" in message && "id" in message) {
-          const response = await this.#tryCallRequestHandler(message.method, message.params);
-          if ("error" in response) {
-            console.error("Error handling request", message, response.error);
-          }
-          await this.#sendMessage({
-            jsonrpc: "2.0",
-            id: message.id,
-            ...response
-          });
-        } else if ("method" in message) {
-          const response = await this.#tryCallNotificationHandler(message.method, message.params);
-          if ("error" in response) {
-            console.error("Error handling notification", message, response.error);
-          }
-        } else if ("id" in message) {
-          this.#handleResponse(message);
-        } else {
-          console.error("Invalid message", {
-            message
-          });
-        }
-      }
-      async #tryCallRequestHandler(method, params) {
-        try {
-          const result = await this.#requestHandler(method, params);
-          return {
-            result: result ?? null
-          };
-        } catch (error) {
-          if (error instanceof RequestError) {
-            return error.toResult();
-          }
-          if (error instanceof z2.ZodError) {
-            return RequestError.invalidParams(error.format()).toResult();
-          }
-          let details;
-          if (error instanceof Error) {
-            details = error.message;
-          } else if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string") {
-            details = error.message;
-          }
-          try {
-            return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
-          } catch {
-            return RequestError.internalError({
-              details
-            }).toResult();
-          }
-        }
-      }
-      async #tryCallNotificationHandler(method, params) {
-        try {
-          await this.#notificationHandler(method, params);
-          return {
-            result: null
-          };
-        } catch (error) {
-          if (error instanceof RequestError) {
-            return error.toResult();
-          }
-          if (error instanceof z2.ZodError) {
-            return RequestError.invalidParams(error.format()).toResult();
-          }
-          let details;
-          if (error instanceof Error) {
-            details = error.message;
-          } else if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string") {
-            details = error.message;
-          }
-          try {
-            return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
-          } catch {
-            return RequestError.internalError({
-              details
-            }).toResult();
-          }
-        }
-      }
-      #handleResponse(response) {
-        const pendingResponse = this.#pendingResponses.get(response.id);
-        if (pendingResponse) {
-          if ("result" in response) {
-            pendingResponse.resolve(response.result);
-          } else if ("error" in response) {
-            pendingResponse.reject(response.error);
-          }
-          this.#pendingResponses.delete(response.id);
-        } else {
-          console.error("Got response to unknown request", response.id);
-        }
-      }
-      async sendRequest(method, params) {
-        const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve, reject) => {
-          this.#pendingResponses.set(id, {
-            resolve,
-            reject
-          });
-        });
-        await this.#sendMessage({
-          jsonrpc: "2.0",
-          id,
-          method,
-          params
-        });
-        return responsePromise;
-      }
-      async sendNotification(method, params) {
-        await this.#sendMessage({
-          jsonrpc: "2.0",
-          method,
-          params
-        });
-      }
-      async #sendMessage(message) {
-        this.#writeQueue = this.#writeQueue.then(async () => {
-          const writer = this.#stream.writable.getWriter();
-          try {
-            await writer.write(message);
-          } finally {
-            writer.releaseLock();
-          }
-        }).catch((error) => {
-          console.error("ACP write error:", error);
-        });
-        return this.#writeQueue;
-      }
-    };
-    RequestError = class _RequestError extends Error {
-      static {
-        __name(this, "RequestError");
-      }
-      code;
-      data;
-      constructor(code, message, data) {
-        super(message);
-        this.code = code;
-        this.name = "RequestError";
-        this.data = data;
-      }
-      /**
-       * Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
-       */
-      static parseError(data, additionalMessage) {
-        return new _RequestError(-32700, `Parse error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-      }
-      /**
-       * The JSON sent is not a valid Request object.
-       */
-      static invalidRequest(data, additionalMessage) {
-        return new _RequestError(-32600, `Invalid request${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-      }
-      /**
-       * The method does not exist / is not available.
-       */
-      static methodNotFound(method) {
-        return new _RequestError(-32601, `"Method not found": ${method}`, {
-          method
-        });
-      }
-      /**
-       * Invalid method parameter(s).
-       */
-      static invalidParams(data, additionalMessage) {
-        return new _RequestError(-32602, `Invalid params${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-      }
-      /**
-       * Internal JSON-RPC error.
-       */
-      static internalError(data, additionalMessage) {
-        return new _RequestError(-32603, `Internal error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-      }
-      /**
-       * Authentication required.
-       */
-      static authRequired(data, additionalMessage) {
-        return new _RequestError(-32e3, `Authentication required${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
-      }
-      /**
-       * Resource, such as a file, was not found
-       */
-      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
-        };
-      }
-    };
-  }
-});
-
-export {
-  __name,
-  __require,
-  __esm,
-  __commonJS,
-  __export,
-  __toESM,
-  __toCommonJS,
-  AGENT_METHODS,
-  CLIENT_METHODS,
-  PROTOCOL_VERSION,
-  ndJsonStream,
-  AgentSideConnection,
-  TerminalHandle,
-  ClientSideConnection,
-  RequestError,
-  acp_exports,
-  init_acp
-};