@dexto/core 1.2.4 → 1.2.6

package/dist/storage/blob/memory-blob-store.js

@@ -0,0 +1,303 @@
+import "../../chunk-C6A6W6XS.js";
+import { createHash } from "crypto";
+import { Readable } from "stream";
+import { DextoLogComponent } from "../../logger/v2/types.js";
+import { StorageError } from "../errors.js";
+class InMemoryBlobStore {
+  config;
+  blobs = /* @__PURE__ */ new Map();
+  connected = false;
+  logger;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
+  }
+  async connect() {
+    if (this.connected) return;
+    this.connected = true;
+    this.logger.debug("InMemoryBlobStore connected");
+  }
+  async disconnect() {
+    this.blobs.clear();
+    this.connected = false;
+    this.logger.debug("InMemoryBlobStore disconnected");
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async store(input, metadata = {}) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const buffer = await this.inputToBuffer(input);
+    if (buffer.length > this.config.maxBlobSize) {
+      throw StorageError.blobSizeExceeded(buffer.length, this.config.maxBlobSize);
+    }
+    const hash = createHash("sha256").update(buffer).digest("hex").substring(0, 16);
+    const id = hash;
+    const existing = this.blobs.get(id);
+    if (existing) {
+      this.logger.debug(
+        `Blob ${id} already exists, returning existing reference (deduplication)`
+      );
+      return {
+        id,
+        uri: `blob:${id}`,
+        metadata: existing.metadata
+      };
+    }
+    const currentSize = this.getTotalSize();
+    if (currentSize + buffer.length > this.config.maxTotalSize) {
+      throw StorageError.blobTotalSizeExceeded(
+        currentSize + buffer.length,
+        this.config.maxTotalSize
+      );
+    }
+    const storedMetadata = {
+      id,
+      mimeType: metadata.mimeType || this.detectMimeType(buffer, metadata.originalName),
+      originalName: metadata.originalName,
+      createdAt: metadata.createdAt || /* @__PURE__ */ new Date(),
+      source: metadata.source || "system",
+      size: buffer.length,
+      hash
+    };
+    this.blobs.set(id, { data: buffer, metadata: storedMetadata });
+    this.logger.debug(`Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`);
+    return {
+      id,
+      uri: `blob:${id}`,
+      metadata: storedMetadata
+    };
+  }
+  async retrieve(reference, format = "base64") {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    const blob = this.blobs.get(id);
+    if (!blob) {
+      throw StorageError.blobNotFound(reference);
+    }
+    switch (format) {
+      case "base64":
+        return {
+          format: "base64",
+          data: blob.data.toString("base64"),
+          metadata: blob.metadata
+        };
+      case "buffer":
+        return {
+          format: "buffer",
+          data: Buffer.from(blob.data),
+          metadata: { ...blob.metadata }
+        };
+      case "path":
+        throw new Error(
+          "Path format not supported for in-memory blobs. Use local blob storage for filesystem paths."
+        );
+      case "stream": {
+        const stream = Readable.from(blob.data);
+        return {
+          format: "stream",
+          data: stream,
+          metadata: blob.metadata
+        };
+      }
+      case "url": {
+        const base64 = blob.data.toString("base64");
+        const mimeType = blob.metadata.mimeType || "application/octet-stream";
+        const dataUrl = `data:${mimeType};base64,${base64}`;
+        return {
+          format: "url",
+          data: dataUrl,
+          metadata: blob.metadata
+        };
+      }
+      default:
+        throw StorageError.blobInvalidInput(format, `Unsupported format: ${format}`);
+    }
+  }
+  async exists(reference) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    return this.blobs.has(id);
+  }
+  async delete(reference) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    if (!this.blobs.has(id)) {
+      throw StorageError.blobNotFound(reference);
+    }
+    this.blobs.delete(id);
+    this.logger.debug(`Deleted blob: ${id}`);
+  }
+  async cleanup(olderThan) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const cutoffDate = olderThan || new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
+    let deletedCount = 0;
+    for (const [id, { metadata }] of this.blobs.entries()) {
+      if (metadata.createdAt < cutoffDate) {
+        this.blobs.delete(id);
+        deletedCount++;
+        this.logger.debug(`Cleaned up old blob: ${id}`);
+      }
+    }
+    if (deletedCount > 0) {
+      this.logger.info(`Blob cleanup: removed ${deletedCount} old blobs from memory`);
+    }
+    return deletedCount;
+  }
+  async getStats() {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    return {
+      count: this.blobs.size,
+      totalSize: this.getTotalSize(),
+      backendType: "in-memory",
+      storePath: "memory://"
+    };
+  }
+  async listBlobs() {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    return Array.from(this.blobs.entries()).map(([id, { metadata }]) => ({
+      id,
+      uri: `blob:${id}`,
+      metadata
+    }));
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  /**
+   * Calculate total size of all blobs in memory
+   */
+  getTotalSize() {
+    return Array.from(this.blobs.values()).reduce((sum, { data }) => sum + data.length, 0);
+  }
+  /**
+   * Convert various input types to Buffer.
+   * Copied from LocalBlobStore with minor adaptations.
+   */
+  async inputToBuffer(input) {
+    if (Buffer.isBuffer(input)) {
+      return input;
+    }
+    if (input instanceof Uint8Array) {
+      return Buffer.from(input);
+    }
+    if (input instanceof ArrayBuffer) {
+      return Buffer.from(new Uint8Array(input));
+    }
+    if (typeof input === "string") {
+      if (input.startsWith("data:")) {
+        const commaIndex = input.indexOf(",");
+        if (commaIndex !== -1 && input.includes(";base64,")) {
+          const base64Data = input.substring(commaIndex + 1);
+          return Buffer.from(base64Data, "base64");
+        }
+        throw StorageError.blobEncodingError(
+          "inputToBuffer",
+          "Unsupported data URI format"
+        );
+      }
+      try {
+        return Buffer.from(input, "base64");
+      } catch {
+        throw StorageError.blobEncodingError("inputToBuffer", "Invalid base64 string");
+      }
+    }
+    throw StorageError.blobInvalidInput(input, `Unsupported input type: ${typeof input}`);
+  }
+  /**
+   * Parse blob reference to extract ID.
+   * Copied from LocalBlobStore.
+   */
+  parseReference(reference) {
+    if (!reference) {
+      throw StorageError.blobInvalidReference(reference, "Empty reference");
+    }
+    if (reference.startsWith("blob:")) {
+      const id = reference.substring(5);
+      if (!id) {
+        throw StorageError.blobInvalidReference(reference, "Empty blob ID after prefix");
+      }
+      return id;
+    }
+    return reference;
+  }
+  /**
+   * Detect MIME type from buffer content and/or filename.
+   * Copied from LocalBlobStore.
+   */
+  detectMimeType(buffer, filename) {
+    const header = buffer.subarray(0, 16);
+    if (header.length >= 3) {
+      const jpegSignature = header.subarray(0, 3);
+      if (jpegSignature.equals(Buffer.from([255, 216, 255]))) {
+        return "image/jpeg";
+      }
+    }
+    if (header.length >= 4) {
+      const signature = header.subarray(0, 4);
+      if (signature.equals(Buffer.from([137, 80, 78, 71]))) return "image/png";
+      if (signature.equals(Buffer.from([71, 73, 70, 56]))) return "image/gif";
+      if (signature.equals(Buffer.from([37, 80, 68, 70]))) return "application/pdf";
+    }
+    if (filename) {
+      const ext = filename.split(".").pop()?.toLowerCase();
+      const mimeTypes = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        pdf: "application/pdf",
+        txt: "text/plain",
+        json: "application/json",
+        xml: "text/xml",
+        html: "text/html",
+        css: "text/css",
+        js: "text/javascript",
+        md: "text/markdown",
+        mp3: "audio/mpeg",
+        mp4: "video/mp4",
+        wav: "audio/wav"
+      };
+      if (ext && mimeTypes[ext]) return mimeTypes[ext];
+    }
+    if (this.isTextBuffer(buffer)) {
+      return "text/plain";
+    }
+    return "application/octet-stream";
+  }
+  /**
+   * Check if buffer contains text content.
+   * Copied from LocalBlobStore.
+   */
+  isTextBuffer(buffer) {
+    let printableCount = 0;
+    const sampleSize = Math.min(512, buffer.length);
+    for (let i = 0; i < sampleSize; i++) {
+      const byte = buffer[i];
+      if (byte !== void 0 && (byte >= 32 && byte <= 126 || byte === 9 || byte === 10 || byte === 13)) {
+        printableCount++;
+      }
+    }
+    return printableCount / sampleSize > 0.7;
+  }
+}
+export {
+  InMemoryBlobStore
+};

package/dist/storage/blob/schemas.cjs

@@ -31,7 +31,9 @@ const InMemoryBlobStoreSchema = import_zod.z.object({
 }).strict();
 const LocalBlobStoreSchema = import_zod.z.object({
   type: import_zod.z.literal("local").describe("Blob store type identifier"),
-  storePath: import_zod.z.string().optional().describe("Custom storage path (defaults to context-aware path)"),
+  storePath: import_zod.z.string().describe(
+    "Blob storage directory path (required for local storage - CLI enrichment provides per-agent default)"
+  ),
   maxBlobSize: import_zod.z.number().int().positive().optional().default(50 * 1024 * 1024).describe("Maximum size per blob in bytes"),
   maxTotalSize: import_zod.z.number().int().positive().optional().default(1024 * 1024 * 1024).describe("Maximum total storage size in bytes"),
   cleanupAfterDays: import_zod.z.number().int().positive().optional().default(30).describe("Auto-cleanup blobs older than N days")

package/dist/storage/blob/schemas.d.ts

@@ -23,7 +23,7 @@ export type InMemoryBlobStoreConfig = z.output<typeof InMemoryBlobStoreSchema>;
  */
 declare const LocalBlobStoreSchema: z.ZodObject<{
     type: z.ZodLiteral<"local">;
-    storePath: z.ZodOptional<z.ZodString>;
+    storePath: z.ZodString;
     maxBlobSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     maxTotalSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     cleanupAfterDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -31,13 +31,13 @@ declare const LocalBlobStoreSchema: z.ZodObject<{
     type: "local";
     maxBlobSize: number;
     maxTotalSize: number;
+    storePath: string;
     cleanupAfterDays: number;
-    storePath?: string | undefined;
 }, {
     type: "local";
+    storePath: string;
     maxBlobSize?: number | undefined;
     maxTotalSize?: number | undefined;
-    storePath?: string | undefined;
     cleanupAfterDays?: number | undefined;
 }>;
 export type LocalBlobStoreConfig = z.output<typeof LocalBlobStoreSchema>;
@@ -58,7 +58,7 @@ export declare const BlobStoreConfigSchema: z.ZodDiscriminatedUnion<"type", [z.Z
     maxTotalSize?: number | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"local">;
-    storePath: z.ZodOptional<z.ZodString>;
+    storePath: z.ZodString;
     maxBlobSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     maxTotalSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     cleanupAfterDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -66,13 +66,13 @@ export declare const BlobStoreConfigSchema: z.ZodDiscriminatedUnion<"type", [z.Z
     type: "local";
     maxBlobSize: number;
     maxTotalSize: number;
+    storePath: string;
     cleanupAfterDays: number;
-    storePath?: string | undefined;
 }, {
     type: "local";
+    storePath: string;
     maxBlobSize?: number | undefined;
     maxTotalSize?: number | undefined;
-    storePath?: string | undefined;
     cleanupAfterDays?: number | undefined;
 }>]>;
 export type BlobStoreConfig = z.output<typeof BlobStoreConfigSchema>;

package/dist/storage/blob/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,iCAAkC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;EAkBhB,CAAC;AAEd,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA6Bb,CAAC;AAEd,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWO,CAAC;AAE1C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,iCAAkC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;EAkBhB,CAAC;AAEd,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AAEd,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWO,CAAC;AAE1C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/storage/blob/schemas.js

@@ -8,7 +8,9 @@ const InMemoryBlobStoreSchema = z.object({
 }).strict();
 const LocalBlobStoreSchema = z.object({
   type: z.literal("local").describe("Blob store type identifier"),
-  storePath: z.string().optional().describe("Custom storage path (defaults to context-aware path)"),
+  storePath: z.string().describe(
+    "Blob storage directory path (required for local storage - CLI enrichment provides per-agent default)"
+  ),
   maxBlobSize: z.number().int().positive().optional().default(50 * 1024 * 1024).describe("Maximum size per blob in bytes"),
   maxTotalSize: z.number().int().positive().optional().default(1024 * 1024 * 1024).describe("Maximum total storage size in bytes"),
   cleanupAfterDays: z.number().int().positive().optional().default(30).describe("Auto-cleanup blobs older than N days")

package/dist/storage/cache/factory.cjs

@@ -32,28 +32,27 @@ __export(factory_exports, {
 });
 module.exports = __toCommonJS(factory_exports);
 var import_memory_cache_store = require("./memory-cache-store.js");
-var import_logger = require("../../logger/index.js");
 let RedisStore = null;
-async function createCache(config) {
+async function createCache(config, logger) {
   switch (config.type) {
     case "redis":
-      return createRedisStore(config);
+      return createRedisStore(config, logger);
     case "in-memory":
     default:
-      import_logger.logger.info("Using in-memory cache store");
+      logger.info("Using in-memory cache store");
       return new import_memory_cache_store.MemoryCacheStore();
   }
 }
-async function createRedisStore(config) {
+async function createRedisStore(config, logger) {
   try {
     if (!RedisStore) {
       const module2 = await import("./redis-store.js");
       RedisStore = module2.RedisStore;
     }
-    import_logger.logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
-    return new RedisStore(config);
+    logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
+    return new RedisStore(config, logger);
   } catch (error) {
-    import_logger.logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
+    logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
     return new import_memory_cache_store.MemoryCacheStore();
   }
 }

package/dist/storage/cache/factory.d.ts

@@ -1,8 +1,11 @@
 import type { Cache } from './types.js';
 import type { CacheConfig } from '../schemas.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Create a cache store based on configuration.
  * Handles lazy loading of optional dependencies with automatic fallback.
+ * @param config Cache configuration
+ * @param logger Logger instance for logging
  */
-export declare function createCache(config: CacheConfig): Promise<Cache>;
+export declare function createCache(config: CacheConfig, logger: IDextoLogger): Promise<Cache>;
 //# sourceMappingURL=factory.d.ts.map

package/dist/storage/cache/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,eAAe,CAAC;AAYnE;;;GAGG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAUrE"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,eAAe,CAAC;AAEnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAU7D;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,CAU3F"}

package/dist/storage/cache/factory.js

@@ -1,25 +1,24 @@
 import "../../chunk-C6A6W6XS.js";
 import { MemoryCacheStore } from "./memory-cache-store.js";
-import { logger } from "../../logger/index.js";
 let RedisStore = null;
-async function createCache(config) {
+async function createCache(config, logger) {
   switch (config.type) {
     case "redis":
-      return createRedisStore(config);
+      return createRedisStore(config, logger);
     case "in-memory":
     default:
       logger.info("Using in-memory cache store");
       return new MemoryCacheStore();
   }
 }
-async function createRedisStore(config) {
+async function createRedisStore(config, logger) {
   try {
     if (!RedisStore) {
       const module = await import("./redis-store.js");
       RedisStore = module.RedisStore;
     }
     logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
-    return new RedisStore(config);
+    return new RedisStore(config, logger);
   } catch (error) {
     logger.warn(`Redis not available, falling back to in-memory cache: ${error}`);
     return new MemoryCacheStore();

package/dist/storage/cache/redis-store.cjs

@@ -22,13 +22,16 @@ __export(redis_store_exports, {
 });
 module.exports = __toCommonJS(redis_store_exports);
 var import_ioredis = require("ioredis");
+var import_types = require("../../logger/v2/types.js");
 var import_errors = require("../errors.js");
 class RedisStore {
-  constructor(config) {
+  constructor(config, logger) {
     this.config = config;
+    this.logger = logger.createChild(import_types.DextoLogComponent.STORAGE);
   }
   redis = null;
   connected = false;
+  logger;
   async connect() {
     if (this.connected) return;
     this.redis = new import_ioredis.Redis({

package/dist/storage/cache/redis-store.d.ts

@@ -1,5 +1,6 @@
 import type { Cache } from './types.js';
 import type { RedisCacheConfig } from './schemas.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Redis cache store for production cache operations.
  * Implements the Cache interface with connection pooling and optimizations.
@@ -9,7 +10,8 @@ export declare class RedisStore implements Cache {
     private config;
     private redis;
     private connected;
-    constructor(config: RedisCacheConfig);
+    private logger;
+    constructor(config: RedisCacheConfig, logger: IDextoLogger);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;

package/dist/storage/cache/redis-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/redis-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD;;;;GAIG;AACH,qBAAa,UAAW,YAAW,KAAK;IAIxB,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAS;gBAEN,MAAM,EAAE,gBAAgB;IAEtC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;IAQnD,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7D,OAAO,CAAC,eAAe;IAOjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAKxB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAIhC"}
+{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/redis-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D;;;;GAIG;AACH,qBAAa,UAAW,YAAW,KAAK;IAMhC,OAAO,CAAC,MAAM;IALlB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAe;gBAGjB,MAAM,EAAE,gBAAgB,EAChC,MAAM,EAAE,YAAY;IAKlB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAQjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;IAQnD,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW9C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAE,MAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7D,OAAO,CAAC,eAAe;IAOjB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAKxB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAIhC"}

package/dist/storage/cache/redis-store.js

@@ -1,12 +1,15 @@
 import "../../chunk-C6A6W6XS.js";
 import { Redis } from "ioredis";
+import { DextoLogComponent } from "../../logger/v2/types.js";
 import { StorageError } from "../errors.js";
 class RedisStore {
-  constructor(config) {
+  constructor(config, logger) {
     this.config = config;
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
   }
   redis = null;
   connected = false;
+  logger;
   async connect() {
     if (this.connected) return;
     this.redis = new Redis({

package/dist/storage/database/factory.cjs

@@ -32,51 +32,48 @@ __export(factory_exports, {
 });
 module.exports = __toCommonJS(factory_exports);
 var import_memory_database_store = require("./memory-database-store.js");
-var import_logger = require("../../logger/index.js");
 let SQLiteStore = null;
 let PostgresStore = null;
-async function createDatabase(config, agentId) {
+async function createDatabase(config, logger) {
   switch (config.type) {
     case "postgres":
-      return createPostgresStore(config);
+      return createPostgresStore(config, logger);
     case "sqlite":
-      return createSQLiteStore(config, agentId);
+      return createSQLiteStore(config, logger);
     case "in-memory":
     default:
-      import_logger.logger.info("Using in-memory database store");
+      logger.info("Using in-memory database store");
       return new import_memory_database_store.MemoryDatabaseStore();
   }
 }
-async function createPostgresStore(config) {
+async function createPostgresStore(config, logger) {
   try {
     if (!PostgresStore) {
       const module2 = await import("./postgres-store.js");
       PostgresStore = module2.PostgresStore;
     }
-    import_logger.logger.info("Connecting to PostgreSQL database");
-    return new PostgresStore(config);
+    logger.info("Connecting to PostgreSQL database");
+    return new PostgresStore(config, logger);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    import_logger.logger.warn(
+    logger.warn(
       `PostgreSQL not available, falling back to in-memory database: ${errorMessage}`
     );
     return new import_memory_database_store.MemoryDatabaseStore();
   }
 }
-async function createSQLiteStore(config, agentId) {
+async function createSQLiteStore(config, logger) {
   try {
     if (!SQLiteStore) {
       const module2 = await import("./sqlite-store.js");
       SQLiteStore = module2.SQLiteStore;
     }
-    const defaultFilename = agentId ? `${agentId}.db` : "dexto.db";
-    const effectivePath = config.path || defaultFilename;
-    import_logger.logger.info(`Creating SQLite database store: ${effectivePath}`);
-    return new SQLiteStore(config, agentId);
+    logger.info(`Creating SQLite database store: ${config.path}`);
+    return new SQLiteStore(config, logger);
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));
-    import_logger.logger.error(`SQLite store failed to load: ${err.message}`, err);
-    import_logger.logger.warn("Falling back to in-memory database store");
+    logger.error(`SQLite store failed to load: ${err.message}`, { error: err.message });
+    logger.warn("Falling back to in-memory database store");
     return new import_memory_database_store.MemoryDatabaseStore();
   }
 }

package/dist/storage/database/factory.d.ts

@@ -1,10 +1,12 @@
 import type { Database } from './types.js';
 import type { DatabaseConfig } from '../schemas.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * Create a database store based on configuration.
  * Handles lazy loading of optional dependencies with automatic fallback.
- * @param config Database configuration
- * @param agentId Optional agent identifier for database naming (used for SQLite default filename)
+ * Database paths are provided via CLI enrichment layer.
+ * @param config Database configuration with explicit paths
+ * @param logger Logger instance for logging
  */
-export declare function createDatabase(config: DatabaseConfig, agentId?: string): Promise<Database>;
+export declare function createDatabase(config: DatabaseConfig, logger: IDextoLogger): Promise<Database>;
 //# sourceMappingURL=factory.d.ts.map

package/dist/storage/database/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/database/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAgD,MAAM,eAAe,CAAC;AAiBlG;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAahG"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/database/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAgD,MAAM,eAAe,CAAC;AAElG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAe7D;;;;;;GAMG;AACH,wBAAsB,cAAc,CAChC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,QAAQ,CAAC,CAanB"}