@agentuity/runtime 0.0.86 → 0.0.88

package/src/services/local/keyvalue.ts

@@ -45,7 +45,13 @@ export class LocalKeyValueStorage implements KeyValueStorage {
 		// Deserialize based on content type
 		let data: T;
 		if (row.content_type === 'application/json') {
-			data = JSON.parse(row.value.toString('utf-8'));
+			try {
+				const text = row.value.toString('utf-8');
+				data = JSON.parse(text);
+			} catch {
+				// If JSON parse fails, return the raw buffer as Uint8Array
+				data = new Uint8Array(row.value) as T;
+			}
 		} else if (row.content_type.startsWith('text/')) {
 			data = row.value.toString('utf-8') as T;
 		} else {

package/src/services/local/vector.ts

@@ -173,9 +173,6 @@ export class LocalVectorStorage implements VectorStorage {
 			throw new Error('Query is required');
 		}
 
-		// Generate query embedding
-		const queryEmbedding = simpleEmbedding(params.query);
-
 		// Fetch all vectors for this name
 		const query = this.#db.query(`
 			SELECT id, key, embedding, metadata 
@@ -190,6 +187,18 @@ export class LocalVectorStorage implements VectorStorage {
 			metadata: string | null;
 		}>;
 
+		// If no vectors exist, return empty results
+		if (rows.length === 0) {
+			return [];
+		}
+
+		// Detect dimensionality from first stored vector
+		const firstEmbedding = JSON.parse(rows[0].embedding);
+		const dimensions = firstEmbedding.length;
+
+		// Generate query embedding with matching dimensions
+		const queryEmbedding = simpleEmbedding(params.query, dimensions);
+
 		// Calculate similarities
 		const results: Array<VectorSearchResult<T> & { similarity: number }> = [];
 

package/src/session.ts

@@ -615,10 +615,15 @@ export class DefaultSession implements Session {
 }
 
 /**
- * WebSocket client for thread state persistence
+ * WebSocket client for thread state persistence.
+ *
+ * **WARNING: This class is exported for testing purposes only and is subject to change
+ * without notice. Do not use this class directly in production code.**
+ *
  * @internal
+ * @experimental
  */
-class ThreadWebSocketClient {
+export class ThreadWebSocketClient {
 	private ws: WebSocket | null = null;
 	private authenticated = false;
 	private pendingRequests = new Map<
@@ -630,6 +635,10 @@ class ThreadWebSocketClient {
 	private apiKey: string;
 	private wsUrl: string;
 	private wsConnecting: Promise<void> | null = null;
+	private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private isDisposed = false;
+	private initialConnectResolve: (() => void) | null = null;
+	private initialConnectReject: ((err: Error) => void) | null = null;
 
 	constructor(apiKey: string, wsUrl: string) {
 		this.apiKey = apiKey;
@@ -638,10 +647,19 @@ class ThreadWebSocketClient {
 
 	async connect(): Promise<void> {
 		return new Promise((resolve, reject) => {
+			// Store the initial connect promise callbacks if this is the first attempt
+			if (this.reconnectAttempts === 0) {
+				this.initialConnectResolve = resolve;
+				this.initialConnectReject = reject;
+			}
+
 			// Set connection timeout
 			const connectionTimeout = setTimeout(() => {
 				this.cleanup();
-				reject(new Error('WebSocket connection timeout (10s)'));
+				const rejectFn = this.initialConnectReject || reject;
+				this.initialConnectResolve = null;
+				this.initialConnectReject = null;
+				rejectFn(new Error('WebSocket connection timeout (10s)'));
 			}, 10_000);
 
 			try {
@@ -662,13 +680,21 @@ class ThreadWebSocketClient {
 							if (message.success) {
 								this.authenticated = true;
 								this.reconnectAttempts = 0;
-								resolve();
+
+								// Resolve both the current promise and the initial connect promise
+								const resolveFn = this.initialConnectResolve || resolve;
+								this.initialConnectResolve = null;
+								this.initialConnectReject = null;
+								resolveFn();
 							} else {
 								const err = new Error(
 									`WebSocket authentication failed: ${message.error || 'Unknown error'}`
 								);
 								this.cleanup();
-								reject(err);
+								const rejectFn = this.initialConnectReject || reject;
+								this.initialConnectResolve = null;
+								this.initialConnectReject = null;
+								rejectFn(err);
 							}
 							return;
 						}
@@ -692,7 +718,13 @@ class ThreadWebSocketClient {
 				this.ws.on('error', (err: Error) => {
 					clearTimeout(connectionTimeout);
 					if (!this.authenticated) {
-						reject(new Error(`WebSocket error: ${err.message}`));
+						// Don't reject immediately if we'll attempt reconnection
+						if (this.reconnectAttempts >= this.maxReconnectAttempts || this.isDisposed) {
+							const rejectFn = this.initialConnectReject || reject;
+							this.initialConnectResolve = null;
+							this.initialConnectReject = null;
+							rejectFn(new Error(`WebSocket error: ${err.message}`));
+						}
 					}
 				});
 
@@ -707,29 +739,59 @@ class ThreadWebSocketClient {
 						this.pendingRequests.delete(id);
 					}
 
-					// Reject connecting promise if still pending
-					if (!wasAuthenticated) {
-						reject(new Error('WebSocket closed before authentication'));
+					// Don't attempt reconnection if disposed
+					if (this.isDisposed) {
+						// Reject initial connect if still pending
+						if (!wasAuthenticated && this.initialConnectReject) {
+							this.initialConnectReject(new Error('WebSocket closed before authentication'));
+							this.initialConnectResolve = null;
+							this.initialConnectReject = null;
+						}
+						return;
 					}
 
-					// Attempt reconnection only if we were previously authenticated
-					if (wasAuthenticated && this.reconnectAttempts < this.maxReconnectAttempts) {
+					// Attempt reconnection if within retry limits (even if auth didn't complete)
+					// This handles server rollouts where connection closes before auth finishes
+					if (this.reconnectAttempts < this.maxReconnectAttempts) {
 						this.reconnectAttempts++;
 						const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30_000);
 
+						internal.info(
+							`WebSocket disconnected, attempting reconnection ${this.reconnectAttempts}/${this.maxReconnectAttempts} in ${delay}ms`
+						);
+
 						// Schedule reconnection with backoff delay
-						setTimeout(() => {
+						this.reconnectTimer = setTimeout(() => {
+							this.reconnectTimer = null;
 							// Create new connection promise for reconnection
 							this.wsConnecting = this.connect().catch(() => {
 								// Reconnection failed, reset
 								this.wsConnecting = null;
 							});
 						}, delay);
+					} else {
+						internal.error(
+							`WebSocket disconnected after ${this.reconnectAttempts} attempts, giving up`
+						);
+
+						// Reject initial connect if still pending (all attempts exhausted)
+						if (!wasAuthenticated && this.initialConnectReject) {
+							this.initialConnectReject(
+								new Error(
+									`WebSocket closed before authentication after ${this.reconnectAttempts} attempts`
+								)
+							);
+							this.initialConnectResolve = null;
+							this.initialConnectReject = null;
+						}
 					}
 				});
 			} catch (err) {
 				clearTimeout(connectionTimeout);
-				reject(err);
+				const rejectFn = this.initialConnectReject || reject;
+				this.initialConnectResolve = null;
+				this.initialConnectReject = null;
+				rejectFn(err as Error);
 			}
 		});
 	}
@@ -846,12 +908,25 @@ class ThreadWebSocketClient {
 	}
 
 	cleanup(): void {
+		// Mark as disposed to prevent new reconnection attempts
+		this.isDisposed = true;
+
+		// Cancel any pending reconnection timer
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+
 		if (this.ws) {
 			this.ws.close();
 			this.ws = null;
 		}
 		this.authenticated = false;
 		this.pendingRequests.clear();
+		this.reconnectAttempts = 0;
+		this.wsConnecting = null;
+		this.initialConnectResolve = null;
+		this.initialConnectReject = null;
 	}
 }