@agentuity/runtime 1.0.48 → 2.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/runtime",
-	"version": "1.0.48",
+	"version": "2.0.0-beta.0",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -26,11 +26,11 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/auth": "1.0.48",
-		"@agentuity/core": "1.0.48",
-		"@agentuity/frontend": "1.0.48",
-		"@agentuity/schema": "1.0.48",
-		"@agentuity/server": "1.0.48",
+		"@agentuity/auth": "2.0.0-beta.0",
+		"@agentuity/core": "2.0.0-beta.0",
+		"@agentuity/frontend": "2.0.0-beta.0",
+		"@agentuity/schema": "2.0.0-beta.0",
+		"@agentuity/server": "2.0.0-beta.0",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.207.0",
 		"@opentelemetry/auto-instrumentations-node": "^0.66.0",
@@ -50,7 +50,7 @@
 		"zod": "^4.3.5"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "1.0.48",
+		"@agentuity/test-utils": "2.0.0-beta.0",
 		"@types/bun": "latest",
 		"@types/react": "^19.2.2",
 		"@types/react-dom": "^19.2.2",

package/src/_globals.ts

@@ -0,0 +1,92 @@
+/**
+ * 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/_metadata.ts

@@ -136,6 +136,13 @@ export function loadBuildMetadata(): BuildMetadata | undefined {
 
 	if (!existsSync(metadataPath)) {
 		internal.info('[metadata] agentuity.metadata.json not found at %s', metadataPath);
+		// In dev mode, don't cache "not found" — the dev server generates
+		// the metadata file after createApp() has already been called.
+		// Caching undefined would permanently prevent the workbench from
+		// finding agents once the file is later written.
+		if (process.env.NODE_ENV === 'development') {
+			return undefined;
+		}
 		_metadataCache = undefined;
 		return undefined;
 	}
@@ -208,6 +215,13 @@ function ensureAgentMaps(): void {
 	const metadata = loadBuildMetadata();
 	if (!metadata?.agents) {
 		internal.info(`[metadata] ensureAgentMaps: no metadata or no agents found`);
+		// In dev mode, don't cache empty maps — metadata file may appear later
+		if (process.env.NODE_ENV === 'development') {
+			_agentsByName = null;
+			_agentsByAgentId = null;
+			_evalsByAgentName = null;
+			_evalsByAgentId = null;
+		}
 		return;
 	}
 

package/src/_process-protection.ts

@@ -3,26 +3,24 @@
  *
  * Prevents user code from calling process.exit() which would crash the server.
  * The runtime can still exit gracefully using the internal exit function.
+ *
+ * Uses _globals.ts Symbol.for() accessors to store state across hot reloads.
  */
 
 import { StructuredError } from '@agentuity/core';
+import {
+	originalProcessExit as exitGlobal,
+	processExitProtected as protectedGlobal,
+} from './_globals';
 
-// Store the original process.exit ONLY if not already stored.
-// This is critical for hot reload scenarios where this module may be re-imported
-// multiple times. We must capture the truly original process.exit, not a previously
-// wrapped version.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const existingOriginalExit = (globalThis as any).__AGENTUITY_ORIGINAL_PROCESS_EXIT__;
-const originalExit: (code?: number) => never = existingOriginalExit ?? process.exit.bind(process);
-// Store it globally so subsequent imports get the same original
-if (!existingOriginalExit) {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	(globalThis as any).__AGENTUITY_ORIGINAL_PROCESS_EXIT__ = originalExit;
+// Capture the original process.exit ONLY if not already stored.
+// Critical for hot reload: we must capture the truly original, not a wrapped version.
+const existingExit = exitGlobal.get();
+const originalExit: (code?: number) => never = existingExit ?? process.exit.bind(process);
+if (!existingExit) {
+	exitGlobal.set(originalExit);
 }
 
-// Flag to track if protection is enabled
-let protectionEnabled = false;
-
 const ProcessExitAttemptError = StructuredError(
 	'ProcessExitAttemptError',
 	'Calling process.exit() is not allowed in agent code. The server must remain running to handle requests.'
@@ -35,16 +33,11 @@ const ProcessExitAttemptError = StructuredError(
  * After calling this, user code calling process.exit() will throw an error.
  */
 export function enableProcessExitProtection(): void {
-	if (protectionEnabled) {
+	if (protectedGlobal.get()) {
 		return;
 	}
-
-	protectionEnabled = true;
+	protectedGlobal.set(true);
 
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	(globalThis as any).AGENTUITY_PROCESS_EXIT = originalExit;
-
-	// Replace process.exit with a function that throws
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	(process as any).exit = (code?: number | string | null | undefined): never => {
 		throw new ProcessExitAttemptError({ code });
@@ -55,14 +48,10 @@ export function enableProcessExitProtection(): void {
  * Disable protection (mainly for testing)
  */
 export function disableProcessExitProtection(): void {
-	if (!protectionEnabled) {
+	if (!protectedGlobal.get()) {
 		return;
 	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	(globalThis as any).AGENTUITY_PROCESS_EXIT = undefined;
-
-	protectionEnabled = false;
+	protectedGlobal.set(false);
 	process.exit = originalExit;
 }
 
@@ -78,5 +67,5 @@ export function internalExit(code?: number): never {
  * Check if protection is currently enabled
  */
 export function isProtectionEnabled(): boolean {
-	return protectionEnabled;
+	return protectedGlobal.get();
 }

package/src/_server.ts

@@ -1,6 +1,10 @@
 /**
  * Minimal server globals for Vite-native architecture
  * The server is managed by Vite (dev) or Bun.serve in the generated entry file (prod)
+ *
+ * These module-level variables persist across bun --hot reloads (since this
+ * module is not re-evaluated unless it changes). createApp() updates them
+ * via setters on each reload.
  */
 
 import type { Logger } from './logger';

package/src/_services.ts

@@ -43,6 +43,7 @@ import { getTracer } from './_server';
 import { populateAgentsRegistry } from './agent.js';
 import { getSDKVersion, isAuthenticated, isProduction } from './_config';
 import type { AppConfig } from './app';
+import { localServicesLogged } from './_globals';
 import {
 	DefaultSessionProvider,
 	DefaultThreadProvider,
@@ -200,7 +201,7 @@ const ServerUrlMissingError = StructuredError(
 );
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function createServices(logger: Logger, config?: AppConfig<any>, serverUrl?: string) {
+export function createServices(logger: Logger, config?: AppConfig, serverUrl?: string) {
 	const authenticated = isAuthenticated();
 	const useLocal = config?.services?.useLocal ?? false;
 	adapter = createFetchAdapter(logger);
@@ -217,7 +218,10 @@ export function createServices(logger: Logger, config?: AppConfig<any>, serverUr
 			throw new ServerUrlMissingError();
 		}
 
-		logger.info('Using local services (development only)');
+		if (!localServicesLogged.get()) {
+			localServicesLogged.set(true);
+			logger.info('Using local services (development only)');
+		}
 
 		kv = config?.services?.keyvalue || new LocalKeyValueStorage(db, projectPath);
 		stream = config?.services?.stream || new LocalStreamStorage(db, projectPath, serverUrl);

package/src/_standalone.ts

@@ -26,7 +26,7 @@ import WaitUntilHandler from './_waituntil';
 import { registerServices, createServices } from './_services';
 import { getAgentAsyncLocalStorage } from './_context';
 import { getLogger, getTracer, setGlobalLogger, setGlobalTracer } from './_server';
-import { getAppState } from './app';
+
 import { getThreadProvider, getSessionProvider, getSessionEventProvider } from './_services';
 import * as runtimeConfig from './_config';
 
@@ -100,12 +100,7 @@ function initializeStandaloneRuntime(): void {
 	setGlobalLogger(logger);
 	setGlobalTracer(tracer);
 
-	// Set minimal app state if not already set
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	if (!(globalThis as any).__AGENTUITY_APP_STATE__) {
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		(globalThis as any).__AGENTUITY_APP_STATE__ = {};
-	}
+	// App state is already initialized as {} in _server.ts module-level var
 
 	// Initialize services (will use local services since not authenticated)
 	const serverUrl = `http://127.0.0.1:${process.env.PORT || '3500'}`;
@@ -226,7 +221,7 @@ export class StandaloneAgentContext<
 		// Auto-initialize if not inside agent runtime and globals are not set
 		let logger = getLogger();
 		let tracer = getTracer();
-		let app = getAppState();
+		let app = {} as Record<string, unknown>;
 
 		if (!logger || !tracer) {
 			// Check if we're inside the agent runtime (dev server or cloud)
@@ -244,7 +239,7 @@ export class StandaloneAgentContext<
 			// Re-fetch globals after initialization
 			logger = getLogger()!;
 			tracer = getTracer()!;
-			app = getAppState();
+			app = {};
 		}
 
 		this.logger = logger;

package/src/agent.ts

@@ -2382,6 +2382,7 @@ export function createAgent<
 		inputSchema: inputSchema as TInput,
 		outputSchema: outputSchema as TOutput,
 		stream: (config.schema?.stream as TStream) || (false as TStream),
+		evals: agent.evals,
 		createEval,
 		addEventListener: agent.addEventListener,
 		removeEventListener: agent.removeEventListener,