@agentuity/server 0.0.4 → 0.0.6

package/src/_waituntil.ts

@@ -1,246 +0,0 @@
-import { context, SpanStatusCode, type Tracer, trace } from '@opentelemetry/api';
-import type { Logger } from './logger';
-import { internal } from './logger/internal';
-
-let running = 0;
-
-/**
- * returns true if wait until is pending
- * @returns boolean
- */
-export function hasWaitUntilPending(): boolean {
-	internal.debug('hasWaitUntilPending called: %d', running);
-	return running > 0;
-}
-
-export default class WaitUntilHandler {
-	private promises: Promise<void>[];
-	private tracer: Tracer;
-	private started: number | undefined;
-	private hasCalledWaitUntilAll = false;
-	private setHeader: (k: string, v: string) => void;
-
-	public constructor(setHeader: (k: string, v: string) => void, tracer: Tracer) {
-		this.tracer = tracer;
-		this.promises = [];
-		this.setHeader = setHeader;
-		this.hasCalledWaitUntilAll = false;
-	}
-
-	public waitUntil(promise: Promise<void> | (() => void | Promise<void>)): void {
-		if (this.hasCalledWaitUntilAll) {
-			throw new Error('Cannot call waitUntil after waitUntilAll has been called');
-		}
-		this.setHeader('x-agentuity-session-pending', 'true');
-		running++;
-		internal.debug('wait until called, running: %d', running);
-		const currentContext = context.active();
-
-		// Start execution immediately, don't defer it
-		const executingPromise = (async () => {
-			if (this.started === undefined) {
-				this.started = Date.now(); /// this first execution marks the start time
-			}
-			const span = this.tracer.startSpan('waitUntil', {}, currentContext);
-			const spanContext = trace.setSpan(currentContext, span);
-			try {
-				internal.debug('starting waituntil');
-				await context.with(spanContext, async () => {
-					const resolvedPromise = typeof promise === 'function' ? promise() : promise;
-					return await Promise.resolve(resolvedPromise);
-				});
-				internal.debug('completed waituntil');
-				span.setStatus({ code: SpanStatusCode.OK });
-			} catch (ex: unknown) {
-				span.recordException(ex as Error);
-				span.setStatus({ code: SpanStatusCode.ERROR });
-				throw ex;
-			} finally {
-				span.end();
-			}
-			// NOTE: we only decrement when the promise is removed from the array in waitUntilAll
-		})();
-
-		// Store the executing promise for cleanup tracking
-		this.promises.push(executingPromise);
-	}
-
-	public hasPending(): boolean {
-		return this.promises.length > 0;
-	}
-
-	private async markSessionCompleted(sessionId: string, duration: number) {
-		// TODO:
-		internal.debug('markSessionCompleted sessionId: %s, duration: %dms', sessionId, duration);
-	}
-
-	public async waitUntilAll(logger: Logger, sessionId: string): Promise<void> {
-		internal.debug(`🔍 waitUntilAll() called for session ${sessionId} (count: %d)`, running);
-
-		if (this.hasCalledWaitUntilAll) {
-			throw new Error('waitUntilAll can only be called once per instance');
-		}
-		this.hasCalledWaitUntilAll = true;
-
-		if (this.promises.length === 0) {
-			internal.debug('No promises to wait for, executing evals directly');
-			// await this.executeEvalsForSession(logger, sessionId);
-			return;
-		}
-
-		internal.debug(`⏳ Waiting for ${this.promises.length} promises to complete...`);
-		try {
-			// Promises are already executing, just wait for them to complete
-			await Promise.all(this.promises);
-			const duration = Date.now() - (this.started as number);
-			internal.debug('✅ All promises completed, marking session completed');
-			await this.markSessionCompleted(sessionId, duration);
-
-			// // Execute evals after session completion
-			// internal.debug('🚀 Starting eval execution after session completion');
-			// await this.executeEvalsForSession(logger, sessionId);
-		} catch (ex) {
-			logger.error('error sending session completed', ex);
-		} finally {
-			running -= this.promises.length;
-			this.promises.length = 0;
-		}
-	}
-
-	// /**
-	//  * Execute evals for the completed session
-	//  */
-	// private async executeEvalsForSession(
-	// 	logger: Logger,
-	// 	sessionId: string
-	// ): Promise<void> {
-	// 	try {
-	// 		internal.debug(`🔍 Starting eval execution for session ${sessionId}`);
-
-	// 		// Get pending eval jobs for this session
-	// 		internal.debug('🔍 Getting EvalJobScheduler instance...');
-	// 		const evalJobScheduler = await EvalJobScheduler.getInstance();
-	// 		internal.debug('✅ EvalJobScheduler instance obtained');
-
-	// 		internal.debug(`🔍 Querying jobs for session ${sessionId}...`);
-	// 		const jobs = evalJobScheduler.getJobs({ sessionId });
-
-	// 		if (jobs.length === 0) {
-	// 			internal.debug(`📭 No eval jobs found for session ${sessionId}`);
-	// 			return;
-	// 		}
-
-	// 		internal.debug(
-	// 			`📋 Found ${jobs.length} eval jobs for session ${sessionId}`
-	// 		);
-
-	// 		// Load eval metadata map
-	// 		internal.debug('🔧 Loading eval metadata map...');
-	// 		const evalAPI = new EvalAPI();
-	// 		const evalMetadataMap = await evalAPI.loadEvalMetadataMap();
-	// 		internal.debug(`📚 Loaded ${evalMetadataMap.size} eval mappings`);
-
-	// 		// Execute evals for each job
-	// 		let totalEvalsExecuted = 0;
-	// 		for (let i = 0; i < jobs.length; i++) {
-	// 			const job = jobs[i];
-	// 			internal.debug(
-	// 				`🎯 Processing job ${i + 1}/${jobs.length} (spanId: ${job.spanId})`
-	// 			);
-	// 			const evalsInJob = await this.executeEvalsForJob(
-	// 				logger,
-	// 				job,
-	// 				evalAPI,
-	// 				evalMetadataMap
-	// 			);
-	// 			totalEvalsExecuted += evalsInJob;
-	// 			internal.debug(
-	// 				`✅ Completed job ${i + 1}/${jobs.length}: ${evalsInJob} evals executed`
-	// 			);
-	// 		}
-
-	// 		internal.debug(
-	// 			`✅ Completed eval execution for session ${sessionId}: ${totalEvalsExecuted} evals executed`
-	// 		);
-
-	// 		// Clean up completed jobs
-	// 		internal.debug(`🧹 Cleaning up ${jobs.length} completed jobs...`);
-	// 		for (const job of jobs) {
-	// 			evalJobScheduler.removeJob(job.spanId);
-	// 		}
-	// 		internal.debug(`✅ Cleaned up ${jobs.length} completed jobs`);
-	// 	} catch (error) {
-	// 		logger.error('❌ Error executing evals for session:', error);
-	// 	}
-	// }
-
-	// /**
-	//  * Execute evals for a specific job
-	//  */
-	// private async executeEvalsForJob(
-	// 	logger: Logger,
-	// 	job: {
-	// 		spanId: string;
-	// 		sessionId: string;
-	// 		promptMetadata: PromptAttributes[];
-	// 		input?: string;
-	// 		output?: string;
-	// 	},
-	// 	evalAPI: EvalAPI,
-	// 	evalMetadataMap: Map<string, string>
-	// ): Promise<number> {
-	// 	let evalsExecuted = 0;
-
-	// 	internal.debug(
-	// 		`🎯 Processing job ${job.spanId} with ${job.promptMetadata.length} prompt metadata entries`
-	// 	);
-
-	// 	for (const promptMeta of job.promptMetadata || []) {
-	// 		if (!promptMeta.evals || promptMeta.evals.length === 0) {
-	// 			logger.debug('⏭️  Skipping prompt metadata with no evals');
-	// 			continue;
-	// 		}
-
-	// 		internal.debug(
-	// 			`📝 Found ${promptMeta.evals.length} evals for prompt: ${promptMeta.evals.join(', ')}`
-	// 		);
-
-	// 		for (const evalSlug of promptMeta.evals) {
-	// 			try {
-	// 				internal.debug(
-	// 					`🚀 Running eval '${evalSlug}' for session ${job.sessionId}`
-	// 				);
-
-	// 				internal.debug(`🔑 Template hash: ${promptMeta.templateHash}`);
-	// 				internal.debug(`🔑 Compiled hash: ${promptMeta.compiledHash}`);
-
-	// 				const result = await evalAPI.runEval(
-	// 					evalSlug,
-	// 					job.input || '',
-	// 					job.output || '',
-	// 					job.sessionId,
-	// 					job.spanId,
-	// 					promptMeta.templateHash
-	// 				);
-
-	// 				if (result.success) {
-	// 					internal.debug(`✅ Successfully executed eval '${evalSlug}'`);
-	// 					evalsExecuted++;
-	// 				} else {
-	// 					logger.warn(
-	// 						`⚠️  Eval '${evalSlug}' completed but returned error: ${result.message}`
-	// 					);
-	// 				}
-	// 			} catch (error) {
-	// 				logger.error(`❌ Failed to execute eval '${evalSlug}':`, error);
-	// 				// Continue with other evals even if one fails
-	// 			}
-	// 		}
-	// 	}
-
-	// 	internal.debug(
-	// 		`📊 Job ${job.spanId} completed: ${evalsExecuted} evals executed`
-	// 	);
-	// 	return evalsExecuted;
-	// }
-}

package/src/agent.ts

@@ -1,287 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type {
-	StandardSchemaV1,
-	KeyValueStorage,
-	ObjectStorage,
-	StreamStorage,
-	VectorStorage,
-} from '@agentuity/core';
-import { trace, type Tracer } from '@opentelemetry/api';
-
-import type { Context, MiddlewareHandler } from 'hono';
-import { getAgentContext, runInAgentContext, type RequestAgentContextArgs } from './_context';
-import type { Logger } from './logger';
-
-export interface AgentContext {
-	//   email: () => Promise<Email | null>;
-	//   sms: () => Promise<SMS | null>;
-	//   cron: () => Promise<Cron | null>;
-	waitUntil: (promise: Promise<void> | (() => void | Promise<void>)) => void;
-	agent?: any; // Will be augmented by generated code
-	current?: any; // Will be augmented by generated code
-	agentName?: AgentName;
-	logger: Logger;
-	sessionId: string;
-	tracer: Tracer;
-	kv: KeyValueStorage;
-	objectstore: ObjectStorage;
-	stream: StreamStorage;
-	vector: VectorStorage;
-}
-
-interface AgentMetadata {
-	/**
-	 * the unique identifier for this agent and project
-	 */
-	id: string;
-	/**
-	 * the folder name for the agent
-	 */
-	identifier: string;
-	/**
-	 * the human readable name for the agent (identifier is used if not specified)
-	 */
-	name: string;
-	/**
-	 * the human readable description for the agent (empty if not provided)
-	 */
-	description: string;
-	/**
-	 * the relative path to the agent from the root project directory
-	 */
-	filename: string;
-	/**
-	 * a unique version for the agent. computed as the SHA256 contents of the file.
-	 */
-	version: string;
-}
-
-/**
- * The Agent handler interface.
- */
-export type Agent<
-	TInput extends StandardSchemaV1 | undefined = any,
-	TOutput extends StandardSchemaV1 | undefined = any,
-	TStream extends boolean = false,
-> = {
-	metadata: AgentMetadata;
-	handler: (ctx: AgentContext, ...args: any[]) => any | Promise<any>;
-} & (TInput extends StandardSchemaV1 ? { inputSchema: TInput } : { inputSchema?: never }) &
-	(TOutput extends StandardSchemaV1 ? { outputSchema: TOutput } : { outputSchema?: never }) &
-	(TStream extends true ? { stream: true } : { stream?: false });
-
-type InferSchemaInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : never;
-
-type InferStreamOutput<TOutput, TStream extends boolean> = TStream extends true
-	? TOutput extends StandardSchemaV1
-		? ReadableStream<StandardSchemaV1.InferOutput<TOutput>>
-		: ReadableStream<unknown>
-	: TOutput extends StandardSchemaV1
-		? StandardSchemaV1.InferOutput<TOutput>
-		: void;
-
-export interface AgentRunner<
-	TInput extends StandardSchemaV1 | undefined = any,
-	TOutput extends StandardSchemaV1 | undefined = any,
-	TStream extends boolean = false,
-> {
-	metadata: AgentMetadata;
-	run: undefined extends TInput
-		? () => Promise<InferStreamOutput<Exclude<TOutput, undefined>, TStream>>
-		: (
-				input: InferSchemaInput<Exclude<TInput, undefined>>
-			) => Promise<InferStreamOutput<Exclude<TOutput, undefined>, TStream>>;
-}
-
-// Will be populated at runtime with strongly typed agents
-const agents = new Map<string, Agent>();
-
-/**
- * Union type of all registered agent names.
- * Falls back to `string` when no agents are registered (before augmentation).
- * After augmentation, this becomes a strict union of agent names for full type safety.
- */
-export type AgentName = string;
-export type AgentRegistry = Record<AgentName, AgentRunner>;
-
-export const registerAgent = (name: AgentName, agent: Agent): void => {
-	agents.set(name, agent);
-};
-
-export function createAgent<
-	TInput extends StandardSchemaV1 | undefined = undefined,
-	TOutput extends StandardSchemaV1 | undefined = undefined,
-	TStream extends boolean = false,
->(config: {
-	schema?: {
-		input?: TInput;
-		output?: TOutput;
-		stream?: TStream;
-	};
-	metadata?: Partial<Omit<AgentMetadata, 'id'>>;
-	handler: TInput extends StandardSchemaV1
-		? TStream extends true
-			? TOutput extends StandardSchemaV1
-				? (
-						c: AgentContext,
-						input: StandardSchemaV1.InferOutput<TInput>
-					) =>
-						| Promise<ReadableStream<StandardSchemaV1.InferOutput<TOutput>>>
-						| ReadableStream<StandardSchemaV1.InferOutput<TOutput>>
-				: (
-						c: AgentContext,
-						input: StandardSchemaV1.InferOutput<TInput>
-					) => Promise<ReadableStream<unknown>> | ReadableStream<unknown>
-			: TOutput extends StandardSchemaV1
-				? (
-						c: AgentContext,
-						input: StandardSchemaV1.InferOutput<TInput>
-					) =>
-						| Promise<StandardSchemaV1.InferOutput<TOutput>>
-						| StandardSchemaV1.InferOutput<TOutput>
-				: (c: AgentContext, input: StandardSchemaV1.InferOutput<TInput>) => Promise<void> | void
-		: TStream extends true
-			? TOutput extends StandardSchemaV1
-				? (
-						c: AgentContext
-					) =>
-						| Promise<ReadableStream<StandardSchemaV1.InferOutput<TOutput>>>
-						| ReadableStream<StandardSchemaV1.InferOutput<TOutput>>
-				: (c: AgentContext) => Promise<ReadableStream<unknown>> | ReadableStream<unknown>
-			: TOutput extends StandardSchemaV1
-				? (
-						c: AgentContext
-					) =>
-						| Promise<StandardSchemaV1.InferOutput<TOutput>>
-						| StandardSchemaV1.InferOutput<TOutput>
-				: (c: AgentContext) => Promise<void> | void;
-}): Agent<TInput, TOutput, TStream> {
-	const inputSchema = config.schema?.input;
-	const outputSchema = config.schema?.output;
-
-	const handler = async (_ctx: Context, input?: any) => {
-		let validatedInput: any = undefined;
-
-		if (inputSchema) {
-			const inputResult = await inputSchema['~standard'].validate(input);
-			if (inputResult.issues) {
-				throw new Error(
-					`Input validation failed: ${inputResult.issues.map((i: any) => i.message).join(', ')}`
-				);
-			}
-			validatedInput = inputResult.value;
-		}
-
-		const agentCtx = getAgentContext();
-
-		const result = inputSchema
-			? await (config.handler as any)(agentCtx, validatedInput)
-			: await (config.handler as any)(agentCtx);
-
-		if (outputSchema) {
-			const outputResult = await outputSchema['~standard'].validate(result);
-			if (outputResult.issues) {
-				throw new Error(
-					`Output validation failed: ${outputResult.issues.map((i: any) => i.message).join(', ')}`
-				);
-			}
-			return outputResult.value;
-		}
-
-		return result;
-	};
-
-	const agent: any = { handler, metadata: config.metadata };
-
-	if (inputSchema) {
-		agent.inputSchema = inputSchema;
-	}
-
-	if (outputSchema) {
-		agent.outputSchema = outputSchema;
-	}
-
-	if (config.schema?.stream) {
-		agent.stream = config.schema.stream;
-	}
-
-	return agent as Agent<TInput, TOutput, TStream>;
-}
-
-const createAgentRunner = <
-	TInput extends StandardSchemaV1 | undefined = any,
-	TOutput extends StandardSchemaV1 | undefined = any,
-	TStream extends boolean = false,
->(
-	agent: Agent<TInput, TOutput, TStream>,
-	ctx: Context
-): AgentRunner<TInput, TOutput, TStream> => {
-	if (agent.inputSchema) {
-		return {
-			metadata: agent.metadata,
-			run: async (input: any) => {
-				return agent.handler(ctx as unknown as AgentContext, input);
-			},
-		} as AgentRunner<TInput, TOutput, TStream>;
-	} else {
-		return {
-			metadata: agent.metadata,
-			run: async () => {
-				return agent.handler(ctx as unknown as AgentContext);
-			},
-		} as AgentRunner<TInput, TOutput, TStream>;
-	}
-};
-
-export const createAgentMiddleware = (agentName: AgentName): MiddlewareHandler => {
-	return async (ctx, next) => {
-		// Populate agents object with strongly-typed keys
-		const agentsObj: any = {};
-		for (const [name, agentFn] of agents) {
-			agentsObj[name] = createAgentRunner(agentFn, ctx);
-		}
-
-		const args: Partial<RequestAgentContextArgs<AgentRegistry, any>> = {
-			agent: agentsObj,
-			current: agentsObj[agentName],
-			agentName,
-			logger: ctx.var.logger.child({ agent: agentName }),
-			tracer: ctx.var.tracer,
-			setHeader: (k: string, v: string) => ctx.res.headers.set(k, v),
-		};
-
-		const span = trace.getActiveSpan();
-		if (span?.spanContext) {
-			args.sessionId = span.spanContext().traceId;
-		} else {
-			args.sessionId = Bun.randomUUIDv7();
-		}
-
-		return runInAgentContext(
-			ctx as unknown as Record<string, unknown>,
-			args as RequestAgentContextArgs<any, any>,
-			next
-		);
-
-		// FIXME
-		// ctx.email = async (): Promise<Email> => {
-		//     return {
-		//         address: 'test@example.com',
-		//         name: 'Test User',
-		//         html: '<p>Hello, world!</p>',
-		//         text: 'Hello, world!',
-		//     };
-		// };
-		// ctx.sms = async (): Promise<SMS> => {
-		//     return {
-		//         message: 'Hello, world!',
-		//         number: '+1234567890',
-		//     };
-		// };
-		// ctx.cron = async (): Promise<Cron> => {
-		//     return {
-		//         schedule: '0 0 * * *',
-		//     };
-		// };
-	};
-};

package/src/app.ts

@@ -1,31 +0,0 @@
-import { type Env as HonoEnv, Hono } from 'hono';
-import { createServer, getLogger } from './_server';
-import type { Logger } from './logger';
-import { type Meter, type Tracer } from '@opentelemetry/api';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface AppConfig {
-	// currently empty but may be extended in the future
-}
-
-export interface Variables {
-	logger: Logger;
-	meter: Meter;
-	tracer: Tracer;
-}
-
-export interface Env extends HonoEnv {
-	Variables: Variables;
-}
-
-/**
- * create a new app instance
- *
- * @returns App instance
- */
-export function createApp(config?: AppConfig) {
-	const app = new Hono<Env>();
-	const server = createServer(app, config);
-	const logger = getLogger() as Logger;
-	return { app, server, logger };
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './agent';
-export * from './app';
-export * from './router';
-export type { Logger } from './logger';
-export { getApp } from './_server';

package/src/logger/console.ts

@@ -1,111 +0,0 @@
-import { __originalConsole } from '../otel/logger';
-import type { Logger } from './logger';
-import { formatMessage } from './util';
-
-const yellow = '\x1b[33m';
-const green = '\x1b[32m';
-const red = '\x1b[31m';
-const black = '\x1b[1;30m';
-const reset = '\x1b[0m';
-
-/**
- * Console implementation of the Logger interface
- */
-export default class ConsoleLogger implements Logger {
-	private context: Record<string, unknown>;
-	private formatContext: boolean;
-
-	/**
-	 * Creates a new console logger
-	 *
-	 * @param context - Initial context for the logger
-	 */
-	constructor(context: Record<string, unknown> = {}, formatContext = true) {
-		this.context = context;
-		this.formatContext = formatContext;
-	}
-
-	/**
-	 * Log a debug message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	debug(message: unknown, ...args: unknown[]): void {
-		try {
-			const formattedMessage = formatMessage(this.formatContext, this.context, message, args);
-			__originalConsole.debug(`${black}[DEBUG]${reset} ${formattedMessage}`);
-		} catch (err) {
-			// Fallback to direct logging if formatting fails
-			__originalConsole.debug(`${black}[DEBUG]${reset} ${message}`, ...args);
-			__originalConsole.error('Error formatting log message:', err);
-		}
-	}
-
-	/**
-	 * Log an info message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	info(message: unknown, ...args: unknown[]): void {
-		try {
-			const formattedMessage = formatMessage(this.formatContext, this.context, message, args);
-			__originalConsole.info(`${green}[INFO]${reset}  ${formattedMessage}`);
-		} catch (err) {
-			// Fallback to direct logging if formatting fails
-			__originalConsole.info(`${green}[INFO]${reset}  ${message}`, ...args);
-			__originalConsole.error('Error formatting log message:', err);
-		}
-	}
-
-	/**
-	 * Log a warning message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	warn(message: unknown, ...args: unknown[]): void {
-		try {
-			const formattedMessage = formatMessage(this.formatContext, this.context, message, args);
-			__originalConsole.warn(`${yellow}[WARN]${reset}  ${formattedMessage}`);
-		} catch (err) {
-			// Fallback to direct logging if formatting fails
-			__originalConsole.warn(`${yellow}[WARN]${reset}  ${message}`, ...args);
-			__originalConsole.error('Error formatting log message:', err);
-		}
-	}
-
-	/**
-	 * Log an error message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	error(message: unknown, ...args: unknown[]): void {
-		try {
-			const formattedMessage = formatMessage(this.formatContext, this.context, message, args);
-			__originalConsole.error(`${red}[ERROR]${reset} ${formattedMessage}`);
-		} catch (err) {
-			// Fallback to direct logging if formatting fails
-			__originalConsole.error(`${red}[ERROR]${reset} ${message}`, ...args);
-			__originalConsole.error('Error formatting log message:', err);
-		}
-	}
-
-	/**
-	 * Create a child logger with additional context
-	 *
-	 * @param opts - Additional context for the child logger
-	 * @returns A new logger instance with the additional context
-	 */
-	child(opts: Record<string, unknown>): Logger {
-		return new ConsoleLogger(
-			{
-				...this.context,
-				...opts,
-			},
-			this.formatContext
-		);
-	}
-}

package/src/logger/index.ts

@@ -1,3 +0,0 @@
-export { internal } from './internal';
-export * from './logger';
-export { type Logger, logger } from './user';