@dexto/core 1.2.4 → 1.2.5

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"}

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"),