@desplega.ai/agent-swarm 1.136.0 → 1.138.0

package/dist/acp-adapter-6nttxe2q.js

@@ -0,0 +1,4787 @@
+import {
+  fetchInstalledMcpServers
+} from "./cli-tng3131n.js";
+import"./cli-rx5cxzn2.js";
+import {
+  array,
+  boolean,
+  exports_external,
+  int,
+  intersection,
+  literal,
+  number,
+  object,
+  record,
+  string,
+  union,
+  unknown,
+  url
+} from "./cli-pqv5gvyf.js";
+import {
+  init_package,
+  package_default
+} from "./cli-kkn46gfr.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-mkq1rk7b.js";
+import"./cli-pq2ee5ja.js";
+
+// node_modules/@agentclientprotocol/sdk/dist/schema/index.js
+var AGENT_METHODS = {
+  initialize: "initialize",
+  authenticate: "authenticate",
+  providers_list: "providers/list",
+  providers_set: "providers/set",
+  providers_disable: "providers/disable",
+  session_new: "session/new",
+  session_load: "session/load",
+  session_set_mode: "session/set_mode",
+  session_set_config_option: "session/set_config_option",
+  session_prompt: "session/prompt",
+  session_cancel: "session/cancel",
+  mcp_message: "mcp/message",
+  session_list: "session/list",
+  session_delete: "session/delete",
+  session_fork: "session/fork",
+  session_resume: "session/resume",
+  session_close: "session/close",
+  logout: "logout",
+  nes_start: "nes/start",
+  nes_suggest: "nes/suggest",
+  nes_accept: "nes/accept",
+  nes_reject: "nes/reject",
+  nes_close: "nes/close",
+  document_did_open: "document/didOpen",
+  document_did_change: "document/didChange",
+  document_did_close: "document/didClose",
+  document_did_save: "document/didSave",
+  document_did_focus: "document/didFocus"
+};
+var CLIENT_METHODS = {
+  session_request_permission: "session/request_permission",
+  session_update: "session/update",
+  fs_write_text_file: "fs/write_text_file",
+  fs_read_text_file: "fs/read_text_file",
+  terminal_create: "terminal/create",
+  terminal_output: "terminal/output",
+  terminal_release: "terminal/release",
+  terminal_wait_for_exit: "terminal/wait_for_exit",
+  terminal_kill: "terminal/kill",
+  mcp_connect: "mcp/connect",
+  mcp_message: "mcp/message",
+  mcp_disconnect: "mcp/disconnect",
+  elicitation_create: "elicitation/create",
+  elicitation_complete: "elicitation/complete"
+};
+var PROTOCOL_METHODS = {
+  cancel_request: "$/cancel_request"
+};
+var PROTOCOL_VERSION = 1;
+
+// node_modules/@agentclientprotocol/sdk/dist/schema-deserialize.js
+var skippedItem = Symbol("skippedItem");
+function defaultOnError(schema, fallback) {
+  return schema.catch(fallback);
+}
+function requiredDefaultOnError(schema, fallback) {
+  const schemaWithCatch = schema.catch(fallback);
+  return exports_external.unknown().transform((value, context) => {
+    if (value !== undefined)
+      return schemaWithCatch.parse(value);
+    context.addIssue({
+      code: "custom",
+      message: "Required value is missing"
+    });
+    return exports_external.NEVER;
+  });
+}
+function stringTag(value, key) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const tag = value[key];
+  return typeof tag === "string" ? tag : undefined;
+}
+function excludeKnownTags(schema, key, knownTags) {
+  return schema.superRefine((value, context) => {
+    const tag = stringTag(value, key);
+    if (tag !== undefined && knownTags.includes(tag)) {
+      context.addIssue({
+        code: "custom",
+        path: [key],
+        message: `${key} ${JSON.stringify(tag)} is reserved by a known variant, ` + `but the value does not match that variant's schema`
+      });
+    }
+  });
+}
+function preserveCustomPayload(schema, key, knownTags) {
+  return exports_external.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 exports_external.NEVER;
+    }
+    const output = result.data;
+    const tag = stringTag(value, key);
+    if (tag !== undefined && !knownTags.includes(tag)) {
+      const raw = value;
+      for (const [property, rawValue] of Object.entries(raw)) {
+        if (property === "__proto__")
+          continue;
+        if (!Object.hasOwn(output, property))
+          output[property] = rawValue;
+      }
+    }
+    return output;
+  });
+}
+function vecSkipError(itemSchema) {
+  return exports_external.array(itemSchema.catch(skippedItem)).transform((items) => items.filter((item) => item !== skippedItem));
+}
+
+// node_modules/@agentclientprotocol/sdk/dist/schema/zod.gen.js
+var zRequestId = union([number(), string()]).nullable();
+var zSessionId = string();
+var zWriteTextFileRequest = object({
+  sessionId: zSessionId,
+  path: string(),
+  content: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zReadTextFileRequest = object({
+  sessionId: zSessionId,
+  path: string(),
+  line: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  limit: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zToolCallId = string();
+var zToolKind = union([
+  literal("read"),
+  literal("edit"),
+  literal("delete"),
+  literal("move"),
+  literal("search"),
+  literal("execute"),
+  literal("think"),
+  literal("fetch"),
+  literal("switch_mode"),
+  literal("other")
+]);
+var zToolCallStatus = union([
+  literal("pending"),
+  literal("in_progress"),
+  literal("completed"),
+  literal("failed")
+]);
+var zRole = union([literal("assistant"), literal("user")]);
+var zAnnotations = object({
+  audience: defaultOnError(vecSkipError(zRole).nullish(), () => {
+    return;
+  }),
+  lastModified: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  priority: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTextContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => {
+    return;
+  }),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zImageContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => {
+    return;
+  }),
+  data: string(),
+  mimeType: string(),
+  uri: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAudioContent = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => {
+    return;
+  }),
+  data: string(),
+  mimeType: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zResourceLink = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  mimeType: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  name: string(),
+  size: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTextResourceContents = object({
+  mimeType: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  text: string(),
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zBlobResourceContents = object({
+  blob: string(),
+  mimeType: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zEmbeddedResourceResource = union([
+  zTextResourceContents,
+  zBlobResourceContents
+]);
+var zEmbeddedResource = object({
+  annotations: defaultOnError(zAnnotations.nullish(), () => {
+    return;
+  }),
+  resource: zEmbeddedResourceResource,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zContentBlock = union([
+  zTextContent.and(object({
+    type: literal("text")
+  })),
+  zImageContent.and(object({
+    type: literal("image")
+  })),
+  zAudioContent.and(object({
+    type: literal("audio")
+  })),
+  zResourceLink.and(object({
+    type: literal("resource_link")
+  })),
+  zEmbeddedResource.and(object({
+    type: literal("resource")
+  }))
+]);
+var zContent = object({
+  content: zContentBlock,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDiff = object({
+  path: string(),
+  oldText: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  newText: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTerminalId = string();
+var zTerminal = object({
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zToolCallContent = union([
+  zContent.and(object({
+    type: literal("content")
+  })),
+  zDiff.and(object({
+    type: literal("diff")
+  })),
+  zTerminal.and(object({
+    type: literal("terminal")
+  }))
+]);
+var zToolCallLocation = object({
+  path: string(),
+  line: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zToolCallUpdate = object({
+  toolCallId: zToolCallId,
+  kind: defaultOnError(zToolKind.nullish(), () => {
+    return;
+  }),
+  status: defaultOnError(zToolCallStatus.nullish(), () => {
+    return;
+  }),
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  name: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  content: defaultOnError(vecSkipError(zToolCallContent).nullish(), () => {
+    return;
+  }),
+  locations: defaultOnError(vecSkipError(zToolCallLocation).nullish(), () => {
+    return;
+  }),
+  rawInput: defaultOnError(unknown().optional(), () => {
+    return;
+  }),
+  rawOutput: defaultOnError(unknown().optional(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPermissionOptionId = string();
+var zPermissionOptionKind = union([
+  literal("allow_once"),
+  literal("allow_always"),
+  literal("reject_once"),
+  literal("reject_always")
+]);
+var zPermissionOption = object({
+  optionId: zPermissionOptionId,
+  name: string(),
+  kind: zPermissionOptionKind,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zRequestPermissionRequest = object({
+  sessionId: zSessionId,
+  toolCall: zToolCallUpdate,
+  options: array(zPermissionOption),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zEnvVariable = object({
+  name: string(),
+  value: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCreateTerminalRequest = object({
+  sessionId: zSessionId,
+  command: string(),
+  args: defaultOnError(vecSkipError(string()).optional(), () => []),
+  env: defaultOnError(vecSkipError(zEnvVariable).optional(), () => []),
+  cwd: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  outputByteLimit: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTerminalOutputRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zReleaseTerminalRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zWaitForTerminalExitRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zKillTerminalRequest = object({
+  sessionId: zSessionId,
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationSessionScope = object({
+  sessionId: zSessionId,
+  toolCallId: defaultOnError(zToolCallId.nullish(), () => {
+    return;
+  })
+});
+var zElicitationRequestScope = object({
+  requestId: zRequestId
+});
+var zElicitationSchemaType = literal("object");
+var zStringFormat = union([
+  literal("email"),
+  literal("uri"),
+  literal("date"),
+  literal("date-time")
+]);
+var zEnumOption = object({
+  const: string(),
+  title: string(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zStringPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  minLength: int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(),
+  maxLength: int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(),
+  pattern: string().nullish(),
+  format: zStringFormat.nullish(),
+  default: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  enum: array(string()).nullish(),
+  oneOf: array(zEnumOption).nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNumberPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  minimum: number().nullish(),
+  maximum: number().nullish(),
+  default: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zIntegerPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  minimum: number().nullish(),
+  maximum: number().nullish(),
+  default: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zBooleanPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  default: defaultOnError(boolean().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zStringMultiSelectItems = object({
+  enum: array(string()),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTitledMultiSelectItems = object({
+  anyOf: array(zEnumOption),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMultiSelectItems = preserveCustomPayload(union([
+  zStringMultiSelectItems.and(object({
+    type: literal("string")
+  })),
+  excludeKnownTags(object({
+    type: string()
+  }), "type", ["string"]),
+  zTitledMultiSelectItems
+]), "type", ["string"]);
+var zMultiSelectPropertySchema = object({
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  minItems: number().nullish(),
+  maxItems: number().nullish(),
+  items: zMultiSelectItems,
+  default: defaultOnError(vecSkipError(string()).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationPropertySchema = preserveCustomPayload(union([
+  zStringPropertySchema.and(object({
+    type: literal("string")
+  })),
+  zNumberPropertySchema.and(object({
+    type: literal("number")
+  })),
+  zIntegerPropertySchema.and(object({
+    type: literal("integer")
+  })),
+  zBooleanPropertySchema.and(object({
+    type: literal("boolean")
+  })),
+  zMultiSelectPropertySchema.and(object({
+    type: literal("array")
+  })),
+  excludeKnownTags(object({
+    type: string()
+  }), "type", ["array", "boolean", "integer", "number", "string"])
+]), "type", ["array", "boolean", "integer", "number", "string"]);
+var zElicitationSchema = object({
+  type: defaultOnError(zElicitationSchemaType.optional().default("object"), () => "object"),
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  properties: record(string(), zElicitationPropertySchema).optional().default({}),
+  required: array(string()).nullish(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationFormMode = intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
+  requestedSchema: zElicitationSchema
+}));
+var zElicitationId = string();
+var zElicitationUrlMode = intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
+  elicitationId: zElicitationId,
+  url: url()
+}));
+var zCreateElicitationRequest = preserveCustomPayload(intersection(union([
+  zElicitationFormMode.and(object({
+    mode: literal("form")
+  })),
+  zElicitationUrlMode.and(object({
+    mode: literal("url")
+  })),
+  excludeKnownTags(intersection(union([zElicitationSessionScope, zElicitationRequestScope]), object({
+    mode: string()
+  })), "mode", ["form", "url"])
+]), object({
+  message: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+})), "mode", ["form", "url"]);
+var zMcpServerAcpId = string();
+var zConnectMcpRequest = object({
+  serverId: zMcpServerAcpId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMcpConnectionId = string();
+var zMessageMcpRequest = object({
+  connectionId: zMcpConnectionId,
+  method: string(),
+  params: record(string(), unknown()).nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDisconnectMcpRequest = object({
+  connectionId: zMcpConnectionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zExtRequest = unknown();
+var zAgentRequest = object({
+  id: zRequestId,
+  method: string(),
+  params: union([
+    zWriteTextFileRequest,
+    zReadTextFileRequest,
+    zRequestPermissionRequest,
+    zCreateTerminalRequest,
+    zTerminalOutputRequest,
+    zReleaseTerminalRequest,
+    zWaitForTerminalExitRequest,
+    zKillTerminalRequest,
+    zCreateElicitationRequest,
+    zConnectMcpRequest,
+    zMessageMcpRequest,
+    zDisconnectMcpRequest,
+    zExtRequest
+  ]).nullish()
+});
+var zProtocolVersion = int().gte(0).lte(65535);
+var zPromptCapabilities = object({
+  image: defaultOnError(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(), () => {
+    return;
+  })
+});
+var 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(), () => {
+    return;
+  })
+});
+var zSessionListCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionDeleteCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionAdditionalDirectoriesCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionForkCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionResumeCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionCloseCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionCapabilities = object({
+  list: defaultOnError(zSessionListCapabilities.nullish(), () => {
+    return;
+  }),
+  delete: defaultOnError(zSessionDeleteCapabilities.nullish(), () => {
+    return;
+  }),
+  additionalDirectories: defaultOnError(zSessionAdditionalDirectoriesCapabilities.nullish(), () => {
+    return;
+  }),
+  fork: defaultOnError(zSessionForkCapabilities.nullish(), () => {
+    return;
+  }),
+  resume: defaultOnError(zSessionResumeCapabilities.nullish(), () => {
+    return;
+  }),
+  close: defaultOnError(zSessionCloseCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zLogoutCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAgentAuthCapabilities = object({
+  logout: defaultOnError(zLogoutCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zProvidersCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDocumentDidOpenCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTextDocumentSyncKind = union([
+  literal("full"),
+  literal("incremental")
+]);
+var zNesDocumentDidChangeCapabilities = object({
+  syncKind: zTextDocumentSyncKind,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDocumentDidCloseCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDocumentDidSaveCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDocumentDidFocusCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDocumentEventCapabilities = object({
+  didOpen: defaultOnError(zNesDocumentDidOpenCapabilities.nullish(), () => {
+    return;
+  }),
+  didChange: defaultOnError(zNesDocumentDidChangeCapabilities.nullish(), () => {
+    return;
+  }),
+  didClose: defaultOnError(zNesDocumentDidCloseCapabilities.nullish(), () => {
+    return;
+  }),
+  didSave: defaultOnError(zNesDocumentDidSaveCapabilities.nullish(), () => {
+    return;
+  }),
+  didFocus: defaultOnError(zNesDocumentDidFocusCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesEventCapabilities = object({
+  document: defaultOnError(zNesDocumentEventCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRecentFilesCapabilities = object({
+  maxCount: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRelatedSnippetsCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesEditHistoryCapabilities = object({
+  maxCount: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesUserActionsCapabilities = object({
+  maxCount: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesOpenFilesCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDiagnosticsCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesContextCapabilities = object({
+  recentFiles: defaultOnError(zNesRecentFilesCapabilities.nullish(), () => {
+    return;
+  }),
+  relatedSnippets: defaultOnError(zNesRelatedSnippetsCapabilities.nullish(), () => {
+    return;
+  }),
+  editHistory: defaultOnError(zNesEditHistoryCapabilities.nullish(), () => {
+    return;
+  }),
+  userActions: defaultOnError(zNesUserActionsCapabilities.nullish(), () => {
+    return;
+  }),
+  openFiles: defaultOnError(zNesOpenFilesCapabilities.nullish(), () => {
+    return;
+  }),
+  diagnostics: defaultOnError(zNesDiagnosticsCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesCapabilities = object({
+  events: defaultOnError(zNesEventCapabilities.nullish(), () => {
+    return;
+  }),
+  context: defaultOnError(zNesContextCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPositionEncodingKind = union([
+  literal("utf-16"),
+  literal("utf-32"),
+  literal("utf-8")
+]);
+var 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(), () => {
+    return;
+  }),
+  nes: defaultOnError(zNesCapabilities.nullish(), () => {
+    return;
+  }),
+  positionEncoding: defaultOnError(zPositionEncodingKind.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAuthMethodId = string();
+var zAuthMethodTerminal = object({
+  id: zAuthMethodId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  args: defaultOnError(vecSkipError(string()).optional(), () => []),
+  env: defaultOnError(record(string(), string()).optional(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAuthMethodAgent = object({
+  id: zAuthMethodId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAuthMethod = union([
+  zAuthMethodTerminal.and(object({
+    type: literal("terminal")
+  })),
+  zAuthMethodAgent
+]);
+var zImplementation = object({
+  name: string(),
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  version: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zInitializeResponse = object({
+  protocolVersion: zProtocolVersion,
+  agentCapabilities: defaultOnError(zAgentCapabilities.optional().default({
+    loadSession: false,
+    promptCapabilities: {
+      image: false,
+      audio: false,
+      embeddedContext: false
+    },
+    mcpCapabilities: {
+      http: false,
+      sse: false,
+      acp: false
+    },
+    sessionCapabilities: {},
+    auth: {}
+  }), () => ({
+    loadSession: false,
+    promptCapabilities: {
+      image: false,
+      audio: false,
+      embeddedContext: false
+    },
+    mcpCapabilities: {
+      http: false,
+      sse: false,
+      acp: false
+    },
+    sessionCapabilities: {},
+    auth: {}
+  })),
+  authMethods: defaultOnError(vecSkipError(zAuthMethod).optional().default([]), () => []),
+  agentInfo: defaultOnError(zImplementation.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAuthenticateResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zProviderId = string();
+var zLlmProtocol = union([
+  literal("anthropic"),
+  literal("openai"),
+  literal("azure"),
+  literal("vertex"),
+  literal("bedrock"),
+  string()
+]);
+var zProviderCurrentConfig = object({
+  apiType: zLlmProtocol,
+  baseUrl: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zProviderInfo = object({
+  providerId: zProviderId,
+  supported: requiredDefaultOnError(vecSkipError(zLlmProtocol), () => []),
+  required: boolean(),
+  current: zProviderCurrentConfig.nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zListProvidersResponse = object({
+  providers: array(zProviderInfo),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSetProviderResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDisableProviderResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zLogoutResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionModeId = string();
+var zSessionMode = object({
+  id: zSessionModeId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionModeState = object({
+  currentModeId: zSessionModeId,
+  availableModes: requiredDefaultOnError(vecSkipError(zSessionMode), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionConfigId = string();
+var zSessionConfigOptionCategory = union([
+  literal("mode"),
+  literal("model"),
+  literal("model_config"),
+  literal("thought_level"),
+  string()
+]);
+var zSessionConfigValueId = string();
+var zSessionConfigSelectOption = object({
+  value: zSessionConfigValueId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionConfigGroupId = string();
+var zSessionConfigSelectGroup = object({
+  group: zSessionConfigGroupId,
+  name: string(),
+  options: requiredDefaultOnError(vecSkipError(zSessionConfigSelectOption), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionConfigSelectOptions = union([
+  array(zSessionConfigSelectOption),
+  array(zSessionConfigSelectGroup)
+]);
+var zSessionConfigSelect = object({
+  currentValue: zSessionConfigValueId,
+  options: zSessionConfigSelectOptions
+});
+var zSessionConfigBoolean = object({
+  currentValue: boolean()
+});
+var zSessionConfigOption = intersection(union([
+  zSessionConfigSelect.and(object({
+    type: literal("select")
+  })),
+  zSessionConfigBoolean.and(object({
+    type: literal("boolean")
+  }))
+]), object({
+  id: zSessionConfigId,
+  name: string(),
+  description: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  category: defaultOnError(zSessionConfigOptionCategory.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+}));
+var zNewSessionResponse = object({
+  sessionId: zSessionId,
+  modes: defaultOnError(zSessionModeState.nullish(), () => {
+    return;
+  }),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zLoadSessionResponse = object({
+  modes: defaultOnError(zSessionModeState.nullish(), () => {
+    return;
+  }),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionInfo = object({
+  sessionId: zSessionId,
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  updatedAt: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zListSessionsResponse = object({
+  sessions: requiredDefaultOnError(vecSkipError(zSessionInfo), () => []),
+  nextCursor: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDeleteSessionResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zForkSessionResponse = object({
+  sessionId: zSessionId,
+  modes: defaultOnError(zSessionModeState.nullish(), () => {
+    return;
+  }),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zResumeSessionResponse = object({
+  modes: defaultOnError(zSessionModeState.nullish(), () => {
+    return;
+  }),
+  configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCloseSessionResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSetSessionModeResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSetSessionConfigOptionResponse = object({
+  configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zStopReason = union([
+  literal("end_turn"),
+  literal("max_tokens"),
+  literal("max_turn_requests"),
+  literal("refusal"),
+  literal("cancelled")
+]);
+var zUsage = object({
+  totalTokens: number(),
+  inputTokens: number(),
+  outputTokens: number(),
+  thoughtTokens: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  cachedReadTokens: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  cachedWriteTokens: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPromptResponse = object({
+  stopReason: zStopReason,
+  usage: defaultOnError(zUsage.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zStartNesResponse = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesSuggestionId = string();
+var zPosition = object({
+  line: int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }),
+  character: int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zRange = object({
+  start: zPosition,
+  end: zPosition,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesTextEdit = object({
+  range: zRange,
+  newText: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesEditSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  edits: array(zNesTextEdit),
+  cursorPosition: defaultOnError(zPosition.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesJumpSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  position: zPosition,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRenameSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  position: zPosition,
+  newName: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesSearchAndReplaceSuggestion = object({
+  id: zNesSuggestionId,
+  uri: string(),
+  search: string(),
+  replace: string(),
+  isRegex: boolean().nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesSuggestion = union([
+  zNesEditSuggestion.and(object({
+    kind: literal("edit")
+  })),
+  zNesJumpSuggestion.and(object({
+    kind: literal("jump")
+  })),
+  zNesRenameSuggestion.and(object({
+    kind: literal("rename")
+  })),
+  zNesSearchAndReplaceSuggestion.and(object({
+    kind: literal("searchAndReplace")
+  }))
+]);
+var zSuggestNesResponse = object({
+  suggestions: array(zNesSuggestion),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCloseNesResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zExtResponse = unknown();
+var zMessageMcpResponse = unknown();
+var zErrorCode = union([
+  literal(-32700),
+  literal(-32600),
+  literal(-32601),
+  literal(-32602),
+  literal(-32603),
+  literal(-32800),
+  literal(-32000),
+  literal(-32002),
+  int().min(-2147483648, {
+    error: "Invalid value: Expected int32 to be >= -2147483648"
+  }).max(2147483647, {
+    error: "Invalid value: Expected int32 to be <= 2147483647"
+  })
+]);
+var zError = object({
+  code: zErrorCode,
+  message: string(),
+  data: defaultOnError(unknown().optional(), () => {
+    return;
+  })
+});
+var zAgentResponse = union([
+  object({
+    id: zRequestId,
+    result: union([
+      zInitializeResponse,
+      zAuthenticateResponse,
+      zListProvidersResponse,
+      zSetProviderResponse,
+      zDisableProviderResponse,
+      zLogoutResponse,
+      zNewSessionResponse,
+      zLoadSessionResponse,
+      zListSessionsResponse,
+      zDeleteSessionResponse,
+      zForkSessionResponse,
+      zResumeSessionResponse,
+      zCloseSessionResponse,
+      zSetSessionModeResponse,
+      zSetSessionConfigOptionResponse,
+      zPromptResponse,
+      zStartNesResponse,
+      zSuggestNesResponse,
+      zCloseNesResponse,
+      zExtResponse,
+      zMessageMcpResponse
+    ])
+  }),
+  object({
+    id: zRequestId,
+    error: zError
+  })
+]);
+var zMessageId = string();
+var zContentChunk = object({
+  content: zContentBlock,
+  messageId: defaultOnError(zMessageId.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zToolCall = object({
+  toolCallId: zToolCallId,
+  title: string(),
+  name: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  kind: defaultOnError(zToolKind.optional(), () => {
+    return;
+  }),
+  status: defaultOnError(zToolCallStatus.optional(), () => {
+    return;
+  }),
+  content: defaultOnError(vecSkipError(zToolCallContent).optional(), () => []),
+  locations: defaultOnError(vecSkipError(zToolCallLocation).optional(), () => []),
+  rawInput: defaultOnError(unknown().optional(), () => {
+    return;
+  }),
+  rawOutput: defaultOnError(unknown().optional(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanEntryPriority = union([
+  literal("high"),
+  literal("medium"),
+  literal("low")
+]);
+var zPlanEntryStatus = union([
+  literal("pending"),
+  literal("in_progress"),
+  literal("completed")
+]);
+var zPlanEntry = object({
+  content: string(),
+  priority: zPlanEntryPriority,
+  status: zPlanEntryStatus,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlan = object({
+  entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanId = string();
+var zPlanItems = object({
+  planId: zPlanId,
+  entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanFile = object({
+  planId: zPlanId,
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanMarkdown = object({
+  planId: zPlanId,
+  content: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanUpdateContent = union([
+  zPlanItems.and(object({
+    type: literal("items")
+  })),
+  zPlanFile.and(object({
+    type: literal("file")
+  })),
+  zPlanMarkdown.and(object({
+    type: literal("markdown")
+  }))
+]);
+var zPlanUpdate = object({
+  plan: zPlanUpdateContent,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanRemoved = object({
+  planId: zPlanId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zUnstructuredCommandInput = object({
+  hint: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAvailableCommandInput = zUnstructuredCommandInput;
+var zAvailableCommand = object({
+  name: string(),
+  description: string(),
+  input: defaultOnError(zAvailableCommandInput.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAvailableCommandsUpdate = object({
+  availableCommands: requiredDefaultOnError(vecSkipError(zAvailableCommand), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCurrentModeUpdate = object({
+  currentModeId: zSessionModeId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zConfigOptionUpdate = object({
+  configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionInfoUpdate = object({
+  title: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  updatedAt: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCost = object({
+  amount: number(),
+  currency: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zUsageUpdate = object({
+  used: number(),
+  size: number(),
+  cost: defaultOnError(zCost.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCompactionId = string();
+var zCompactionStatus = union([
+  literal("in_progress"),
+  literal("completed"),
+  literal("failed"),
+  literal("cancelled"),
+  string()
+]);
+var zCompactionUpdate = object({
+  compactionId: zCompactionId,
+  status: zCompactionStatus,
+  summary: defaultOnError(vecSkipError(zContentBlock).nullish(), () => {
+    return;
+  }),
+  error: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCompactionSummaryChunk = object({
+  compactionId: zCompactionId,
+  content: zContentBlock,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionUpdate = union([
+  zContentChunk.and(object({
+    sessionUpdate: literal("user_message_chunk")
+  })),
+  zContentChunk.and(object({
+    sessionUpdate: literal("agent_message_chunk")
+  })),
+  zContentChunk.and(object({
+    sessionUpdate: literal("agent_thought_chunk")
+  })),
+  zToolCall.and(object({
+    sessionUpdate: literal("tool_call")
+  })),
+  zToolCallUpdate.and(object({
+    sessionUpdate: literal("tool_call_update")
+  })),
+  zPlan.and(object({
+    sessionUpdate: literal("plan")
+  })),
+  zPlanUpdate.and(object({
+    sessionUpdate: literal("plan_update")
+  })),
+  zPlanRemoved.and(object({
+    sessionUpdate: literal("plan_removed")
+  })),
+  zAvailableCommandsUpdate.and(object({
+    sessionUpdate: literal("available_commands_update")
+  })),
+  zCurrentModeUpdate.and(object({
+    sessionUpdate: literal("current_mode_update")
+  })),
+  zConfigOptionUpdate.and(object({
+    sessionUpdate: literal("config_option_update")
+  })),
+  zSessionInfoUpdate.and(object({
+    sessionUpdate: literal("session_info_update")
+  })),
+  zUsageUpdate.and(object({
+    sessionUpdate: literal("usage_update")
+  })),
+  zCompactionUpdate.and(object({
+    sessionUpdate: literal("compaction_update")
+  })),
+  zCompactionSummaryChunk.and(object({
+    sessionUpdate: literal("compaction_summary_chunk")
+  }))
+]);
+var zSessionNotification = object({
+  sessionId: zSessionId,
+  update: zSessionUpdate,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCompleteElicitationNotification = object({
+  elicitationId: zElicitationId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMessageMcpNotification = object({
+  connectionId: zMcpConnectionId,
+  method: string(),
+  params: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zExtNotification = unknown();
+var zAgentNotification = object({
+  method: string(),
+  params: union([
+    zSessionNotification,
+    zCompleteElicitationNotification,
+    zMessageMcpNotification,
+    zExtNotification
+  ]).nullish()
+});
+var zFileSystemCapabilities = object({
+  readTextFile: defaultOnError(boolean().optional().default(false), () => false),
+  writeTextFile: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCompactionCapabilities = record(string(), unknown());
+var zBooleanConfigOptionCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSessionConfigOptionsCapabilities = object({
+  boolean: defaultOnError(zBooleanConfigOptionCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zClientSessionCapabilities = object({
+  compaction: defaultOnError(zCompactionCapabilities.nullish(), () => {
+    return;
+  }),
+  configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zPlanCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAuthCapabilities = object({
+  terminal: defaultOnError(boolean().optional().default(false), () => false),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationFormCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationUrlCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationCapabilities = object({
+  form: defaultOnError(zElicitationFormCapabilities.nullish(), () => {
+    return;
+  }),
+  url: defaultOnError(zElicitationUrlCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesJumpCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRenameCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesSearchAndReplaceCapabilities = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zClientNesCapabilities = object({
+  jump: defaultOnError(zNesJumpCapabilities.nullish(), () => {
+    return;
+  }),
+  rename: defaultOnError(zNesRenameCapabilities.nullish(), () => {
+    return;
+  }),
+  searchAndReplace: defaultOnError(zNesSearchAndReplaceCapabilities.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var 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(), () => {
+    return;
+  }),
+  plan: defaultOnError(zPlanCapabilities.nullish(), () => {
+    return;
+  }),
+  auth: defaultOnError(zAuthCapabilities.optional().default({ terminal: false }), () => ({ terminal: false })),
+  elicitation: defaultOnError(zElicitationCapabilities.nullish(), () => {
+    return;
+  }),
+  nes: defaultOnError(zClientNesCapabilities.nullish(), () => {
+    return;
+  }),
+  positionEncodings: defaultOnError(vecSkipError(zPositionEncodingKind).optional(), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zInitializeRequest = object({
+  protocolVersion: zProtocolVersion,
+  clientCapabilities: defaultOnError(zClientCapabilities.optional().default({
+    fs: { readTextFile: false, writeTextFile: false },
+    terminal: false,
+    auth: { terminal: false }
+  }), () => ({
+    fs: { readTextFile: false, writeTextFile: false },
+    terminal: false,
+    auth: { terminal: false }
+  })),
+  clientInfo: defaultOnError(zImplementation.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAuthenticateRequest = object({
+  methodId: zAuthMethodId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zListProvidersRequest = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSetProviderRequest = object({
+  providerId: zProviderId,
+  apiType: zLlmProtocol,
+  baseUrl: string(),
+  headers: record(string(), string()).optional(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDisableProviderRequest = object({
+  providerId: zProviderId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zLogoutRequest = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zHttpHeader = object({
+  name: string(),
+  value: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMcpServerHttp = object({
+  name: string(),
+  url: string(),
+  headers: array(zHttpHeader),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMcpServerSse = object({
+  name: string(),
+  url: string(),
+  headers: array(zHttpHeader),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMcpServerAcp = object({
+  name: string(),
+  serverId: zMcpServerAcpId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMcpServerStdio = object({
+  name: string(),
+  command: string(),
+  args: array(string()),
+  env: array(zEnvVariable),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zMcpServer = union([
+  zMcpServerHttp.and(object({
+    type: literal("http")
+  })),
+  zMcpServerSse.and(object({
+    type: literal("sse")
+  })),
+  zMcpServerAcp.and(object({
+    type: literal("acp")
+  })),
+  zMcpServerStdio
+]);
+var zNewSessionRequest = object({
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zLoadSessionRequest = object({
+  mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zListSessionsRequest = object({
+  cwd: string().nullish(),
+  cursor: string().nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDeleteSessionRequest = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zForkSessionRequest = object({
+  sessionId: zSessionId,
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zResumeSessionRequest = object({
+  sessionId: zSessionId,
+  cwd: string(),
+  additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
+  mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCloseSessionRequest = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSetSessionModeRequest = object({
+  sessionId: zSessionId,
+  modeId: zSessionModeId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSetSessionConfigOptionRequest = intersection(union([
+  object({
+    value: boolean(),
+    type: literal("boolean")
+  }),
+  object({
+    value: zSessionConfigValueId
+  })
+]), object({
+  sessionId: zSessionId,
+  configId: zSessionConfigId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+}));
+var zPromptRequest = object({
+  sessionId: zSessionId,
+  prompt: array(zContentBlock),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zWorkspaceFolder = object({
+  uri: string(),
+  name: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRepository = object({
+  name: string(),
+  owner: string(),
+  remoteUrl: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zStartNesRequest = object({
+  workspaceUri: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  workspaceFolders: array(zWorkspaceFolder).nullish(),
+  repository: defaultOnError(zNesRepository.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesTriggerKind = union([
+  literal("automatic"),
+  literal("diagnostic"),
+  literal("manual")
+]);
+var zNesRecentFile = object({
+  uri: string(),
+  languageId: string(),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesExcerpt = object({
+  startLine: int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }),
+  endLine: int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRelatedSnippet = object({
+  uri: string(),
+  excerpts: array(zNesExcerpt),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesEditHistoryEntry = object({
+  uri: string(),
+  diff: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesUserAction = object({
+  action: string(),
+  uri: string(),
+  position: zPosition,
+  timestampMs: number(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesOpenFile = object({
+  uri: string(),
+  languageId: string(),
+  visibleRange: defaultOnError(zRange.nullish(), () => {
+    return;
+  }),
+  lastFocusedMs: defaultOnError(number().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesDiagnosticSeverity = union([
+  literal("error"),
+  literal("warning"),
+  literal("information"),
+  literal("hint")
+]);
+var zNesDiagnostic = object({
+  uri: string(),
+  range: zRange,
+  severity: zNesDiagnosticSeverity,
+  message: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesSuggestContext = object({
+  recentFiles: array(zNesRecentFile).nullish(),
+  relatedSnippets: array(zNesRelatedSnippet).nullish(),
+  editHistory: array(zNesEditHistoryEntry).nullish(),
+  userActions: array(zNesUserAction).nullish(),
+  openFiles: array(zNesOpenFile).nullish(),
+  diagnostics: array(zNesDiagnostic).nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSuggestNesRequest = object({
+  sessionId: zSessionId,
+  uri: string(),
+  version: number(),
+  position: zPosition,
+  selection: zRange.nullish(),
+  triggerKind: zNesTriggerKind,
+  context: zNesSuggestContext.nullish(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCloseNesRequest = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zClientRequest = 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()
+});
+var zWriteTextFileResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zReadTextFileResponse = object({
+  content: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zSelectedPermissionOutcome = object({
+  optionId: zPermissionOptionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zRequestPermissionOutcome = union([
+  object({
+    outcome: literal("cancelled")
+  }),
+  zSelectedPermissionOutcome.and(object({
+    outcome: literal("selected")
+  }))
+]);
+var zRequestPermissionResponse = object({
+  outcome: zRequestPermissionOutcome,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zCreateTerminalResponse = object({
+  terminalId: zTerminalId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTerminalExitStatus = object({
+  exitCode: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  signal: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTerminalOutputResponse = object({
+  output: string(),
+  truncated: boolean(),
+  exitStatus: defaultOnError(zTerminalExitStatus.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zReleaseTerminalResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zWaitForTerminalExitResponse = object({
+  exitCode: defaultOnError(int().gte(0).max(4294967295, {
+    error: "Invalid value: Expected uint32 to be <= 4294967295"
+  }).nullish(), () => {
+    return;
+  }),
+  signal: defaultOnError(string().nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zKillTerminalResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zElicitationContentValue = union([
+  string(),
+  number(),
+  number(),
+  boolean(),
+  array(string())
+]);
+var zElicitationAcceptAction = object({
+  content: record(string(), zElicitationContentValue).nullish()
+});
+var 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(), () => {
+    return;
+  })
+})), "action", ["accept", "cancel", "decline"]);
+var zConnectMcpResponse = object({
+  connectionId: zMcpConnectionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDisconnectMcpResponse = object({
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zClientResponse = union([
+  object({
+    id: zRequestId,
+    result: union([
+      zWriteTextFileResponse,
+      zReadTextFileResponse,
+      zRequestPermissionResponse,
+      zCreateTerminalResponse,
+      zTerminalOutputResponse,
+      zReleaseTerminalResponse,
+      zWaitForTerminalExitResponse,
+      zKillTerminalResponse,
+      zCreateElicitationResponse,
+      zConnectMcpResponse,
+      zDisconnectMcpResponse,
+      zMessageMcpResponse,
+      zExtResponse
+    ])
+  }),
+  object({
+    id: zRequestId,
+    error: zError
+  })
+]);
+var zCancelNotification = object({
+  sessionId: zSessionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDidOpenDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  languageId: string(),
+  version: number(),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zTextDocumentContentChangeEvent = object({
+  range: zRange.nullish(),
+  text: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDidChangeDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  version: number(),
+  contentChanges: requiredDefaultOnError(vecSkipError(zTextDocumentContentChangeEvent), () => []),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDidCloseDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDidSaveDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zDidFocusDocumentNotification = object({
+  sessionId: zSessionId,
+  uri: string(),
+  version: number(),
+  position: zPosition,
+  visibleRange: zRange,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zAcceptNesNotification = object({
+  sessionId: zSessionId,
+  id: zNesSuggestionId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zNesRejectReason = union([
+  literal("rejected"),
+  literal("ignored"),
+  literal("replaced"),
+  literal("cancelled")
+]);
+var zRejectNesNotification = object({
+  sessionId: zSessionId,
+  id: zNesSuggestionId,
+  reason: defaultOnError(zNesRejectReason.nullish(), () => {
+    return;
+  }),
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+var zClientNotification = object({
+  method: string(),
+  params: union([
+    zCancelNotification,
+    zDidOpenDocumentNotification,
+    zDidChangeDocumentNotification,
+    zDidCloseDocumentNotification,
+    zDidSaveDocumentNotification,
+    zDidFocusDocumentNotification,
+    zAcceptNesNotification,
+    zRejectNesNotification,
+    zMessageMcpNotification,
+    zExtNotification
+  ]).nullish()
+});
+var zCancelRequestNotification = object({
+  requestId: zRequestId,
+  _meta: defaultOnError(record(string(), unknown()).nullish(), () => {
+    return;
+  })
+});
+
+// node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
+var CANCEL_REQUEST_METHOD = "$/cancel_request";
+function isRequestMessage(value) {
+  return isJsonRpcEnvelope(value) && "id" in value && typeof value["method"] === "string" && isJsonRpcId(value["id"]);
+}
+function isResponseMessage(value) {
+  if (!isJsonRpcEnvelope(value) || "method" in value) {
+    return false;
+  }
+  if (!("id" in value) || !isJsonRpcId(value["id"])) {
+    return false;
+  }
+  const hasResult = Object.hasOwn(value, "result");
+  const hasError = Object.hasOwn(value, "error");
+  if (hasResult === hasError) {
+    return false;
+  }
+  return !hasError || isErrorResponse(value["error"]);
+}
+function isNotificationMessage(value) {
+  return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isJsonRpcEnvelope(value) {
+  return isRecord(value) && value["jsonrpc"] === "2.0";
+}
+function isJsonRpcId(value) {
+  return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isResponseShapedMessage(value) {
+  return isRecord(value) && !("method" in value) && (("id" in value) || ("result" in value) || ("error" in value));
+}
+function isResponseBatch(batch) {
+  let hasValidCall = false;
+  let hasValidResponse = false;
+  let hasCallShape = false;
+  let hasResponseShape = false;
+  for (const entry of batch) {
+    hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
+    hasValidResponse ||= isResponseMessage(entry);
+    if (!isRecord(entry)) {
+      continue;
+    }
+    hasCallShape ||= "method" in entry;
+    hasResponseShape ||= "result" in entry || "error" in entry;
+  }
+  if (hasValidCall) {
+    return false;
+  }
+  if (hasValidResponse) {
+    return true;
+  }
+  return hasResponseShape && !hasCallShape;
+}
+function cancelRequestId(params) {
+  if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
+    return;
+  }
+  return params["requestId"];
+}
+function isErrorResponse(value) {
+  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+}
+var Handled = {
+  yes() {
+    return { handled: true };
+  },
+  no(message, retry = false) {
+    return { handled: false, message, retry };
+  }
+};
+function rejectedPromise(error) {
+  const promise = Promise.reject(error);
+  promise.catch(() => {});
+  return promise;
+}
+function errorDetails(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return;
+}
+function isZodError(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "ZodError" && "issues" in error && Array.isArray(error.issues) && "format" in error && typeof error.format === "function";
+}
+function errorToResult(error) {
+  if (error instanceof RequestError) {
+    return error.toResult();
+  }
+  if (isZodError(error)) {
+    return RequestError.invalidParams(error.format()).toResult();
+  }
+  const details = errorDetails(error);
+  try {
+    return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
+  } catch {
+    return RequestError.internalError({ details }).toResult();
+  }
+}
+function requestCancelledError(reason) {
+  if (reason instanceof RequestError && reason.code === -32800) {
+    return reason;
+  }
+  return RequestError.requestCancelled(reason);
+}
+function errorToRequestResult(error, signal) {
+  const requestCancelled = abortErrorToRequestCancelled(error, signal);
+  return requestCancelled ? requestCancelled.toResult() : errorToResult(error);
+}
+function abortErrorToRequestCancelled(error, signal) {
+  if (!signal.aborted || !isAbortError(error)) {
+    return;
+  }
+  return requestCancelledError(signal.reason);
+}
+function isAbortError(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const maybeAbortError = error;
+  return maybeAbortError.name === "AbortError" || maybeAbortError.code === "ABORT_ERR";
+}
+
+class RequestResponder {
+  id;
+  sendResult;
+  signal;
+  finishRequest;
+  didRespond = false;
+  constructor(id, sendResult, signal = new AbortController().signal, finishRequest) {
+    this.id = id;
+    this.sendResult = sendResult;
+    this.signal = signal;
+    this.finishRequest = finishRequest;
+  }
+  get responded() {
+    return this.didRespond;
+  }
+  respond(response) {
+    return this.respondWithResult({ result: response ?? null });
+  }
+  respondWithError(error) {
+    const errorResponse = error instanceof RequestError ? error.toErrorResponse() : error;
+    return this.respondWithResult({ error: errorResponse });
+  }
+  respondWithResult(result) {
+    if (this.didRespond) {
+      return rejectedPromise(new Error("JSON-RPC request already responded"));
+    }
+    this.didRespond = true;
+    return this.sendResult(result).finally(() => {
+      this.finishRequest?.();
+    });
+  }
+}
+var requestBatchSizes = new WeakMap;
+class HandlerRegistration {
+  disposeHandler;
+  active = true;
+  constructor(disposeHandler) {
+    this.disposeHandler = disposeHandler;
+  }
+  dispose() {
+    if (!this.active) {
+      return;
+    }
+    this.active = false;
+    this.disposeHandler();
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  runIndefinitely() {
+    return this;
+  }
+}
+
+class ConnectionContext {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  sendRequest(method, params, mapResponse, options) {
+    return this.connection.sendRequest(method, params, mapResponse, options);
+  }
+  sendNotification(method, params) {
+    return this.connection.sendNotification(method, params);
+  }
+  sendBatch(entries) {
+    return this.connection.sendBatch(entries);
+  }
+  sendCancelRequest(requestId) {
+    return this.connection.sendCancelRequest(requestId);
+  }
+  addDynamicHandler(handler) {
+    return this.connection.addDynamicHandler(handler);
+  }
+  get signal() {
+    return this.connection.signal;
+  }
+  get closed() {
+    return this.connection.closed;
+  }
+}
+
+class Connection {
+  pendingResponses = new Map;
+  incomingRequests = new Map;
+  nextRequestId = 0;
+  staticHandlers = [];
+  dynamicHandlers = new Set;
+  stream;
+  writeQueue = Promise.resolve();
+  abortController = new AbortController;
+  closedPromise;
+  retryQueue = [];
+  context = new ConnectionContext(this);
+  receiveReader;
+  allowBatches = true;
+  constructor(requestHandlerOrStream, notificationHandlerOrHandlers, streamOrOptions, options) {
+    if (typeof requestHandlerOrStream === "function") {
+      const requestHandler = requestHandlerOrStream;
+      const notificationHandler = notificationHandlerOrHandlers;
+      const 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);
+  }
+  static builder() {
+    return new ConnectionBuilder;
+  }
+  runUntil(op) {
+    let opSettled = false;
+    const opPromise = Promise.resolve().then(() => op(this.context)).finally(() => {
+      opSettled = true;
+    });
+    const closedPromise = this.closed.then(() => {
+      if (opSettled) {
+        return new Promise(() => {});
+      }
+      throw this.closedReason();
+    });
+    return Promise.race([opPromise, closedPromise]).finally(() => {
+      opSettled = true;
+      this.close();
+    });
+  }
+  addDynamicHandler(handler) {
+    this.dynamicHandlers.add(handler);
+    if (this.retryQueue.length > 0) {
+      for (const message of this.retryQueue.splice(0)) {
+        this.processIncomingMessage(message).catch((error) => this.close(error));
+      }
+    }
+    return new HandlerRegistration(() => {
+      this.dynamicHandlers.delete(handler);
+    });
+  }
+  get signal() {
+    return this.abortController.signal;
+  }
+  get closed() {
+    return this.closedPromise;
+  }
+  getContext() {
+    return this.context;
+  }
+  sendRequest(method, params, mapResponse, options = {}) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    const request = this.prepareRequest(method, params, mapResponse, options);
+    const requestSent = this.sendWireMessage(request.message);
+    requestSent.catch(() => {});
+    if (options.cancellationSignal?.aborted) {
+      request.cancel();
+    }
+    return request.response;
+  }
+  sendBatch(entries) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    if (!this.allowBatches) {
+      return rejectedPromise(new TypeError("JSON-RPC batches are not supported on this connection"));
+    }
+    if (entries.length === 0) {
+      return rejectedPromise(new TypeError("JSON-RPC batch must contain at least one entry"));
+    }
+    const messages = [];
+    const cancellations = [];
+    const outputs = [];
+    for (const entry of entries) {
+      if (entry.kind === "notification") {
+        messages.push({
+          jsonrpc: "2.0",
+          method: entry.method,
+          params: entry.params
+        });
+        outputs.push(Promise.resolve(undefined));
+        continue;
+      }
+      const request = this.prepareRequest(entry.method, entry.params, entry.mapResponse, entry.options);
+      messages.push(request.message);
+      outputs.push(request.response);
+      cancellations.push({
+        signal: entry.options?.cancellationSignal,
+        cancel: request.cancel
+      });
+    }
+    const batch = messages;
+    const batchSent = this.sendWireMessage(batch);
+    for (const cancellation of cancellations) {
+      if (cancellation.signal?.aborted) {
+        cancellation.cancel();
+      }
+    }
+    const response = Promise.all([batchSent, ...outputs]).then(([, ...resolved]) => resolved);
+    response.catch(() => {});
+    return response;
+  }
+  sendCancelRequest(requestId) {
+    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
+  }
+  sendNotification(method, params) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    return this.sendWireMessage({ jsonrpc: "2.0", method, params });
+  }
+  prepareRequest(method, params, mapResponse, options = {}) {
+    const id = this.nextRequestId++;
+    let cancel = () => {};
+    const response = new Promise((resolve, reject) => {
+      const pendingResponse = {
+        resolve: (value) => {
+          try {
+            resolve(mapResponse ? mapResponse(value) : value);
+          } catch (error) {
+            reject(error);
+          }
+        },
+        reject
+      };
+      cancel = () => {
+        if (pendingResponse.cancellationSent) {
+          return;
+        }
+        pendingResponse.cancellationSent = true;
+        pendingResponse.cleanup?.();
+        this.sendCancelRequest(id).catch(() => {});
+      };
+      options.cancellationSignal?.addEventListener("abort", cancel, {
+        once: true
+      });
+      pendingResponse.cleanup = () => {
+        options.cancellationSignal?.removeEventListener("abort", cancel);
+      };
+      this.pendingResponses.set(id, pendingResponse);
+    });
+    response.catch(() => {});
+    return {
+      message: { jsonrpc: "2.0", id, method, params },
+      response,
+      cancel: () => cancel()
+    };
+  }
+  close(error) {
+    if (this.abortController.signal.aborted) {
+      return;
+    }
+    const closeError = error ?? new Error("ACP connection closed");
+    this.abortController.abort(closeError);
+    for (const pendingResponse of this.pendingResponses.values()) {
+      pendingResponse.cleanup?.();
+      pendingResponse.reject(closeError);
+    }
+    this.pendingResponses.clear();
+    for (const controller of this.incomingRequests.values()) {
+      controller.abort(closeError);
+    }
+    this.incomingRequests.clear();
+    this.receiveReader?.cancel(closeError).catch(() => {});
+  }
+  initialize(stream, handlers, options) {
+    this.stream = stream;
+    this.staticHandlers = handlers;
+    this.allowBatches = options?.allowBatches ?? true;
+    this.closedPromise = new Promise((resolve) => {
+      this.abortController.signal.addEventListener("abort", () => resolve());
+    });
+    this.receive();
+  }
+  legacyHandler(requestHandler, notificationHandler) {
+    return {
+      handleMessage: async (message, cx) => {
+        if (message.kind === "request") {
+          const result = await requestHandler(message.method, message.params, cx);
+          await message.responder.respond(result);
+        } else {
+          await notificationHandler(message.method, message.params, cx);
+        }
+        return Handled.yes();
+      }
+    };
+  }
+  async receive() {
+    let closeError = undefined;
+    try {
+      const reader = this.stream.readable.getReader();
+      this.receiveReader = reader;
+      try {
+        while (!this.abortController.signal.aborted) {
+          const { value: message, done } = await reader.read();
+          if (this.abortController.signal.aborted) {
+            break;
+          }
+          if (done) {
+            break;
+          }
+          this.receiveWireMessage(message);
+        }
+      } finally {
+        if (this.receiveReader === reader) {
+          this.receiveReader = undefined;
+        }
+        reader.releaseLock();
+      }
+    } catch (error) {
+      closeError = error;
+    } finally {
+      this.close(closeError);
+    }
+  }
+  receiveWireMessage(message) {
+    if (Array.isArray(message)) {
+      if (!this.allowBatches) {
+        this.close(new TypeError("JSON-RPC batches are not supported on this connection"));
+        return;
+      }
+      this.receiveBatch(message);
+      return;
+    }
+    if (!isRequestMessage(message) && !isNotificationMessage(message) && !isResponseShapedMessage(message)) {
+      this.sendWireMessage(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {});
+      return;
+    }
+    this.receiveMessage(message);
+  }
+  receiveBatch(batch) {
+    if (batch.length === 0) {
+      this.sendWireMessage(protocolErrorResponse(RequestError.invalidRequest(batch))).catch(() => {});
+      return;
+    }
+    const responseBatch = isResponseBatch(batch);
+    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
+    let remaining = responseCount;
+    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
+    let responseSent = false;
+    const responses = [];
+    const sendResponsesIfReady = async () => {
+      if (responseSent || remaining !== 0 || remainingNotifications !== 0 || responses.length === 0) {
+        return;
+      }
+      responseSent = true;
+      await this.sendWireMessage(responses);
+    };
+    const collectResponse = async (response) => {
+      responses.push(response);
+      remaining -= 1;
+      await sendResponsesIfReady();
+    };
+    for (const message of batch) {
+      if (responseBatch) {
+        if (isResponseShapedMessage(message)) {
+          this.receiveMessage(message);
+        }
+        continue;
+      }
+      if (!isRequestMessage(message) && !isNotificationMessage(message)) {
+        collectResponse(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {});
+        continue;
+      }
+      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : undefined, batch.length);
+      if (isNotificationMessage(message)) {
+        processing.finally(() => {
+          remainingNotifications -= 1;
+          sendResponsesIfReady().catch((error) => this.close(error));
+        });
+      }
+    }
+  }
+  receiveMessage(message, sendResponse, batchSize) {
+    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, batchSize)).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, batchSize) {
+    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);
+        }
+      };
+      const 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);
+      if (batchSize !== undefined) {
+        requestBatchSizes.set(responder, batchSize);
+      }
+      return {
+        kind: "request",
+        method: message.method,
+        params: message.params,
+        raw: message,
+        signal: abortController.signal,
+        responder
+      };
+    }
+    return {
+      kind: "notification",
+      method: message.method,
+      params: message.params,
+      raw: message
+    };
+  }
+  handleResponse(response) {
+    const pendingResponse = this.pendingResponses.get(response.id);
+    if (pendingResponse) {
+      this.pendingResponses.delete(response.id);
+      pendingResponse.cleanup?.();
+      if (!isResponseMessage(response)) {
+        pendingResponse.reject(RequestError.invalidRequest(response));
+      } else if ("result" in response) {
+        pendingResponse.resolve(response.result);
+      } else {
+        const { code, message, data } = response.error;
+        pendingResponse.reject(new RequestError(code, message, data));
+      }
+    } else {
+      console.error("Got response to unknown request", response.id);
+    }
+  }
+  handleProtocolNotification(message) {
+    if (message.method !== CANCEL_REQUEST_METHOD) {
+      return;
+    }
+    const requestId = cancelRequestId(message.params);
+    if (requestId === undefined) {
+      return;
+    }
+    const controller = this.incomingRequests.get(requestId);
+    if (!controller || controller.signal.aborted) {
+      return;
+    }
+    controller.abort(RequestError.requestCancelled({ requestId }));
+  }
+  closedReason() {
+    return this.abortController.signal.reason ?? new Error("ACP connection closed");
+  }
+  async sendWireMessage(message) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    this.writeQueue = this.writeQueue.then(async () => {
+      if (this.abortController.signal.aborted) {
+        throw this.closedReason();
+      }
+      const writer = this.stream.writable.getWriter();
+      try {
+        await writer.write(message);
+      } finally {
+        writer.releaseLock();
+      }
+    }).catch((error) => {
+      this.close(error);
+      throw error;
+    });
+    return this.writeQueue;
+  }
+}
+
+class ConnectionBuilder {
+  handlers = [];
+  connectionName;
+  name(name) {
+    this.connectionName = name;
+    return this;
+  }
+  withHandler(handler) {
+    this.handlers.push(handler);
+    return this;
+  }
+  onReceiveMessage(handler) {
+    return this.withHandler({
+      handleMessage: async (message, cx) => await handler(message, cx) ?? Handled.no(message),
+      describe: () => this.connectionName ?? "onReceiveMessage"
+    });
+  }
+  onReceiveRequest(method, parse, handler) {
+    return this.withHandler({
+      handleMessage: async (message, cx) => {
+        if (message.kind !== "request" || message.method !== method) {
+          return Handled.no(message);
+        }
+        const request = parse(message.params);
+        return await handler(request, message.responder, cx) ?? Handled.yes();
+      },
+      describe: () => `${this.connectionName ?? "request"}:${method}`
+    });
+  }
+  onReceiveNotification(method, parse, handler) {
+    return this.withHandler({
+      handleMessage: async (message, cx) => {
+        if (message.kind !== "notification" || message.method !== method) {
+          return Handled.no(message);
+        }
+        const notification = parse(message.params);
+        return await handler(notification, cx) ?? Handled.yes();
+      },
+      describe: () => `${this.connectionName ?? "notification"}:${method}`
+    });
+  }
+  connect(stream, options) {
+    return new Connection(stream, this.handlers, options);
+  }
+  connectWith(stream, op, options) {
+    return this.connect(stream, options).runUntil(op);
+  }
+}
+
+class RequestError extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.name = "RequestError";
+    this.data = data;
+  }
+  static parseError(data, additionalMessage) {
+    return new RequestError(-32700, `Parse error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
+  static invalidRequest(data, additionalMessage) {
+    return new RequestError(-32600, `Invalid request${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
+  static methodNotFound(method) {
+    return new RequestError(-32601, `"Method not found": ${method}`, {
+      method
+    });
+  }
+  static invalidParams(data, additionalMessage) {
+    return new RequestError(-32602, `Invalid params${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
+  static internalError(data, additionalMessage) {
+    return new RequestError(-32603, `Internal error${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
+  static requestCancelled(data, additionalMessage) {
+    return new RequestError(-32800, `Request cancelled${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
+  static authRequired(data, additionalMessage) {
+    return new RequestError(-32000, `Authentication required${additionalMessage ? `: ${additionalMessage}` : ""}`, data);
+  }
+  static resourceNotFound(uri) {
+    return new RequestError(-32002, `Resource not found${uri ? `: ${uri}` : ""}`, uri && { uri });
+  }
+  toResult() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        data: this.data
+      }
+    };
+  }
+  toErrorResponse() {
+    return {
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+}
+function protocolErrorResponse(error) {
+  return {
+    jsonrpc: "2.0",
+    id: null,
+    error: error.toErrorResponse()
+  };
+}
+
+// node_modules/@agentclientprotocol/sdk/dist/line-buffer.js
+var newline = 10;
+
+class LineBuffer {
+  #pending = [];
+  push(chunk) {
+    const lines = [];
+    let start = 0;
+    let newlineIndex = chunk.indexOf(newline, start);
+    while (newlineIndex !== -1) {
+      lines.push(this.#takeLine(chunk.subarray(start, newlineIndex)));
+      start = newlineIndex + 1;
+      newlineIndex = chunk.indexOf(newline, start);
+    }
+    if (start < chunk.byteLength) {
+      this.#pending.push(start === 0 ? chunk : new Uint8Array(chunk.subarray(start)));
+    }
+    return lines;
+  }
+  flush() {
+    if (this.#pending.length === 0) {
+      return;
+    }
+    return this.#takeLine(new Uint8Array(0));
+  }
+  #takeLine(tail) {
+    if (this.#pending.length === 0) {
+      return tail;
+    }
+    let total = tail.byteLength;
+    for (const part of this.#pending) {
+      total += part.byteLength;
+    }
+    const line = new Uint8Array(total);
+    let offset = 0;
+    for (const part of this.#pending) {
+      line.set(part, offset);
+      offset += part.byteLength;
+    }
+    line.set(tail, offset);
+    this.#pending = [];
+    return line;
+  }
+}
+
+// node_modules/@agentclientprotocol/sdk/dist/stream.js
+function ndJsonStream(output, input) {
+  const textEncoder = new TextEncoder;
+  const textDecoder = new TextDecoder;
+  let cancelled = false;
+  let inputReader;
+  let outputWrite = Promise.resolve();
+  const writeJson = (message) => {
+    const content = JSON.stringify(message) + `
+`;
+    const write = outputWrite.then(async () => {
+      const writer = output.getWriter();
+      try {
+        await writer.write(textEncoder.encode(content));
+      } finally {
+        writer.releaseLock();
+      }
+    });
+    outputWrite = write.catch(() => {});
+    return write;
+  };
+  const readable = new ReadableStream({
+    async start(controller) {
+      const lines = new LineBuffer;
+      const enqueueLine = async (lineBytes) => {
+        const trimmedLine = textDecoder.decode(lineBytes).trim();
+        if (!trimmedLine) {
+          return;
+        }
+        let message;
+        try {
+          message = JSON.parse(trimmedLine);
+        } catch {
+          await writeJson(protocolErrorResponse(RequestError.parseError()));
+          return;
+        }
+        if (isRecord(message) || Array.isArray(message)) {
+          controller.enqueue(message);
+        } else {
+          await writeJson(protocolErrorResponse(RequestError.invalidRequest(message)));
+        }
+      };
+      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)) {
+            await enqueueLine(line);
+            if (cancelled) {
+              return;
+            }
+          }
+        }
+        if (cancelled) {
+          return;
+        }
+        const lastLine = lines.flush();
+        if (lastLine) {
+          await enqueueLine(lastLine);
+        }
+      } catch (err) {
+        if (cancelled) {
+          return;
+        }
+        controller.error(err);
+        return;
+      } finally {
+        if (inputReader === reader) {
+          inputReader = undefined;
+        }
+        reader.releaseLock();
+      }
+      if (cancelled) {
+        return;
+      }
+      controller.close();
+    },
+    cancel(reason) {
+      cancelled = true;
+      return inputReader?.cancel(reason);
+    }
+  });
+  const writable = new WritableStream({
+    write(message) {
+      return writeJson(message);
+    }
+  });
+  return { readable, writable };
+}
+
+// node_modules/@agentclientprotocol/sdk/dist/schema/guards.gen.js
+var zGuardCreateElicitationRequestForm = zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string() }));
+var zGuardCreateElicitationRequestUrl = zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string() }));
+var zGuardCreateElicitationRequestCustom = union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string() }));
+var zGuardElicitationPropertySchemaString = zStringPropertySchema.and(object({ type: literal("string") }));
+var zGuardElicitationPropertySchemaNumber = zNumberPropertySchema.and(object({ type: literal("number") }));
+var zGuardElicitationPropertySchemaInteger = zIntegerPropertySchema.and(object({ type: literal("integer") }));
+var zGuardElicitationPropertySchemaBoolean = zBooleanPropertySchema.and(object({ type: literal("boolean") }));
+var zGuardElicitationPropertySchemaArray = zMultiSelectPropertySchema.and(object({ type: literal("array") }));
+var zGuardMultiSelectItemsString = zStringMultiSelectItems.and(object({ type: literal("string") }));
+var zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
+var zGuardCreateElicitationResponseDecline = object({
+  action: literal("decline")
+});
+var zGuardCreateElicitationResponseCancel = object({
+  action: literal("cancel")
+});
+// node_modules/@agentclientprotocol/sdk/dist/acp.js
+function ndJsonStream2(output, input) {
+  return ndJsonStream(output, input);
+}
+function emptyObjectResponse(response) {
+  return response ?? {};
+}
+function isStream(value) {
+  return typeof value === "object" && value !== null && "readable" in value && "writable" in value;
+}
+function memoryStreamPair() {
+  const leftToRight = new TransformStream;
+  const rightToLeft = new TransformStream;
+  return [
+    {
+      readable: rightToLeft.readable,
+      writable: leftToRight.writable
+    },
+    {
+      readable: leftToRight.readable,
+      writable: rightToLeft.writable
+    }
+  ];
+}
+var methods = {
+  agent: {
+    initialize: AGENT_METHODS.initialize,
+    authenticate: AGENT_METHODS.authenticate,
+    logout: AGENT_METHODS.logout,
+    providers: {
+      list: AGENT_METHODS.providers_list,
+      set: AGENT_METHODS.providers_set,
+      disable: AGENT_METHODS.providers_disable
+    },
+    session: {
+      new: AGENT_METHODS.session_new,
+      load: AGENT_METHODS.session_load,
+      list: AGENT_METHODS.session_list,
+      delete: AGENT_METHODS.session_delete,
+      fork: AGENT_METHODS.session_fork,
+      resume: AGENT_METHODS.session_resume,
+      close: AGENT_METHODS.session_close,
+      setMode: AGENT_METHODS.session_set_mode,
+      setConfigOption: AGENT_METHODS.session_set_config_option,
+      prompt: AGENT_METHODS.session_prompt,
+      cancel: AGENT_METHODS.session_cancel
+    },
+    nes: {
+      start: AGENT_METHODS.nes_start,
+      suggest: AGENT_METHODS.nes_suggest,
+      accept: AGENT_METHODS.nes_accept,
+      reject: AGENT_METHODS.nes_reject,
+      close: AGENT_METHODS.nes_close
+    },
+    document: {
+      didOpen: AGENT_METHODS.document_did_open,
+      didChange: AGENT_METHODS.document_did_change,
+      didClose: AGENT_METHODS.document_did_close,
+      didSave: AGENT_METHODS.document_did_save,
+      didFocus: AGENT_METHODS.document_did_focus
+    }
+  },
+  client: {
+    session: {
+      requestPermission: CLIENT_METHODS.session_request_permission,
+      update: CLIENT_METHODS.session_update
+    },
+    fs: {
+      writeTextFile: CLIENT_METHODS.fs_write_text_file,
+      readTextFile: CLIENT_METHODS.fs_read_text_file
+    },
+    terminal: {
+      create: CLIENT_METHODS.terminal_create,
+      output: CLIENT_METHODS.terminal_output,
+      release: CLIENT_METHODS.terminal_release,
+      waitForExit: CLIENT_METHODS.terminal_wait_for_exit,
+      kill: CLIENT_METHODS.terminal_kill
+    },
+    elicitation: {
+      create: CLIENT_METHODS.elicitation_create,
+      complete: CLIENT_METHODS.elicitation_complete
+    }
+  },
+  protocol: {
+    cancelRequest: PROTOCOL_METHODS.cancel_request
+  }
+};
+var startActiveSession = Symbol("startActiveSession");
+
+class AcpContext {
+  cx;
+  currentRequestId;
+  constructor(cx, currentRequestId) {
+    this.cx = cx;
+    this.currentRequestId = currentRequestId;
+  }
+  get requestId() {
+    return this.currentRequestId;
+  }
+  get connectionContext() {
+    return this.cx;
+  }
+  sendRequest(method, params, mapResponse, options) {
+    return this.cx.sendRequest(method, params, mapResponse, options);
+  }
+  sendNotification(method, params) {
+    return this.cx.sendNotification(method, params);
+  }
+  addDynamicHandler(handler) {
+    return this.cx.addDynamicHandler(handler);
+  }
+}
+
+class AgentContext extends AcpContext {
+  constructor(cx, requestId) {
+    super(cx, requestId);
+  }
+  static create(cx, requestId) {
+    return new AgentContext(cx, requestId);
+  }
+  request(method, params, options) {
+    const spec = clientRequestSpecsByMethod[method];
+    return this.sendRequest(method, params, spec?.mapResponse, options);
+  }
+  notify(method, params) {
+    return this.sendNotification(method, params);
+  }
+}
+
+class ClientContext extends AcpContext {
+  constructor(cx, requestId) {
+    super(cx, requestId);
+  }
+  static create(cx, requestId) {
+    return new ClientContext(cx, requestId);
+  }
+  [startActiveSession](params, options) {
+    return this.sendRequest(AGENT_METHODS.session_new, params, (response) => this.attachSession(response), options);
+  }
+  buildSession(cwdOrRequest) {
+    if (typeof cwdOrRequest === "string") {
+      return SessionBuilder.create(this, {
+        cwd: cwdOrRequest,
+        mcpServers: []
+      });
+    }
+    return SessionBuilder.create(this, cwdOrRequest);
+  }
+  attachSession(response) {
+    const updates = new AsyncQueue;
+    const closeSignal = this.connectionContext.signal;
+    const failUpdatesOnClose = () => {
+      updates.fail(closeSignal.reason ?? new Error("ACP connection closed"));
+    };
+    if (closeSignal.aborted) {
+      failUpdatesOnClose();
+    } else {
+      closeSignal.addEventListener("abort", failUpdatesOnClose);
+    }
+    const sessionRegistration = sessionUpdateRouter(this.connectionContext).attach(response, updates);
+    const closeRegistration = new HandlerRegistration(() => {
+      closeSignal.removeEventListener("abort", failUpdatesOnClose);
+    });
+    return ActiveSession.create(this, response, updates, [
+      sessionRegistration,
+      closeRegistration
+    ]);
+  }
+  request(method, params, options) {
+    const spec = agentRequestSpecsByMethod[method];
+    return this.sendRequest(method, params, spec?.mapResponse, options);
+  }
+  notify(method, params) {
+    return this.sendNotification(method, params);
+  }
+}
+
+class AcpConnectionHandle {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  get signal() {
+    return this.connection.signal;
+  }
+  get closed() {
+    return this.connection.closed;
+  }
+  close(error) {
+    this.connection.close(error);
+  }
+}
+
+class AgentConnectionHandle extends AcpConnectionHandle {
+  connectHandlers;
+  client;
+  didStartConnectHandlers = false;
+  constructor(connection, connectHandlers = []) {
+    super(connection);
+    this.connectHandlers = connectHandlers;
+    this.client = AgentContext.create(connection.getContext());
+  }
+  startConnectHandlers() {
+    if (this.didStartConnectHandlers) {
+      return;
+    }
+    this.didStartConnectHandlers = true;
+    runConnectHandlers(this, this.connectHandlers);
+  }
+}
+
+class ClientConnectionHandle extends AcpConnectionHandle {
+  connectHandlers;
+  agent;
+  didStartConnectHandlers = false;
+  constructor(connection, connectHandlers = []) {
+    super(connection);
+    this.connectHandlers = connectHandlers;
+    this.agent = ClientContext.create(connection.getContext());
+  }
+  startConnectHandlers() {
+    if (this.didStartConnectHandlers) {
+      return;
+    }
+    this.didStartConnectHandlers = true;
+    runConnectHandlers(this, this.connectHandlers);
+  }
+}
+function agentConnection(connection, connectHandlers = []) {
+  return new AgentConnectionHandle(connection, connectHandlers);
+}
+function clientConnection(connection, connectHandlers = []) {
+  return new ClientConnectionHandle(connection, connectHandlers);
+}
+
+class AsyncQueue {
+  values = [];
+  waiters = [];
+  failed = false;
+  failure;
+  enqueue(value) {
+    if (this.failed) {
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve(value);
+    } else {
+      this.values.push({ kind: "value", value });
+    }
+  }
+  reject(error) {
+    if (this.failed) {
+      return;
+    }
+    if (this.waiters.length > 0) {
+      for (const waiter of this.waiters.splice(0)) {
+        waiter.reject(error);
+      }
+      return;
+    }
+    this.values.push({ kind: "error", error });
+  }
+  clearErrors() {
+    this.values = this.values.filter((entry) => entry.kind === "value");
+  }
+  fail(error) {
+    if (this.failed) {
+      return;
+    }
+    this.failed = true;
+    this.failure = error;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.reject(error);
+    }
+  }
+  next() {
+    if (this.values.length > 0) {
+      const entry = this.values.shift();
+      if (entry.kind === "error") {
+        return Promise.reject(entry.error);
+      }
+      return Promise.resolve(entry.value);
+    }
+    if (this.failed) {
+      return Promise.reject(this.failure);
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+}
+function cloneNewSessionRequest(request) {
+  return {
+    ...request,
+    additionalDirectories: request.additionalDirectories ? [...request.additionalDirectories] : undefined,
+    mcpServers: [...request.mcpServers]
+  };
+}
+
+class SessionBuilder {
+  cx;
+  request;
+  constructor(cx, request) {
+    this.cx = cx;
+    this.request = cloneNewSessionRequest(request);
+  }
+  static create(cx, request) {
+    return new SessionBuilder(cx, request);
+  }
+  toRequest() {
+    return cloneNewSessionRequest(this.request);
+  }
+  withAdditionalDirectories(additionalDirectories) {
+    this.request = {
+      ...this.request,
+      additionalDirectories: [...additionalDirectories]
+    };
+    return this;
+  }
+  withMcpServer(mcpServer) {
+    this.request = {
+      ...this.request,
+      mcpServers: [...this.request.mcpServers, mcpServer]
+    };
+    return this;
+  }
+  async start(options) {
+    return this.cx[startActiveSession](this.toRequest(), options);
+  }
+  async withSession(op) {
+    const session = await this.start();
+    try {
+      return await op(session);
+    } finally {
+      session.dispose();
+    }
+  }
+}
+
+class ActiveSession {
+  cx;
+  sessionResponse;
+  updates;
+  registrations;
+  constructor(cx, sessionResponse, updates, registrations) {
+    this.cx = cx;
+    this.sessionResponse = sessionResponse;
+    this.updates = updates;
+    this.registrations = registrations;
+  }
+  static create(cx, sessionResponse, updates, registrations) {
+    return new ActiveSession(cx, sessionResponse, updates, registrations);
+  }
+  get sessionId() {
+    return this.sessionResponse.sessionId;
+  }
+  get modes() {
+    return this.sessionResponse.modes;
+  }
+  get meta() {
+    return this.sessionResponse._meta;
+  }
+  get newSessionResponse() {
+    return this.sessionResponse;
+  }
+  prompt(prompt, options) {
+    this.updates.clearErrors();
+    const response = this.cx.request(AGENT_METHODS.session_prompt, {
+      sessionId: this.sessionId,
+      prompt: this.promptBlocks(prompt)
+    }, options);
+    response.then((value) => {
+      this.updates.enqueue({
+        kind: "stop",
+        response: value,
+        stopReason: value.stopReason
+      });
+    }, (error) => {
+      this.updates.reject(error);
+    });
+    return response;
+  }
+  nextUpdate() {
+    return this.updates.next();
+  }
+  async readText() {
+    let output = "";
+    for (;; ) {
+      const message = await this.nextUpdate();
+      if (message.kind === "stop") {
+        return output;
+      }
+      const { update } = message;
+      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+        output += update.content.text;
+      }
+    }
+  }
+  dispose() {
+    for (const registration of this.registrations.splice(0)) {
+      registration.dispose();
+    }
+    this.updates.fail(new Error("Active session disposed"));
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
+  promptBlocks(prompt) {
+    if (typeof prompt === "string") {
+      return [{ type: "text", text: prompt }];
+    }
+    if (Array.isArray(prompt)) {
+      return prompt;
+    }
+    return [prompt];
+  }
+}
+function parseParams(parser, params) {
+  if (!parser) {
+    return params;
+  }
+  if (typeof parser === "function") {
+    return parser(params);
+  }
+  return parser.parse(params);
+}
+function requestSpec(method, params, mapResponse) {
+  return { method, params, mapResponse };
+}
+function notificationSpec(method, params) {
+  return { method, params };
+}
+function registerAppRequest(builder, spec, context, handler) {
+  builder.onReceiveRequest(spec.method, (params) => parseParams(spec.params, params), async (params, responder, cx) => {
+    const response = await handler(context(params, cx, responder.signal, responder.id));
+    await responder.respond(spec.mapResponse ? spec.mapResponse(response) : response);
+  });
+}
+function registerAppNotification(builder, spec, context, handler) {
+  builder.onReceiveNotification(spec.method, (params) => parseParams(spec.params, params), (params, cx) => handler(context(params, cx, cx.signal)));
+}
+function specsByMethod(specs) {
+  const byMethod = {};
+  for (const spec of Object.values(specs)) {
+    byMethod[spec.method] = spec;
+  }
+  return byMethod;
+}
+var agentRequestSpecs = {
+  initialize: requestSpec(AGENT_METHODS.initialize, zInitializeRequest),
+  newSession: requestSpec(AGENT_METHODS.session_new, zNewSessionRequest),
+  loadSession: requestSpec(AGENT_METHODS.session_load, zLoadSessionRequest, emptyObjectResponse),
+  unstable_forkSession: requestSpec(AGENT_METHODS.session_fork, zForkSessionRequest),
+  listSessions: requestSpec(AGENT_METHODS.session_list, zListSessionsRequest),
+  deleteSession: requestSpec(AGENT_METHODS.session_delete, zDeleteSessionRequest, emptyObjectResponse),
+  resumeSession: requestSpec(AGENT_METHODS.session_resume, zResumeSessionRequest),
+  closeSession: requestSpec(AGENT_METHODS.session_close, zCloseSessionRequest, emptyObjectResponse),
+  setSessionMode: requestSpec(AGENT_METHODS.session_set_mode, zSetSessionModeRequest, emptyObjectResponse),
+  setSessionConfigOption: requestSpec(AGENT_METHODS.session_set_config_option, zSetSessionConfigOptionRequest),
+  authenticate: requestSpec(AGENT_METHODS.authenticate, zAuthenticateRequest, emptyObjectResponse),
+  unstable_listProviders: requestSpec(AGENT_METHODS.providers_list, zListProvidersRequest),
+  unstable_setProvider: requestSpec(AGENT_METHODS.providers_set, zSetProviderRequest, emptyObjectResponse),
+  unstable_disableProvider: requestSpec(AGENT_METHODS.providers_disable, zDisableProviderRequest, emptyObjectResponse),
+  logout: requestSpec(AGENT_METHODS.logout, zLogoutRequest, emptyObjectResponse),
+  prompt: requestSpec(AGENT_METHODS.session_prompt, zPromptRequest),
+  unstable_startNes: requestSpec(AGENT_METHODS.nes_start, zStartNesRequest),
+  unstable_suggestNes: requestSpec(AGENT_METHODS.nes_suggest, zSuggestNesRequest),
+  unstable_closeNes: requestSpec(AGENT_METHODS.nes_close, zCloseNesRequest, emptyObjectResponse)
+};
+var agentNotificationSpecs = {
+  cancel: notificationSpec(AGENT_METHODS.session_cancel, zCancelNotification),
+  unstable_didOpenDocument: notificationSpec(AGENT_METHODS.document_did_open, zDidOpenDocumentNotification),
+  unstable_didChangeDocument: notificationSpec(AGENT_METHODS.document_did_change, zDidChangeDocumentNotification),
+  unstable_didCloseDocument: notificationSpec(AGENT_METHODS.document_did_close, zDidCloseDocumentNotification),
+  unstable_didSaveDocument: notificationSpec(AGENT_METHODS.document_did_save, zDidSaveDocumentNotification),
+  unstable_didFocusDocument: notificationSpec(AGENT_METHODS.document_did_focus, zDidFocusDocumentNotification),
+  unstable_acceptNes: notificationSpec(AGENT_METHODS.nes_accept, zAcceptNesNotification),
+  unstable_rejectNes: notificationSpec(AGENT_METHODS.nes_reject, zRejectNesNotification)
+};
+var clientRequestSpecs = {
+  requestPermission: requestSpec(CLIENT_METHODS.session_request_permission, zRequestPermissionRequest),
+  writeTextFile: requestSpec(CLIENT_METHODS.fs_write_text_file, zWriteTextFileRequest, emptyObjectResponse),
+  readTextFile: requestSpec(CLIENT_METHODS.fs_read_text_file, zReadTextFileRequest),
+  createTerminal: requestSpec(CLIENT_METHODS.terminal_create, zCreateTerminalRequest),
+  terminalOutput: requestSpec(CLIENT_METHODS.terminal_output, zTerminalOutputRequest),
+  releaseTerminal: requestSpec(CLIENT_METHODS.terminal_release, zReleaseTerminalRequest, emptyObjectResponse),
+  waitForTerminalExit: requestSpec(CLIENT_METHODS.terminal_wait_for_exit, zWaitForTerminalExitRequest),
+  killTerminal: requestSpec(CLIENT_METHODS.terminal_kill, zKillTerminalRequest, emptyObjectResponse),
+  createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, zCreateElicitationRequest)
+};
+var clientNotificationSpecs = {
+  sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, zSessionNotification),
+  completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
+};
+var agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
+var agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
+var clientRequestSpecsByMethod = specsByMethod(clientRequestSpecs);
+var clientNotificationSpecsByMethod = specsByMethod(clientNotificationSpecs);
+function agentRequestContext(params, client, signal, requestId) {
+  return {
+    params,
+    requestId,
+    signal,
+    client
+  };
+}
+function agentNotificationContext(params, client, signal) {
+  return {
+    params,
+    signal,
+    client
+  };
+}
+function clientRequestContext(params, agent, signal, requestId) {
+  return {
+    params,
+    requestId,
+    signal,
+    agent
+  };
+}
+function clientNotificationContext(params, agent, signal) {
+  return {
+    params,
+    signal,
+    agent
+  };
+}
+
+class SessionUpdateRouter {
+  activeSessions = new Map;
+  handleMessage(message) {
+    if (message.kind !== "notification" || message.method !== CLIENT_METHODS.session_update) {
+      return Handled.no(message);
+    }
+    const notification = zSessionNotification.parse(message.params);
+    const update = {
+      kind: "session_update",
+      notification,
+      update: notification.update
+    };
+    const activeSessions = this.activeSessions.get(notification.sessionId);
+    if (activeSessions && activeSessions.size > 0) {
+      for (const session of activeSessions) {
+        session.enqueue(update);
+      }
+    }
+    return Handled.no(message);
+  }
+  attach(response, updates) {
+    const sessions = this.activeSessions.get(response.sessionId) ?? new Set;
+    sessions.add(updates);
+    this.activeSessions.set(response.sessionId, sessions);
+    return new HandlerRegistration(() => {
+      sessions.delete(updates);
+      if (sessions.size === 0) {
+        this.activeSessions.delete(response.sessionId);
+      }
+    });
+  }
+}
+var sessionUpdateRouters = new WeakMap;
+function sessionUpdateRouter(cx) {
+  let router = sessionUpdateRouters.get(cx);
+  if (!router) {
+    router = new SessionUpdateRouter;
+    sessionUpdateRouters.set(cx, router);
+  }
+  return router;
+}
+function runConnectHandlers(connection, handlers) {
+  for (const handler of handlers) {
+    let result;
+    try {
+      result = handler(connection);
+    } catch (error) {
+      connection.close(error);
+      throw error;
+    }
+    Promise.resolve(result).catch((error) => {
+      connection.close(error);
+    });
+  }
+}
+var appBuilder = Symbol("appBuilder");
+var runAgentConnectHandlers = Symbol("runAgentConnectHandlers");
+var runClientConnectHandlers = Symbol("runClientConnectHandlers");
+var stableConnectionOptions = { allowBatches: false };
+class AgentApp {
+  builder = Connection.builder();
+  connectHandlers = [];
+  constructor(options = {}) {
+    if (options.name) {
+      this.builder.name(options.name);
+    }
+  }
+  [appBuilder]() {
+    return this.builder;
+  }
+  [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));
+  }
+  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);
+    state.rawConnection.closed.then(() => peerConnection.close());
+    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"
+    });
+  }
+  [appBuilder]() {
+    return this.builder;
+  }
+  [runClientConnectHandlers](connection) {
+    runConnectHandlers(connection, this.connectHandlers);
+  }
+  connect(target) {
+    return this.connectConnection(target).connection;
+  }
+  connectWith(target, op) {
+    const { rawConnection, connection } = this.connectConnection(target);
+    return rawConnection.runUntil(() => op(connection.agent));
+  }
+  onConnect(handler) {
+    this.connectHandlers.push(handler);
+    return this;
+  }
+  onRequest(method, handlerOrParams, handler) {
+    if (handler) {
+      return this.request({ method, params: handlerOrParams }, handler);
+    }
+    const spec = clientRequestSpecsByMethod[method];
+    if (!spec) {
+      throw new Error(`Unknown ACP request method '${method}'. Pass a params parser for custom methods.`);
+    }
+    return this.request(spec, handlerOrParams);
+  }
+  onNotification(method, handlerOrParams, handler) {
+    if (handler) {
+      return this.notification({ method, params: handlerOrParams }, handler);
+    }
+    const spec = clientNotificationSpecsByMethod[method];
+    if (!spec) {
+      throw new Error(`Unknown ACP notification method '${method}'. Pass a params parser for custom methods.`);
+    }
+    return this.notification(spec, handlerOrParams);
+  }
+  request(spec, handler) {
+    registerAppRequest(this.builder, spec, (params, cx, signal, requestId) => clientRequestContext(params, ClientContext.create(cx, requestId), signal, requestId), handler);
+    return this;
+  }
+  notification(spec, handler) {
+    registerAppNotification(this.builder, spec, (params, cx, signal) => clientNotificationContext(params, ClientContext.create(cx), signal), handler);
+    return this;
+  }
+  connectConnection(target) {
+    if (isStream(target)) {
+      const 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);
+    state.rawConnection.closed.then(() => peerConnection.close());
+    peerRawConnection.closed.then(() => state.connection.close());
+    try {
+      target[runAgentConnectHandlers](peerConnection);
+      this[runClientConnectHandlers](state.connection);
+    } catch (error) {
+      peerConnection.close(error);
+      state.connection.close(error);
+      throw error;
+    }
+    return state;
+  }
+  openStreamConnection(stream) {
+    const rawConnection = this.builder.connect(stream, stableConnectionOptions);
+    return {
+      rawConnection,
+      connection: clientConnection(rawConnection, this.connectHandlers)
+    };
+  }
+}
+var legacyAgentRequestMethods = new Set([
+  AGENT_METHODS.initialize,
+  AGENT_METHODS.authenticate,
+  AGENT_METHODS.providers_list,
+  AGENT_METHODS.providers_set,
+  AGENT_METHODS.providers_disable,
+  AGENT_METHODS.session_new,
+  AGENT_METHODS.session_load,
+  AGENT_METHODS.session_set_mode,
+  AGENT_METHODS.session_set_config_option,
+  AGENT_METHODS.session_prompt,
+  AGENT_METHODS.session_list,
+  AGENT_METHODS.session_delete,
+  AGENT_METHODS.session_fork,
+  AGENT_METHODS.session_resume,
+  AGENT_METHODS.session_close,
+  AGENT_METHODS.logout,
+  AGENT_METHODS.nes_start,
+  AGENT_METHODS.nes_suggest,
+  AGENT_METHODS.nes_close
+]);
+var legacyAgentNotificationMethods = new Set([
+  AGENT_METHODS.session_cancel,
+  AGENT_METHODS.nes_accept,
+  AGENT_METHODS.nes_reject,
+  AGENT_METHODS.document_did_open,
+  AGENT_METHODS.document_did_change,
+  AGENT_METHODS.document_did_close,
+  AGENT_METHODS.document_did_save,
+  AGENT_METHODS.document_did_focus
+]);
+var legacyClientRequestMethods = new Set([
+  CLIENT_METHODS.session_request_permission,
+  CLIENT_METHODS.fs_write_text_file,
+  CLIENT_METHODS.fs_read_text_file,
+  CLIENT_METHODS.terminal_create,
+  CLIENT_METHODS.terminal_output,
+  CLIENT_METHODS.terminal_release,
+  CLIENT_METHODS.terminal_wait_for_exit,
+  CLIENT_METHODS.terminal_kill,
+  CLIENT_METHODS.elicitation_create
+]);
+var legacyClientNotificationMethods = new Set([
+  CLIENT_METHODS.session_update,
+  CLIENT_METHODS.elicitation_complete
+]);
+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.createElicitation) {
+    app.onRequest(CLIENT_METHODS.elicitation_create, (ctx) => implementation.createElicitation(ctx.params));
+  }
+  if (implementation.completeElicitation) {
+    app.onNotification(CLIENT_METHODS.elicitation_complete, (ctx) => implementation.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 TerminalHandle {
+  id;
+  sessionId;
+  connection;
+  constructor(id, sessionId, conn) {
+    this.id = id;
+    this.sessionId = sessionId;
+    this.connection = conn;
+  }
+  static create(id, sessionId, conn) {
+    return new TerminalHandle(id, sessionId, conn);
+  }
+  currentOutput() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_output, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  waitForExit() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_wait_for_exit, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    });
+  }
+  kill() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_kill, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    }, emptyObjectResponse);
+  }
+  release() {
+    return this.connection.sendRequest(CLIENT_METHODS.terminal_release, {
+      sessionId: this.sessionId,
+      terminalId: this.id
+    }, emptyObjectResponse);
+  }
+  async[Symbol.asyncDispose]() {
+    await this.release();
+  }
+}
+
+class ClientSideConnection {
+  connection;
+  constructor(toClient, stream) {
+    this.connection = legacyClientApp(toClient(this))[appBuilder]().connect(stream, stableConnectionOptions);
+  }
+  initialize(params) {
+    return this.connection.sendRequest(AGENT_METHODS.initialize, params);
+  }
+  newSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_new, params);
+  }
+  loadSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_load, params, emptyObjectResponse);
+  }
+  unstable_forkSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_fork, params);
+  }
+  listSessions(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_list, params);
+  }
+  deleteSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_delete, params, emptyObjectResponse);
+  }
+  resumeSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_resume, params);
+  }
+  closeSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_close, params, emptyObjectResponse);
+  }
+  setSessionMode(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_set_mode, params, emptyObjectResponse);
+  }
+  setSessionConfigOption(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_set_config_option, params);
+  }
+  authenticate(params) {
+    return this.connection.sendRequest(AGENT_METHODS.authenticate, params, emptyObjectResponse);
+  }
+  unstable_listProviders(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_list, params);
+  }
+  unstable_setProvider(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_set, params, emptyObjectResponse);
+  }
+  unstable_disableProvider(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_disable, params, emptyObjectResponse);
+  }
+  logout(params) {
+    return this.connection.sendRequest(AGENT_METHODS.logout, params, emptyObjectResponse);
+  }
+  prompt(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_prompt, params);
+  }
+  cancel(params) {
+    return this.connection.sendNotification(AGENT_METHODS.session_cancel, params);
+  }
+  unstable_startNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_start, params);
+  }
+  unstable_suggestNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_suggest, params);
+  }
+  unstable_closeNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_close, params, emptyObjectResponse);
+  }
+  unstable_didOpenDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_open, params);
+  }
+  unstable_didChangeDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_change, params);
+  }
+  unstable_didCloseDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_close, params);
+  }
+  unstable_didSaveDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_save, params);
+  }
+  unstable_didFocusDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_focus, params);
+  }
+  unstable_acceptNes(params) {
+    return this.connection.sendNotification(AGENT_METHODS.nes_accept, params);
+  }
+  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);
+  }
+  extMethod(method, params) {
+    return this.request(method, params);
+  }
+  extNotification(method, params) {
+    return this.notify(method, params);
+  }
+  get signal() {
+    return this.connection.signal;
+  }
+  get closed() {
+    return this.connection.closed;
+  }
+}
+
+// src/providers/acp-adapter.ts
+init_package();
+init_secret_scrubber();
+
+// src/providers/acp-swarm-events.ts
+function contentToText(content) {
+  if (content.type === "text")
+    return content.text;
+  return JSON.stringify(content);
+}
+function toolName(update) {
+  return update.title ?? update.kind ?? "tool";
+}
+function toolResult(update) {
+  return {
+    status: update.status,
+    content: update.content,
+    rawOutput: update.rawOutput,
+    locations: update.locations
+  };
+}
+function translateAcpSessionUpdate(update) {
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      return [{ type: "message", role: "assistant", content: contentToText(update.content) }];
+    case "user_message_chunk":
+      return [{ type: "message", role: "user", content: contentToText(update.content) }];
+    case "agent_thought_chunk":
+      return [
+        {
+          type: "custom",
+          name: "acp_agent_thought_chunk",
+          data: { content: update.content, messageId: update.messageId ?? null }
+        }
+      ];
+    case "tool_call":
+      return [
+        {
+          type: "tool_start",
+          toolCallId: update.toolCallId,
+          toolName: toolName(update),
+          args: update.rawInput ?? update.content ?? null
+        }
+      ];
+    case "tool_call_update": {
+      if (update.status === "completed" || update.status === "failed") {
+        return [
+          {
+            type: "tool_end",
+            toolCallId: update.toolCallId,
+            toolName: toolName(update),
+            result: toolResult(update)
+          }
+        ];
+      }
+      return [
+        {
+          type: "progress",
+          message: `ACP tool ${update.toolCallId}${update.status ? ` ${update.status}` : " updated"}`
+        },
+        {
+          type: "custom",
+          name: "acp_tool_call_update",
+          data: update
+        }
+      ];
+    }
+    case "current_mode_update":
+      return [{ type: "custom", name: "acp_current_mode_update", data: update }];
+    case "plan":
+      return [{ type: "custom", name: "acp_plan", data: update }];
+    case "available_commands_update":
+      return [{ type: "custom", name: "acp_available_commands_update", data: update }];
+    case "config_option_update":
+      return [{ type: "custom", name: "acp_config_option_update", data: update }];
+    case "session_info_update":
+      return [{ type: "custom", name: "acp_session_info_update", data: update }];
+    case "usage_update":
+      return [
+        {
+          type: "context_usage",
+          contextUsedTokens: update.used,
+          contextTotalTokens: update.size,
+          contextPercent: update.size > 0 ? update.used / update.size : null,
+          outputTokens: null,
+          contextFormula: "harness-reported"
+        }
+      ];
+    default:
+      return [
+        {
+          type: "custom",
+          name: `acp_${update.sessionUpdate}`,
+          data: update
+        }
+      ];
+  }
+}
+function translateAcpSessionNotification(notification) {
+  return translateAcpSessionUpdate(notification.update);
+}
+
+// src/providers/acp-targets.ts
+import { join } from "node:path";
+
+class AcpTargetResolutionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AcpTargetResolutionError";
+  }
+}
+var BASE_ENV_KEYS = [
+  "PATH",
+  "HOME",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "SHELL",
+  "USER",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "BUN_INSTALL",
+  "NODE_PATH"
+];
+function readEnv(config, key) {
+  return config.env?.[key] ?? process.env[key];
+}
+function baseTargetEnv(config) {
+  const env = {};
+  for (const key of BASE_ENV_KEYS) {
+    const value = readEnv(config, key);
+    if (value)
+      env[key] = value;
+  }
+  return env;
+}
+function parseCommand(command, args) {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    throw new AcpTargetResolutionError("ACP target command is empty. Set ACP_TARGET_COMMAND to an ACP-compatible executable.");
+  }
+  if (args?.trim()) {
+    try {
+      const parsed = JSON.parse(args);
+      if (Array.isArray(parsed) && parsed.every((part) => typeof part === "string")) {
+        return [trimmed, ...parsed];
+      }
+    } catch {}
+    return [trimmed, ...args.trim().split(/\s+/).filter(Boolean)];
+  }
+  return trimmed.split(/\s+/).filter(Boolean);
+}
+var customTargetProfile = {
+  target: "custom",
+  command(config) {
+    const command = readEnv(config, "ACP_TARGET_COMMAND") ?? readEnv(config, "ACP_COMMAND");
+    if (!command) {
+      throw new AcpTargetResolutionError("No ACP target configured. Set ACP_TARGET_COMMAND to an ACP-compatible executable before using HARNESS_PROVIDER=acp.");
+    }
+    return parseCommand(command, readEnv(config, "ACP_TARGET_ARGS"));
+  },
+  env(config) {
+    return baseTargetEnv(config);
+  },
+  async writeSystemPromptArtifact(config) {
+    const relativePath = readEnv(config, "ACP_SYSTEM_PROMPT_PATH");
+    if (!relativePath)
+      return;
+    const targetPath = relativePath.startsWith("/") ? relativePath : join(config.cwd, relativePath);
+    await Bun.write(targetPath, config.systemPrompt ?? "");
+  }
+};
+function resolveAcpTarget(config) {
+  const target = readEnv(config, "ACP_TARGET") ?? "custom";
+  switch (target) {
+    case "custom":
+      return customTargetProfile;
+    default:
+      throw new AcpTargetResolutionError(`Unsupported ACP target "${target}". Only the generic "custom" target exists today — leave ACP_TARGET unset and point ACP_TARGET_COMMAND at your ACP agent.`);
+  }
+}
+
+// src/providers/acp-adapter.ts
+class SwarmAcpClient {
+  emit;
+  constructor(emit) {
+    this.emit = emit;
+  }
+  async requestPermission(params) {
+    const selected = params.options.find((option) => option.kind === "allow_always") ?? params.options.find((option) => option.kind === "allow_once") ?? params.options[0];
+    if (!selected)
+      return { outcome: { outcome: "cancelled" } };
+    return { outcome: { outcome: "selected", optionId: selected.optionId } };
+  }
+  async sessionUpdate(params) {
+    for (const event of translateAcpSessionNotification(params)) {
+      this.emit(event);
+    }
+  }
+}
+
+class ACPSession {
+  connection;
+  process;
+  config;
+  sessionId;
+  listeners = new Set;
+  pendingEvents = [];
+  startedAt = Date.now();
+  completed = false;
+  aborted = false;
+  output = "";
+  completionPromise;
+  completionResolve;
+  constructor(connection, process2, config, sessionId) {
+    this.connection = connection;
+    this.process = process2;
+    this.config = config;
+    this.sessionId = sessionId;
+    this.completionPromise = new Promise((resolve) => {
+      this.completionResolve = resolve;
+    });
+    this.consumeStderr();
+    this.emit({ type: "session_init", sessionId, provider: "acp" });
+    this.runPrompt();
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    for (const event of this.pendingEvents.splice(0)) {
+      listener(event);
+    }
+  }
+  waitForCompletion() {
+    return this.completionPromise;
+  }
+  async abort() {
+    if (this.aborted)
+      return;
+    this.aborted = true;
+    try {
+      await this.connection.cancel({ sessionId: this.sessionId });
+    } catch (err) {
+      this.emit({
+        type: "error",
+        message: scrubSecrets(`ACP session/cancel failed: ${formatError(err)}`),
+        category: "abort"
+      });
+    }
+    this.process.kill();
+    this.finish({
+      exitCode: 1,
+      sessionId: this.sessionId,
+      isError: true,
+      failureReason: "aborted"
+    });
+  }
+  emitFromAcp(event) {
+    this.emit(event);
+  }
+  emit(event) {
+    if (event.type === "message" && event.role === "assistant") {
+      this.output += event.content;
+    }
+    if (this.listeners.size === 0) {
+      this.pendingEvents.push(event);
+      return;
+    }
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  async runPrompt() {
+    try {
+      const response = await this.connection.prompt({
+        sessionId: this.sessionId,
+        prompt: [{ type: "text", text: this.config.prompt }]
+      });
+      const isError = response.stopReason === "refusal" || response.stopReason === "cancelled";
+      const cost = this.buildCostData(isError);
+      const result = {
+        exitCode: isError ? 1 : 0,
+        sessionId: this.sessionId,
+        cost,
+        output: this.output,
+        isError,
+        failureReason: isError ? `ACP prompt stopped with ${response.stopReason}` : undefined
+      };
+      this.emit({ type: "result", cost, output: this.output, isError });
+      this.finish(result);
+    } catch (err) {
+      const message = scrubSecrets(formatError(err));
+      this.emit({ type: "error", message, category: "protocol" });
+      this.finish({
+        exitCode: 1,
+        sessionId: this.sessionId,
+        isError: true,
+        failureReason: `ACP prompt failed: ${message}`
+      });
+    } finally {
+      this.process.kill();
+    }
+  }
+  async consumeStderr() {
+    const stderr = this.process.stderr;
+    if (!stderr)
+      return;
+    const reader = stderr.getReader();
+    const decoder = new TextDecoder;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value.length > 0) {
+          this.emit({ type: "raw_stderr", content: scrubSecrets(decoder.decode(value)) });
+        }
+      }
+    } catch {}
+  }
+  buildCostData(isError) {
+    return {
+      sessionId: this.sessionId,
+      taskId: this.config.taskId,
+      agentId: this.config.agentId,
+      totalCostUsd: 0,
+      durationMs: Date.now() - this.startedAt,
+      numTurns: 1,
+      model: this.config.model,
+      isError,
+      provider: "acp"
+    };
+  }
+  finish(result) {
+    if (this.completed)
+      return;
+    this.completed = true;
+    this.completionResolve(result);
+  }
+}
+
+class ACPAdapter {
+  name = "acp";
+  traits = {
+    hasMcp: true,
+    hasLocalEnvironment: true
+  };
+  async createSession(config) {
+    const target = resolveAcpTarget(config);
+    await target.writeSystemPromptArtifact(config);
+    const command = target.command(config);
+    const proc = Bun.spawn(command, {
+      cwd: config.cwd,
+      env: target.env(config),
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    let session = null;
+    const client2 = new SwarmAcpClient((event) => session?.emitFromAcp(event));
+    const stream = ndJsonStream2(fileSinkWritableStream(proc.stdin), proc.stdout);
+    const connection = new ClientSideConnection(() => client2, stream);
+    try {
+      await connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientInfo: { name: "agent-swarm", version: package_default.version },
+        clientCapabilities: {}
+      });
+      const installedServers = await fetchInstalledMcpServers(config.apiUrl, config.apiKey, config.agentId, "claude");
+      const newSession = await connection.newSession({
+        cwd: config.cwd,
+        mcpServers: [
+          {
+            type: "http",
+            name: "swarm",
+            url: `${config.apiUrl.replace(/\/+$/, "")}/mcp`,
+            headers: [
+              { name: "Authorization", value: `Bearer ${config.apiKey}` },
+              { name: "X-Agent-ID", value: config.agentId },
+              { name: "X-Source-Task-Id", value: config.taskId }
+            ]
+          },
+          ...toAcpMcpServers(installedServers)
+        ]
+      });
+      session = new ACPSession(connection, proc, config, newSession.sessionId);
+      return session;
+    } catch (err) {
+      proc.kill();
+      throw new Error(`ACP target failed during startup: ${scrubSecrets(formatError(err))}`);
+    }
+  }
+  async canResume(_sessionId) {
+    return false;
+  }
+  formatCommand(commandName) {
+    return `/${commandName}`;
+  }
+}
+function toAcpMcpServers(installed) {
+  if (!installed)
+    return [];
+  const servers = [];
+  for (const [name, entry] of Object.entries(installed)) {
+    if (typeof entry.command === "string") {
+      const env = entry.env ?? {};
+      servers.push({
+        name,
+        command: entry.command,
+        args: Array.isArray(entry.args) ? entry.args : [],
+        env: Object.entries(env).map(([key, value]) => ({ name: key, value }))
+      });
+      continue;
+    }
+    if (typeof entry.url === "string") {
+      const headers = entry.headers ?? {};
+      servers.push({
+        type: entry.type === "sse" ? "sse" : "http",
+        name,
+        url: entry.url,
+        headers: Object.entries(headers).map(([key, value]) => ({ name: key, value }))
+      });
+      continue;
+    }
+    console.warn(`\x1B[33m[acp]\x1B[0m Skipping installed MCP server "${name}": no command or url in resolved config`);
+  }
+  return servers;
+}
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function fileSinkWritableStream(sink) {
+  return new WritableStream({
+    write(chunk) {
+      sink.write(chunk);
+      sink.flush();
+    },
+    close() {
+      sink.end();
+    },
+    abort() {
+      sink.end();
+    }
+  });
+}
+export {
+  ACPAdapter,
+  toAcpMcpServers
+};