@agentuity/runtime 0.0.94 → 0.0.96

package/src/middleware.ts

@@ -0,0 +1,252 @@
+/**
+ * Middleware factories for Vite-native architecture
+ * Extracted from _server.ts to be used by generated entry files
+ */
+
+import { createMiddleware } from 'hono/factory';
+import { cors } from 'hono/cors';
+import type { Env } from './app';
+import type { Logger } from './logger';
+import { generateId } from './session';
+import { runInHTTPContext } from './_context';
+import { DURATION_HEADER, TOKENS_HEADER } from './_tokens';
+import { extractTraceContextFromRequest } from './otel/http';
+import {
+	context,
+	SpanKind,
+	SpanStatusCode,
+	trace,
+	propagation,
+	Meter,
+	Tracer,
+} from '@opentelemetry/api';
+import { TraceState } from '@opentelemetry/core';
+import * as runtimeConfig from './_config';
+
+const SESSION_HEADER = 'x-session-id';
+const THREAD_HEADER = 'x-thread-id';
+const DEPLOYMENT_HEADER = 'x-deployment';
+
+export const AGENT_CONTEXT_PROPERTIES = [
+	'logger',
+	'tracer',
+	'sessionId',
+	'kv',
+	'stream',
+	'vector',
+	'state',
+	'thread',
+	'session',
+	'config',
+	'app',
+	'waitUntil',
+] as const;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function installContextPropertyHelpers(c: any): void {
+	for (const property of AGENT_CONTEXT_PROPERTIES) {
+		if (Object.prototype.hasOwnProperty.call(c, property)) {
+			continue;
+		}
+
+		Object.defineProperty(c, property, {
+			get() {
+				throw new Error(
+					`In route handlers, use c.var.${property} instead of c.${property}. ` +
+						`The property '${property}' is available on AgentContext (for agent handlers) ` +
+						`but must be accessed via c.var in HonoContext (route handlers).`
+				);
+			},
+			configurable: true,
+			enumerable: false,
+		});
+	}
+}
+
+export interface MiddlewareConfig {
+	logger: Logger;
+	tracer: Tracer;
+	meter: Meter;
+	corsOptions?: Parameters<typeof cors>[0];
+}
+
+/**
+ * Create base middleware that sets up context variables
+ */
+export function createBaseMiddleware(config: MiddlewareConfig) {
+	return createMiddleware<Env>(async (c, next) => {
+		c.set('logger', config.logger);
+		c.set('tracer', config.tracer);
+		c.set('meter', config.meter);
+
+		// Import services dynamically to avoid circular deps
+		const { getServices } = await import('./_services');
+		const { getAppState } = await import('./app');
+
+		c.set('app', getAppState());
+
+		const services = getServices();
+		c.set('kv', services.kv);
+		c.set('stream', services.stream);
+		c.set('vector', services.vector);
+
+		installContextPropertyHelpers(c);
+
+		const isWebSocket = c.req.header('upgrade')?.toLowerCase() === 'websocket';
+		const skipLogging = c.req.path.startsWith('/_agentuity/');
+		const started = performance.now();
+
+		if (!skipLogging) {
+			config.logger.debug('%s %s started', c.req.method, c.req.path);
+		}
+
+		await runInHTTPContext(c, next);
+
+		if (!isWebSocket) {
+			const endTime = performance.now();
+			const duration = ((endTime - started) / 1000).toFixed(1);
+			c.header(DURATION_HEADER, `${duration}s`);
+		}
+
+		if (!skipLogging && !isWebSocket) {
+			config.logger.debug(
+				'%s %s completed (%d) in %sms',
+				c.req.method,
+				c.req.path,
+				c.res.status,
+				Number(performance.now() - started).toFixed(2)
+			);
+		}
+	});
+}
+
+/**
+ * Create CORS middleware
+ */
+export function createCorsMiddleware(corsOptions?: Parameters<typeof cors>[0]) {
+	return cors({
+		origin: corsOptions?.origin ?? ((origin) => origin),
+		allowHeaders: corsOptions?.allowHeaders ?? [
+			'Content-Type',
+			'Authorization',
+			'Accept',
+			'Origin',
+			'X-Requested-With',
+			THREAD_HEADER,
+		],
+		allowMethods: ['POST', 'GET', 'OPTIONS', 'HEAD', 'PUT', 'DELETE', 'PATCH'],
+		exposeHeaders: [
+			'Content-Length',
+			TOKENS_HEADER,
+			DURATION_HEADER,
+			THREAD_HEADER,
+			SESSION_HEADER,
+			DEPLOYMENT_HEADER,
+		],
+		maxAge: 600,
+		credentials: true,
+		...(corsOptions ?? {}),
+	});
+}
+
+/**
+ * Create OpenTelemetry middleware for session/thread tracking
+ * This is the critical middleware that creates AgentContext
+ */
+export function createOtelMiddleware() {
+	return createMiddleware<Env>(async (c, next) => {
+		// Import providers dynamically to avoid circular deps
+		const { getThreadProvider, getSessionProvider } = await import('./_services');
+		const WaitUntilHandler = (await import('./_waituntil')).default;
+
+		const extractedContext = extractTraceContextFromRequest(c.req.raw);
+		const method = c.req.method;
+		const url = new URL(c.req.url);
+		const threadProvider = getThreadProvider();
+		const sessionProvider = getSessionProvider();
+
+		await context.with(extractedContext, async (): Promise<void> => {
+			const tracer = trace.getTracer('http-server');
+			await tracer.startActiveSpan(
+				`HTTP ${method}`,
+				{
+					kind: SpanKind.SERVER,
+					attributes: {
+						'http.method': method,
+						'http.host': url.host,
+						'http.user_agent': c.req.header('user-agent') || '',
+						'http.path': url.pathname,
+					},
+				},
+				async (span): Promise<void> => {
+					const sctx = span.spanContext();
+					const sessionId = sctx?.traceId ? `sess_${sctx.traceId}` : generateId('sess');
+
+					let traceState = sctx.traceState ?? new TraceState();
+					const projectId = runtimeConfig.getProjectId();
+					const orgId = runtimeConfig.getOrganizationId();
+					const deploymentId = runtimeConfig.getDeploymentId();
+					const isDevMode = runtimeConfig.isDevMode();
+
+					if (projectId) traceState = traceState.set('pid', projectId);
+					if (orgId) traceState = traceState.set('oid', orgId);
+					if (isDevMode) traceState = traceState.set('d', '1');
+
+					// Update the active context with the new trace state
+					// Note: SpanContext.traceState is readonly, so we update it by setting the span with a new context
+					trace.setSpan(
+						context.active(),
+						trace.wrapSpanContext({
+							...sctx,
+							traceState,
+						})
+					);
+
+					const thread = await threadProvider.restore(c);
+					const session = await sessionProvider.restore(thread, sessionId);
+					const handler = new WaitUntilHandler(tracer);
+
+					c.set('sessionId', sessionId);
+					c.set('thread', thread);
+					c.set('session', session);
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					(c as any).set('waitUntilHandler', handler);
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					(c as any).set('agentIds', new Set<string>());
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					(c as any).set('trigger', 'api');
+
+					try {
+						await next();
+
+						// Save session/thread and send events
+						await sessionProvider.save(session);
+						await threadProvider.save(thread);
+						span.setStatus({ code: SpanStatusCode.OK });
+					} catch (ex) {
+						if (ex instanceof Error) {
+							span.recordException(ex);
+						}
+						span.setStatus({
+							code: SpanStatusCode.ERROR,
+							message: (ex as Error).message ?? String(ex),
+						});
+						throw ex;
+					} finally {
+						const headers: Record<string, string> = {};
+						propagation.inject(context.active(), headers);
+						for (const key of Object.keys(headers)) {
+							c.header(key, headers[key]);
+						}
+						const traceId = sctx?.traceId || sessionId.replace(/^sess_/, '');
+						c.header(SESSION_HEADER, `sess_${traceId}`);
+						if (deploymentId) {
+							c.header(DEPLOYMENT_HEADER, deploymentId);
+						}
+						span.end();
+					}
+				}
+			);
+		});
+	});
+}

package/src/router.ts

@@ -9,7 +9,7 @@ import {
 	type Env as HonoEnv,
 } from 'hono';
 import { stream as honoStream, streamSSE as honoStreamSSE } from 'hono/streaming';
-import { upgradeWebSocket as honoUpgradeWebSocket } from 'hono/bun';
+import { upgradeWebSocket } from 'hono/bun';
 import { hash, returnResponse } from './_util';
 import type { Env } from './app';
 import { getAgentAsyncLocalStorage } from './_context';
@@ -487,6 +487,9 @@ export const createRouter = <E extends Env = Env, S extends Schema = Schema>():
 			const asyncLocalStorage = getAgentAsyncLocalStorage();
 			const capturedContext = asyncLocalStorage.getStore();
 
+			// Set Content-Type header for streaming response detection by clients
+			c.header('Content-Type', 'application/octet-stream');
+
 			return honoStream(c, async (s: any) => {
 				const runInContext = async () => {
 					try {
@@ -527,7 +530,8 @@ export const createRouter = <E extends Env = Env, S extends Schema = Schema>():
 			handler = args[1];
 		}
 
-		const wrapper = honoUpgradeWebSocket((c: Context) => {
+		// Use upgradeWebSocket directly from hono/bun
+		const wrapper = upgradeWebSocket((c: Context) => {
 			let openHandler: ((event: any) => void | Promise<void>) | undefined;
 			let messageHandler: ((event: any) => void | Promise<void>) | undefined;
 			let closeHandler: ((event: any) => void | Promise<void>) | undefined;

package/src/services/local/vector.ts

@@ -188,12 +188,13 @@ export class LocalVectorStorage implements VectorStorage {
 		}>;
 
 		// If no vectors exist, return empty results
-		if (rows.length === 0) {
+		const row = rows[0];
+		if (!row) {
 			return [];
 		}
 
 		// Detect dimensionality from first stored vector
-		const firstEmbedding = JSON.parse(rows[0].embedding);
+		const firstEmbedding = JSON.parse(row.embedding);
 		const dimensions = firstEmbedding.length;
 
 		// Generate query embedding with matching dimensions

package/src/services/thread/local.ts

@@ -0,0 +1,106 @@
+import type { Context } from 'hono';
+import type { Database } from 'bun:sqlite';
+import type { AppState } from '../../index';
+import type { Env } from '../../app';
+import {
+	DefaultThread,
+	DefaultThreadIDProvider,
+	validateThreadIdOrThrow,
+	type Thread,
+	type ThreadIDProvider,
+	type ThreadProvider,
+} from '../../session';
+import { getLocalDB } from '../local/_db';
+
+/**
+ * Local thread provider with SQLite persistence.
+ * Stores thread state in local DB for development and testing.
+ * Suitable for local development and testing with persistence across requests.
+ */
+export class LocalThreadProvider implements ThreadProvider {
+	private appState: AppState | null = null;
+	private threadIDProvider: ThreadIDProvider = new DefaultThreadIDProvider();
+	private db: Database | null = null;
+
+	async initialize(appState: AppState): Promise<void> {
+		this.appState = appState;
+		this.db = getLocalDB();
+
+		// Create threads table if it doesn't exist
+		this.db.run(`
+			CREATE TABLE IF NOT EXISTS threads (
+				id TEXT PRIMARY KEY,
+				state TEXT NOT NULL,
+				updated_at INTEGER NOT NULL
+			)
+		`);
+	}
+
+	setThreadIDProvider(provider: ThreadIDProvider): void {
+		this.threadIDProvider = provider;
+	}
+
+	async restore(ctx: Context<Env>): Promise<Thread> {
+		if (this.appState === null || this.db === null) {
+			throw new Error(
+				'LocalThreadProvider.restore called before initialize(): appState/db not set; call initialize(appState) first'
+			);
+		}
+
+		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);
+		const initialStateJson = row?.state;
+
+		// Create thread with restored state
+		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
+			}
+		}
+
+		return thread;
+	}
+
+	async save(thread: Thread): Promise<void> {
+		if (!this.db || !(thread instanceof DefaultThread)) {
+			return;
+		}
+
+		// Only save if state was modified
+		if (!thread.isDirty()) {
+			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]
+		);
+	}
+
+	async destroy(thread: Thread): Promise<void> {
+		if (!this.db) {
+			return;
+		}
+
+		// Delete thread from DB
+		this.db.run('DELETE FROM threads WHERE id = ?', [thread.id]);
+	}
+}