@dexto/core 1.4.0 → 1.5.1

package/dist/storage/errors.js

@@ -295,6 +295,86 @@ class StorageError {
       }
     );
   }
+  /**
+   * Unknown blob provider type
+   */
+  static unknownBlobProvider(type, availableTypes) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_PROVIDER_UNKNOWN,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Unknown blob store type: '${type}'`,
+      { type, availableTypes },
+      `Available types: ${availableTypes.length > 0 ? availableTypes.join(", ") : "none"}`
+    );
+  }
+  /**
+   * Blob provider already registered
+   */
+  static blobProviderAlreadyRegistered(type) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_PROVIDER_ALREADY_REGISTERED,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Blob store provider '${type}' is already registered`,
+      { type },
+      `Use unregister() first if you need to replace it`
+    );
+  }
+  // ==================== Database Provider Registry Errors ====================
+  /**
+   * Unknown database provider type
+   */
+  static unknownDatabaseProvider(type, availableTypes) {
+    return new DextoRuntimeError(
+      StorageErrorCode.DATABASE_PROVIDER_UNKNOWN,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Unknown database type: '${type}'`,
+      { type, availableTypes },
+      `Available types: ${availableTypes.length > 0 ? availableTypes.join(", ") : "none"}`
+    );
+  }
+  /**
+   * Database provider already registered
+   */
+  static databaseProviderAlreadyRegistered(type) {
+    return new DextoRuntimeError(
+      StorageErrorCode.DATABASE_PROVIDER_ALREADY_REGISTERED,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Database provider '${type}' is already registered`,
+      { type },
+      `Use unregister() first if you need to replace it`
+    );
+  }
+  // ==================== Cache Provider Registry Errors ====================
+  /**
+   * Unknown cache provider type
+   */
+  static unknownCacheProvider(type, availableTypes) {
+    return new DextoRuntimeError(
+      StorageErrorCode.CACHE_PROVIDER_UNKNOWN,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Unknown cache type: '${type}'`,
+      { type, availableTypes },
+      `Available types: ${availableTypes.length > 0 ? availableTypes.join(", ") : "none"}`
+    );
+  }
+  /**
+   * Cache provider already registered
+   */
+  static cacheProviderAlreadyRegistered(type) {
+    return new DextoRuntimeError(
+      StorageErrorCode.CACHE_PROVIDER_ALREADY_REGISTERED,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Cache provider '${type}' is already registered`,
+      { type },
+      `Use unregister() first if you need to replace it`
+    );
+  }
 }
 export {
   StorageError

package/dist/storage/index.cjs

@@ -20,33 +20,76 @@ var storage_exports = {};
 __export(storage_exports, {
   BLOB_STORE_TYPES: () => import_schemas.BLOB_STORE_TYPES,
   BlobStoreConfigSchema: () => import_schemas2.BlobStoreConfigSchema,
+  BlobStoreRegistry: () => import_blob.BlobStoreRegistry,
   CACHE_TYPES: () => import_schemas.CACHE_TYPES,
   CacheConfigSchema: () => import_schemas2.CacheConfigSchema,
+  CacheRegistry: () => import_cache.CacheRegistry,
   DATABASE_TYPES: () => import_schemas.DATABASE_TYPES,
   DatabaseConfigSchema: () => import_schemas2.DatabaseConfigSchema,
+  DatabaseRegistry: () => import_database.DatabaseRegistry,
+  InMemoryBlobStore: () => import_blob2.InMemoryBlobStore,
+  LocalBlobStore: () => import_blob2.LocalBlobStore,
   MemoryCacheStore: () => import_memory_cache_store.MemoryCacheStore,
   MemoryDatabaseStore: () => import_memory_database_store.MemoryDatabaseStore,
   StorageManager: () => import_storage_manager.StorageManager,
   StorageSchema: () => import_schemas2.StorageSchema,
-  createStorageManager: () => import_storage_manager.createStorageManager
+  blobStoreRegistry: () => import_blob.blobStoreRegistry,
+  cacheRegistry: () => import_cache.cacheRegistry,
+  createBlobStore: () => import_blob.createBlobStore,
+  createCache: () => import_cache.createCache,
+  createDatabase: () => import_database.createDatabase,
+  createStorageManager: () => import_storage_manager.createStorageManager,
+  databaseRegistry: () => import_database.databaseRegistry,
+  inMemoryBlobStoreProvider: () => import_providers3.inMemoryBlobStoreProvider,
+  inMemoryCacheProvider: () => import_providers2.inMemoryCacheProvider,
+  inMemoryDatabaseProvider: () => import_providers.inMemoryDatabaseProvider,
+  localBlobStoreProvider: () => import_providers3.localBlobStoreProvider,
+  postgresDatabaseProvider: () => import_providers.postgresDatabaseProvider,
+  redisCacheProvider: () => import_providers2.redisCacheProvider,
+  sqliteDatabaseProvider: () => import_providers.sqliteDatabaseProvider
 });
 module.exports = __toCommonJS(storage_exports);
 var import_storage_manager = require("./storage-manager.js");
-var import_memory_cache_store = require("./cache/memory-cache-store.js");
-var import_memory_database_store = require("./database/memory-database-store.js");
 var import_schemas = require("./schemas.js");
 var import_schemas2 = require("./schemas.js");
+var import_database = require("./database/index.js");
+var import_providers = require("./database/providers/index.js");
+var import_memory_database_store = require("./database/memory-database-store.js");
+var import_cache = require("./cache/index.js");
+var import_providers2 = require("./cache/providers/index.js");
+var import_memory_cache_store = require("./cache/memory-cache-store.js");
+var import_blob = require("./blob/index.js");
+var import_providers3 = require("./blob/providers/index.js");
+var import_blob2 = require("./blob/index.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOB_STORE_TYPES,
   BlobStoreConfigSchema,
+  BlobStoreRegistry,
   CACHE_TYPES,
   CacheConfigSchema,
+  CacheRegistry,
   DATABASE_TYPES,
   DatabaseConfigSchema,
+  DatabaseRegistry,
+  InMemoryBlobStore,
+  LocalBlobStore,
   MemoryCacheStore,
   MemoryDatabaseStore,
   StorageManager,
   StorageSchema,
-  createStorageManager
+  blobStoreRegistry,
+  cacheRegistry,
+  createBlobStore,
+  createCache,
+  createDatabase,
+  createStorageManager,
+  databaseRegistry,
+  inMemoryBlobStoreProvider,
+  inMemoryCacheProvider,
+  inMemoryDatabaseProvider,
+  localBlobStoreProvider,
+  postgresDatabaseProvider,
+  redisCacheProvider,
+  sqliteDatabaseProvider
 });

package/dist/storage/index.d.ts

@@ -1,9 +1,12 @@
 /**
  * Dexto Storage Layer
  *
- * A storage system with two storage types:
+ * A storage system with three storage types:
  * - Cache: Fast, ephemeral storage (Redis, Memory) with TTL support
  * - Database: Persistent, reliable storage (PostgreSQL, SQLite, Memory) with list operations
+ * - Blob: Large object storage (Local, Memory) for files and binary data
+ *
+ * All storage types use a provider pattern for extensibility.
  *
  * Usage:
  *
@@ -11,12 +14,14 @@
  * // Create and initialize a storage manager
  * const manager = await createStorageManager({
  *   cache: { type: 'in-memory' },
- *   database: { type: 'in-memory' }
+ *   database: { type: 'in-memory' },
+ *   blob: { type: 'local', storePath: '/tmp/blobs' }
  * });
  *
  * // Access cache and database via getters
  * const cache = manager.getCache();
  * const database = manager.getDatabase();
+ * const blobStore = manager.getBlobStore();
  *
  * // Use cache for temporary data
  * await cache.set('session:123', sessionData, 3600); // 1 hour TTL
@@ -30,19 +35,40 @@
  * // Cleanup when done
  * await manager.disconnect();
  * ```
+ *
+ * ## Registering Custom Providers
+ *
+ * ```typescript
+ * import { databaseRegistry, cacheRegistry, blobStoreRegistry } from '@dexto/core';
+ *
+ * // Register before loading config
+ * databaseRegistry.register(mongoProvider);
+ * cacheRegistry.register(memcachedProvider);
+ * blobStoreRegistry.register(s3Provider);
+ * ```
  */
 export { StorageManager, createStorageManager } from './storage-manager.js';
-export type { Cache } from './cache/types.js';
-export type { Database } from './database/types.js';
 export type { StorageConfig, ValidatedStorageConfig } from './schemas.js';
-export { MemoryCacheStore } from './cache/memory-cache-store.js';
-export { MemoryDatabaseStore } from './database/memory-database-store.js';
 export { CACHE_TYPES, DATABASE_TYPES, BLOB_STORE_TYPES } from './schemas.js';
 export type { CacheType, DatabaseType, BlobStoreType } from './schemas.js';
 export { CacheConfigSchema, DatabaseConfigSchema, BlobStoreConfigSchema, StorageSchema, } from './schemas.js';
+export { createDatabase, databaseRegistry, DatabaseRegistry } from './database/index.js';
+export type { DatabaseProvider } from './database/index.js';
+export type { Database } from './database/types.js';
+export { inMemoryDatabaseProvider, sqliteDatabaseProvider, postgresDatabaseProvider, } from './database/providers/index.js';
+export type { DatabaseConfig, InMemoryDatabaseConfig, SqliteDatabaseConfig, PostgresDatabaseConfig, } from './schemas.js';
+export { MemoryDatabaseStore } from './database/memory-database-store.js';
+export { createCache, cacheRegistry, CacheRegistry } from './cache/index.js';
+export type { CacheProvider } from './cache/index.js';
+export type { Cache } from './cache/types.js';
+export { inMemoryCacheProvider, redisCacheProvider } from './cache/providers/index.js';
+export type { CacheConfig, InMemoryCacheConfig, RedisCacheConfig } from './schemas.js';
+export { MemoryCacheStore } from './cache/memory-cache-store.js';
+export { createBlobStore, blobStoreRegistry, BlobStoreRegistry } from './blob/index.js';
+export type { BlobStoreProvider } from './blob/index.js';
 export type { BlobStore } from './blob/types.js';
 export type { BlobInput, BlobMetadata, StoredBlobMetadata, BlobReference, BlobData, BlobStats, } from './blob/types.js';
+export { localBlobStoreProvider, inMemoryBlobStoreProvider } from './blob/providers/index.js';
 export type { BlobStoreConfig, InMemoryBlobStoreConfig, LocalBlobStoreConfig } from './schemas.js';
-export type { CacheConfig, InMemoryCacheConfig, RedisCacheConfig } from './schemas.js';
-export type { DatabaseConfig, InMemoryDatabaseConfig, SqliteDatabaseConfig, PostgresDatabaseConfig, } from './schemas.js';
+export { LocalBlobStore, InMemoryBlobStore } from './blob/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5E,YAAY,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAG1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAG1E,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EACH,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,GAChB,MAAM,cAAc,CAAC;AAGtB,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,YAAY,EACR,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,SAAS,GACZ,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGnG,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGvF,YAAY,EACR,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,GACzB,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAGH,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5E,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EACH,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,GAChB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACzF,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,YAAY,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EACH,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,GAC3B,MAAM,+BAA+B,CAAC;AAEvC,YAAY,EACR,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,GACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7E,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,YAAY,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEvF,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEjE,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACxF,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,YAAY,EACR,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,SAAS,GACZ,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAE9F,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEnG,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/storage/index.js

@@ -1,7 +1,5 @@
 import "../chunk-PTJYTZNU.js";
 import { StorageManager, createStorageManager } from "./storage-manager.js";
-import { MemoryCacheStore } from "./cache/memory-cache-store.js";
-import { MemoryDatabaseStore } from "./database/memory-database-store.js";
 import { CACHE_TYPES, DATABASE_TYPES, BLOB_STORE_TYPES } from "./schemas.js";
 import {
   CacheConfigSchema,
@@ -9,16 +7,47 @@ import {
   BlobStoreConfigSchema,
   StorageSchema
 } from "./schemas.js";
+import { createDatabase, databaseRegistry, DatabaseRegistry } from "./database/index.js";
+import {
+  inMemoryDatabaseProvider,
+  sqliteDatabaseProvider,
+  postgresDatabaseProvider
+} from "./database/providers/index.js";
+import { MemoryDatabaseStore } from "./database/memory-database-store.js";
+import { createCache, cacheRegistry, CacheRegistry } from "./cache/index.js";
+import { inMemoryCacheProvider, redisCacheProvider } from "./cache/providers/index.js";
+import { MemoryCacheStore } from "./cache/memory-cache-store.js";
+import { createBlobStore, blobStoreRegistry, BlobStoreRegistry } from "./blob/index.js";
+import { localBlobStoreProvider, inMemoryBlobStoreProvider } from "./blob/providers/index.js";
+import { LocalBlobStore, InMemoryBlobStore } from "./blob/index.js";
 export {
   BLOB_STORE_TYPES,
   BlobStoreConfigSchema,
+  BlobStoreRegistry,
   CACHE_TYPES,
   CacheConfigSchema,
+  CacheRegistry,
   DATABASE_TYPES,
   DatabaseConfigSchema,
+  DatabaseRegistry,
+  InMemoryBlobStore,
+  LocalBlobStore,
   MemoryCacheStore,
   MemoryDatabaseStore,
   StorageManager,
   StorageSchema,
-  createStorageManager
+  blobStoreRegistry,
+  cacheRegistry,
+  createBlobStore,
+  createCache,
+  createDatabase,
+  createStorageManager,
+  databaseRegistry,
+  inMemoryBlobStoreProvider,
+  inMemoryCacheProvider,
+  inMemoryDatabaseProvider,
+  localBlobStoreProvider,
+  postgresDatabaseProvider,
+  redisCacheProvider,
+  sqliteDatabaseProvider
 };

package/dist/storage/schemas.cjs

@@ -24,6 +24,8 @@ __export(schemas_exports, {
   CacheConfigSchema: () => import_schemas.CacheConfigSchema,
   DATABASE_TYPES: () => import_schemas2.DATABASE_TYPES,
   DatabaseConfigSchema: () => import_schemas2.DatabaseConfigSchema,
+  InMemoryBlobStoreSchema: () => import_schemas3.InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema: () => import_schemas3.LocalBlobStoreSchema,
   StorageSchema: () => StorageSchema
 });
 module.exports = __toCommonJS(schemas_exports);
@@ -49,5 +51,7 @@ const StorageSchema = import_zod.z.object({
   CacheConfigSchema,
   DATABASE_TYPES,
   DatabaseConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema,
   StorageSchema
 });

package/dist/storage/schemas.d.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 export { CACHE_TYPES, CacheConfigSchema, type CacheType, type CacheConfig, type InMemoryCacheConfig, type RedisCacheConfig, } from './cache/schemas.js';
 export { DATABASE_TYPES, DatabaseConfigSchema, type DatabaseType, type DatabaseConfig, type InMemoryDatabaseConfig, type SqliteDatabaseConfig, type PostgresDatabaseConfig, } from './database/schemas.js';
-export { BLOB_STORE_TYPES, BlobStoreConfigSchema, type BlobStoreType, type BlobStoreConfig, type InMemoryBlobStoreConfig, type LocalBlobStoreConfig, } from './blob/schemas.js';
+export { BLOB_STORE_TYPES, BlobStoreConfigSchema, InMemoryBlobStoreSchema, LocalBlobStoreSchema, type BlobStoreType, type BlobStoreConfig, type InMemoryBlobStoreConfig, type LocalBlobStoreConfig, } from './blob/schemas.js';
 /**
  * Top-level storage configuration schema
  * Composes cache, database, and blob store configurations
+ *
+ * Note: Blob config uses runtime validation via the provider registry,
+ * allowing custom providers to be registered at the CLI/server layer.
  */
 export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
     cache: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -149,6 +152,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port: z.ZodOptional<z.ZodNumber>;
         database: z.ZodOptional<z.ZodString>;
         password: z.ZodOptional<z.ZodString>;
+        keyPrefix: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         type: "postgres";
         password?: string | undefined;
@@ -161,6 +165,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }, {
         type: "postgres";
         password?: string | undefined;
@@ -173,6 +178,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }>]>, {
         type: "in-memory";
         options?: Record<string, any> | undefined;
@@ -198,6 +204,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }, {
         type: "in-memory";
         options?: Record<string, any> | undefined;
@@ -223,38 +230,15 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     }>;
-    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>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "in-memory";
-        maxBlobSize: number;
-        maxTotalSize: number;
-    }, {
-        type: "in-memory";
-        maxBlobSize?: number | undefined;
-        maxTotalSize?: number | undefined;
-    }>, z.ZodObject<{
-        type: z.ZodLiteral<"local">;
-        storePath: z.ZodString;
-        maxBlobSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        maxTotalSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        cleanupAfterDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, "strict", z.ZodTypeAny, {
-        type: "local";
-        maxBlobSize: number;
-        maxTotalSize: number;
-        storePath: string;
-        cleanupAfterDays: number;
-    }, {
-        type: "local";
-        storePath: string;
-        maxBlobSize?: number | undefined;
-        maxTotalSize?: number | undefined;
-        cleanupAfterDays?: number | undefined;
-    }>]>;
+    blob: z.ZodObject<{
+        type: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
 }, "strict", z.ZodTypeAny, {
     database: {
         type: "in-memory";
@@ -281,6 +265,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     };
     cache: {
         type: "in-memory";
@@ -301,15 +286,9 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         database?: number | undefined;
     };
     blob: {
-        type: "in-memory";
-        maxBlobSize: number;
-        maxTotalSize: number;
-    } | {
-        type: "local";
-        maxBlobSize: number;
-        maxTotalSize: number;
-        storePath: string;
-        cleanupAfterDays: number;
+        type: string;
+    } & {
+        [k: string]: unknown;
     };
 }, {
     database: {
@@ -337,6 +316,7 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         port?: number | undefined;
         database?: string | undefined;
         connectionString?: string | undefined;
+        keyPrefix?: string | undefined;
     };
     cache: {
         type: "in-memory";
@@ -357,15 +337,9 @@ export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
         database?: number | undefined;
     };
     blob: {
-        type: "in-memory";
-        maxBlobSize?: number | undefined;
-        maxTotalSize?: number | undefined;
-    } | {
-        type: "local";
-        storePath: string;
-        maxBlobSize?: number | undefined;
-        maxTotalSize?: number | undefined;
-        cleanupAfterDays?: number | undefined;
+        type: string;
+    } & {
+        [k: string]: unknown;
     };
 }>, "ValidatedStorageConfig">;
 export type StorageConfig = z.input<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,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;;;;GAMG;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

@@ -10,7 +10,9 @@ import {
 } from "./database/schemas.js";
 import {
   BLOB_STORE_TYPES,
-  BlobStoreConfigSchema
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
 } from "./blob/schemas.js";
 import { CacheConfigSchema as CacheConfigSchema2 } from "./cache/schemas.js";
 import { DatabaseConfigSchema as DatabaseConfigSchema2 } from "./database/schemas.js";
@@ -29,5 +31,7 @@ export {
   CacheConfigSchema,
   DATABASE_TYPES,
   DatabaseConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema,
   StorageSchema
 };

package/dist/storage/storage-manager.cjs

@@ -22,9 +22,9 @@ __export(storage_manager_exports, {
   createStorageManager: () => createStorageManager
 });
 module.exports = __toCommonJS(storage_manager_exports);
-var import_factory = require("./cache/factory.js");
-var import_factory2 = require("./database/factory.js");
-var import_factory3 = require("./blob/factory.js");
+var import_cache = require("./cache/index.js");
+var import_database = require("./database/index.js");
+var import_blob = require("./blob/index.js");
 var import_errors = require("./errors.js");
 var import_types = require("../logger/v2/types.js");
 const HEALTH_CHECK_KEY = "storage_manager_health_check";
@@ -48,9 +48,9 @@ class StorageManager {
     if (this.initialized) {
       return;
     }
-    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.cache = await (0, import_cache.createCache)(this.config.cache, this.logger);
+    this.database = await (0, import_database.createDatabase)(this.config.database, this.logger);
+    this.blobStore = (0, import_blob.createBlobStore)(this.config.blob, this.logger);
     this.initialized = true;
   }
   /**

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;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"}
+{"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;AAM3D,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"}

package/dist/storage/storage-manager.js

@@ -1,7 +1,7 @@
 import "../chunk-PTJYTZNU.js";
-import { createCache } from "./cache/factory.js";
-import { createDatabase } from "./database/factory.js";
-import { createBlobStore } from "./blob/factory.js";
+import { createCache } from "./cache/index.js";
+import { createDatabase } from "./database/index.js";
+import { createBlobStore } from "./blob/index.js";
 import { StorageError } from "./errors.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 const HEALTH_CHECK_KEY = "storage_manager_health_check";

package/dist/systemPrompt/in-built-prompts.cjs

@@ -18,12 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var in_built_prompts_exports = {};
 __export(in_built_prompts_exports, {
-  getCurrentDateTime: () => getCurrentDateTime,
+  getCurrentDate: () => getCurrentDate,
   getResourceData: () => getResourceData
 });
 module.exports = __toCommonJS(in_built_prompts_exports);
-async function getCurrentDateTime(_context) {
-  return `<dateTime>Current date and time: ${(/* @__PURE__ */ new Date()).toISOString()}</dateTime>`;
+async function getCurrentDate(_context) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `<date>Current date: ${date}</date>`;
 }
 async function getResourceData(context) {
   const resources = await context.mcpManager.listAllResources();
@@ -36,9 +37,9 @@ async function getResourceData(context) {
         const response = await context.mcpManager.readResource(resource.key);
         const first = response?.contents?.[0];
         let content;
-        if (first?.text && typeof first.text === "string") {
+        if (first && "text" in first && first.text && typeof first.text === "string") {
           content = first.text;
-        } else if (first?.blob && typeof first.blob === "string") {
+        } else if (first && "blob" in first && first.blob && typeof first.blob === "string") {
           content = first.blob;
         } else {
           content = JSON.stringify(response, null, 2);
@@ -56,6 +57,6 @@ ${parts.join("\n")}
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getCurrentDateTime,
+  getCurrentDate,
   getResourceData
 });

package/dist/systemPrompt/in-built-prompts.d.ts

@@ -10,8 +10,8 @@ import { DynamicContributorContext } from './types.js';
  * - Place all dynamic prompt-generating functions in this file.
  * - Also update the `registry.ts` file to register the new function.
  * - Use XML tags to indicate the start and end of the dynamic prompt - they are known to improve performance
- * - Each function should be named clearly to reflect its purpose (e.g., getCurrentDateTime, getResourceData).
+ * - Each function should be named clearly to reflect its purpose (e.g., getCurrentDate, getResourceData).
  */
-export declare function getCurrentDateTime(_context: DynamicContributorContext): Promise<string>;
+export declare function getCurrentDate(_context: DynamicContributorContext): Promise<string>;
 export declare function getResourceData(context: DynamicContributorContext): Promise<string>;
 //# sourceMappingURL=in-built-prompts.d.ts.map

package/dist/systemPrompt/in-built-prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-built-prompts.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/in-built-prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;GAYG;AAEH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAE7F;AAGD,wBAAsB,eAAe,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BzF"}
+{"version":3,"file":"in-built-prompts.d.ts","sourceRoot":"","sources":["../../src/systemPrompt/in-built-prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;GAYG;AAEH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAIzF;AAGD,wBAAsB,eAAe,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiCzF"}

package/dist/systemPrompt/in-built-prompts.js

@@ -1,6 +1,7 @@
 import "../chunk-PTJYTZNU.js";
-async function getCurrentDateTime(_context) {
-  return `<dateTime>Current date and time: ${(/* @__PURE__ */ new Date()).toISOString()}</dateTime>`;
+async function getCurrentDate(_context) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `<date>Current date: ${date}</date>`;
 }
 async function getResourceData(context) {
   const resources = await context.mcpManager.listAllResources();
@@ -13,9 +14,9 @@ async function getResourceData(context) {
         const response = await context.mcpManager.readResource(resource.key);
         const first = response?.contents?.[0];
         let content;
-        if (first?.text && typeof first.text === "string") {
+        if (first && "text" in first && first.text && typeof first.text === "string") {
           content = first.text;
-        } else if (first?.blob && typeof first.blob === "string") {
+        } else if (first && "blob" in first && first.blob && typeof first.blob === "string") {
           content = first.blob;
         } else {
           content = JSON.stringify(response, null, 2);
@@ -32,6 +33,6 @@ ${parts.join("\n")}
 </resources>`;
 }
 export {
-  getCurrentDateTime,
+  getCurrentDate,
   getResourceData
 };

package/dist/systemPrompt/registry.cjs

@@ -34,9 +34,9 @@ __export(registry_exports, {
 });
 module.exports = __toCommonJS(registry_exports);
 var handlers = __toESM(require("./in-built-prompts.js"), 1);
-const PROMPT_GENERATOR_SOURCES = ["dateTime", "resources"];
+const PROMPT_GENERATOR_SOURCES = ["date", "resources"];
 const PROMPT_GENERATOR_REGISTRY = {
-  dateTime: handlers.getCurrentDateTime,
+  date: handlers.getCurrentDate,
   resources: handlers.getResourceData
 };
 function getPromptGenerator(source) {