@townco/ui 0.1.15 → 0.1.16

package/dist/sdk/transports/http.js

@@ -4,476 +4,709 @@ 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);
+            console.log("[HTTP Transport] Received SSE message:", message);
+            // 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;
+            console.log("[HTTP Transport] Parsed ACP message, method:", "method" in acpMessage ? acpMessage.method : "(no method)");
+            // Check if this is a notification (has method but not a response)
+            if ("method" in acpMessage && acpMessage.method === "session/update") {
+                console.log("[HTTP Transport] This is a session/update notification");
+                // Type narrowing: we know it has method and params
+                if ("params" in acpMessage && acpMessage.params) {
+                    console.log("[HTTP Transport] Calling handleSessionNotification with params:", 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) {
+        console.log("[HTTP Transport] handleSessionNotification called with:", params);
+        // Extract content from the update
+        const paramsExtended = params;
+        const update = paramsExtended.update;
+        const sessionId = this.currentSessionId || params.sessionId;
+        console.log("[HTTP Transport] update.sessionUpdate type:", update?.sessionUpdate);
+        // Handle ACP tool call notifications
+        if (update?.sessionUpdate === "tool_call") {
+            console.log("[HTTP Transport] tool_call - tokenUsage:", update.tokenUsage);
+            // Extract messageId from _meta
+            const messageId = update._meta &&
+                typeof update._meta === "object" &&
+                "messageId" in update._meta
+                ? String(update._meta.messageId)
+                : undefined;
+            // Initial tool call notification
+            const toolCall = {
+                id: update.toolCallId ?? "",
+                title: update.title ?? "",
+                kind: update.kind || "other",
+                status: update.status || "pending",
+                locations: update.locations,
+                rawInput: update.rawInput,
+                tokenUsage: update.tokenUsage,
+                content: update.content?.map((c) => {
+                    // Type guard to safely check properties
+                    if (typeof c !== "object" || c === null) {
+                        return { type: "text", text: "" };
+                    }
+                    const content = c;
+                    // Handle ACP nested content format
+                    if (content.type === "content" &&
+                        typeof content.content === "object" &&
+                        content.content !== null) {
+                        const innerContent = content.content;
+                        if (innerContent.type === "text") {
+                            return {
+                                type: "content",
+                                content: {
+                                    type: "text",
+                                    text: typeof innerContent.text === "string"
+                                        ? innerContent.text
+                                        : "",
+                                },
+                            };
+                        }
+                    }
+                    // Handle legacy direct formats
+                    if (content.type === "text")
+                        return {
+                            type: "text",
+                            text: typeof content.text === "string" ? content.text : "",
+                        };
+                    if (content.type === "diff")
+                        return {
+                            type: "diff",
+                            path: typeof content.path === "string" ? content.path : "",
+                            oldText: typeof content.oldText === "string" ? content.oldText : "",
+                            newText: typeof content.newText === "string" ? content.newText : "",
+                            line: typeof content.line === "number" ? content.line : null,
+                        };
+                    if (content.type === "terminal")
+                        return {
+                            type: "terminal",
+                            terminalId: typeof content.terminalId === "string"
+                                ? content.terminalId
+                                : "",
+                        };
+                    return { type: "text", text: "" };
+                }),
+                startedAt: Date.now(),
+            };
+            const sessionUpdate = {
+                type: "tool_call",
+                sessionId,
+                status: "active",
+                toolCall: toolCall,
+                messageId,
+            };
+            this.notifySessionUpdate(sessionUpdate);
+        }
+        else if (update?.sessionUpdate === "tool_call_update") {
+            // Extract messageId from _meta
+            const messageId = update._meta &&
+                typeof update._meta === "object" &&
+                "messageId" in update._meta
+                ? String(update._meta.messageId)
+                : undefined;
+            // Tool call update notification
+            const toolCallUpdate = {
+                id: update.toolCallId ?? "",
+                status: update.status,
+                locations: update.locations,
+                rawOutput: update.rawOutput,
+                tokenUsage: update.tokenUsage,
+                content: update.content?.map((c) => {
+                    // Type guard to safely check properties
+                    if (typeof c !== "object" || c === null) {
+                        return { type: "text", text: "" };
+                    }
+                    const content = c;
+                    // Handle ACP nested content format
+                    if (content.type === "content" &&
+                        typeof content.content === "object" &&
+                        content.content !== null) {
+                        const innerContent = content.content;
+                        if (innerContent.type === "text") {
+                            return {
+                                type: "content",
+                                content: {
+                                    type: "text",
+                                    text: typeof innerContent.text === "string"
+                                        ? innerContent.text
+                                        : "",
+                                },
+                            };
+                        }
+                    }
+                    // Handle legacy direct formats
+                    if (content.type === "text")
+                        return {
+                            type: "text",
+                            text: typeof content.text === "string" ? content.text : "",
+                        };
+                    if (content.type === "diff")
+                        return {
+                            type: "diff",
+                            path: typeof content.path === "string" ? content.path : "",
+                            oldText: typeof content.oldText === "string" ? content.oldText : "",
+                            newText: typeof content.newText === "string" ? content.newText : "",
+                            line: typeof content.line === "number" ? content.line : null,
+                        };
+                    if (content.type === "terminal")
+                        return {
+                            type: "terminal",
+                            terminalId: typeof content.terminalId === "string"
+                                ? content.terminalId
+                                : "",
+                        };
+                    return { type: "text", text: "" };
+                }),
+                error: update.error,
+                completedAt: update.status === "completed" || update.status === "failed"
+                    ? Date.now()
+                    : undefined,
+            };
+            const sessionUpdate = {
+                type: "tool_call_update",
+                sessionId,
+                status: "active",
+                toolCallUpdate: toolCallUpdate,
+                messageId,
+            };
+            console.log("[HTTP Transport] Notifying tool_call_update session update:", sessionUpdate);
+            this.notifySessionUpdate(sessionUpdate);
+        }
+        else if (update &&
+            "sessionUpdate" in update &&
+            update.sessionUpdate === "tool_output") {
+            // Tool output notification (sent separately from tool_call_update)
+            // Type guard for tool_output extension
+            const toolOutputUpdate = update;
+            // Extract messageId from _meta
+            const messageId = toolOutputUpdate._meta &&
+                typeof toolOutputUpdate._meta === "object" &&
+                "messageId" in toolOutputUpdate._meta
+                ? String(toolOutputUpdate._meta.messageId)
+                : undefined;
+            const toolOutput = {
+                id: toolOutputUpdate.toolCallId ?? "",
+                rawOutput: toolOutputUpdate.rawOutput,
+                content: toolOutputUpdate.content?.map((c) => {
+                    // Type guard to safely check properties
+                    if (typeof c !== "object" || c === null) {
+                        return { type: "text", text: "" };
+                    }
+                    const content = c;
+                    // Handle ACP nested content format
+                    if (content.type === "content" &&
+                        typeof content.content === "object" &&
+                        content.content !== null) {
+                        const innerContent = content.content;
+                        if (innerContent.type === "text") {
+                            return {
+                                type: "content",
+                                content: {
+                                    type: "text",
+                                    text: typeof innerContent.text === "string"
+                                        ? innerContent.text
+                                        : "",
+                                },
+                            };
+                        }
+                    }
+                    // Handle legacy direct formats
+                    if (content.type === "text")
+                        return {
+                            type: "text",
+                            text: typeof content.text === "string" ? content.text : "",
+                        };
+                    if (content.type === "diff")
+                        return {
+                            type: "diff",
+                            path: typeof content.path === "string" ? content.path : "",
+                            oldText: typeof content.oldText === "string" ? content.oldText : "",
+                            newText: typeof content.newText === "string" ? content.newText : "",
+                            line: typeof content.line === "number" ? content.line : null,
+                        };
+                    if (content.type === "terminal")
+                        return {
+                            type: "terminal",
+                            terminalId: typeof content.terminalId === "string"
+                                ? content.terminalId
+                                : "",
+                        };
+                    return { type: "text", text: "" };
+                }),
+            };
+            // Emit as a tool_call_update so it merges with existing tool call
+            const sessionUpdate = {
+                type: "tool_call_update",
+                sessionId,
+                status: "active",
+                toolCallUpdate: toolOutput,
+                messageId,
+            };
+            console.log("[HTTP Transport] Notifying tool_output as tool_call_update:", sessionUpdate);
+            this.notifySessionUpdate(sessionUpdate);
+        }
+        else if (update?.sessionUpdate === "agent_message_chunk") {
+            // Handle agent message chunks
+            const sessionUpdate = {
+                type: "generic",
+                sessionId,
+                status: "active",
+            };
+            // Queue message chunks if present
+            // For agent_message_chunk, content is an object, not an array
+            const content = update.content;
+            if (content && typeof content === "object") {
+                const contentObj = content;
+                let chunk = null;
+                if (contentObj.type === "text" && typeof contentObj.text === "string") {
+                    chunk = {
+                        id: params.sessionId,
+                        role: "assistant",
+                        contentDelta: { type: "text", text: contentObj.text },
+                        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);
+        }
+        else {
+            // Handle other session updates
+            const sessionUpdate = {
+                type: "generic",
+                sessionId,
+                status: "active",
+            };
+            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);
+            }
+        }
+    }
 }