@dexto/core 1.2.3 → 1.2.5

package/dist/storage/database/sqlite-store.cjs

@@ -33,9 +33,7 @@ __export(sqlite_store_exports, {
 module.exports = __toCommonJS(sqlite_store_exports);
 var import_path = require("path");
 var import_fs = require("fs");
-var import_logger = require("../../logger/index.js");
-var import_path2 = require("../../utils/path.js");
-var path = __toESM(require("path"), 1);
+var import_types = require("../../logger/v2/types.js");
 var import_errors = require("../errors.js");
 let BetterSqlite3Database;
 class SQLiteStore {
@@ -43,36 +41,14 @@ class SQLiteStore {
   // Database.Database
   dbPath;
   config;
-  agentId;
-  constructor(config, agentId) {
+  logger;
+  constructor(config, logger) {
     this.config = config;
-    if (agentId) {
-      const trimmed = agentId.trim();
-      if (!trimmed) {
-        throw import_errors.StorageError.databaseInvalidConfig(
-          "agentId cannot be empty or whitespace-only"
-        );
-      }
-      if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
-        throw import_errors.StorageError.databaseInvalidConfig(
-          "agentId must contain only alphanumeric characters, hyphens, and underscores"
-        );
-      }
-      this.agentId = trimmed;
-    } else {
-      this.agentId = agentId;
-    }
     this.dbPath = "";
-  }
-  resolveDefaultPath(dbName) {
-    const storageDir = (0, import_path2.getDextoPath)("database");
-    const finalPath = path.join(storageDir, dbName);
-    import_logger.logger.info(`SQLite storage directory: ${storageDir}`);
-    import_logger.logger.debug(`SQLite database file: ${finalPath}`);
-    return finalPath;
+    this.logger = logger.createChild(import_types.DextoLogComponent.STORAGE);
   }
   initializeTables() {
-    import_logger.logger.debug("SQLite initializing database schema...");
+    this.logger.debug("SQLite initializing database schema...");
     try {
       this.db.exec(`
                 CREATE TABLE IF NOT EXISTS kv_store (
@@ -96,7 +72,7 @@ class SQLiteStore {
                 CREATE INDEX IF NOT EXISTS idx_list_store_key ON list_store(key);
                 CREATE INDEX IF NOT EXISTS idx_list_store_sequence ON list_store(key, sequence);
             `);
-      import_logger.logger.debug(
+      this.logger.debug(
         "SQLite database schema initialized: kv_store, list_store tables with indexes"
       );
     } catch (error) {
@@ -120,22 +96,17 @@ class SQLiteStore {
         );
       }
     }
-    if (this.config.path) {
-      this.dbPath = this.config.path;
-      import_logger.logger.info(`SQLite using custom path: ${this.dbPath}`);
-    } else {
-      const defaultFilename = this.agentId ? `${this.agentId}.db` : "dexto.db";
-      this.dbPath = this.resolveDefaultPath(this.config.database || defaultFilename);
-    }
+    this.dbPath = this.config.path;
+    this.logger.info(`SQLite using database file: ${this.dbPath}`);
     const dir = (0, import_path.dirname)(this.dbPath);
-    import_logger.logger.debug(`SQLite ensuring directory exists: ${dir}`);
+    this.logger.debug(`SQLite ensuring directory exists: ${dir}`);
     try {
       (0, import_fs.mkdirSync)(dir, { recursive: true });
     } catch (error) {
-      import_logger.logger.debug(`Directory creation result: ${error ? "exists" : "created"}`);
+      this.logger.debug(`Directory creation result: ${error ? "exists" : "created"}`);
     }
     const sqliteOptions = this.config.options || {};
-    import_logger.logger.debug(`SQLite initializing database with config:`, {
+    this.logger.debug(`SQLite initializing database with config:`, {
       readonly: sqliteOptions.readonly || false,
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3
@@ -145,16 +116,17 @@ class SQLiteStore {
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3,
       verbose: sqliteOptions.verbose ? (message, ...additionalArgs) => {
-        import_logger.logger.debug(
-          typeof message === "string" || typeof message === "object" && message !== null ? message : String(message),
-          ...additionalArgs
+        const messageStr = typeof message === "string" ? message : typeof message === "object" && message !== null ? JSON.stringify(message) : String(message);
+        this.logger.debug(
+          messageStr,
+          additionalArgs.length > 0 ? { args: additionalArgs } : void 0
         );
       } : void 0
     });
     this.db.pragma("journal_mode = WAL");
-    import_logger.logger.debug("SQLite enabled WAL mode for better concurrency");
+    this.logger.debug("SQLite enabled WAL mode for better concurrency");
     this.initializeTables();
-    import_logger.logger.info(`\u2705 SQLite store successfully connected to: ${this.dbPath}`);
+    this.logger.info(`\u2705 SQLite store successfully connected to: ${this.dbPath}`);
   }
   async disconnect() {
     if (this.db) {

package/dist/storage/database/sqlite-store.d.ts

@@ -1,4 +1,5 @@
 import type { Database } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 import type { SqliteDatabaseConfig } from './schemas.js';
 /**
  * SQLite database store for local development and production.
@@ -8,9 +9,8 @@ export declare class SQLiteStore implements Database {
     private db;
     private dbPath;
     private config;
-    private agentId;
-    constructor(config: SqliteDatabaseConfig, agentId?: string);
-    private resolveDefaultPath;
+    private logger;
+    constructor(config: SqliteDatabaseConfig, logger: IDextoLogger);
     private initializeTables;
     connect(): Promise<void>;
     disconnect(): Promise<void>;

package/dist/storage/database/sqlite-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/sqlite-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAQzD;;;GAGG;AACH,qBAAa,WAAY,YAAW,QAAQ;IACxC,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAqB;gBAExB,MAAM,EAAE,oBAAoB,EAAE,OAAO,CAAC,EAAE,MAAM;IAyB1D,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,gBAAgB;IA8ClB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoExB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAgB3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAelC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA0BvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAqB1E,OAAO,CAAC,eAAe;IAOjB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKvB,QAAQ,IAAI,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;CAqBL"}
+{"version":3,"file":"sqlite-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/sqlite-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAMzD;;;GAGG;AACH,qBAAa,WAAY,YAAW,QAAQ;IACxC,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,YAAY;IAO9D,OAAO,CAAC,gBAAgB;IA8ClB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkExB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAKhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAgB3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAelC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA0BvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAqB1E,OAAO,CAAC,eAAe;IAOjB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKvB,QAAQ,IAAI,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;CAqBL"}

package/dist/storage/database/sqlite-store.js

@@ -1,9 +1,7 @@
 import "../../chunk-C6A6W6XS.js";
 import { dirname } from "path";
 import { mkdirSync } from "fs";
-import { logger } from "../../logger/index.js";
-import { getDextoPath } from "../../utils/path.js";
-import * as path from "path";
+import { DextoLogComponent } from "../../logger/v2/types.js";
 import { StorageError } from "../errors.js";
 let BetterSqlite3Database;
 class SQLiteStore {
@@ -11,36 +9,14 @@ class SQLiteStore {
   // Database.Database
   dbPath;
   config;
-  agentId;
-  constructor(config, agentId) {
+  logger;
+  constructor(config, logger) {
     this.config = config;
-    if (agentId) {
-      const trimmed = agentId.trim();
-      if (!trimmed) {
-        throw StorageError.databaseInvalidConfig(
-          "agentId cannot be empty or whitespace-only"
-        );
-      }
-      if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
-        throw StorageError.databaseInvalidConfig(
-          "agentId must contain only alphanumeric characters, hyphens, and underscores"
-        );
-      }
-      this.agentId = trimmed;
-    } else {
-      this.agentId = agentId;
-    }
     this.dbPath = "";
-  }
-  resolveDefaultPath(dbName) {
-    const storageDir = getDextoPath("database");
-    const finalPath = path.join(storageDir, dbName);
-    logger.info(`SQLite storage directory: ${storageDir}`);
-    logger.debug(`SQLite database file: ${finalPath}`);
-    return finalPath;
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
   }
   initializeTables() {
-    logger.debug("SQLite initializing database schema...");
+    this.logger.debug("SQLite initializing database schema...");
     try {
       this.db.exec(`
                 CREATE TABLE IF NOT EXISTS kv_store (
@@ -64,7 +40,7 @@ class SQLiteStore {
                 CREATE INDEX IF NOT EXISTS idx_list_store_key ON list_store(key);
                 CREATE INDEX IF NOT EXISTS idx_list_store_sequence ON list_store(key, sequence);
             `);
-      logger.debug(
+      this.logger.debug(
         "SQLite database schema initialized: kv_store, list_store tables with indexes"
       );
     } catch (error) {
@@ -88,22 +64,17 @@ class SQLiteStore {
         );
       }
     }
-    if (this.config.path) {
-      this.dbPath = this.config.path;
-      logger.info(`SQLite using custom path: ${this.dbPath}`);
-    } else {
-      const defaultFilename = this.agentId ? `${this.agentId}.db` : "dexto.db";
-      this.dbPath = this.resolveDefaultPath(this.config.database || defaultFilename);
-    }
+    this.dbPath = this.config.path;
+    this.logger.info(`SQLite using database file: ${this.dbPath}`);
     const dir = dirname(this.dbPath);
-    logger.debug(`SQLite ensuring directory exists: ${dir}`);
+    this.logger.debug(`SQLite ensuring directory exists: ${dir}`);
     try {
       mkdirSync(dir, { recursive: true });
     } catch (error) {
-      logger.debug(`Directory creation result: ${error ? "exists" : "created"}`);
+      this.logger.debug(`Directory creation result: ${error ? "exists" : "created"}`);
     }
     const sqliteOptions = this.config.options || {};
-    logger.debug(`SQLite initializing database with config:`, {
+    this.logger.debug(`SQLite initializing database with config:`, {
       readonly: sqliteOptions.readonly || false,
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3
@@ -113,16 +84,17 @@ class SQLiteStore {
       fileMustExist: sqliteOptions.fileMustExist || false,
       timeout: sqliteOptions.timeout || 5e3,
       verbose: sqliteOptions.verbose ? (message, ...additionalArgs) => {
-        logger.debug(
-          typeof message === "string" || typeof message === "object" && message !== null ? message : String(message),
-          ...additionalArgs
+        const messageStr = typeof message === "string" ? message : typeof message === "object" && message !== null ? JSON.stringify(message) : String(message);
+        this.logger.debug(
+          messageStr,
+          additionalArgs.length > 0 ? { args: additionalArgs } : void 0
         );
       } : void 0
     });
     this.db.pragma("journal_mode = WAL");
-    logger.debug("SQLite enabled WAL mode for better concurrency");
+    this.logger.debug("SQLite enabled WAL mode for better concurrency");
     this.initializeTables();
-    logger.info(`\u2705 SQLite store successfully connected to: ${this.dbPath}`);
+    this.logger.info(`\u2705 SQLite store successfully connected to: ${this.dbPath}`);
   }
   async disconnect() {
     if (this.db) {

package/dist/storage/schemas.cjs

@@ -37,7 +37,9 @@ var import_schemas6 = require("./blob/schemas.js");
 const StorageSchema = import_zod.z.object({
   cache: import_schemas4.CacheConfigSchema.describe("Cache configuration (fast, ephemeral)"),
   database: import_schemas5.DatabaseConfigSchema.describe("Database configuration (persistent, reliable)"),
-  blob: import_schemas6.BlobStoreConfigSchema.optional().default({ type: "local" }).describe("Blob store configuration (for large, unstructured data)")
+  blob: import_schemas6.BlobStoreConfigSchema.describe(
+    "Blob store configuration (for large, unstructured data)"
+  )
 }).strict().describe("Storage configuration with cache, database, and blob store").brand();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/storage/schemas.d.ts

@@ -121,24 +121,21 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     } & {
         type: z.ZodLiteral<"sqlite">;
-        path: z.ZodOptional<z.ZodString>;
-        database: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
     }, "strict", z.ZodTypeAny, {
+        path: string;
         type: "sqlite";
-        path?: string | undefined;
         options?: Record<string, any> | undefined;
         maxConnections?: number | undefined;
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
-        database?: string | undefined;
     }, {
+        path: string;
         type: "sqlite";
-        path?: string | undefined;
         options?: Record<string, any> | undefined;
         maxConnections?: number | undefined;
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
-        database?: string | undefined;
     }>, z.ZodObject<{
         maxConnections: z.ZodOptional<z.ZodNumber>;
         idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
@@ -183,13 +180,12 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
     } | {
+        path: string;
         type: "sqlite";
-        path?: string | undefined;
         options?: Record<string, any> | undefined;
         maxConnections?: number | undefined;
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
-        database?: string | undefined;
     } | {
         type: "postgres";
         password?: string | undefined;
@@ -209,13 +205,12 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
     } | {
+        path: string;
         type: "sqlite";
-        path?: string | undefined;
         options?: Record<string, any> | undefined;
         maxConnections?: number | undefined;
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
-        database?: string | undefined;
     } | {
         type: "postgres";
         password?: string | undefined;
@@ -229,7 +224,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         database?: string | undefined;
         connectionString?: string | undefined;
     }>;
-    blob: z.ZodDefault<z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    blob: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"in-memory">;
         maxBlobSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         maxTotalSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -243,7 +238,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         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>>;
@@ -251,15 +246,15 @@ export declare const StorageSchema: z.ZodBranded<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;
-    }>]>>>;
+    }>]>;
 }, "strict", z.ZodTypeAny, {
     database: {
         type: "in-memory";
@@ -268,13 +263,12 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
     } | {
+        path: string;
         type: "sqlite";
-        path?: string | undefined;
         options?: Record<string, any> | undefined;
         maxConnections?: number | undefined;
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
-        database?: string | undefined;
     } | {
         type: "postgres";
         password?: string | undefined;
@@ -314,8 +308,8 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         type: "local";
         maxBlobSize: number;
         maxTotalSize: number;
+        storePath: string;
         cleanupAfterDays: number;
-        storePath?: string | undefined;
     };
 }, {
     database: {
@@ -325,13 +319,12 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
     } | {
+        path: string;
         type: "sqlite";
-        path?: string | undefined;
         options?: Record<string, any> | undefined;
         maxConnections?: number | undefined;
         idleTimeoutMillis?: number | undefined;
         connectionTimeoutMillis?: number | undefined;
-        database?: string | undefined;
     } | {
         type: "postgres";
         password?: string | undefined;
@@ -363,17 +356,17 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: number | undefined;
     };
-    blob?: {
+    blob: {
         type: "in-memory";
         maxBlobSize?: number | undefined;
         maxTotalSize?: number | undefined;
     } | {
         type: "local";
+        storePath: string;
         maxBlobSize?: number | undefined;
         maxTotalSize?: number | undefined;
-        storePath?: string | undefined;
         cleanupAfterDays?: number | undefined;
-    } | undefined;
+    };
 }>, "ValidatedStorageConfig">;
 export type StorageConfig = z.input<typeof StorageSchema>;
 export type ValidatedStorageConfig = z.output<typeof StorageSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/storage/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/storage/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/storage/schemas.js

@@ -18,7 +18,9 @@ import { BlobStoreConfigSchema as BlobStoreConfigSchema2 } from "./blob/schemas.
 const StorageSchema = z.object({
   cache: CacheConfigSchema2.describe("Cache configuration (fast, ephemeral)"),
   database: DatabaseConfigSchema2.describe("Database configuration (persistent, reliable)"),
-  blob: BlobStoreConfigSchema2.optional().default({ type: "local" }).describe("Blob store configuration (for large, unstructured data)")
+  blob: BlobStoreConfigSchema2.describe(
+    "Blob store configuration (for large, unstructured data)"
+  )
 }).strict().describe("Storage configuration with cache, database, and blob store").brand();
 export {
   BLOB_STORE_TYPES,

package/dist/storage/storage-manager.cjs

@@ -26,7 +26,7 @@ var import_factory = require("./cache/factory.js");
 var import_factory2 = require("./database/factory.js");
 var import_factory3 = require("./blob/factory.js");
 var import_errors = require("./errors.js");
-var import_logger = require("../logger/index.js");
+var import_types = require("../logger/v2/types.js");
 const HEALTH_CHECK_KEY = "storage_manager_health_check";
 class StorageManager {
   config;
@@ -35,10 +35,10 @@ class StorageManager {
   blobStore;
   initialized = false;
   connected = false;
-  agentId;
-  constructor(config, agentId) {
+  logger;
+  constructor(config, logger) {
     this.config = config;
-    this.agentId = agentId;
+    this.logger = logger.createChild(import_types.DextoLogComponent.STORAGE);
   }
   /**
    * Initialize storage instances without connecting.
@@ -48,9 +48,9 @@ class StorageManager {
     if (this.initialized) {
       return;
     }
-    this.cache = await (0, import_factory.createCache)(this.config.cache);
-    this.database = await (0, import_factory2.createDatabase)(this.config.database, this.agentId);
-    this.blobStore = (0, import_factory3.createBlobStore)(this.config.blob, this.agentId);
+    this.cache = await (0, import_factory.createCache)(this.config.cache, this.logger);
+    this.database = await (0, import_factory2.createDatabase)(this.config.database, this.logger);
+    this.blobStore = (0, import_factory3.createBlobStore)(this.config.blob, this.logger);
     this.initialized = true;
   }
   /**
@@ -74,7 +74,7 @@ class StorageManager {
       connected.push("blob");
       this.connected = true;
     } catch (error) {
-      import_logger.logger.warn(
+      this.logger.warn(
         `Storage connection failed, rolling back ${connected.length} connected stores`
       );
       for (const store of connected.reverse()) {
@@ -83,7 +83,7 @@ class StorageManager {
           else if (store === "database") await this.database.disconnect();
           else if (store === "blob") await this.blobStore.disconnect();
         } catch (disconnectError) {
-          import_logger.logger.error(
+          this.logger.error(
             `Failed to rollback ${store} during connection failure: ${disconnectError}`
           );
         }
@@ -104,7 +104,7 @@ class StorageManager {
       if (result.status === "rejected") {
         const storeName = storeNames[index];
         const error = result.reason;
-        import_logger.logger.error(`Failed to disconnect ${storeName}: ${error}`);
+        this.logger.error(`Failed to disconnect ${storeName}: ${error}`);
         errors.push(error instanceof Error ? error : new Error(String(error)));
       }
     });
@@ -185,7 +185,7 @@ class StorageManager {
         await this.cache.delete(HEALTH_CHECK_KEY);
       }
     } catch (error) {
-      import_logger.logger.warn(`Cache health check failed: ${error}`);
+      this.logger.warn(`Cache health check failed: ${error}`);
     }
     try {
       if (this.database.isConnected()) {
@@ -195,14 +195,14 @@ class StorageManager {
         await this.database.delete(HEALTH_CHECK_KEY);
       }
     } catch (error) {
-      import_logger.logger.warn(`Database health check failed: ${error}`);
+      this.logger.warn(`Database health check failed: ${error}`);
     }
     try {
       if (this.blobStore.isConnected()) {
         blobHealthy = this.blobStore.isConnected();
       }
     } catch (error) {
-      import_logger.logger.warn(`Blob store health check failed: ${error}`);
+      this.logger.warn(`Blob store health check failed: ${error}`);
     }
     return {
       cache: cacheHealthy,
@@ -212,8 +212,8 @@ class StorageManager {
     };
   }
 }
-async function createStorageManager(config, agentId) {
-  const manager = new StorageManager(config, agentId);
+async function createStorageManager(config, logger) {
+  const manager = new StorageManager(config, logger);
   await manager.initialize();
   await manager.connect();
   return manager;

package/dist/storage/storage-manager.d.ts

@@ -2,6 +2,7 @@ import type { Cache } from './cache/types.js';
 import type { Database } from './database/types.js';
 import type { BlobStore } from './blob/types.js';
 import type { ValidatedStorageConfig } from './schemas.js';
+import type { IDextoLogger } from '../logger/v2/types.js';
 /**
  * Storage manager that initializes and manages storage backends.
  * Handles cache, database, and blob backends with automatic fallbacks.
@@ -19,8 +20,8 @@ export declare class StorageManager {
     private blobStore;
     private initialized;
     private connected;
-    private agentId;
-    constructor(config: ValidatedStorageConfig, agentId?: string);
+    private logger;
+    constructor(config: ValidatedStorageConfig, logger: IDextoLogger);
     /**
      * Initialize storage instances without connecting.
      * This allows configuration and inspection before establishing connections.
@@ -73,9 +74,8 @@ export declare class StorageManager {
 /**
  * Create and initialize a storage manager.
  * This is a convenience helper that combines initialization and connection.
- * This allows multiple agent instances to have independent storage.
- * @param config Storage configuration
- * @param agentId Optional agent identifier for database naming (used for SQLite default filename)
+ * Per-agent paths are provided via CLI enrichment layer before this point.
+ * @param config Storage configuration with explicit paths
  */
-export declare function createStorageManager(config: ValidatedStorageConfig, agentId?: string): Promise<StorageManager>;
+export declare function createStorageManager(config: ValidatedStorageConfig, logger: IDextoLogger): Promise<StorageManager>;
 //# sourceMappingURL=storage-manager.d.ts.map

package/dist/storage/storage-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/storage/storage-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAS3D;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAqB;gBAExB,MAAM,EAAE,sBAAsB,EAAE,OAAO,CAAC,EAAE,MAAM;IAK5D;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiCjC,WAAW,IAAI,OAAO;IAStB;;;OAGG;IACH,QAAQ,IAAI,KAAK;IAOjB;;;OAGG;IACH,WAAW,IAAI,QAAQ;IAOvB;;;OAGG;IACH,YAAY,IAAI,SAAS;IAQnB,OAAO,IAAI,OAAO,CAAC;QACrB,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC5C,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC/C,IAAI,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC3C,SAAS,EAAE,OAAO,CAAC;KACtB,CAAC;IAuBI,WAAW,IAAI,OAAO,CAAC;QACzB,KAAK,EAAE,OAAO,CAAC;QACf,QAAQ,EAAE,OAAO,CAAC;QAClB,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;KACpB,CAAC;CA+CL;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACtC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,cAAc,CAAC,CAKzB"}
+{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/storage/storage-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAK3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAK1D;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,YAAY;IAKhE;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiCjC,WAAW,IAAI,OAAO;IAStB;;;OAGG;IACH,QAAQ,IAAI,KAAK;IAOjB;;;OAGG;IACH,WAAW,IAAI,QAAQ;IAOvB;;;OAGG;IACH,YAAY,IAAI,SAAS;IAQnB,OAAO,IAAI,OAAO,CAAC;QACrB,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC5C,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC/C,IAAI,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;QAC3C,SAAS,EAAE,OAAO,CAAC;KACtB,CAAC;IAuBI,WAAW,IAAI,OAAO,CAAC;QACzB,KAAK,EAAE,OAAO,CAAC;QACf,QAAQ,EAAE,OAAO,CAAC;QAClB,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,OAAO,CAAC;KACpB,CAAC;CA+CL;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACtC,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,cAAc,CAAC,CAKzB"}