@agentick/client 0.0.1

package/dist/client.js

@@ -0,0 +1,1381 @@
+/**
+ * AgentickClient - Multiplexed session client
+ *
+ * Connects to a Agentick server with a single SSE connection
+ * that multiplexes events for multiple sessions.
+ *
+ * @module @agentick/client
+ */
+// ============================================================================
+// Channel Accessor Implementation
+// ============================================================================
+class ChannelAccessorImpl {
+    sendFn;
+    name;
+    handlers = new Set();
+    pendingRequests = new Map();
+    constructor(name, sendFn) {
+        this.sendFn = sendFn;
+        this.name = name;
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    async publish(type, payload) {
+        await this.sendFn({
+            channel: this.name,
+            type,
+            payload,
+            metadata: { timestamp: Date.now() },
+        });
+    }
+    async request(type, payload, timeoutMs = 30000) {
+        const requestId = generateId();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`Request timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pendingRequests.set(requestId, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            this.sendFn({
+                channel: this.name,
+                type,
+                payload,
+                id: requestId,
+                metadata: { timestamp: Date.now() },
+            }).catch((error) => {
+                this.pendingRequests.delete(requestId);
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    /** @internal */
+    _handleEvent(event) {
+        // Check for response to pending request
+        if (event.type === "response" && event.id) {
+            const pending = this.pendingRequests.get(event.id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(event.id);
+                pending.resolve(event.payload);
+                return;
+            }
+        }
+        // Check for error response
+        if (event.type === "error" && event.id) {
+            const pending = this.pendingRequests.get(event.id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(event.id);
+                pending.reject(new Error(event.payload?.message ?? "Request failed"));
+                return;
+            }
+        }
+        // Notify subscribers
+        for (const handler of this.handlers) {
+            try {
+                handler(event.payload, event);
+            }
+            catch (error) {
+                console.error(`Error in channel handler for ${this.name}:`, error);
+            }
+        }
+    }
+    /** @internal */
+    _destroy() {
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error("Channel destroyed"));
+        }
+        this.pendingRequests.clear();
+        this.handlers.clear();
+    }
+}
+// ============================================================================
+// Async Event Queue (single-consumer)
+// ============================================================================
+class AsyncEventQueue {
+    buffer = [];
+    resolvers = [];
+    closed = false;
+    push(value) {
+        if (this.closed)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+            return;
+        }
+        this.buffer.push(value);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            const resolver = this.resolvers.shift();
+            if (resolver) {
+                resolver({ value: undefined, done: true });
+            }
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.buffer.length > 0) {
+                    const value = this.buffer.shift();
+                    return Promise.resolve({ value, done: false });
+                }
+                if (this.closed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+// ============================================================================
+// Client Execution Handle
+// ============================================================================
+class ClientExecutionHandleImpl {
+    client;
+    abortController;
+    queue = new AsyncEventQueue();
+    resultPromise;
+    resolveResult;
+    rejectResult;
+    _status = "running";
+    _sessionId;
+    _executionId = "pending";
+    hasResult = false;
+    constructor(client, abortController, sessionId) {
+        this.client = client;
+        this.abortController = abortController;
+        this._sessionId = sessionId ?? "pending";
+        this.resultPromise = new Promise((resolve, reject) => {
+            this.resolveResult = resolve;
+            this.rejectResult = reject;
+        });
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get executionId() {
+        return this._executionId;
+    }
+    get status() {
+        return this._status;
+    }
+    get result() {
+        return this.resultPromise;
+    }
+    [Symbol.asyncIterator]() {
+        return this.queue[Symbol.asyncIterator]();
+    }
+    abort(reason) {
+        if (this._status !== "running")
+            return;
+        this._status = "aborted";
+        this.abortController.abort(reason ?? "Client aborted execution");
+        if (this._sessionId !== "pending") {
+            void this.client.abort(this._sessionId, reason).catch(() => { });
+        }
+        this.queue.close();
+        this.rejectResult(new Error(reason ?? "Execution aborted"));
+    }
+    queueMessage(message) {
+        if (this._sessionId === "pending") {
+            throw new Error("Cannot queue message before sessionId is known");
+        }
+        const handle = this.client.send({ messages: [message] }, { sessionId: this._sessionId });
+        void handle.result.catch(() => { });
+    }
+    submitToolResult(toolUseId, result) {
+        if (this._sessionId === "pending") {
+            throw new Error("Cannot submit tool result before sessionId is known");
+        }
+        void this.client.submitToolResult(this._sessionId, toolUseId, result).catch(() => { });
+    }
+    /** @internal */
+    _handleEvent(event) {
+        if (event.sessionId) {
+            this._sessionId = event.sessionId;
+        }
+        if ("executionId" in event && event.executionId) {
+            this._executionId = event.executionId;
+        }
+        const streamEvent = event;
+        this.queue.push(streamEvent);
+        if (event.type === "result") {
+            this.hasResult = true;
+            this._status = "completed";
+            this.resolveResult(event.result);
+        }
+        // Handle server-side errors
+        if (event.type === "error") {
+            this.hasResult = true; // Prevent "completed without result" error
+            this._status = "error";
+            const errorMessage = event.error ?? "Server error";
+            this.rejectResult(new Error(errorMessage));
+        }
+        if (event.type === "execution_end") {
+            if (this._status === "running") {
+                this._status = "completed";
+            }
+            this.queue.close();
+        }
+    }
+    /** @internal */
+    _fail(error) {
+        if (this._status === "running") {
+            this._status = "error";
+        }
+        this.queue.close();
+        if (!this.hasResult) {
+            this.rejectResult(error);
+        }
+    }
+    /** @internal */
+    _complete() {
+        if (this._status === "running") {
+            this._status = "completed";
+        }
+        this.queue.close();
+        if (!this.hasResult) {
+            this.rejectResult(new Error("Execution completed without result"));
+        }
+    }
+}
+// ============================================================================
+// Session Accessor Implementation
+// ============================================================================
+class SessionAccessorImpl {
+    client;
+    sessionId;
+    _isSubscribed = false;
+    eventHandlers = new Set();
+    resultHandlers = new Set();
+    toolConfirmationHandlers = new Set();
+    channels = new Map();
+    constructor(sessionId, client) {
+        this.client = client;
+        this.sessionId = sessionId;
+    }
+    get isSubscribed() {
+        return this._isSubscribed;
+    }
+    subscribe() {
+        if (this._isSubscribed)
+            return;
+        this._isSubscribed = true;
+        this.client._subscribeToSession(this.sessionId).catch((error) => {
+            this._isSubscribed = false;
+            console.error(`Failed to subscribe to session ${this.sessionId}:`, error);
+        });
+    }
+    unsubscribe() {
+        if (!this._isSubscribed)
+            return;
+        this._isSubscribed = false;
+        this.client._unsubscribeFromSession(this.sessionId).catch((error) => {
+            console.error(`Failed to unsubscribe from session ${this.sessionId}:`, error);
+        });
+    }
+    send(input) {
+        return this.client.send(input, { sessionId: this.sessionId });
+    }
+    async abort(reason) {
+        await this.client.abort(this.sessionId, reason);
+    }
+    async close() {
+        await this.client.closeSession(this.sessionId);
+    }
+    submitToolResult(toolUseId, result) {
+        void this.client.submitToolResult(this.sessionId, toolUseId, result).catch(() => { });
+    }
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => {
+            this.eventHandlers.delete(handler);
+        };
+    }
+    onResult(handler) {
+        this.resultHandlers.add(handler);
+        return () => {
+            this.resultHandlers.delete(handler);
+        };
+    }
+    onToolConfirmation(handler) {
+        this.toolConfirmationHandlers.add(handler);
+        return () => {
+            this.toolConfirmationHandlers.delete(handler);
+        };
+    }
+    /** @internal - Called by client when event is received for this session */
+    _handleEvent(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                console.error("Error in session event handler:", error);
+            }
+        }
+    }
+    /** @internal - Called by client when result is received for this session */
+    _handleResult(result) {
+        for (const handler of this.resultHandlers) {
+            try {
+                handler(result);
+            }
+            catch (error) {
+                console.error("Error in session result handler:", error);
+            }
+        }
+    }
+    /** @internal - Called by client when channel event is received for this session */
+    _handleChannelEvent(channelName, event) {
+        const channelAccessor = this.channels.get(channelName);
+        if (channelAccessor) {
+            channelAccessor._handleEvent(event);
+        }
+    }
+    /** @internal - Called by client when tool confirmation is requested */
+    _handleToolConfirmation(request) {
+        const respond = (response) => {
+            this.submitToolResult(request.toolUseId, response);
+        };
+        for (const handler of this.toolConfirmationHandlers) {
+            try {
+                handler(request, respond);
+            }
+            catch (error) {
+                console.error("Error in tool confirmation handler:", error);
+            }
+        }
+    }
+    channel(name) {
+        let channelAccessor = this.channels.get(name);
+        if (!channelAccessor) {
+            channelAccessor = new ChannelAccessorImpl(name, async (event) => {
+                await this.client._publishToChannel(this.sessionId, name, event);
+            });
+            this.channels.set(name, channelAccessor);
+            // Subscribe to this channel on the server
+            this.client._subscribeToChannel(this.sessionId, name).catch((err) => {
+                console.error(`Failed to subscribe to channel ${name}:`, err);
+            });
+        }
+        return channelAccessor;
+    }
+    /**
+     * Invoke a custom method with auto-injected sessionId.
+     *
+     * @example
+     * ```typescript
+     * const session = client.session("main");
+     * const tasks = await session.invoke("tasks:list");
+     * const newTask = await session.invoke("tasks:create", { title: "Buy groceries" });
+     * ```
+     */
+    async invoke(method, params = {}) {
+        return this.client.invoke(method, {
+            ...params,
+            sessionId: this.sessionId,
+        });
+    }
+    /**
+     * Invoke a streaming method with auto-injected sessionId.
+     *
+     * @example
+     * ```typescript
+     * const session = client.session("main");
+     * for await (const change of session.stream("tasks:watch")) {
+     *   console.log("Task changed:", change);
+     * }
+     * ```
+     */
+    async *stream(method, params = {}) {
+        yield* this.client.stream(method, {
+            ...params,
+            sessionId: this.sessionId,
+        });
+    }
+    /** @internal */
+    _destroy() {
+        this.eventHandlers.clear();
+        this.resultHandlers.clear();
+        this.toolConfirmationHandlers.clear();
+        for (const channel of this.channels.values()) {
+            channel._destroy();
+        }
+        this.channels.clear();
+    }
+}
+// ============================================================================
+// Utilities
+// ============================================================================
+function generateId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+// ============================================================================
+// AgentickClient
+// ============================================================================
+/**
+ * AgentickClient - Multiplexed session client.
+ *
+ * Connects to a Agentick server with a single SSE connection that
+ * can manage multiple session subscriptions.
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({
+ *   baseUrl: 'https://api.example.com',
+ * });
+ *
+ * // Get session accessor (cold - no subscription)
+ * const session = client.session('conv-123');
+ *
+ * // Subscribe to receive events (hot)
+ * session.subscribe();
+ *
+ * // Listen for events
+ * session.onEvent((event) => {
+ *   console.log(event);
+ * });
+ *
+ * // Send a message
+ * const handle = session.send({ messages: [{ role: 'user', content: [...] }] });
+ * await handle.result;
+ *
+ * // Or use ephemeral send (creates session, executes, closes)
+ * const ephemeral = client.send({ messages: [{...}] });
+ * await ephemeral.result;
+ * ```
+ */
+export class AgentickClient {
+    config;
+    fetchFn;
+    EventSourceCtor;
+    requestHeaders;
+    // Custom transport (when provided)
+    customTransport = null;
+    transportCleanup = null;
+    _state = "disconnected";
+    _connectionId;
+    eventSource;
+    connectionPromise;
+    stateHandlers = new Set();
+    eventHandlers = new Set();
+    streamingTextHandlers = new Set();
+    _streamingText = { text: "", isStreaming: false };
+    sessions = new Map();
+    subscriptions = new Set();
+    seenEventIds = new Set();
+    seenEventIdsOrder = [];
+    maxSeenEventIds = 5000;
+    constructor(config) {
+        this.config = config;
+        // Build request headers
+        this.requestHeaders = { "Content-Type": "application/json", ...config.headers };
+        if (config.token && !this.requestHeaders["Authorization"]) {
+            this.requestHeaders["Authorization"] = `Bearer ${config.token}`;
+        }
+        // Use custom implementations or fall back to globals
+        this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+        this.EventSourceCtor = config.EventSource ?? globalThis.EventSource;
+        // Check if a custom transport was provided
+        if (config.transport && typeof config.transport === "object") {
+            this.customTransport = config.transport;
+            this.setupTransportHandlers();
+        }
+    }
+    /**
+     * Setup handlers for custom transport events.
+     */
+    setupTransportHandlers() {
+        if (!this.customTransport)
+            return;
+        // Forward transport events to our handlers
+        const cleanupEvent = this.customTransport.onEvent((event) => {
+            this.handleIncomingEvent(event);
+        });
+        // Map transport state to connection state
+        const cleanupState = this.customTransport.onStateChange((state) => {
+            const connectionState = state === "disconnected"
+                ? "disconnected"
+                : state === "connecting"
+                    ? "connecting"
+                    : state === "connected"
+                        ? "connected"
+                        : "error";
+            this.setState(connectionState);
+        });
+        this.transportCleanup = () => {
+            cleanupEvent();
+            cleanupState();
+        };
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Connection State
+    // ══════════════════════════════════════════════════════════════════════════
+    /** Current connection state */
+    get state() {
+        return this._state;
+    }
+    setState(state) {
+        if (this._state === state)
+            return;
+        this._state = state;
+        for (const handler of this.stateHandlers) {
+            try {
+                handler(state);
+            }
+            catch (error) {
+                console.error("Error in state handler:", error);
+            }
+        }
+    }
+    /**
+     * Subscribe to connection state changes.
+     */
+    onConnectionChange(handler) {
+        this.stateHandlers.add(handler);
+        return () => {
+            this.stateHandlers.delete(handler);
+        };
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Connection Lifecycle
+    // ══════════════════════════════════════════════════════════════════════════
+    /**
+     * Ensure the connection is established.
+     * This is called lazily when subscribing to sessions.
+     */
+    async ensureConnection() {
+        // Use custom transport if provided
+        if (this.customTransport) {
+            if (this.customTransport.state === "connected") {
+                this._connectionId = this.customTransport.connectionId;
+                return;
+            }
+            await this.customTransport.connect();
+            this._connectionId = this.customTransport.connectionId;
+            return;
+        }
+        // Default SSE connection logic
+        if (this._state === "connected") {
+            return;
+        }
+        if (this.connectionPromise) {
+            await this.connectionPromise;
+            return;
+        }
+        this.setState("connecting");
+        this.connectionPromise = this.openEventSource();
+        try {
+            await this.connectionPromise;
+            this.setState("connected");
+        }
+        catch (error) {
+            this.setState("error");
+            throw error;
+        }
+        finally {
+            this.connectionPromise = undefined;
+        }
+    }
+    async openEventSource() {
+        this.closeEventSource();
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const eventsPath = this.config.paths?.events ?? "/events";
+        const url = `${baseUrl}${eventsPath}`;
+        return new Promise((resolve, reject) => {
+            try {
+                this.eventSource = new this.EventSourceCtor(url, {
+                    withCredentials: this.config.withCredentials,
+                });
+                const onMessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        this.handleIncomingEvent(data);
+                        if (data.type === "connection" && data.connectionId) {
+                            this._connectionId = data.connectionId;
+                            if (data.subscriptions) {
+                                for (const sessionId of data.subscriptions) {
+                                    this.subscriptions.add(sessionId);
+                                }
+                            }
+                            resolve();
+                        }
+                    }
+                    catch (error) {
+                        console.error("Failed to parse SSE event:", error);
+                    }
+                };
+                const onError = () => {
+                    if (this._state === "connecting") {
+                        this.closeEventSource();
+                        reject(new Error("SSE connection failed"));
+                    }
+                    else {
+                        this.setState("error");
+                    }
+                };
+                this.eventSource.addEventListener("message", onMessage);
+                this.eventSource.addEventListener("error", onError);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    closeEventSource() {
+        if (!this.eventSource)
+            return;
+        this.eventSource.close();
+        this.eventSource = undefined;
+        this._connectionId = undefined;
+        this.subscriptions.clear();
+        this.setState("disconnected");
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Session Management
+    // ══════════════════════════════════════════════════════════════════════════
+    /**
+     * Get a session accessor (cold - no subscription).
+     *
+     * Call `accessor.subscribe()` to receive events.
+     */
+    session(sessionId) {
+        let accessor = this.sessions.get(sessionId);
+        if (!accessor) {
+            accessor = new SessionAccessorImpl(sessionId, this);
+            this.sessions.set(sessionId, accessor);
+        }
+        return accessor;
+    }
+    /**
+     * Subscribe to a session and get accessor (hot).
+     */
+    subscribe(sessionId) {
+        const accessor = this.session(sessionId);
+        accessor.subscribe();
+        return accessor;
+    }
+    /** @internal - Called by SessionAccessor */
+    async _subscribeToSession(sessionId) {
+        await this.ensureConnection();
+        if (this.subscriptions.has(sessionId)) {
+            return;
+        }
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.subscribeToSession(sessionId);
+            this.subscriptions.add(sessionId);
+            return;
+        }
+        if (!this._connectionId) {
+            throw new Error("Connection not established");
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const subscribePath = this.config.paths?.subscribe ?? "/subscribe";
+        const response = await this.fetchFn(`${baseUrl}${subscribePath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({
+                connectionId: this._connectionId,
+                add: [sessionId],
+            }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to subscribe: ${response.status} ${text}`);
+        }
+        this.subscriptions.add(sessionId);
+    }
+    /** @internal - Called by SessionAccessor */
+    async _unsubscribeFromSession(sessionId) {
+        if (!this.subscriptions.has(sessionId)) {
+            return;
+        }
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.unsubscribeFromSession(sessionId);
+            this.subscriptions.delete(sessionId);
+            return;
+        }
+        if (!this._connectionId) {
+            return;
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const subscribePath = this.config.paths?.subscribe ?? "/subscribe";
+        await this.fetchFn(`${baseUrl}${subscribePath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({
+                connectionId: this._connectionId,
+                remove: [sessionId],
+            }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        this.subscriptions.delete(sessionId);
+    }
+    /** @internal - Called by SessionAccessor to publish to a channel */
+    async _publishToChannel(sessionId, channelName, event) {
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.publishToChannel(sessionId, channelName, event);
+            return;
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const channelPath = this.config.paths?.channel ?? "/channel";
+        const response = await this.fetchFn(`${baseUrl}${channelPath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({
+                sessionId,
+                channel: channelName,
+                type: event.type,
+                payload: event.payload,
+                id: event.id,
+                metadata: event.metadata,
+            }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to publish to channel: ${response.status} ${text}`);
+        }
+    }
+    /** @internal - Called by SessionAccessor to subscribe to a channel */
+    async _subscribeToChannel(sessionId, channelName) {
+        // Ensure we have a connection before subscribing
+        await this.ensureConnection();
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.subscribeToChannel(sessionId, channelName);
+            return;
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const channelPath = this.config.paths?.channel ?? "/channel";
+        const response = await this.fetchFn(`${baseUrl}${channelPath}/subscribe`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({
+                sessionId,
+                channel: channelName,
+                clientId: this._connectionId,
+            }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to subscribe to channel: ${response.status} ${text}`);
+        }
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Message Operations
+    // ══════════════════════════════════════════════════════════════════════════
+    /**
+     * Send a message.
+     *
+     * @param input - Message input (message or messages)
+     * @param options - Options including optional sessionId
+     */
+    send(input, options) {
+        const payload = this.normalizeSendInput(input);
+        const abortController = new AbortController();
+        const handle = new ClientExecutionHandleImpl(this, abortController, options?.sessionId);
+        void this.performSend(payload, options, handle, abortController);
+        return handle;
+    }
+    async performSend(payload, options, handle, abortController) {
+        try {
+            // Use custom transport if provided
+            if (this.customTransport) {
+                const stream = this.customTransport.send(payload, options?.sessionId);
+                // Wire up abort
+                abortController.signal.addEventListener("abort", () => {
+                    stream.abort(abortController.signal.reason ?? "Aborted");
+                });
+                for await (const event of stream) {
+                    if (event.type === "channel" || event.type === "connection") {
+                        continue;
+                    }
+                    handle._handleEvent(event);
+                    this.handleIncomingEvent(event);
+                }
+                handle._complete();
+                return;
+            }
+            // Default HTTP fetch logic
+            const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+            const sendPath = this.config.paths?.send ?? "/send";
+            const body = { ...payload };
+            if (options?.sessionId) {
+                body.sessionId = options.sessionId;
+            }
+            const response = await this.fetchFn(`${baseUrl}${sendPath}`, {
+                method: "POST",
+                headers: this.requestHeaders,
+                credentials: this.config.withCredentials ? "include" : "same-origin",
+                body: JSON.stringify(body),
+                signal: abortController.signal,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`Failed to send: ${response.status} ${text}`);
+            }
+            if (!response.body) {
+                throw new Error("No response body for send");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.startsWith("data: "))
+                        continue;
+                    try {
+                        const data = JSON.parse(line.slice(6));
+                        if (data.type === "channel" || data.type === "connection") {
+                            continue;
+                        }
+                        const event = data;
+                        handle._handleEvent(event);
+                        this.handleIncomingEvent(data);
+                    }
+                    catch (error) {
+                        console.error("Failed to parse send event:", error);
+                    }
+                }
+            }
+            handle._complete();
+        }
+        catch (error) {
+            handle._fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    normalizeSendInput(input) {
+        if (typeof input === "string") {
+            return { messages: [{ role: "user", content: [{ type: "text", text: input }] }] };
+        }
+        if (Array.isArray(input)) {
+            if (input.length === 0) {
+                return { messages: [] };
+            }
+            if (typeof input[0].role === "string") {
+                return { messages: input };
+            }
+            return { messages: [{ role: "user", content: input }] };
+        }
+        if (typeof input === "object" && input && "role" in input && "content" in input) {
+            return { messages: [input] };
+        }
+        return input;
+    }
+    /**
+     * Abort a session's current execution.
+     */
+    async abort(sessionId, reason) {
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.abortSession(sessionId, reason);
+            return;
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const abortPath = this.config.paths?.abort ?? "/abort";
+        const response = await this.fetchFn(`${baseUrl}${abortPath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({ sessionId, reason }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to abort: ${response.status} ${text}`);
+        }
+    }
+    /**
+     * Close a session.
+     */
+    async closeSession(sessionId) {
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.closeSession(sessionId);
+        }
+        else {
+            const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+            const closePath = this.config.paths?.close ?? "/close";
+            const response = await this.fetchFn(`${baseUrl}${closePath}`, {
+                method: "POST",
+                headers: this.requestHeaders,
+                credentials: this.config.withCredentials ? "include" : "same-origin",
+                body: JSON.stringify({ sessionId }),
+                signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`Failed to close: ${response.status} ${text}`);
+            }
+        }
+        // Clean up accessor
+        const accessor = this.sessions.get(sessionId);
+        if (accessor) {
+            accessor._destroy();
+            this.sessions.delete(sessionId);
+        }
+        this.subscriptions.delete(sessionId);
+    }
+    /**
+     * Submit a tool confirmation response.
+     */
+    async submitToolResult(sessionId, toolUseId, result) {
+        // Use custom transport if provided
+        if (this.customTransport) {
+            await this.customTransport.submitToolResult(sessionId, toolUseId, result);
+            return;
+        }
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const toolResponsePath = this.config.paths?.toolResponse ?? "/tool-response";
+        const response = await this.fetchFn(`${baseUrl}${toolResponsePath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({ sessionId, toolUseId, result }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to submit tool result: ${response.status} ${text}`);
+        }
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Event Handling
+    // ══════════════════════════════════════════════════════════════════════════
+    /**
+     * Subscribe to all stream events (from all sessions).
+     */
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => {
+            this.eventHandlers.delete(handler);
+        };
+    }
+    /**
+     * Ergonomic event subscription.
+     */
+    on(eventName, handler) {
+        switch (eventName) {
+            case "event":
+                return this.onEvent(handler);
+            case "state":
+                return this.onConnectionChange(handler);
+            default: {
+                const streamType = eventName;
+                const streamHandler = handler;
+                return this.onEvent((event) => {
+                    if (event.type === streamType) {
+                        streamHandler(event);
+                    }
+                });
+            }
+        }
+    }
+    handleIncomingEvent(data) {
+        const sessionId = data.sessionId;
+        const type = data.type;
+        // Handle connection event
+        if (type === "connection") {
+            return;
+        }
+        // Handle channel events (from server → client)
+        if (type === "channel" && sessionId) {
+            const channelName = data.channel;
+            const channelEvent = data.event;
+            if (channelName && channelEvent) {
+                const accessor = this.sessions.get(sessionId);
+                if (accessor) {
+                    accessor._handleChannelEvent(channelName, channelEvent);
+                }
+            }
+            return;
+        }
+        // Route stream events
+        const streamEvent = data;
+        const eventId = streamEvent.id;
+        if (eventId) {
+            if (this.seenEventIds.has(eventId)) {
+                return;
+            }
+            this.seenEventIds.add(eventId);
+            this.seenEventIdsOrder.push(eventId);
+            if (this.seenEventIdsOrder.length > this.maxSeenEventIds) {
+                const oldest = this.seenEventIdsOrder.shift();
+                if (oldest) {
+                    this.seenEventIds.delete(oldest);
+                }
+            }
+        }
+        // Update streaming text state
+        this.updateStreamingText(streamEvent);
+        // Notify global handlers
+        if (sessionId) {
+            const sessionEvent = streamEvent;
+            for (const handler of this.eventHandlers) {
+                try {
+                    handler(sessionEvent);
+                }
+                catch (error) {
+                    console.error("Error in event handler:", error);
+                }
+            }
+        }
+        // Notify session-specific handlers
+        if (sessionId) {
+            const accessor = this.sessions.get(sessionId);
+            if (accessor) {
+                accessor._handleEvent(streamEvent);
+            }
+        }
+        // Handle result events
+        if (type === "result" && "result" in data) {
+            if (sessionId) {
+                const accessor = this.sessions.get(sessionId);
+                if (accessor) {
+                    accessor._handleResult(data.result);
+                }
+            }
+        }
+        // Handle tool confirmation requests
+        if (type === "tool_confirmation_required" && sessionId) {
+            const required = data;
+            const request = {
+                toolUseId: required.callId,
+                name: required.name,
+                arguments: required.input,
+                message: required.message,
+            };
+            const accessor = this.sessions.get(sessionId);
+            if (accessor) {
+                accessor._handleToolConfirmation(request);
+            }
+        }
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Streaming Text
+    // ══════════════════════════════════════════════════════════════════════════
+    /** Current streaming text state */
+    get streamingText() {
+        return this._streamingText;
+    }
+    /**
+     * Subscribe to streaming text state changes.
+     */
+    onStreamingText(handler) {
+        this.streamingTextHandlers.add(handler);
+        handler(this._streamingText);
+        return () => {
+            this.streamingTextHandlers.delete(handler);
+        };
+    }
+    /** Clear the accumulated streaming text */
+    clearStreamingText() {
+        this.setStreamingText({ text: "", isStreaming: false });
+    }
+    setStreamingText(state) {
+        this._streamingText = state;
+        for (const handler of this.streamingTextHandlers) {
+            try {
+                handler(state);
+            }
+            catch (error) {
+                console.error("Error in streaming text handler:", error);
+            }
+        }
+    }
+    updateStreamingText(event) {
+        switch (event.type) {
+            case "tick_start":
+                this.setStreamingText({ text: "", isStreaming: true });
+                break;
+            case "content_delta":
+                this.setStreamingText({
+                    text: this._streamingText.text + event.delta,
+                    isStreaming: true,
+                });
+                break;
+            case "tick_end":
+            case "execution_end":
+                this.setStreamingText({
+                    text: this._streamingText.text,
+                    isStreaming: false,
+                });
+                break;
+        }
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Custom Method Invocation
+    // ══════════════════════════════════════════════════════════════════════════
+    /**
+     * Invoke a custom Gateway method.
+     * For session-scoped methods, use session.invoke() instead.
+     *
+     * @example
+     * ```typescript
+     * // Invoke a custom method
+     * const result = await client.invoke("tasks:list", { status: "active" });
+     *
+     * // Invoke with admin method
+     * const stats = await client.invoke("admin:stats");
+     * ```
+     */
+    async invoke(method, params = {}) {
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const invokePath = this.config.paths?.invoke ?? "/invoke";
+        const response = await this.fetchFn(`${baseUrl}${invokePath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({
+                method,
+                params,
+            }),
+            signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to invoke method: ${response.status} ${text}`);
+        }
+        const result = await response.json();
+        return result;
+    }
+    /**
+     * Invoke a streaming method, returns async iterator.
+     * Yields values as they arrive from the server.
+     *
+     * @example
+     * ```typescript
+     * // Stream task updates
+     * for await (const change of client.stream("tasks:watch")) {
+     *   console.log("Task changed:", change);
+     * }
+     * ```
+     */
+    async *stream(method, params = {}) {
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const invokePath = this.config.paths?.invoke ?? "/invoke";
+        const response = await this.fetchFn(`${baseUrl}${invokePath}`, {
+            method: "POST",
+            headers: this.requestHeaders,
+            credentials: this.config.withCredentials ? "include" : "same-origin",
+            body: JSON.stringify({
+                method,
+                params,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to invoke streaming method: ${response.status} ${text}`);
+        }
+        if (!response.body) {
+            throw new Error("No response body for streaming method");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: "))
+                    continue;
+                try {
+                    const data = JSON.parse(line.slice(6));
+                    if (data.type === "method:chunk") {
+                        yield data.chunk;
+                    }
+                    else if (data.type === "method:end") {
+                        return;
+                    }
+                }
+                catch (error) {
+                    console.error("Failed to parse stream event:", error);
+                }
+            }
+        }
+    }
+    /**
+     * Get authorization headers for use with fetch.
+     * Useful for making authenticated requests to custom routes.
+     *
+     * @example
+     * ```typescript
+     * // Make authenticated request to custom API
+     * const response = await fetch("/api/custom", {
+     *   headers: client.getAuthHeaders(),
+     * });
+     * ```
+     */
+    getAuthHeaders() {
+        const headers = {};
+        if (this.config.token) {
+            headers["Authorization"] = `Bearer ${this.config.token}`;
+        }
+        return headers;
+    }
+    // ══════════════════════════════════════════════════════════════════════════
+    // Cleanup
+    // ══════════════════════════════════════════════════════════════════════════
+    /**
+     * Cleanup and close the client.
+     */
+    destroy() {
+        // Clean up custom transport
+        if (this.customTransport) {
+            this.transportCleanup?.();
+            this.customTransport.disconnect();
+        }
+        else {
+            this.closeEventSource();
+        }
+        for (const accessor of this.sessions.values()) {
+            accessor._destroy();
+        }
+        this.sessions.clear();
+        this.stateHandlers.clear();
+        this.eventHandlers.clear();
+        this.streamingTextHandlers.clear();
+        this._streamingText = { text: "", isStreaming: false };
+        this.seenEventIds.clear();
+        this.seenEventIdsOrder = [];
+        this.subscriptions.clear();
+    }
+    /**
+     * Get the underlying transport (if using custom transport).
+     * Useful for accessing transport-specific features like leadership status.
+     */
+    getTransport() {
+        return this.customTransport ?? undefined;
+    }
+}
+// ============================================================================
+// Transport Detection
+// ============================================================================
+/**
+ * Detect the appropriate transport based on URL scheme.
+ */
+function detectTransport(baseUrl) {
+    const url = baseUrl.toLowerCase();
+    if (url.startsWith("ws://") || url.startsWith("wss://")) {
+        return "websocket";
+    }
+    return "sse";
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create a new AgentickClient.
+ *
+ * Transport is auto-detected from the URL scheme:
+ * - http:// or https:// -> SSE transport
+ * - ws:// or wss:// -> WebSocket transport
+ *
+ * You can also explicitly set the transport in the config, or provide
+ * a custom ClientTransport instance (e.g., SharedTransport for multi-tab).
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect transport (SSE for http://)
+ * const client = createClient({
+ *   baseUrl: 'https://api.example.com',
+ * });
+ *
+ * // Auto-detect transport (WebSocket for ws://)
+ * const wsClient = createClient({
+ *   baseUrl: 'ws://localhost:18789',
+ * });
+ *
+ * // Force WebSocket transport
+ * const wsClient2 = createClient({
+ *   baseUrl: 'http://localhost:3000',
+ *   transport: 'websocket',
+ * });
+ *
+ * // Custom transport (e.g., SharedTransport for multi-tab)
+ * import { createSharedTransport } from '@agentick/client-multiplexer';
+ * const sharedClient = createClient({
+ *   baseUrl: 'https://api.example.com',
+ *   transport: createSharedTransport({ baseUrl: 'https://api.example.com' }),
+ * });
+ *
+ * // Subscribe to a session
+ * const session = client.subscribe('conv-123');
+ *
+ * // Send a message
+ * const handle = session.send({ messages: [{ role: 'user', content: [...] }] });
+ * await handle.result;
+ * ```
+ */
+export function createClient(config) {
+    // If a custom transport object is provided, use it directly
+    if (config.transport && typeof config.transport === "object") {
+        return new AgentickClient(config);
+    }
+    const transport = config.transport === "auto" || !config.transport
+        ? detectTransport(config.baseUrl)
+        : config.transport;
+    if (transport === "websocket") {
+        // Log warning - WebSocket transport requires using the WSTransport directly
+        // or the gateway client for full functionality
+        console.warn("[AgentickClient] WebSocket URL detected. For full WebSocket support, " +
+            "use createWSTransport() directly or connect to a Gateway. " +
+            "Falling back to SSE transport with URL conversion.");
+        // Convert ws:// to http:// for SSE fallback
+        let baseUrl = config.baseUrl;
+        if (baseUrl.startsWith("ws://")) {
+            baseUrl = baseUrl.replace("ws://", "http://");
+        }
+        else if (baseUrl.startsWith("wss://")) {
+            baseUrl = baseUrl.replace("wss://", "https://");
+        }
+        return new AgentickClient({ ...config, baseUrl });
+    }
+    return new AgentickClient(config);
+}
+//# sourceMappingURL=client.js.map