agentxjs 0.0.2 → 0.0.4

package/dist/server/index.js

@@ -1,9 +1,167 @@
-import { isStreamEvent, isErrorEvent } from '@agentxjs/types';
-import { createLogger } from '@agentxjs/common';
+import { LogLevel, isStreamEvent, isErrorEvent } from '@agentxjs/types';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _ConsoleLogger = class _ConsoleLogger2 {
+  constructor(name, options = {}) {
+    __publicField2(this, "name");
+    __publicField2(this, "level");
+    __publicField2(this, "colors");
+    __publicField2(this, "timestamps");
+    this.name = name;
+    this.level = options.level ?? LogLevel.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.level <= LogLevel.DEBUG;
+  }
+  isInfoEnabled() {
+    return this.level <= LogLevel.INFO;
+  }
+  isWarnEnabled() {
+    return this.level <= LogLevel.WARN;
+  }
+  isErrorEnabled() {
+    return this.level <= LogLevel.ERROR;
+  }
+  log(level, message, context) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (this.colors) {
+      const color = _ConsoleLogger2.COLORS[level];
+      parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger2.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;
+  }
+};
+__publicField2(_ConsoleLogger, "COLORS", {
+  DEBUG: "\x1B[36m",
+  INFO: "\x1B[32m",
+  WARN: "\x1B[33m",
+  ERROR: "\x1B[31m",
+  RESET: "\x1B[0m"
+});
+var ConsoleLogger = _ConsoleLogger;
+var externalFactory = null;
+var LoggerFactoryImpl = class {
+  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: LogLevel.INFO };
+    externalFactory = null;
+  }
+  static createLazyLogger(name) {
+    let realLogger = null;
+    const getRealLogger = () => {
+      if (!realLogger) {
+        realLogger = this.createLogger(name);
+      }
+      return realLogger;
+    };
+    return {
+      name,
+      level: this.config.defaultLevel || LogLevel.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
+    });
+  }
+};
+__publicField2(LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
+__publicField2(LoggerFactoryImpl, "config", {
+  defaultLevel: LogLevel.INFO
+});
+function createLogger(name) {
+  return LoggerFactoryImpl.getLogger(name);
+}
+
+// src/server/SSEServerTransport.ts
 var logger = createLogger("agentx/SSEServerTransport");
 var SSEConnection = class {
   constructor(connectionId, agentId) {
@@ -215,6 +373,8 @@ var SSEConnectionManager = class {
     return this._connections.size;
   }
 };
+
+// src/server/createAgentXHandler.ts
 var logger2 = createLogger("agentx/AgentXHandler");
 var VERSION = "0.1.0";
 function createAgentXHandler(agentx, options = {}) {