lody 0.72.0 → 0.74.0

package/dist/chunks/package-C4jJQVT8.js

@@ -0,0 +1,4133 @@
+import { c as array, e as unknown, N as NEVER, u as union, n as number, s as string, o as object, r as record, G as int, l as literal, b as boolean, y as intersection, H as url } from "./schemas-BDpQ67Nq.js";
+const 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",
+  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"
+};
+const 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",
+  elicitation_create: "elicitation/create",
+  elicitation_complete: "elicitation/complete"
+};
+const PROTOCOL_VERSION = 1;
+const 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 !== void 0)
+      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 void 0;
+  }
+  const tag = value[key];
+  return typeof tag === "string" ? tag : void 0;
+}
+function excludeKnownTags(schema, key, knownTags) {
+  return schema.superRefine((value, context) => {
+    const tag = stringTag(value, key);
+    if (tag !== void 0 && 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 !== void 0 && !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));
+}
+const zRequestId = union([number(), string()]).nullable();
+const zSessionId = string();
+const zWriteTextFileRequest = object({
+  sessionId: zSessionId,
+  path: string(),
+  content: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zReadTextFileRequest = object({
+  sessionId: zSessionId,
+  path: string(),
+  line: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  limit: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zToolCallId = string();
+const zToolKind = union([
+  literal("read"),
+  literal("edit"),
+  literal("delete"),
+  literal("move"),
+  literal("search"),
+  literal("execute"),
+  literal("think"),
+  literal("fetch"),
+  literal("switch_mode"),
+  literal("other")
+]);
+const zToolCallStatus = union([
+  literal("pending"),
+  literal("in_progress"),
+  literal("completed"),
+  literal("failed")
+]);
+const zRole = union([literal("assistant"), literal("user")]);
+const zAnnotations = object({
+  audience: defaultOnError(vecSkipError(zRole).nullish(), () => void 0),
+  lastModified: defaultOnError(string().nullish(), () => void 0),
+  priority: defaultOnError(number().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTextContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zImageContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  data: string(),
+  mimeType: string(),
+  uri: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAudioContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  data: string(),
+  mimeType: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zResourceLink = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  description: defaultOnError(string().nullish(), () => void 0),
+  mimeType: defaultOnError(string().nullish(), () => void 0),
+  name: string(),
+  size: defaultOnError(number().nullish(), () => void 0),
+  title: defaultOnError(string().nullish(), () => void 0),
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTextResourceContents = object({
+  mimeType: defaultOnError(string().nullish(), () => void 0),
+  text: string(),
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zBlobResourceContents = object({
+  blob: string(),
+  mimeType: defaultOnError(string().nullish(), () => void 0),
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zEmbeddedResourceResource = union([
+  zTextResourceContents,
+  zBlobResourceContents
+]);
+const zEmbeddedResource = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
+  resource: zEmbeddedResourceResource,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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")
+  }))
+]);
+const zContent = object({
+  content: zContentBlock,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDiff = object({
+  path: string(),
+  oldText: defaultOnError(string().nullish(), () => void 0),
+  newText: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTerminalId = string();
+const zTerminal = object({
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zToolCallContent = union([
+  zContent.and(object({
+    type: literal("content")
+  })),
+  zDiff.and(object({
+    type: literal("diff")
+  })),
+  zTerminal.and(object({
+    type: literal("terminal")
+  }))
+]);
+const zToolCallLocation = object({
+  path: string(),
+  line: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zToolCallUpdate = object({
+  toolCallId: zToolCallId,
+  kind: defaultOnError(zToolKind.nullish(), () => void 0),
+  status: defaultOnError(zToolCallStatus.nullish(), () => void 0),
+  title: defaultOnError(string().nullish(), () => void 0),
+  name: defaultOnError(string().nullish(), () => void 0),
+  content: defaultOnError(vecSkipError(zToolCallContent).nullish(), () => void 0),
+  locations: defaultOnError(vecSkipError(zToolCallLocation).nullish(), () => void 0),
+  rawInput: defaultOnError(unknown().optional(), () => void 0),
+  rawOutput: defaultOnError(unknown().optional(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPermissionOptionId = string();
+const zPermissionOptionKind = union([
+  literal("allow_once"),
+  literal("allow_always"),
+  literal("reject_once"),
+  literal("reject_always")
+]);
+const zPermissionOption = object({
+  optionId: zPermissionOptionId,
+  name: string(),
+  kind: zPermissionOptionKind,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zRequestPermissionRequest = object({
+  sessionId: zSessionId,
+  toolCall: zToolCallUpdate,
+  options: array(zPermissionOption),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zEnvVariable = object({
+  name: string(),
+  value: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCreateTerminalRequest = object({
+  sessionId: zSessionId,
+  command: string(),
+  args: defaultOnError(vecSkipError(string()).optional(), () => []),
+  env: defaultOnError(vecSkipError(zEnvVariable).optional(), () => []),
+  cwd: defaultOnError(string().nullish(), () => void 0),
+  outputByteLimit: defaultOnError(number().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTerminalOutputRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zReleaseTerminalRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zWaitForTerminalExitRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zKillTerminalRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zElicitationSessionScope = object({
+  sessionId: zSessionId,
+  toolCallId: defaultOnError(zToolCallId.nullish(), () => void 0)
+});
+const zElicitationRequestScope = object({
+  requestId: zRequestId
+});
+const zElicitationSchemaType = literal("object");
+const zStringFormat = union([
+  literal("email"),
+  literal("uri"),
+  literal("date"),
+  literal("date-time")
+]);
+const zEnumOption = object({
+  const: string(),
+  title: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zStringPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => void 0),
+  description: defaultOnError(string().nullish(), () => void 0),
+  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: string().nullish(),
+  format: zStringFormat.nullish(),
+  default: defaultOnError(string().nullish(), () => void 0),
+  enum: array(string()).nullish(),
+  oneOf: array(zEnumOption).nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNumberPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => void 0),
+  description: defaultOnError(string().nullish(), () => void 0),
+  minimum: number().nullish(),
+  maximum: number().nullish(),
+  default: defaultOnError(number().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zIntegerPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => void 0),
+  description: defaultOnError(string().nullish(), () => void 0),
+  minimum: number().nullish(),
+  maximum: number().nullish(),
+  default: defaultOnError(number().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zBooleanPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => void 0),
+  description: defaultOnError(string().nullish(), () => void 0),
+  default: defaultOnError(boolean().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zStringMultiSelectItems = object({
+  enum: array(string()),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTitledMultiSelectItems = object({
+  anyOf: array(zEnumOption),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMultiSelectItems = preserveCustomPayload(union([
+  zStringMultiSelectItems.and(object({
+    type: literal("string")
+  })),
+  excludeKnownTags(object({
+    type: string()
+  }), "type", ["string"]),
+  zTitledMultiSelectItems
+]), "type", ["string"]);
+const zMultiSelectPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => void 0),
+  description: defaultOnError(string().nullish(), () => void 0),
+  minItems: number().nullish(),
+  maxItems: number().nullish(),
+  items: zMultiSelectItems,
+  default: defaultOnError(vecSkipError(string()).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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: string()
+  }), "type", ["array", "boolean", "integer", "number", "string"])
+]), "type", ["array", "boolean", "integer", "number", "string"]);
+const zElicitationSchema = object({
+  type: defaultOnError(zElicitationSchemaType.optional().default("object"), () => "object"),
+  title: defaultOnError(string().nullish(), () => void 0),
+  properties: record(string(), zElicitationPropertySchema).optional().default({}),
+  required: array(string()).nullish(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zElicitationFormMode = intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
+  requestedSchema: zElicitationSchema
+}));
+const zElicitationId = string();
+const zElicitationUrlMode = intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
+  elicitationId: zElicitationId,
+  url: url()
+}));
+const zCreateElicitationRequest = preserveCustomPayload(intersection(union([
+  zElicitationFormMode.and(object({
+    mode: literal("form")
+  })),
+  zElicitationUrlMode.and(object({
+    mode: literal("url")
+  })),
+  excludeKnownTags(intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
+    mode: string()
+  })), "mode", ["form", "url"])
+]), object({
+  message: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+})), "mode", ["form", "url"]);
+const zMcpServerAcpId = string();
+const zConnectMcpRequest = object({
+  serverId: zMcpServerAcpId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpConnectionId = string();
+const zMessageMcpRequest = object({
+  connectionId: zMcpConnectionId,
+  method: string(),
+  params: record(string(), unknown()).nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDisconnectMcpRequest = object({
+  connectionId: zMcpConnectionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zExtRequest = unknown();
+object({
+  id: zRequestId,
+  method: string(),
+  params: union([
+    zWriteTextFileRequest,
+    zReadTextFileRequest,
+    zRequestPermissionRequest,
+    zCreateTerminalRequest,
+    zTerminalOutputRequest,
+    zReleaseTerminalRequest,
+    zWaitForTerminalExitRequest,
+    zKillTerminalRequest,
+    zCreateElicitationRequest,
+    zConnectMcpRequest,
+    zMessageMcpRequest,
+    zDisconnectMcpRequest,
+    zExtRequest
+  ]).nullish()
+});
+const zProtocolVersion = int().gte(0).lte(65535);
+const zPromptCapabilities = object({
+  image: defaultOnError(boolean().optional().default(false), () => false),
+  audio: defaultOnError(boolean().optional().default(false), () => false),
+  embeddedContext: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpCapabilities = object({
+  http: defaultOnError(boolean().optional().default(false), () => false),
+  sse: defaultOnError(boolean().optional().default(false), () => false),
+  acp: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionListCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionDeleteCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionAdditionalDirectoriesCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionForkCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionResumeCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionCloseCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionCapabilities = object({
+  list: defaultOnError(zSessionListCapabilities.nullish(), () => void 0),
+  delete: defaultOnError(zSessionDeleteCapabilities.nullish(), () => void 0),
+  additionalDirectories: defaultOnError(zSessionAdditionalDirectoriesCapabilities.nullish(), () => void 0),
+  fork: defaultOnError(zSessionForkCapabilities.nullish(), () => void 0),
+  resume: defaultOnError(zSessionResumeCapabilities.nullish(), () => void 0),
+  close: defaultOnError(zSessionCloseCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zLogoutCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAgentAuthCapabilities = object({
+  logout: defaultOnError(zLogoutCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zProvidersCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDocumentDidOpenCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTextDocumentSyncKind = union([
+  literal("full"),
+  literal("incremental")
+]);
+const zNesDocumentDidChangeCapabilities = object({
+  syncKind: zTextDocumentSyncKind,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDocumentDidCloseCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDocumentDidSaveCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDocumentDidFocusCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDocumentEventCapabilities = object({
+  didOpen: defaultOnError(zNesDocumentDidOpenCapabilities.nullish(), () => void 0),
+  didChange: defaultOnError(zNesDocumentDidChangeCapabilities.nullish(), () => void 0),
+  didClose: defaultOnError(zNesDocumentDidCloseCapabilities.nullish(), () => void 0),
+  didSave: defaultOnError(zNesDocumentDidSaveCapabilities.nullish(), () => void 0),
+  didFocus: defaultOnError(zNesDocumentDidFocusCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesEventCapabilities = object({
+  document: defaultOnError(zNesDocumentEventCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRecentFilesCapabilities = object({
+  maxCount: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRelatedSnippetsCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesEditHistoryCapabilities = object({
+  maxCount: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesUserActionsCapabilities = object({
+  maxCount: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesOpenFilesCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDiagnosticsCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesContextCapabilities = object({
+  recentFiles: defaultOnError(zNesRecentFilesCapabilities.nullish(), () => void 0),
+  relatedSnippets: defaultOnError(zNesRelatedSnippetsCapabilities.nullish(), () => void 0),
+  editHistory: defaultOnError(zNesEditHistoryCapabilities.nullish(), () => void 0),
+  userActions: defaultOnError(zNesUserActionsCapabilities.nullish(), () => void 0),
+  openFiles: defaultOnError(zNesOpenFilesCapabilities.nullish(), () => void 0),
+  diagnostics: defaultOnError(zNesDiagnosticsCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesCapabilities = object({
+  events: defaultOnError(zNesEventCapabilities.nullish(), () => void 0),
+  context: defaultOnError(zNesContextCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPositionEncodingKind = union([
+  literal("utf-16"),
+  literal("utf-32"),
+  literal("utf-8")
+]);
+const zAgentCapabilities = object({
+  loadSession: defaultOnError(boolean().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(), () => void 0),
+  nes: defaultOnError(zNesCapabilities.nullish(), () => void 0),
+  positionEncoding: defaultOnError(zPositionEncodingKind.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthMethodId = string();
+const zAuthEnvVar = object({
+  name: string(),
+  label: defaultOnError(string().nullish(), () => void 0),
+  secret: defaultOnError(boolean().optional().default(true), () => true),
+  optional: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthMethodEnvVar = object({
+  id: zAuthMethodId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  vars: requiredDefaultOnError(vecSkipError(zAuthEnvVar), () => []),
+  link: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthMethodTerminal = object({
+  id: zAuthMethodId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  args: defaultOnError(vecSkipError(string()).optional(), () => []),
+  env: defaultOnError(record(string(), string()).optional(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthMethodAgent = object({
+  id: zAuthMethodId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthMethod = union([
+  zAuthMethodEnvVar.and(object({
+    type: literal("env_var")
+  })),
+  zAuthMethodTerminal.and(object({
+    type: literal("terminal")
+  })),
+  zAuthMethodAgent
+]);
+const zImplementation = object({
+  name: string(),
+  title: defaultOnError(string().nullish(), () => void 0),
+  version: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthenticateResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zProviderId = string();
+const zLlmProtocol = union([
+  literal("anthropic"),
+  literal("openai"),
+  literal("azure"),
+  literal("vertex"),
+  literal("bedrock"),
+  string()
+]);
+const zProviderCurrentConfig = object({
+  apiType: zLlmProtocol,
+  baseUrl: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zProviderInfo = object({
+  providerId: zProviderId,
+  supported: requiredDefaultOnError(vecSkipError(zLlmProtocol), () => []),
+  required: boolean(),
+  current: zProviderCurrentConfig.nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zListProvidersResponse = object({
+  providers: array(zProviderInfo),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSetProviderResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDisableProviderResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zLogoutResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionModeId = string();
+const zSessionMode = object({
+  id: zSessionModeId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionModeState = object({
+  currentModeId: zSessionModeId,
+  availableModes: requiredDefaultOnError(vecSkipError(zSessionMode), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionConfigId = string();
+const zSessionConfigOptionCategory = union([
+  literal("mode"),
+  literal("model"),
+  literal("model_config"),
+  literal("thought_level"),
+  string()
+]);
+const zSessionConfigValueId = string();
+const zSessionConfigSelectOption = object({
+  value: zSessionConfigValueId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionConfigGroupId = string();
+const zSessionConfigSelectGroup = object({
+  group: zSessionConfigGroupId,
+  name: string(),
+  options: requiredDefaultOnError(vecSkipError(zSessionConfigSelectOption), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionConfigSelectOptions = union([
+  array(zSessionConfigSelectOption),
+  array(zSessionConfigSelectGroup)
+]);
+const zSessionConfigSelect = object({
+  currentValue: zSessionConfigValueId,
+  options: zSessionConfigSelectOptions
+});
+const zSessionConfigBoolean = object({
+  currentValue: boolean()
+});
+const zSessionConfigOption = intersection(union([
+  zSessionConfigSelect.and(object({
+    type: literal("select")
+  })),
+  zSessionConfigBoolean.and(object({
+    type: literal("boolean")
+  }))
+]), object({
+  id: zSessionConfigId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => void 0),
+  category: defaultOnError(zSessionConfigOptionCategory.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+}));
+const zNewSessionResponse = object({
+  sessionId: zSessionId,
+  modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zLoadSessionResponse = object({
+  modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionInfo = object({
+  sessionId: zSessionId,
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  title: defaultOnError(string().nullish(), () => void 0),
+  updatedAt: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zListSessionsResponse = object({
+  sessions: requiredDefaultOnError(vecSkipError(zSessionInfo), () => []),
+  nextCursor: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDeleteSessionResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zForkSessionResponse = object({
+  sessionId: zSessionId,
+  modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zResumeSessionResponse = object({
+  modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCloseSessionResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSetSessionModeResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSetSessionConfigOptionResponse = object({
+  configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zStopReason = union([
+  literal("end_turn"),
+  literal("max_tokens"),
+  literal("max_turn_requests"),
+  literal("refusal"),
+  literal("cancelled")
+]);
+const zUsage = object({
+  totalTokens: number(),
+  inputTokens: number(),
+  outputTokens: number(),
+  thoughtTokens: defaultOnError(number().nullish(), () => void 0),
+  cachedReadTokens: defaultOnError(number().nullish(), () => void 0),
+  cachedWriteTokens: defaultOnError(number().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPromptResponse = object({
+  stopReason: zStopReason,
+  usage: defaultOnError(zUsage.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zStartNesResponse = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesSuggestionId = string();
+const 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(string(), unknown()).nullish(), () => void 0)
+});
+const zRange = object({
+  start: zPosition,
+  end: zPosition,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesTextEdit = object({
+  range: zRange,
+  newText: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesEditSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  edits: array(zNesTextEdit),
+  cursorPosition: defaultOnError(zPosition.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesJumpSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  position: zPosition,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRenameSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  position: zPosition,
+  newName: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesSearchAndReplaceSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  search: string(),
+  replace: string(),
+  isRegex: boolean().nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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")
+  }))
+]);
+const zSuggestNesResponse = object({
+  suggestions: array(zNesSuggestion),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCloseNesResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zExtResponse = unknown();
+const zMessageMcpResponse = unknown();
+const zErrorCode = union([
+  literal(-32700),
+  literal(-32600),
+  literal(-32601),
+  literal(-32602),
+  literal(-32603),
+  literal(-32800),
+  literal(-32e3),
+  literal(-32002),
+  int().min(-2147483648, {
+    error: "Invalid value: Expected int32 to be >= -2147483648"
+  }).max(2147483647, {
+    error: "Invalid value: Expected int32 to be <= 2147483647"
+  })
+]);
+const zError = object({
+  code: zErrorCode,
+  message: string(),
+  data: defaultOnError(unknown().optional(), () => void 0)
+});
+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
+  })
+]);
+const zMessageId = string();
+const zContentChunk = object({
+  content: zContentBlock,
+  messageId: defaultOnError(zMessageId.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zToolCall = object({
+  toolCallId: zToolCallId,
+  title: string(),
+  name: defaultOnError(string().nullish(), () => void 0),
+  kind: defaultOnError(zToolKind.optional(), () => void 0),
+  status: defaultOnError(zToolCallStatus.optional(), () => void 0),
+  content: defaultOnError(vecSkipError(zToolCallContent).optional(), () => []),
+  locations: defaultOnError(vecSkipError(zToolCallLocation).optional(), () => []),
+  rawInput: defaultOnError(unknown().optional(), () => void 0),
+  rawOutput: defaultOnError(unknown().optional(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanEntryPriority = union([
+  literal("high"),
+  literal("medium"),
+  literal("low")
+]);
+const zPlanEntryStatus = union([
+  literal("pending"),
+  literal("in_progress"),
+  literal("completed")
+]);
+const zPlanEntry = object({
+  content: string(),
+  priority: zPlanEntryPriority,
+  status: zPlanEntryStatus,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlan = object({
+  entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanId = string();
+const zPlanItems = object({
+  planId: zPlanId,
+  entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanFile = object({
+  planId: zPlanId,
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanMarkdown = object({
+  planId: zPlanId,
+  content: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanUpdateContent = union([
+  zPlanItems.and(object({
+    type: literal("items")
+  })),
+  zPlanFile.and(object({
+    type: literal("file")
+  })),
+  zPlanMarkdown.and(object({
+    type: literal("markdown")
+  }))
+]);
+const zPlanUpdate = object({
+  plan: zPlanUpdateContent,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanRemoved = object({
+  planId: zPlanId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zUnstructuredCommandInput = object({
+  hint: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAvailableCommandInput = zUnstructuredCommandInput;
+const zAvailableCommand = object({
+  name: string(),
+  description: string(),
+  input: defaultOnError(zAvailableCommandInput.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAvailableCommandsUpdate = object({
+  availableCommands: requiredDefaultOnError(vecSkipError(zAvailableCommand), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCurrentModeUpdate = object({
+  currentModeId: zSessionModeId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zConfigOptionUpdate = object({
+  configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionInfoUpdate = object({
+  title: defaultOnError(string().nullish(), () => void 0),
+  updatedAt: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCost = object({
+  amount: number(),
+  currency: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zUsageUpdate = object({
+  used: number(),
+  size: number(),
+  cost: defaultOnError(zCost.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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")
+  }))
+]);
+const zSessionNotification = object({
+  sessionId: zSessionId,
+  update: zSessionUpdate,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCompleteElicitationNotification = object({
+  elicitationId: zElicitationId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMessageMcpNotification = object({
+  connectionId: zMcpConnectionId,
+  method: string(),
+  params: defaultOnError(record(string(), unknown()).nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zExtNotification = unknown();
+object({
+  method: string(),
+  params: union([
+    zSessionNotification,
+    zCompleteElicitationNotification,
+    zMessageMcpNotification,
+    zExtNotification
+  ]).nullish()
+});
+const zFileSystemCapabilities = object({
+  readTextFile: defaultOnError(boolean().optional().default(false), () => false),
+  writeTextFile: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zBooleanConfigOptionCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSessionConfigOptionsCapabilities = object({
+  boolean: defaultOnError(zBooleanConfigOptionCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zClientSessionCapabilities = object({
+  configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zPlanCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthCapabilities = object({
+  terminal: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zElicitationFormCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zElicitationUrlCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zElicitationCapabilities = object({
+  form: defaultOnError(zElicitationFormCapabilities.nullish(), () => void 0),
+  url: defaultOnError(zElicitationUrlCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesJumpCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRenameCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesSearchAndReplaceCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zClientNesCapabilities = object({
+  jump: defaultOnError(zNesJumpCapabilities.nullish(), () => void 0),
+  rename: defaultOnError(zNesRenameCapabilities.nullish(), () => void 0),
+  searchAndReplace: defaultOnError(zNesSearchAndReplaceCapabilities.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zClientCapabilities = object({
+  fs: defaultOnError(zFileSystemCapabilities.optional().default({ readTextFile: false, writeTextFile: false }), () => ({ readTextFile: false, writeTextFile: false })),
+  terminal: defaultOnError(boolean().optional().default(false), () => false),
+  session: defaultOnError(zClientSessionCapabilities.nullish(), () => void 0),
+  plan: defaultOnError(zPlanCapabilities.nullish(), () => void 0),
+  auth: defaultOnError(zAuthCapabilities.optional().default({ terminal: false }), () => ({ terminal: false })),
+  elicitation: defaultOnError(zElicitationCapabilities.nullish(), () => void 0),
+  nes: defaultOnError(zClientNesCapabilities.nullish(), () => void 0),
+  positionEncodings: defaultOnError(vecSkipError(zPositionEncodingKind).optional(), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAuthenticateRequest = object({
+  methodId: zAuthMethodId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zListProvidersRequest = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSetProviderRequest = object({
+  providerId: zProviderId,
+  apiType: zLlmProtocol,
+  baseUrl: string(),
+  headers: record(string(), string()).optional(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDisableProviderRequest = object({
+  providerId: zProviderId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zLogoutRequest = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zHttpHeader = object({
+  name: string(),
+  value: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpServerHttp = object({
+  name: string(),
+  url: string(),
+  headers: array(zHttpHeader),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpServerSse = object({
+  name: string(),
+  url: string(),
+  headers: array(zHttpHeader),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpServerAcp = object({
+  name: string(),
+  serverId: zMcpServerAcpId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpServerStdio = object({
+  name: string(),
+  command: string(),
+  args: array(string()),
+  env: array(zEnvVariable),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zMcpServer = union([
+  zMcpServerHttp.and(object({
+    type: literal("http")
+  })),
+  zMcpServerSse.and(object({
+    type: literal("sse")
+  })),
+  zMcpServerAcp.and(object({
+    type: literal("acp")
+  })),
+  zMcpServerStdio
+]);
+const zNewSessionRequest = object({
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zLoadSessionRequest = object({
+  mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zListSessionsRequest = object({
+  cwd: string().nullish(),
+  cursor: string().nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDeleteSessionRequest = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zForkSessionRequest = object({
+  sessionId: zSessionId,
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zResumeSessionRequest = object({
+  sessionId: zSessionId,
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCloseSessionRequest = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSetSessionModeRequest = object({
+  sessionId: zSessionId,
+  modeId: zSessionModeId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSetSessionConfigOptionRequest = intersection(union([
+  object({
+    value: boolean(),
+    type: literal("boolean")
+  }),
+  object({
+    value: zSessionConfigValueId
+  })
+]), object({
+  sessionId: zSessionId,
+  configId: zSessionConfigId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+}));
+const zPromptRequest = object({
+  sessionId: zSessionId,
+  prompt: array(zContentBlock),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zWorkspaceFolder = object({
+  uri: string(),
+  name: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRepository = object({
+  name: string(),
+  owner: string(),
+  remoteUrl: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zStartNesRequest = object({
+  workspaceUri: defaultOnError(string().nullish(), () => void 0),
+  workspaceFolders: array(zWorkspaceFolder).nullish(),
+  repository: defaultOnError(zNesRepository.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesTriggerKind = union([
+  literal("automatic"),
+  literal("diagnostic"),
+  literal("manual")
+]);
+const zNesRecentFile = object({
+  uri: string(),
+  languageId: string(),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRelatedSnippet = object({
+  uri: string(),
+  excerpts: array(zNesExcerpt),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesEditHistoryEntry = object({
+  uri: string(),
+  diff: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesUserAction = object({
+  action: string(),
+  uri: string(),
+  position: zPosition,
+  timestampMs: number(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesOpenFile = object({
+  uri: string(),
+  languageId: string(),
+  visibleRange: defaultOnError(zRange.nullish(), () => void 0),
+  lastFocusedMs: defaultOnError(number().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesDiagnosticSeverity = union([
+  literal("error"),
+  literal("warning"),
+  literal("information"),
+  literal("hint")
+]);
+const zNesDiagnostic = object({
+  uri: string(),
+  range: zRange,
+  severity: zNesDiagnosticSeverity,
+  message: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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(string(), unknown()).nullish(), () => void 0)
+});
+const zSuggestNesRequest = object({
+  sessionId: zSessionId,
+  uri: string(),
+  version: number(),
+  position: zPosition,
+  selection: zRange.nullish(),
+  triggerKind: zNesTriggerKind,
+  context: zNesSuggestContext.nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCloseNesRequest = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+object({
+  id: zRequestId,
+  method: string(),
+  params: union([
+    zInitializeRequest,
+    zAuthenticateRequest,
+    zListProvidersRequest,
+    zSetProviderRequest,
+    zDisableProviderRequest,
+    zLogoutRequest,
+    zNewSessionRequest,
+    zLoadSessionRequest,
+    zListSessionsRequest,
+    zDeleteSessionRequest,
+    zForkSessionRequest,
+    zResumeSessionRequest,
+    zCloseSessionRequest,
+    zSetSessionModeRequest,
+    zSetSessionConfigOptionRequest,
+    zPromptRequest,
+    zStartNesRequest,
+    zSuggestNesRequest,
+    zCloseNesRequest,
+    zMessageMcpRequest,
+    zExtRequest
+  ]).nullish()
+});
+const zWriteTextFileResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zReadTextFileResponse = object({
+  content: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zSelectedPermissionOutcome = object({
+  optionId: zPermissionOptionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zRequestPermissionOutcome = union([
+  object({
+    outcome: literal("cancelled")
+  }),
+  zSelectedPermissionOutcome.and(object({
+    outcome: literal("selected")
+  }))
+]);
+const zRequestPermissionResponse = object({
+  outcome: zRequestPermissionOutcome,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zCreateTerminalResponse = object({
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTerminalExitStatus = object({
+  exitCode: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  signal: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTerminalOutputResponse = object({
+  output: string(),
+  truncated: boolean(),
+  exitStatus: defaultOnError(zTerminalExitStatus.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zReleaseTerminalResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zWaitForTerminalExitResponse = object({
+  exitCode: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => void 0),
+  signal: defaultOnError(string().nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zKillTerminalResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zElicitationContentValue = union([
+  string(),
+  number(),
+  number(),
+  boolean(),
+  array(string())
+]);
+const zElicitationAcceptAction = object({
+  content: record(string(), zElicitationContentValue).nullish()
+});
+const zCreateElicitationResponse = preserveCustomPayload(intersection(union([
+  zElicitationAcceptAction.and(object({
+    action: literal("accept")
+  })),
+  object({
+    action: literal("decline")
+  }),
+  object({
+    action: literal("cancel")
+  }),
+  excludeKnownTags(object({
+    action: string()
+  }), "action", ["accept", "cancel", "decline"])
+]), object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+})), "action", ["accept", "cancel", "decline"]);
+const zConnectMcpResponse = object({
+  connectionId: zMcpConnectionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDisconnectMcpResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+union([
+  object({
+    id: zRequestId,
+    result: union([
+      zWriteTextFileResponse,
+      zReadTextFileResponse,
+      zRequestPermissionResponse,
+      zCreateTerminalResponse,
+      zTerminalOutputResponse,
+      zReleaseTerminalResponse,
+      zWaitForTerminalExitResponse,
+      zKillTerminalResponse,
+      zCreateElicitationResponse,
+      zConnectMcpResponse,
+      zDisconnectMcpResponse,
+      zMessageMcpResponse,
+      zExtResponse
+    ])
+  }),
+  object({
+    id: zRequestId,
+    error: zError
+  })
+]);
+const zCancelNotification = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDidOpenDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  languageId: string(),
+  version: number(),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zTextDocumentContentChangeEvent = object({
+  range: zRange.nullish(),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDidChangeDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  version: number(),
+  contentChanges: requiredDefaultOnError(vecSkipError(zTextDocumentContentChangeEvent), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDidCloseDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDidSaveDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zDidFocusDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  version: number(),
+  position: zPosition,
+  visibleRange: zRange,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zAcceptNesNotification = object({
+  sessionId: zSessionId,
+  id: zNesSuggestionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const zNesRejectReason = union([
+  literal("rejected"),
+  literal("ignored"),
+  literal("replaced"),
+  literal("cancelled")
+]);
+const zRejectNesNotification = object({
+  sessionId: zSessionId,
+  id: zNesSuggestionId,
+  reason: defaultOnError(zNesRejectReason.nullish(), () => void 0),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+object({
+  method: string(),
+  params: union([
+    zCancelNotification,
+    zDidOpenDocumentNotification,
+    zDidChangeDocumentNotification,
+    zDidCloseDocumentNotification,
+    zDidSaveDocumentNotification,
+    zDidFocusDocumentNotification,
+    zAcceptNesNotification,
+    zRejectNesNotification,
+    zMessageMcpNotification,
+    zExtNotification
+  ]).nullish()
+});
+object({
+  requestId: zRequestId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
+});
+const 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 void 0;
+  }
+  return params["requestId"];
+}
+function isErrorResponse(value) {
+  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+}
+const Handled = {
+  /**
+   * Marks a message as handled.
+   */
+  yes() {
+    return { handled: true };
+  },
+  /**
+   * Leaves a message unhandled so later handlers can process it.
+   */
+  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 void 0;
+}
+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 void 0;
+  }
+  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;
+  }
+  /**
+   * Whether this request has already received a response.
+   */
+  get responded() {
+    return this.didRespond;
+  }
+  /**
+   * Sends a successful JSON-RPC response.
+   */
+  respond(response) {
+    return this.respondWithResult({ result: response ?? null });
+  }
+  /**
+   * Sends an error JSON-RPC response.
+   */
+  respondWithError(error) {
+    const errorResponse = error instanceof RequestError ? error.toErrorResponse() : error;
+    return this.respondWithResult({ error: errorResponse });
+  }
+  /**
+   * Sends a complete JSON-RPC result payload.
+   */
+  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;
+  }
+  /**
+   * Unregisters the associated handler.
+   */
+  dispose() {
+    if (!this.active) {
+      return;
+    }
+    this.active = false;
+    this.disposeHandler();
+  }
+  /**
+   * Supports explicit resource management with `using`.
+   */
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  /**
+   * Returns this registration for call sites that intentionally keep it active.
+   */
+  runIndefinitely() {
+    return this;
+  }
+}
+class ConnectionContext {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  /**
+   * Sends a request over the connection.
+   */
+  sendRequest(method, params, mapResponse, options) {
+    return this.connection.sendRequest(method, params, mapResponse, options);
+  }
+  /**
+   * Sends a notification over the connection.
+   */
+  sendNotification(method, params) {
+    return this.connection.sendNotification(method, params);
+  }
+  /**
+   * Sends a non-empty JSON-RPC batch in one transport message.
+   */
+  sendBatch(entries) {
+    return this.connection.sendBatch(entries);
+  }
+  /**
+   * Sends a protocol-level request cancellation notification.
+   */
+  sendCancelRequest(requestId) {
+    return this.connection.sendCancelRequest(requestId);
+  }
+  /**
+   * Registers a handler that can be disposed independently.
+   */
+  addDynamicHandler(handler) {
+    return this.connection.addDynamicHandler(handler);
+  }
+  /**
+   * AbortSignal that aborts when the connection closes.
+   */
+  get signal() {
+    return this.connection.signal;
+  }
+  /**
+   * Promise that resolves when the connection closes.
+   */
+  get closed() {
+    return this.connection.closed;
+  }
+}
+class Connection {
+  pendingResponses = /* @__PURE__ */ new Map();
+  incomingRequests = /* @__PURE__ */ new Map();
+  nextRequestId = 0;
+  staticHandlers = [];
+  dynamicHandlers = /* @__PURE__ */ 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 stream2 = streamOrOptions;
+      this.initialize(stream2, [
+        ...options?.handlers ?? [],
+        this.legacyHandler(requestHandler, notificationHandler)
+      ], options);
+      return;
+    }
+    const stream = requestHandlerOrStream;
+    const handlers = notificationHandlerOrHandlers;
+    const connectionOptions = streamOrOptions;
+    this.initialize(stream, [...connectionOptions?.handlers ?? [], ...handlers], connectionOptions);
+  }
+  /**
+   * Creates a builder for configuring a handler-based connection.
+   */
+  static builder() {
+    return new ConnectionBuilder();
+  }
+  /**
+   * Runs an operation while the connection is open, then closes the connection.
+   *
+   * If the stream closes before `op` settles, the returned promise rejects with
+   * the connection close reason.
+   */
+  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();
+    });
+  }
+  /**
+   * Adds a handler after the connection has started.
+   *
+   * Any messages queued with `Handled.no(message, true)` are retried after the
+   * handler is added.
+   */
+  addDynamicHandler(handler) {
+    this.dynamicHandlers.add(handler);
+    if (this.retryQueue.length > 0) {
+      for (const message of this.retryQueue.splice(0)) {
+        void this.processIncomingMessage(message).catch((error) => this.close(error));
+      }
+    }
+    return new HandlerRegistration(() => {
+      this.dynamicHandlers.delete(handler);
+    });
+  }
+  /**
+   * AbortSignal that aborts when the connection closes.
+   */
+  get signal() {
+    return this.abortController.signal;
+  }
+  /**
+   * Promise that resolves when the connection closes.
+   */
+  get closed() {
+    return this.closedPromise;
+  }
+  /** @internal */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Sends a JSON-RPC request.
+   *
+   * `mapResponse` can convert the raw result before the returned promise
+   * resolves.
+   */
+  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);
+    void requestSent.catch(() => {
+    });
+    if (options.cancellationSignal?.aborted) {
+      request.cancel();
+    }
+    return request.response;
+  }
+  /**
+   * Sends a non-empty JSON-RPC batch in one transport message.
+   *
+   * Requests and notifications are processed independently by the peer. The
+   * returned tuple preserves the input order: request entries resolve to their
+   * mapped response, while notification entries resolve to `undefined`.
+   */
+  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(void 0));
+        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;
+  }
+  /**
+   * Sends a protocol-level request cancellation notification.
+   */
+  sendCancelRequest(requestId) {
+    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
+  }
+  /**
+   * Sends a JSON-RPC notification.
+   */
+  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?.();
+        void 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()
+    };
+  }
+  /**
+   * Closes the connection and rejects pending requests.
+   */
+  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();
+    void 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());
+    });
+    void 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 = void 0;
+    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 = void 0;
+        }
+        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) {
+      void 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)) {
+        void collectResponse({
+          jsonrpc: "2.0",
+          id: null,
+          error: RequestError.invalidRequest(message).toErrorResponse()
+        }).catch(() => {
+        });
+        continue;
+      }
+      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : void 0);
+      if (isNotificationMessage(message)) {
+        void processing.finally(() => {
+          remainingNotifications -= 1;
+          void 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 === void 0) {
+      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;
+  /**
+   * Sets a diagnostic name used by handlers created from this builder.
+   */
+  name(name2) {
+    this.connectionName = name2;
+    return this;
+  }
+  /**
+   * Adds a raw JSON-RPC handler to the handler chain.
+   */
+  withHandler(handler) {
+    this.handlers.push(handler);
+    return this;
+  }
+  /**
+   * Adds a handler that can inspect every incoming request or notification.
+   *
+   * Observer callbacks that return void pass the message through to later
+   * handlers. Return `Handled.yes()` to stop dispatch explicitly.
+   */
+  onReceiveMessage(handler) {
+    return this.withHandler({
+      handleMessage: async (message, cx) => await handler(message, cx) ?? Handled.no(message),
+      describe: () => this.connectionName ?? "onReceiveMessage"
+    });
+  }
+  /**
+   * Adds a typed request handler for one method.
+   */
+  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}`
+    });
+  }
+  /**
+   * Adds a typed notification handler for one 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}`
+    });
+  }
+  /**
+   * Connects the configured handlers to a stream.
+   */
+  connect(stream, options) {
+    return new Connection(stream, this.handlers, options);
+  }
+  /**
+   * Connects to a stream for the lifetime of `op`, then closes the connection.
+   */
+  connectWith(stream, op, options) {
+    return this.connect(stream, options).runUntil(op);
+  }
+}
+class RequestError extends Error {
+  code;
+  /**
+   * Additional JSON-RPC error data.
+   */
+  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);
+  }
+  /**
+   * Execution of the request was aborted.
+   */
+  static requestCancelled(data, additionalMessage) {
+    return new RequestError(-32800, `Request cancelled${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 });
+  }
+  /**
+   * Converts this error to a JSON-RPC result object.
+   */
+  toResult() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        data: this.data
+      }
+    };
+  }
+  /**
+   * Converts this error to a JSON-RPC error response payload.
+   */
+  toErrorResponse() {
+    return {
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+}
+const newline = 10;
+class LineBuffer {
+  /** Bytes of the current (incomplete) line, carried across chunks. */
+  #pending = [];
+  /**
+   * Consumes a chunk, returning each complete line without its trailing
+   * newline.
+   */
+  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;
+  }
+  /**
+   * Returns the trailing unterminated line and resets the buffer, or
+   * undefined if no bytes are buffered.
+   */
+  flush() {
+    if (this.#pending.length === 0) {
+      return void 0;
+    }
+    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;
+  }
+}
+function ndJsonStream$1(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 = void 0;
+        }
+        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) + "\n";
+      const writer = output.getWriter();
+      try {
+        await writer.write(textEncoder.encode(content));
+      } finally {
+        writer.releaseLock();
+      }
+    }
+  });
+  return { readable, writable };
+}
+function tagOf(value, key) {
+  return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string() }));
+zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string() }));
+union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string() }));
+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") }));
+zStringMultiSelectItems.and(object({ type: literal("string") }));
+const zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
+const zGuardCreateElicitationResponseDecline = object({
+  action: literal("decline")
+});
+const zGuardCreateElicitationResponseCancel = object({
+  action: literal("cancel")
+});
+const CreateElicitationResponse = {
+  /** Narrow to the `accept` variant, validating its payload. */
+  isAccept(value) {
+    return tagOf(value, "action") === "accept" && zGuardCreateElicitationResponseAccept.safeParse(value).success;
+  },
+  /** Narrow to the `decline` variant, validating its payload. */
+  isDecline(value) {
+    return tagOf(value, "action") === "decline" && zGuardCreateElicitationResponseDecline.safeParse(value).success;
+  },
+  /** Narrow to the `cancel` variant, validating its payload. */
+  isCancel(value) {
+    return tagOf(value, "action") === "cancel" && zGuardCreateElicitationResponseCancel.safeParse(value).success;
+  },
+  /**
+   * Narrow to a custom or future variant: the `action` tag matches no known variant.
+   *
+   * TypeScript keeps the known variants in the narrowed union (they are
+   * structural subtypes of the catch-all), so read vendor payload keys
+   * via a widening cast: `(value as Record<string, unknown>).someKey`.
+   */
+  isCustom(value) {
+    const tag = tagOf(value, "action");
+    return typeof tag === "string" && !["accept", "cancel", "decline"].includes(tag);
+  }
+};
+function ndJsonStream(output, input) {
+  return ndJsonStream$1(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
+    }
+  ];
+}
+const 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
+    }
+  },
+  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
+    },
+    elicitation: {
+      create: CLIENT_METHODS.elicitation_create,
+      complete: CLIENT_METHODS.elicitation_complete
+    }
+  }
+};
+const startActiveSession = Symbol("startActiveSession");
+class AcpContext {
+  cx;
+  currentRequestId;
+  /** @internal */
+  constructor(cx, currentRequestId) {
+    this.cx = cx;
+    this.currentRequestId = currentRequestId;
+  }
+  /**
+   * JSON-RPC id of the request currently being handled.
+   *
+   * This is `undefined` for notification handlers and for contexts created
+   * outside an inbound request, such as `connect(...)` and `connectWith(...)`.
+   */
+  get requestId() {
+    return this.currentRequestId;
+  }
+  /** @internal */
+  get connectionContext() {
+    return this.cx;
+  }
+  /** @internal */
+  sendRequest(method, params, mapResponse, options) {
+    return this.cx.sendRequest(method, params, mapResponse, options);
+  }
+  /** @internal */
+  sendNotification(method, params) {
+    return this.cx.sendNotification(method, params);
+  }
+  /** @internal */
+  addDynamicHandler(handler) {
+    return this.cx.addDynamicHandler(handler);
+  }
+}
+class AgentContext extends AcpContext {
+  constructor(cx, requestId) {
+    super(cx, requestId);
+  }
+  /** @internal */
+  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);
+  }
+  /** @internal */
+  static create(cx, requestId) {
+    return new ClientContext(cx, requestId);
+  }
+  /** @internal */
+  [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);
+  }
+  /**
+   * Builds active-session helpers around a `session/new` response.
+   */
+  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());
+  }
+  /** @internal */
+  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());
+  }
+  /** @internal */
+  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] : void 0,
+    mcpServers: [...request.mcpServers]
+  };
+}
+class SessionBuilder {
+  cx;
+  request;
+  constructor(cx, request) {
+    this.cx = cx;
+    this.request = cloneNewSessionRequest(request);
+  }
+  /** @internal */
+  static create(cx, request) {
+    return new SessionBuilder(cx, request);
+  }
+  /**
+   * Returns the `session/new` request that will be sent.
+   *
+   * The returned object is a defensive copy, so mutating it does not change the
+   * builder.
+   */
+  toRequest() {
+    return cloneNewSessionRequest(this.request);
+  }
+  /**
+   * Replaces the additional workspace roots for this session.
+   *
+   * `additionalDirectories` expand the session's file-system scope without
+   * changing `cwd`. Each path should be absolute.
+   */
+  withAdditionalDirectories(additionalDirectories) {
+    this.request = {
+      ...this.request,
+      additionalDirectories: [...additionalDirectories]
+    };
+    return this;
+  }
+  /**
+   * Adds one MCP server to the `session/new` request.
+   */
+  withMcpServer(mcpServer) {
+    this.request = {
+      ...this.request,
+      mcpServers: [...this.request.mcpServers, mcpServer]
+    };
+    return this;
+  }
+  /**
+   * Starts the session and returns an `ActiveSession` for prompting and reading
+   * updates.
+   *
+   * Call `dispose()` on the returned session when you no longer need update
+   * routing, or use `withSession(...)` to scope disposal automatically.
+   */
+  async start(options) {
+    return this.cx[startActiveSession](this.toRequest(), options);
+  }
+  /**
+   * Starts the session, runs `op`, and disposes the active-session update
+   * routing when `op` finishes or throws.
+   */
+  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;
+  }
+  /** @internal */
+  static create(cx, sessionResponse, updates, registrations) {
+    return new ActiveSession(cx, sessionResponse, updates, registrations);
+  }
+  /**
+   * Session ID returned by `session/new`.
+   */
+  get sessionId() {
+    return this.sessionResponse.sessionId;
+  }
+  /**
+   * Mode state returned when the session was created, if the agent provided it.
+   */
+  get modes() {
+    return this.sessionResponse.modes;
+  }
+  /**
+   * Metadata returned when the session was created.
+   */
+  get meta() {
+    return this.sessionResponse._meta;
+  }
+  /**
+   * Full response returned by `session/new`.
+   */
+  get newSessionResponse() {
+    return this.sessionResponse;
+  }
+  /**
+   * Sends a prompt to this session.
+   *
+   * Strings are converted to one text content block. A single content block is
+   * wrapped in an array. The returned promise resolves with the final
+   * `PromptResponse`, and the same completion is also queued as a `stop`
+   * message for `nextUpdate()`.
+   */
+  prompt(prompt, options) {
+    this.updates.clearErrors();
+    const response = this.cx.request(AGENT_METHODS.session_prompt, {
+      sessionId: this.sessionId,
+      prompt: this.promptBlocks(prompt)
+    }, options);
+    void response.then((value) => {
+      this.updates.enqueue({
+        kind: "stop",
+        response: value,
+        stopReason: value.stopReason
+      });
+    }, (error) => {
+      this.updates.reject(error);
+    });
+    return response;
+  }
+  /**
+   * Reads the next update or stop message for this session.
+   */
+  nextUpdate() {
+    return this.updates.next();
+  }
+  /**
+   * Reads text chunks until the current prompt turn stops.
+   *
+   * Only `agent_message_chunk` updates with text content are appended. Other
+   * update types are ignored by this helper; use `nextUpdate()` when you need
+   * tool calls, plans, or the final `PromptResponse`.
+   */
+  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;
+      }
+    }
+  }
+  /**
+   * Stops routing updates to this active-session helper.
+   *
+   * This does not close the ACP session on the agent. Use `ClientContext`
+   * session lifecycle methods when the protocol session itself should be closed
+   * or deleted.
+   */
+  dispose() {
+    for (const registration of this.registrations.splice(0)) {
+      registration.dispose();
+    }
+    this.updates.fail(new Error("Active session disposed"));
+  }
+  /**
+   * Supports explicit resource management with `using`.
+   */
+  [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;
+}
+const 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)
+};
+const 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)
+};
+const 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)
+};
+const clientNotificationSpecs = {
+  sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, zSessionNotification),
+  unstable_completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
+};
+const agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
+const agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
+const clientRequestSpecsByMethod = specsByMethod(clientRequestSpecs);
+const clientNotificationSpecsByMethod = specsByMethod(clientNotificationSpecs);
+function agentRequestContext(params, client2, signal, requestId) {
+  return {
+    params,
+    requestId,
+    signal,
+    client: client2
+  };
+}
+function agentNotificationContext(params, client2, signal) {
+  return {
+    params,
+    signal,
+    client: client2
+  };
+}
+function clientRequestContext(params, agent2, signal, requestId) {
+  return {
+    params,
+    requestId,
+    signal,
+    agent: agent2
+  };
+}
+function clientNotificationContext(params, agent2, signal) {
+  return {
+    params,
+    signal,
+    agent: agent2
+  };
+}
+class SessionUpdateRouter {
+  activeSessions = /* @__PURE__ */ 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) ?? /* @__PURE__ */ 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);
+      }
+    });
+  }
+}
+const sessionUpdateRouters = /* @__PURE__ */ 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;
+    }
+    void Promise.resolve(result).catch((error) => {
+      connection.close(error);
+    });
+  }
+}
+const appBuilder = Symbol("appBuilder");
+const runAgentConnectHandlers = Symbol("runAgentConnectHandlers");
+const runClientConnectHandlers = Symbol("runClientConnectHandlers");
+const stableConnectionOptions = { allowBatches: false };
+function agent(options) {
+  return new AgentApp(options);
+}
+class AgentApp {
+  builder = Connection.builder();
+  connectHandlers = [];
+  constructor(options = {}) {
+    if (options.name) {
+      this.builder.name(options.name);
+    }
+  }
+  /** @internal */
+  [appBuilder]() {
+    return this.builder;
+  }
+  /** @internal */
+  [runAgentConnectHandlers](connection) {
+    runConnectHandlers(connection, this.connectHandlers);
+  }
+  connect(target, options = {}) {
+    return this.connectConnection(target, options).connection;
+  }
+  connectWith(target, op) {
+    const { rawConnection, connection } = this.connectConnection(target);
+    return rawConnection.runUntil(() => op(connection.client));
+  }
+  /**
+   * Registers a handler that runs when this agent app opens a connection.
+   *
+   * Use this for connection-scoped work that needs to call client-side ACP
+   * methods outside an inbound request handler.
+   */
+  onConnect(handler) {
+    this.connectHandlers.push(handler);
+    return this;
+  }
+  onRequest(method, handlerOrParams, handler) {
+    if (handler) {
+      return this.request({ method, params: handlerOrParams }, handler);
+    }
+    const spec = agentRequestSpecsByMethod[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 = agentNotificationSpecsByMethod[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) => agentRequestContext(params, AgentContext.create(cx, requestId), signal, requestId), handler);
+    return this;
+  }
+  notification(spec, handler) {
+    registerAppNotification(this.builder, spec, (params, cx, signal) => agentNotificationContext(params, AgentContext.create(cx), signal), handler);
+    return this;
+  }
+  connectConnection(target, options = {}) {
+    if (isStream(target)) {
+      const state2 = this.openStreamConnection(target);
+      if (!options.deferConnectHandlers) {
+        this[runAgentConnectHandlers](state2.connection);
+      }
+      return state2;
+    }
+    const [thisStream, peerStream] = memoryStreamPair();
+    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
+    const peerConnection = clientConnection(peerRawConnection);
+    const state = this.openStreamConnection(thisStream);
+    void state.rawConnection.closed.then(() => peerConnection.close());
+    void peerRawConnection.closed.then(() => state.connection.close());
+    try {
+      target[runClientConnectHandlers](peerConnection);
+      this[runAgentConnectHandlers](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: agentConnection(rawConnection, this.connectHandlers)
+    };
+  }
+}
+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"
+    });
+  }
+  /** @internal */
+  [appBuilder]() {
+    return this.builder;
+  }
+  /** @internal */
+  [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));
+  }
+  /**
+   * Registers a handler that runs when this client app opens a connection.
+   *
+   * Use this for connection-scoped work that needs to call agent-side ACP
+   * methods outside an inbound request handler.
+   */
+  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 state2 = this.openStreamConnection(target);
+      this[runClientConnectHandlers](state2.connection);
+      return state2;
+    }
+    const [thisStream, peerStream] = memoryStreamPair();
+    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
+    const peerConnection = agentConnection(peerRawConnection);
+    const state = this.openStreamConnection(thisStream);
+    void state.rawConnection.closed.then(() => peerConnection.close());
+    void 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)
+    };
+  }
+}
+const legacyClientRequestMethods = /* @__PURE__ */ 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
+]);
+const legacyClientNotificationMethods = /* @__PURE__ */ new Set([
+  CLIENT_METHODS.session_update,
+  CLIENT_METHODS.elicitation_complete
+]);
+function legacyClientApp(implementation) {
+  const app = client().onRequest(CLIENT_METHODS.session_request_permission, (ctx) => implementation.requestPermission(ctx.params)).onNotification(CLIENT_METHODS.session_update, (ctx) => implementation.sessionUpdate(ctx.params)).onRequest(CLIENT_METHODS.fs_write_text_file, async (ctx) => await implementation.writeTextFile?.(ctx.params) ?? {}).onRequest(CLIENT_METHODS.fs_read_text_file, async (ctx) => await implementation.readTextFile?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_create, async (ctx) => await implementation.createTerminal?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_output, async (ctx) => await implementation.terminalOutput?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_release, async (ctx) => await implementation.releaseTerminal?.(ctx.params) ?? {}).onRequest(CLIENT_METHODS.terminal_wait_for_exit, async (ctx) => await implementation.waitForTerminalExit?.(ctx.params)).onRequest(CLIENT_METHODS.terminal_kill, async (ctx) => await implementation.killTerminal?.(ctx.params) ?? {});
+  if (implementation.unstable_createElicitation) {
+    app.onRequest(CLIENT_METHODS.elicitation_create, (ctx) => implementation.unstable_createElicitation(ctx.params));
+  }
+  if (implementation.unstable_completeElicitation) {
+    app.onNotification(CLIENT_METHODS.elicitation_complete, (ctx) => implementation.unstable_completeElicitation(ctx.params));
+  }
+  if (implementation.extMethod) {
+    app[appBuilder]().withHandler({
+      handleMessage: async (message) => {
+        if (message.kind !== "request" || legacyClientRequestMethods.has(message.method)) {
+          return Handled.no(message);
+        }
+        await message.responder.respond(await implementation.extMethod(message.method, message.params));
+        return Handled.yes();
+      },
+      describe: () => "legacy-client-extension-request"
+    });
+  }
+  if (implementation.extNotification) {
+    app[appBuilder]().withHandler({
+      handleMessage: async (message) => {
+        if (message.kind !== "notification" || legacyClientNotificationMethods.has(message.method)) {
+          return Handled.no(message);
+        }
+        await implementation.extNotification(message.method, message.params);
+        return Handled.yes();
+      },
+      describe: () => "legacy-client-extension-notification"
+    });
+  }
+  return app;
+}
+class 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)
+   *
+   * @deprecated Prefer `client({ name }).connectWith(stream, async (ctx) => ...)`.
+   */
+  constructor(toClient, stream) {
+    this.connection = legacyClientApp(toClient(this))[appBuilder]().connect(stream, stableConnectionOptions);
+  }
+  /**
+   * 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)
+   */
+  initialize(params) {
+    return 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
+   *
+   * The request may include `additionalDirectories` to expand the session's filesystem
+   * scope beyond `cwd` without changing the base for relative paths.
+   *
+   * May return an `auth_required` error if the agent requires authentication.
+   *
+   * See protocol docs: [Session Setup](https://agentclientprotocol.com/protocol/session-setup)
+   */
+  newSession(params) {
+    return 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
+   *
+   * The request may include `additionalDirectories` to set the complete list of
+   * additional workspace roots for the loaded session.
+   *
+   * See protocol docs: [Loading Sessions](https://agentclientprotocol.com/protocol/session-setup#loading-sessions)
+   */
+  loadSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_load, params, emptyObjectResponse);
+  }
+  /**
+   * **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.
+   *
+   * The request may include `additionalDirectories` to set the complete list of
+   * additional workspace roots for the forked session.
+   *
+   * This method is only available if the agent advertises the `session.fork` capability.
+   *
+   * @experimental
+   */
+  unstable_forkSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_fork, params);
+  }
+  /**
+   * 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,
+   * `additionalDirectories`, and cursor-based pagination.
+   */
+  listSessions(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_list, params);
+  }
+  /**
+   * Deletes an existing session returned by `session/list`.
+   *
+   * This method is only available if the agent advertises the `sessionCapabilities.delete` capability.
+   */
+  deleteSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_delete, params, emptyObjectResponse);
+  }
+  /**
+   * 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`).
+   *
+   * The request may include `additionalDirectories` to set the complete list of
+   * additional workspace roots for the resumed session.
+   */
+  resumeSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_resume, params);
+  }
+  /**
+   * Closes an active session and frees up any resources associated with it.
+   *
+   * This method is only available if the agent advertises the `session.close` capability.
+   *
+   * The agent must cancel any ongoing work (as if `session/cancel` was called)
+   * and then free up any resources associated with the session.
+   */
+  closeSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_close, params, emptyObjectResponse);
+  }
+  /**
+   * 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)
+   */
+  setSessionMode(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_set_mode, params, emptyObjectResponse);
+  }
+  /**
+   * 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.
+   */
+  setSessionConfigOption(params) {
+    return 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)
+   */
+  authenticate(params) {
+    return this.connection.sendRequest(AGENT_METHODS.authenticate, params, emptyObjectResponse);
+  }
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Lists providers that can be configured by the client.
+   *
+   * This method is only available if the agent advertises the `providers` capability.
+   *
+   * @experimental
+   */
+  unstable_listProviders(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_list, params);
+  }
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Replaces the configuration for a provider.
+   *
+   * This method is only available if the agent advertises the `providers` capability.
+   *
+   * @experimental
+   */
+  unstable_setProvider(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_set, params, emptyObjectResponse);
+  }
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Disables a provider.
+   *
+   * This method is only available if the agent advertises the `providers` capability.
+   *
+   * @experimental
+   */
+  unstable_disableProvider(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_disable, params, emptyObjectResponse);
+  }
+  /**
+   * Logout of the current authentication method.
+   */
+  logout(params) {
+    return this.connection.sendRequest(AGENT_METHODS.logout, params, emptyObjectResponse);
+  }
+  /**
+   * 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)
+   */
+  prompt(params) {
+    return 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)
+   */
+  cancel(params) {
+    return this.connection.sendNotification(AGENT_METHODS.session_cancel, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Starts a NES (Next Edit Suggestions) session.
+   *
+   * @experimental
+   */
+  unstable_startNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_start, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Sends a NES suggestion request.
+   *
+   * @experimental
+   */
+  unstable_suggestNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_suggest, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Closes a NES session.
+   *
+   * @experimental
+   */
+  unstable_closeNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_close, params, emptyObjectResponse);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was opened.
+   *
+   * @experimental
+   */
+  unstable_didOpenDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_open, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was changed.
+   *
+   * @experimental
+   */
+  unstable_didChangeDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_change, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was closed.
+   *
+   * @experimental
+   */
+  unstable_didCloseDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_close, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was saved.
+   *
+   * @experimental
+   */
+  unstable_didSaveDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_save, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document received focus.
+   *
+   * @experimental
+   */
+  unstable_didFocusDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_focus, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a NES suggestion was accepted.
+   *
+   * @experimental
+   */
+  unstable_acceptNes(params) {
+    return this.connection.sendNotification(AGENT_METHODS.nes_accept, params);
+  }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a NES suggestion was rejected.
+   *
+   * @experimental
+   */
+  unstable_rejectNes(params) {
+    return this.connection.sendNotification(AGENT_METHODS.nes_reject, params);
+  }
+  request(method, params, options) {
+    const spec = agentRequestSpecsByMethod[method];
+    return this.connection.sendRequest(method, params, spec?.mapResponse, options);
+  }
+  notify(method, params) {
+    return this.connection.sendNotification(method, params);
+  }
+  /**
+   * Extension method.
+   *
+   * @deprecated Use {@link request}.
+   */
+  extMethod(method, params) {
+    return this.request(method, params);
+  }
+  /**
+   * Extension notification.
+   *
+   * @deprecated Use {@link notify}.
+   */
+  extNotification(method, params) {
+    return this.notify(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;
+  }
+}
+const name = "acp-extension-claude";
+const version = "0.62.0";
+const dependencies = { "@anthropic-ai/claude-agent-sdk": "0.3.220" };
+const packageJson = {
+  name,
+  version,
+  dependencies
+};
+export {
+  ClientSideConnection as C,
+  PROTOCOL_VERSION as P,
+  RequestError as R,
+  CreateElicitationResponse as a,
+  agent as b,
+  methods as m,
+  ndJsonStream as n,
+  packageJson as p
+};