lody 0.72.0 → 0.74.0

package/dist/claude-acp.js

@@ -27,14 +27,14 @@ import path__default from "node:path";
 import * as os$1 from "node:os";
 import os__default from "node:os";
 import process$1 from "node:process";
-import { c as array, e as unknown, N as NEVER, u as union, n as number, s as string, o as object, r as record, i as int, l as literal, b as boolean, h as intersection, j as url } from "./chunks/schemas-CDSDDVK-.js";
+import { a as CreateElicitationResponse, n as ndJsonStream, b as agent$1, m as methods, R as RequestError, p as packageJson } from "./chunks/package-C4jJQVT8.js";
 import { execFile as execFile$1 } from "node:child_process";
 import { randomUUID as randomUUID$1 } from "node:crypto";
 import * as fs$2 from "node:fs/promises";
 import { promisify as promisify$1 } from "node:util";
-import { p as packageJson } from "./chunks/package-CkkAIS-_.js";
 import * as fs$1 from "node:fs";
-import { WritableStream as WritableStream$1, ReadableStream as ReadableStream$1 } from "node:stream/web";
+import { WritableStream, ReadableStream as ReadableStream$1 } from "node:stream/web";
+import "./chunks/schemas-BDpQ67Nq.js";
 (async () => {
   var wW = Object.create;
   var { getPrototypeOf: TW, defineProperty: $y, getOwnPropertyNames: AW } = Object;
@@ -52928,3446 +52928,6 @@ new Anthropic({ apiKey, dangerouslyAllowBrowser: true });
     }
     return null;
   }
-  const AGENT_METHODS = {
-    initialize: "initialize",
-    authenticate: "authenticate",
-    providers_list: "providers/list",
-    providers_set: "providers/set",
-    providers_disable: "providers/disable",
-    session_new: "session/new",
-    session_load: "session/load",
-    session_set_mode: "session/set_mode",
-    session_set_config_option: "session/set_config_option",
-    session_prompt: "session/prompt",
-    session_cancel: "session/cancel",
-    session_list: "session/list",
-    session_delete: "session/delete",
-    session_fork: "session/fork",
-    session_resume: "session/resume",
-    session_close: "session/close",
-    logout: "logout",
-    nes_start: "nes/start",
-    nes_suggest: "nes/suggest",
-    nes_accept: "nes/accept",
-    nes_reject: "nes/reject",
-    nes_close: "nes/close",
-    document_did_open: "document/didOpen",
-    document_did_change: "document/didChange",
-    document_did_close: "document/didClose",
-    document_did_save: "document/didSave",
-    document_did_focus: "document/didFocus"
-  };
-  const CLIENT_METHODS = {
-    session_request_permission: "session/request_permission",
-    session_update: "session/update",
-    fs_write_text_file: "fs/write_text_file",
-    fs_read_text_file: "fs/read_text_file",
-    terminal_create: "terminal/create",
-    terminal_output: "terminal/output",
-    terminal_release: "terminal/release",
-    terminal_wait_for_exit: "terminal/wait_for_exit",
-    terminal_kill: "terminal/kill",
-    elicitation_create: "elicitation/create",
-    elicitation_complete: "elicitation/complete"
-  };
-  const skippedItem = Symbol("skippedItem");
-  function defaultOnError(schema, fallback) {
-    return schema.catch(fallback);
-  }
-  function requiredDefaultOnError(schema, fallback) {
-    const schemaWithCatch = schema.catch(fallback);
-    return unknown().transform((value, context) => {
-      if (value !== void 0) return schemaWithCatch.parse(value);
-      context.addIssue({
-        code: "custom",
-        message: "Required value is missing"
-      });
-      return NEVER;
-    });
-  }
-  function stringTag(value, key) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-      return void 0;
-    }
-    const tag = value[key];
-    return typeof tag === "string" ? tag : void 0;
-  }
-  function excludeKnownTags(schema, key, knownTags) {
-    return schema.superRefine((value, context) => {
-      const tag = stringTag(value, key);
-      if (tag !== void 0 && knownTags.includes(tag)) {
-        context.addIssue({
-          code: "custom",
-          path: [
-            key
-          ],
-          message: `${key} ${JSON.stringify(tag)} is reserved by a known variant, but the value does not match that variant's schema`
-        });
-      }
-    });
-  }
-  function preserveCustomPayload(schema, key, knownTags) {
-    return unknown().transform((value, context) => {
-      const result = schema.safeParse(value);
-      if (!result.success) {
-        for (const issue of result.error.issues) {
-          context.addIssue({
-            ...issue,
-            input: value
-          });
-        }
-        return NEVER;
-      }
-      const output = result.data;
-      const tag = stringTag(value, key);
-      if (tag !== void 0 && !knownTags.includes(tag)) {
-        const raw = value;
-        for (const [property, rawValue] of Object.entries(raw)) {
-          if (property === "__proto__") continue;
-          if (!Object.hasOwn(output, property)) output[property] = rawValue;
-        }
-      }
-      return output;
-    });
-  }
-  function vecSkipError(itemSchema) {
-    return array(itemSchema.catch(skippedItem)).transform((items) => items.filter((item) => item !== skippedItem));
-  }
-  const zRequestId = union([
-    number(),
-    string()
-  ]).nullable();
-  const zSessionId = string();
-  const zWriteTextFileRequest = object({
-    sessionId: zSessionId,
-    path: string(),
-    content: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zReadTextFileRequest = object({
-    sessionId: zSessionId,
-    path: string(),
-    line: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    limit: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zToolCallId = string();
-  const zToolKind = union([
-    literal("read"),
-    literal("edit"),
-    literal("delete"),
-    literal("move"),
-    literal("search"),
-    literal("execute"),
-    literal("think"),
-    literal("fetch"),
-    literal("switch_mode"),
-    literal("other")
-  ]);
-  const zToolCallStatus = union([
-    literal("pending"),
-    literal("in_progress"),
-    literal("completed"),
-    literal("failed")
-  ]);
-  const zRole = union([
-    literal("assistant"),
-    literal("user")
-  ]);
-  const zAnnotations = object({
-    audience: defaultOnError(vecSkipError(zRole).nullish(), () => void 0),
-    lastModified: defaultOnError(string().nullish(), () => void 0),
-    priority: defaultOnError(number().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTextContent = object({
-    annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-    text: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zImageContent = object({
-    annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-    data: string(),
-    mimeType: string(),
-    uri: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAudioContent = object({
-    annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-    data: string(),
-    mimeType: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zResourceLink = object({
-    annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-    description: defaultOnError(string().nullish(), () => void 0),
-    mimeType: defaultOnError(string().nullish(), () => void 0),
-    name: string(),
-    size: defaultOnError(number().nullish(), () => void 0),
-    title: defaultOnError(string().nullish(), () => void 0),
-    uri: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTextResourceContents = object({
-    mimeType: defaultOnError(string().nullish(), () => void 0),
-    text: string(),
-    uri: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zBlobResourceContents = object({
-    blob: string(),
-    mimeType: defaultOnError(string().nullish(), () => void 0),
-    uri: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zEmbeddedResourceResource = union([
-    zTextResourceContents,
-    zBlobResourceContents
-  ]);
-  const zEmbeddedResource = object({
-    annotations: defaultOnError(zAnnotations.nullish(), () => void 0),
-    resource: zEmbeddedResourceResource,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zContentBlock = union([
-    zTextContent.and(object({
-      type: literal("text")
-    })),
-    zImageContent.and(object({
-      type: literal("image")
-    })),
-    zAudioContent.and(object({
-      type: literal("audio")
-    })),
-    zResourceLink.and(object({
-      type: literal("resource_link")
-    })),
-    zEmbeddedResource.and(object({
-      type: literal("resource")
-    }))
-  ]);
-  const zContent = object({
-    content: zContentBlock,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDiff = object({
-    path: string(),
-    oldText: defaultOnError(string().nullish(), () => void 0),
-    newText: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTerminalId = string();
-  const zTerminal = object({
-    terminalId: zTerminalId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zToolCallContent = union([
-    zContent.and(object({
-      type: literal("content")
-    })),
-    zDiff.and(object({
-      type: literal("diff")
-    })),
-    zTerminal.and(object({
-      type: literal("terminal")
-    }))
-  ]);
-  const zToolCallLocation = object({
-    path: string(),
-    line: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zToolCallUpdate = object({
-    toolCallId: zToolCallId,
-    kind: defaultOnError(zToolKind.nullish(), () => void 0),
-    status: defaultOnError(zToolCallStatus.nullish(), () => void 0),
-    title: defaultOnError(string().nullish(), () => void 0),
-    name: defaultOnError(string().nullish(), () => void 0),
-    content: defaultOnError(vecSkipError(zToolCallContent).nullish(), () => void 0),
-    locations: defaultOnError(vecSkipError(zToolCallLocation).nullish(), () => void 0),
-    rawInput: defaultOnError(unknown().optional(), () => void 0),
-    rawOutput: defaultOnError(unknown().optional(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPermissionOptionId = string();
-  const zPermissionOptionKind = union([
-    literal("allow_once"),
-    literal("allow_always"),
-    literal("reject_once"),
-    literal("reject_always")
-  ]);
-  const zPermissionOption = object({
-    optionId: zPermissionOptionId,
-    name: string(),
-    kind: zPermissionOptionKind,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zRequestPermissionRequest = object({
-    sessionId: zSessionId,
-    toolCall: zToolCallUpdate,
-    options: array(zPermissionOption),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zEnvVariable = object({
-    name: string(),
-    value: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCreateTerminalRequest = object({
-    sessionId: zSessionId,
-    command: string(),
-    args: defaultOnError(vecSkipError(string()).optional(), () => []),
-    env: defaultOnError(vecSkipError(zEnvVariable).optional(), () => []),
-    cwd: defaultOnError(string().nullish(), () => void 0),
-    outputByteLimit: defaultOnError(number().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTerminalOutputRequest = object({
-    sessionId: zSessionId,
-    terminalId: zTerminalId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zReleaseTerminalRequest = object({
-    sessionId: zSessionId,
-    terminalId: zTerminalId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zWaitForTerminalExitRequest = object({
-    sessionId: zSessionId,
-    terminalId: zTerminalId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zKillTerminalRequest = object({
-    sessionId: zSessionId,
-    terminalId: zTerminalId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationSessionScope = object({
-    sessionId: zSessionId,
-    toolCallId: defaultOnError(zToolCallId.nullish(), () => void 0)
-  });
-  const zElicitationRequestScope = object({
-    requestId: zRequestId
-  });
-  const zElicitationSchemaType = literal("object");
-  const zStringFormat = union([
-    literal("email"),
-    literal("uri"),
-    literal("date"),
-    literal("date-time")
-  ]);
-  const zEnumOption = object({
-    const: string(),
-    title: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zStringPropertySchema = object({
-    title: defaultOnError(string().nullish(), () => void 0),
-    description: defaultOnError(string().nullish(), () => void 0),
-    minLength: int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(),
-    maxLength: int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(),
-    pattern: string().nullish(),
-    format: zStringFormat.nullish(),
-    default: defaultOnError(string().nullish(), () => void 0),
-    enum: array(string()).nullish(),
-    oneOf: array(zEnumOption).nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNumberPropertySchema = object({
-    title: defaultOnError(string().nullish(), () => void 0),
-    description: defaultOnError(string().nullish(), () => void 0),
-    minimum: number().nullish(),
-    maximum: number().nullish(),
-    default: defaultOnError(number().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zIntegerPropertySchema = object({
-    title: defaultOnError(string().nullish(), () => void 0),
-    description: defaultOnError(string().nullish(), () => void 0),
-    minimum: number().nullish(),
-    maximum: number().nullish(),
-    default: defaultOnError(number().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zBooleanPropertySchema = object({
-    title: defaultOnError(string().nullish(), () => void 0),
-    description: defaultOnError(string().nullish(), () => void 0),
-    default: defaultOnError(boolean().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zStringMultiSelectItems = object({
-    enum: array(string()),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTitledMultiSelectItems = object({
-    anyOf: array(zEnumOption),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMultiSelectItems = preserveCustomPayload(union([
-    zStringMultiSelectItems.and(object({
-      type: literal("string")
-    })),
-    excludeKnownTags(object({
-      type: string()
-    }), "type", [
-      "string"
-    ]),
-    zTitledMultiSelectItems
-  ]), "type", [
-    "string"
-  ]);
-  const zMultiSelectPropertySchema = object({
-    title: defaultOnError(string().nullish(), () => void 0),
-    description: defaultOnError(string().nullish(), () => void 0),
-    minItems: number().nullish(),
-    maxItems: number().nullish(),
-    items: zMultiSelectItems,
-    default: defaultOnError(vecSkipError(string()).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationPropertySchema = preserveCustomPayload(union([
-    zStringPropertySchema.and(object({
-      type: literal("string")
-    })),
-    zNumberPropertySchema.and(object({
-      type: literal("number")
-    })),
-    zIntegerPropertySchema.and(object({
-      type: literal("integer")
-    })),
-    zBooleanPropertySchema.and(object({
-      type: literal("boolean")
-    })),
-    zMultiSelectPropertySchema.and(object({
-      type: literal("array")
-    })),
-    excludeKnownTags(object({
-      type: string()
-    }), "type", [
-      "array",
-      "boolean",
-      "integer",
-      "number",
-      "string"
-    ])
-  ]), "type", [
-    "array",
-    "boolean",
-    "integer",
-    "number",
-    "string"
-  ]);
-  const zElicitationSchema = object({
-    type: defaultOnError(zElicitationSchemaType.optional().default("object"), () => "object"),
-    title: defaultOnError(string().nullish(), () => void 0),
-    properties: record(string(), zElicitationPropertySchema).optional().default({}),
-    required: array(string()).nullish(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationFormMode = intersection(union([
-    zElicitationSessionScope,
-    zElicitationRequestScope
-  ]), object({
-    requestedSchema: zElicitationSchema
-  }));
-  const zElicitationId = string();
-  const zElicitationUrlMode = intersection(union([
-    zElicitationSessionScope,
-    zElicitationRequestScope
-  ]), object({
-    elicitationId: zElicitationId,
-    url: url()
-  }));
-  const zCreateElicitationRequest = preserveCustomPayload(intersection(union([
-    zElicitationFormMode.and(object({
-      mode: literal("form")
-    })),
-    zElicitationUrlMode.and(object({
-      mode: literal("url")
-    })),
-    excludeKnownTags(intersection(union([
-      zElicitationSessionScope,
-      zElicitationRequestScope
-    ]), object({
-      mode: string()
-    })), "mode", [
-      "form",
-      "url"
-    ])
-  ]), object({
-    message: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  })), "mode", [
-    "form",
-    "url"
-  ]);
-  const zMcpServerAcpId = string();
-  const zConnectMcpRequest = object({
-    serverId: zMcpServerAcpId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpConnectionId = string();
-  const zMessageMcpRequest = object({
-    connectionId: zMcpConnectionId,
-    method: string(),
-    params: record(string(), unknown()).nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDisconnectMcpRequest = object({
-    connectionId: zMcpConnectionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zExtRequest = unknown();
-  object({
-    id: zRequestId,
-    method: string(),
-    params: union([
-      zWriteTextFileRequest,
-      zReadTextFileRequest,
-      zRequestPermissionRequest,
-      zCreateTerminalRequest,
-      zTerminalOutputRequest,
-      zReleaseTerminalRequest,
-      zWaitForTerminalExitRequest,
-      zKillTerminalRequest,
-      zCreateElicitationRequest,
-      zConnectMcpRequest,
-      zMessageMcpRequest,
-      zDisconnectMcpRequest,
-      zExtRequest
-    ]).nullish()
-  });
-  const zProtocolVersion = int().gte(0).lte(65535);
-  const zPromptCapabilities = object({
-    image: defaultOnError(boolean().optional().default(false), () => false),
-    audio: defaultOnError(boolean().optional().default(false), () => false),
-    embeddedContext: defaultOnError(boolean().optional().default(false), () => false),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpCapabilities = object({
-    http: defaultOnError(boolean().optional().default(false), () => false),
-    sse: defaultOnError(boolean().optional().default(false), () => false),
-    acp: defaultOnError(boolean().optional().default(false), () => false),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionListCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionDeleteCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionAdditionalDirectoriesCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionForkCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionResumeCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionCloseCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionCapabilities = object({
-    list: defaultOnError(zSessionListCapabilities.nullish(), () => void 0),
-    delete: defaultOnError(zSessionDeleteCapabilities.nullish(), () => void 0),
-    additionalDirectories: defaultOnError(zSessionAdditionalDirectoriesCapabilities.nullish(), () => void 0),
-    fork: defaultOnError(zSessionForkCapabilities.nullish(), () => void 0),
-    resume: defaultOnError(zSessionResumeCapabilities.nullish(), () => void 0),
-    close: defaultOnError(zSessionCloseCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zLogoutCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAgentAuthCapabilities = object({
-    logout: defaultOnError(zLogoutCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zProvidersCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDocumentDidOpenCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTextDocumentSyncKind = union([
-    literal("full"),
-    literal("incremental")
-  ]);
-  const zNesDocumentDidChangeCapabilities = object({
-    syncKind: zTextDocumentSyncKind,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDocumentDidCloseCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDocumentDidSaveCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDocumentDidFocusCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDocumentEventCapabilities = object({
-    didOpen: defaultOnError(zNesDocumentDidOpenCapabilities.nullish(), () => void 0),
-    didChange: defaultOnError(zNesDocumentDidChangeCapabilities.nullish(), () => void 0),
-    didClose: defaultOnError(zNesDocumentDidCloseCapabilities.nullish(), () => void 0),
-    didSave: defaultOnError(zNesDocumentDidSaveCapabilities.nullish(), () => void 0),
-    didFocus: defaultOnError(zNesDocumentDidFocusCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesEventCapabilities = object({
-    document: defaultOnError(zNesDocumentEventCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRecentFilesCapabilities = object({
-    maxCount: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRelatedSnippetsCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesEditHistoryCapabilities = object({
-    maxCount: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesUserActionsCapabilities = object({
-    maxCount: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesOpenFilesCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDiagnosticsCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesContextCapabilities = object({
-    recentFiles: defaultOnError(zNesRecentFilesCapabilities.nullish(), () => void 0),
-    relatedSnippets: defaultOnError(zNesRelatedSnippetsCapabilities.nullish(), () => void 0),
-    editHistory: defaultOnError(zNesEditHistoryCapabilities.nullish(), () => void 0),
-    userActions: defaultOnError(zNesUserActionsCapabilities.nullish(), () => void 0),
-    openFiles: defaultOnError(zNesOpenFilesCapabilities.nullish(), () => void 0),
-    diagnostics: defaultOnError(zNesDiagnosticsCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesCapabilities = object({
-    events: defaultOnError(zNesEventCapabilities.nullish(), () => void 0),
-    context: defaultOnError(zNesContextCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPositionEncodingKind = union([
-    literal("utf-16"),
-    literal("utf-32"),
-    literal("utf-8")
-  ]);
-  const zAgentCapabilities = object({
-    loadSession: defaultOnError(boolean().optional().default(false), () => false),
-    promptCapabilities: defaultOnError(zPromptCapabilities.optional().default({
-      image: false,
-      audio: false,
-      embeddedContext: false
-    }), () => ({
-      image: false,
-      audio: false,
-      embeddedContext: false
-    })),
-    mcpCapabilities: defaultOnError(zMcpCapabilities.optional().default({
-      http: false,
-      sse: false,
-      acp: false
-    }), () => ({
-      http: false,
-      sse: false,
-      acp: false
-    })),
-    sessionCapabilities: defaultOnError(zSessionCapabilities.optional().default({}), () => ({})),
-    auth: defaultOnError(zAgentAuthCapabilities.optional().default({}), () => ({})),
-    providers: defaultOnError(zProvidersCapabilities.nullish(), () => void 0),
-    nes: defaultOnError(zNesCapabilities.nullish(), () => void 0),
-    positionEncoding: defaultOnError(zPositionEncodingKind.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthMethodId = string();
-  const zAuthEnvVar = object({
-    name: string(),
-    label: defaultOnError(string().nullish(), () => void 0),
-    secret: defaultOnError(boolean().optional().default(true), () => true),
-    optional: defaultOnError(boolean().optional().default(false), () => false),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthMethodEnvVar = object({
-    id: zAuthMethodId,
-    name: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    vars: requiredDefaultOnError(vecSkipError(zAuthEnvVar), () => []),
-    link: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthMethodTerminal = object({
-    id: zAuthMethodId,
-    name: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    args: defaultOnError(vecSkipError(string()).optional(), () => []),
-    env: defaultOnError(record(string(), string()).optional(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthMethodAgent = object({
-    id: zAuthMethodId,
-    name: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthMethod = union([
-    zAuthMethodEnvVar.and(object({
-      type: literal("env_var")
-    })),
-    zAuthMethodTerminal.and(object({
-      type: literal("terminal")
-    })),
-    zAuthMethodAgent
-  ]);
-  const zImplementation = object({
-    name: string(),
-    title: defaultOnError(string().nullish(), () => void 0),
-    version: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zInitializeResponse = object({
-    protocolVersion: zProtocolVersion,
-    agentCapabilities: defaultOnError(zAgentCapabilities.optional().default({
-      loadSession: false,
-      promptCapabilities: {
-        image: false,
-        audio: false,
-        embeddedContext: false
-      },
-      mcpCapabilities: {
-        http: false,
-        sse: false,
-        acp: false
-      },
-      sessionCapabilities: {},
-      auth: {}
-    }), () => ({
-      loadSession: false,
-      promptCapabilities: {
-        image: false,
-        audio: false,
-        embeddedContext: false
-      },
-      mcpCapabilities: {
-        http: false,
-        sse: false,
-        acp: false
-      },
-      sessionCapabilities: {},
-      auth: {}
-    })),
-    authMethods: defaultOnError(vecSkipError(zAuthMethod).optional().default([]), () => []),
-    agentInfo: defaultOnError(zImplementation.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthenticateResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zProviderId = string();
-  const zLlmProtocol = union([
-    literal("anthropic"),
-    literal("openai"),
-    literal("azure"),
-    literal("vertex"),
-    literal("bedrock"),
-    string()
-  ]);
-  const zProviderCurrentConfig = object({
-    apiType: zLlmProtocol,
-    baseUrl: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zProviderInfo = object({
-    providerId: zProviderId,
-    supported: requiredDefaultOnError(vecSkipError(zLlmProtocol), () => []),
-    required: boolean(),
-    current: zProviderCurrentConfig.nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zListProvidersResponse = object({
-    providers: array(zProviderInfo),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSetProviderResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDisableProviderResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zLogoutResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionModeId = string();
-  const zSessionMode = object({
-    id: zSessionModeId,
-    name: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionModeState = object({
-    currentModeId: zSessionModeId,
-    availableModes: requiredDefaultOnError(vecSkipError(zSessionMode), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionConfigId = string();
-  const zSessionConfigOptionCategory = union([
-    literal("mode"),
-    literal("model"),
-    literal("model_config"),
-    literal("thought_level"),
-    string()
-  ]);
-  const zSessionConfigValueId = string();
-  const zSessionConfigSelectOption = object({
-    value: zSessionConfigValueId,
-    name: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionConfigGroupId = string();
-  const zSessionConfigSelectGroup = object({
-    group: zSessionConfigGroupId,
-    name: string(),
-    options: requiredDefaultOnError(vecSkipError(zSessionConfigSelectOption), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionConfigSelectOptions = union([
-    array(zSessionConfigSelectOption),
-    array(zSessionConfigSelectGroup)
-  ]);
-  const zSessionConfigSelect = object({
-    currentValue: zSessionConfigValueId,
-    options: zSessionConfigSelectOptions
-  });
-  const zSessionConfigBoolean = object({
-    currentValue: boolean()
-  });
-  const zSessionConfigOption = intersection(union([
-    zSessionConfigSelect.and(object({
-      type: literal("select")
-    })),
-    zSessionConfigBoolean.and(object({
-      type: literal("boolean")
-    }))
-  ]), object({
-    id: zSessionConfigId,
-    name: string(),
-    description: defaultOnError(string().nullish(), () => void 0),
-    category: defaultOnError(zSessionConfigOptionCategory.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  }));
-  const zNewSessionResponse = object({
-    sessionId: zSessionId,
-    modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
-    configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zLoadSessionResponse = object({
-    modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
-    configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionInfo = object({
-    sessionId: zSessionId,
-    cwd: string(),
-    additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
-    title: defaultOnError(string().nullish(), () => void 0),
-    updatedAt: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zListSessionsResponse = object({
-    sessions: requiredDefaultOnError(vecSkipError(zSessionInfo), () => []),
-    nextCursor: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDeleteSessionResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zForkSessionResponse = object({
-    sessionId: zSessionId,
-    modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
-    configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zResumeSessionResponse = object({
-    modes: defaultOnError(zSessionModeState.nullish(), () => void 0),
-    configOptions: defaultOnError(vecSkipError(zSessionConfigOption).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCloseSessionResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSetSessionModeResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSetSessionConfigOptionResponse = object({
-    configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zStopReason = union([
-    literal("end_turn"),
-    literal("max_tokens"),
-    literal("max_turn_requests"),
-    literal("refusal"),
-    literal("cancelled")
-  ]);
-  const zUsage = object({
-    totalTokens: number(),
-    inputTokens: number(),
-    outputTokens: number(),
-    thoughtTokens: defaultOnError(number().nullish(), () => void 0),
-    cachedReadTokens: defaultOnError(number().nullish(), () => void 0),
-    cachedWriteTokens: defaultOnError(number().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPromptResponse = object({
-    stopReason: zStopReason,
-    usage: defaultOnError(zUsage.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zStartNesResponse = object({
-    sessionId: zSessionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesSuggestionId = string();
-  const zPosition = object({
-    line: int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }),
-    character: int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zRange = object({
-    start: zPosition,
-    end: zPosition,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesTextEdit = object({
-    range: zRange,
-    newText: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesEditSuggestion = object({
-    id: zNesSuggestionId,
-    uri: string(),
-    edits: array(zNesTextEdit),
-    cursorPosition: defaultOnError(zPosition.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesJumpSuggestion = object({
-    id: zNesSuggestionId,
-    uri: string(),
-    position: zPosition,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRenameSuggestion = object({
-    id: zNesSuggestionId,
-    uri: string(),
-    position: zPosition,
-    newName: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesSearchAndReplaceSuggestion = object({
-    id: zNesSuggestionId,
-    uri: string(),
-    search: string(),
-    replace: string(),
-    isRegex: boolean().nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesSuggestion = union([
-    zNesEditSuggestion.and(object({
-      kind: literal("edit")
-    })),
-    zNesJumpSuggestion.and(object({
-      kind: literal("jump")
-    })),
-    zNesRenameSuggestion.and(object({
-      kind: literal("rename")
-    })),
-    zNesSearchAndReplaceSuggestion.and(object({
-      kind: literal("searchAndReplace")
-    }))
-  ]);
-  const zSuggestNesResponse = object({
-    suggestions: array(zNesSuggestion),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCloseNesResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zExtResponse = unknown();
-  const zMessageMcpResponse = unknown();
-  const zErrorCode = union([
-    literal(-32700),
-    literal(-32600),
-    literal(-32601),
-    literal(-32602),
-    literal(-32603),
-    literal(-32800),
-    literal(-32e3),
-    literal(-32002),
-    int().min(-2147483648, {
-      error: "Invalid value: Expected int32 to be >= -2147483648"
-    }).max(2147483647, {
-      error: "Invalid value: Expected int32 to be <= 2147483647"
-    })
-  ]);
-  const zError = object({
-    code: zErrorCode,
-    message: string(),
-    data: defaultOnError(unknown().optional(), () => void 0)
-  });
-  union([
-    object({
-      id: zRequestId,
-      result: union([
-        zInitializeResponse,
-        zAuthenticateResponse,
-        zListProvidersResponse,
-        zSetProviderResponse,
-        zDisableProviderResponse,
-        zLogoutResponse,
-        zNewSessionResponse,
-        zLoadSessionResponse,
-        zListSessionsResponse,
-        zDeleteSessionResponse,
-        zForkSessionResponse,
-        zResumeSessionResponse,
-        zCloseSessionResponse,
-        zSetSessionModeResponse,
-        zSetSessionConfigOptionResponse,
-        zPromptResponse,
-        zStartNesResponse,
-        zSuggestNesResponse,
-        zCloseNesResponse,
-        zExtResponse,
-        zMessageMcpResponse
-      ])
-    }),
-    object({
-      id: zRequestId,
-      error: zError
-    })
-  ]);
-  const zMessageId = string();
-  const zContentChunk = object({
-    content: zContentBlock,
-    messageId: defaultOnError(zMessageId.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zToolCall = object({
-    toolCallId: zToolCallId,
-    title: string(),
-    name: defaultOnError(string().nullish(), () => void 0),
-    kind: defaultOnError(zToolKind.optional(), () => void 0),
-    status: defaultOnError(zToolCallStatus.optional(), () => void 0),
-    content: defaultOnError(vecSkipError(zToolCallContent).optional(), () => []),
-    locations: defaultOnError(vecSkipError(zToolCallLocation).optional(), () => []),
-    rawInput: defaultOnError(unknown().optional(), () => void 0),
-    rawOutput: defaultOnError(unknown().optional(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanEntryPriority = union([
-    literal("high"),
-    literal("medium"),
-    literal("low")
-  ]);
-  const zPlanEntryStatus = union([
-    literal("pending"),
-    literal("in_progress"),
-    literal("completed")
-  ]);
-  const zPlanEntry = object({
-    content: string(),
-    priority: zPlanEntryPriority,
-    status: zPlanEntryStatus,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlan = object({
-    entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanId = string();
-  const zPlanItems = object({
-    planId: zPlanId,
-    entries: requiredDefaultOnError(vecSkipError(zPlanEntry), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanFile = object({
-    planId: zPlanId,
-    uri: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanMarkdown = object({
-    planId: zPlanId,
-    content: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanUpdateContent = union([
-    zPlanItems.and(object({
-      type: literal("items")
-    })),
-    zPlanFile.and(object({
-      type: literal("file")
-    })),
-    zPlanMarkdown.and(object({
-      type: literal("markdown")
-    }))
-  ]);
-  const zPlanUpdate = object({
-    plan: zPlanUpdateContent,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanRemoved = object({
-    planId: zPlanId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zUnstructuredCommandInput = object({
-    hint: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAvailableCommandInput = zUnstructuredCommandInput;
-  const zAvailableCommand = object({
-    name: string(),
-    description: string(),
-    input: defaultOnError(zAvailableCommandInput.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAvailableCommandsUpdate = object({
-    availableCommands: requiredDefaultOnError(vecSkipError(zAvailableCommand), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCurrentModeUpdate = object({
-    currentModeId: zSessionModeId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zConfigOptionUpdate = object({
-    configOptions: requiredDefaultOnError(vecSkipError(zSessionConfigOption), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionInfoUpdate = object({
-    title: defaultOnError(string().nullish(), () => void 0),
-    updatedAt: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCost = object({
-    amount: number(),
-    currency: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zUsageUpdate = object({
-    used: number(),
-    size: number(),
-    cost: defaultOnError(zCost.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionUpdate = union([
-    zContentChunk.and(object({
-      sessionUpdate: literal("user_message_chunk")
-    })),
-    zContentChunk.and(object({
-      sessionUpdate: literal("agent_message_chunk")
-    })),
-    zContentChunk.and(object({
-      sessionUpdate: literal("agent_thought_chunk")
-    })),
-    zToolCall.and(object({
-      sessionUpdate: literal("tool_call")
-    })),
-    zToolCallUpdate.and(object({
-      sessionUpdate: literal("tool_call_update")
-    })),
-    zPlan.and(object({
-      sessionUpdate: literal("plan")
-    })),
-    zPlanUpdate.and(object({
-      sessionUpdate: literal("plan_update")
-    })),
-    zPlanRemoved.and(object({
-      sessionUpdate: literal("plan_removed")
-    })),
-    zAvailableCommandsUpdate.and(object({
-      sessionUpdate: literal("available_commands_update")
-    })),
-    zCurrentModeUpdate.and(object({
-      sessionUpdate: literal("current_mode_update")
-    })),
-    zConfigOptionUpdate.and(object({
-      sessionUpdate: literal("config_option_update")
-    })),
-    zSessionInfoUpdate.and(object({
-      sessionUpdate: literal("session_info_update")
-    })),
-    zUsageUpdate.and(object({
-      sessionUpdate: literal("usage_update")
-    }))
-  ]);
-  const zSessionNotification = object({
-    sessionId: zSessionId,
-    update: zSessionUpdate,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCompleteElicitationNotification = object({
-    elicitationId: zElicitationId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMessageMcpNotification = object({
-    connectionId: zMcpConnectionId,
-    method: string(),
-    params: defaultOnError(record(string(), unknown()).nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zExtNotification = unknown();
-  object({
-    method: string(),
-    params: union([
-      zSessionNotification,
-      zCompleteElicitationNotification,
-      zMessageMcpNotification,
-      zExtNotification
-    ]).nullish()
-  });
-  const zFileSystemCapabilities = object({
-    readTextFile: defaultOnError(boolean().optional().default(false), () => false),
-    writeTextFile: defaultOnError(boolean().optional().default(false), () => false),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zBooleanConfigOptionCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSessionConfigOptionsCapabilities = object({
-    boolean: defaultOnError(zBooleanConfigOptionCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zClientSessionCapabilities = object({
-    configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zPlanCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthCapabilities = object({
-    terminal: defaultOnError(boolean().optional().default(false), () => false),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationFormCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationUrlCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationCapabilities = object({
-    form: defaultOnError(zElicitationFormCapabilities.nullish(), () => void 0),
-    url: defaultOnError(zElicitationUrlCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesJumpCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRenameCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesSearchAndReplaceCapabilities = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zClientNesCapabilities = object({
-    jump: defaultOnError(zNesJumpCapabilities.nullish(), () => void 0),
-    rename: defaultOnError(zNesRenameCapabilities.nullish(), () => void 0),
-    searchAndReplace: defaultOnError(zNesSearchAndReplaceCapabilities.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zClientCapabilities = object({
-    fs: defaultOnError(zFileSystemCapabilities.optional().default({
-      readTextFile: false,
-      writeTextFile: false
-    }), () => ({
-      readTextFile: false,
-      writeTextFile: false
-    })),
-    terminal: defaultOnError(boolean().optional().default(false), () => false),
-    session: defaultOnError(zClientSessionCapabilities.nullish(), () => void 0),
-    plan: defaultOnError(zPlanCapabilities.nullish(), () => void 0),
-    auth: defaultOnError(zAuthCapabilities.optional().default({
-      terminal: false
-    }), () => ({
-      terminal: false
-    })),
-    elicitation: defaultOnError(zElicitationCapabilities.nullish(), () => void 0),
-    nes: defaultOnError(zClientNesCapabilities.nullish(), () => void 0),
-    positionEncodings: defaultOnError(vecSkipError(zPositionEncodingKind).optional(), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zInitializeRequest = object({
-    protocolVersion: zProtocolVersion,
-    clientCapabilities: defaultOnError(zClientCapabilities.optional().default({
-      fs: {
-        readTextFile: false,
-        writeTextFile: false
-      },
-      terminal: false,
-      auth: {
-        terminal: false
-      }
-    }), () => ({
-      fs: {
-        readTextFile: false,
-        writeTextFile: false
-      },
-      terminal: false,
-      auth: {
-        terminal: false
-      }
-    })),
-    clientInfo: defaultOnError(zImplementation.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAuthenticateRequest = object({
-    methodId: zAuthMethodId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zListProvidersRequest = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSetProviderRequest = object({
-    providerId: zProviderId,
-    apiType: zLlmProtocol,
-    baseUrl: string(),
-    headers: record(string(), string()).optional(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDisableProviderRequest = object({
-    providerId: zProviderId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zLogoutRequest = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zHttpHeader = object({
-    name: string(),
-    value: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpServerHttp = object({
-    name: string(),
-    url: string(),
-    headers: array(zHttpHeader),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpServerSse = object({
-    name: string(),
-    url: string(),
-    headers: array(zHttpHeader),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpServerAcp = object({
-    name: string(),
-    serverId: zMcpServerAcpId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpServerStdio = object({
-    name: string(),
-    command: string(),
-    args: array(string()),
-    env: array(zEnvVariable),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zMcpServer = union([
-    zMcpServerHttp.and(object({
-      type: literal("http")
-    })),
-    zMcpServerSse.and(object({
-      type: literal("sse")
-    })),
-    zMcpServerAcp.and(object({
-      type: literal("acp")
-    })),
-    zMcpServerStdio
-  ]);
-  const zNewSessionRequest = object({
-    cwd: string(),
-    additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
-    mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zLoadSessionRequest = object({
-    mcpServers: requiredDefaultOnError(vecSkipError(zMcpServer), () => []),
-    cwd: string(),
-    additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
-    sessionId: zSessionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zListSessionsRequest = object({
-    cwd: string().nullish(),
-    cursor: string().nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDeleteSessionRequest = object({
-    sessionId: zSessionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zForkSessionRequest = object({
-    sessionId: zSessionId,
-    cwd: string(),
-    additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
-    mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zResumeSessionRequest = object({
-    sessionId: zSessionId,
-    cwd: string(),
-    additionalDirectories: defaultOnError(vecSkipError(string()).optional(), () => []),
-    mcpServers: defaultOnError(vecSkipError(zMcpServer).optional(), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCloseSessionRequest = object({
-    sessionId: zSessionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSetSessionModeRequest = object({
-    sessionId: zSessionId,
-    modeId: zSessionModeId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSetSessionConfigOptionRequest = intersection(union([
-    object({
-      value: boolean(),
-      type: literal("boolean")
-    }),
-    object({
-      value: zSessionConfigValueId
-    })
-  ]), object({
-    sessionId: zSessionId,
-    configId: zSessionConfigId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  }));
-  const zPromptRequest = object({
-    sessionId: zSessionId,
-    prompt: array(zContentBlock),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zWorkspaceFolder = object({
-    uri: string(),
-    name: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRepository = object({
-    name: string(),
-    owner: string(),
-    remoteUrl: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zStartNesRequest = object({
-    workspaceUri: defaultOnError(string().nullish(), () => void 0),
-    workspaceFolders: array(zWorkspaceFolder).nullish(),
-    repository: defaultOnError(zNesRepository.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesTriggerKind = union([
-    literal("automatic"),
-    literal("diagnostic"),
-    literal("manual")
-  ]);
-  const zNesRecentFile = object({
-    uri: string(),
-    languageId: string(),
-    text: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesExcerpt = object({
-    startLine: int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }),
-    endLine: int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }),
-    text: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRelatedSnippet = object({
-    uri: string(),
-    excerpts: array(zNesExcerpt),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesEditHistoryEntry = object({
-    uri: string(),
-    diff: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesUserAction = object({
-    action: string(),
-    uri: string(),
-    position: zPosition,
-    timestampMs: number(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesOpenFile = object({
-    uri: string(),
-    languageId: string(),
-    visibleRange: defaultOnError(zRange.nullish(), () => void 0),
-    lastFocusedMs: defaultOnError(number().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesDiagnosticSeverity = union([
-    literal("error"),
-    literal("warning"),
-    literal("information"),
-    literal("hint")
-  ]);
-  const zNesDiagnostic = object({
-    uri: string(),
-    range: zRange,
-    severity: zNesDiagnosticSeverity,
-    message: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesSuggestContext = object({
-    recentFiles: array(zNesRecentFile).nullish(),
-    relatedSnippets: array(zNesRelatedSnippet).nullish(),
-    editHistory: array(zNesEditHistoryEntry).nullish(),
-    userActions: array(zNesUserAction).nullish(),
-    openFiles: array(zNesOpenFile).nullish(),
-    diagnostics: array(zNesDiagnostic).nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSuggestNesRequest = object({
-    sessionId: zSessionId,
-    uri: string(),
-    version: number(),
-    position: zPosition,
-    selection: zRange.nullish(),
-    triggerKind: zNesTriggerKind,
-    context: zNesSuggestContext.nullish(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCloseNesRequest = object({
-    sessionId: zSessionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  object({
-    id: zRequestId,
-    method: string(),
-    params: union([
-      zInitializeRequest,
-      zAuthenticateRequest,
-      zListProvidersRequest,
-      zSetProviderRequest,
-      zDisableProviderRequest,
-      zLogoutRequest,
-      zNewSessionRequest,
-      zLoadSessionRequest,
-      zListSessionsRequest,
-      zDeleteSessionRequest,
-      zForkSessionRequest,
-      zResumeSessionRequest,
-      zCloseSessionRequest,
-      zSetSessionModeRequest,
-      zSetSessionConfigOptionRequest,
-      zPromptRequest,
-      zStartNesRequest,
-      zSuggestNesRequest,
-      zCloseNesRequest,
-      zMessageMcpRequest,
-      zExtRequest
-    ]).nullish()
-  });
-  const zWriteTextFileResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zReadTextFileResponse = object({
-    content: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zSelectedPermissionOutcome = object({
-    optionId: zPermissionOptionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zRequestPermissionOutcome = union([
-    object({
-      outcome: literal("cancelled")
-    }),
-    zSelectedPermissionOutcome.and(object({
-      outcome: literal("selected")
-    }))
-  ]);
-  const zRequestPermissionResponse = object({
-    outcome: zRequestPermissionOutcome,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zCreateTerminalResponse = object({
-    terminalId: zTerminalId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTerminalExitStatus = object({
-    exitCode: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    signal: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTerminalOutputResponse = object({
-    output: string(),
-    truncated: boolean(),
-    exitStatus: defaultOnError(zTerminalExitStatus.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zReleaseTerminalResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zWaitForTerminalExitResponse = object({
-    exitCode: defaultOnError(int().gte(0).max(4294967295, {
-      error: "Invalid value: Expected uint32 to be <= 4294967295"
-    }).nullish(), () => void 0),
-    signal: defaultOnError(string().nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zKillTerminalResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zElicitationContentValue = union([
-    string(),
-    number(),
-    number(),
-    boolean(),
-    array(string())
-  ]);
-  const zElicitationAcceptAction = object({
-    content: record(string(), zElicitationContentValue).nullish()
-  });
-  const zCreateElicitationResponse = preserveCustomPayload(intersection(union([
-    zElicitationAcceptAction.and(object({
-      action: literal("accept")
-    })),
-    object({
-      action: literal("decline")
-    }),
-    object({
-      action: literal("cancel")
-    }),
-    excludeKnownTags(object({
-      action: string()
-    }), "action", [
-      "accept",
-      "cancel",
-      "decline"
-    ])
-  ]), object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  })), "action", [
-    "accept",
-    "cancel",
-    "decline"
-  ]);
-  const zConnectMcpResponse = object({
-    connectionId: zMcpConnectionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDisconnectMcpResponse = object({
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  union([
-    object({
-      id: zRequestId,
-      result: union([
-        zWriteTextFileResponse,
-        zReadTextFileResponse,
-        zRequestPermissionResponse,
-        zCreateTerminalResponse,
-        zTerminalOutputResponse,
-        zReleaseTerminalResponse,
-        zWaitForTerminalExitResponse,
-        zKillTerminalResponse,
-        zCreateElicitationResponse,
-        zConnectMcpResponse,
-        zDisconnectMcpResponse,
-        zMessageMcpResponse,
-        zExtResponse
-      ])
-    }),
-    object({
-      id: zRequestId,
-      error: zError
-    })
-  ]);
-  const zCancelNotification = object({
-    sessionId: zSessionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDidOpenDocumentNotification = object({
-    sessionId: zSessionId,
-    uri: string(),
-    languageId: string(),
-    version: number(),
-    text: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zTextDocumentContentChangeEvent = object({
-    range: zRange.nullish(),
-    text: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDidChangeDocumentNotification = object({
-    sessionId: zSessionId,
-    uri: string(),
-    version: number(),
-    contentChanges: requiredDefaultOnError(vecSkipError(zTextDocumentContentChangeEvent), () => []),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDidCloseDocumentNotification = object({
-    sessionId: zSessionId,
-    uri: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDidSaveDocumentNotification = object({
-    sessionId: zSessionId,
-    uri: string(),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zDidFocusDocumentNotification = object({
-    sessionId: zSessionId,
-    uri: string(),
-    version: number(),
-    position: zPosition,
-    visibleRange: zRange,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zAcceptNesNotification = object({
-    sessionId: zSessionId,
-    id: zNesSuggestionId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const zNesRejectReason = union([
-    literal("rejected"),
-    literal("ignored"),
-    literal("replaced"),
-    literal("cancelled")
-  ]);
-  const zRejectNesNotification = object({
-    sessionId: zSessionId,
-    id: zNesSuggestionId,
-    reason: defaultOnError(zNesRejectReason.nullish(), () => void 0),
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  object({
-    method: string(),
-    params: union([
-      zCancelNotification,
-      zDidOpenDocumentNotification,
-      zDidChangeDocumentNotification,
-      zDidCloseDocumentNotification,
-      zDidSaveDocumentNotification,
-      zDidFocusDocumentNotification,
-      zAcceptNesNotification,
-      zRejectNesNotification,
-      zMessageMcpNotification,
-      zExtNotification
-    ]).nullish()
-  });
-  object({
-    requestId: zRequestId,
-    _meta: defaultOnError(record(string(), unknown()).nullish(), () => void 0)
-  });
-  const CANCEL_REQUEST_METHOD = "$/cancel_request";
-  function isRequestMessage(value) {
-    return isJsonRpcEnvelope(value) && "id" in value && typeof value["method"] === "string" && isJsonRpcId(value["id"]);
-  }
-  function isResponseMessage(value) {
-    if (!isJsonRpcEnvelope(value) || "method" in value) {
-      return false;
-    }
-    if (!("id" in value) || !isJsonRpcId(value["id"])) {
-      return false;
-    }
-    const hasResult = Object.hasOwn(value, "result");
-    const hasError = Object.hasOwn(value, "error");
-    if (hasResult === hasError) {
-      return false;
-    }
-    return !hasError || isErrorResponse(value["error"]);
-  }
-  function isNotificationMessage(value) {
-    return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
-  }
-  function isRecord(value) {
-    return typeof value === "object" && value !== null;
-  }
-  function isJsonRpcEnvelope(value) {
-    return isRecord(value) && value["jsonrpc"] === "2.0";
-  }
-  function isJsonRpcId(value) {
-    return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
-  }
-  function isResponseShapedMessage(value) {
-    return isRecord(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
-  }
-  function isResponseBatch(batch) {
-    let hasValidCall = false;
-    let hasValidResponse = false;
-    let hasCallShape = false;
-    let hasResponseShape = false;
-    for (const entry of batch) {
-      hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
-      hasValidResponse ||= isResponseMessage(entry);
-      if (!isRecord(entry)) {
-        continue;
-      }
-      hasCallShape ||= "method" in entry;
-      hasResponseShape ||= "result" in entry || "error" in entry;
-    }
-    if (hasValidCall) {
-      return false;
-    }
-    if (hasValidResponse) {
-      return true;
-    }
-    return hasResponseShape && !hasCallShape;
-  }
-  function cancelRequestId(params) {
-    if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
-      return void 0;
-    }
-    return params["requestId"];
-  }
-  function isErrorResponse(value) {
-    return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
-  }
-  const Handled = {
-    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 void 0;
-  }
-  function isZodError(error) {
-    return typeof error === "object" && error !== null && "name" in error && error.name === "ZodError" && "issues" in error && Array.isArray(error.issues) && "format" in error && typeof error.format === "function";
-  }
-  function errorToResult(error) {
-    if (error instanceof RequestError) {
-      return error.toResult();
-    }
-    if (isZodError(error)) {
-      return RequestError.invalidParams(error.format()).toResult();
-    }
-    const details = errorDetails(error);
-    try {
-      return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
-    } catch {
-      return RequestError.internalError({
-        details
-      }).toResult();
-    }
-  }
-  function requestCancelledError(reason) {
-    if (reason instanceof RequestError && reason.code === -32800) {
-      return reason;
-    }
-    return RequestError.requestCancelled(reason);
-  }
-  function errorToRequestResult(error, signal) {
-    const requestCancelled = abortErrorToRequestCancelled(error, signal);
-    return requestCancelled ? requestCancelled.toResult() : errorToResult(error);
-  }
-  function abortErrorToRequestCancelled(error, signal) {
-    if (!signal.aborted || !isAbortError(error)) {
-      return void 0;
-    }
-    return requestCancelledError(signal.reason);
-  }
-  function isAbortError(error) {
-    if (typeof error !== "object" || error === null) {
-      return false;
-    }
-    const maybeAbortError = error;
-    return maybeAbortError.name === "AbortError" || maybeAbortError.code === "ABORT_ERR";
-  }
-  class RequestResponder {
-    id;
-    sendResult;
-    signal;
-    finishRequest;
-    didRespond = false;
-    constructor(id, sendResult, signal = new AbortController().signal, finishRequest) {
-      this.id = id;
-      this.sendResult = sendResult;
-      this.signal = signal;
-      this.finishRequest = finishRequest;
-    }
-    get responded() {
-      return this.didRespond;
-    }
-    respond(response) {
-      return this.respondWithResult({
-        result: response ?? null
-      });
-    }
-    respondWithError(error) {
-      const errorResponse = error instanceof RequestError ? error.toErrorResponse() : error;
-      return this.respondWithResult({
-        error: errorResponse
-      });
-    }
-    respondWithResult(result) {
-      if (this.didRespond) {
-        return rejectedPromise(new Error("JSON-RPC request already responded"));
-      }
-      this.didRespond = true;
-      return this.sendResult(result).finally(() => {
-        this.finishRequest?.();
-      });
-    }
-  }
-  class HandlerRegistration {
-    disposeHandler;
-    active = true;
-    constructor(disposeHandler) {
-      this.disposeHandler = disposeHandler;
-    }
-    dispose() {
-      if (!this.active) {
-        return;
-      }
-      this.active = false;
-      this.disposeHandler();
-    }
-    [Symbol.dispose]() {
-      this.dispose();
-    }
-    runIndefinitely() {
-      return this;
-    }
-  }
-  class ConnectionContext {
-    connection;
-    constructor(connection2) {
-      this.connection = connection2;
-    }
-    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 = /* @__PURE__ */ new Map();
-    incomingRequests = /* @__PURE__ */ new Map();
-    nextRequestId = 0;
-    staticHandlers = [];
-    dynamicHandlers = /* @__PURE__ */ new Set();
-    stream;
-    writeQueue = Promise.resolve();
-    abortController = new AbortController();
-    closedPromise;
-    retryQueue = [];
-    context = new ConnectionContext(this);
-    receiveReader;
-    allowBatches = true;
-    constructor(requestHandlerOrStream, notificationHandlerOrHandlers, streamOrOptions, options) {
-      if (typeof requestHandlerOrStream === "function") {
-        const requestHandler = requestHandlerOrStream;
-        const notificationHandler = notificationHandlerOrHandlers;
-        const stream2 = streamOrOptions;
-        this.initialize(stream2, [
-          ...options?.handlers ?? [],
-          this.legacyHandler(requestHandler, notificationHandler)
-        ], options);
-        return;
-      }
-      const stream = requestHandlerOrStream;
-      const handlers = notificationHandlerOrHandlers;
-      const connectionOptions = streamOrOptions;
-      this.initialize(stream, [
-        ...connectionOptions?.handlers ?? [],
-        ...handlers
-      ], connectionOptions);
-    }
-    static builder() {
-      return new ConnectionBuilder();
-    }
-    runUntil(op2) {
-      let opSettled = false;
-      const opPromise = Promise.resolve().then(() => op2(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)) {
-          void 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);
-      void 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(void 0));
-          continue;
-        }
-        const request = this.prepareRequest(entry.method, entry.params, entry.mapResponse, entry.options);
-        messages.push(request.message);
-        outputs.push(request.response);
-        cancellations.push({
-          signal: entry.options?.cancellationSignal,
-          cancel: request.cancel
-        });
-      }
-      const batch = messages;
-      const batchSent = this.sendWireMessage(batch);
-      for (const cancellation of cancellations) {
-        if (cancellation.signal?.aborted) {
-          cancellation.cancel();
-        }
-      }
-      const response = Promise.all([
-        batchSent,
-        ...outputs
-      ]).then(([, ...resolved]) => resolved);
-      response.catch(() => {
-      });
-      return response;
-    }
-    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((resolve2, reject) => {
-        const pendingResponse = {
-          resolve: (value) => {
-            try {
-              resolve2(mapResponse ? mapResponse(value) : value);
-            } catch (error) {
-              reject(error);
-            }
-          },
-          reject
-        };
-        cancel = () => {
-          if (pendingResponse.cancellationSent) {
-            return;
-          }
-          pendingResponse.cancellationSent = true;
-          pendingResponse.cleanup?.();
-          void this.sendCancelRequest(id).catch(() => {
-          });
-        };
-        options.cancellationSignal?.addEventListener("abort", cancel, {
-          once: true
-        });
-        pendingResponse.cleanup = () => {
-          options.cancellationSignal?.removeEventListener("abort", cancel);
-        };
-        this.pendingResponses.set(id, pendingResponse);
-      });
-      response.catch(() => {
-      });
-      return {
-        message: {
-          jsonrpc: "2.0",
-          id,
-          method,
-          params
-        },
-        response,
-        cancel: () => cancel()
-      };
-    }
-    close(error) {
-      if (this.abortController.signal.aborted) {
-        return;
-      }
-      const closeError = error ?? new Error("ACP connection closed");
-      this.abortController.abort(closeError);
-      for (const pendingResponse of this.pendingResponses.values()) {
-        pendingResponse.cleanup?.();
-        pendingResponse.reject(closeError);
-      }
-      this.pendingResponses.clear();
-      for (const controller of this.incomingRequests.values()) {
-        controller.abort(closeError);
-      }
-      this.incomingRequests.clear();
-      void this.receiveReader?.cancel(closeError).catch(() => {
-      });
-    }
-    initialize(stream, handlers, options) {
-      this.stream = stream;
-      this.staticHandlers = handlers;
-      this.allowBatches = options?.allowBatches ?? true;
-      this.closedPromise = new Promise((resolve2) => {
-        this.abortController.signal.addEventListener("abort", () => resolve2());
-      });
-      void this.receive();
-    }
-    legacyHandler(requestHandler, notificationHandler) {
-      return {
-        handleMessage: async (message, cx2) => {
-          if (message.kind === "request") {
-            const result = await requestHandler(message.method, message.params, cx2);
-            await message.responder.respond(result);
-          } else {
-            await notificationHandler(message.method, message.params, cx2);
-          }
-          return Handled.yes();
-        }
-      };
-    }
-    async receive() {
-      let closeError = void 0;
-      try {
-        const reader = this.stream.readable.getReader();
-        this.receiveReader = reader;
-        try {
-          while (!this.abortController.signal.aborted) {
-            const { value: message, done } = await reader.read();
-            if (this.abortController.signal.aborted) {
-              break;
-            }
-            if (done) {
-              break;
-            }
-            if (!message) {
-              continue;
-            }
-            this.receiveWireMessage(message);
-          }
-        } finally {
-          if (this.receiveReader === reader) {
-            this.receiveReader = void 0;
-          }
-          reader.releaseLock();
-        }
-      } catch (error) {
-        closeError = error;
-      } finally {
-        this.close(closeError);
-      }
-    }
-    receiveWireMessage(message) {
-      if (Array.isArray(message)) {
-        if (!this.allowBatches) {
-          this.close(new TypeError("JSON-RPC batches are not supported on this connection"));
-          return;
-        }
-        this.receiveBatch(message);
-        return;
-      }
-      if (!isRecord(message)) {
-        console.error("Invalid message", {
-          message
-        });
-        return;
-      }
-      this.receiveMessage(message);
-    }
-    receiveBatch(batch) {
-      if (batch.length === 0) {
-        void this.sendWireMessage({
-          jsonrpc: "2.0",
-          id: null,
-          error: RequestError.invalidRequest(batch).toErrorResponse()
-        }).catch(() => {
-        });
-        return;
-      }
-      const responseBatch = isResponseBatch(batch);
-      const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
-      let remaining = responseCount;
-      let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
-      let responseSent = false;
-      const responses = [];
-      const sendResponsesIfReady = async () => {
-        if (responseSent || remaining !== 0 || remainingNotifications !== 0 || responses.length === 0) {
-          return;
-        }
-        responseSent = true;
-        await this.sendWireMessage(responses);
-      };
-      const collectResponse = async (response) => {
-        responses.push(response);
-        remaining -= 1;
-        await sendResponsesIfReady();
-      };
-      for (const message of batch) {
-        if (responseBatch) {
-          if (isResponseShapedMessage(message)) {
-            this.receiveMessage(message);
-          }
-          continue;
-        }
-        if (!isRequestMessage(message) && !isNotificationMessage(message)) {
-          void collectResponse({
-            jsonrpc: "2.0",
-            id: null,
-            error: RequestError.invalidRequest(message).toErrorResponse()
-          }).catch(() => {
-          });
-          continue;
-        }
-        const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : void 0);
-        if (isNotificationMessage(message)) {
-          void processing.finally(() => {
-            remainingNotifications -= 1;
-            void sendResponsesIfReady().catch((error) => this.close(error));
-          });
-        }
-      }
-    }
-    receiveMessage(message, sendResponse) {
-      if (this.abortController.signal.aborted) {
-        return Promise.resolve();
-      }
-      if (!isRecord(message)) {
-        console.error("Invalid message", {
-          message
-        });
-        return Promise.resolve();
-      }
-      if ("method" in message) {
-        if (!("id" in message)) {
-          this.handleProtocolNotification(message);
-        }
-        return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse)).catch((error) => this.close(error));
-      } else if ("id" in message) {
-        this.handleResponse(message);
-      } else {
-        console.error("Invalid message", {
-          message
-        });
-      }
-      return Promise.resolve();
-    }
-    async processIncomingMessage(message) {
-      if (this.abortController.signal.aborted) {
-        return;
-      }
-      let current = message;
-      let retry = false;
-      try {
-        for (const handler of [
-          ...this.staticHandlers,
-          ...this.dynamicHandlers.values()
-        ]) {
-          if (this.abortController.signal.aborted) {
-            return;
-          }
-          const result = await handler.handleMessage(current, this.context) ?? {
-            handled: true
-          };
-          if (result.handled) {
-            return;
-          }
-          current = result.message ?? current;
-          retry = retry || Boolean(result.retry);
-        }
-        if (retry) {
-          this.retryQueue.push(current);
-        } else if (current.kind === "request") {
-          await current.responder.respondWithError(RequestError.methodNotFound(current.method));
-        }
-      } catch (error) {
-        if (this.abortController.signal.aborted) {
-          return;
-        }
-        if (current.kind === "request" && !current.responder.responded) {
-          await current.responder.respondWithResult(errorToRequestResult(error, current.responder.signal));
-        } else {
-          const response = errorToResult(error);
-          if ("error" in response) {
-            console.error("Error handling notification", message.raw, response.error);
-          }
-        }
-      }
-    }
-    toIncomingMessage(message, sendResponse) {
-      if ("id" in message) {
-        const abortController = new AbortController();
-        this.incomingRequests.set(message.id, abortController);
-        const finishRequest = () => {
-          if (this.incomingRequests.get(message.id) === abortController) {
-            this.incomingRequests.delete(message.id);
-          }
-        };
-        return {
-          kind: "request",
-          method: message.method,
-          params: message.params,
-          raw: message,
-          signal: abortController.signal,
-          responder: new RequestResponder(message.id, (result) => {
-            const response = {
-              jsonrpc: "2.0",
-              id: message.id,
-              ...result
-            };
-            return sendResponse ? sendResponse(response) : this.sendWireMessage(response);
-          }, abortController.signal, finishRequest)
-        };
-      }
-      return {
-        kind: "notification",
-        method: message.method,
-        params: message.params,
-        raw: message
-      };
-    }
-    handleResponse(response) {
-      const pendingResponse = this.pendingResponses.get(response.id);
-      if (pendingResponse) {
-        this.pendingResponses.delete(response.id);
-        pendingResponse.cleanup?.();
-        if (!isResponseMessage(response)) {
-          pendingResponse.reject(RequestError.invalidRequest(response));
-        } else if ("result" in response) {
-          pendingResponse.resolve(response.result);
-        } else {
-          const { code, message, data } = response.error;
-          pendingResponse.reject(new RequestError(code, message, data));
-        }
-      } else {
-        console.error("Got response to unknown request", response.id);
-      }
-    }
-    handleProtocolNotification(message) {
-      if (message.method !== CANCEL_REQUEST_METHOD) {
-        return;
-      }
-      const requestId = cancelRequestId(message.params);
-      if (requestId === void 0) {
-        return;
-      }
-      const controller = this.incomingRequests.get(requestId);
-      if (!controller || controller.signal.aborted) {
-        return;
-      }
-      controller.abort(RequestError.requestCancelled({
-        requestId
-      }));
-    }
-    closedReason() {
-      return this.abortController.signal.reason ?? new Error("ACP connection closed");
-    }
-    async sendWireMessage(message) {
-      if (this.abortController.signal.aborted) {
-        return rejectedPromise(this.closedReason());
-      }
-      this.writeQueue = this.writeQueue.then(async () => {
-        if (this.abortController.signal.aborted) {
-          throw this.closedReason();
-        }
-        const writer = this.stream.writable.getWriter();
-        try {
-          await writer.write(message);
-        } finally {
-          writer.releaseLock();
-        }
-      }).catch((error) => {
-        this.close(error);
-        throw error;
-      });
-      return this.writeQueue;
-    }
-  }
-  class ConnectionBuilder {
-    handlers = [];
-    connectionName;
-    name(name) {
-      this.connectionName = name;
-      return this;
-    }
-    withHandler(handler) {
-      this.handlers.push(handler);
-      return this;
-    }
-    onReceiveMessage(handler) {
-      return this.withHandler({
-        handleMessage: async (message, cx2) => await handler(message, cx2) ?? Handled.no(message),
-        describe: () => this.connectionName ?? "onReceiveMessage"
-      });
-    }
-    onReceiveRequest(method, parse, handler) {
-      return this.withHandler({
-        handleMessage: async (message, cx2) => {
-          if (message.kind !== "request" || message.method !== method) {
-            return Handled.no(message);
-          }
-          const request = parse(message.params);
-          return await handler(request, message.responder, cx2) ?? Handled.yes();
-        },
-        describe: () => `${this.connectionName ?? "request"}:${method}`
-      });
-    }
-    onReceiveNotification(method, parse, handler) {
-      return this.withHandler({
-        handleMessage: async (message, cx2) => {
-          if (message.kind !== "notification" || message.method !== method) {
-            return Handled.no(message);
-          }
-          const notification = parse(message.params);
-          return await handler(notification, cx2) ?? Handled.yes();
-        },
-        describe: () => `${this.connectionName ?? "notification"}:${method}`
-      });
-    }
-    connect(stream, options) {
-      return new Connection(stream, this.handlers, options);
-    }
-    connectWith(stream, op2, options) {
-      return this.connect(stream, options).runUntil(op2);
-    }
-  }
-  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(-32e3, `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
-      };
-    }
-  }
-  const 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 void 0;
-      }
-      return this.#takeLine(new Uint8Array(0));
-    }
-    #takeLine(tail) {
-      if (this.#pending.length === 0) {
-        return tail;
-      }
-      let total = tail.byteLength;
-      for (const part of this.#pending) {
-        total += part.byteLength;
-      }
-      const line = new Uint8Array(total);
-      let offset = 0;
-      for (const part of this.#pending) {
-        line.set(part, offset);
-        offset += part.byteLength;
-      }
-      line.set(tail, offset);
-      this.#pending = [];
-      return line;
-    }
-  }
-  function ndJsonStream$1(output, input) {
-    const textEncoder = new TextEncoder();
-    const textDecoder = new TextDecoder();
-    let cancelled = false;
-    let inputReader;
-    const readable = new ReadableStream({
-      async start(controller) {
-        const lines = new LineBuffer();
-        const enqueueLine = (lineBytes) => {
-          const trimmedLine = textDecoder.decode(lineBytes).trim();
-          if (trimmedLine) {
-            try {
-              const message = JSON.parse(trimmedLine);
-              if (isRecord(message) || Array.isArray(message)) {
-                controller.enqueue(message);
-              } else {
-                console.warn("Skipping JSON line that is not an object:", trimmedLine);
-              }
-            } catch (err) {
-              console.error("Failed to parse JSON message:", trimmedLine, err);
-            }
-          }
-        };
-        const reader = input.getReader();
-        inputReader = reader;
-        try {
-          while (true) {
-            const { value, done } = await reader.read();
-            if (cancelled) {
-              return;
-            }
-            if (done) {
-              break;
-            }
-            if (!value) {
-              continue;
-            }
-            for (const line of lines.push(value)) {
-              enqueueLine(line);
-              if (cancelled) {
-                return;
-              }
-            }
-          }
-          if (cancelled) {
-            return;
-          }
-          const lastLine = lines.flush();
-          if (lastLine) {
-            enqueueLine(lastLine);
-          }
-        } catch (err) {
-          if (cancelled) {
-            return;
-          }
-          controller.error(err);
-          return;
-        } finally {
-          if (inputReader === reader) {
-            inputReader = void 0;
-          }
-          reader.releaseLock();
-        }
-        if (cancelled) {
-          return;
-        }
-        controller.close();
-      },
-      cancel(reason) {
-        cancelled = true;
-        return inputReader?.cancel(reason);
-      }
-    });
-    const writable = new WritableStream({
-      async write(message) {
-        const content = JSON.stringify(message) + "\n";
-        const writer = output.getWriter();
-        try {
-          await writer.write(textEncoder.encode(content));
-        } finally {
-          writer.releaseLock();
-        }
-      }
-    });
-    return {
-      readable,
-      writable
-    };
-  }
-  function tagOf(value, key) {
-    return typeof value === "object" && value !== null ? value[key] : void 0;
-  }
-  zElicitationFormMode.and(object({
-    mode: literal("form")
-  })).and(object({
-    message: string()
-  }));
-  zElicitationUrlMode.and(object({
-    mode: literal("url")
-  })).and(object({
-    message: string()
-  }));
-  union([
-    zElicitationSessionScope,
-    zElicitationRequestScope
-  ]).and(object({
-    message: string()
-  }));
-  zStringPropertySchema.and(object({
-    type: literal("string")
-  }));
-  zNumberPropertySchema.and(object({
-    type: literal("number")
-  }));
-  zIntegerPropertySchema.and(object({
-    type: literal("integer")
-  }));
-  zBooleanPropertySchema.and(object({
-    type: literal("boolean")
-  }));
-  zMultiSelectPropertySchema.and(object({
-    type: literal("array")
-  }));
-  zStringMultiSelectItems.and(object({
-    type: literal("string")
-  }));
-  const zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({
-    action: literal("accept")
-  }));
-  const zGuardCreateElicitationResponseDecline = object({
-    action: literal("decline")
-  });
-  const zGuardCreateElicitationResponseCancel = object({
-    action: literal("cancel")
-  });
-  const CreateElicitationResponse = {
-    isAccept(value) {
-      return tagOf(value, "action") === "accept" && zGuardCreateElicitationResponseAccept.safeParse(value).success;
-    },
-    isDecline(value) {
-      return tagOf(value, "action") === "decline" && zGuardCreateElicitationResponseDecline.safeParse(value).success;
-    },
-    isCancel(value) {
-      return tagOf(value, "action") === "cancel" && zGuardCreateElicitationResponseCancel.safeParse(value).success;
-    },
-    isCustom(value) {
-      const tag = tagOf(value, "action");
-      return typeof tag === "string" && ![
-        "accept",
-        "cancel",
-        "decline"
-      ].includes(tag);
-    }
-  };
-  function ndJsonStream(output, input) {
-    return ndJsonStream$1(output, input);
-  }
-  function emptyObjectResponse(response) {
-    return response ?? {};
-  }
-  function isStream(value) {
-    return typeof value === "object" && value !== null && "readable" in value && "writable" in value;
-  }
-  function memoryStreamPair() {
-    const leftToRight = new TransformStream();
-    const rightToLeft = new TransformStream();
-    return [
-      {
-        readable: rightToLeft.readable,
-        writable: leftToRight.writable
-      },
-      {
-        readable: leftToRight.readable,
-        writable: rightToLeft.writable
-      }
-    ];
-  }
-  const methods = {
-    agent: {
-      initialize: AGENT_METHODS.initialize,
-      authenticate: AGENT_METHODS.authenticate,
-      logout: AGENT_METHODS.logout,
-      providers: {
-        list: AGENT_METHODS.providers_list,
-        set: AGENT_METHODS.providers_set,
-        disable: AGENT_METHODS.providers_disable
-      },
-      session: {
-        new: AGENT_METHODS.session_new,
-        load: AGENT_METHODS.session_load,
-        list: AGENT_METHODS.session_list,
-        delete: AGENT_METHODS.session_delete,
-        fork: AGENT_METHODS.session_fork,
-        resume: AGENT_METHODS.session_resume,
-        close: AGENT_METHODS.session_close,
-        setMode: AGENT_METHODS.session_set_mode,
-        setConfigOption: AGENT_METHODS.session_set_config_option,
-        prompt: AGENT_METHODS.session_prompt,
-        cancel: AGENT_METHODS.session_cancel
-      }
-    },
-    client: {
-      session: {
-        requestPermission: CLIENT_METHODS.session_request_permission,
-        update: CLIENT_METHODS.session_update
-      },
-      fs: {
-        writeTextFile: CLIENT_METHODS.fs_write_text_file,
-        readTextFile: CLIENT_METHODS.fs_read_text_file
-      },
-      elicitation: {
-        create: CLIENT_METHODS.elicitation_create,
-        complete: CLIENT_METHODS.elicitation_complete
-      }
-    }
-  };
-  const startActiveSession = Symbol("startActiveSession");
-  class AcpContext {
-    cx;
-    currentRequestId;
-    constructor(cx2, currentRequestId) {
-      this.cx = cx2;
-      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(cx2, requestId) {
-      super(cx2, requestId);
-    }
-    static create(cx2, requestId) {
-      return new AgentContext(cx2, 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(cx2, requestId) {
-      super(cx2, requestId);
-    }
-    static create(cx2, requestId) {
-      return new ClientContext(cx2, 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(connection2) {
-      this.connection = connection2;
-    }
-    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(connection2, connectHandlers = []) {
-      super(connection2);
-      this.connectHandlers = connectHandlers;
-      this.client = AgentContext.create(connection2.getContext());
-    }
-    startConnectHandlers() {
-      if (this.didStartConnectHandlers) {
-        return;
-      }
-      this.didStartConnectHandlers = true;
-      runConnectHandlers(this, this.connectHandlers);
-    }
-  }
-  class ClientConnectionHandle extends AcpConnectionHandle {
-    connectHandlers;
-    agent;
-    didStartConnectHandlers = false;
-    constructor(connection2, connectHandlers = []) {
-      super(connection2);
-      this.connectHandlers = connectHandlers;
-      this.agent = ClientContext.create(connection2.getContext());
-    }
-    startConnectHandlers() {
-      if (this.didStartConnectHandlers) {
-        return;
-      }
-      this.didStartConnectHandlers = true;
-      runConnectHandlers(this, this.connectHandlers);
-    }
-  }
-  function agentConnection(connection2, connectHandlers = []) {
-    return new AgentConnectionHandle(connection2, connectHandlers);
-  }
-  function clientConnection(connection2, connectHandlers = []) {
-    return new ClientConnectionHandle(connection2, 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((resolve2, reject) => {
-        this.waiters.push({
-          resolve: resolve2,
-          reject
-        });
-      });
-    }
-  }
-  function cloneNewSessionRequest(request) {
-    return {
-      ...request,
-      additionalDirectories: request.additionalDirectories ? [
-        ...request.additionalDirectories
-      ] : void 0,
-      mcpServers: [
-        ...request.mcpServers
-      ]
-    };
-  }
-  class SessionBuilder {
-    cx;
-    request;
-    constructor(cx2, request) {
-      this.cx = cx2;
-      this.request = cloneNewSessionRequest(request);
-    }
-    static create(cx2, request) {
-      return new SessionBuilder(cx2, 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(op2) {
-      const session = await this.start();
-      try {
-        return await op2(session);
-      } finally {
-        session.dispose();
-      }
-    }
-  }
-  class ActiveSession {
-    cx;
-    sessionResponse;
-    updates;
-    registrations;
-    constructor(cx2, sessionResponse, updates, registrations) {
-      this.cx = cx2;
-      this.sessionResponse = sessionResponse;
-      this.updates = updates;
-      this.registrations = registrations;
-    }
-    static create(cx2, sessionResponse, updates, registrations) {
-      return new ActiveSession(cx2, 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);
-      void 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, cx2) => {
-      const response = await handler(context(params, cx2, 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, cx2) => handler(context(params, cx2, cx2.signal)));
-  }
-  function specsByMethod(specs) {
-    const byMethod = {};
-    for (const spec of Object.values(specs)) {
-      byMethod[spec.method] = spec;
-    }
-    return byMethod;
-  }
-  const agentRequestSpecs = {
-    initialize: requestSpec(AGENT_METHODS.initialize, zInitializeRequest),
-    newSession: requestSpec(AGENT_METHODS.session_new, zNewSessionRequest),
-    loadSession: requestSpec(AGENT_METHODS.session_load, zLoadSessionRequest, emptyObjectResponse),
-    unstable_forkSession: requestSpec(AGENT_METHODS.session_fork, zForkSessionRequest),
-    listSessions: requestSpec(AGENT_METHODS.session_list, zListSessionsRequest),
-    deleteSession: requestSpec(AGENT_METHODS.session_delete, zDeleteSessionRequest, emptyObjectResponse),
-    resumeSession: requestSpec(AGENT_METHODS.session_resume, zResumeSessionRequest),
-    closeSession: requestSpec(AGENT_METHODS.session_close, zCloseSessionRequest, emptyObjectResponse),
-    setSessionMode: requestSpec(AGENT_METHODS.session_set_mode, zSetSessionModeRequest, emptyObjectResponse),
-    setSessionConfigOption: requestSpec(AGENT_METHODS.session_set_config_option, zSetSessionConfigOptionRequest),
-    authenticate: requestSpec(AGENT_METHODS.authenticate, zAuthenticateRequest, emptyObjectResponse),
-    unstable_listProviders: requestSpec(AGENT_METHODS.providers_list, zListProvidersRequest),
-    unstable_setProvider: requestSpec(AGENT_METHODS.providers_set, zSetProviderRequest, emptyObjectResponse),
-    unstable_disableProvider: requestSpec(AGENT_METHODS.providers_disable, zDisableProviderRequest, emptyObjectResponse),
-    logout: requestSpec(AGENT_METHODS.logout, zLogoutRequest, emptyObjectResponse),
-    prompt: requestSpec(AGENT_METHODS.session_prompt, zPromptRequest),
-    unstable_startNes: requestSpec(AGENT_METHODS.nes_start, zStartNesRequest),
-    unstable_suggestNes: requestSpec(AGENT_METHODS.nes_suggest, zSuggestNesRequest),
-    unstable_closeNes: requestSpec(AGENT_METHODS.nes_close, zCloseNesRequest, emptyObjectResponse)
-  };
-  const agentNotificationSpecs = {
-    cancel: notificationSpec(AGENT_METHODS.session_cancel, zCancelNotification),
-    unstable_didOpenDocument: notificationSpec(AGENT_METHODS.document_did_open, zDidOpenDocumentNotification),
-    unstable_didChangeDocument: notificationSpec(AGENT_METHODS.document_did_change, zDidChangeDocumentNotification),
-    unstable_didCloseDocument: notificationSpec(AGENT_METHODS.document_did_close, zDidCloseDocumentNotification),
-    unstable_didSaveDocument: notificationSpec(AGENT_METHODS.document_did_save, zDidSaveDocumentNotification),
-    unstable_didFocusDocument: notificationSpec(AGENT_METHODS.document_did_focus, zDidFocusDocumentNotification),
-    unstable_acceptNes: notificationSpec(AGENT_METHODS.nes_accept, zAcceptNesNotification),
-    unstable_rejectNes: notificationSpec(AGENT_METHODS.nes_reject, zRejectNesNotification)
-  };
-  const clientRequestSpecs = {
-    requestPermission: requestSpec(CLIENT_METHODS.session_request_permission, zRequestPermissionRequest),
-    writeTextFile: requestSpec(CLIENT_METHODS.fs_write_text_file, zWriteTextFileRequest, emptyObjectResponse),
-    readTextFile: requestSpec(CLIENT_METHODS.fs_read_text_file, zReadTextFileRequest),
-    createTerminal: requestSpec(CLIENT_METHODS.terminal_create, zCreateTerminalRequest),
-    terminalOutput: requestSpec(CLIENT_METHODS.terminal_output, zTerminalOutputRequest),
-    releaseTerminal: requestSpec(CLIENT_METHODS.terminal_release, zReleaseTerminalRequest, emptyObjectResponse),
-    waitForTerminalExit: requestSpec(CLIENT_METHODS.terminal_wait_for_exit, zWaitForTerminalExitRequest),
-    killTerminal: requestSpec(CLIENT_METHODS.terminal_kill, zKillTerminalRequest, emptyObjectResponse),
-    unstable_createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, zCreateElicitationRequest)
-  };
-  const clientNotificationSpecs = {
-    sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, zSessionNotification),
-    unstable_completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
-  };
-  const agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
-  const agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
-  const clientRequestSpecsByMethod = specsByMethod(clientRequestSpecs);
-  specsByMethod(clientNotificationSpecs);
-  function agentRequestContext(params, client, signal, requestId) {
-    return {
-      params,
-      requestId,
-      signal,
-      client
-    };
-  }
-  function agentNotificationContext(params, client, signal) {
-    return {
-      params,
-      signal,
-      client
-    };
-  }
-  class SessionUpdateRouter {
-    activeSessions = /* @__PURE__ */ new Map();
-    handleMessage(message) {
-      if (message.kind !== "notification" || message.method !== CLIENT_METHODS.session_update) {
-        return Handled.no(message);
-      }
-      const notification = zSessionNotification.parse(message.params);
-      const update = {
-        kind: "session_update",
-        notification,
-        update: notification.update
-      };
-      const activeSessions = this.activeSessions.get(notification.sessionId);
-      if (activeSessions && activeSessions.size > 0) {
-        for (const session of activeSessions) {
-          session.enqueue(update);
-        }
-      }
-      return Handled.no(message);
-    }
-    attach(response, updates) {
-      const sessions = this.activeSessions.get(response.sessionId) ?? /* @__PURE__ */ new Set();
-      sessions.add(updates);
-      this.activeSessions.set(response.sessionId, sessions);
-      return new HandlerRegistration(() => {
-        sessions.delete(updates);
-        if (sessions.size === 0) {
-          this.activeSessions.delete(response.sessionId);
-        }
-      });
-    }
-  }
-  const sessionUpdateRouters = /* @__PURE__ */ new WeakMap();
-  function sessionUpdateRouter(cx2) {
-    let router = sessionUpdateRouters.get(cx2);
-    if (!router) {
-      router = new SessionUpdateRouter();
-      sessionUpdateRouters.set(cx2, router);
-    }
-    return router;
-  }
-  function runConnectHandlers(connection2, handlers) {
-    for (const handler of handlers) {
-      let result;
-      try {
-        result = handler(connection2);
-      } catch (error) {
-        connection2.close(error);
-        throw error;
-      }
-      void Promise.resolve(result).catch((error) => {
-        connection2.close(error);
-      });
-    }
-  }
-  const appBuilder = Symbol("appBuilder");
-  const runAgentConnectHandlers = Symbol("runAgentConnectHandlers");
-  const runClientConnectHandlers = Symbol("runClientConnectHandlers");
-  const stableConnectionOptions = {
-    allowBatches: false
-  };
-  function agent$1(options) {
-    return new AgentApp(options);
-  }
-  class AgentApp {
-    builder = Connection.builder();
-    connectHandlers = [];
-    constructor(options = {}) {
-      if (options.name) {
-        this.builder.name(options.name);
-      }
-    }
-    [appBuilder]() {
-      return this.builder;
-    }
-    [runAgentConnectHandlers](connection2) {
-      runConnectHandlers(connection2, this.connectHandlers);
-    }
-    connect(target, options = {}) {
-      return this.connectConnection(target, options).connection;
-    }
-    connectWith(target, op2) {
-      const { rawConnection, connection: connection2 } = this.connectConnection(target);
-      return rawConnection.runUntil(() => op2(connection2.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, cx2, signal, requestId) => agentRequestContext(params, AgentContext.create(cx2, requestId), signal, requestId), handler);
-      return this;
-    }
-    notification(spec, handler) {
-      registerAppNotification(this.builder, spec, (params, cx2, signal) => agentNotificationContext(params, AgentContext.create(cx2), signal), handler);
-      return this;
-    }
-    connectConnection(target, options = {}) {
-      if (isStream(target)) {
-        const state2 = this.openStreamConnection(target);
-        if (!options.deferConnectHandlers) {
-          this[runAgentConnectHandlers](state2.connection);
-        }
-        return state2;
-      }
-      const [thisStream, peerStream] = memoryStreamPair();
-      const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
-      const peerConnection = clientConnection(peerRawConnection);
-      const state = this.openStreamConnection(thisStream);
-      void state.rawConnection.closed.then(() => peerConnection.close());
-      void peerRawConnection.closed.then(() => state.connection.close());
-      try {
-        target[runClientConnectHandlers](peerConnection);
-        this[runAgentConnectHandlers](state.connection);
-      } catch (error) {
-        peerConnection.close(error);
-        state.connection.close(error);
-        throw error;
-      }
-      return state;
-    }
-    openStreamConnection(stream) {
-      const rawConnection = this.builder.connect(stream, stableConnectionOptions);
-      return {
-        rawConnection,
-        connection: agentConnection(rawConnection, this.connectHandlers)
-      };
-    }
-  }
   function mcpElicitationToCreateRequest(request, sessionId) {
     if (request.mode === "url") {
       if (!request.url) {
@@ -57601,7 +54161,7 @@ ${content.text}
     }
   }
   function nodeToWebWritable(nodeStream) {
-    return new WritableStream$1({
+    return new WritableStream({
       write(chunk) {
         return new Promise((resolve2, reject) => {
           nodeStream.write(Buffer.from(chunk), (err) => {
@@ -57883,6 +54443,16 @@ ${content.text}
   const DEFAULT_FORCE_CANCEL_GRACE_MS = 3e4;
   const TURN_NO_RESULT_MESSAGE = "The turn ended without a result: the agent went idle while this prompt was still in flight (e.g. the model stream dropped mid-turn). Any partial output may be incomplete; please retry.";
   const STEER_METHOD = "_session/steering";
+  function getLodyForkTurnId(meta) {
+    if (!meta || typeof meta !== "object") return void 0;
+    const lody = meta.lody;
+    if (!lody || typeof lody !== "object") return void 0;
+    const forkAtTurn = lody.forkAtTurn;
+    if (!forkAtTurn || typeof forkAtTurn !== "object") return void 0;
+    const version = forkAtTurn.version;
+    const turnId = forkAtTurn.turnId;
+    return version === 1 && typeof turnId === "string" && turnId.length > 0 ? turnId : void 0;
+  }
   const STEER_PRIORITY = "now";
   function parseSteerRequest(params) {
     if (!params || typeof params !== "object") {
@@ -58320,6 +54890,11 @@ ${content.text}
                 version: 1,
                 appliedNotification: CLAUDE_STEER_APPLIED_METHOD
               }
+            },
+            lody: {
+              forkAtTurn: {
+                version: 1
+              }
             }
           },
           promptCapabilities: {
@@ -58377,6 +54952,7 @@ ${content.text}
       };
     }
     async unstable_forkSession(params) {
+      const forkTurnId = getLodyForkTurnId(params._meta);
       const response = await this.createSession({
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
@@ -58384,7 +54960,8 @@ ${content.text}
         _meta: params._meta
       }, {
         resume: params.sessionId,
-        forkSession: true
+        forkSession: true,
+        resumeSessionAt: forkTurnId
       });
       setTimeout(() => {
         this.sendAvailableCommandsUpdate(response.sessionId);
@@ -58687,14 +55264,14 @@ ${content.text}
         session.pendingOrphanResults = 0;
         session.orphanCommands?.clear();
         if (!turn.isLocalOnlyCommand) {
-          for (const [taskId, record2] of session.liveBackgroundTasks) {
-            if (!record2.endedPerLevel) {
+          for (const [taskId, record] of session.liveBackgroundTasks) {
+            if (!record.endedPerLevel) {
               continue;
             }
-            if (record2.endedPerLevel === "sweep-armed") {
+            if (record.endedPerLevel === "sweep-armed") {
               session.liveBackgroundTasks.delete(taskId);
             } else {
-              record2.endedPerLevel = "sweep-armed";
+              record.endedPerLevel = "sweep-armed";
             }
           }
         }
@@ -58763,8 +55340,8 @@ ${content.text}
           return false;
         }
         for (const taskId of turn.spawnedTaskIds) {
-          const record2 = session.liveBackgroundTasks.get(taskId);
-          if (record2?.isSubagent && !record2.endedPerLevel) {
+          const record = session.liveBackgroundTasks.get(taskId);
+          if (record?.isSubagent && !record.endedPerLevel) {
             return true;
           }
         }
@@ -59250,13 +55827,13 @@ ${message.api_refusal_explanation}` : "";
                 case "background_tasks_changed":
                   if (session.liveBackgroundTasks.size > 0) {
                     const live = new Set(message.tasks.map((t) => t.task_id));
-                    for (const [taskId, record2] of session.liveBackgroundTasks) {
+                    for (const [taskId, record] of session.liveBackgroundTasks) {
                       if (live.has(taskId)) {
-                        record2.endedPerLevel = void 0;
+                        record.endedPerLevel = void 0;
                         continue;
                       }
-                      if (record2.isSubagent) {
-                        record2.endedPerLevel ??= "ended";
+                      if (record.isSubagent) {
+                        record.endedPerLevel ??= "ended";
                       } else {
                         session.liveBackgroundTasks.delete(taskId);
                       }
@@ -59516,10 +56093,6 @@ ${message.api_refusal_explanation}` : "";
             }
             case "user":
             case "assistant": {
-              const mappedMessageId = messageIdForGrouping(message);
-              if (mappedMessageId && typeof message.uuid === "string" && message.uuid.length > 0) {
-                session.messageIdToUuid.set(mappedMessageId, message.uuid);
-              }
               if (message.type === "user" && "uuid" in message && message.uuid) {
                 const queued = findUnsettledTurn(message.uuid);
                 if (queued) {
@@ -59645,6 +56218,9 @@ ${message.api_refusal_explanation}` : "";
               })) {
                 await sendUpdate(notification);
               }
+              if (message.type === "assistant" && message.parent_tool_use_id === null && typeof message.uuid === "string" && message.uuid.length > 0) {
+                await sendUpdate(createClaudeTurnBoundaryUpdate(params.sessionId, message.uuid));
+              }
               break;
             }
             case "tool_progress": {
@@ -59955,10 +56531,6 @@ ${message.api_refusal_explanation}` : "";
       const messages = await Rkt(sessionId);
       for (const message of messages) {
         const replayMessageId = messageIdForGrouping(message);
-        const replaySession = this.sessions[sessionId];
-        if (replaySession && replayMessageId && message.uuid) {
-          replaySession.messageIdToUuid.set(replayMessageId, message.uuid);
-        }
         if (message.type === "assistant" && isSyntheticLoginMessage(message.message)) {
           continue;
         }
@@ -59976,6 +56548,9 @@ ${message.api_refusal_explanation}` : "";
         })) {
           await this.client.sessionUpdate(notification);
         }
+        if (message.type === "assistant" && message.parent_tool_use_id === null && typeof message.uuid === "string" && message.uuid.length > 0) {
+          await this.client.sessionUpdate(createClaudeTurnBoundaryUpdate(sessionId, message.uuid));
+        }
       }
     }
     async readTextFile(params) {
@@ -60838,8 +57413,7 @@ ${message.api_refusal_explanation}` : "";
         emittedToolCalls: /* @__PURE__ */ new Set(),
         liveBackgroundTasks: /* @__PURE__ */ new Map(),
         emittedAssistantText: false,
-        owedTrailingIdles: 0,
-        messageIdToUuid: /* @__PURE__ */ new Map()
+        owedTrailingIdles: 0
       };
       return {
         sessionId,
@@ -61476,6 +58050,19 @@ ${chunk.resource.text}
       update.messageId = messageId;
     }
   }
+  function createClaudeTurnBoundaryUpdate(sessionId, turnId) {
+    return {
+      sessionId,
+      update: {
+        sessionUpdate: "session_info_update",
+        _meta: {
+          lody: {
+            turnId
+          }
+        }
+      }
+    };
+  }
   function isTaskTool(toolName) {
     return toolName === "TaskCreate" || toolName === "TaskUpdate" || toolName === "TaskList" || toolName === "TaskGet";
   }