@agentuity/runtime 0.0.60 → 0.0.62

package/src/session.ts

@@ -3,6 +3,9 @@
 import type { Context } from 'hono';
 import { getCookie, setCookie } from 'hono/cookie';
 import { type Env, fireEvent } from './app';
+import type { AppState } from './index';
+import { getServiceUrls } from '@agentuity/server';
+import { WebSocket } from 'ws';
 
 export type ThreadEventName = 'destroyed';
 export type SessionEventName = 'completed';
@@ -17,44 +20,342 @@ type SessionEventCallback<T extends Session> = (
 	session: T
 ) => Promise<void> | void;
 
+/**
+ * Represents a conversation thread that persists across multiple sessions.
+ * Threads maintain state and can contain multiple request-response sessions.
+ *
+ * Threads are automatically managed by the runtime and stored in cookies.
+ * They expire after 1 hour of inactivity by default.
+ *
+ * @example
+ * ```typescript
+ * // Access thread in agent handler
+ * const agent = createAgent({
+ *   handler: async (ctx, input) => {
+ *     // Get thread ID
+ *     console.log('Thread:', ctx.thread.id);
+ *
+ *     // Store data in thread state (persists across sessions)
+ *     ctx.thread.state.set('conversationCount',
+ *       (ctx.thread.state.get('conversationCount') as number || 0) + 1
+ *     );
+ *
+ *     // Listen for thread destruction
+ *     ctx.thread.addEventListener('destroyed', (eventName, thread) => {
+ *       console.log('Thread destroyed:', thread.id);
+ *     });
+ *
+ *     return 'Response';
+ *   }
+ * });
+ * ```
+ */
 export interface Thread {
+	/**
+	 * Unique thread identifier (e.g., "thrd_a1b2c3d4...").
+	 * Stored in cookie and persists across requests.
+	 */
 	id: string;
+
+	/**
+	 * Thread-scoped state storage that persists across multiple sessions.
+	 * Use this to maintain conversation history or user preferences.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Store conversation count
+	 * ctx.thread.state.set('messageCount',
+	 *   (ctx.thread.state.get('messageCount') as number || 0) + 1
+	 * );
+	 * ```
+	 */
 	state: Map<string, unknown>;
+
+	/**
+	 * Register an event listener for when the thread is destroyed.
+	 * Thread is destroyed when it expires or is manually destroyed.
+	 *
+	 * @param eventName - Must be 'destroyed'
+	 * @param callback - Function called when thread is destroyed
+	 *
+	 * @example
+	 * ```typescript
+	 * ctx.thread.addEventListener('destroyed', (eventName, thread) => {
+	 *   console.log('Cleaning up thread:', thread.id);
+	 * });
+	 * ```
+	 */
 	addEventListener(
 		eventName: 'destroyed',
 		callback: (eventName: 'destroyed', thread: Thread) => Promise<void> | void
 	): void;
+
+	/**
+	 * Remove a previously registered 'destroyed' event listener.
+	 *
+	 * @param eventName - Must be 'destroyed'
+	 * @param callback - The callback function to remove
+	 */
 	removeEventListener(
 		eventName: 'destroyed',
 		callback: (eventName: 'destroyed', thread: Thread) => Promise<void> | void
 	): void;
+
+	/**
+	 * Manually destroy the thread and clean up resources.
+	 * Fires the 'destroyed' event and removes thread from storage.
+	 *
+	 * @example
+	 * ```typescript
+	 * // End conversation
+	 * await ctx.thread.destroy();
+	 * ```
+	 */
 	destroy(): Promise<void>;
 }
 
+/**
+ * Represents a single request-response session within a thread.
+ * Sessions are scoped to a single agent execution and its sub-agent calls.
+ *
+ * Each HTTP request creates a new session with a unique ID, but shares the same thread.
+ *
+ * @example
+ * ```typescript
+ * const agent = createAgent({
+ *   handler: async (ctx, input) => {
+ *     // Get session ID (unique per request)
+ *     console.log('Session:', ctx.session.id);
+ *
+ *     // Store data in session state (only for this request)
+ *     ctx.session.state.set('startTime', Date.now());
+ *
+ *     // Access parent thread
+ *     console.log('Thread:', ctx.session.thread.id);
+ *
+ *     // Listen for session completion
+ *     ctx.session.addEventListener('completed', (eventName, session) => {
+ *       const duration = Date.now() - (session.state.get('startTime') as number);
+ *       console.log(`Session completed in ${duration}ms`);
+ *     });
+ *
+ *     return 'Response';
+ *   }
+ * });
+ * ```
+ */
 export interface Session {
+	/**
+	 * Unique session identifier for this request.
+	 * Changes with each HTTP request, even within the same thread.
+	 */
 	id: string;
+
+	/**
+	 * The parent thread this session belongs to.
+	 * Multiple sessions can share the same thread.
+	 */
 	thread: Thread;
+
+	/**
+	 * Session-scoped state storage that only exists for this request.
+	 * Use this for temporary data that shouldn't persist across requests.
+	 *
+	 * @example
+	 * ```typescript
+	 * ctx.session.state.set('requestStartTime', Date.now());
+	 * ```
+	 */
 	state: Map<string, unknown>;
+
+	/**
+	 * Register an event listener for when the session completes.
+	 * Fired after the agent handler returns and response is sent.
+	 *
+	 * @param eventName - Must be 'completed'
+	 * @param callback - Function called when session completes
+	 *
+	 * @example
+	 * ```typescript
+	 * ctx.session.addEventListener('completed', (eventName, session) => {
+	 *   console.log('Session finished:', session.id);
+	 * });
+	 * ```
+	 */
 	addEventListener(
 		eventName: 'completed',
 		callback: (eventName: 'completed', session: Session) => Promise<void> | void
 	): void;
+
+	/**
+	 * Remove a previously registered 'completed' event listener.
+	 *
+	 * @param eventName - Must be 'completed'
+	 * @param callback - The callback function to remove
+	 */
 	removeEventListener(
 		eventName: 'completed',
 		callback: (eventName: 'completed', session: Session) => Promise<void> | void
 	): void;
+
+	/**
+	 * Return the session data as a serializable string or return undefined if not
+	 * data should be serialized.
+	 */
+	serializeUserData(): string | undefined;
 }
 
+/**
+ * Provider interface for managing thread lifecycle and persistence.
+ * Implement this to customize how threads are stored and retrieved.
+ *
+ * The default implementation (DefaultThreadProvider) stores threads in-memory
+ * with cookie-based identification and 1-hour expiration.
+ *
+ * @example
+ * ```typescript
+ * class RedisThreadProvider implements ThreadProvider {
+ *   private redis: Redis;
+ *
+ *   async initialize(appState: AppState): Promise<void> {
+ *     this.redis = await connectRedis();
+ *   }
+ *
+ *   async restore(ctx: Context<Env>): Promise<Thread> {
+ *     const threadId = getCookie(ctx, 'atid') || generateId('thrd');
+ *     const data = await this.redis.get(`thread:${threadId}`);
+ *     const thread = new DefaultThread(this, threadId);
+ *     if (data) {
+ *       thread.state = new Map(JSON.parse(data));
+ *     }
+ *     return thread;
+ *   }
+ *
+ *   async save(thread: Thread): Promise<void> {
+ *     await this.redis.setex(
+ *       `thread:${thread.id}`,
+ *       3600,
+ *       JSON.stringify([...thread.state])
+ *     );
+ *   }
+ *
+ *   async destroy(thread: Thread): Promise<void> {
+ *     await this.redis.del(`thread:${thread.id}`);
+ *   }
+ * }
+ *
+ * // Use custom provider
+ * const app = await createApp({
+ *   services: {
+ *     thread: new RedisThreadProvider()
+ *   }
+ * });
+ * ```
+ */
 export interface ThreadProvider {
-	initialize(): Promise<void>;
+	/**
+	 * Initialize the provider when the app starts.
+	 * Use this to set up connections, start cleanup intervals, etc.
+	 *
+	 * @param appState - The app state from createApp setup function
+	 */
+	initialize(appState: AppState): Promise<void>;
+
+	/**
+	 * Restore or create a thread from the HTTP request context.
+	 * Should check cookies for existing thread ID or create a new one.
+	 *
+	 * @param ctx - Hono request context
+	 * @returns The restored or newly created thread
+	 */
 	restore(ctx: Context<Env>): Promise<Thread>;
+
+	/**
+	 * Persist thread state to storage.
+	 * Called periodically to save thread data.
+	 *
+	 * @param thread - The thread to save
+	 */
 	save(thread: Thread): Promise<void>;
+
+	/**
+	 * Destroy a thread and clean up resources.
+	 * Should fire the 'destroyed' event and remove from storage.
+	 *
+	 * @param thread - The thread to destroy
+	 */
 	destroy(thread: Thread): Promise<void>;
 }
 
+/**
+ * Provider interface for managing session lifecycle and persistence.
+ * Implement this to customize how sessions are stored and retrieved.
+ *
+ * The default implementation (DefaultSessionProvider) stores sessions in-memory
+ * and automatically cleans them up after completion.
+ *
+ * @example
+ * ```typescript
+ * class PostgresSessionProvider implements SessionProvider {
+ *   private db: Database;
+ *
+ *   async initialize(appState: AppState): Promise<void> {
+ *     this.db = appState.db;
+ *   }
+ *
+ *   async restore(thread: Thread, sessionId: string): Promise<Session> {
+ *     const row = await this.db.query(
+ *       'SELECT state FROM sessions WHERE id = $1',
+ *       [sessionId]
+ *     );
+ *     const session = new DefaultSession(thread, sessionId);
+ *     if (row) {
+ *       session.state = new Map(JSON.parse(row.state));
+ *     }
+ *     return session;
+ *   }
+ *
+ *   async save(session: Session): Promise<void> {
+ *     await this.db.query(
+ *       'INSERT INTO sessions (id, thread_id, state) VALUES ($1, $2, $3)',
+ *       [session.id, session.thread.id, JSON.stringify([...session.state])]
+ *     );
+ *   }
+ * }
+ *
+ * // Use custom provider
+ * const app = await createApp({
+ *   services: {
+ *     session: new PostgresSessionProvider()
+ *   }
+ * });
+ * ```
+ */
 export interface SessionProvider {
-	initialize(): Promise<void>;
+	/**
+	 * Initialize the provider when the app starts.
+	 * Use this to set up database connections or other resources.
+	 *
+	 * @param appState - The app state from createApp setup function
+	 */
+	initialize(appState: AppState): Promise<void>;
+
+	/**
+	 * Restore or create a session for the given thread and session ID.
+	 * Should load existing session data or create a new session.
+	 *
+	 * @param thread - The parent thread for this session
+	 * @param sessionId - The unique session identifier
+	 * @returns The restored or newly created session
+	 */
 	restore(thread: Thread, sessionId: string): Promise<Session>;
+
+	/**
+	 * Persist session state and fire completion events.
+	 * Called after the agent handler completes.
+	 *
+	 * @param session - The session to save
+	 */
 	save(session: Session): Promise<void>;
 }
 
@@ -103,15 +404,17 @@ export function generateId(prefix?: string): string {
 
 export class DefaultThread implements Thread {
 	#lastUsed: number;
+	#initialStateJson: string | undefined;
 	readonly id: string;
 	readonly state: Map<string, unknown>;
 	private provider: ThreadProvider;
 
-	constructor(provider: ThreadProvider, id: string) {
+	constructor(provider: ThreadProvider, id: string, initialStateJson?: string) {
 		this.provider = provider;
 		this.id = id;
 		this.state = new Map();
 		this.#lastUsed = Date.now();
+		this.#initialStateJson = initialStateJson;
 	}
 
 	addEventListener(eventName: ThreadEventName, callback: ThreadEventCallback<any>): void {
@@ -141,7 +444,7 @@ export class DefaultThread implements Thread {
 	}
 
 	async destroy(): Promise<void> {
-		this.provider.destroy(this);
+		await this.provider.destroy(this);
 	}
 
 	touch() {
@@ -151,6 +454,28 @@ export class DefaultThread implements Thread {
 	expired() {
 		return Date.now() - this.#lastUsed >= 3.6e6; // 1 hour
 	}
+
+	/**
+	 * Check if thread state has been modified since restore
+	 * @internal
+	 */
+	isDirty(): boolean {
+		if (this.state.size === 0 && !this.#initialStateJson) {
+			return false;
+		}
+
+		const currentJson = JSON.stringify(Object.fromEntries(this.state));
+
+		return currentJson !== this.#initialStateJson;
+	}
+
+	/**
+	 * Get serialized state for saving
+	 * @internal
+	 */
+	getSerializedState(): string {
+		return JSON.stringify(Object.fromEntries(this.state));
+	}
 }
 
 export class DefaultSession implements Session {
@@ -189,25 +514,305 @@ export class DefaultSession implements Session {
 	async fireEvent(eventName: SessionEventName): Promise<void> {
 		await fireSessionEvent(this, eventName);
 	}
+
+	/**
+	 * Serialize session state to JSON string for persistence.
+	 * Returns undefined if state is empty or exceeds 1MB limit.
+	 * @internal
+	 */
+	serializeUserData(): string | undefined {
+		if (this.state.size === 0) {
+			return undefined;
+		}
+
+		try {
+			const obj = Object.fromEntries(this.state);
+			const json = JSON.stringify(obj);
+
+			// Check 1MB limit (1,048,576 bytes)
+			const sizeInBytes = new TextEncoder().encode(json).length;
+			if (sizeInBytes > 1048576) {
+				console.error(
+					`Session ${this.id} user_data exceeds 1MB limit (${sizeInBytes} bytes), data will not be persisted`
+				);
+				return undefined;
+			}
+
+			return json;
+		} catch (err) {
+			console.error(`Failed to serialize session ${this.id} user_data:`, err);
+			return undefined;
+		}
+	}
 }
 
-export class DefaultThreadProvider implements ThreadProvider {
-	private threads = new Map<string, DefaultThread>();
-
-	async initialize(): Promise<void> {
-		setInterval(() => {
-			for (const [, thread] of this.threads) {
-				if (thread.expired()) {
-					void (async () => {
-						try {
-							await this.destroy(thread);
-						} catch (err) {
-							console.error('Failed to destroy expired thread', err);
+/**
+ * WebSocket client for thread state persistence
+ * @internal
+ */
+class ThreadWebSocketClient {
+	private ws: WebSocket | null = null;
+	private authenticated = false;
+	private pendingRequests = new Map<
+		string,
+		{ resolve: (data?: string) => void; reject: (err: Error) => void }
+	>();
+	private requestCounter = 0;
+	private reconnectAttempts = 0;
+	private maxReconnectAttempts = 5;
+	private apiKey: string;
+	private wsUrl: string;
+	private wsConnecting: Promise<void> | null = null;
+
+	constructor(apiKey: string, wsUrl: string) {
+		this.apiKey = apiKey;
+		this.wsUrl = wsUrl;
+	}
+
+	async connect(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			// Set connection timeout
+			const connectionTimeout = setTimeout(() => {
+				this.cleanup();
+				reject(new Error('WebSocket connection timeout (10s)'));
+			}, 10000);
+
+			try {
+				this.ws = new WebSocket(this.wsUrl);
+
+				this.ws.on('open', () => {
+					// Send authentication (do NOT clear timeout yet - wait for auth response)
+					this.ws?.send(JSON.stringify({ authorization: this.apiKey }));
+				});
+
+				this.ws.on('message', (data: any) => {
+					try {
+						const message = JSON.parse(data.toString());
+
+						// Handle auth response
+						if ('success' in message && !this.authenticated) {
+							clearTimeout(connectionTimeout);
+							if (message.success) {
+								this.authenticated = true;
+								this.reconnectAttempts = 0;
+								resolve();
+							} else {
+								const err = new Error(
+									`WebSocket authentication failed: ${message.error || 'Unknown error'}`
+								);
+								this.cleanup();
+								reject(err);
+							}
+							return;
 						}
-					})();
-				}
+
+						// Handle action response
+						if ('id' in message && this.pendingRequests.has(message.id)) {
+							const pending = this.pendingRequests.get(message.id)!;
+							this.pendingRequests.delete(message.id);
+
+							if (message.success) {
+								pending.resolve(message.data);
+							} else {
+								pending.reject(new Error(message.error || 'Request failed'));
+							}
+						}
+					} catch {
+						// Ignore parse errors
+					}
+				});
+
+				this.ws.on('error', (err: Error) => {
+					clearTimeout(connectionTimeout);
+					if (!this.authenticated) {
+						reject(new Error(`WebSocket error: ${err.message}`));
+					}
+				});
+
+				this.ws.on('close', () => {
+					clearTimeout(connectionTimeout);
+					const wasAuthenticated = this.authenticated;
+					this.authenticated = false;
+
+					// Reject all pending requests
+					for (const [id, pending] of this.pendingRequests) {
+						pending.reject(new Error('WebSocket connection closed'));
+						this.pendingRequests.delete(id);
+					}
+
+					// Reject connecting promise if still pending
+					if (!wasAuthenticated) {
+						reject(new Error('WebSocket closed before authentication'));
+					}
+
+					// Attempt reconnection only if we were previously authenticated
+					if (wasAuthenticated && this.reconnectAttempts < this.maxReconnectAttempts) {
+						this.reconnectAttempts++;
+						const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+
+						// Schedule reconnection with backoff delay
+						setTimeout(() => {
+							// Create new connection promise for reconnection
+							this.wsConnecting = this.connect().catch(() => {
+								// Reconnection failed, reset
+								this.wsConnecting = null;
+							});
+						}, delay);
+					}
+				});
+			} catch (err) {
+				clearTimeout(connectionTimeout);
+				reject(err);
 			}
-		}, 60_000).unref();
+		});
+	}
+
+	async restore(threadId: string): Promise<string | undefined> {
+		// Wait for connection/reconnection if in progress
+		if (this.wsConnecting) {
+			await this.wsConnecting;
+		}
+
+		if (!this.authenticated || !this.ws) {
+			throw new Error('WebSocket not connected or authenticated');
+		}
+
+		return new Promise((resolve, reject) => {
+			const requestId = `req_${++this.requestCounter}`;
+			this.pendingRequests.set(requestId, { resolve, reject });
+
+			const message = {
+				id: requestId,
+				action: 'restore',
+				data: { thread_id: threadId },
+			};
+
+			this.ws!.send(JSON.stringify(message));
+
+			// Timeout after 10 seconds
+			setTimeout(() => {
+				if (this.pendingRequests.has(requestId)) {
+					this.pendingRequests.delete(requestId);
+					reject(new Error('Request timeout'));
+				}
+			}, 10000);
+		});
+	}
+
+	async save(threadId: string, userData: string): Promise<void> {
+		// Wait for connection/reconnection if in progress
+		if (this.wsConnecting) {
+			await this.wsConnecting;
+		}
+
+		if (!this.authenticated || !this.ws) {
+			throw new Error('WebSocket not connected or authenticated');
+		}
+
+		// Check 1MB limit
+		const sizeInBytes = new TextEncoder().encode(userData).length;
+		if (sizeInBytes > 1048576) {
+			console.error(
+				`Thread ${threadId} user_data exceeds 1MB limit (${sizeInBytes} bytes), data will not be persisted`
+			);
+			return;
+		}
+
+		return new Promise((resolve, reject) => {
+			const requestId = crypto.randomUUID();
+			this.pendingRequests.set(requestId, {
+				resolve: () => resolve(),
+				reject,
+			});
+
+			const message = {
+				id: requestId,
+				action: 'save',
+				data: { thread_id: threadId, user_data: userData },
+			};
+
+			this.ws!.send(JSON.stringify(message));
+
+			// Timeout after 10 seconds
+			setTimeout(() => {
+				if (this.pendingRequests.has(requestId)) {
+					this.pendingRequests.delete(requestId);
+					reject(new Error('Request timeout'));
+				}
+			}, 10_000);
+		});
+	}
+
+	async delete(threadId: string): Promise<void> {
+		// Wait for connection/reconnection if in progress
+		if (this.wsConnecting) {
+			await this.wsConnecting;
+		}
+
+		if (!this.authenticated || !this.ws) {
+			throw new Error('WebSocket not connected or authenticated');
+		}
+
+		return new Promise((resolve, reject) => {
+			const requestId = crypto.randomUUID();
+			this.pendingRequests.set(requestId, {
+				resolve: () => resolve(),
+				reject,
+			});
+
+			const message = {
+				id: requestId,
+				action: 'delete',
+				data: { thread_id: threadId },
+			};
+
+			this.ws!.send(JSON.stringify(message));
+
+			// Timeout after 10 seconds
+			setTimeout(() => {
+				if (this.pendingRequests.has(requestId)) {
+					this.pendingRequests.delete(requestId);
+					reject(new Error('Request timeout'));
+				}
+			}, 10_000);
+		});
+	}
+
+	cleanup(): void {
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		this.authenticated = false;
+		this.pendingRequests.clear();
+	}
+}
+
+export class DefaultThreadProvider implements ThreadProvider {
+	private wsClient: ThreadWebSocketClient | null = null;
+	private wsConnecting: Promise<void> | null = null;
+
+	async initialize(_appState: AppState): Promise<void> {
+		// Initialize WebSocket connection for thread persistence (async, non-blocking)
+		const apiKey = process.env.AGENTUITY_SDK_KEY;
+		if (apiKey) {
+			const serviceUrls = getServiceUrls();
+			const catalystUrl = serviceUrls.catalyst;
+			const wsUrl = new URL('/thread/ws', catalystUrl.replace(/^http/, 'ws'));
+
+			this.wsClient = new ThreadWebSocketClient(apiKey, wsUrl.toString());
+			// Connect in background, don't block initialization
+			this.wsConnecting = this.wsClient
+				.connect()
+				.then(() => {
+					this.wsConnecting = null;
+				})
+				.catch((err) => {
+					console.error('Failed to connect to thread WebSocket:', err);
+					this.wsClient = null;
+					this.wsConnecting = null;
+				});
+		}
 	}
 
 	async restore(ctx: Context<Env>): Promise<Thread> {
@@ -222,14 +827,40 @@ export class DefaultThreadProvider implements ThreadProvider {
 
 		if (threadId) {
 			setCookie(ctx, 'atid', threadId);
-			const existing = this.threads.get(threadId);
-			if (existing) {
-				return existing;
+		}
+
+		// Wait for WebSocket connection if still connecting
+		if (this.wsConnecting) {
+			await this.wsConnecting;
+		}
+
+		// Restore thread state from WebSocket if available
+		let initialStateJson: string | undefined;
+		if (this.wsClient) {
+			try {
+				const restoredData = await this.wsClient.restore(threadId);
+				if (restoredData) {
+					initialStateJson = restoredData;
+				}
+			} catch {
+				// Continue with empty state rather than failing
+			}
+		}
+
+		const thread = new DefaultThread(this, threadId, initialStateJson);
+
+		// Populate thread state from restored data
+		if (initialStateJson) {
+			try {
+				const data = JSON.parse(initialStateJson);
+				for (const [key, value] of Object.entries(data)) {
+					thread.state.set(key, value);
+				}
+			} catch {
+				// Continue with empty state if parsing fails
 			}
 		}
 
-		const thread = new DefaultThread(this, threadId);
-		this.threads.set(thread.id, thread);
 		await fireEvent('thread.created', thread);
 		return thread;
 	}
@@ -237,16 +868,45 @@ export class DefaultThreadProvider implements ThreadProvider {
 	async save(thread: Thread): Promise<void> {
 		if (thread instanceof DefaultThread) {
 			thread.touch();
+
+			// Wait for WebSocket connection if still connecting
+			if (this.wsConnecting) {
+				await this.wsConnecting;
+			}
+
+			// Only save to WebSocket if state has changed
+			if (this.wsClient && thread.isDirty()) {
+				try {
+					const serialized = thread.getSerializedState();
+					await this.wsClient.save(thread.id, serialized);
+				} catch {
+					// Don't throw - allow request to complete even if save fails
+				}
+			}
 		}
 	}
 
 	async destroy(thread: Thread): Promise<void> {
 		if (thread instanceof DefaultThread) {
 			try {
+				// Wait for WebSocket connection if still connecting
+				if (this.wsConnecting) {
+					await this.wsConnecting;
+				}
+
+				// Delete thread from remote storage
+				if (this.wsClient) {
+					try {
+						await this.wsClient.delete(thread.id);
+					} catch (err) {
+						console.error(`Failed to delete thread ${thread.id} from remote storage:`, err);
+						// Continue with local cleanup even if remote delete fails
+					}
+				}
+
 				await thread.fireEvent('destroyed');
 				await fireEvent('thread.destroyed', thread);
 			} finally {
-				this.threads.delete(thread.id);
 				threadEventListeners.delete(thread);
 			}
 		}
@@ -256,7 +916,7 @@ export class DefaultThreadProvider implements ThreadProvider {
 export class DefaultSessionProvider implements SessionProvider {
 	private sessions = new Map<string, DefaultSession>();
 
-	async initialize(): Promise<void> {
+	async initialize(_appState: AppState): Promise<void> {
 		// No initialization needed for in-memory provider
 	}