@agentuity/runtime 2.0.11 → 3.0.0-alpha.1

package/src/_tokens.ts

@@ -1,114 +0,0 @@
-import type { Context, AttributeValue } from '@opentelemetry/api';
-import type { Span } from '@opentelemetry/sdk-trace-base';
-import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { inAgentContext, inHTTPContext, getHTTPContext } from './_context';
-import {
-	ATTR_GEN_AI_SYSTEM,
-	ATTR_GEN_AI_RESPONSE_MODEL,
-	ATTR_GEN_AI_USAGE_INPUT_TOKENS,
-	ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
-} from '@opentelemetry/semantic-conventions/incubating';
-
-export const TOKENS_HEADER = 'x-agentuity-tokens';
-export const DURATION_HEADER = 'x-agentuity-duration';
-
-// AI SDK span names: ai.generateText, ai.streamText, ai.generateObject, ai.streamObject, ai.embed, ai.embedMany
-const AI_SDK_SPAN_PREFIX = 'ai.';
-const AI_SDK_MODEL_NAME = 'ai.model.id';
-const AI_SDK_USAGE_PROMPT_TOKENS = 'ai.usage.promptTokens';
-const AI_SDK_USAGE_COMPLETION_TOKENS = 'ai.usage.completionTokens';
-
-const parseTokenHeader = (val: string | undefined): Map<string, number> => {
-	const kv = new Map<string, number>();
-	if (val) {
-		// format is: [model]:[count] [model:count]
-		const tok = val.split(' ');
-		for (const entry of tok) {
-			const [name, count] = entry.split(':');
-			if (name) {
-				kv.set(name, parseInt(count ?? '0', 10) ?? 0);
-			}
-		}
-	}
-	return kv;
-};
-
-const serializeTokenHeader = (kv: Map<string, number>): string => {
-	const lines: string[] = [];
-	for (const [k, v] of kv) {
-		lines.push(`${k}:${v}`);
-	}
-	return lines.join(' ');
-};
-
-const getTokenValue = (val: AttributeValue | undefined): number => {
-	if (val) {
-		const v = val.valueOf();
-		switch (typeof v) {
-			case 'number':
-				return v;
-			case 'string':
-				return parseInt(v, 10);
-			default:
-		}
-	}
-	return 0;
-};
-
-export class TokenSpanProcessor implements SpanProcessor {
-	onStart(_span: Span, _context: Context) {
-		return;
-	}
-
-	onEnd(span: Span) {
-		if (inAgentContext() && inHTTPContext()) {
-			const ctx = getHTTPContext();
-			const tokenLine = ctx.res.headers.get(TOKENS_HEADER) ?? undefined;
-			const tokens = parseTokenHeader(tokenLine);
-			let mutated = false;
-			// AI SDK uses ai.* span names but doesn't use the semantic attribute names
-			if (span.name.startsWith(AI_SDK_SPAN_PREFIX) && AI_SDK_MODEL_NAME in span.attributes) {
-				const model = span.attributes[AI_SDK_MODEL_NAME]!.toString();
-				let totalTokens = tokens.get(model) ?? 0;
-				if (AI_SDK_USAGE_PROMPT_TOKENS in span.attributes) {
-					totalTokens += getTokenValue(span.attributes[AI_SDK_USAGE_PROMPT_TOKENS]);
-				}
-				if (AI_SDK_USAGE_COMPLETION_TOKENS in span.attributes) {
-					totalTokens += getTokenValue(span.attributes[AI_SDK_USAGE_COMPLETION_TOKENS]);
-				}
-				if (totalTokens > 0) {
-					tokens.set(model, totalTokens);
-					mutated = true;
-				}
-			} else if (
-				ATTR_GEN_AI_SYSTEM in span.attributes &&
-				ATTR_GEN_AI_RESPONSE_MODEL in span.attributes
-			) {
-				// OpenTelemetry GenAI semantic conventions (used by build-time LLM instrumentation)
-				const model = span.attributes[ATTR_GEN_AI_RESPONSE_MODEL]!.toString();
-				let totalTokens = tokens.get(model) ?? 0;
-				if (ATTR_GEN_AI_USAGE_INPUT_TOKENS in span.attributes) {
-					totalTokens += getTokenValue(span.attributes[ATTR_GEN_AI_USAGE_INPUT_TOKENS]);
-				}
-				if (ATTR_GEN_AI_USAGE_OUTPUT_TOKENS in span.attributes) {
-					totalTokens += getTokenValue(span.attributes[ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]);
-				}
-				if (totalTokens > 0) {
-					tokens.set(model, totalTokens);
-					mutated = true;
-				}
-			}
-			if (mutated) {
-				ctx.header(TOKENS_HEADER, serializeTokenHeader(tokens));
-			}
-		}
-	}
-
-	forceFlush() {
-		return Promise.resolve();
-	}
-
-	shutdown() {
-		return Promise.resolve();
-	}
-}

package/src/_util.ts

@@ -1,62 +0,0 @@
-import type { Context } from 'hono';
-
-export function returnResponse(ctx: Context, result: unknown) {
-	if (result instanceof ReadableStream) return ctx.body(result);
-	if (result instanceof Response) return result;
-	if (typeof result === 'string') return ctx.text(result);
-	if (typeof result === 'number' || typeof result === 'boolean') return ctx.text(String(result));
-	return ctx.json(result);
-}
-
-/**
- * SHA256 hash of the given values
- *
- * @param val one or more strings to hash
- * @returns hash string in hex format
- */
-export function hash(...val: string[]): string {
-	const hasher = new Bun.CryptoHasher('sha256');
-	val.map((val) => hasher.update(val));
-	return hasher.digest().toHex();
-}
-
-/**
- * Safely stringify an object to JSON, handling circular references
- * @param obj - The object to stringify
- * @returns JSON string representation
- */
-export function safeStringify(obj: unknown): string {
-	const stack: unknown[] = [];
-
-	function replacer(_key: string, value: unknown): unknown {
-		if (typeof value === 'bigint') {
-			return value.toString();
-		}
-
-		if (typeof value === 'object' && value !== null) {
-			// Check if this object is already in our ancestor chain
-			if (stack.includes(value)) {
-				return '[Circular]';
-			}
-
-			// Add to stack before processing
-			stack.push(value);
-
-			// Process the object
-			const result = Array.isArray(value) ? [] : {};
-
-			for (const [k, v] of Object.entries(value)) {
-				(result as Record<string, unknown>)[k] = replacer(k, v);
-			}
-
-			// Remove from stack after processing
-			stack.pop();
-
-			return result;
-		}
-
-		return value;
-	}
-
-	return JSON.stringify(replacer('', obj));
-}

package/src/_validation.ts

@@ -1,119 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { StandardSchemaV1, InferInput, InferOutput } from '@agentuity/core';
-
-/**
- * Schema definition for routes that can have input (POST, PUT, PATCH, DELETE).
- * Both input and output are optional, but output is recommended.
- *
- * @template TInput - Input schema (StandardSchemaV1 or undefined)
- * @template TOutput - Output schema (StandardSchemaV1 or undefined)
- *
- * @example
- * ```typescript
- * const schema: RouteSchema<z.ZodObject<{name: z.ZodString}>, z.ZodString> = {
- *   input: z.object({ name: z.string() }),
- *   output: z.string()
- * };
- * ```
- */
-export type RouteSchema<
-	TInput extends StandardSchemaV1 | undefined = StandardSchemaV1 | undefined,
-	TOutput extends StandardSchemaV1 | undefined = StandardSchemaV1 | undefined,
-> = {
-	input?: TInput;
-	output?: TOutput;
-};
-
-/**
- * Schema definition for GET routes.
- * Input is not allowed (enforced as never), only output validation is supported.
- *
- * @template TOutput - Output schema (StandardSchemaV1 or undefined)
- *
- * @example
- * ```typescript
- * const schema: GetRouteSchema<z.ZodString> = {
- *   output: z.string()
- * };
- * ```
- */
-export type GetRouteSchema<
-	TOutput extends StandardSchemaV1 | undefined = StandardSchemaV1 | undefined,
-> = {
-	input?: never;
-	output?: TOutput;
-};
-
-/**
- * Infer the input type from a StandardSchema.
- * Returns the input type of the schema (before validation/transformation).
- *
- * @template T - Schema type
- */
-export type InferSchemaInput<T> = T extends StandardSchemaV1 ? InferInput<T> : undefined;
-
-/**
- * Infer the output type from a StandardSchema.
- * Returns the output type of the schema (after validation/transformation).
- *
- * @template T - Schema type
- */
-export type InferSchemaOutput<T> = T extends StandardSchemaV1 ? InferOutput<T> : undefined;
-
-/**
- * Extract input schema from RouteSchema or GetRouteSchema.
- *
- * @template T - RouteSchema or GetRouteSchema type
- */
-export type ExtractInputSchema<T> =
-	T extends RouteSchema<infer I, any> ? I : T extends GetRouteSchema<any> ? never : never;
-
-/**
- * Extract output schema from RouteSchema or GetRouteSchema.
- *
- * @template T - RouteSchema or GetRouteSchema type
- */
-export type ExtractOutputSchema<T> =
-	T extends RouteSchema<any, infer O> ? O : T extends GetRouteSchema<infer O> ? O : never;
-
-/**
- * Validation result from StandardSchema validation.
- */
-export type ValidationResult<T> =
-	| { success: true; data: T }
-	| { success: false; issues: StandardSchemaV1.Issue[] };
-
-/**
- * Validates a value against a StandardSchema.
- *
- * @param schema - The StandardSchema to validate against
- * @param value - The value to validate
- * @returns ValidationResult with success/failure and data/issues
- */
-export async function validateSchema<T>(
-	schema: StandardSchemaV1,
-	value: unknown
-): Promise<ValidationResult<T>> {
-	const result = await schema['~standard'].validate(value);
-
-	if ('issues' in result && result.issues) {
-		return { success: false, issues: Array.from(result.issues) };
-	}
-
-	return { success: true, data: result.value as T };
-}
-
-/**
- * Format validation issues into a readable error message.
- *
- * @param issues - Array of validation issues
- * @returns Formatted error message
- */
-export function formatValidationIssues(issues: StandardSchemaV1.Issue[]): string {
-	return issues
-		.map((issue) => {
-			const path = issue.path?.map((p) => (typeof p === 'object' ? p.key : p)).join('.') || '';
-			return path ? `${path}: ${issue.message}` : issue.message;
-		})
-		.join(', ');
-}

package/src/_waituntil.ts

@@ -1,188 +0,0 @@
-import { context, SpanStatusCode, type Tracer, trace } from '@opentelemetry/api';
-import type { Logger } from './logger';
-import { internal } from './logger/internal';
-import { StructuredError } from '@agentuity/core';
-
-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;
-}
-
-const WaitUntilInvalidStateError = StructuredError(
-	'WaitUntilInvalidStateError',
-	'waitUntil cannot be called after waitUntilAll has been called'
-);
-
-const WaitUntilAllInvalidStateError = StructuredError(
-	'WaitUntilAllInvalidStateError',
-	'waitUntilAll can only be called once per instance'
-);
-
-export default class WaitUntilHandler {
-	private promises: Promise<void>[];
-	private tracer: Tracer;
-	private started: number | undefined;
-	private hasCalledWaitUntilAll = false;
-
-	public constructor(tracer: Tracer) {
-		this.tracer = tracer;
-		this.promises = [];
-	}
-
-	public waitUntil(
-		promise: Promise<void> | (() => void | Promise<void>),
-		options?: { noSpan?: boolean }
-	): void {
-		if (this.hasCalledWaitUntilAll) {
-			throw new WaitUntilInvalidStateError();
-		}
-		running++;
-		internal.debug('wait until called, running: %d', running);
-		const currentContext = context.active();
-		const skipSpan = options?.noSpan === true;
-
-		// 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
-			}
-
-			try {
-				if (skipSpan) {
-					// Execute without creating a span (used for coordination tasks)
-					// Still propagate context so downstream async operations inherit the original context
-					try {
-						internal.debug('starting waituntil (no span)');
-						await context.with(currentContext, async () => {
-							const resolvedPromise = typeof promise === 'function' ? promise() : promise;
-							return await Promise.resolve(resolvedPromise);
-						});
-						internal.debug('completed waituntil (no span)');
-					} catch (ex: unknown) {
-						// Log the error but don't re-throw - background tasks should never crash the server
-						internal.error('Background task error: %s', ex);
-					}
-				} else {
-					// Execute with a span (default behavior)
-					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 });
-						// Log the error but don't re-throw - background tasks should never crash the server
-						internal.error('Background task error: %s', ex);
-					} finally {
-						span.end();
-					}
-				}
-			} finally {
-				// Decrement running counter when promise completes (success or failure)
-				running--;
-				internal.debug('waituntil completed, running: %d', running);
-			}
-		})();
-
-		// Store the executing promise for cleanup tracking
-		this.promises.push(executingPromise);
-	}
-
-	public hasPending(): boolean {
-		return this.promises.length > 0;
-	}
-
-	/**
-	 * Returns a snapshot of currently pending promises.
-	 * This allows waiting for specific promises without including promises added later.
-	 * Useful to avoid deadlock when the caller will add their own promise via waitUntil.
-	 */
-	public getPendingSnapshot(): Promise<void>[] {
-		return [...this.promises];
-	}
-
-	/**
-	 * Wait for a specific set of promises to complete.
-	 * Unlike waitUntilAll, this doesn't mark the handler as "all called" and
-	 * allows additional waitUntil calls afterward.
-	 */
-	public async waitForPromises(
-		promises: Promise<void>[],
-		logger: Logger,
-		sessionId: string
-	): Promise<void> {
-		if (promises.length === 0) {
-			internal.debug('No promises to wait for in snapshot');
-			return;
-		}
-
-		internal.debug(
-			`⏳ Waiting for ${promises.length} snapshot promises to complete (session: ${sessionId})...`
-		);
-		try {
-			const results = await Promise.allSettled(promises);
-
-			// Log any failures
-			const failures = results.filter((r) => r.status === 'rejected');
-			if (failures.length > 0) {
-				logger.error('%d background task(s) failed during execution', failures.length);
-			}
-
-			internal.debug('✅ Snapshot promises completed (session: %s)', sessionId);
-		} catch (ex) {
-			logger.error('error waiting for snapshot promises', ex);
-		}
-	}
-
-	public async waitUntilAll(logger: Logger, sessionId: string): Promise<void> {
-		internal.debug(`🔍 waitUntilAll() called for session ${sessionId} (count: %d)`, running);
-
-		if (this.hasCalledWaitUntilAll) {
-			throw new WaitUntilAllInvalidStateError();
-		}
-		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
-			// Use allSettled so one failing promise doesn't stop others
-			const results = await Promise.allSettled(this.promises);
-			const duration = Date.now() - (this.started as number);
-
-			// Log any failures
-			const failures = results.filter((r) => r.status === 'rejected');
-			if (failures.length > 0) {
-				logger.error('%d background task(s) failed during execution', failures.length);
-			}
-
-			internal.debug(
-				'✅ All promises completed, marking session completed (duration %dms)',
-				duration
-			);
-		} catch (ex) {
-			logger.error('error sending session completed', ex);
-		} finally {
-			// Note: running counter is decremented by each promise when it completes,
-			// so we don't decrement here. Just clear the array.
-			this.promises.length = 0;
-		}
-	}
-}