@hypercli.com/sdk 0.9.1

package/dist/acp.d.ts

@@ -0,0 +1,179 @@
+import * as acp from '@agentclientprotocol/sdk';
+export type { ContentBlock, SessionNotification, RequestPermissionRequest } from '@agentclientprotocol/sdk';
+export type CodingAgentAcpProtocolVersion = 1;
+export type CodingAgentAcpPromptResult = acp.PromptResponse;
+export type CodingAgentAcpTransport = 'proxy' | 'direct';
+export declare const ACP_RECONNECT_DELAYS_MS: readonly number[];
+export declare const ACP_PROXY_UNKNOWN_SESSION_CLOSE_CODE = 4404;
+export declare class CodingAgentAcpUnavailableError extends Error {
+    readonly capability: string;
+    constructor(capability: string, detail: string);
+}
+export declare class CodingAgentAcpConnectionError extends Error {
+    readonly code: number | null;
+    constructor(message: string, options?: {
+        code?: number | null;
+        cause?: unknown;
+    });
+}
+export declare class CodingAgentAcpRequestError extends Error {
+    readonly method: string;
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(method: string, code: number, message: string, data?: unknown | undefined, cause?: unknown);
+}
+export declare class CodingAgentAcpAttachmentError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string, detail: string, options?: {
+        cause?: unknown;
+    });
+}
+export type CodingAgentAcpStage = 'connect' | 'initialize' | 'cwd' | 'new' | 'list' | 'resume' | 'prompt';
+export interface CodingAgentAcpDiagnosticError {
+    name: string;
+    code?: number | string;
+    statusCode?: number;
+    cause?: CodingAgentAcpDiagnosticError;
+}
+export type CodingAgentAcpDiagnostic = {
+    stage: CodingAgentAcpStage;
+    operationId: number;
+    timestamp: number;
+    elapsedMs: number;
+    phase: 'started' | 'succeeded' | 'failed';
+    error?: CodingAgentAcpDiagnosticError;
+} | {
+    stage: 'transport';
+    phase: 'closed';
+    timestamp: number;
+    code: number | null;
+    reasonPresent: boolean;
+};
+type PermissionHandler = (params: acp.RequestPermissionRequest, signal?: AbortSignal) => acp.MaybePromise<acp.RequestPermissionResponse>;
+export interface CodingAgentAcpConnectOptions {
+    onDiagnostic?: (event: CodingAgentAcpDiagnostic) => void;
+    resolveDefaultCwd?: () => Promise<string>;
+    signal?: AbortSignal;
+    token?: string;
+    cwd?: string;
+    clientInfo?: {
+        name?: string;
+        version?: string;
+    };
+    mcpServers?: acp.McpServer[];
+    transport?: CodingAgentAcpTransport;
+    sessionId?: string;
+    source?: string | null;
+    onUpdate?: (notification: acp.SessionNotification) => void;
+    onPermissionRequest?: PermissionHandler;
+    onError?: (error: Error) => void;
+    onClose?: (event: {
+        code: number;
+        reason: string;
+    }) => void;
+    /** Refresh platform history before reconnect resumes the tracked sessions. */
+    onReconnect?: () => void | Promise<void>;
+}
+export interface CodingAgentAcpTarget {
+    url: string;
+    token: string;
+}
+/** Retained product publication, independent of native ACP. */
+export interface SessionAttachment {
+    type: 'attachment';
+    id: string;
+    sessionId: string;
+    agentId: string;
+    nativeSessionId: string;
+    file: {
+        type: 'resource_link';
+        uri: string;
+        name: string;
+        mimeType: string;
+        size: number;
+        sha256: string;
+    };
+}
+export declare class CodingAgentAcpClient {
+    private readonly options;
+    private readonly target;
+    private readonly cookieStore;
+    private connection;
+    private pendingConnection;
+    private initializeValue;
+    private readonly sessions;
+    private readonly sessionConfig;
+    private ready;
+    private readonly connectedWaiters;
+    private readonly pendingPrompts;
+    private readonly updateListeners;
+    private readonly attachmentListeners;
+    private readonly errorListeners;
+    private readonly closeListeners;
+    private permissionHandler;
+    private closedFlag;
+    private terminalError;
+    private failures;
+    private generation;
+    private reconnectTimer;
+    private nextDiagnosticOperation;
+    private readonly onAbort;
+    private constructor();
+    static connect(target: CodingAgentAcpTarget, options?: CodingAgentAcpConnectOptions): Promise<CodingAgentAcpClient>;
+    get connected(): boolean;
+    get closed(): boolean;
+    get negotiatedProtocolVersion(): CodingAgentAcpProtocolVersion | null;
+    get initializeResponse(): acp.InitializeResponse | null;
+    get sessionIds(): string[];
+    /** Latest native configuration advertised for an attached session. */
+    sessionConfigOptions(sessionId: string): readonly acp.SessionConfigOption[];
+    addUpdateListener(listener: (notification: acp.SessionNotification) => void): () => void;
+    addAttachmentListener(listener: (attachment: SessionAttachment) => void): () => void;
+    addErrorListener(listener: (error: Error) => void): () => void;
+    addCloseListener(listener: (event: {
+        code: number;
+        reason: string;
+    }) => void): () => void;
+    setPermissionHandler(handler: PermissionHandler | null): void;
+    waitConnected(signal?: AbortSignal): Promise<void>;
+    private diagnostic;
+    private observe;
+    newSession(options?: {
+        cwd?: string;
+        mcpServers?: acp.McpServer[];
+    }): Promise<acp.NewSessionResponse>;
+    listSessions(options?: {
+        cwd?: string | null;
+        cursor?: string | null;
+    }): Promise<acp.ListSessionsResponse>;
+    private originalSessionCwd;
+    /** Exact tracked/catalog session cwd, without a launch/connection default fallback. */
+    sessionCwd(sessionId: string): Promise<string>;
+    resumeSession(sessionId: string, options?: {
+        cwd?: string;
+        mcpServers?: acp.McpServer[];
+    }): Promise<acp.ResumeSessionResponse>;
+    prompt(sessionId: string, prompt: string | acp.ContentBlock | acp.ContentBlock[]): Promise<acp.PromptResponse>;
+    cancel(sessionId: string): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    unstableForkSession(sessionId: string, options?: {
+        cwd?: string;
+        mcpServers?: acp.McpServer[];
+    }): Promise<acp.ForkSessionResponse>;
+    setMode(sessionId: string, modeId: string): Promise<void>;
+    setConfigOption(params: acp.SetSessionConfigOptionRequest): Promise<acp.SetSessionConfigOptionResponse>;
+    setConfigOption(sessionId: string, configId: string, value: string | boolean): Promise<acp.SetSessionConfigOptionResponse>;
+    setModel(sessionId: string, modelId: string): Promise<acp.SetSessionConfigOptionResponse>;
+    unstableListProviders(): Promise<unknown>;
+    unstableSetProvider(params: acp.SetProviderRequest): Promise<unknown>;
+    unstableDisableProvider(params: acp.DisableProviderRequest): Promise<unknown>;
+    request<T = unknown>(method: string, params?: unknown): Promise<T>;
+    notify(method: string, params?: unknown): Promise<void>;
+    private context;
+    close(): void;
+    private open;
+    private markReady;
+    private scheduleReconnect;
+}
+//# sourceMappingURL=acp.d.ts.map

package/dist/acp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp.d.ts","sourceRoot":"","sources":["../src/acp.ts"],"names":[],"mappings":"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"}

package/dist/acp.js

@@ -0,0 +1,487 @@
+/** Vanilla ACP v1. Platform history/receipts are separate from native turns. */
+import NodeWebSocket from 'ws';
+import * as acp from '@agentclientprotocol/sdk';
+import { createWebSocketStream, MemoryAcpCookieStore } from '@agentclientprotocol/sdk/experimental/ws-client';
+export const ACP_RECONNECT_DELAYS_MS = [1_000, 2_000, 4_000];
+export const ACP_PROXY_UNKNOWN_SESSION_CLOSE_CODE = 4404;
+const TERMINAL_CODES = new Set([4401, 4403, 4404, 4408]);
+export class CodingAgentAcpUnavailableError extends Error {
+    capability;
+    constructor(capability, detail) {
+        super(`${capability} is not available: ${detail}`);
+        this.capability = capability;
+        this.name = 'CodingAgentAcpUnavailableError';
+    }
+}
+export class CodingAgentAcpConnectionError extends Error {
+    code;
+    constructor(message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'CodingAgentAcpConnectionError';
+        this.code = options.code ?? null;
+    }
+}
+export class CodingAgentAcpRequestError extends Error {
+    method;
+    code;
+    data;
+    constructor(method, code, message, data, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.method = method;
+        this.code = code;
+        this.data = data;
+        this.name = 'CodingAgentAcpRequestError';
+    }
+}
+export class CodingAgentAcpAttachmentError extends Error {
+    sessionId;
+    constructor(sessionId, detail, options = {}) {
+        super(`ACP session ${sessionId} could not be reattached: ${detail}`, options);
+        this.sessionId = sessionId;
+        this.name = 'CodingAgentAcpAttachmentError';
+    }
+}
+function diagnosticError(error, depth = 0) {
+    const value = error;
+    const name = value?.constructor?.name;
+    return {
+        name: typeof name === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,79}$/.test(name) ? name : 'Error',
+        ...(typeof value?.code === 'number' || (typeof value?.code === 'string' && /^(?:E[A-Z]+|UND_ERR_[A-Z_]+)$/.test(value.code)) ? { code: value.code } : {}),
+        ...(typeof value?.statusCode === 'number' ? { statusCode: value.statusCode } : {}),
+        ...(value?.cause !== undefined && depth < 3 ? { cause: diagnosticError(value.cause, depth + 1) } : {}),
+    };
+}
+/** Observers never own protocol settlement, including accidentally async observers. */
+function callObserver(observer, value) {
+    try {
+        void Promise.resolve(observer?.(value)).catch(() => { });
+    }
+    catch { /* Isolate consumer observers. */ }
+}
+export class CodingAgentAcpClient {
+    options;
+    target;
+    cookieStore = new MemoryAcpCookieStore();
+    connection = null;
+    pendingConnection = null;
+    initializeValue = null;
+    sessions = new Map();
+    sessionConfig = new Map();
+    ready = false;
+    connectedWaiters = new Set();
+    pendingPrompts = new Set();
+    updateListeners = new Set();
+    attachmentListeners = new Set();
+    errorListeners = new Set();
+    closeListeners = new Set();
+    permissionHandler = null;
+    closedFlag = false;
+    terminalError = null;
+    failures = 0;
+    generation = 0;
+    reconnectTimer = null;
+    nextDiagnosticOperation = 0;
+    onAbort = () => this.close();
+    constructor(target, options) {
+        this.options = options;
+        const url = new URL(target.url);
+        if (options.source !== undefined && options.source !== null) {
+            if (options.transport === 'direct')
+                throw new Error('source requires the ACP proxy transport');
+            url.searchParams.set('source', options.source);
+        }
+        this.target = { ...target, url: url.toString() };
+    }
+    static async connect(target, options = {}) {
+        const client = new CodingAgentAcpClient(target, options);
+        try {
+            if (options.signal?.aborted)
+                throw new CodingAgentAcpConnectionError('ACP connect aborted');
+            options.signal?.addEventListener('abort', client.onAbort, { once: true });
+            await client.open();
+            return client;
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+    }
+    get connected() { return this.ready && this.connection !== null && !this.closedFlag; }
+    get closed() { return this.closedFlag; }
+    get negotiatedProtocolVersion() { return this.initializeValue ? 1 : null; }
+    get initializeResponse() { return this.initializeValue; }
+    get sessionIds() { return [...this.sessions.keys()]; }
+    /** Latest native configuration advertised for an attached session. */
+    sessionConfigOptions(sessionId) {
+        return this.sessionConfig.get(sessionId) ?? [];
+    }
+    addUpdateListener(listener) {
+        this.updateListeners.add(listener);
+        return () => { this.updateListeners.delete(listener); };
+    }
+    addAttachmentListener(listener) {
+        this.attachmentListeners.add(listener);
+        return () => { this.attachmentListeners.delete(listener); };
+    }
+    addErrorListener(listener) {
+        this.errorListeners.add(listener);
+        return () => { this.errorListeners.delete(listener); };
+    }
+    addCloseListener(listener) {
+        this.closeListeners.add(listener);
+        return () => { this.closeListeners.delete(listener); };
+    }
+    setPermissionHandler(handler) { this.permissionHandler = handler; }
+    waitConnected(signal) {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        if (this.connected)
+            return Promise.resolve();
+        if (this.closedFlag)
+            return Promise.reject(this.terminalError ?? new CodingAgentAcpConnectionError('ACP client closed'));
+        return new Promise((resolve, reject) => {
+            const cleanup = () => { this.connectedWaiters.delete(waiter); signal?.removeEventListener('abort', abort); };
+            const waiter = { resolve: () => { cleanup(); resolve(); }, reject: (error) => { cleanup(); reject(error); } };
+            const abort = () => waiter.reject(signal.reason);
+            this.connectedWaiters.add(waiter);
+            signal?.addEventListener('abort', abort, { once: true });
+        });
+    }
+    diagnostic(event) {
+        callObserver(this.options.onDiagnostic, event);
+    }
+    async observe(stage, run) {
+        const operationId = ++this.nextDiagnosticOperation;
+        const started = globalThis.performance.now();
+        this.diagnostic({ stage, operationId, timestamp: Date.now(), elapsedMs: 0, phase: 'started' });
+        try {
+            const result = await run();
+            this.diagnostic({ stage, operationId, timestamp: Date.now(), elapsedMs: Math.round(globalThis.performance.now() - started), phase: 'succeeded' });
+            return result;
+        }
+        catch (error) {
+            this.diagnostic({ stage, operationId, timestamp: Date.now(), elapsedMs: Math.round(globalThis.performance.now() - started), phase: 'failed', error: diagnosticError(error) });
+            throw error;
+        }
+    }
+    async newSession(options = {}) {
+        const cwd = await this.observe('cwd', async () => {
+            const supplied = options.cwd ?? this.options.cwd;
+            if (supplied !== undefined)
+                return supplied;
+            if (!this.options.resolveDefaultCwd)
+                throw new CodingAgentAcpUnavailableError('session/new', 'supply cwd or a runtime path resolver');
+            return this.options.resolveDefaultCwd();
+        });
+        const mcpServers = structuredClone(options.mcpServers ?? this.options.mcpServers ?? []);
+        const result = await this.observe('new', () => this.request('session/new', { cwd, mcpServers }));
+        this.sessions.set(result.sessionId, { cwd, mcpServers });
+        if (result.configOptions)
+            this.sessionConfig.set(result.sessionId, result.configOptions);
+        return result;
+    }
+    async listSessions(options = {}) {
+        return this.observe('list', () => this.request('session/list', options));
+    }
+    async originalSessionCwd(sessionId) {
+        return this.sessions.get(sessionId)?.cwd ?? this.options.cwd ?? this.sessionCwd(sessionId);
+    }
+    /** Exact tracked/catalog session cwd, without a launch/connection default fallback. */
+    async sessionCwd(sessionId) {
+        const tracked = this.sessions.get(sessionId);
+        if (tracked)
+            return tracked.cwd;
+        let cursor;
+        const seen = new Set();
+        do {
+            const page = await this.listSessions({ cursor });
+            const entry = page.sessions.find(s => s.sessionId === sessionId);
+            if (entry)
+                return entry.cwd;
+            cursor = page.nextCursor ?? undefined;
+            if (cursor && seen.has(cursor))
+                throw new Error('session/list repeated a cursor');
+            if (cursor)
+                seen.add(cursor);
+        } while (cursor);
+        throw new CodingAgentAcpUnavailableError('session/list', 'original session cwd is unavailable');
+    }
+    async resumeSession(sessionId, options = {}) {
+        const previous = this.sessions.get(sessionId);
+        const cwd = await this.observe('cwd', () => options.cwd !== undefined ? Promise.resolve(options.cwd) : this.originalSessionCwd(sessionId));
+        const mcpServers = structuredClone(options.mcpServers ?? previous?.mcpServers ?? this.options.mcpServers ?? []);
+        const connection = this.connection, generation = this.generation;
+        const result = await this.observe('resume', () => this.request('session/resume', { sessionId, cwd, mcpServers }));
+        if (connection !== this.connection || generation !== this.generation || this.closedFlag)
+            throw new CodingAgentAcpConnectionError('ACP attachment interrupted');
+        this.sessions.set(sessionId, { cwd, mcpServers });
+        if (result.configOptions)
+            this.sessionConfig.set(sessionId, result.configOptions);
+        return result;
+    }
+    async prompt(sessionId, prompt) {
+        const pending = { sessionId, controller: new AbortController() };
+        this.pendingPrompts.add(pending);
+        try {
+            await this.waitConnected(pending.controller.signal);
+            pending.controller.signal.throwIfAborted();
+        }
+        finally {
+            this.pendingPrompts.delete(pending);
+        }
+        const blocks = typeof prompt === 'string' ? [{ type: 'text', text: prompt }] : Array.isArray(prompt) ? prompt : [prompt];
+        return this.observe('prompt', () => this.request('session/prompt', { sessionId, prompt: blocks }));
+    }
+    async cancel(sessionId) {
+        for (const pending of this.pendingPrompts) {
+            if (pending.sessionId === sessionId)
+                pending.controller.abort(new Error('ACP prompt cancelled before delivery'));
+        }
+        await this.notify('session/cancel', { sessionId });
+    }
+    async closeSession(sessionId) { await this.request('session/close', { sessionId }); this.sessions.delete(sessionId); this.sessionConfig.delete(sessionId); }
+    async deleteSession(sessionId) { await this.request('session/delete', { sessionId }); this.sessions.delete(sessionId); this.sessionConfig.delete(sessionId); }
+    async unstableForkSession(sessionId, options = {}) {
+        const cwd = options.cwd ?? await this.originalSessionCwd(sessionId);
+        const mcpServers = structuredClone(options.mcpServers ?? this.sessions.get(sessionId)?.mcpServers ?? this.options.mcpServers ?? []);
+        const result = await this.request('session/fork', { sessionId, cwd, mcpServers });
+        this.sessions.set(result.sessionId, { cwd, mcpServers });
+        return result;
+    }
+    async setMode(sessionId, modeId) { await this.request('session/set_mode', { sessionId, modeId }); }
+    async setConfigOption(...args) {
+        const params = args.length === 1 ? args[0] : {
+            sessionId: args[0], configId: args[1], value: args[2],
+            ...(typeof args[2] === 'boolean' ? { type: 'boolean' } : {}),
+        };
+        const result = await this.request('session/set_config_option', params);
+        this.sessionConfig.set(params.sessionId, result.configOptions);
+        return result;
+    }
+    async setModel(sessionId, modelId) {
+        const option = this.sessionConfig.get(sessionId)?.find(o => o.category === 'model');
+        if (!option)
+            throw new CodingAgentAcpUnavailableError('session/set_config_option', 'no model configuration advertised');
+        return this.setConfigOption(sessionId, option.id, modelId);
+    }
+    async unstableListProviders() { return this.request('providers/list', {}); }
+    async unstableSetProvider(params) { return this.request('providers/set', params); }
+    async unstableDisableProvider(params) { return this.request('providers/disable', params); }
+    async request(method, params) {
+        try {
+            return await this.context().request(method, params);
+        }
+        catch (error) {
+            if (error instanceof acp.RequestError)
+                throw new CodingAgentAcpRequestError(method, error.code, error.message, error.data, error);
+            throw error;
+        }
+    }
+    notify(method, params) { return this.context().notify(method, params); }
+    context() {
+        if (!this.connection || this.closedFlag)
+            throw this.terminalError ?? new CodingAgentAcpConnectionError('ACP connection unavailable');
+        return this.connection.agent;
+    }
+    close() {
+        if (this.closedFlag)
+            return;
+        this.closedFlag = true;
+        ++this.generation;
+        this.options.signal?.removeEventListener('abort', this.onAbort);
+        if (this.reconnectTimer !== null)
+            clearTimeout(this.reconnectTimer);
+        const error = this.terminalError ?? new CodingAgentAcpConnectionError('ACP client closed; pending delivery is unresolved');
+        this.pendingConnection?.close(error);
+        this.connection?.close(error);
+        this.connection = this.pendingConnection = null;
+        for (const waiter of this.connectedWaiters)
+            waiter.reject(error);
+        this.connectedWaiters.clear();
+        this.updateListeners.clear();
+        this.errorListeners.clear();
+        this.closeListeners.clear();
+        this.sessionConfig.clear();
+        this.permissionHandler = null;
+    }
+    async open(reconnecting = false) {
+        const generation = this.generation;
+        const closeInfo = { reason: '' };
+        let socketOpened;
+        let socketFailed;
+        const opened = new Promise((resolve, reject) => { socketOpened = resolve; socketFailed = reject; });
+        void opened.catch(() => { });
+        const WebSocketImpl = (NodeWebSocket ?? globalThis.WebSocket);
+        const diagnostic = (event) => this.diagnostic(event);
+        const TrackedSocket = class {
+            constructor(url, protocols, options) {
+                const ws = new WebSocketImpl(url, protocols, options);
+                const closed = (code, reason = '') => {
+                    closeInfo.code = code;
+                    closeInfo.reason = reason;
+                    socketFailed(new CodingAgentAcpConnectionError('ACP socket closed before opening', { code }));
+                    diagnostic({ stage: 'transport', phase: 'closed', timestamp: Date.now(), code: code ?? null, reasonPresent: reason.length > 0 });
+                };
+                if (typeof ws.on === 'function') {
+                    ws.on('open', socketOpened);
+                    ws.on('error', (error) => socketFailed(new CodingAgentAcpConnectionError('ACP socket failed before opening', { cause: error })));
+                    ws.on('close', (...args) => closed(typeof args[0] === 'number' ? args[0] : undefined, String(args[1] ?? '')));
+                }
+                else {
+                    ws.addEventListener?.('open', socketOpened);
+                    ws.addEventListener?.('error', (error) => socketFailed(new CodingAgentAcpConnectionError('ACP socket failed before opening', { cause: error })));
+                    ws.addEventListener?.('close', (event) => { const e = event; closed(e.code, e.reason); });
+                }
+                return ws;
+            }
+        };
+        const app = acp.client({ name: this.options.clientInfo?.name ?? 'hypercli-ts-sdk' });
+        app.onRequest('session/request_permission', context => {
+            const handler = this.permissionHandler ?? this.options.onPermissionRequest;
+            return handler ? handler(context.params, context.signal) : { outcome: { outcome: 'cancelled' } };
+        });
+        const sessionUpdate = (notification) => {
+            if (this.closedFlag || generation !== this.generation)
+                return;
+            if (notification.update.sessionUpdate === 'config_option_update') {
+                this.sessionConfig.set(notification.sessionId, notification.update.configOptions);
+            }
+            for (const listener of [this.options.onUpdate, ...this.updateListeners]) {
+                callObserver(listener, notification);
+            }
+        };
+        const productAttachment = (attachment) => {
+            if (this.closedFlag || generation !== this.generation)
+                return;
+            for (const listener of this.attachmentListeners)
+                callObserver(listener, attachment);
+        };
+        const connection = await this.observe('connect', async () => {
+            const stream = createWebSocketStream(this.target.url, {
+                WebSocket: TrackedSocket, cookieStore: this.cookieStore,
+                headers: this.target.token ? { Authorization: `Bearer ${this.target.token}` } : undefined,
+            });
+            const pending = app.connect({ ...stream,
+                // Upstream's active-session router validates an exhaustive update union.
+                // Forward notifications untouched; RPCs/callbacks remain SDK-owned.
+                readable: stream.readable.pipeThrough(new globalThis.TransformStream({ transform(frame, controller) {
+                        if (frame && typeof frame === 'object' && 'type' in frame && frame.type === 'attachment') {
+                            const attachment = frame;
+                            if (typeof attachment.sessionId === 'string' && typeof attachment.id === 'string'
+                                && typeof attachment.agentId === 'string' && typeof attachment.file?.name === 'string'
+                                && typeof attachment.file.mimeType === 'string'
+                                && typeof attachment.file.uri === 'string' && typeof attachment.file.sha256 === 'string') {
+                                productAttachment(attachment);
+                            }
+                            return;
+                        }
+                        if (frame && typeof frame === 'object' && 'method' in frame && frame.method === 'session/update' && !('id' in frame)) {
+                            sessionUpdate(frame.params);
+                        }
+                        else
+                            controller.enqueue(frame);
+                    } })),
+            });
+            this.pendingConnection = pending;
+            void pending.closed.then(() => socketFailed(new CodingAgentAcpConnectionError('ACP connection closed before opening')));
+            try {
+                await opened;
+                return pending;
+            }
+            catch (error) {
+                pending.close(error instanceof Error ? error : undefined);
+                throw error;
+            }
+        });
+        this.pendingConnection = connection;
+        void connection.closed.then(() => {
+            if (this.closedFlag || this.connection !== connection)
+                return;
+            this.connection = null;
+            this.ready = false;
+            ++this.generation;
+            this.scheduleReconnect(closeInfo.code ?? 1006, closeInfo.reason);
+        });
+        try {
+            const response = await this.observe('initialize', () => connection.agent.request('initialize', {
+                protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: this.options.clientInfo?.name ?? 'hypercli-ts-sdk', version: this.options.clientInfo?.version ?? '' },
+            }));
+            if (response.protocolVersion !== 1)
+                throw new CodingAgentAcpConnectionError('ACP peer did not select v1');
+            if (this.closedFlag || generation !== this.generation)
+                throw new CodingAgentAcpConnectionError('ACP connect aborted');
+            this.initializeValue = response;
+            this.connection = connection;
+            if (!reconnecting)
+                this.markReady();
+        }
+        catch (error) {
+            connection.close(error instanceof Error ? error : undefined);
+            throw error;
+        }
+        finally {
+            if (this.pendingConnection === connection)
+                this.pendingConnection = null;
+        }
+    }
+    markReady() {
+        this.ready = true;
+        for (const waiter of this.connectedWaiters)
+            waiter.resolve();
+        this.connectedWaiters.clear();
+    }
+    scheduleReconnect(code, reason) {
+        if (this.closedFlag)
+            return;
+        if (TERMINAL_CODES.has(code) || this.failures >= ACP_RECONNECT_DELAYS_MS.length) {
+            this.terminalError = new CodingAgentAcpConnectionError('ACP connection closed', { code });
+            const listeners = [...this.closeListeners];
+            this.close();
+            for (const listener of [this.options.onClose, ...listeners])
+                callObserver(listener, { code, reason });
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.open(true).then(async () => {
+                const connection = this.connection, generation = this.generation;
+                const ownsConnection = () => !this.closedFlag && connection === this.connection && generation === this.generation;
+                this.failures = 0;
+                try {
+                    await this.options.onReconnect?.();
+                }
+                catch (error) {
+                    const failure = error instanceof Error ? error : new CodingAgentAcpConnectionError('ACP reconnect callback failed', { cause: error });
+                    if (ownsConnection())
+                        for (const listener of [this.options.onError, ...this.errorListeners])
+                            callObserver(listener, failure);
+                }
+                for (const [sid, setup] of this.sessions) {
+                    if (!ownsConnection())
+                        return;
+                    try {
+                        await this.resumeSession(sid, { cwd: setup.cwd });
+                    }
+                    catch (error) {
+                        if (!ownsConnection())
+                            return;
+                        if (!(error instanceof CodingAgentAcpRequestError)) {
+                            connection?.close(error instanceof Error ? error : undefined);
+                            return;
+                        }
+                        this.sessions.delete(sid);
+                        const gap = new CodingAgentAcpAttachmentError(sid, error.message, { cause: error });
+                        for (const waiter of this.connectedWaiters)
+                            waiter.reject(gap);
+                        this.connectedWaiters.clear();
+                        for (const listener of [this.options.onError, ...this.errorListeners])
+                            callObserver(listener, gap);
+                    }
+                }
+                if (ownsConnection())
+                    this.markReady();
+            }, () => this.scheduleReconnect(code, reason));
+        }, ACP_RECONNECT_DELAYS_MS[this.failures++]);
+    }
+}
+//# sourceMappingURL=acp.js.map