@dexto/core 1.2.4 → 1.2.6

package/dist/logger/v2/dexto-logger.cjs

@@ -0,0 +1,141 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dexto_logger_exports = {};
+__export(dexto_logger_exports, {
+  DextoLogger: () => DextoLogger
+});
+module.exports = __toCommonJS(dexto_logger_exports);
+class DextoLogger {
+  level;
+  component;
+  agentId;
+  transports;
+  // Log level hierarchy for filtering
+  // Following Winston convention: lower number = more severe
+  // If level is 'debug', logs error(0), warn(1), info(2), debug(3) but not silly(4)
+  static LEVELS = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    silly: 4
+  };
+  constructor(config) {
+    this.level = config.level;
+    this.component = config.component;
+    this.agentId = config.agentId;
+    this.transports = config.transports;
+  }
+  debug(message, context) {
+    if (this.shouldLog("debug")) {
+      this.log("debug", message, context);
+    }
+  }
+  silly(message, context) {
+    if (this.shouldLog("silly")) {
+      this.log("silly", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.shouldLog("info")) {
+      this.log("info", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.shouldLog("warn")) {
+      this.log("warn", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.shouldLog("error")) {
+      this.log("error", message, context);
+    }
+  }
+  trackException(error, context) {
+    this.error(error.message, {
+      ...context,
+      errorName: error.name,
+      errorStack: error.stack,
+      errorType: error.constructor.name
+    });
+  }
+  /**
+   * Internal log method that creates log entry and sends to transports
+   */
+  log(level, message, context) {
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      component: this.component,
+      agentId: this.agentId,
+      context
+    };
+    for (const transport of this.transports) {
+      try {
+        const result = transport.write(entry);
+        if (result && typeof result === "object" && "catch" in result) {
+          result.catch((error) => {
+            console.error("Logger transport error:", error);
+          });
+        }
+      } catch (error) {
+        console.error("Logger transport error:", error);
+      }
+    }
+  }
+  /**
+   * Check if a log level should be recorded based on configured level
+   * Winston convention: log if level number <= configured level number
+   * So if configured is 'debug' (3), we log error(0), warn(1), info(2), debug(3) but not silly(4)
+   */
+  shouldLog(level) {
+    return DextoLogger.LEVELS[level] <= DextoLogger.LEVELS[this.level];
+  }
+  /**
+   * Create a child logger for a different component
+   * Shares the same transports but uses different component identifier
+   */
+  createChild(component) {
+    return new DextoLogger({
+      level: this.level,
+      component,
+      agentId: this.agentId,
+      transports: this.transports
+    });
+  }
+  /**
+   * Cleanup all transports
+   */
+  async destroy() {
+    for (const transport of this.transports) {
+      if (transport.destroy) {
+        try {
+          await transport.destroy();
+        } catch (error) {
+          console.error("Error destroying transport:", error);
+        }
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DextoLogger
+});

package/dist/logger/v2/dexto-logger.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Dexto Logger
+ *
+ * Main logger implementation with multi-transport support.
+ * Supports structured logging, component-based categorization, and per-agent isolation.
+ */
+import type { IDextoLogger, ILoggerTransport, LogLevel, DextoLogComponent } from './types.js';
+export interface DextoLoggerConfig {
+    /** Minimum log level to record */
+    level: LogLevel;
+    /** Component identifier */
+    component: DextoLogComponent;
+    /** Agent ID for multi-agent isolation */
+    agentId: string;
+    /** Transport instances */
+    transports: ILoggerTransport[];
+}
+/**
+ * DextoLogger - Multi-transport logger with structured logging
+ */
+export declare class DextoLogger implements IDextoLogger {
+    private level;
+    private component;
+    private agentId;
+    private transports;
+    private static readonly LEVELS;
+    constructor(config: DextoLoggerConfig);
+    debug(message: string, context?: Record<string, unknown>): void;
+    silly(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    trackException(error: Error, context?: Record<string, unknown>): void;
+    /**
+     * Internal log method that creates log entry and sends to transports
+     */
+    private log;
+    /**
+     * Check if a log level should be recorded based on configured level
+     * Winston convention: log if level number <= configured level number
+     * So if configured is 'debug' (3), we log error(0), warn(1), info(2), debug(3) but not silly(4)
+     */
+    private shouldLog;
+    /**
+     * Create a child logger for a different component
+     * Shares the same transports but uses different component identifier
+     */
+    createChild(component: DextoLogComponent): DextoLogger;
+    /**
+     * Cleanup all transports
+     */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=dexto-logger.d.ts.map

package/dist/logger/v2/dexto-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dexto-logger.d.ts","sourceRoot":"","sources":["../../../src/logger/v2/dexto-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACR,YAAY,EACZ,gBAAgB,EAEhB,QAAQ,EACR,iBAAiB,EACpB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,iBAAiB;IAC9B,kCAAkC;IAClC,KAAK,EAAE,QAAQ,CAAC;IAChB,2BAA2B;IAC3B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,UAAU,EAAE,gBAAgB,EAAE,CAAC;CAClC;AAED;;GAEG;AACH,qBAAa,WAAY,YAAW,YAAY;IAC5C,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAqB;IAKvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAM5B;gBAEU,MAAM,EAAE,iBAAiB;IAOrC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IASrE;;OAEG;IACH,OAAO,CAAC,GAAG;IA2BX;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAIjB;;;OAGG;IACH,WAAW,CAAC,SAAS,EAAE,iBAAiB,GAAG,WAAW;IAStD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAWjC"}

package/dist/logger/v2/dexto-logger.js

@@ -0,0 +1,118 @@
+import "../../chunk-C6A6W6XS.js";
+class DextoLogger {
+  level;
+  component;
+  agentId;
+  transports;
+  // Log level hierarchy for filtering
+  // Following Winston convention: lower number = more severe
+  // If level is 'debug', logs error(0), warn(1), info(2), debug(3) but not silly(4)
+  static LEVELS = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    silly: 4
+  };
+  constructor(config) {
+    this.level = config.level;
+    this.component = config.component;
+    this.agentId = config.agentId;
+    this.transports = config.transports;
+  }
+  debug(message, context) {
+    if (this.shouldLog("debug")) {
+      this.log("debug", message, context);
+    }
+  }
+  silly(message, context) {
+    if (this.shouldLog("silly")) {
+      this.log("silly", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.shouldLog("info")) {
+      this.log("info", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.shouldLog("warn")) {
+      this.log("warn", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.shouldLog("error")) {
+      this.log("error", message, context);
+    }
+  }
+  trackException(error, context) {
+    this.error(error.message, {
+      ...context,
+      errorName: error.name,
+      errorStack: error.stack,
+      errorType: error.constructor.name
+    });
+  }
+  /**
+   * Internal log method that creates log entry and sends to transports
+   */
+  log(level, message, context) {
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      component: this.component,
+      agentId: this.agentId,
+      context
+    };
+    for (const transport of this.transports) {
+      try {
+        const result = transport.write(entry);
+        if (result && typeof result === "object" && "catch" in result) {
+          result.catch((error) => {
+            console.error("Logger transport error:", error);
+          });
+        }
+      } catch (error) {
+        console.error("Logger transport error:", error);
+      }
+    }
+  }
+  /**
+   * Check if a log level should be recorded based on configured level
+   * Winston convention: log if level number <= configured level number
+   * So if configured is 'debug' (3), we log error(0), warn(1), info(2), debug(3) but not silly(4)
+   */
+  shouldLog(level) {
+    return DextoLogger.LEVELS[level] <= DextoLogger.LEVELS[this.level];
+  }
+  /**
+   * Create a child logger for a different component
+   * Shares the same transports but uses different component identifier
+   */
+  createChild(component) {
+    return new DextoLogger({
+      level: this.level,
+      component,
+      agentId: this.agentId,
+      transports: this.transports
+    });
+  }
+  /**
+   * Cleanup all transports
+   */
+  async destroy() {
+    for (const transport of this.transports) {
+      if (transport.destroy) {
+        try {
+          await transport.destroy();
+        } catch (error) {
+          console.error("Error destroying transport:", error);
+        }
+      }
+    }
+  }
+}
+export {
+  DextoLogger
+};

package/dist/{preferences → logger/v2}/error-codes.cjs

@@ -18,18 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var error_codes_exports = {};
 __export(error_codes_exports, {
-  PreferenceErrorCode: () => PreferenceErrorCode
+  LoggerErrorCode: () => LoggerErrorCode
 });
 module.exports = __toCommonJS(error_codes_exports);
-var PreferenceErrorCode = /* @__PURE__ */ ((PreferenceErrorCode2) => {
-  PreferenceErrorCode2["FILE_NOT_FOUND"] = "preference_file_not_found";
-  PreferenceErrorCode2["FILE_READ_ERROR"] = "preference_file_read_error";
-  PreferenceErrorCode2["FILE_WRITE_ERROR"] = "preference_file_write_error";
-  PreferenceErrorCode2["VALIDATION_ERROR"] = "preference_validation_error";
-  PreferenceErrorCode2["MODEL_INCOMPATIBLE"] = "preference_model_incompatible";
-  return PreferenceErrorCode2;
-})(PreferenceErrorCode || {});
+var LoggerErrorCode = /* @__PURE__ */ ((LoggerErrorCode2) => {
+  LoggerErrorCode2["TRANSPORT_NOT_IMPLEMENTED"] = "logger_transport_not_implemented";
+  LoggerErrorCode2["TRANSPORT_UNKNOWN_TYPE"] = "logger_transport_unknown_type";
+  LoggerErrorCode2["TRANSPORT_INITIALIZATION_FAILED"] = "logger_transport_initialization_failed";
+  LoggerErrorCode2["TRANSPORT_WRITE_FAILED"] = "logger_transport_write_failed";
+  LoggerErrorCode2["INVALID_CONFIG"] = "logger_invalid_config";
+  LoggerErrorCode2["INVALID_LOG_LEVEL"] = "logger_invalid_log_level";
+  return LoggerErrorCode2;
+})(LoggerErrorCode || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PreferenceErrorCode
+  LoggerErrorCode
 });

package/dist/logger/v2/error-codes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Logger-specific error codes
+ * Covers transport initialization, configuration, and logging operations
+ */
+export declare enum LoggerErrorCode {
+    TRANSPORT_NOT_IMPLEMENTED = "logger_transport_not_implemented",
+    TRANSPORT_UNKNOWN_TYPE = "logger_transport_unknown_type",
+    TRANSPORT_INITIALIZATION_FAILED = "logger_transport_initialization_failed",
+    TRANSPORT_WRITE_FAILED = "logger_transport_write_failed",
+    INVALID_CONFIG = "logger_invalid_config",
+    INVALID_LOG_LEVEL = "logger_invalid_log_level"
+}
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/logger/v2/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../../src/logger/v2/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IAEvB,yBAAyB,qCAAqC;IAC9D,sBAAsB,kCAAkC;IACxD,+BAA+B,2CAA2C;IAC1E,sBAAsB,kCAAkC;IAGxD,cAAc,0BAA0B;IACxC,iBAAiB,6BAA6B;CACjD"}

package/dist/logger/v2/error-codes.js

@@ -0,0 +1,13 @@
+import "../../chunk-C6A6W6XS.js";
+var LoggerErrorCode = /* @__PURE__ */ ((LoggerErrorCode2) => {
+  LoggerErrorCode2["TRANSPORT_NOT_IMPLEMENTED"] = "logger_transport_not_implemented";
+  LoggerErrorCode2["TRANSPORT_UNKNOWN_TYPE"] = "logger_transport_unknown_type";
+  LoggerErrorCode2["TRANSPORT_INITIALIZATION_FAILED"] = "logger_transport_initialization_failed";
+  LoggerErrorCode2["TRANSPORT_WRITE_FAILED"] = "logger_transport_write_failed";
+  LoggerErrorCode2["INVALID_CONFIG"] = "logger_invalid_config";
+  LoggerErrorCode2["INVALID_LOG_LEVEL"] = "logger_invalid_log_level";
+  return LoggerErrorCode2;
+})(LoggerErrorCode || {});
+export {
+  LoggerErrorCode
+};

package/dist/logger/v2/errors.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  LoggerError: () => LoggerError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_types = require("../../errors/types.js");
+var import_error_codes = require("./error-codes.js");
+class LoggerError {
+  /**
+   * Transport not yet implemented
+   */
+  static transportNotImplemented(transportType, availableTransports) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LoggerErrorCode.TRANSPORT_NOT_IMPLEMENTED,
+      import_types.ErrorScope.LOGGER,
+      import_types.ErrorType.USER,
+      `${transportType} transport not yet implemented. Available transports: ${availableTransports.join(", ")}`,
+      { transportType, availableTransports }
+    );
+  }
+  /**
+   * Unknown transport type
+   */
+  static unknownTransportType(transportType) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LoggerErrorCode.TRANSPORT_UNKNOWN_TYPE,
+      import_types.ErrorScope.LOGGER,
+      import_types.ErrorType.USER,
+      `Unknown transport type: ${transportType}`,
+      { transportType }
+    );
+  }
+  /**
+   * Transport initialization failed
+   */
+  static transportInitializationFailed(transportType, reason, details) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LoggerErrorCode.TRANSPORT_INITIALIZATION_FAILED,
+      import_types.ErrorScope.LOGGER,
+      import_types.ErrorType.SYSTEM,
+      `Failed to initialize ${transportType} transport: ${reason}`,
+      { transportType, reason, ...details ?? {} }
+    );
+  }
+  /**
+   * Transport write operation failed
+   */
+  static transportWriteFailed(transportType, error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LoggerErrorCode.TRANSPORT_WRITE_FAILED,
+      import_types.ErrorScope.LOGGER,
+      import_types.ErrorType.SYSTEM,
+      `Transport write failed for ${transportType}`,
+      {
+        transportType,
+        originalError: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+  /**
+   * Invalid logger configuration
+   */
+  static invalidConfig(message, context) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LoggerErrorCode.INVALID_CONFIG,
+      import_types.ErrorScope.LOGGER,
+      import_types.ErrorType.USER,
+      `Invalid logger configuration: ${message}`,
+      context
+    );
+  }
+  /**
+   * Invalid log level
+   */
+  static invalidLogLevel(level, validLevels) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LoggerErrorCode.INVALID_LOG_LEVEL,
+      import_types.ErrorScope.LOGGER,
+      import_types.ErrorType.USER,
+      `Invalid log level '${level}'. Valid levels: ${validLevels.join(", ")}`,
+      { level, validLevels }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoggerError
+});

package/dist/logger/v2/errors.d.ts

@@ -0,0 +1,32 @@
+import { DextoRuntimeError } from '../../errors/DextoRuntimeError.js';
+/**
+ * Logger error factory with typed methods for creating logger-specific errors
+ * Each method creates a properly typed error with LOGGER scope
+ */
+export declare class LoggerError {
+    /**
+     * Transport not yet implemented
+     */
+    static transportNotImplemented(transportType: string, availableTransports: string[]): DextoRuntimeError;
+    /**
+     * Unknown transport type
+     */
+    static unknownTransportType(transportType: string): DextoRuntimeError;
+    /**
+     * Transport initialization failed
+     */
+    static transportInitializationFailed(transportType: string, reason: string, details?: Record<string, unknown>): DextoRuntimeError;
+    /**
+     * Transport write operation failed
+     */
+    static transportWriteFailed(transportType: string, error: unknown): DextoRuntimeError;
+    /**
+     * Invalid logger configuration
+     */
+    static invalidConfig(message: string, context?: Record<string, unknown>): DextoRuntimeError;
+    /**
+     * Invalid log level
+     */
+    static invalidLogLevel(level: string, validLevels: string[]): DextoRuntimeError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/logger/v2/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/logger/v2/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAItE;;;GAGG;AACH,qBAAa,WAAW;IACpB;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAC1B,aAAa,EAAE,MAAM,EACrB,mBAAmB,EAAE,MAAM,EAAE,GAC9B,iBAAiB;IAUpB;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,iBAAiB;IAUrE;;OAEG;IACH,MAAM,CAAC,6BAA6B,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,iBAAiB;IAUpB;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,iBAAiB;IAarF;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,iBAAiB;IAU3F;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,iBAAiB;CASlF"}

package/dist/logger/v2/errors.js

@@ -0,0 +1,84 @@
+import "../../chunk-C6A6W6XS.js";
+import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
+import { ErrorScope, ErrorType } from "../../errors/types.js";
+import { LoggerErrorCode } from "./error-codes.js";
+class LoggerError {
+  /**
+   * Transport not yet implemented
+   */
+  static transportNotImplemented(transportType, availableTransports) {
+    return new DextoRuntimeError(
+      LoggerErrorCode.TRANSPORT_NOT_IMPLEMENTED,
+      ErrorScope.LOGGER,
+      ErrorType.USER,
+      `${transportType} transport not yet implemented. Available transports: ${availableTransports.join(", ")}`,
+      { transportType, availableTransports }
+    );
+  }
+  /**
+   * Unknown transport type
+   */
+  static unknownTransportType(transportType) {
+    return new DextoRuntimeError(
+      LoggerErrorCode.TRANSPORT_UNKNOWN_TYPE,
+      ErrorScope.LOGGER,
+      ErrorType.USER,
+      `Unknown transport type: ${transportType}`,
+      { transportType }
+    );
+  }
+  /**
+   * Transport initialization failed
+   */
+  static transportInitializationFailed(transportType, reason, details) {
+    return new DextoRuntimeError(
+      LoggerErrorCode.TRANSPORT_INITIALIZATION_FAILED,
+      ErrorScope.LOGGER,
+      ErrorType.SYSTEM,
+      `Failed to initialize ${transportType} transport: ${reason}`,
+      { transportType, reason, ...details ?? {} }
+    );
+  }
+  /**
+   * Transport write operation failed
+   */
+  static transportWriteFailed(transportType, error) {
+    return new DextoRuntimeError(
+      LoggerErrorCode.TRANSPORT_WRITE_FAILED,
+      ErrorScope.LOGGER,
+      ErrorType.SYSTEM,
+      `Transport write failed for ${transportType}`,
+      {
+        transportType,
+        originalError: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+  /**
+   * Invalid logger configuration
+   */
+  static invalidConfig(message, context) {
+    return new DextoRuntimeError(
+      LoggerErrorCode.INVALID_CONFIG,
+      ErrorScope.LOGGER,
+      ErrorType.USER,
+      `Invalid logger configuration: ${message}`,
+      context
+    );
+  }
+  /**
+   * Invalid log level
+   */
+  static invalidLogLevel(level, validLevels) {
+    return new DextoRuntimeError(
+      LoggerErrorCode.INVALID_LOG_LEVEL,
+      ErrorScope.LOGGER,
+      ErrorType.USER,
+      `Invalid log level '${level}'. Valid levels: ${validLevels.join(", ")}`,
+      { level, validLevels }
+    );
+  }
+}
+export {
+  LoggerError
+};

package/dist/logger/v2/schemas.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  LoggerConfigSchema: () => LoggerConfigSchema,
+  LoggerTransportSchema: () => LoggerTransportSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const ConsoleTransportSchema = import_zod.z.object({
+  type: import_zod.z.literal("console"),
+  colorize: import_zod.z.boolean().default(true).describe("Enable colored output")
+}).strict().describe("Console transport for terminal output");
+const FileTransportSchema = import_zod.z.object({
+  type: import_zod.z.literal("file"),
+  path: import_zod.z.string().describe("Absolute path to log file"),
+  maxSize: import_zod.z.number().positive().default(10 * 1024 * 1024).describe("Max file size in bytes before rotation (default: 10MB)"),
+  maxFiles: import_zod.z.number().int().positive().default(5).describe("Max number of rotated files to keep (default: 5)")
+}).strict().describe("File transport with rotation support");
+const UpstashTransportSchema = import_zod.z.object({
+  type: import_zod.z.literal("upstash"),
+  url: import_zod.z.string().url().describe("Upstash Redis REST URL"),
+  token: import_zod.z.string().describe("Upstash Redis REST token"),
+  listName: import_zod.z.string().default("dexto-logs").describe("Redis list name for log entries"),
+  maxListLength: import_zod.z.number().int().positive().default(1e4).describe("Max entries in Redis list (default: 10000)"),
+  batchSize: import_zod.z.number().int().positive().default(100).describe("Number of log entries to batch before sending (default: 100)")
+}).strict().describe("Upstash Redis transport for remote logging");
+const LoggerTransportSchema = import_zod.z.discriminatedUnion("type", [
+  ConsoleTransportSchema,
+  FileTransportSchema,
+  UpstashTransportSchema
+]);
+const LoggerConfigSchema = import_zod.z.object({
+  level: import_zod.z.enum(["debug", "info", "warn", "error", "silly"]).default("info").describe("Minimum log level to record"),
+  transports: import_zod.z.array(LoggerTransportSchema).min(1).default([{ type: "console", colorize: true }]).describe("Log output destinations")
+}).strict().describe("Logger configuration with multi-transport support");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoggerConfigSchema,
+  LoggerTransportSchema
+});