@agentuity/runtime 0.0.107 → 0.0.109

package/src/bun-s3-patch.ts

@@ -4,8 +4,19 @@
  * Agentuity storage uses virtual-hosted-style URLs (e.g., ag-{id}.t3.storage.dev).
  * Bun's default s3 export uses path-style addressing, causing bucket path mismatch.
  *
- * This module patches Bun.S3Client.prototype.file to automatically set
+ * This module patches Bun.S3Client.prototype methods to automatically set
  * virtualHostedStyle: true when S3_ENDPOINT matches *.storage.dev
+ *
+ * Patched methods:
+ * - file(path, options?) - S3Options
+ * - presign(path, options?) - S3FilePresignOptions
+ * - write(path, data, options?) - S3Options
+ * - delete(path, options?) - S3Options
+ * - exists(path, options?) - S3Options
+ * - stat(path, options?) - S3Options
+ * - size(path, options?) - S3Options
+ * - unlink(path, options?) - S3Options
+ * - list(input?, options?) - options type doesn't include virtualHostedStyle but we inject it anyway
  */
 
 const PATCHED_SYMBOL = Symbol.for('agentuity.s3.patched');
@@ -27,13 +38,23 @@ export function isAgentuityStorageEndpoint(raw: string): boolean {
 	return host === 'storage.dev' || host.endsWith('.storage.dev');
 }
 
+/**
+ * Helper to inject virtualHostedStyle into options if not already set
+ */
+function injectVirtualHostedStyle(options?: Record<string, unknown>): Record<string, unknown> {
+	if (!options || typeof options.virtualHostedStyle === 'undefined') {
+		return { ...options, virtualHostedStyle: true };
+	}
+	return options;
+}
+
 /**
  * Patch Bun's S3Client to automatically use virtualHostedStyle for storage.dev endpoints
  *
  * This function:
  * 1. Checks if we're running in Bun with S3 support
  * 2. Checks if S3_ENDPOINT (or AWS_ENDPOINT) points to *.storage.dev
- * 3. Patches S3Client.prototype.file to inject virtualHostedStyle: true
+ * 3. Patches S3Client.prototype methods to inject virtualHostedStyle: true
  *
  * Safe to call in non-Bun environments (will no-op).
  * Idempotent (safe to call multiple times).
@@ -45,6 +66,21 @@ export function patchBunS3ForStorageDev(): void {
 				S3Client?: {
 					prototype: {
 						file?: (path: string, options?: Record<string, unknown>) => unknown;
+						presign?: (path: string, options?: Record<string, unknown>) => unknown;
+						write?: (
+							path: string,
+							data: unknown,
+							options?: Record<string, unknown>
+						) => unknown;
+						delete?: (path: string, options?: Record<string, unknown>) => unknown;
+						exists?: (path: string, options?: Record<string, unknown>) => unknown;
+						stat?: (path: string, options?: Record<string, unknown>) => unknown;
+						size?: (path: string, options?: Record<string, unknown>) => unknown;
+						unlink?: (path: string, options?: Record<string, unknown>) => unknown;
+						list?: (
+							input?: Record<string, unknown> | null,
+							options?: Record<string, unknown>
+						) => unknown;
 						[PATCHED_SYMBOL]?: boolean;
 					};
 				};
@@ -70,22 +106,114 @@ export function patchBunS3ForStorageDev(): void {
 		return;
 	}
 
+	// Patch file(path, options?)
 	const originalFile = S3ClientProto.file!;
-
 	S3ClientProto.file = function patchedFile(
 		this: unknown,
 		path: string,
 		options?: Record<string, unknown>
 	): unknown {
-		let nextOptions = options;
+		return originalFile.call(this, path, injectVirtualHostedStyle(options));
+	};
+
+	// Patch presign(path, options?)
+	if (S3ClientProto.presign) {
+		const originalPresign = S3ClientProto.presign;
+		S3ClientProto.presign = function patchedPresign(
+			this: unknown,
+			path: string,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalPresign.call(this, path, injectVirtualHostedStyle(options));
+		};
+	}
 
-		// Apply virtualHostedStyle to all S3Client instances when endpoint is storage.dev
-		if (!nextOptions || typeof nextOptions.virtualHostedStyle === 'undefined') {
-			nextOptions = { ...nextOptions, virtualHostedStyle: true };
-		}
+	// Patch write(path, data, options?)
+	if (S3ClientProto.write) {
+		const originalWrite = S3ClientProto.write;
+		S3ClientProto.write = function patchedWrite(
+			this: unknown,
+			path: string,
+			data: unknown,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalWrite.call(this, path, data, injectVirtualHostedStyle(options));
+		};
+	}
 
-		return originalFile.call(this, path, nextOptions);
-	};
+	// Patch delete(path, options?)
+	if (S3ClientProto.delete) {
+		const originalDelete = S3ClientProto.delete;
+		S3ClientProto.delete = function patchedDelete(
+			this: unknown,
+			path: string,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalDelete.call(this, path, injectVirtualHostedStyle(options));
+		};
+	}
+
+	// Patch exists(path, options?)
+	if (S3ClientProto.exists) {
+		const originalExists = S3ClientProto.exists;
+		S3ClientProto.exists = function patchedExists(
+			this: unknown,
+			path: string,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalExists.call(this, path, injectVirtualHostedStyle(options));
+		};
+	}
+
+	// Patch stat(path, options?)
+	if (S3ClientProto.stat) {
+		const originalStat = S3ClientProto.stat;
+		S3ClientProto.stat = function patchedStat(
+			this: unknown,
+			path: string,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalStat.call(this, path, injectVirtualHostedStyle(options));
+		};
+	}
+
+	// Patch size(path, options?)
+	if (S3ClientProto.size) {
+		const originalSize = S3ClientProto.size;
+		S3ClientProto.size = function patchedSize(
+			this: unknown,
+			path: string,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalSize.call(this, path, injectVirtualHostedStyle(options));
+		};
+	}
+
+	// Patch unlink(path, options?)
+	if (S3ClientProto.unlink) {
+		const originalUnlink = S3ClientProto.unlink;
+		S3ClientProto.unlink = function patchedUnlink(
+			this: unknown,
+			path: string,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalUnlink.call(this, path, injectVirtualHostedStyle(options));
+		};
+	}
+
+	// Patch list(input?, options?)
+	// Note: The TypeScript type for list's options doesn't include virtualHostedStyle,
+	// but we inject it anyway as the underlying implementation may still use it
+	if (S3ClientProto.list) {
+		const originalList = S3ClientProto.list;
+		S3ClientProto.list = function patchedList(
+			this: unknown,
+			input?: Record<string, unknown> | null,
+			options?: Record<string, unknown>
+		): unknown {
+			return originalList.call(this, input, injectVirtualHostedStyle(options));
+		};
+	}
 
 	S3ClientProto[PATCHED_SYMBOL] = true;
 }

package/src/index.ts

@@ -100,6 +100,8 @@ export {
 export {
 	type ThreadEventName,
 	type SessionEventName,
+	type ThreadState,
+	type MergeOperation,
 	type Thread,
 	type Session,
 	type ThreadIDProvider,
@@ -108,6 +110,7 @@ export {
 	generateId,
 	DefaultThreadIDProvider,
 	DefaultThread,
+	LazyThreadState,
 } from './session';
 
 // services/thread/local exports
@@ -166,6 +169,9 @@ export {
 	CompositeEvalRunEventProvider,
 } from './services/evalrun';
 
+// for loading metadata
+export { loadBuildMetadata } from './_metadata';
+
 // _services.ts exports
 export { getEvalRunEventProvider, getThreadProvider, getSessionProvider } from './_services';
 

package/src/middleware.ts

@@ -113,6 +113,12 @@ export function createBaseMiddleware(config: MiddlewareConfig) {
 			const endTime = performance.now();
 			const duration = ((endTime - started) / 1000).toFixed(1);
 			c.header(DURATION_HEADER, `${duration}s`);
+
+			// Set deployment header for all routes
+			const deploymentId = runtimeConfig.getDeploymentId();
+			if (deploymentId) {
+				c.header(DEPLOYMENT_HEADER, deploymentId);
+			}
 		}
 
 		if (!skipLogging && !isWebSocket) {
@@ -336,9 +342,10 @@ export function createOtelMiddleware() {
 								const agentIdsSet = (c as any).get('agentIds') as Set<string> | undefined;
 								const agentIds = agentIdsSet ? [...agentIdsSet].filter(Boolean) : undefined;
 								internal.info('[session] agentIds: %o', agentIds);
+								const isEmpty = await thread.empty();
 								await sessionEventProvider.complete({
 									id: sessionId,
-									threadId: thread.empty() ? null : thread.id,
+									threadId: isEmpty ? null : thread.id,
 									statusCode: c.res?.status ?? 200,
 									agentIds: agentIds?.length ? agentIds : undefined,
 									userData,
@@ -357,9 +364,6 @@ export function createOtelMiddleware() {
 						}
 						const traceId = sctx?.traceId || sessionId.replace(/^sess_/, '');
 						c.header(SESSION_HEADER, `sess_${traceId}`);
-						if (deploymentId) {
-							c.header(DEPLOYMENT_HEADER, deploymentId);
-						}
 						span.end();
 					}
 				}

package/src/services/thread/local.ts

@@ -51,30 +51,37 @@ export class LocalThreadProvider implements ThreadProvider {
 		const threadId = await this.threadIDProvider.getThreadId(this.appState, ctx);
 		validateThreadIdOrThrow(threadId);
 
-		// Try to restore state from DB
-		const row = this.db
-			.query<{ state: string }, [string]>('SELECT state FROM threads WHERE id = ?')
-			.get(threadId);
-
-		// Parse the stored data, handling both old (flat) and new ({ state, metadata }) formats
-		const { flatStateJson, metadata } = parseThreadData(row?.state);
-
-		// Create thread with restored state and metadata
-		const thread = new DefaultThread(this, threadId, flatStateJson, metadata);
-
-		// Populate thread state from restored data
-		if (flatStateJson) {
-			try {
-				const data = JSON.parse(flatStateJson);
-				for (const [key, value] of Object.entries(data)) {
-					thread.state.set(key, value);
+		// Create a restore function for lazy loading
+		const restoreFn = async (): Promise<{
+			state: Map<string, unknown>;
+			metadata: Record<string, unknown>;
+		}> => {
+			if (!this.db) {
+				return { state: new Map(), metadata: {} };
+			}
+
+			const row = this.db
+				.query<{ state: string }, [string]>('SELECT state FROM threads WHERE id = ?')
+				.get(threadId);
+
+			const { flatStateJson, metadata } = parseThreadData(row?.state);
+
+			const state = new Map<string, unknown>();
+			if (flatStateJson) {
+				try {
+					const data = JSON.parse(flatStateJson);
+					for (const [key, value] of Object.entries(data)) {
+						state.set(key, value);
+					}
+				} catch {
+					// Continue with empty state if parsing fails
 				}
-			} catch {
-				// Continue with empty state if parsing fails
 			}
-		}
 
-		return thread;
+			return { state, metadata: metadata || {} };
+		};
+
+		return new DefaultThread(this, threadId, restoreFn);
 	}
 
 	async save(thread: Thread): Promise<void> {
@@ -82,20 +89,102 @@ export class LocalThreadProvider implements ThreadProvider {
 			return;
 		}
 
-		// Only save if state was modified
-		if (!thread.isDirty()) {
+		const saveMode = thread.getSaveMode();
+		if (saveMode === 'none') {
 			return;
 		}
 
-		const stateJson = thread.getSerializedState();
 		const now = Date.now();
 
-		// Upsert thread state
-		this.db.run(
-			`INSERT INTO threads (id, state, updated_at) VALUES (?, ?, ?)
-			 ON CONFLICT(id) DO UPDATE SET state = ?, updated_at = ?`,
-			[thread.id, stateJson, now, stateJson, now]
-		);
+		if (saveMode === 'merge') {
+			// For merge, we need to load existing state, apply operations, then save
+			const operations = thread.getPendingOperations();
+			const metadata = thread.getMetadataForSave();
+
+			// Load existing state
+			const row = this.db
+				.query<{ state: string }, [string]>('SELECT state FROM threads WHERE id = ?')
+				.get(thread.id);
+
+			const { flatStateJson, metadata: existingMetadata } = parseThreadData(row?.state);
+
+			const state: Record<string, unknown> = {};
+			if (flatStateJson) {
+				try {
+					Object.assign(state, JSON.parse(flatStateJson));
+				} catch {
+					// Continue with empty state if parsing fails
+				}
+			}
+
+			// Apply operations
+			for (const op of operations) {
+				switch (op.op) {
+					case 'clear':
+						for (const key of Object.keys(state)) {
+							delete state[key];
+						}
+						break;
+					case 'set':
+						if (op.key !== undefined) {
+							state[op.key] = op.value;
+						}
+						break;
+					case 'delete':
+						if (op.key !== undefined) {
+							delete state[op.key];
+						}
+						break;
+					case 'push':
+						if (op.key !== undefined) {
+							const existing = state[op.key];
+							let arr: unknown[];
+							if (Array.isArray(existing)) {
+								existing.push(op.value);
+								arr = existing;
+							} else if (existing === undefined) {
+								arr = [op.value];
+								state[op.key] = arr;
+							} else {
+								// If non-array, silently skip
+								continue;
+							}
+							// Apply maxRecords limit
+							if (op.maxRecords !== undefined && arr.length > op.maxRecords) {
+								state[op.key] = arr.slice(arr.length - op.maxRecords);
+							}
+						}
+						break;
+				}
+			}
+
+			// Build final data
+			const finalMetadata = metadata || existingMetadata || {};
+			const hasState = Object.keys(state).length > 0;
+			const hasMetadata = Object.keys(finalMetadata).length > 0;
+
+			let stateJson = '';
+			if (hasState || hasMetadata) {
+				const data: { state?: Record<string, unknown>; metadata?: Record<string, unknown> } = {};
+				if (hasState) data.state = state;
+				if (hasMetadata) data.metadata = finalMetadata;
+				stateJson = JSON.stringify(data);
+			}
+
+			this.db.run(
+				`INSERT INTO threads (id, state, updated_at) VALUES (?, ?, ?)
+				 ON CONFLICT(id) DO UPDATE SET state = ?, updated_at = ?`,
+				[thread.id, stateJson, now, stateJson, now]
+			);
+		} else {
+			// Full save
+			const stateJson = await thread.getSerializedState();
+			this.db.run(
+				`INSERT INTO threads (id, state, updated_at) VALUES (?, ?, ?)
+				 ON CONFLICT(id) DO UPDATE SET state = ?, updated_at = ?`,
+				[thread.id, stateJson, now, stateJson, now]
+			);
+		}
 	}
 
 	async destroy(thread: Thread): Promise<void> {