@agentxjs/core 1.9.5-dev → 1.9.6-dev

package/dist/combinators-nEa5dD0T.d.ts

@@ -0,0 +1,271 @@
+import { P as Processor } from './Processor-DT0N1qI6.js';
+
+/**
+ * Source - Input adapter for Mealy Machine
+ *
+ * A Source transforms external requests into internal events.
+ * This is a pure function type - lifecycle management belongs to higher layers.
+ *
+ * Pattern: (request) => AsyncIterable<input>
+ *
+ * @template TInput - The event type produced for Processors
+ * @template TRequest - The request type received from external (default: void)
+ *
+ * @example
+ * ```typescript
+ * // Simple source (no request)
+ * const timerSource: Source<TimerEvent> = async function* () {
+ *   while (true) {
+ *     yield { type: 'tick', timestamp: Date.now() };
+ *     await sleep(1000);
+ *   }
+ * };
+ *
+ * // Source with request
+ * const apiSource: Source<ApiEvent, ApiRequest> = async function* (request) {
+ *   const response = await fetch(request.url);
+ *   yield { type: 'response', data: await response.json() };
+ * };
+ * ```
+ */
+type Source<TInput, TRequest = void> = (request: TRequest) => AsyncIterable<TInput>;
+/**
+ * SourceDefinition - Named Source with metadata
+ *
+ * Use this when you need to identify sources by name.
+ */
+interface SourceDefinition<TInput, TRequest = void> {
+    /**
+     * Unique name for this source
+     */
+    name: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * The source function
+     */
+    source: Source<TInput, TRequest>;
+}
+
+/**
+ * Sink - Output adapter for Mealy Machine
+ *
+ * A Sink receives outputs from Processors and produces external effects.
+ * This is a pure function type - lifecycle management belongs to higher layers.
+ *
+ * Pattern: (id, outputs) => void | Promise<void>
+ *
+ * @template TOutput - The output type received from Processors
+ *
+ * @example
+ * ```typescript
+ * // Sync sink (logging)
+ * const logSink: Sink<AgentEvent> = (id, outputs) => {
+ *   outputs.forEach(output => console.log(`[${id}]`, output));
+ * };
+ *
+ * // Async sink (network)
+ * const sseSink: Sink<AgentEvent> = async (id, outputs) => {
+ *   for (const output of outputs) {
+ *     await sseConnection.send(id, output);
+ *   }
+ * };
+ * ```
+ */
+type Sink<TOutput> = (id: string, outputs: TOutput[]) => void | Promise<void>;
+/**
+ * SinkDefinition - Named Sink with metadata
+ *
+ * Use this when you need to identify sinks by name.
+ */
+interface SinkDefinition<TOutput> {
+    /**
+     * Unique name for this sink
+     */
+    name: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Optional filter to select which outputs to process
+     *
+     * If not provided, all outputs are processed.
+     * Return true to process the output, false to skip.
+     */
+    filter?: (output: TOutput) => boolean;
+    /**
+     * The sink function
+     */
+    sink: Sink<TOutput>;
+}
+
+/**
+ * Store - State storage interface for stream processing
+ *
+ * A Store abstracts state persistence, allowing processors to be stateless
+ * while maintaining state externally.
+ *
+ * @template T - The state type to store
+ *
+ * @example
+ * ```typescript
+ * const store = new MemoryStore<AgentState>();
+ * store.set('agent_123', { count: 0 });
+ * const state = store.get('agent_123');
+ * ```
+ */
+interface Store<T> {
+    /**
+     * Get state by ID
+     * @param id - Unique identifier (e.g., agentId, sessionId)
+     * @returns The stored state or undefined if not found
+     */
+    get(id: string): T | undefined;
+    /**
+     * Set state for an ID
+     * @param id - Unique identifier
+     * @param state - The state to store
+     */
+    set(id: string, state: T): void;
+    /**
+     * Delete state for an ID
+     * @param id - Unique identifier
+     */
+    delete(id: string): void;
+    /**
+     * Check if state exists for an ID
+     * @param id - Unique identifier
+     * @returns True if state exists
+     */
+    has(id: string): boolean;
+}
+/**
+ * MemoryStore - In-memory implementation of Store
+ *
+ * Stores state in a Map. Suitable for development and single-process deployments.
+ * For production multi-process scenarios, use RedisStore or PostgresStore.
+ *
+ * @template T - The state type to store
+ *
+ * @example
+ * ```typescript
+ * const store = new MemoryStore<MyState>();
+ * store.set('session_1', { count: 0 });
+ * ```
+ */
+declare class MemoryStore<T> implements Store<T> {
+    private states;
+    get(id: string): T | undefined;
+    set(id: string, state: T): void;
+    delete(id: string): void;
+    has(id: string): boolean;
+    /**
+     * Clear all stored states
+     */
+    clear(): void;
+    /**
+     * Get the number of stored states
+     */
+    get size(): number;
+    /**
+     * Get all stored IDs
+     */
+    keys(): IterableIterator<string>;
+}
+
+/**
+ * Combinators - Functions to compose multiple Processors
+ *
+ * These utilities allow building complex stream processing pipelines
+ * from simple, composable Processor functions.
+ */
+
+/**
+ * combineProcessors - Combine multiple processors into one
+ *
+ * Each sub-processor manages its own slice of state.
+ * All processors receive the same event and their outputs are merged.
+ *
+ * @example
+ * ```typescript
+ * interface CombinedState {
+ *   message: MessageState;
+ *   state: StateMachineState;
+ *   turn: TurnState;
+ * }
+ *
+ * const combinedProcessor = combineProcessors<CombinedState, Event, Event>({
+ *   message: messageProcessor,
+ *   state: stateMachineProcessor,
+ *   turn: turnTrackerProcessor,
+ * });
+ * ```
+ */
+declare function combineProcessors<TState extends Record<string, unknown>, TInput, TOutput>(processors: {
+    [K in keyof TState]: Processor<TState[K], TInput, TOutput>;
+}): Processor<TState, TInput, TOutput>;
+/**
+ * combineInitialStates - Helper to create initial state for combined processors
+ */
+declare function combineInitialStates<TState extends Record<string, unknown>>(initialStates: {
+    [K in keyof TState]: () => TState[K];
+}): () => TState;
+/**
+ * chainProcessors - Chain processors where output of one feeds into the next
+ *
+ * Useful for layered event processing:
+ * Stream Events → Message Events → Turn Events
+ *
+ * @example
+ * ```typescript
+ * const pipeline = chainProcessors(
+ *   streamToMessageProcessor,
+ *   messageToTurnProcessor,
+ * );
+ * ```
+ */
+declare function chainProcessors<TState, TEvent>(...processors: Processor<TState, TEvent, TEvent>[]): Processor<TState, TEvent, TEvent>;
+/**
+ * filterProcessor - Create a processor that only processes certain events
+ *
+ * @example
+ * ```typescript
+ * const textOnlyProcessor = filterProcessor(
+ *   (event) => event.type === 'text_delta',
+ *   textProcessor,
+ * );
+ * ```
+ */
+declare function filterProcessor<TState, TInput, TOutput>(predicate: (event: TInput) => boolean, processor: Processor<TState, TInput, TOutput>): Processor<TState, TInput, TOutput>;
+/**
+ * mapOutput - Transform output events
+ *
+ * @example
+ * ```typescript
+ * const withTimestamp = mapOutput(
+ *   myProcessor,
+ *   (output) => ({ ...output, processedAt: Date.now() }),
+ * );
+ * ```
+ */
+declare function mapOutput<TState, TInput, TOutput, TMapped>(processor: Processor<TState, TInput, TOutput>, mapper: (output: TOutput) => TMapped): Processor<TState, TInput, TMapped>;
+/**
+ * withLogging - Add logging to a processor (for debugging)
+ *
+ * @example
+ * ```typescript
+ * const debugProcessor = withLogging(myProcessor, 'MyProcessor');
+ * ```
+ */
+declare function withLogging<TState, TInput, TOutput>(processor: Processor<TState, TInput, TOutput>, name: string, logger?: {
+    debug: (message: string, data?: unknown) => void;
+}): Processor<TState, TInput, TOutput>;
+/**
+ * identityProcessor - A processor that does nothing (useful as default)
+ */
+declare function identityProcessor<TState, TEvent>(): Processor<TState, TEvent, TEvent>;
+
+export { MemoryStore as M, type Store as S, type Sink as a, type SinkDefinition as b, type Source as c, type SourceDefinition as d, combineProcessors as e, combineInitialStates as f, chainProcessors as g, filterProcessor as h, identityProcessor as i, mapOutput as m, withLogging as w };

package/dist/common/index.d.ts

@@ -0,0 +1 @@
+export * from 'commonxjs/logger';

package/dist/common/index.js

@@ -0,0 +1,2 @@
+import "../chunk-RL3JRNXM.js";
+//# sourceMappingURL=index.js.map

package/dist/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/common/logger/index.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Logger type definitions
+ *
+ * Self-contained types for the logger module.
+ * No external dependencies required.
+ */
+/**
+ * LogLevel - Standard log level type
+ *
+ * Defines the severity levels for logging.
+ * Uses string literal types for better readability and type safety.
+ */
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+/**
+ * Logging context metadata
+ */
+type LogContext = Record<string, unknown>;
+/**
+ * Logger interface
+ *
+ * Platform-agnostic logging interface that can be implemented
+ * by any logging library (console, pino, winston, etc.)
+ *
+ * Similar to SLF4J's Logger interface in Java.
+ */
+interface Logger {
+    /**
+     * Logger name (typically class name or module path)
+     */
+    readonly name: string;
+    /**
+     * Current log level
+     */
+    readonly level: LogLevel;
+    /**
+     * Log debug message
+     */
+    debug(message: string, context?: LogContext): void;
+    /**
+     * Log info message
+     */
+    info(message: string, context?: LogContext): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string, context?: LogContext): void;
+    /**
+     * Log error message or Error object
+     */
+    error(message: string | Error, context?: LogContext): void;
+    /**
+     * Check if debug level is enabled
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * Check if info level is enabled
+     */
+    isInfoEnabled(): boolean;
+    /**
+     * Check if warn level is enabled
+     */
+    isWarnEnabled(): boolean;
+    /**
+     * Check if error level is enabled
+     */
+    isErrorEnabled(): boolean;
+}
+/**
+ * LoggerFactory interface
+ *
+ * Factory for creating named Logger instances.
+ * External implementations can provide their own LoggerFactory
+ * to integrate custom logging libraries (pino, winston, etc.)
+ *
+ * Similar to SLF4J's LoggerFactory in Java.
+ */
+interface LoggerFactory {
+    /**
+     * Get or create a logger with the specified name
+     *
+     * @param name - Logger name (typically class name or module path)
+     * @returns Logger instance
+     */
+    getLogger(name: string): Logger;
+}
+
+/**
+ * ConsoleLogger - Default logger implementation
+ *
+ * Simple console-based logger with color support.
+ * Used as fallback when no custom LoggerFactory is provided.
+ */
+
+interface ConsoleLoggerOptions {
+    level?: LogLevel;
+    colors?: boolean;
+    timestamps?: boolean;
+}
+declare class ConsoleLogger implements Logger {
+    readonly name: string;
+    readonly level: LogLevel;
+    private readonly colors;
+    private readonly timestamps;
+    private static readonly COLORS;
+    constructor(name: string, options?: ConsoleLoggerOptions);
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string | Error, context?: LogContext): void;
+    isDebugEnabled(): boolean;
+    isInfoEnabled(): boolean;
+    isWarnEnabled(): boolean;
+    isErrorEnabled(): boolean;
+    private getLevelValue;
+    private log;
+    private getConsoleMethod;
+    private isNodeEnvironment;
+}
+
+/**
+ * LoggerFactoryImpl - Central factory for creating logger instances
+ *
+ * Implements lazy initialization pattern:
+ * - createLogger() can be called at module level (before config)
+ * - Real logger is created on first use
+ * - External LoggerFactory can be injected via Runtime
+ */
+
+interface LoggerFactoryConfig {
+    defaultImplementation?: (name: string) => Logger;
+    defaultLevel?: LogLevel;
+    consoleOptions?: Omit<ConsoleLoggerOptions, "level">;
+}
+/**
+ * Internal LoggerFactory implementation
+ *
+ * Uses lazy proxy pattern to allow module-level createLogger() calls.
+ */
+declare class LoggerFactoryImpl {
+    private static loggers;
+    private static config;
+    static getLogger(nameOrClass: string | (new (...args: unknown[]) => unknown)): Logger;
+    static configure(config: LoggerFactoryConfig): void;
+    static reset(): void;
+    private static createLazyLogger;
+    private static createLogger;
+}
+/**
+ * Set external LoggerFactory (called by Runtime initialization)
+ */
+declare function setLoggerFactory(factory: LoggerFactory): void;
+/**
+ * Create a logger instance
+ *
+ * Safe to call at module level before Runtime is configured.
+ * Uses lazy initialization - actual logger is created on first use.
+ *
+ * @param name - Logger name (hierarchical, e.g., "engine/AgentEngine")
+ * @returns Logger instance (lazy proxy)
+ */
+declare function createLogger(name: string): Logger;
+
+export { ConsoleLogger, type ConsoleLoggerOptions, type LogContext, type LogLevel, type Logger, type LoggerFactory, type LoggerFactoryConfig, LoggerFactoryImpl, createLogger, setLoggerFactory };

package/dist/common/logger/index.js

@@ -0,0 +1,184 @@
+import "../../chunk-7D4SUZUM.js";
+
+// src/common/logger/ConsoleLogger.ts
+var ConsoleLogger = class _ConsoleLogger {
+  name;
+  level;
+  colors;
+  timestamps;
+  static COLORS = {
+    DEBUG: "\x1B[36m",
+    INFO: "\x1B[32m",
+    WARN: "\x1B[33m",
+    ERROR: "\x1B[31m",
+    RESET: "\x1B[0m"
+  };
+  constructor(name, options = {}) {
+    this.name = name;
+    this.level = options.level ?? "info";
+    this.colors = options.colors ?? this.isNodeEnvironment();
+    this.timestamps = options.timestamps ?? true;
+  }
+  debug(message, context) {
+    if (this.isDebugEnabled()) {
+      this.log("DEBUG", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.isInfoEnabled()) {
+      this.log("INFO", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.isWarnEnabled()) {
+      this.log("WARN", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.isErrorEnabled()) {
+      if (message instanceof Error) {
+        this.log("ERROR", message.message, { ...context, stack: message.stack });
+      } else {
+        this.log("ERROR", message, context);
+      }
+    }
+  }
+  isDebugEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("debug");
+  }
+  isInfoEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("info");
+  }
+  isWarnEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("warn");
+  }
+  isErrorEnabled() {
+    return this.getLevelValue(this.level) <= this.getLevelValue("error");
+  }
+  getLevelValue(level) {
+    const levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+    return levels[level];
+  }
+  log(level, message, context) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (this.colors) {
+      const color = _ConsoleLogger.COLORS[level];
+      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger.COLORS.RESET}`);
+    } else {
+      parts.push(level.padEnd(5));
+    }
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    const logLine = parts.join(" ");
+    const consoleMethod = this.getConsoleMethod(level);
+    if (context && Object.keys(context).length > 0) {
+      consoleMethod(logLine, context);
+    } else {
+      consoleMethod(logLine);
+    }
+  }
+  getConsoleMethod(level) {
+    switch (level) {
+      case "DEBUG":
+        return console.debug.bind(console);
+      case "INFO":
+        return console.info.bind(console);
+      case "WARN":
+        return console.warn.bind(console);
+      case "ERROR":
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
+    }
+  }
+  isNodeEnvironment() {
+    return typeof process !== "undefined" && process.versions?.node !== void 0;
+  }
+};
+
+// src/common/logger/LoggerFactoryImpl.ts
+var externalFactory = null;
+var factoryVersion = 0;
+var LoggerFactoryImpl = class {
+  static loggers = /* @__PURE__ */ new Map();
+  static config = {
+    defaultLevel: "info"
+  };
+  static getLogger(nameOrClass) {
+    const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
+    if (this.loggers.has(name)) {
+      return this.loggers.get(name);
+    }
+    const lazyLogger = this.createLazyLogger(name);
+    this.loggers.set(name, lazyLogger);
+    return lazyLogger;
+  }
+  static configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  static reset() {
+    this.loggers.clear();
+    this.config = { defaultLevel: "info" };
+    externalFactory = null;
+    factoryVersion++;
+  }
+  static createLazyLogger(name) {
+    let realLogger = null;
+    let loggerVersion = -1;
+    const getRealLogger = () => {
+      if (!realLogger || loggerVersion !== factoryVersion) {
+        realLogger = this.createLogger(name);
+        loggerVersion = factoryVersion;
+      }
+      return realLogger;
+    };
+    return {
+      name,
+      level: this.config.defaultLevel || "info",
+      debug: (message, context) => getRealLogger().debug(message, context),
+      info: (message, context) => getRealLogger().info(message, context),
+      warn: (message, context) => getRealLogger().warn(message, context),
+      error: (message, context) => getRealLogger().error(message, context),
+      isDebugEnabled: () => getRealLogger().isDebugEnabled(),
+      isInfoEnabled: () => getRealLogger().isInfoEnabled(),
+      isWarnEnabled: () => getRealLogger().isWarnEnabled(),
+      isErrorEnabled: () => getRealLogger().isErrorEnabled()
+    };
+  }
+  static createLogger(name) {
+    if (externalFactory) {
+      return externalFactory.getLogger(name);
+    }
+    if (this.config.defaultImplementation) {
+      return this.config.defaultImplementation(name);
+    }
+    return new ConsoleLogger(name, {
+      level: this.config.defaultLevel,
+      ...this.config.consoleOptions
+    });
+  }
+};
+function setLoggerFactory(factory) {
+  externalFactory = factory;
+  LoggerFactoryImpl.reset();
+  externalFactory = factory;
+}
+function createLogger(name) {
+  return LoggerFactoryImpl.getLogger(name);
+}
+export {
+  ConsoleLogger,
+  LoggerFactoryImpl,
+  createLogger,
+  setLoggerFactory
+};
+//# sourceMappingURL=index.js.map

package/dist/common/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/common/logger/ConsoleLogger.ts","../../../src/common/logger/LoggerFactoryImpl.ts"],"sourcesContent":["/**\n * ConsoleLogger - Default logger implementation\n *\n * Simple console-based logger with color support.\n * Used as fallback when no custom LoggerFactory is provided.\n */\n\nimport type { Logger, LogContext, LogLevel } from \"./types\";\n\nexport interface ConsoleLoggerOptions {\n  level?: LogLevel;\n  colors?: boolean;\n  timestamps?: boolean;\n}\n\nexport class ConsoleLogger implements Logger {\n  readonly name: string;\n  readonly level: LogLevel;\n  private readonly colors: boolean;\n  private readonly timestamps: boolean;\n\n  private static readonly COLORS = {\n    DEBUG: \"\\x1b[36m\",\n    INFO: \"\\x1b[32m\",\n    WARN: \"\\x1b[33m\",\n    ERROR: \"\\x1b[31m\",\n    RESET: \"\\x1b[0m\",\n  };\n\n  constructor(name: string, options: ConsoleLoggerOptions = {}) {\n    this.name = name;\n    this.level = options.level ?? \"info\";\n    this.colors = options.colors ?? this.isNodeEnvironment();\n    this.timestamps = options.timestamps ?? true;\n  }\n\n  debug(message: string, context?: LogContext): void {\n    if (this.isDebugEnabled()) {\n      this.log(\"DEBUG\", message, context);\n    }\n  }\n\n  info(message: string, context?: LogContext): void {\n    if (this.isInfoEnabled()) {\n      this.log(\"INFO\", message, context);\n    }\n  }\n\n  warn(message: string, context?: LogContext): void {\n    if (this.isWarnEnabled()) {\n      this.log(\"WARN\", message, context);\n    }\n  }\n\n  error(message: string | Error, context?: LogContext): void {\n    if (this.isErrorEnabled()) {\n      if (message instanceof Error) {\n        this.log(\"ERROR\", message.message, { ...context, stack: message.stack });\n      } else {\n        this.log(\"ERROR\", message, context);\n      }\n    }\n  }\n\n  isDebugEnabled(): boolean {\n    return this.getLevelValue(this.level) <= this.getLevelValue(\"debug\");\n  }\n\n  isInfoEnabled(): boolean {\n    return this.getLevelValue(this.level) <= this.getLevelValue(\"info\");\n  }\n\n  isWarnEnabled(): boolean {\n    return this.getLevelValue(this.level) <= this.getLevelValue(\"warn\");\n  }\n\n  isErrorEnabled(): boolean {\n    return this.getLevelValue(this.level) <= this.getLevelValue(\"error\");\n  }\n\n  private getLevelValue(level: LogLevel): number {\n    const levels: Record<LogLevel, number> = {\n      debug: 0,\n      info: 1,\n      warn: 2,\n      error: 3,\n      silent: 4,\n    };\n    return levels[level];\n  }\n\n  private log(level: string, message: string, context?: LogContext): void {\n    const parts: string[] = [];\n\n    if (this.timestamps) {\n      parts.push(new Date().toISOString());\n    }\n\n    if (this.colors) {\n      const color = ConsoleLogger.COLORS[level as keyof typeof ConsoleLogger.COLORS];\n      parts.push(`${color}${level.padEnd(5)}${ConsoleLogger.COLORS.RESET}`);\n    } else {\n      parts.push(level.padEnd(5));\n    }\n\n    parts.push(`[${this.name}]`);\n    parts.push(message);\n\n    const logLine = parts.join(\" \");\n    const consoleMethod = this.getConsoleMethod(level);\n\n    if (context && Object.keys(context).length > 0) {\n      consoleMethod(logLine, context);\n    } else {\n      consoleMethod(logLine);\n    }\n  }\n\n  private getConsoleMethod(level: string): (...args: unknown[]) => void {\n    switch (level) {\n      case \"DEBUG\":\n        return console.debug.bind(console);\n      case \"INFO\":\n        return console.info.bind(console);\n      case \"WARN\":\n        return console.warn.bind(console);\n      case \"ERROR\":\n        return console.error.bind(console);\n      default:\n        return console.log.bind(console);\n    }\n  }\n\n  private isNodeEnvironment(): boolean {\n    return typeof process !== \"undefined\" && process.versions?.node !== undefined;\n  }\n}\n","/**\n * LoggerFactoryImpl - Central factory for creating logger instances\n *\n * Implements lazy initialization pattern:\n * - createLogger() can be called at module level (before config)\n * - Real logger is created on first use\n * - External LoggerFactory can be injected via Runtime\n */\n\nimport type { Logger, LoggerFactory, LogContext, LogLevel } from \"./types\";\nimport { ConsoleLogger, type ConsoleLoggerOptions } from \"./ConsoleLogger\";\n\n// External factory injected via Runtime\nlet externalFactory: LoggerFactory | null = null;\n\n// Version counter to invalidate cached real loggers\nlet factoryVersion = 0;\n\nexport interface LoggerFactoryConfig {\n  defaultImplementation?: (name: string) => Logger;\n  defaultLevel?: LogLevel;\n  consoleOptions?: Omit<ConsoleLoggerOptions, \"level\">;\n}\n\n/**\n * Internal LoggerFactory implementation\n *\n * Uses lazy proxy pattern to allow module-level createLogger() calls.\n */\nexport class LoggerFactoryImpl {\n  private static loggers: Map<string, Logger> = new Map();\n  private static config: LoggerFactoryConfig = {\n    defaultLevel: \"info\",\n  };\n\n  static getLogger(nameOrClass: string | (new (...args: unknown[]) => unknown)): Logger {\n    const name = typeof nameOrClass === \"string\" ? nameOrClass : nameOrClass.name;\n\n    if (this.loggers.has(name)) {\n      return this.loggers.get(name)!;\n    }\n\n    const lazyLogger = this.createLazyLogger(name);\n    this.loggers.set(name, lazyLogger);\n    return lazyLogger;\n  }\n\n  static configure(config: LoggerFactoryConfig): void {\n    this.config = { ...this.config, ...config };\n  }\n\n  static reset(): void {\n    this.loggers.clear();\n    this.config = { defaultLevel: \"info\" };\n    externalFactory = null;\n    factoryVersion++; // Invalidate all cached real loggers\n  }\n\n  private static createLazyLogger(name: string): Logger {\n    let realLogger: Logger | null = null;\n    let loggerVersion = -1; // Track which factory version created this logger\n\n    const getRealLogger = (): Logger => {\n      // Recreate logger if factory version changed (setLoggerFactory was called)\n      if (!realLogger || loggerVersion !== factoryVersion) {\n        realLogger = this.createLogger(name);\n        loggerVersion = factoryVersion;\n      }\n      return realLogger;\n    };\n\n    return {\n      name,\n      level: this.config.defaultLevel || \"info\",\n      debug: (message: string, context?: LogContext) => getRealLogger().debug(message, context),\n      info: (message: string, context?: LogContext) => getRealLogger().info(message, context),\n      warn: (message: string, context?: LogContext) => getRealLogger().warn(message, context),\n      error: (message: string | Error, context?: LogContext) =>\n        getRealLogger().error(message, context),\n      isDebugEnabled: () => getRealLogger().isDebugEnabled(),\n      isInfoEnabled: () => getRealLogger().isInfoEnabled(),\n      isWarnEnabled: () => getRealLogger().isWarnEnabled(),\n      isErrorEnabled: () => getRealLogger().isErrorEnabled(),\n    };\n  }\n\n  private static createLogger(name: string): Logger {\n    if (externalFactory) {\n      return externalFactory.getLogger(name);\n    }\n\n    if (this.config.defaultImplementation) {\n      return this.config.defaultImplementation(name);\n    }\n\n    return new ConsoleLogger(name, {\n      level: this.config.defaultLevel,\n      ...this.config.consoleOptions,\n    });\n  }\n}\n\n/**\n * Set external LoggerFactory (called by Runtime initialization)\n */\nexport function setLoggerFactory(factory: LoggerFactory): void {\n  externalFactory = factory;\n  LoggerFactoryImpl.reset();\n  externalFactory = factory;\n}\n\n/**\n * Create a logger instance\n *\n * Safe to call at module level before Runtime is configured.\n * Uses lazy initialization - actual logger is created on first use.\n *\n * @param name - Logger name (hierarchical, e.g., \"engine/AgentEngine\")\n * @returns Logger instance (lazy proxy)\n */\nexport function createLogger(name: string): Logger {\n  return LoggerFactoryImpl.getLogger(name);\n}\n"],"mappings":"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","names":[]}