@agentuity/runtime 2.0.11 → 3.0.0-alpha.1

package/src/otel/otel.ts

@@ -1,354 +0,0 @@
-import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import opentelemetry, { type Meter, metrics, propagation, type Tracer } from '@opentelemetry/api';
-import * as LogsAPI from '@opentelemetry/api-logs';
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-import {
-	CompositePropagator,
-	W3CBaggagePropagator,
-	W3CTraceContextPropagator,
-} from '@opentelemetry/core';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
-import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { HostMetrics } from '@opentelemetry/host-metrics';
-import { CompressionAlgorithm } from '@opentelemetry/otlp-exporter-base';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import type { Resource } from '@opentelemetry/resources';
-import {
-	BatchLogRecordProcessor,
-	LoggerProvider,
-	type LogRecordProcessor,
-	SimpleLogRecordProcessor,
-} from '@opentelemetry/sdk-logs';
-import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-import type { Logger } from '../logger';
-import { ConsoleLogRecordExporter, DebugSpanExporter } from './console';
-import { instrumentFetch } from './fetch';
-import { createLogger, patchConsole } from './logger';
-import { getSDKVersion, isAuthenticated } from '../_config';
-import type { LogLevel } from '@agentuity/core';
-import { JSONLLogExporter, JSONLTraceExporter, JSONLMetricExporter } from './exporters';
-
-/**
- * Configuration for OpenTelemetry initialization
- */
-export interface OtelConfig {
-	url?: string;
-	name: string;
-	version: string;
-	bearerToken?: string;
-	orgId?: string;
-	projectId?: string;
-	deploymentId?: string;
-	environment?: string;
-	cliVersion?: string;
-	devmode?: boolean;
-	spanProcessors?: Array<SpanProcessor>;
-	logLevel?: LogLevel;
-	jsonlBasePath?: string;
-}
-
-/**
- * Response from OpenTelemetry initialization
- */
-export interface OtelResponse {
-	tracer: Tracer;
-	meter: Meter;
-	logger: Logger;
-	shutdown: () => Promise<void>;
-}
-
-const devmodeExportInterval = 1_000; // 1 second
-const productionExportInterval = 10_000; // 10 seconds
-
-export const createResource = (config: OtelConfig): Resource => {
-	const { name, version, orgId, projectId, deploymentId, environment, devmode, cliVersion } =
-		config;
-
-	const sdkVersion = getSDKVersion();
-
-	return resourceFromAttributes({
-		[ATTR_SERVICE_NAME]: name,
-		[ATTR_SERVICE_VERSION]: version,
-		'@agentuity/orgId': orgId ?? 'unknown',
-		'@agentuity/projectId': projectId ?? 'unknown',
-		'@agentuity/deploymentId': deploymentId ?? 'unknown',
-		'@agentuity/env': environment,
-		'@agentuity/devmode': devmode,
-		'@agentuity/sdkVersion': sdkVersion ?? 'unknown',
-		'@agentuity/cliVersion': cliVersion ?? 'unknown',
-	});
-};
-
-export const createAgentuityLoggerProvider = ({
-	url,
-	headers,
-	resource,
-	jsonlBasePath,
-	useConsoleExporters,
-}: {
-	url?: string;
-	headers?: Record<string, string>;
-	resource: Resource;
-	logLevel: LogLevel;
-	jsonlBasePath?: string;
-	useConsoleExporters: boolean;
-}) => {
-	let processor: LogRecordProcessor;
-	let exporter: OTLPLogExporter | JSONLLogExporter | undefined;
-
-	if (useConsoleExporters) {
-		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter(true));
-	} else if (jsonlBasePath) {
-		exporter = new JSONLLogExporter(jsonlBasePath);
-		processor = new BatchLogRecordProcessor(exporter);
-	} else if (url) {
-		// Original OTLP export behavior
-		const otlpExporter = new OTLPLogExporter({
-			url: `${url}/v1/logs`,
-			headers,
-			compression: CompressionAlgorithm.GZIP,
-			timeoutMillis: 10_000,
-		});
-		exporter = otlpExporter;
-		processor = new BatchLogRecordProcessor(otlpExporter);
-	} else {
-		processor = new SimpleLogRecordProcessor(new ConsoleLogRecordExporter(false));
-	}
-	const provider = new LoggerProvider({
-		resource,
-		processors: [processor],
-	});
-	LogsAPI.logs.setGlobalLoggerProvider(provider);
-
-	return {
-		processor,
-		provider,
-		exporter,
-	};
-};
-
-export const createUserLoggerProvider = ({
-	url,
-	headers,
-	resource,
-}: {
-	url: string;
-	headers?: Record<string, string>;
-	resource: Resource;
-}) => {
-	const exporter = new OTLPLogExporter({
-		url: `${url}/v1/logs`,
-		headers,
-		compression: CompressionAlgorithm.GZIP,
-		timeoutMillis: 10_000,
-	});
-	const processor = new BatchLogRecordProcessor(exporter);
-	const provider = new LoggerProvider({
-		resource,
-		processors: [processor],
-	});
-	return {
-		provider,
-		exporter,
-		processor,
-	};
-};
-
-import { otel as otelGlobal } from '../_globals';
-
-/**
- * Registers and initializes OpenTelemetry with the specified configuration.
- *
- * Idempotent: if called again (e.g. during bun --hot reload), the previous
- * instance is shut down before creating a new one.
- *
- * @param config - The configuration for OpenTelemetry
- * @returns An object containing the tracer, logger, and shutdown function
- */
-export function registerOtel(config: OtelConfig): OtelResponse {
-	// Shut down previous instance if this is a hot reload
-	const previous = otelGlobal.get();
-	if (previous) {
-		previous.shutdown().catch(() => {});
-	}
-	const {
-		url,
-		name,
-		version,
-		bearerToken,
-		environment = 'development',
-		orgId,
-		projectId,
-		deploymentId,
-		devmode = false,
-		logLevel = 'warn',
-		jsonlBasePath = undefined,
-	} = config;
-
-	let headers: Record<string, string> | undefined;
-
-	if (bearerToken) {
-		headers = {};
-		headers.Authorization = `Bearer ${bearerToken}`;
-	}
-
-	// use console debug exporters for local debugging
-	const useConsoleExporters = process.env.AGENTUITY_DEBUG_OTEL_CONSOLE === 'true';
-
-	const resource = createResource(config);
-	const loggerProvider = createAgentuityLoggerProvider({
-		url,
-		headers,
-		resource,
-		logLevel,
-		jsonlBasePath,
-		useConsoleExporters,
-	});
-	const attrs = {
-		'@agentuity/orgId': orgId ?? 'unknown',
-		'@agentuity/projectId': projectId ?? 'unknown',
-		'@agentuity/deploymentId': deploymentId ?? 'unknown',
-		'@agentuity/env': environment,
-		'@agentuity/devmode': devmode,
-		'@agentuity/language': 'javascript',
-	};
-	const logger = createLogger(!!url, attrs, logLevel);
-
-	// must do this after we have created the logger
-	// don't patch console if we're using console exporters (to avoid double logging)
-	if (!useConsoleExporters) {
-		patchConsole(!!url, attrs, logLevel);
-	}
-
-	// Build trace exporter (OTLP or JSONL)
-	const traceExporter = jsonlBasePath
-		? new JSONLTraceExporter(jsonlBasePath)
-		: url
-			? new OTLPTraceExporter({
-					url: `${url}/v1/traces`,
-					headers,
-					keepAlive: true,
-					compression: CompressionAlgorithm.GZIP,
-				})
-			: undefined;
-
-	// Build metric exporter (OTLP or JSONL)
-	const metricExporter = jsonlBasePath
-		? new JSONLMetricExporter(jsonlBasePath)
-		: url
-			? new OTLPMetricExporter({
-					url: `${url}/v1/metrics`,
-					headers,
-					keepAlive: true,
-					compression: CompressionAlgorithm.GZIP,
-				})
-			: undefined;
-
-	// Create span processors
-	const spanProcessors: SpanProcessor[] = [];
-
-	// Add OTLP/JSONL span processor if we have an exporter
-	if (traceExporter) {
-		spanProcessors.push(new BatchSpanProcessor(traceExporter));
-	}
-
-	// Add debug span processor if console debugging is enabled
-	if (useConsoleExporters) {
-		spanProcessors.push(new SimpleSpanProcessor(new DebugSpanExporter()));
-	}
-
-	// Create a separate metric reader for the NodeSDK
-	const sdkMetricReader = metricExporter
-		? new PeriodicExportingMetricReader({
-				exporter: metricExporter,
-				exportTimeoutMillis: devmode ? devmodeExportInterval : productionExportInterval,
-				exportIntervalMillis: devmode ? devmodeExportInterval : productionExportInterval,
-			})
-		: undefined;
-
-	// Create a separate metric reader for the MeterProvider
-	const hostMetricReader = metricExporter
-		? new PeriodicExportingMetricReader({
-				exporter: metricExporter,
-				exportTimeoutMillis: devmode ? devmodeExportInterval : productionExportInterval,
-				exportIntervalMillis: devmode ? devmodeExportInterval : productionExportInterval,
-			})
-		: undefined;
-
-	const meterProvider = hostMetricReader
-		? new MeterProvider({
-				resource,
-				readers: [hostMetricReader],
-			})
-		: undefined;
-
-	if (meterProvider) {
-		metrics.setGlobalMeterProvider(meterProvider);
-	}
-
-	const hostMetrics = meterProvider ? new HostMetrics({ meterProvider }) : undefined;
-
-	let running = false;
-	let instrumentationSDK: NodeSDK | undefined;
-
-	if (url || useConsoleExporters) {
-		const propagator = new CompositePropagator({
-			propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()],
-		});
-		propagation.setGlobalPropagator(propagator);
-
-		instrumentFetch();
-
-		// Combine custom span processors with our span processors
-		const allSpanProcessors = [...spanProcessors, ...(config.spanProcessors || [])];
-
-		instrumentationSDK = new NodeSDK({
-			logRecordProcessor: loggerProvider.processor,
-			metricReader: sdkMetricReader,
-			instrumentations: [getNodeAutoInstrumentations()],
-			resource,
-			textMapPropagator: propagator,
-			spanProcessors: allSpanProcessors,
-		});
-		instrumentationSDK.start();
-		hostMetrics?.start();
-
-		logger.debug('Telemetry configured successfully');
-		logger.debug('Sending telemetry data to %s', url);
-		running = true;
-	}
-
-	const tracer = opentelemetry.trace.getTracer(name, version);
-	const meter = metrics.getMeter(name, version);
-
-	const shutdown = async () => {
-		if (running) {
-			running = false;
-			logger.debug('shutting down OpenTelemetry');
-			await loggerProvider.provider
-				.forceFlush()
-				.catch((e) => logger.warn('error in forceFlush of otel provider. %s', e));
-			await loggerProvider.exporter
-				?.shutdown()
-				.catch((e) => !devmode && logger.warn('error in shutdown of otel exporter. %s', e));
-			await instrumentationSDK
-				?.shutdown()
-				.catch(
-					(e) => !devmode && logger.warn('error in shutdown of otel instrumentation. %s', e)
-				);
-			logger.debug('shut down OpenTelemetry');
-		}
-	};
-
-	if (url && isAuthenticated()) {
-		logger.info('connected to Agentuity Agent Cloud');
-	}
-
-	const instance: OtelResponse = { tracer, meter, logger, shutdown };
-	otelGlobal.set(instance);
-	return instance;
-}

package/src/otel/tracestate.ts

@@ -1,108 +0,0 @@
-import { trace, TraceFlags, type Context } from '@opentelemetry/api';
-import { TraceState } from '@opentelemetry/core';
-
-/**
- * Entries to set on the W3C tracestate header. Each key-value pair is added
- * to the parent context's existing traceState (if any). Values that are
- * `undefined` or empty strings are skipped.
- */
-export type TraceStateEntries = Record<string, string | undefined>;
-
-/**
- * Build a context whose span context carries an enriched W3C traceState.
- *
- * The returned context is intended to be passed as the **parent context**
- * to `tracer.startActiveSpan(name, opts, enrichedCtx, fn)` or
- * `tracer.startSpan(name, opts, enrichedCtx)`.  Because the OTel SDK
- * copies `traceState` from a *valid* parent span context into every new
- * child span, the recording span that gets exported to OTLP will carry the
- * enriched traceState — making it visible in backends like ClickHouse.
- *
- * ### How it works
- *
- * 1. If the supplied `parentContext` already contains a span with a valid
- *    span context (e.g. from an incoming `traceparent` header), we enrich
- *    that span context's traceState and wrap it in a `NonRecordingSpan`.
- *
- * 2. If there is **no** valid parent span (e.g. no incoming `traceparent`),
- *    we synthesise a minimal remote span context with a freshly generated
- *    traceId.  The OTel SDK will treat this as a valid remote parent,
- *    inherit both the traceId **and** the traceState, and mark the new
- *    span as a continuation of that trace.
- *
- * @param parentContext  The context to enrich (typically `context.active()`).
- * @param entries        Key-value pairs to merge into the traceState.
- * @returns A new `Context` ready to be used as a parent for span creation.
- */
-export function enrichContextWithTraceState(
-	parentContext: Context,
-	entries: TraceStateEntries
-): Context {
-	const parentSpan = trace.getSpan(parentContext);
-	const parentSctx = parentSpan?.spanContext();
-
-	// Start from any existing traceState on the parent, or a fresh one.
-	let traceState = parentSctx?.traceState ?? new TraceState();
-
-	// Merge caller-supplied entries.
-	for (const [key, value] of Object.entries(entries)) {
-		if (value !== undefined && value !== '') {
-			traceState = traceState.set(key, value);
-		}
-	}
-
-	if (parentSctx && trace.isSpanContextValid(parentSctx)) {
-		// The parent already has a valid traceId/spanId (e.g. from an
-		// incoming request with `traceparent`).  We just need to update
-		// its traceState.
-		return trace.setSpan(
-			parentContext,
-			trace.wrapSpanContext({
-				...parentSctx,
-				traceState,
-			})
-		);
-	}
-
-	// No valid parent — synthesise a remote parent so the OTel SDK
-	// considers the span context valid and copies traceState to the child.
-	return trace.setSpan(
-		parentContext,
-		trace.wrapSpanContext({
-			traceId: generateTraceId(),
-			spanId: generateSpanId(),
-			traceFlags: TraceFlags.SAMPLED,
-			isRemote: true,
-			traceState,
-		})
-	);
-}
-
-// ── ID generation helpers ────────────────────────────────────────────
-
-/**
- * Generate a random 32-hex-char trace ID (16 bytes).
- * Uses the Web Crypto API which is available in Bun and Node 20+.
- */
-export function generateTraceId(): string {
-	const bytes = new Uint8Array(16);
-	crypto.getRandomValues(bytes);
-	return hexFromBytes(bytes);
-}
-
-/**
- * Generate a random 16-hex-char span ID (8 bytes).
- */
-export function generateSpanId(): string {
-	const bytes = new Uint8Array(8);
-	crypto.getRandomValues(bytes);
-	return hexFromBytes(bytes);
-}
-
-function hexFromBytes(bytes: Uint8Array): string {
-	let hex = '';
-	for (let i = 0; i < bytes.length; i++) {
-		hex += (bytes[i] as number).toString(16).padStart(2, '0');
-	}
-	return hex;
-}

package/src/router.ts

@@ -1,75 +0,0 @@
-import { Hono, type Env as HonoEnv, type Schema } from 'hono';
-import type { BlankSchema } from 'hono/types';
-import type { Env } from './app';
-
-// Re-export both Env types
-export type { Env };
-export type { HonoEnv };
-
-// Re-export WebSocketConnection from handlers
-export type { WebSocketConnection } from './handlers/websocket';
-
-// Module augmentation to extend Hono types for Agentuity runtime
-declare module 'hono' {
-	// Extend Context with waitUntil for route handlers
-	interface Context {
-		/**
-		 * Schedule a background task that runs after the response is sent.
-		 * Works the same as `ctx.waitUntil()` in agent handlers.
-		 *
-		 * @example
-		 * ```typescript
-		 * router.post('/data', async (c) => {
-		 *   c.waitUntil(async () => {
-		 *     await sendAnalytics(c.req.url);
-		 *   });
-		 *   return c.json({ success: true });
-		 * });
-		 * ```
-		 */
-		waitUntil(callback: Promise<void> | (() => void | Promise<void>)): void;
-	}
-}
-
-/**
- * Creates a Hono router for use with Agentuity.
- *
- * This is a thin wrapper around `new Hono()` that provides the correct
- * Agentuity environment types. Hono's full type inference chain is
- * preserved — the Schema type parameter accumulates route definitions
- * as you chain `.get()`, `.post()`, etc.
- *
- * @template E - Environment type (defaults to Agentuity's Env)
- * @template S - Schema type for route definitions
- *
- * @returns Hono router instance
- *
- * @example
- * ```typescript
- * import { createRouter, websocket, sse, stream, cron } from '@agentuity/runtime';
- *
- * const router = createRouter();
- *
- * // Standard HTTP routes — full type inference
- * router.get('/hello', (c) => c.text('Hello!'));
- * router.post('/data', async (c) => {
- *   const body = await c.req.json();
- *   return c.json({ received: body });
- * });
- *
- * // WebSocket connection
- * router.get('/ws', websocket((c, ws) => {
- *   ws.onMessage((event) => {
- *     ws.send('Echo: ' + event.data);
- *   });
- * }));
- *
- * // Server-Sent Events
- * router.get('/events', sse((c, stream) => {
- *   stream.writeSSE({ data: 'Hello', event: 'message' });
- * }));
- * ```
- */
-export const createRouter = <E extends Env = Env, S extends Schema = BlankSchema>(): Hono<E, S> => {
-	return new Hono<E, S>();
-};

package/src/services/evalrun/composite.ts

@@ -1,34 +0,0 @@
-import {
-	type EvalRunEventProvider,
-	type EvalRunStartEvent,
-	type EvalRunCompleteEvent,
-} from '@agentuity/core';
-
-/**
- * An implementation of the EvalRunEventProvider which wraps multiple providers
- */
-export class CompositeEvalRunEventProvider implements EvalRunEventProvider {
-	private providers: EvalRunEventProvider[];
-
-	constructor(...providers: EvalRunEventProvider[]) {
-		this.providers = providers;
-	}
-
-	/**
-	 * called when the eval run starts
-	 *
-	 * @param event EvalRunStartEvent
-	 */
-	async start(event: EvalRunStartEvent): Promise<void> {
-		await Promise.allSettled(this.providers.map((provider) => provider.start(event)));
-	}
-
-	/**
-	 * called when the eval run completes
-	 *
-	 * @param event EvalRunCompleteEvent
-	 */
-	async complete(event: EvalRunCompleteEvent): Promise<void> {
-		await Promise.allSettled(this.providers.map((provider) => provider.complete(event)));
-	}
-}