kennel 0.2.12 → 0.2.15

package/node_modules/@agentclientprotocol/sdk/dist/v2/acp.js

@@ -1,1183 +0,0 @@
-/**
- * Experimental TypeScript API for the draft ACP v2 protocol.
- *
- * @remarks
- * ACP v2 is still a draft. Its wire protocol and this API may change
- * incompatibly in any SDK release. The stable package entry point remains ACP
- * v1; consumers must opt in through
- * `@agentclientprotocol/sdk/experimental/v2`.
- *
- * @packageDocumentation
- * @experimental
- */
-import * as schema from "./schema/index.js";
-import * as validate from "./schema/zod.gen.js";
-import * as guards from "./schema/guards.gen.js";
-import { ndJsonStream as createJsonStream } from "../stream.js";
-// Runtime narrowing helpers for extensible unions, exposed as companion values
-// that merge (declaration merging) with the like-named types — e.g.
-// `CreateElicitationResponse.isAccept(response)`. See schema/guards.gen.ts.
-//
-// Listed explicitly (not `export *`) so each value+type pair merges rather than
-// colliding with the `export type *` above. The guards.gen re-export test
-// asserts this list stays in sync as new extensible unions are added.
-export { AuthMethod, AvailableCommandInput, ContentBlock, CreateElicitationRequest, CreateElicitationResponse, DiffChange, ElicitationPropertySchema, McpServer, MultiSelectItems, NesSuggestion, PlanUpdateContent, ReplayFrom, RequestPermissionOutcome, RequestPermissionSubject, SessionConfigOption, SessionUpdate, SetSessionConfigOptionRequest, StateUpdate, ToolCallContent, } from "./schema/guards.gen.js";
-export { AGENT_METHODS, CLIENT_METHODS, PROTOCOL_METHODS, PROTOCOL_VERSION, } from "./schema/index.js";
-/**
- * Creates an experimental draft ACP v2 stream from newline-delimited JSON.
- *
- * Individual and batch JSON-RPC messages are accepted by default.
- *
- * @experimental
- */
-export function ndJsonStream(output, input) {
-    return createJsonStream(output, input);
-}
-export { RequestError, batchNotification, batchRequest } from "../jsonrpc.js";
-export { AgentProtocolRouter, agentProtocolRouter, } from "../protocol-router.js";
-import { Connection, Handled, HandlerRegistration, RequestError, } from "../jsonrpc.js";
-function emptyObjectResponse(response) {
-    return response ?? {};
-}
-function assertV2Method(method, builtIns, kind, allowProtocolNotification = false) {
-    if (Object.hasOwn(builtIns, method) ||
-        (allowProtocolNotification &&
-            method === schema.PROTOCOL_METHODS.cancel_request)) {
-        return;
-    }
-    if (!method.startsWith("_")) {
-        throw new TypeError(`Custom ACP v2 ${kind} method '${method}' must start with '_'`);
-    }
-}
-function assertV2BatchMethods(entries, requestMethods, notificationMethods) {
-    for (const entry of entries) {
-        assertV2Method(entry.method, entry.kind === "request" ? requestMethods : notificationMethods, entry.kind, entry.kind === "notification");
-    }
-}
-function parseV2InitializeRequest(params) {
-    const request = validate.zInitializeRequest.parse(params);
-    if (request.protocolVersion !== schema.PROTOCOL_VERSION) {
-        throw RequestError.invalidParams({
-            expectedProtocolVersion: schema.PROTOCOL_VERSION,
-            receivedProtocolVersion: request.protocolVersion,
-        }, `The v2 API only supports protocol version ${schema.PROTOCOL_VERSION}`);
-    }
-    return request;
-}
-function normalizeOutgoingV2InitializeRequest(params) {
-    const request = typeof params === "object" && params !== null && !Array.isArray(params)
-        ? params
-        : {};
-    return parseV2InitializeRequest({
-        ...request,
-        protocolVersion: schema.PROTOCOL_VERSION,
-    });
-}
-function mapV2InitializeResponse(response) {
-    const parsed = validate.zInitializeResponse.parse(response);
-    if (parsed.protocolVersion !== schema.PROTOCOL_VERSION) {
-        throw RequestError.invalidRequest({
-            expectedProtocolVersion: schema.PROTOCOL_VERSION,
-            receivedProtocolVersion: parsed.protocolVersion,
-        }, `The v2 API only supports protocol version ${schema.PROTOCOL_VERSION}`);
-    }
-    return parsed;
-}
-function normalizeClientBatch(entries) {
-    return entries.map((entry) => {
-        if (entry.kind !== "request" ||
-            entry.method !== schema.AGENT_METHODS.initialize) {
-            return entry;
-        }
-        const mapResponse = entry.mapResponse;
-        return {
-            ...entry,
-            params: normalizeOutgoingV2InitializeRequest(entry.params),
-            mapResponse: (response) => {
-                const parsed = mapV2InitializeResponse(response);
-                return mapResponse ? mapResponse(parsed) : parsed;
-            },
-        };
-    });
-}
-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,
-        },
-    ];
-}
-/**
- * ACP method-name constants for the experimental draft v2 API.
- *
- * Use these with `onRequest(...)`, `onNotification(...)`, `request(...)`, and
- * `notify(...)` when you want literal-string type inference without spelling
- * protocol strings inline.
- *
- * @experimental
- */
-export const methods = {
-    agent: {
-        initialize: schema.AGENT_METHODS.initialize,
-        auth: {
-            login: schema.AGENT_METHODS.auth_login,
-            logout: schema.AGENT_METHODS.auth_logout,
-        },
-        providers: {
-            list: schema.AGENT_METHODS.providers_list,
-            set: schema.AGENT_METHODS.providers_set,
-            disable: schema.AGENT_METHODS.providers_disable,
-        },
-        session: {
-            new: schema.AGENT_METHODS.session_new,
-            list: schema.AGENT_METHODS.session_list,
-            delete: schema.AGENT_METHODS.session_delete,
-            fork: schema.AGENT_METHODS.session_fork,
-            resume: schema.AGENT_METHODS.session_resume,
-            close: schema.AGENT_METHODS.session_close,
-            setConfigOption: schema.AGENT_METHODS.session_set_config_option,
-            prompt: schema.AGENT_METHODS.session_prompt,
-            cancel: schema.AGENT_METHODS.session_cancel,
-        },
-        mcp: {
-            message: schema.AGENT_METHODS.mcp_message,
-        },
-        nes: {
-            start: schema.AGENT_METHODS.nes_start,
-            suggest: schema.AGENT_METHODS.nes_suggest,
-            accept: schema.AGENT_METHODS.nes_accept,
-            reject: schema.AGENT_METHODS.nes_reject,
-            close: schema.AGENT_METHODS.nes_close,
-        },
-        document: {
-            didOpen: schema.AGENT_METHODS.document_did_open,
-            didChange: schema.AGENT_METHODS.document_did_change,
-            didClose: schema.AGENT_METHODS.document_did_close,
-            didSave: schema.AGENT_METHODS.document_did_save,
-            didFocus: schema.AGENT_METHODS.document_did_focus,
-        },
-    },
-    client: {
-        session: {
-            requestPermission: schema.CLIENT_METHODS.session_request_permission,
-            update: schema.CLIENT_METHODS.session_update,
-        },
-        mcp: {
-            connect: schema.CLIENT_METHODS.mcp_connect,
-            message: schema.CLIENT_METHODS.mcp_message,
-            disconnect: schema.CLIENT_METHODS.mcp_disconnect,
-        },
-        elicitation: {
-            create: schema.CLIENT_METHODS.elicitation_create,
-            complete: schema.CLIENT_METHODS.elicitation_complete,
-        },
-    },
-    protocol: {
-        cancelRequest: schema.PROTOCOL_METHODS.cancel_request,
-    },
-};
-const startActiveSession = Symbol("startActiveSession");
-class AcpContext {
-    cx;
-    currentRequestId;
-    /** @internal */
-    constructor(cx, currentRequestId) {
-        this.cx = cx;
-        this.currentRequestId = currentRequestId;
-    }
-    /**
-     * JSON-RPC id of the request currently being handled.
-     *
-     * This is `undefined` for notification handlers and for contexts created
-     * outside an inbound request, such as `connect(...)` and `connectWith(...)`.
-     */
-    get requestId() {
-        return this.currentRequestId;
-    }
-    /** @internal */
-    get connectionContext() {
-        return this.cx;
-    }
-    /** @internal */
-    sendRequest(method, params, mapResponse, options) {
-        return this.cx.sendRequest(method, params, mapResponse, options);
-    }
-    /** @internal */
-    sendNotification(method, params) {
-        return this.cx.sendNotification(method, params);
-    }
-    /** @internal */
-    sendBatch(entries) {
-        return this.cx.sendBatch(entries);
-    }
-    /** @internal */
-    addDynamicHandler(handler) {
-        return this.cx.addDynamicHandler(handler);
-    }
-}
-/**
- * Experimental draft ACP v2 context passed to agent-side handlers.
- *
- * Agents use this context to call client-side ACP methods while handling
- * requests such as `session/prompt`.
- *
- * @experimental
- */
-export class AgentContext extends AcpContext {
-    constructor(cx, requestId) {
-        super(cx, requestId);
-    }
-    /** @internal */
-    static create(cx, requestId) {
-        return new AgentContext(cx, requestId);
-    }
-    request(method, params, options) {
-        assertV2Method(method, clientRequestSpecsByMethod, "request");
-        const spec = clientRequestSpecsByMethod[method];
-        return this.sendRequest(method, params, spec?.mapResponse, options);
-    }
-    notify(method, params) {
-        assertV2Method(method, clientNotificationSpecsByMethod, "notification", true);
-        return this.sendNotification(method, params);
-    }
-    /**
-     * Sends requests and notifications to the client as one JSON-RPC batch.
-     */
-    batch(entries) {
-        assertV2BatchMethods(entries, clientRequestSpecsByMethod, clientNotificationSpecsByMethod);
-        return this.sendBatch(entries);
-    }
-}
-/**
- * Experimental draft ACP v2 context used by clients to call agent-side ACP
- * methods.
- *
- * `connectWith` passes a `ClientContext` to the callback. Client handlers also
- * receive one as `ctx.agent` when they need to call back into the agent.
- *
- * @experimental
- */
-export class ClientContext extends AcpContext {
-    constructor(cx, requestId) {
-        super(cx, requestId);
-    }
-    /** @internal */
-    static create(cx, requestId) {
-        return new ClientContext(cx, requestId);
-    }
-    /** @internal */
-    [startActiveSession](params, options) {
-        return this.sendRequest(schema.AGENT_METHODS.session_new, params, (response) => this.attachSession(response), options);
-    }
-    buildSession(cwdOrRequest) {
-        if (typeof cwdOrRequest === "string") {
-            return SessionBuilder.create(this, {
-                cwd: cwdOrRequest,
-                mcpServers: [],
-            });
-        }
-        return SessionBuilder.create(this, cwdOrRequest);
-    }
-    /**
-     * Builds active-session helpers around a `session/new` response.
-     */
-    attachSession(response) {
-        const updates = new AsyncQueue();
-        const activePrompts = new Set();
-        const activeSessionQueue = {
-            enqueue: (value) => updates.enqueue(value),
-            reject: (error) => updates.reject(error),
-            clearErrors: () => updates.clearErrors(),
-            fail: (error) => updates.fail(error),
-            next: () => updates.next(),
-            nextAfter: (cursor, signal) => updates.nextAfter(cursor, signal),
-            beginPrompt: () => {
-                const prompt = {
-                    updateCursor: updates.cursor(),
-                    overlapController: new AbortController(),
-                };
-                if (activePrompts.size > 0) {
-                    const error = new Error("readText() cannot attribute updates across overlapping prompts; use nextUpdate() instead");
-                    for (const activePrompt of activePrompts) {
-                        activePrompt.overlapController.abort(error);
-                    }
-                    prompt.overlapController.abort(error);
-                }
-                activePrompts.add(prompt);
-                return prompt;
-            },
-            cancelPrompt: (prompt) => activePrompts.delete(prompt),
-            isAwaitingPromptCompletion: () => activePrompts.size > 0,
-            completePrompt: () => {
-                activePrompts.clear();
-            },
-        };
-        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, activeSessionQueue);
-        const closeRegistration = new HandlerRegistration(() => {
-            closeSignal.removeEventListener("abort", failUpdatesOnClose);
-        });
-        return ActiveSession.create(this, response, activeSessionQueue, [
-            sessionRegistration,
-            closeRegistration,
-        ]);
-    }
-    request(method, params, options) {
-        assertV2Method(method, agentRequestSpecsByMethod, "request");
-        const spec = agentRequestSpecsByMethod[method];
-        const wireParams = method === schema.AGENT_METHODS.initialize
-            ? normalizeOutgoingV2InitializeRequest(params)
-            : params;
-        return this.sendRequest(method, wireParams, spec?.mapResponse, options);
-    }
-    notify(method, params) {
-        assertV2Method(method, agentNotificationSpecsByMethod, "notification", true);
-        return this.sendNotification(method, params);
-    }
-    /**
-     * Sends requests and notifications to the agent as one JSON-RPC batch.
-     */
-    batch(entries) {
-        assertV2BatchMethods(entries, agentRequestSpecsByMethod, agentNotificationSpecsByMethod);
-        return this.sendBatch(normalizeClientBatch(entries));
-    }
-}
-class AcpConnectionHandle {
-    connection;
-    constructor(connection) {
-        this.connection = connection;
-    }
-    get signal() {
-        return this.connection.signal;
-    }
-    get closed() {
-        return this.connection.closed;
-    }
-    close(error) {
-        this.connection.close(error);
-    }
-}
-class AgentConnectionHandle extends AcpConnectionHandle {
-    connectHandlers;
-    client;
-    didStartConnectHandlers = false;
-    constructor(connection, connectHandlers = []) {
-        super(connection);
-        this.connectHandlers = connectHandlers;
-        this.client = AgentContext.create(connection.getContext());
-    }
-    /** @internal */
-    startConnectHandlers() {
-        if (this.didStartConnectHandlers) {
-            return;
-        }
-        this.didStartConnectHandlers = true;
-        runConnectHandlers(this, this.connectHandlers);
-    }
-}
-class ClientConnectionHandle extends AcpConnectionHandle {
-    connectHandlers;
-    agent;
-    didStartConnectHandlers = false;
-    constructor(connection, connectHandlers = []) {
-        super(connection);
-        this.connectHandlers = connectHandlers;
-        this.agent = ClientContext.create(connection.getContext());
-    }
-    /** @internal */
-    startConnectHandlers() {
-        if (this.didStartConnectHandlers) {
-            return;
-        }
-        this.didStartConnectHandlers = true;
-        runConnectHandlers(this, this.connectHandlers);
-    }
-}
-function agentConnection(connection, connectHandlers = []) {
-    return new AgentConnectionHandle(connection, connectHandlers);
-}
-function clientConnection(connection, connectHandlers = []) {
-    return new ClientConnectionHandle(connection, connectHandlers);
-}
-class AsyncQueue {
-    values = [];
-    waiters = [];
-    failed = false;
-    failure;
-    nextSequence = 0;
-    enqueue(value) {
-        if (this.failed) {
-            return;
-        }
-        const sequence = this.nextSequence++;
-        const waiter = this.waiters.shift();
-        if (waiter) {
-            waiter.resolve(value);
-        }
-        else {
-            this.values.push({ kind: "value", value, sequence });
-        }
-    }
-    reject(error) {
-        if (this.failed) {
-            return;
-        }
-        const sequence = this.nextSequence++;
-        if (this.waiters.length > 0) {
-            for (const waiter of this.waiters.splice(0)) {
-                waiter.reject(error);
-            }
-            return;
-        }
-        this.values.push({ kind: "error", error, sequence });
-    }
-    clearErrors() {
-        this.values = this.values.filter((entry) => entry.kind === "value");
-    }
-    cursor() {
-        return this.nextSequence;
-    }
-    nextAfter(cursor, signal) {
-        if (signal?.aborted) {
-            return Promise.reject(signal.reason);
-        }
-        while (this.values[0] && this.values[0].sequence < cursor) {
-            this.values.shift();
-        }
-        return this.next(signal);
-    }
-    fail(error) {
-        if (this.failed) {
-            return;
-        }
-        this.failed = true;
-        this.failure = error;
-        for (const waiter of this.waiters.splice(0)) {
-            waiter.reject(error);
-        }
-    }
-    next(signal) {
-        if (signal?.aborted) {
-            return Promise.reject(signal.reason);
-        }
-        if (this.values.length > 0) {
-            const entry = this.values.shift();
-            if (entry.kind === "error") {
-                return Promise.reject(entry.error);
-            }
-            return Promise.resolve(entry.value);
-        }
-        if (this.failed) {
-            return Promise.reject(this.failure);
-        }
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                signal?.removeEventListener("abort", onAbort);
-            };
-            const waiter = {
-                resolve: (value) => {
-                    cleanup();
-                    resolve(value);
-                },
-                reject: (error) => {
-                    cleanup();
-                    reject(error);
-                },
-            };
-            const onAbort = () => {
-                const index = this.waiters.indexOf(waiter);
-                if (index >= 0) {
-                    this.waiters.splice(index, 1);
-                }
-                waiter.reject(signal?.reason);
-            };
-            this.waiters.push(waiter);
-            signal?.addEventListener("abort", onAbort, { once: true });
-            if (signal?.aborted) {
-                onAbort();
-            }
-        });
-    }
-}
-function cloneNewSessionRequest(request) {
-    return structuredClone(request);
-}
-/**
- * Experimental draft ACP v2 builder for creating an `ActiveSession`.
- *
- * Start from `ctx.buildSession("/absolute/cwd")` for the common case, or
- * pass a full `NewSessionRequest` to `ctx.buildSession(...)` when the session
- * needs MCP servers, `_meta`, or additional request fields. All paths in ACP
- * payloads should be absolute.
- *
- * @experimental
- */
-export class SessionBuilder {
-    cx;
-    request;
-    constructor(cx, request) {
-        this.cx = cx;
-        this.request = cloneNewSessionRequest(request);
-    }
-    /** @internal */
-    static create(cx, request) {
-        return new SessionBuilder(cx, request);
-    }
-    /**
-     * Returns the `session/new` request that will be sent.
-     *
-     * The returned object is a defensive copy, so mutating it does not change the
-     * builder.
-     */
-    toRequest() {
-        return cloneNewSessionRequest(this.request);
-    }
-    /**
-     * Replaces the additional workspace roots for this session.
-     *
-     * `additionalDirectories` expand the session's file-system scope without
-     * changing `cwd`. Each path should be absolute.
-     */
-    withAdditionalDirectories(additionalDirectories) {
-        this.request = {
-            ...this.request,
-            additionalDirectories: [...additionalDirectories],
-        };
-        return this;
-    }
-    /**
-     * Adds one MCP server to the `session/new` request.
-     */
-    withMcpServer(mcpServer) {
-        this.request = {
-            ...this.request,
-            mcpServers: [
-                ...(this.request.mcpServers ?? []),
-                structuredClone(mcpServer),
-            ],
-        };
-        return this;
-    }
-    /**
-     * Starts the session and returns an `ActiveSession` for prompting and reading
-     * updates.
-     *
-     * Call `dispose()` on the returned session when you no longer need update
-     * routing, or use `withSession(...)` to scope disposal automatically.
-     */
-    async start(options) {
-        return this.cx[startActiveSession](this.toRequest(), options);
-    }
-    /**
-     * Starts the session, runs `op`, and disposes the active-session update
-     * routing when `op` finishes or throws.
-     */
-    async withSession(op) {
-        const session = await this.start();
-        try {
-            return await op(session);
-        }
-        finally {
-            session.dispose();
-        }
-    }
-}
-/**
- * Experimental draft ACP v2 convenience wrapper for an active session.
- *
- * An active session routes `session/update` notifications for one session ID
- * into an async queue. Use `prompt(...)` to send user content, then read updates
- * with `nextUpdate()` until a `stop` message is returned.
- *
- * @experimental
- */
-export class ActiveSession {
-    cx;
-    sessionResponse;
-    updates;
-    registrations;
-    latestPrompt;
-    constructor(cx, sessionResponse, updates, registrations) {
-        this.cx = cx;
-        this.sessionResponse = sessionResponse;
-        this.updates = updates;
-        this.registrations = registrations;
-    }
-    /** @internal */
-    static create(cx, sessionResponse, updates, registrations) {
-        return new ActiveSession(cx, sessionResponse, updates, registrations);
-    }
-    /**
-     * Session ID returned by `session/new`.
-     */
-    get sessionId() {
-        return this.sessionResponse.sessionId;
-    }
-    /**
-     * Configuration options returned when the session was created, if provided.
-     */
-    get configOptions() {
-        return this.sessionResponse.configOptions;
-    }
-    /**
-     * Metadata returned when the session was created.
-     */
-    get meta() {
-        return this.sessionResponse._meta;
-    }
-    /**
-     * Full response returned by `session/new`.
-     */
-    get newSessionResponse() {
-        return this.sessionResponse;
-    }
-    /**
-     * Sends a prompt to this session.
-     *
-     * Strings are converted to one text content block. A single content block is
-     * wrapped in an array. The returned promise resolves when the agent accepts
-     * the prompt. Completion is reported separately by an idle `state_update`,
-     * which is queued as a `stop` message for `nextUpdate()`.
-     */
-    prompt(prompt, options) {
-        this.updates.clearErrors();
-        const activePrompt = this.updates.beginPrompt();
-        this.latestPrompt = activePrompt;
-        const response = this.cx.request(schema.AGENT_METHODS.session_prompt, {
-            sessionId: this.sessionId,
-            prompt: this.promptBlocks(prompt),
-        }, options);
-        void response.catch((error) => {
-            if (this.updates.cancelPrompt(activePrompt)) {
-                this.updates.reject(error);
-            }
-        });
-        return response;
-    }
-    /**
-     * Reads the next update or stop message for this session.
-     */
-    nextUpdate() {
-        return this.updates.next();
-    }
-    /**
-     * Reads agent text until the current prompt turn stops.
-     *
-     * Updates queued before the most recent call to `prompt(...)` are skipped.
-     * Call prompts serially, after the preceding turn reports `stop`: session
-     * updates do not carry a prompt ID and cannot be attributed across overlapping
-     * prompt requests. Use `nextUpdate()` when coordinating requests directly.
-     *
-     * Full `agent_message` updates replace content for their `messageId`, while
-     * `agent_message_chunk` updates append to it. Non-text content and other
-     * update types are ignored; use `nextUpdate()` when you need them.
-     */
-    async readText() {
-        const activePrompt = this.latestPrompt;
-        const updateCursor = activePrompt?.updateCursor;
-        const messageOrder = [];
-        const messageContent = new Map();
-        const ensureMessage = (messageId) => {
-            let content = messageContent.get(messageId);
-            if (!content) {
-                content = [];
-                messageOrder.push(messageId);
-                messageContent.set(messageId, content);
-            }
-            return content;
-        };
-        for (;;) {
-            const message = updateCursor === undefined
-                ? await this.nextUpdate()
-                : await this.updates.nextAfter(updateCursor, activePrompt?.overlapController.signal);
-            if (message.kind === "stop") {
-                return messageOrder
-                    .flatMap((messageId) => messageContent.get(messageId) ?? [])
-                    .filter(guards.ContentBlock.isText)
-                    .map((content) => content.text)
-                    .join("");
-            }
-            const { update } = message;
-            if (guards.SessionUpdate.isAgentMessage(update)) {
-                ensureMessage(update.messageId);
-                if (update.content !== undefined) {
-                    messageContent.set(update.messageId, update.content ?? []);
-                }
-            }
-            else if (guards.SessionUpdate.isAgentMessageChunk(update)) {
-                ensureMessage(update.messageId).push(update.content);
-            }
-        }
-    }
-    /**
-     * Stops routing updates to this active-session helper.
-     *
-     * This does not close the ACP session on the agent. Use `ClientContext`
-     * session lifecycle methods when the protocol session itself should be closed
-     * or deleted.
-     */
-    dispose() {
-        for (const registration of this.registrations.splice(0)) {
-            registration.dispose();
-        }
-        this.updates.fail(new Error("Active session disposed"));
-    }
-    /**
-     * Supports explicit resource management with `using`.
-     */
-    [Symbol.dispose]() {
-        this.dispose();
-    }
-    promptBlocks(prompt) {
-        if (typeof prompt === "string") {
-            return [{ type: "text", text: prompt }];
-        }
-        if (Array.isArray(prompt)) {
-            return prompt;
-        }
-        return [prompt];
-    }
-}
-function parseParams(parser, params) {
-    if (!parser) {
-        return params;
-    }
-    if (typeof parser === "function") {
-        return parser(params);
-    }
-    return parser.parse(params);
-}
-function requestSpec(method, params, mapResponse) {
-    return { method, params, mapResponse };
-}
-function notificationSpec(method, params) {
-    return { method, params };
-}
-function registerAppRequest(builder, spec, context, handler) {
-    builder.onReceiveRequest(spec.method, (params) => parseParams(spec.params, params), async (params, responder, cx) => {
-        const response = await handler(context(params, cx, responder.signal, responder.id));
-        await responder.respond((spec.mapResponse
-            ? spec.mapResponse(response)
-            : response));
-    });
-}
-function registerAppNotification(builder, spec, context, handler) {
-    builder.onReceiveNotification(spec.method, (params) => parseParams(spec.params, params), (params, cx) => handler(context(params, cx, cx.signal)));
-}
-function specsByMethod(specs) {
-    const byMethod = Object.create(null);
-    for (const spec of Object.values(specs)) {
-        byMethod[spec.method] = spec;
-    }
-    return byMethod;
-}
-const agentRequestSpecs = {
-    initialize: requestSpec(schema.AGENT_METHODS.initialize, parseV2InitializeRequest, mapV2InitializeResponse),
-    loginAuth: requestSpec(schema.AGENT_METHODS.auth_login, validate.zLoginAuthRequest, emptyObjectResponse),
-    unstable_listProviders: requestSpec(schema.AGENT_METHODS.providers_list, validate.zListProvidersRequest),
-    unstable_setProvider: requestSpec(schema.AGENT_METHODS.providers_set, validate.zSetProviderRequest, emptyObjectResponse),
-    unstable_disableProvider: requestSpec(schema.AGENT_METHODS.providers_disable, validate.zDisableProviderRequest, emptyObjectResponse),
-    newSession: requestSpec(schema.AGENT_METHODS.session_new, validate.zNewSessionRequest),
-    setSessionConfigOption: requestSpec(schema.AGENT_METHODS.session_set_config_option, validate.zSetSessionConfigOptionRequest),
-    prompt: requestSpec(schema.AGENT_METHODS.session_prompt, validate.zPromptRequest, emptyObjectResponse),
-    unstable_messageMcp: requestSpec(schema.AGENT_METHODS.mcp_message, validate.zMessageMcpRequest),
-    listSessions: requestSpec(schema.AGENT_METHODS.session_list, validate.zListSessionsRequest),
-    deleteSession: requestSpec(schema.AGENT_METHODS.session_delete, validate.zDeleteSessionRequest, emptyObjectResponse),
-    unstable_forkSession: requestSpec(schema.AGENT_METHODS.session_fork, validate.zForkSessionRequest),
-    resumeSession: requestSpec(schema.AGENT_METHODS.session_resume, validate.zResumeSessionRequest),
-    closeSession: requestSpec(schema.AGENT_METHODS.session_close, validate.zCloseSessionRequest, emptyObjectResponse),
-    logoutAuth: requestSpec(schema.AGENT_METHODS.auth_logout, validate.zLogoutAuthRequest, emptyObjectResponse),
-    unstable_startNes: requestSpec(schema.AGENT_METHODS.nes_start, validate.zStartNesRequest),
-    unstable_suggestNes: requestSpec(schema.AGENT_METHODS.nes_suggest, validate.zSuggestNesRequest),
-    unstable_closeNes: requestSpec(schema.AGENT_METHODS.nes_close, validate.zCloseNesRequest, emptyObjectResponse),
-};
-const agentNotificationSpecs = {
-    cancelSession: notificationSpec(schema.AGENT_METHODS.session_cancel, validate.zCancelSessionNotification),
-    unstable_messageMcp: notificationSpec(schema.AGENT_METHODS.mcp_message, validate.zMessageMcpNotification),
-    unstable_didOpenDocument: notificationSpec(schema.AGENT_METHODS.document_did_open, validate.zDidOpenDocumentNotification),
-    unstable_didChangeDocument: notificationSpec(schema.AGENT_METHODS.document_did_change, validate.zDidChangeDocumentNotification),
-    unstable_didCloseDocument: notificationSpec(schema.AGENT_METHODS.document_did_close, validate.zDidCloseDocumentNotification),
-    unstable_didSaveDocument: notificationSpec(schema.AGENT_METHODS.document_did_save, validate.zDidSaveDocumentNotification),
-    unstable_didFocusDocument: notificationSpec(schema.AGENT_METHODS.document_did_focus, validate.zDidFocusDocumentNotification),
-    unstable_acceptNes: notificationSpec(schema.AGENT_METHODS.nes_accept, validate.zAcceptNesNotification),
-    unstable_rejectNes: notificationSpec(schema.AGENT_METHODS.nes_reject, validate.zRejectNesNotification),
-};
-const clientRequestSpecs = {
-    requestPermission: requestSpec(schema.CLIENT_METHODS.session_request_permission, validate.zRequestPermissionRequest),
-    unstable_connectMcp: requestSpec(schema.CLIENT_METHODS.mcp_connect, validate.zConnectMcpRequest),
-    unstable_messageMcp: requestSpec(schema.CLIENT_METHODS.mcp_message, validate.zMessageMcpRequest),
-    unstable_disconnectMcp: requestSpec(schema.CLIENT_METHODS.mcp_disconnect, validate.zDisconnectMcpRequest, emptyObjectResponse),
-    unstable_createElicitation: requestSpec(schema.CLIENT_METHODS.elicitation_create, validate.zCreateElicitationRequest),
-};
-const clientNotificationSpecs = {
-    sessionUpdate: notificationSpec(schema.CLIENT_METHODS.session_update, validate.zUpdateSessionNotification),
-    unstable_messageMcp: notificationSpec(schema.CLIENT_METHODS.mcp_message, validate.zMessageMcpNotification),
-    unstable_completeElicitation: notificationSpec(schema.CLIENT_METHODS.elicitation_complete, validate.zCompleteElicitationNotification),
-};
-const agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
-const agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
-const clientRequestSpecsByMethod = specsByMethod(clientRequestSpecs);
-const clientNotificationSpecsByMethod = specsByMethod(clientNotificationSpecs);
-function agentRequestContext(params, client, signal, requestId) {
-    return {
-        params,
-        requestId,
-        signal,
-        client,
-    };
-}
-function agentNotificationContext(params, client, signal) {
-    return {
-        params,
-        signal,
-        client,
-    };
-}
-function clientRequestContext(params, agent, signal, requestId) {
-    return {
-        params,
-        requestId,
-        signal,
-        agent,
-    };
-}
-function clientNotificationContext(params, agent, signal) {
-    return {
-        params,
-        signal,
-        agent,
-    };
-}
-class SessionUpdateRouter {
-    activeSessions = new Map();
-    handleMessage(message) {
-        if (message.kind !== "notification" ||
-            message.method !== schema.CLIENT_METHODS.session_update) {
-            return Handled.no(message);
-        }
-        const notification = validate.zUpdateSessionNotification.parse(message.params);
-        const { update } = notification;
-        const isIdle = guards.SessionUpdate.isStateUpdate(update) &&
-            guards.StateUpdate.isIdle(update);
-        const activeSessions = this.activeSessions.get(notification.sessionId);
-        if (activeSessions && activeSessions.size > 0) {
-            for (const session of activeSessions) {
-                if (isIdle && session.isAwaitingPromptCompletion()) {
-                    session.completePrompt();
-                    session.enqueue({
-                        kind: "stop",
-                        notification,
-                        update,
-                        stopReason: update.stopReason,
-                    });
-                }
-                else {
-                    session.enqueue({
-                        kind: "session_update",
-                        notification,
-                        update,
-                    });
-                }
-            }
-        }
-        return Handled.no(message);
-    }
-    attach(response, updates) {
-        const sessions = this.activeSessions.get(response.sessionId) ??
-            new Set();
-        sessions.add(updates);
-        this.activeSessions.set(response.sessionId, sessions);
-        return new HandlerRegistration(() => {
-            sessions.delete(updates);
-            if (sessions.size === 0) {
-                this.activeSessions.delete(response.sessionId);
-            }
-        });
-    }
-}
-const sessionUpdateRouters = new WeakMap();
-function sessionUpdateRouter(cx) {
-    let router = sessionUpdateRouters.get(cx);
-    if (!router) {
-        router = new SessionUpdateRouter();
-        sessionUpdateRouters.set(cx, router);
-    }
-    return router;
-}
-function runConnectHandlers(connection, handlers) {
-    for (const handler of handlers) {
-        let result;
-        try {
-            result = handler(connection);
-        }
-        catch (error) {
-            connection.close(error);
-            throw error;
-        }
-        void Promise.resolve(result).catch((error) => {
-            connection.close(error);
-        });
-    }
-}
-const appBuilder = Symbol("appBuilder");
-const runAgentConnectHandlers = Symbol("runAgentConnectHandlers");
-const runClientConnectHandlers = Symbol("runClientConnectHandlers");
-/**
- * Creates an agent-side app for the experimental draft ACP v2 API.
- *
- * Register request and notification handlers by ACP method name, then call
- * `connect(stream)` to serve an ACP client.
- *
- * @experimental
- */
-export function agent(options) {
-    return new AgentApp(options);
-}
-/**
- * Agent-side app builder for the experimental draft ACP v2 API.
- *
- * Methods on this class register typed request or notification handlers and
- * return `this`, so apps can be built with a fluent chain. Handler params are
- * parsed with the generated ACP schemas before your handler runs, and thrown
- * errors are converted to JSON-RPC errors by the connection layer.
- *
- * @experimental
- */
-export class AgentApp {
-    builder = Connection.builder();
-    connectHandlers = [];
-    constructor(options = {}) {
-        if (options.name) {
-            this.builder.name(options.name);
-        }
-    }
-    /** @internal */
-    [appBuilder]() {
-        return this.builder;
-    }
-    /** @internal */
-    [runAgentConnectHandlers](connection) {
-        runConnectHandlers(connection, this.connectHandlers);
-    }
-    connect(target, options = {}) {
-        return this.connectConnection(target, options).connection;
-    }
-    connectWith(target, op) {
-        const { rawConnection, connection } = this.connectConnection(target);
-        return rawConnection.runUntil(() => op(connection.client));
-    }
-    /**
-     * Registers a handler that runs when this agent app opens a connection.
-     *
-     * Use this for connection-scoped work that needs to call client-side ACP
-     * methods outside an inbound request handler.
-     */
-    onConnect(handler) {
-        this.connectHandlers.push(handler);
-        return this;
-    }
-    onRequest(method, handlerOrParams, handler) {
-        if (handler) {
-            assertV2Method(method, agentRequestSpecsByMethod, "request");
-            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) {
-            assertV2Method(method, agentNotificationSpecsByMethod, "notification", true);
-            return this.notification({ method, params: handlerOrParams }, handler);
-        }
-        const spec = agentNotificationSpecsByMethod[method];
-        if (!spec) {
-            throw new Error(`Unknown ACP notification method '${method}'. Pass a params parser for custom methods.`);
-        }
-        return this.notification(spec, handlerOrParams);
-    }
-    request(spec, handler) {
-        registerAppRequest(this.builder, spec, (params, cx, signal, requestId) => agentRequestContext(params, AgentContext.create(cx, requestId), signal, requestId), handler);
-        return this;
-    }
-    notification(spec, handler) {
-        registerAppNotification(this.builder, spec, (params, cx, signal) => agentNotificationContext(params, AgentContext.create(cx), signal), handler);
-        return this;
-    }
-    connectConnection(target, options = {}) {
-        if (isStream(target)) {
-            const state = this.openStreamConnection(target);
-            if (!options.deferConnectHandlers) {
-                this[runAgentConnectHandlers](state.connection);
-            }
-            return state;
-        }
-        const [thisStream, peerStream] = memoryStreamPair();
-        const peerRawConnection = target[appBuilder]().connect(peerStream);
-        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);
-        return {
-            rawConnection,
-            connection: agentConnection(rawConnection, this.connectHandlers),
-        };
-    }
-}
-/**
- * Creates a client-side app for the experimental draft ACP v2 API.
- *
- * Register request and notification handlers by ACP method name, then use
- * `connectWith(...)` to run the workflow that calls agent-side methods.
- *
- * @experimental
- */
-export function client(options) {
-    return new ClientApp(options);
-}
-/**
- * Client-side app builder for the experimental draft ACP v2 API.
- *
- * Methods on this class register typed client handlers and return `this`, so
- * apps can be built with a fluent chain. `connectWith(...)` is the usual entry
- * point for clients because it provides a `ClientContext` for calling
- * agent-side requests and session helpers.
- *
- * @experimental
- */
-export class ClientApp {
-    builder = Connection.builder();
-    connectHandlers = [];
-    constructor(options = {}) {
-        if (options.name) {
-            this.builder.name(options.name);
-        }
-        this.builder.withHandler({
-            handleMessage: (message, cx) => sessionUpdateRouter(cx).handleMessage(message),
-            describe: () => "client-session-update-router",
-        });
-    }
-    /** @internal */
-    [appBuilder]() {
-        return this.builder;
-    }
-    /** @internal */
-    [runClientConnectHandlers](connection) {
-        runConnectHandlers(connection, this.connectHandlers);
-    }
-    connect(target) {
-        return this.connectConnection(target).connection;
-    }
-    connectWith(target, op) {
-        const { rawConnection, connection } = this.connectConnection(target);
-        return rawConnection.runUntil(() => op(connection.agent));
-    }
-    /**
-     * Registers a handler that runs when this client app opens a connection.
-     *
-     * Use this for connection-scoped work that needs to call agent-side ACP
-     * methods outside an inbound request handler.
-     */
-    onConnect(handler) {
-        this.connectHandlers.push(handler);
-        return this;
-    }
-    onRequest(method, handlerOrParams, handler) {
-        if (handler) {
-            assertV2Method(method, clientRequestSpecsByMethod, "request");
-            return this.request({ method, params: handlerOrParams }, handler);
-        }
-        const spec = clientRequestSpecsByMethod[method];
-        if (!spec) {
-            throw new Error(`Unknown ACP request method '${method}'. Pass a params parser for custom methods.`);
-        }
-        return this.request(spec, handlerOrParams);
-    }
-    onNotification(method, handlerOrParams, handler) {
-        if (handler) {
-            assertV2Method(method, clientNotificationSpecsByMethod, "notification", true);
-            return this.notification({ method, params: handlerOrParams }, handler);
-        }
-        const spec = clientNotificationSpecsByMethod[method];
-        if (!spec) {
-            throw new Error(`Unknown ACP notification method '${method}'. Pass a params parser for custom methods.`);
-        }
-        return this.notification(spec, handlerOrParams);
-    }
-    request(spec, handler) {
-        registerAppRequest(this.builder, spec, (params, cx, signal, requestId) => clientRequestContext(params, ClientContext.create(cx, requestId), signal, requestId), handler);
-        return this;
-    }
-    notification(spec, handler) {
-        registerAppNotification(this.builder, spec, (params, cx, signal) => clientNotificationContext(params, ClientContext.create(cx), signal), handler);
-        return this;
-    }
-    connectConnection(target) {
-        if (isStream(target)) {
-            const state = this.openStreamConnection(target);
-            this[runClientConnectHandlers](state.connection);
-            return state;
-        }
-        const [thisStream, peerStream] = memoryStreamPair();
-        const peerRawConnection = target[appBuilder]().connect(peerStream);
-        const peerConnection = agentConnection(peerRawConnection);
-        const state = this.openStreamConnection(thisStream);
-        void state.rawConnection.closed.then(() => peerConnection.close());
-        void peerRawConnection.closed.then(() => state.connection.close());
-        try {
-            target[runAgentConnectHandlers](peerConnection);
-            this[runClientConnectHandlers](state.connection);
-        }
-        catch (error) {
-            peerConnection.close(error);
-            state.connection.close(error);
-            throw error;
-        }
-        return state;
-    }
-    openStreamConnection(stream) {
-        const rawConnection = this.builder.connect(stream);
-        return {
-            rawConnection,
-            connection: clientConnection(rawConnection, this.connectHandlers),
-        };
-    }
-}
-//# sourceMappingURL=acp.js.map