@townco/ui 0.1.0 → 0.1.6

package/dist/sdk/transports/http.js

@@ -4,473 +4,476 @@ import * as acp from "@agentclientprotocol/sdk";
  * Uses POST /rpc for client->agent messages and GET /events (SSE) for agent->client
  */
 export class HttpTransport {
-    connected = false;
-    sessionUpdateCallbacks = new Set();
-    errorCallbacks = new Set();
-    messageQueue = [];
-    currentSessionId = null;
-    chunkResolvers = [];
-    streamComplete = false;
-    sseAbortController = null;
-    reconnectAttempts = 0;
-    maxReconnectAttempts = 5;
-    reconnectDelay = 1000; // Start with 1 second
-    reconnecting = false;
-    abortController = null;
-    options;
-    constructor(options) {
-        // Ensure baseUrl doesn't end with a slash
-        this.options = { ...options, baseUrl: options.baseUrl.replace(/\/$/, "") };
-    }
-    async connect() {
-        if (this.connected) {
-            return;
-        }
-        try {
-            this.abortController = new AbortController();
-            // Step 1: Initialize the ACP connection
-            const initRequest = {
-                protocolVersion: acp.PROTOCOL_VERSION,
-                clientCapabilities: {
-                    fs: {
-                        readTextFile: true,
-                        writeTextFile: true,
-                    },
-                },
-            };
-            const initResponse = await this.sendRpcRequest("initialize", initRequest);
-            console.log("ACP connection initialized:", initResponse);
-            // Step 2: Create a new session
-            const sessionRequest = {
-                cwd: "/",
-                mcpServers: [],
-            };
-            const sessionResponse = await this.sendRpcRequest("session/new", sessionRequest);
-            this.currentSessionId = sessionResponse.sessionId;
-            console.log("Session created:", this.currentSessionId);
-            // Step 3: Open SSE connection for receiving messages
-            await this.connectSSE();
-            this.connected = true;
-            this.reconnectAttempts = 0; // Reset on successful connection
-        }
-        catch (error) {
-            this.connected = false;
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.notifyError(err);
-            throw err;
-        }
-    }
-    async disconnect() {
-        if (!this.connected) {
-            return;
-        }
-        try {
-            // Abort any ongoing requests
-            if (this.abortController) {
-                this.abortController.abort();
-                this.abortController = null;
-            }
-            // Abort SSE connection
-            if (this.sseAbortController) {
-                this.sseAbortController.abort();
-                this.sseAbortController = null;
-            }
-            // Clear state
-            this.connected = false;
-            this.currentSessionId = null;
-            this.messageQueue = [];
-            this.chunkResolvers = [];
-            this.streamComplete = false;
-            this.reconnecting = false;
-            this.reconnectAttempts = 0;
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.notifyError(err);
-            throw err;
-        }
-    }
-    async send(message) {
-        if (!this.connected || !this.currentSessionId) {
-            throw new Error("Transport not connected");
-        }
-        try {
-            // Reset stream state for new message
-            this.streamComplete = false;
-            this.messageQueue = [];
-            // Convert our message format to ACP prompt format
-            const textContent = message.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("\n");
-            // Create ACP prompt request
-            const promptRequest = {
-                sessionId: this.currentSessionId,
-                prompt: [
-                    {
-                        type: "text",
-                        text: textContent,
-                    },
-                ],
-            };
-            // Send the prompt - this will trigger streaming responses via SSE
-            const promptResponse = await this.sendRpcRequest("session/prompt", promptRequest);
-            console.log("Prompt sent:", promptResponse);
-            // Mark stream as complete after prompt finishes
-            this.streamComplete = true;
-            // Send completion chunk
-            const resolver = this.chunkResolvers.shift();
-            if (resolver) {
-                resolver({
-                    id: this.currentSessionId || "unknown",
-                    role: "assistant",
-                    contentDelta: { type: "text", text: "" },
-                    isComplete: true,
-                });
-            }
-            else {
-                this.messageQueue.push({
-                    id: this.currentSessionId || "unknown",
-                    role: "assistant",
-                    contentDelta: { type: "text", text: "" },
-                    isComplete: true,
-                });
-            }
-        }
-        catch (error) {
-            this.streamComplete = true;
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.notifyError(err);
-            throw err;
-        }
-    }
-    async *receive() {
-        // Keep yielding chunks until stream is complete
-        while (!this.streamComplete) {
-            // Check if there are queued messages
-            if (this.messageQueue.length > 0) {
-                const chunk = this.messageQueue.shift();
-                if (chunk) {
-                    yield chunk;
-                    if (chunk.isComplete) {
-                        return;
-                    }
-                }
-            }
-            else {
-                // Wait for next chunk to arrive
-                const chunk = await new Promise((resolve) => {
-                    this.chunkResolvers.push(resolve);
-                });
-                if (chunk.isComplete) {
-                    yield chunk;
-                    return;
-                }
-                else {
-                    yield chunk;
-                }
-            }
-        }
-        // Yield any remaining queued messages
-        while (this.messageQueue.length > 0) {
-            const chunk = this.messageQueue.shift();
-            if (chunk) {
-                yield chunk;
-            }
-        }
-        // Mark the stream as complete
-        yield {
-            id: this.currentSessionId || "unknown",
-            role: "assistant",
-            contentDelta: { type: "text", text: "" },
-            isComplete: true,
-        };
-    }
-    isConnected() {
-        return this.connected;
-    }
-    onSessionUpdate(callback) {
-        this.sessionUpdateCallbacks.add(callback);
-        return () => {
-            this.sessionUpdateCallbacks.delete(callback);
-        };
-    }
-    onError(callback) {
-        this.errorCallbacks.add(callback);
-        return () => {
-            this.errorCallbacks.delete(callback);
-        };
-    }
-    /**
-     * Send an ACP RPC request to the server
-     */
-    async sendRpcRequest(method, params) {
-        const requestId = this.generateRequestId();
-        // Construct ACP request message
-        const request = {
-            jsonrpc: "2.0",
-            id: requestId,
-            method,
-            params,
-        };
-        const headers = {
-            "Content-Type": "application/json",
-            ...this.options.headers,
-        };
-        const timeout = this.options.timeout || 30000;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const response = await fetch(`${this.options.baseUrl}/rpc`, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(request),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
-            }
-            const result = await response.json();
-            // Check for JSON-RPC error
-            if (result.error) {
-                throw new Error(`ACP error: ${result.error.message || JSON.stringify(result.error)}`);
-            }
-            return result.result || result;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new Error(`Request timeout after ${timeout}ms`);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Connect to the SSE event stream
-     * Uses fetch-based SSE to support custom headers (X-Session-ID)
-     */
-    async connectSSE() {
-        if (!this.currentSessionId) {
-            throw new Error("Cannot connect SSE without a session ID");
-        }
-        const url = `${this.options.baseUrl}/events`;
-        const headers = {
-            "X-Session-ID": this.currentSessionId,
-            ...this.options.headers,
-        };
-        // Create a new abort controller for this SSE connection
-        this.sseAbortController = new AbortController();
-        try {
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: this.sseAbortController.signal,
-            });
-            if (!response.ok) {
-                throw new Error(`SSE connection failed: HTTP ${response.status}`);
-            }
-            if (!response.body) {
-                throw new Error("Response body is null");
-            }
-            console.log("SSE connection opened");
-            this.reconnectAttempts = 0;
-            this.reconnectDelay = 1000;
-            // Read the SSE stream
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = "";
-            // Process the stream in the background
-            (async () => {
-                try {
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done) {
-                            console.log("SSE stream closed by server");
-                            if (this.connected) {
-                                await this.handleSSEDisconnect();
-                            }
-                            break;
-                        }
-                        // Decode the chunk and add to buffer
-                        buffer += decoder.decode(value, { stream: true });
-                        // Process complete SSE messages
-                        const lines = buffer.split("\n");
-                        buffer = lines.pop() || ""; // Keep incomplete line in buffer
-                        let currentEvent = { event: "message", data: "" };
-                        for (const line of lines) {
-                            if (line.startsWith("event:")) {
-                                currentEvent.event = line.substring(6).trim();
-                            }
-                            else if (line.startsWith("data:")) {
-                                currentEvent.data = line.substring(5).trim();
-                            }
-                            else if (line === "") {
-                                // Empty line signals end of event
-                                if (currentEvent.event === "message" && currentEvent.data) {
-                                    this.handleSSEMessage(currentEvent.data);
-                                }
-                                // Reset for next event
-                                currentEvent = { event: "message", data: "" };
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    if (error instanceof Error && error.name === "AbortError") {
-                        console.log("SSE stream aborted");
-                        return;
-                    }
-                    console.error("Error reading SSE stream:", error);
-                    if (this.connected && !this.reconnecting) {
-                        await this.handleSSEDisconnect();
-                    }
-                }
-            })();
-        }
-        catch (error) {
-            console.error("SSE connection error:", error);
-            throw error;
-        }
-    }
-    /**
-     * Handle SSE disconnection with automatic reconnection
-     */
-    async handleSSEDisconnect() {
-        if (this.reconnecting || !this.connected) {
-            return;
-        }
-        this.reconnecting = true;
-        // Abort the current SSE connection
-        if (this.sseAbortController) {
-            this.sseAbortController.abort();
-            this.sseAbortController = null;
-        }
-        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            const error = new Error(`SSE reconnection failed after ${this.maxReconnectAttempts} attempts`);
-            this.notifyError(error);
-            this.connected = false;
-            this.reconnecting = false;
-            return;
-        }
-        this.reconnectAttempts++;
-        const delay = Math.min(this.reconnectDelay * 2 ** (this.reconnectAttempts - 1), 32000);
-        console.log(`SSE reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        try {
-            await this.connectSSE();
-            console.log("SSE reconnected successfully");
-            this.reconnecting = false;
-        }
-        catch (error) {
-            console.error("SSE reconnection failed:", error);
-            this.reconnecting = false;
-            // Will try again on next error event
-        }
-    }
-    /**
-     * Handle an incoming SSE message
-     */
-    handleSSEMessage(data) {
-        try {
-            const message = JSON.parse(data);
-            // Validate the message is an ACP agent outgoing message
-            const parseResult = acp.agentOutgoingMessageSchema.safeParse(message);
-            if (!parseResult.success) {
-                console.error("Invalid ACP message from SSE:", parseResult.error.issues);
-                return;
-            }
-            const acpMessage = parseResult.data;
-            // Check if this is a notification (has method but not a response)
-            if ("method" in acpMessage && acpMessage.method === "session/update") {
-                // Type narrowing: we know it has method and params
-                if ("params" in acpMessage && acpMessage.params) {
-                    this.handleSessionNotification(acpMessage.params);
-                }
-            }
-        }
-        catch (error) {
-            console.error("Error parsing SSE message:", error);
-            this.notifyError(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Handle a session notification from the agent
-     */
-    handleSessionNotification(params) {
-        // Extract content from the update
-        const paramsExtended = params;
-        const update = paramsExtended.update;
-        const sessionUpdate = {
-            sessionId: this.currentSessionId || params.sessionId,
-            status: "active",
-        };
-        // Queue message chunks if present
-        if (update?.content) {
-            const content = update.content;
-            let chunk = null;
-            if (content.type === "text" && content.text) {
-                chunk = {
-                    id: params.sessionId,
-                    role: "assistant",
-                    contentDelta: { type: "text", text: content.text },
-                    isComplete: false,
-                };
-            }
-            else if (content.type === "tool_call") {
-                chunk = {
-                    id: params.sessionId,
-                    role: "assistant",
-                    // biome-ignore lint/suspicious/noExplicitAny: hopefully assume that the server is sending the right stuff
-                    contentDelta: content,
-                    isComplete: false,
-                };
-            }
-            if (chunk) {
-                // Resolve any waiting receive() calls immediately
-                const resolver = this.chunkResolvers.shift();
-                if (resolver) {
-                    resolver(chunk);
-                }
-                else {
-                    // Only queue if no resolver is waiting
-                    this.messageQueue.push(chunk);
-                }
-            }
-        }
-        this.notifySessionUpdate(sessionUpdate);
-    }
-    /**
-     * Generate a unique request ID
-     */
-    generateRequestId() {
-        return `req-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-    }
-    /**
-     * Notify all session update callbacks
-     */
-    notifySessionUpdate(update) {
-        for (const callback of this.sessionUpdateCallbacks) {
-            try {
-                callback(update);
-            }
-            catch (error) {
-                console.error("Error in session update callback:", error);
-            }
-        }
-    }
-    /**
-     * Notify all error callbacks
-     */
-    notifyError(error) {
-        for (const callback of this.errorCallbacks) {
-            try {
-                callback(error);
-            }
-            catch (err) {
-                console.error("Error in error callback:", err);
-            }
-        }
-    }
+	connected = false;
+	sessionUpdateCallbacks = new Set();
+	errorCallbacks = new Set();
+	messageQueue = [];
+	currentSessionId = null;
+	chunkResolvers = [];
+	streamComplete = false;
+	sseAbortController = null;
+	reconnectAttempts = 0;
+	maxReconnectAttempts = 5;
+	reconnectDelay = 1000; // Start with 1 second
+	reconnecting = false;
+	abortController = null;
+	options;
+	constructor(options) {
+		// Ensure baseUrl doesn't end with a slash
+		this.options = { ...options, baseUrl: options.baseUrl.replace(/\/$/, "") };
+	}
+	async connect() {
+		if (this.connected) {
+			return;
+		}
+		try {
+			this.abortController = new AbortController();
+			// Step 1: Initialize the ACP connection
+			const initRequest = {
+				protocolVersion: acp.PROTOCOL_VERSION,
+				clientCapabilities: {
+					fs: {
+						readTextFile: true,
+						writeTextFile: true,
+					},
+				},
+			};
+			const initResponse = await this.sendRpcRequest("initialize", initRequest);
+			console.log("ACP connection initialized:", initResponse);
+			// Step 2: Create a new session
+			const sessionRequest = {
+				cwd: "/",
+				mcpServers: [],
+			};
+			const sessionResponse = await this.sendRpcRequest(
+				"session/new",
+				sessionRequest,
+			);
+			this.currentSessionId = sessionResponse.sessionId;
+			console.log("Session created:", this.currentSessionId);
+			// Step 3: Open SSE connection for receiving messages
+			await this.connectSSE();
+			this.connected = true;
+			this.reconnectAttempts = 0; // Reset on successful connection
+		} catch (error) {
+			this.connected = false;
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.notifyError(err);
+			throw err;
+		}
+	}
+	async disconnect() {
+		if (!this.connected) {
+			return;
+		}
+		try {
+			// Abort any ongoing requests
+			if (this.abortController) {
+				this.abortController.abort();
+				this.abortController = null;
+			}
+			// Abort SSE connection
+			if (this.sseAbortController) {
+				this.sseAbortController.abort();
+				this.sseAbortController = null;
+			}
+			// Clear state
+			this.connected = false;
+			this.currentSessionId = null;
+			this.messageQueue = [];
+			this.chunkResolvers = [];
+			this.streamComplete = false;
+			this.reconnecting = false;
+			this.reconnectAttempts = 0;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.notifyError(err);
+			throw err;
+		}
+	}
+	async send(message) {
+		if (!this.connected || !this.currentSessionId) {
+			throw new Error("Transport not connected");
+		}
+		try {
+			// Reset stream state for new message
+			this.streamComplete = false;
+			this.messageQueue = [];
+			// Convert our message format to ACP prompt format
+			const textContent = message.content
+				.filter((c) => c.type === "text")
+				.map((c) => c.text)
+				.join("\n");
+			// Create ACP prompt request
+			const promptRequest = {
+				sessionId: this.currentSessionId,
+				prompt: [
+					{
+						type: "text",
+						text: textContent,
+					},
+				],
+			};
+			// Send the prompt - this will trigger streaming responses via SSE
+			const promptResponse = await this.sendRpcRequest(
+				"session/prompt",
+				promptRequest,
+			);
+			console.log("Prompt sent:", promptResponse);
+			// Mark stream as complete after prompt finishes
+			this.streamComplete = true;
+			// Send completion chunk
+			const resolver = this.chunkResolvers.shift();
+			if (resolver) {
+				resolver({
+					id: this.currentSessionId || "unknown",
+					role: "assistant",
+					contentDelta: { type: "text", text: "" },
+					isComplete: true,
+				});
+			} else {
+				this.messageQueue.push({
+					id: this.currentSessionId || "unknown",
+					role: "assistant",
+					contentDelta: { type: "text", text: "" },
+					isComplete: true,
+				});
+			}
+		} catch (error) {
+			this.streamComplete = true;
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.notifyError(err);
+			throw err;
+		}
+	}
+	async *receive() {
+		// Keep yielding chunks until stream is complete
+		while (!this.streamComplete) {
+			// Check if there are queued messages
+			if (this.messageQueue.length > 0) {
+				const chunk = this.messageQueue.shift();
+				if (chunk) {
+					yield chunk;
+					if (chunk.isComplete) {
+						return;
+					}
+				}
+			} else {
+				// Wait for next chunk to arrive
+				const chunk = await new Promise((resolve) => {
+					this.chunkResolvers.push(resolve);
+				});
+				if (chunk.isComplete) {
+					yield chunk;
+					return;
+				} else {
+					yield chunk;
+				}
+			}
+		}
+		// Yield any remaining queued messages
+		while (this.messageQueue.length > 0) {
+			const chunk = this.messageQueue.shift();
+			if (chunk) {
+				yield chunk;
+			}
+		}
+		// Mark the stream as complete
+		yield {
+			id: this.currentSessionId || "unknown",
+			role: "assistant",
+			contentDelta: { type: "text", text: "" },
+			isComplete: true,
+		};
+	}
+	isConnected() {
+		return this.connected;
+	}
+	onSessionUpdate(callback) {
+		this.sessionUpdateCallbacks.add(callback);
+		return () => {
+			this.sessionUpdateCallbacks.delete(callback);
+		};
+	}
+	onError(callback) {
+		this.errorCallbacks.add(callback);
+		return () => {
+			this.errorCallbacks.delete(callback);
+		};
+	}
+	/**
+	 * Send an ACP RPC request to the server
+	 */
+	async sendRpcRequest(method, params) {
+		const requestId = this.generateRequestId();
+		// Construct ACP request message
+		const request = {
+			jsonrpc: "2.0",
+			id: requestId,
+			method,
+			params,
+		};
+		const headers = {
+			"Content-Type": "application/json",
+			...this.options.headers,
+		};
+		const timeout = this.options.timeout || 30000;
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		try {
+			const response = await fetch(`${this.options.baseUrl}/rpc`, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(request),
+				signal: controller.signal,
+			});
+			clearTimeout(timeoutId);
+			if (!response.ok) {
+				const errorText = await response.text();
+				throw new Error(`HTTP ${response.status}: ${errorText}`);
+			}
+			const result = await response.json();
+			// Check for JSON-RPC error
+			if (result.error) {
+				throw new Error(
+					`ACP error: ${result.error.message || JSON.stringify(result.error)}`,
+				);
+			}
+			return result.result || result;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof Error && error.name === "AbortError") {
+				throw new Error(`Request timeout after ${timeout}ms`);
+			}
+			throw error;
+		}
+	}
+	/**
+	 * Connect to the SSE event stream
+	 * Uses fetch-based SSE to support custom headers (X-Session-ID)
+	 */
+	async connectSSE() {
+		if (!this.currentSessionId) {
+			throw new Error("Cannot connect SSE without a session ID");
+		}
+		const url = `${this.options.baseUrl}/events`;
+		const headers = {
+			"X-Session-ID": this.currentSessionId,
+			...this.options.headers,
+		};
+		// Create a new abort controller for this SSE connection
+		this.sseAbortController = new AbortController();
+		try {
+			const response = await fetch(url, {
+				method: "GET",
+				headers,
+				signal: this.sseAbortController.signal,
+			});
+			if (!response.ok) {
+				throw new Error(`SSE connection failed: HTTP ${response.status}`);
+			}
+			if (!response.body) {
+				throw new Error("Response body is null");
+			}
+			console.log("SSE connection opened");
+			this.reconnectAttempts = 0;
+			this.reconnectDelay = 1000;
+			// Read the SSE stream
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			// Process the stream in the background
+			(async () => {
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) {
+							console.log("SSE stream closed by server");
+							if (this.connected) {
+								await this.handleSSEDisconnect();
+							}
+							break;
+						}
+						// Decode the chunk and add to buffer
+						buffer += decoder.decode(value, { stream: true });
+						// Process complete SSE messages
+						const lines = buffer.split("\n");
+						buffer = lines.pop() || ""; // Keep incomplete line in buffer
+						let currentEvent = { event: "message", data: "" };
+						for (const line of lines) {
+							if (line.startsWith("event:")) {
+								currentEvent.event = line.substring(6).trim();
+							} else if (line.startsWith("data:")) {
+								currentEvent.data = line.substring(5).trim();
+							} else if (line === "") {
+								// Empty line signals end of event
+								if (currentEvent.event === "message" && currentEvent.data) {
+									this.handleSSEMessage(currentEvent.data);
+								}
+								// Reset for next event
+								currentEvent = { event: "message", data: "" };
+							}
+						}
+					}
+				} catch (error) {
+					if (error instanceof Error && error.name === "AbortError") {
+						console.log("SSE stream aborted");
+						return;
+					}
+					console.error("Error reading SSE stream:", error);
+					if (this.connected && !this.reconnecting) {
+						await this.handleSSEDisconnect();
+					}
+				}
+			})();
+		} catch (error) {
+			console.error("SSE connection error:", error);
+			throw error;
+		}
+	}
+	/**
+	 * Handle SSE disconnection with automatic reconnection
+	 */
+	async handleSSEDisconnect() {
+		if (this.reconnecting || !this.connected) {
+			return;
+		}
+		this.reconnecting = true;
+		// Abort the current SSE connection
+		if (this.sseAbortController) {
+			this.sseAbortController.abort();
+			this.sseAbortController = null;
+		}
+		if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+			const error = new Error(
+				`SSE reconnection failed after ${this.maxReconnectAttempts} attempts`,
+			);
+			this.notifyError(error);
+			this.connected = false;
+			this.reconnecting = false;
+			return;
+		}
+		this.reconnectAttempts++;
+		const delay = Math.min(
+			this.reconnectDelay * 2 ** (this.reconnectAttempts - 1),
+			32000,
+		);
+		console.log(
+			`SSE reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`,
+		);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		try {
+			await this.connectSSE();
+			console.log("SSE reconnected successfully");
+			this.reconnecting = false;
+		} catch (error) {
+			console.error("SSE reconnection failed:", error);
+			this.reconnecting = false;
+			// Will try again on next error event
+		}
+	}
+	/**
+	 * Handle an incoming SSE message
+	 */
+	handleSSEMessage(data) {
+		try {
+			const message = JSON.parse(data);
+			// Validate the message is an ACP agent outgoing message
+			const parseResult = acp.agentOutgoingMessageSchema.safeParse(message);
+			if (!parseResult.success) {
+				console.error(
+					"Invalid ACP message from SSE:",
+					parseResult.error.issues,
+				);
+				return;
+			}
+			const acpMessage = parseResult.data;
+			// Check if this is a notification (has method but not a response)
+			if ("method" in acpMessage && acpMessage.method === "session/update") {
+				// Type narrowing: we know it has method and params
+				if ("params" in acpMessage && acpMessage.params) {
+					this.handleSessionNotification(acpMessage.params);
+				}
+			}
+		} catch (error) {
+			console.error("Error parsing SSE message:", error);
+			this.notifyError(
+				error instanceof Error ? error : new Error(String(error)),
+			);
+		}
+	}
+	/**
+	 * Handle a session notification from the agent
+	 */
+	handleSessionNotification(params) {
+		// Extract content from the update
+		const paramsExtended = params;
+		const update = paramsExtended.update;
+		const sessionUpdate = {
+			sessionId: this.currentSessionId || params.sessionId,
+			status: "active",
+		};
+		// Queue message chunks if present
+		if (update?.content) {
+			const content = update.content;
+			let chunk = null;
+			if (content.type === "text" && content.text) {
+				chunk = {
+					id: params.sessionId,
+					role: "assistant",
+					contentDelta: { type: "text", text: content.text },
+					isComplete: false,
+				};
+			} else if (content.type === "tool_call") {
+				chunk = {
+					id: params.sessionId,
+					role: "assistant",
+					// biome-ignore lint/suspicious/noExplicitAny: hopefully assume that the server is sending the right stuff
+					contentDelta: content,
+					isComplete: false,
+				};
+			}
+			if (chunk) {
+				// Resolve any waiting receive() calls immediately
+				const resolver = this.chunkResolvers.shift();
+				if (resolver) {
+					resolver(chunk);
+				} else {
+					// Only queue if no resolver is waiting
+					this.messageQueue.push(chunk);
+				}
+			}
+		}
+		this.notifySessionUpdate(sessionUpdate);
+	}
+	/**
+	 * Generate a unique request ID
+	 */
+	generateRequestId() {
+		return `req-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+	}
+	/**
+	 * Notify all session update callbacks
+	 */
+	notifySessionUpdate(update) {
+		for (const callback of this.sessionUpdateCallbacks) {
+			try {
+				callback(update);
+			} catch (error) {
+				console.error("Error in session update callback:", error);
+			}
+		}
+	}
+	/**
+	 * Notify all error callbacks
+	 */
+	notifyError(error) {
+		for (const callback of this.errorCallbacks) {
+			try {
+				callback(error);
+			} catch (err) {
+				console.error("Error in error callback:", err);
+			}
+		}
+	}
 }