@agentuity/server 0.0.5 → 0.0.6

package/src/logger/internal.ts

@@ -1,165 +0,0 @@
-import { formatMessage } from './util';
-
-const cyan = '\x1b[1;96m';
-const reset = '\x1b[0m';
-
-/**
- * Log levels for internal SDK logging
- */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
-
-/**
- * Internal logger configuration
- */
-interface InternalLoggerConfig {
-	level: LogLevel;
-	context?: Record<string, unknown>;
-}
-
-/**
- * Simple internal logger that doesn't depend on other SDK modules
- * This logger is only for SDK internal diagnostics and debugging
- */
-class InternalLogger {
-	private config: InternalLoggerConfig;
-
-	constructor() {
-		this.config = this.loadConfig();
-	}
-
-	/**
-	 * Load configuration from environment variables
-	 */
-	private loadConfig(): InternalLoggerConfig {
-		const envLevel = process.env.AGENTUITY_SDK_LOG_LEVEL?.toLowerCase();
-
-		// Validate log level
-		const validLevels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'silent'];
-		const level = validLevels.includes(envLevel as LogLevel) ? (envLevel as LogLevel) : 'silent';
-
-		return {
-			level,
-			context: {
-				'@agentuity/source': 'sdk-internal',
-				'@agentuity/timestamp': new Date().toISOString(),
-			},
-		};
-	}
-
-	/**
-	 * Check if a log level should be output based on current configuration
-	 */
-	private shouldLog(level: LogLevel): boolean {
-		if (this.config.level === 'silent') return false;
-
-		const levelPriority = {
-			debug: 0,
-			info: 1,
-			warn: 2,
-			error: 3,
-			silent: 4,
-		};
-
-		return levelPriority[level] >= levelPriority[this.config.level];
-	}
-
-	/**
-	 * Format a log message with context
-	 */
-	private formatMessage(message: unknown, ...args: unknown[]): string {
-		const formattedMessage = formatMessage(false, this.config.context, message, args);
-		return `${cyan}[INTERNAL]${reset} ${formattedMessage}`;
-	}
-
-	/**
-	 * Log a debug message
-	 */
-	debug(message: unknown, ...args: unknown[]): void {
-		if (this.shouldLog('debug')) {
-			console.debug(this.formatMessage(message, ...args));
-		}
-	}
-
-	/**
-	 * Log an info message
-	 */
-	info(message: unknown, ...args: unknown[]): void {
-		if (this.shouldLog('info')) {
-			console.info(this.formatMessage(message, ...args));
-		}
-	}
-
-	/**
-	 * Log a warning message
-	 */
-	warn(message: unknown, ...args: unknown[]): void {
-		if (this.shouldLog('warn')) {
-			console.warn(this.formatMessage(message, ...args));
-		}
-	}
-
-	/**
-	 * Log an error message
-	 */
-	error(message: unknown, ...args: unknown[]): void {
-		if (this.shouldLog('error')) {
-			console.error(this.formatMessage(message, ...args));
-		}
-	}
-
-	/**
-	 * Update configuration at runtime
-	 */
-	updateConfig(config: Partial<InternalLoggerConfig>): void {
-		this.config = { ...this.config, ...config };
-	}
-
-	/**
-	 * Get current configuration
-	 */
-	getConfig(): InternalLoggerConfig {
-		return { ...this.config };
-	}
-
-	/**
-	 * Check if logging is enabled
-	 */
-	isEnabled(): boolean {
-		return this.config.level !== 'silent';
-	}
-
-	/**
-	 * Create a child logger with additional context
-	 */
-	child(context: Record<string, unknown>): InternalLogger {
-		const childLogger = new InternalLogger();
-		childLogger.updateConfig({
-			...this.config,
-			context: {
-				...this.config.context,
-				...context,
-			},
-		});
-		return childLogger;
-	}
-}
-
-// Singleton instance - not exported
-const internalLogger = new InternalLogger();
-
-/**
- * Internal logger for SDK use only
- * This is NOT exported from the main SDK index
- */
-export const internal = {
-	debug: (message: unknown, ...args: unknown[]) => internalLogger.debug(message, ...args),
-	info: (message: unknown, ...args: unknown[]) => internalLogger.info(message, ...args),
-	warn: (message: unknown, ...args: unknown[]) => internalLogger.warn(message, ...args),
-	error: (message: unknown, ...args: unknown[]) => internalLogger.error(message, ...args),
-
-	// Utility methods
-	updateConfig: (config: Partial<InternalLoggerConfig>) => internalLogger.updateConfig(config),
-	getConfig: () => internalLogger.getConfig(),
-	isEnabled: () => internalLogger.isEnabled(),
-	child: (context: Record<string, unknown>) => internalLogger.child(context),
-};

package/src/logger/logger.ts

@@ -1,44 +0,0 @@
-/**
- * Interface for logging functionality
- */
-export interface Logger {
-	/**
-	 * Log a debug message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	debug(message: unknown, ...args: unknown[]): void;
-
-	/**
-	 * Log an info message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	info(message: unknown, ...args: unknown[]): void;
-
-	/**
-	 * Log a warning message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	warn(message: unknown, ...args: unknown[]): void;
-
-	/**
-	 * Log an error message
-	 *
-	 * @param message - The message to log
-	 * @param args - Additional arguments to log
-	 */
-	error(message: unknown, ...args: unknown[]): void;
-
-	/**
-	 * 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;
-}

package/src/logger/user.ts

@@ -1,11 +0,0 @@
-import ConsoleLogger from './console';
-import type { Logger } from './logger';
-
-/**
- * User-facing logger instance
- * This is the logger that SDK consumers should use
- */
-export const logger: Logger = new ConsoleLogger(undefined, false);
-
-// Re-export the Logger type for convenience
-export type { Logger } from './logger';

package/src/logger/util.ts

@@ -1,80 +0,0 @@
-import { formatWithOptions, inspect } from 'node:util';
-import { safeStringify } from '@agentuity/core';
-
-export function buildContextString(context?: Record<string, unknown>): string {
-	if (context) {
-		const contextStr =
-			context && Object.keys(context).length > 0
-				? Object.entries(context)
-						.map(([key, value]) => {
-							try {
-								return `${key}=${typeof value === 'object' ? safeStringify(value) : value}`;
-							} catch {
-								return `${key}=[object Object]`;
-							}
-						})
-						.join(' ')
-				: '';
-
-		return contextStr;
-	}
-	return '';
-}
-
-/**
- * Formats a log message with context
- *
- * @param message - The message to format
- * @param args - Additional arguments for formatting
- * @returns The formatted message with context
- * @private
- */
-export function formatMessage(
-	displayContext: boolean,
-	context: Record<string, unknown> | undefined,
-	message: unknown,
-	args: unknown[]
-): string {
-	// Format the context string
-	const contextStr = displayContext ? buildContextString(context) : null;
-
-	// Format the message based on its type
-	let _message: string;
-	if (typeof message === 'string') {
-		_message = message;
-	} else if (typeof message === 'number' || typeof message === 'boolean') {
-		_message = String(message);
-	} else if (message === null) {
-		_message = 'null';
-	} else if (message === undefined) {
-		_message = 'undefined';
-	} else {
-		// Use inspect for objects for better formatting
-		_message = inspect(message, { depth: null, colors: false });
-	}
-
-	// Format the message with args
-	let formattedMessage: string;
-	try {
-		// Only use format if we have arguments
-		if (args.length > 0) {
-			formattedMessage = formatWithOptions({ depth: null }, _message, ...args);
-		} else {
-			formattedMessage = _message;
-		}
-	} catch {
-		// If formatting fails, use a simple concatenation
-		formattedMessage = `${_message} ${args
-			.map((arg) => {
-				try {
-					return typeof arg === 'object' ? safeStringify(arg) : String(arg);
-				} catch {
-					return '[object Object]';
-				}
-			})
-			.join(' ')}`;
-	}
-
-	// Combine message with context
-	return `${formattedMessage}${contextStr ? ` [${contextStr}]` : ''}`;
-}

package/src/otel/config.ts

@@ -1,81 +0,0 @@
-import { createResource, createUserLoggerProvider, registerOtel } from './otel';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { OtelLogger } from '../otel/logger';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import type { LoggerProvider } from '@opentelemetry/sdk-logs';
-import type { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
-import type { LogRecordProcessor } from '@opentelemetry/sdk-logs';
-import type { OtelResponse, OtelConfig } from './otel';
-import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import * as runtimeConfig from '../_config';
-
-/**
- * Configuration for user provided OpenTelemetry
- */
-export interface CustomizedOtelConfig {
-	endpoint: string;
-	// only supports http/json for now
-	// protocol: 'grpc' | 'http/protobuf' | 'http/json';
-	serviceName: string;
-	resourceAttributes: Record<string, string>;
-	headers: Record<string, string>;
-}
-
-interface OtelRegisterConfig {
-	processors?: SpanProcessor[];
-}
-
-export function register(registerConfig: OtelRegisterConfig): OtelResponse {
-	const url = process.env.AGENTUITY_OTLP_URL ?? 'https://otel.agentuity.cloud';
-	const bearerToken = process.env.AGENTUITY_OTLP_BEARER_TOKEN;
-	const config: OtelConfig = {
-		spanProcessors: registerConfig.processors,
-		name: runtimeConfig.getAppName(),
-		version: runtimeConfig.getAppVersion(),
-		cliVersion: runtimeConfig.getCLIVersion(),
-		devmode: runtimeConfig.isDevMode(),
-		orgId: runtimeConfig.getOrganizationId(),
-		projectId: runtimeConfig.getProjectId(),
-		deploymentId: runtimeConfig.getDeploymentId(),
-		environment: runtimeConfig.getEnvironment(),
-		bearerToken,
-		url,
-	};
-	let userOtelConf: CustomizedOtelConfig | undefined;
-	if (process.env.AGENTUITY_USER_OTEL_CONF) {
-		try {
-			userOtelConf = JSON.parse(process.env.AGENTUITY_USER_OTEL_CONF);
-		} catch (error) {
-			console.warn(
-				`[WARN] Failed to parse AGENTUITY_USER_OTEL_CONF: ${error instanceof Error ? error.message : String(error)}`
-			);
-		}
-	}
-
-	const otel = registerOtel(config);
-	let userLoggerProvider:
-		| {
-				provider: LoggerProvider;
-				exporter: OTLPLogExporter;
-				processor: LogRecordProcessor;
-		  }
-		| undefined;
-	if (userOtelConf) {
-		const resource = resourceFromAttributes({
-			...createResource(config).attributes,
-			...userOtelConf.resourceAttributes,
-			[ATTR_SERVICE_NAME]: userOtelConf.serviceName,
-		});
-		userLoggerProvider = createUserLoggerProvider({
-			url: userOtelConf.endpoint,
-			headers: userOtelConf.headers,
-			resource,
-		});
-		if (otel.logger instanceof OtelLogger) {
-			otel.logger.addDelegate(userLoggerProvider.provider.getLogger('default'));
-		} else {
-			console.warn('[WARN] user OTEL logger not attached: logger does not support addDelegate');
-		}
-	}
-	return otel;
-}

package/src/otel/console.ts

@@ -1,56 +0,0 @@
-import { SeverityNumber } from '@opentelemetry/api-logs';
-import { type ExportResult, ExportResultCode } from '@opentelemetry/core';
-import type { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs';
-import ConsoleLogger from '../logger/console';
-
-/**
- * Console implementation of the LogRecordExporter interface
- */
-export class ConsoleLogRecordExporter implements LogRecordExporter {
-	private readonly logger: ConsoleLogger;
-
-	/**
-	 * Creates a new console log record exporter
-	 */
-	constructor() {
-		this.logger = new ConsoleLogger();
-	}
-
-	/**
-	 * Exports log records to the console
-	 *
-	 * @param logs - The log records to export
-	 * @param resultCallback - Callback function to report the export result
-	 */
-	export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void {
-		for (const log of logs) {
-			switch (log.severityNumber) {
-				case SeverityNumber.DEBUG:
-					this.logger.debug(log.body);
-					break;
-				case SeverityNumber.INFO:
-					this.logger.info(log.body);
-					break;
-				case SeverityNumber.WARN:
-					this.logger.warn(log.body);
-					break;
-				case SeverityNumber.ERROR:
-					this.logger.error(log.body);
-					break;
-				default:
-					this.logger.info(log.body);
-					break;
-			}
-		}
-		resultCallback({ code: ExportResultCode.SUCCESS });
-	}
-
-	/**
-	 * Shuts down the exporter
-	 *
-	 * @returns A promise that resolves when shutdown is complete
-	 */
-	shutdown(): Promise<void> {
-		return Promise.resolve();
-	}
-}

package/src/otel/fetch.ts

@@ -1,103 +0,0 @@
-import { context, propagation, SpanStatusCode, trace } from '@opentelemetry/api';
-
-/**
- * Reference to the original fetch function before instrumentation
- */
-export const __originalFetch = fetch; // save the original fetch before we patch it
-
-/**
- * Instruments the global fetch function with OpenTelemetry tracing
- *
- * Replaces the global fetch with an instrumented version that creates spans
- * for each HTTP request and propagates trace context in headers
- */
-export function instrumentFetch() {
-	const patch = async (
-		input: string | Request | URL,
-		init: RequestInit | undefined
-	): Promise<Response> => {
-		const url =
-			typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
-
-		const method =
-			init?.method ||
-			(typeof input !== 'string' && !(input instanceof URL) ? input.method || 'GET' : 'GET');
-
-		// Get the active span if it exists
-		const activeSpan = trace.getActiveSpan();
-
-		// If there's no active span, just call the original fetch
-		if (!activeSpan) {
-			return __originalFetch(input, init);
-		}
-
-		// Get the current active context
-		const currentContext = context.active();
-		const _url = new URL(url);
-
-		// Create a child span using the current context
-		const childSpan = trace.getTracer('fetch').startSpan(
-			`HTTP ${method}`,
-			{
-				attributes: {
-					'http.url': url,
-					'http.path': _url.pathname,
-					'http.method': method,
-					host: _url.host,
-				},
-			},
-			currentContext
-		);
-
-		try {
-			// Add trace context to headers
-			// Add trace context to headers; preserve headers from Request input
-			const baseHeaders =
-				typeof input !== 'string' && !(input instanceof URL) && input instanceof Request
-					? input.headers
-					: undefined;
-			const headers = new Headers(baseHeaders ?? init?.headers ?? {});
-			const carrier: Record<string, string> = {};
-
-			// Create a new context with the child span
-			const newContext = trace.setSpan(currentContext, childSpan);
-
-			// Use the new context for propagation
-			propagation.inject(newContext, carrier);
-
-			// Copy the carrier properties to headers
-			for (const [key, value] of Object.entries(carrier)) {
-				headers.set(key, value);
-			}
-
-			// Create new init object with updated headers
-			const newInit = {
-				...init,
-				headers,
-			};
-
-			const response = await __originalFetch(input, newInit);
-
-			// Add response attributes to span
-			childSpan.setAttributes({
-				'http.status_code': response.status,
-				'http.user_agent': response.headers.get('user-agent') || '',
-			});
-
-			if (!response.ok) {
-				childSpan.setStatus({ code: SpanStatusCode.ERROR });
-			} else {
-				childSpan.setStatus({ code: SpanStatusCode.OK });
-			}
-
-			return response;
-		} catch (error) {
-			childSpan.recordException(error as Error);
-			childSpan.setStatus({ code: SpanStatusCode.ERROR });
-			throw error;
-		} finally {
-			childSpan.end();
-		}
-	};
-	globalThis.fetch = patch as typeof fetch;
-}

package/src/otel/http.ts

@@ -1,51 +0,0 @@
-import { context, propagation } from '@opentelemetry/api';
-
-/**
- * Injects trace context into response headers using the OpenTelemetry propagation API
- *
- * @param headers - Optional existing headers to include
- * @returns A record of headers with trace context injected
- */
-export function injectTraceContextToHeaders(
-	headers: Record<string, string> | Headers = {}
-): Record<string, string> {
-	let _headers: Record<string, string>;
-	if (headers instanceof Headers) {
-		_headers = {};
-		headers.forEach((v, k) => (_headers[k] = v));
-	} else {
-		_headers = { ...headers };
-	}
-	// Create a carrier object for the headers
-	const carrier: Record<string, string> = { ..._headers } as Record<string, string>;
-
-	// Get the current context
-	const currentContext = context.active();
-
-	// Inject trace context into the carrier
-	propagation.inject(currentContext, carrier);
-
-	return carrier;
-}
-
-/**
- * Extracts trace context from Bun Request headers
- *
- * @param req - The Bun Request object
- * @returns The context with trace information
- */
-export function extractTraceContextFromRequest(
-	req: Request
-): ReturnType<typeof propagation.extract> {
-	// Create a carrier object from the headers
-	const carrier: Record<string, string> = {};
-
-	// Convert headers to the format expected by the propagator
-	req.headers.forEach((value, key) => {
-		carrier[key.toLowerCase()] = value;
-	});
-
-	// Extract the context using the global propagator
-	const activeContext = context.active();
-	return propagation.extract(activeContext, carrier);
-}