@agentuity/runtime 2.0.11 → 3.0.0-alpha.1

package/src/_config.ts

@@ -1,163 +0,0 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-let appName: string | undefined;
-let appVersion: string | undefined;
-let inited = false;
-
-export function init() {
-	if (inited) {
-		return;
-	}
-	const f = join(import.meta.dir, isProduction() ? 'package.json' : '/../package.json');
-	if (existsSync(f)) {
-		try {
-			const pkg = JSON.parse(readFileSync(f, 'utf-8'));
-			appName = pkg.name;
-			appVersion = pkg.version;
-		} catch {
-			// Fallback to defaults if parsing fails
-		}
-	}
-	inited = true;
-}
-
-/**
- * Returns the SDK Version that was used to build this app
- *
- * @returns string
- */
-export function getSDKVersion(): string {
-	return process.env.AGENTUITY_CLOUD_SDK_VERSION ?? 'unknown';
-}
-
-/**
- * Returns the App Name that was used when this app was built
- *
- * @returns string
- */
-export function getAppName(): string {
-	init();
-	return appName ?? 'unknown';
-}
-
-/**
- * Returns the App Version that was used when this app was built
- *
- * @returns string
- */
-export function getAppVersion(): string {
-	init();
-	return appVersion ?? 'unknown';
-}
-
-/**
- * Returns the Organization ID for this app
- *
- * @returns string
- */
-export function getOrganizationId(): string | undefined {
-	return process.env.AGENTUITY_CLOUD_ORG_ID;
-}
-
-/**
- * Returns the Project ID for this app
- *
- * @returns string
- */
-export function getProjectId(): string | undefined {
-	return process.env.AGENTUITY_CLOUD_PROJECT_ID;
-}
-
-/**
- * Returns the Deployment ID for this app that was deployed
- *
- * @returns string | undefined
- */
-export function getDeploymentId(): string | undefined {
-	return process.env.AGENTUITY_CLOUD_DEPLOYMENT_ID;
-}
-
-/**
- * Returns true if the app is running in dev mode
- *
- * @returns boolean
- */
-export function isDevMode(): boolean {
-	return process.env.AGENTUITY_SDK_DEV_MODE === 'true';
-}
-
-/**
- * Returns true if the app is running in production mode
- *
- * @returns boolean
- */
-export function isProduction(): boolean {
-	return getEnvironment() === 'production' && !isDevMode();
-}
-
-/**
- * Returns the CLI version that was used when this app was built
- *
- * @returns string
- */
-export function getCLIVersion(): string {
-	return process.env.AGENTUITY_CLI_VERSION ?? 'unknown';
-}
-
-/**
- * Returns the environment setting for this app
- *
- * @returns string
- */
-export function getEnvironment(): string {
-	return process.env.AGENTUITY_ENVIRONMENT || process.env.NODE_ENV || 'development';
-}
-
-/**
- * Returns true if the AGENTUITY_SDK_KEY is set
- *
- * @returns boolean
- */
-export function isAuthenticated(): boolean {
-	return !!process.env.AGENTUITY_SDK_KEY;
-}
-
-/**
- * Symbol for accessing internal runtime state.
- * Defined here to avoid circular dependency.
- */
-export const AGENT_RUNTIME = Symbol('AGENT_RUNTIME');
-
-/**
- * Symbol for accessing internal agent from AgentRunner.
- * @internal
- */
-export const INTERNAL_AGENT = Symbol('INTERNAL_AGENT');
-
-/**
- * Symbol for tracking the current executing agent (for telemetry).
- * Not exposed on public AgentContext interface.
- * @internal
- */
-export const CURRENT_AGENT = Symbol('CURRENT_AGENT');
-
-/**
- * Symbol for tracking agent IDs that have executed in this session.
- * Used in standalone contexts to track agents for session events.
- * @internal
- */
-export const AGENT_IDS = Symbol('AGENT_IDS');
-
-/**
- * Returns true if running inside the Agentuity agent runtime (dev server or cloud).
- *
- * This is used to determine whether global state (logger, tracer, services) should
- * already be initialized. When running standalone (scripts, Discord bots, cron jobs),
- * this returns false and the runtime will auto-initialize minimal defaults.
- *
- * @returns boolean - true if AGENTUITY_SDK_DEV_MODE=true or AGENTUITY_RUNTIME=yes
- */
-export function isInsideAgentRuntime(): boolean {
-	return process.env.AGENTUITY_SDK_DEV_MODE === 'true' || process.env.AGENTUITY_RUNTIME === 'yes';
-}

package/src/_context.ts

@@ -1,240 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import type { Context as HonoContext } from 'hono';
-import type { Tracer } from '@opentelemetry/api';
-import {
-	StructuredError,
-	type KeyValueStorage,
-	type StreamStorage,
-	type VectorStorage,
-	type SandboxService,
-	type QueueService,
-	type EmailService,
-	type ScheduleService,
-	type TaskStorage,
-} from '@agentuity/core';
-import type { AuthInterface } from '@agentuity/core';
-import type {
-	AgentContext,
-	AgentRegistry,
-	AgentRunner,
-	AgentRuntimeState,
-	AgentMetadata,
-} from './agent';
-import { AGENT_RUNTIME, CURRENT_AGENT } from './_config';
-import type { Logger } from './logger';
-import type WaitUntilHandler from './_waituntil';
-import { registerServices } from './_services';
-import type { Thread, Session } from './session';
-
-export interface RequestAgentContextArgs<
-	TAgentMap extends AgentRegistry = AgentRegistry,
-	TConfig = unknown,
-	TAppState = Record<string, never>,
-> {
-	sessionId: string;
-	agent: TAgentMap;
-	logger: Logger;
-	tracer: Tracer;
-	session: Session;
-	thread: Thread;
-	handler: WaitUntilHandler;
-	config: TConfig;
-	app: TAppState;
-	runtime: AgentRuntimeState;
-	auth?: AuthInterface | null;
-}
-
-export class RequestAgentContext<
-	TAgentMap extends AgentRegistry = AgentRegistry,
-	TConfig = unknown,
-	TAppState = Record<string, never>,
-> implements AgentContext<TAgentMap, TConfig, TAppState>
-{
-	agent: TAgentMap;
-	logger: Logger;
-	sessionId: string;
-	tracer: Tracer;
-	kv!: KeyValueStorage;
-	stream!: StreamStorage;
-	vector!: VectorStorage;
-	sandbox!: SandboxService;
-	queue!: QueueService;
-	email!: EmailService;
-	schedule!: ScheduleService;
-	task!: TaskStorage;
-	state: Map<string, unknown>;
-	session: Session;
-	thread: Thread;
-	config: TConfig;
-	app: TAppState;
-	current!: AgentMetadata;
-	[AGENT_RUNTIME]: AgentRuntimeState;
-	private handler: WaitUntilHandler;
-
-	/**
-	 * Fallback auth value for non-HTTP contexts (standalone, tests, etc.)
-	 * @internal
-	 */
-	private _initialAuth: AuthInterface | null;
-
-	/**
-	 * Authentication context - lazily reads from HTTP context if available.
-	 *
-	 * This is a getter that prefers the current HTTP context's `c.var.auth`,
-	 * allowing auth middleware that runs after the agent middleware to still
-	 * propagate auth to agents.
-	 */
-	get auth(): AuthInterface | null {
-		// Prefer HTTP context var.auth if available (allows late-binding from route middleware)
-		if (inHTTPContext()) {
-			try {
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				const httpCtx = httpAsyncLocalStorage.getStore() as any;
-				if (httpCtx?.var && 'auth' in httpCtx.var) {
-					return httpCtx.var.auth ?? null;
-				}
-			} catch {
-				// If HTTP context not available, fall through
-			}
-		}
-		// Fallback: whatever was passed in at creation time (for standalone/test contexts)
-		return this._initialAuth;
-	}
-
-	/**
-	 * Set auth for non-HTTP contexts (standalone, tests).
-	 * @internal
-	 */
-	set auth(value: AuthInterface | null) {
-		this._initialAuth = value;
-	}
-
-	constructor(args: RequestAgentContextArgs<TAgentMap, TConfig, TAppState>) {
-		this.agent = args.agent;
-		this.logger = args.logger;
-		this.sessionId = args.sessionId;
-		this.tracer = args.tracer;
-		this.thread = args.thread;
-		this.session = args.session;
-		this.config = args.config;
-		this.app = args.app;
-		this._initialAuth = args.auth ?? null;
-		this[AGENT_RUNTIME] = args.runtime;
-		this.state = new Map<string, unknown>();
-		this.handler = args.handler;
-		registerServices(this, false); // agents already populated via args.agent
-	}
-
-	waitUntil(callback: Promise<void> | (() => void | Promise<void>)): void {
-		this.handler.waitUntil(callback);
-	}
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const agentAsyncLocalStorage = new AsyncLocalStorage<AgentContext<any, any, any>>();
-const httpAsyncLocalStorage = new AsyncLocalStorage<HonoContext>();
-
-export const inAgentContext = (): boolean => {
-	const context = agentAsyncLocalStorage.getStore();
-	return !!context;
-};
-
-export const inHTTPContext = (): boolean => {
-	const context = httpAsyncLocalStorage.getStore();
-	return !!context;
-};
-
-const AgentContextNotAvailableError = StructuredError(
-	'AgentContextNotAvailableError',
-	'AgentContext is not available'
-);
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const getAgentContext = (): AgentContext<any, any, any> => {
-	const context = agentAsyncLocalStorage.getStore();
-	if (!context) {
-		throw new AgentContextNotAvailableError();
-	}
-	return context;
-};
-
-const HTTPContextNotAvailableError = StructuredError(
-	'HTTPContextNotAvailableError',
-	'HTTPContext is not available'
-);
-
-export const getHTTPContext = (): HonoContext => {
-	const context = httpAsyncLocalStorage.getStore();
-	if (!context) {
-		throw new HTTPContextNotAvailableError();
-	}
-	return context;
-};
-
-export const getAgentAsyncLocalStorage = () => agentAsyncLocalStorage;
-export const getHTTPAsyncLocalStorage = () => httpAsyncLocalStorage;
-
-/**
- * Get the current executing agent's metadata (for internal telemetry use only).
- * Returns undefined if not in an agent context or no agent is executing.
- * @internal
- */
-export const getCurrentAgentMetadata = (): AgentRunner['metadata'] | undefined => {
-	const context = agentAsyncLocalStorage.getStore();
-	if (!context) return undefined;
-	// Access internal symbol property
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return (context as any)[CURRENT_AGENT]?.metadata;
-};
-
-export const setupRequestAgentContext = <
-	TAgentMap extends AgentRegistry = AgentRegistry,
-	TConfig = unknown,
-	TAppState = Record<string, never>,
->(
-	ctxObject: Record<string, unknown>,
-	args: RequestAgentContextArgs<TAgentMap, TConfig, TAppState>,
-	next: () => Promise<void>
-) => {
-	const ctx = new RequestAgentContext<TAgentMap, TConfig, TAppState>(args);
-
-	// Note: All Hono context variables are set via c.set() in _server.ts middleware.
-	// RequestAgentContext is only used within agents via AsyncLocalStorage.
-	// No properties need to be copied between them.
-
-	// Provide c.waitUntil() directly on route context for consistency with AgentContext
-	if (!('waitUntil' in ctxObject)) {
-		Object.defineProperty(ctxObject, 'waitUntil', {
-			value: (callback: Promise<void> | (() => void | Promise<void>)) => {
-				args.handler.waitUntil(callback);
-			},
-			configurable: true,
-		});
-	}
-
-	// Provide executionCtx.waitUntil for compatibility with Cloudflare Workers API
-	Object.defineProperty(ctxObject, 'executionCtx', {
-		get() {
-			return {
-				waitUntil: (promise: Promise<unknown>) => {
-					args.handler.waitUntil(promise as Promise<void>);
-				},
-				passThroughOnException: () => {},
-				props: {},
-			};
-		},
-		configurable: true,
-	});
-	return agentAsyncLocalStorage.run(ctx, async () => {
-		const result = await next();
-		return result;
-	});
-};
-
-export const runInHTTPContext = async <HonoContext>(
-	ctx: HonoContext,
-	next: () => Promise<void>
-) => {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return httpAsyncLocalStorage.run(ctx as any, next);
-};

package/src/_events.ts

@@ -1,142 +0,0 @@
-/**
- * Global event bus for Vite-native architecture
- * Replaces the App class event system
- */
-
-import type { Agent, AgentContext } from './agent';
-import type { Session, Thread } from './session';
-import { internal } from './logger/internal';
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// Note: Generic event system requires 'any' for proper type inference with unknown app states
-
-export type AppEventMap<TAppState = Record<string, never>> = {
-	'agent.started': [Agent<any, any, any, any, TAppState>, AgentContext<any, any, TAppState>];
-	'agent.completed': [Agent<any, any, any, any, TAppState>, AgentContext<any, any, TAppState>];
-	'agent.errored': [
-		Agent<any, any, any, any, TAppState>,
-		AgentContext<any, any, TAppState>,
-		Error,
-	];
-	'session.started': [Session];
-	'session.completed': [Session];
-	'thread.created': [Thread];
-	'thread.destroyed': [Thread];
-};
-
-type AppEventCallback<K extends keyof AppEventMap<any>, TAppState = Record<string, never>> = (
-	eventName: K,
-	...args: AppEventMap<TAppState>[K]
-) => void | Promise<void>;
-
-class GlobalEventBus {
-	private eventListeners = new Map<keyof AppEventMap<any>, Set<AppEventCallback<any, any>>>();
-
-	addEventListener<K extends keyof AppEventMap<any>>(
-		eventName: K,
-		callback: AppEventCallback<K, any>
-	): void {
-		let callbacks = this.eventListeners.get(eventName);
-		if (!callbacks) {
-			callbacks = new Set();
-			this.eventListeners.set(eventName, callbacks);
-		}
-		callbacks.add(callback);
-	}
-
-	removeEventListener<K extends keyof AppEventMap<any>>(
-		eventName: K,
-		callback: AppEventCallback<K, any>
-	): void {
-		const callbacks = this.eventListeners.get(eventName);
-		if (!callbacks) return;
-		callbacks.delete(callback);
-	}
-
-	async fireEvent<K extends keyof AppEventMap<any>>(
-		eventName: K,
-		...args: AppEventMap<any>[K]
-	): Promise<void> {
-		const callbacks = this.eventListeners.get(eventName);
-		if (!callbacks || callbacks.size === 0) return;
-
-		for (const callback of callbacks) {
-			try {
-				await callback(eventName, ...args);
-			} catch (error) {
-				// Log but don't re-throw - event listener errors should not crash the server
-				internal.error(`Error in event listener for '${eventName}':`, error);
-			}
-		}
-	}
-
-	clearAllListeners(): void {
-		this.eventListeners.clear();
-	}
-}
-
-// Global singleton instance
-const globalEventBus = new GlobalEventBus();
-
-/**
- * Register an event listener for application lifecycle events.
- *
- * Available events:
- * - `agent.started` - Fired when an agent begins execution
- * - `agent.completed` - Fired when an agent completes successfully
- * - `agent.errored` - Fired when an agent throws an error
- * - `session.started` - Fired when a new session starts
- * - `session.completed` - Fired when a session completes
- * - `thread.created` - Fired when a thread is created
- * - `thread.destroyed` - Fired when a thread is destroyed
- *
- * @example
- * ```typescript
- * import { addEventListener } from '@agentuity/runtime';
- *
- * addEventListener('agent.started', (eventName, agent, ctx) => {
- *   console.log(`${agent.metadata.name} started for session ${ctx.sessionId}`);
- * });
- * ```
- */
-export function addEventListener<K extends keyof AppEventMap<any>>(
-	eventName: K,
-	callback: AppEventCallback<K, any>
-): void {
-	globalEventBus.addEventListener(eventName, callback);
-}
-
-/**
- * Remove a previously registered event listener.
- */
-export function removeEventListener<K extends keyof AppEventMap<any>>(
-	eventName: K,
-	callback: AppEventCallback<K, any>
-): void {
-	globalEventBus.removeEventListener(eventName, callback);
-}
-
-/**
- * Fire a global application event.
- *
- * @example
- * ```typescript
- * import { fireEvent } from '@agentuity/runtime';
- *
- * await fireEvent('session.started', session);
- * await fireEvent('agent.completed', agent, ctx);
- * ```
- */
-export async function fireEvent<K extends keyof AppEventMap<any>>(
-	eventName: K,
-	...args: AppEventMap<any>[K]
-): Promise<void> {
-	await globalEventBus.fireEvent(eventName, ...args);
-}
-
-/**
- * Clear all event listeners (useful for testing)
- */
-export function clearAllEventListeners(): void {
-	globalEventBus.clearAllListeners();
-}

package/src/_globals.ts

@@ -1,92 +0,0 @@
-/**
- * Type-safe accessors for Symbol.for() global state.
- *
- * These symbols survive bun --hot reloads because globalThis persists
- * across module re-evaluations. Using Symbol.for() ensures the same
- * symbol is returned regardless of which module instance creates it.
- *
- * Each symbol key maps to a specific type — this module centralises
- * the definitions so call-sites don't need casts.
- */
-
-import type { OtelResponse } from './otel/otel';
-
-/** Shutdown hook function type (duplicated here to avoid circular dep with app.ts) */
-type ShutdownHook = () => Promise<void> | void;
-
-// ── Symbol keys ──────────────────────────────────────────────
-
-const keys = {
-	originalProcessExit: Symbol.for('@agentuity/runtime:original-process-exit'),
-	processExitProtected: Symbol.for('@agentuity/runtime:process-exit-protected'),
-	otelInstance: Symbol.for('@agentuity/runtime:otel-instance'),
-	originalConsole: Symbol.for('agentuity.originalConsole'),
-	serverStarted: Symbol.for('@agentuity/runtime:server-started'),
-	localServicesLogged: Symbol.for('@agentuity/runtime:local-services-logged'),
-	shutdownHooks: Symbol.for('@agentuity/runtime:shutdown-hooks'),
-	s3Patched: Symbol.for('agentuity.s3.patched'),
-} as const;
-
-export { keys };
-
-// ── Typed getter / setter ────────────────────────────────────
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const g = globalThis as any;
-
-export function getGlobal<T>(key: symbol): T | undefined {
-	return g[key] as T | undefined;
-}
-
-export function setGlobal<T>(key: symbol, value: T): void {
-	g[key] = value;
-}
-
-// ── Convenience accessors for commonly used globals ──────────
-
-export const otel = {
-	get: (): OtelResponse | undefined => getGlobal<OtelResponse>(keys.otelInstance),
-	set: (v: OtelResponse) => setGlobal(keys.otelInstance, v),
-};
-
-export const originalProcessExit = {
-	get: (): ((code?: number) => never) | undefined =>
-		getGlobal<(code?: number) => never>(keys.originalProcessExit),
-	set: (v: (code?: number) => never) => setGlobal(keys.originalProcessExit, v),
-};
-
-export const processExitProtected = {
-	get: (): boolean => getGlobal<boolean>(keys.processExitProtected) ?? false,
-	set: (v: boolean) => setGlobal(keys.processExitProtected, v),
-};
-
-export const originalConsole = {
-	get: (): Console | undefined => getGlobal<Console>(keys.originalConsole),
-	set: (v: Console) => setGlobal(keys.originalConsole, v),
-};
-
-export const serverStarted = {
-	get: (): boolean => getGlobal<boolean>(keys.serverStarted) ?? false,
-	set: (v: boolean) => setGlobal(keys.serverStarted, v),
-};
-
-export const localServicesLogged = {
-	get: (): boolean => getGlobal<boolean>(keys.localServicesLogged) ?? false,
-	set: (v: boolean) => setGlobal(keys.localServicesLogged, v),
-};
-
-export const shutdownHooks = {
-	get: (): ShutdownHook[] => {
-		let hooks = getGlobal<ShutdownHook[]>(keys.shutdownHooks);
-		if (!hooks) {
-			hooks = [];
-			setGlobal(keys.shutdownHooks, hooks);
-		}
-		return hooks;
-	},
-};
-
-export const s3Patched = {
-	get: (): boolean => getGlobal<boolean>(keys.s3Patched) ?? false,
-	set: (v: boolean) => setGlobal(keys.s3Patched, v),
-};

package/src/_idle.ts

@@ -1,10 +0,0 @@
-import { hasWaitUntilPending } from './_waituntil';
-
-/**
- * returns true if the server is idle (no pending waitUntil tasks)
- *
- * @returns true if idle
- */
-export function isIdle() {
-	return !hasWaitUntilPending();
-}