@dexto/core 1.2.4 → 1.2.6

package/dist/storage/database/factory.js

@@ -1,28 +1,27 @@
 import "../../chunk-C6A6W6XS.js";
 import { MemoryDatabaseStore } from "./memory-database-store.js";
-import { logger } from "../../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:
       logger.info("Using in-memory database store");
       return new MemoryDatabaseStore();
   }
 }
-async function createPostgresStore(config) {
+async function createPostgresStore(config, logger) {
   try {
     if (!PostgresStore) {
       const module = await import("./postgres-store.js");
       PostgresStore = module.PostgresStore;
     }
     logger.info("Connecting to PostgreSQL database");
-    return new PostgresStore(config);
+    return new PostgresStore(config, logger);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     logger.warn(
@@ -31,19 +30,17 @@ async function createPostgresStore(config) {
     return new MemoryDatabaseStore();
   }
 }
-async function createSQLiteStore(config, agentId) {
+async function createSQLiteStore(config, logger) {
   try {
     if (!SQLiteStore) {
       const module = await import("./sqlite-store.js");
       SQLiteStore = module.SQLiteStore;
     }
-    const defaultFilename = agentId ? `${agentId}.db` : "dexto.db";
-    const effectivePath = config.path || defaultFilename;
-    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));
-    logger.error(`SQLite store failed to load: ${err.message}`, err);
+    logger.error(`SQLite store failed to load: ${err.message}`, { error: err.message });
     logger.warn("Falling back to in-memory database store");
     return new MemoryDatabaseStore();
   }

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

@@ -22,13 +22,16 @@ __export(postgres_store_exports, {
 });
 module.exports = __toCommonJS(postgres_store_exports);
 var import_pg = require("pg");
+var import_types = require("../../logger/v2/types.js");
 var import_errors = require("../errors.js");
 class PostgresStore {
-  constructor(config) {
+  constructor(config, logger) {
     this.config = config;
+    this.logger = logger.createChild(import_types.DextoLogComponent.STORAGE);
   }
   pool = null;
   connected = false;
+  logger;
   async connect() {
     if (this.connected) return;
     this.pool = new import_pg.Pool({

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

@@ -1,6 +1,7 @@
 import { PoolClient } from 'pg';
 import type { Database } from './types.js';
 import type { PostgresDatabaseConfig } from './schemas.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
  * PostgreSQL database store for production database operations.
  * Implements the Database interface with connection pooling and JSONB support.
@@ -10,7 +11,8 @@ export declare class PostgresStore implements Database {
     private config;
     private pool;
     private connected;
-    constructor(config: PostgresDatabaseConfig);
+    private logger;
+    constructor(config: PostgresDatabaseConfig, logger: IDextoLogger);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"postgres-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/postgres-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,MAAM,IAAI,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAG3D;;;;GAIG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAI9B,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,SAAS,CAAS;gBAEN,MAAM,EAAE,sBAAsB;IAE5C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBxB,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;IAiB3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAuBvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;YAe5D,YAAY;IA4B1B,OAAO,CAAC,eAAe;IAOjB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgBxE,QAAQ,IAAI,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACrB,CAAC;IAsBI,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAShC"}
+{"version":3,"file":"postgres-store.d.ts","sourceRoot":"","sources":["../../../src/storage/database/postgres-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,UAAU,EAAE,MAAM,IAAI,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D;;;;GAIG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAMtC,OAAO,CAAC,MAAM;IALlB,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAe;gBAGjB,MAAM,EAAE,sBAAsB,EACtC,MAAM,EAAE,YAAY;IAKlB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBxB,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;IAiB3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAuBvC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9C,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;YAe5D,YAAY;IA4B1B,OAAO,CAAC,eAAe;IAOjB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgBxE,QAAQ,IAAI,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACrB,CAAC;IAsBI,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAShC"}

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

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

package/dist/storage/database/schemas.cjs

@@ -39,10 +39,9 @@ const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
 }).strict();
 const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
   type: import_zod.z.literal("sqlite"),
-  path: import_zod.z.string().optional().describe(
-    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
-  ),
-  database: import_zod.z.string().optional().describe("Database filename (default: <agent-id>.db)")
+  path: import_zod.z.string().describe(
+    "SQLite database file path (required for SQLite - CLI enrichment provides per-agent path)"
+  )
 }).strict();
 const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
   type: import_zod.z.literal("postgres"),

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

@@ -29,24 +29,21 @@ declare const SqliteDatabaseSchema: 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;
 }>;
 export type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
 declare const PostgresDatabaseSchema: z.ZodObject<{
@@ -114,24 +111,21 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     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>;
@@ -176,13 +170,12 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     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;
@@ -202,13 +195,12 @@ export declare const DatabaseConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<
     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;

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/database/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc,8CAA+C,CAAC;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAoB3D,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;EASf,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC3B,CAAC;AAEP,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/database/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc,8CAA+C,CAAC;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAoB3D,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAOf,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGzE,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAC;AAEZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC3B,CAAC;AAEP,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/storage/database/schemas.js

@@ -16,10 +16,9 @@ const InMemoryDatabaseSchema = BaseDatabaseSchema.extend({
 }).strict();
 const SqliteDatabaseSchema = BaseDatabaseSchema.extend({
   type: z.literal("sqlite"),
-  path: z.string().optional().describe(
-    "SQLite database file path (optional, will auto-detect using path resolver if not provided)"
-  ),
-  database: z.string().optional().describe("Database filename (default: <agent-id>.db)")
+  path: z.string().describe(
+    "SQLite database file path (required for SQLite - CLI enrichment provides per-agent path)"
+  )
 }).strict();
 const PostgresDatabaseSchema = BaseDatabaseSchema.extend({
   type: z.literal("postgres"),

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>;