@agentuity/runtime 2.0.11 → 3.0.0-alpha.1

package/src/services/session/http.ts

@@ -1,167 +0,0 @@
-import { APIClient, APIResponseSchemaNoData } from '@agentuity/server';
-import {
-	type SessionEventProvider,
-	type SessionStartEvent,
-	SessionStartEventDelayedSchema,
-	SessionCompleteEventDelayedSchema,
-	type SessionCompleteEvent,
-	type Logger,
-	StructuredError,
-} from '@agentuity/core';
-import { context, trace, SpanStatusCode } from '@opentelemetry/api';
-import { internal } from '../../logger/internal';
-
-const SessionResponseError = StructuredError('SessionResponseError');
-
-/**
- * An implementation of the SessionEventProvider which uses HTTP for delivery.
- *
- * This provider checks that the event has required fields (orgId, projectId for start events)
- * before sending to the backend. If required fields are missing, the event is silently skipped.
- */
-export class HTTPSessionEventProvider implements SessionEventProvider {
-	private apiClient: APIClient;
-	private logger: Logger;
-
-	constructor(client: APIClient, logger: Logger) {
-		this.apiClient = client;
-		this.logger = logger;
-	}
-
-	/**
-	 * Check if a start event has all required fields for HTTP delivery
-	 */
-	private canSendStartEvent(event: SessionStartEvent): boolean {
-		// orgId and projectId are required for the backend
-		if (!event.orgId || !event.projectId) {
-			internal.info(
-				'[session-http] skipping start event - missing required fields: orgId=%s, projectId=%s',
-				event.orgId ?? 'missing',
-				event.projectId ?? 'missing'
-			);
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * called when the session starts
-	 *
-	 * @param event SessionStartEvent
-	 */
-	async start(event: SessionStartEvent): Promise<void> {
-		// Check required fields before sending
-		if (!this.canSendStartEvent(event)) {
-			return;
-		}
-
-		const tracer = trace.getTracer('session');
-		const currentContext = context.active();
-		const span = tracer.startSpan('Session Start', {}, currentContext);
-
-		try {
-			internal.info('[session-http] sending start event: %s', event.id);
-			this.logger.debug('Sending session start event: %s', event.id);
-
-			const spanContext = trace.setSpan(currentContext, span);
-			const resp = await context.with(spanContext, () =>
-				this.apiClient.post(
-					'/session',
-					{ ...event, timestamp: Date.now() },
-					APIResponseSchemaNoData(),
-					SessionStartEventDelayedSchema
-				)
-			);
-
-			if (resp.success) {
-				internal.info('[session-http] start event sent successfully: %s', event.id);
-				this.logger.debug('Session start event sent successfully: %s', event.id);
-				this.startedSessions.add(event.id);
-				span.setStatus({ code: SpanStatusCode.OK });
-				return;
-			}
-			internal.info('[session-http] start event failed: %s - %s', event.id, resp.message);
-			span.setStatus({ code: SpanStatusCode.ERROR, message: resp.message });
-			throw new SessionResponseError({ message: resp.message });
-		} catch (error) {
-			span.recordException(error as Error);
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: error instanceof Error ? error.message : String(error),
-			});
-			throw error;
-		} finally {
-			span.end();
-		}
-	}
-
-	/**
-	 * Track session IDs that have been started (to know if we should send complete)
-	 */
-	private startedSessions = new Set<string>();
-
-	/**
-	 * called when the session completes
-	 *
-	 * @param event SessionCompleteEvent
-	 */
-	async complete(event: SessionCompleteEvent): Promise<void> {
-		// Always create the "Session End" span for telemetry purposes.
-		// This span is used by Catalyst to detect when a session has completed,
-		// so it must always be emitted even if we don't send the HTTP event.
-		const tracer = trace.getTracer('session');
-		const currentContext = context.active();
-		const span = tracer.startSpan('Session End', {}, currentContext);
-
-		try {
-			// Only send HTTP complete event if we successfully sent a start event.
-			// This prevents sending orphaned complete events when start was skipped.
-			// However, we still create the span above for telemetry.
-			if (!this.startedSessions.has(event.id)) {
-				internal.info(
-					'[session-http] skipping HTTP complete event (no matching start), but emitting Session End span: %s',
-					event.id
-				);
-				span.setStatus({ code: SpanStatusCode.OK });
-				return;
-			}
-
-			internal.info(
-				'[session-http] sending complete event: %s, userData: %s',
-				event.id,
-				event.userData ? `${event.userData.length} bytes` : 'none'
-			);
-			this.logger.debug('Sending session complete event: %s', event.id);
-
-			const spanContext = trace.setSpan(currentContext, span);
-			const resp = await context.with(spanContext, () =>
-				this.apiClient.put(
-					'/session',
-					{ ...event, timestamp: Date.now() },
-					APIResponseSchemaNoData(),
-					SessionCompleteEventDelayedSchema
-				)
-			);
-
-			if (resp.success) {
-				this.startedSessions.delete(event.id);
-				internal.info('[session-http] complete event sent successfully: %s', event.id);
-				this.logger.debug('Session complete event sent successfully: %s', event.id);
-				span.setStatus({ code: SpanStatusCode.OK });
-				return;
-			}
-			internal.info('[session-http] complete event failed: %s - %s', event.id, resp.message);
-			span.setStatus({ code: SpanStatusCode.ERROR, message: resp.message });
-			throw new SessionResponseError({ message: resp.message });
-		} catch (error) {
-			span.recordException(error as Error);
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: error instanceof Error ? error.message : String(error),
-			});
-			throw error;
-		} finally {
-			span.end();
-		}
-	}
-}

package/src/services/session/index.ts

@@ -1,4 +0,0 @@
-export * from './composite';
-export * from './http';
-export * from './json';
-export * from './local';

package/src/services/session/json.ts

@@ -1,42 +0,0 @@
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import {
-	type SessionEventProvider,
-	type SessionStartEvent,
-	type SessionCompleteEvent,
-} from '@agentuity/core';
-
-/**
- * An implementation of the SessionEventProvider which uses JSON logs for delivery
- */
-export class JSONSessionEventProvider implements SessionEventProvider {
-	private directory: string;
-
-	constructor(directory: string) {
-		this.directory = directory;
-	}
-	private makeFilename(type: 'start' | 'complete'): string {
-		return join(this.directory, `session-${type}.${Date.now()}${randomUUID()}.json`);
-	}
-	/**
-	 * called when the session starts
-	 *
-	 * @param event SessionStartEvent
-	 */
-	async start(event: SessionStartEvent): Promise<void> {
-		const filename = this.makeFilename('start');
-		const payload = JSON.stringify({ ...event, timestamp: new Date() }) + '\n';
-		await Bun.file(filename).write(payload);
-	}
-
-	/**
-	 * called when the session completes
-	 *
-	 * @param event SessionCompleteEvent
-	 */
-	async complete(event: SessionCompleteEvent): Promise<void> {
-		const filename = this.makeFilename('complete');
-		const payload = JSON.stringify({ ...event, timestamp: new Date() }) + '\n';
-		await Bun.file(filename).write(payload);
-	}
-}

package/src/services/session/local.ts

@@ -1,33 +0,0 @@
-import {
-	type SessionEventProvider,
-	type SessionStartEvent,
-	type SessionCompleteEvent,
-} from '@agentuity/core';
-import { internal } from '../../logger/internal';
-
-/**
- * An implementation of the SessionEventProvider which is no-op
- */
-export class LocalSessionEventProvider implements SessionEventProvider {
-	/**
-	 * called when the session starts
-	 *
-	 * @param event SessionStartEvent
-	 */
-	async start(event: SessionStartEvent): Promise<void> {
-		internal.info('[session-local] start event (no-op): %s', event.id);
-	}
-
-	/**
-	 * called when the session completes
-	 *
-	 * @param event SessionCompleteEvent
-	 */
-	async complete(event: SessionCompleteEvent): Promise<void> {
-		internal.info(
-			'[session-local] complete event (no-op): %s, userData: %s',
-			event.id,
-			event.userData ? `${event.userData.length} bytes` : 'none'
-		);
-	}
-}

package/src/services/thread/local.ts

@@ -1,199 +0,0 @@
-import type { Context } from 'hono';
-import type { Database } from 'bun:sqlite';
-import type { AppState } from '../../index';
-import type { Env } from '../../app';
-import {
-	DefaultThread,
-	DefaultThreadIDProvider,
-	parseThreadData,
-	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);
-
-		// 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
-				}
-			}
-
-			return { state, metadata: metadata || {} };
-		};
-
-		return new DefaultThread(this, threadId, restoreFn);
-	}
-
-	async save(thread: Thread): Promise<void> {
-		if (!this.db || !(thread instanceof DefaultThread)) {
-			return;
-		}
-
-		const saveMode = thread.getSaveMode();
-		if (saveMode === 'none') {
-			return;
-		}
-
-		const now = Date.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> {
-		if (!this.db) {
-			return;
-		}
-
-		// Delete thread from DB
-		this.db.run('DELETE FROM threads WHERE id = ?', [thread.id]);
-	}
-}