@dexto/core 1.1.10 → 1.2.0

package/dist/storage/errors.cjs

@@ -21,7 +21,7 @@ __export(errors_exports, {
   StorageError: () => StorageError
 });
 module.exports = __toCommonJS(errors_exports);
-var import_DextoRuntimeError = require("../errors/DextoRuntimeError.cjs");
+var import_errors = require("../errors/index.cjs");
 var import_types = require("../errors/types.cjs");
 var import_error_codes = require("./error-codes.js");
 class StorageError {
@@ -29,7 +29,7 @@ class StorageError {
    * Connection failed error
    */
   static connectionFailed(reason, config) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.CONNECTION_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.THIRD_PARTY,
@@ -41,7 +41,7 @@ class StorageError {
    * Backend not connected error
    */
   static notConnected(backendType) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.CONNECTION_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -49,11 +49,35 @@ class StorageError {
       { backendType }
     );
   }
+  /**
+   * Storage manager not initialized
+   */
+  static managerNotInitialized(method) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.MANAGER_NOT_INITIALIZED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `StorageManager is not initialized. Call initialize() before ${method}()`,
+      { method, hint: "Call await manager.initialize() first" }
+    );
+  }
+  /**
+   * Storage manager not connected
+   */
+  static managerNotConnected(method) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.MANAGER_NOT_CONNECTED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `StorageManager is not connected. Call connect() before ${method}()`,
+      { method, hint: "Call await manager.connect() after initialize()" }
+    );
+  }
   /**
    * Read operation failed
    */
   static readFailed(operation, reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.READ_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -65,7 +89,7 @@ class StorageError {
    * Write operation failed
    */
   static writeFailed(operation, reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.WRITE_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -77,7 +101,7 @@ class StorageError {
    * Delete operation failed
    */
   static deleteFailed(operation, reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.DELETE_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -89,7 +113,7 @@ class StorageError {
    * Migration failed error
    */
   static migrationFailed(reason, details) {
-    return new import_DextoRuntimeError.DextoRuntimeError(
+    return new import_errors.DextoRuntimeError(
       import_error_codes.StorageErrorCode.MIGRATION_FAILED,
       import_types.ErrorScope.STORAGE,
       import_types.ErrorType.SYSTEM,
@@ -97,6 +121,185 @@ class StorageError {
       { reason, ...details }
     );
   }
+  /**
+   * Invalid database configuration
+   */
+  static databaseInvalidConfig(message, context) {
+    return new import_errors.DextoValidationError([
+      {
+        code: import_error_codes.StorageErrorCode.DATABASE_INVALID_CONFIG,
+        message,
+        scope: import_types.ErrorScope.STORAGE,
+        type: import_types.ErrorType.USER,
+        severity: "error",
+        context: context || {}
+      }
+    ]);
+  }
+  // ==================== Blob Storage Errors ====================
+  /**
+   * Invalid blob configuration
+   */
+  static blobInvalidConfig(message, context) {
+    return new import_errors.DextoValidationError([
+      {
+        code: import_error_codes.StorageErrorCode.BLOB_INVALID_CONFIG,
+        message,
+        scope: import_types.ErrorScope.STORAGE,
+        type: import_types.ErrorType.USER,
+        severity: "error",
+        context: context || {}
+      }
+    ]);
+  }
+  /**
+   * Blob size exceeded maximum
+   */
+  static blobSizeExceeded(size, maxSize) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_SIZE_EXCEEDED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `Blob size ${size} bytes exceeds maximum ${maxSize} bytes`,
+      { size, maxSize }
+    );
+  }
+  /**
+   * Total blob storage size exceeded
+   */
+  static blobTotalSizeExceeded(totalSize, maxTotalSize) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_TOTAL_SIZE_EXCEEDED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Total storage size ${totalSize} bytes exceeds maximum ${maxTotalSize} bytes`,
+      { totalSize, maxTotalSize }
+    );
+  }
+  /**
+   * Invalid blob input
+   */
+  static blobInvalidInput(input, reason) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_INVALID_INPUT,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `Invalid blob input: ${reason}`,
+      { inputType: typeof input, reason }
+    );
+  }
+  /**
+   * Blob encoding error
+   */
+  static blobEncodingError(operation, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_ENCODING_ERROR,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob ${operation} failed: encoding error`,
+      { operation, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob not found
+   */
+  static blobNotFound(reference) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_NOT_FOUND,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.NOT_FOUND,
+      `Blob not found: ${reference}`,
+      { reference }
+    );
+  }
+  /**
+   * Invalid blob reference
+   */
+  static blobInvalidReference(reference, reason) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_INVALID_REFERENCE,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.USER,
+      `Invalid blob reference '${reference}': ${reason}`,
+      { reference, reason }
+    );
+  }
+  /**
+   * Blob access denied
+   */
+  static blobAccessDenied(reference, operation) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_ACCESS_DENIED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.FORBIDDEN,
+      `Access denied for blob ${operation}: ${reference}`,
+      { reference, operation }
+    );
+  }
+  /**
+   * Blob data corrupted
+   */
+  static blobCorrupted(reference, reason) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_CORRUPTED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob data corrupted: ${reference} (${reason})`,
+      { reference, reason }
+    );
+  }
+  /**
+   * Blob backend not connected
+   */
+  static blobBackendNotConnected(backendType) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_BACKEND_NOT_CONNECTED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Blob backend ${backendType} is not connected`,
+      { backendType }
+    );
+  }
+  /**
+   * Blob backend unavailable
+   */
+  static blobBackendUnavailable(backendType, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_BACKEND_UNAVAILABLE,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Blob backend ${backendType} is unavailable`,
+      { backendType, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob cleanup failed
+   */
+  static blobCleanupFailed(backendType, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_CLEANUP_FAILED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob cleanup failed for backend ${backendType}`,
+      { backendType, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob operation failed
+   */
+  static blobOperationFailed(operation, backendType, error) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.StorageErrorCode.BLOB_OPERATION_FAILED,
+      import_types.ErrorScope.STORAGE,
+      import_types.ErrorType.SYSTEM,
+      `Blob ${operation} failed for backend ${backendType}`,
+      {
+        operation,
+        backendType,
+        originalError: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/storage/errors.d.ts

@@ -1,23 +1,10 @@
-import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
-import '../errors/DextoBaseError.js';
-import '../errors/types.js';
-import '../agent/error-codes.js';
-import '../config/error-codes.js';
-import '../context/error-codes.js';
-import '../llm/error-codes.js';
-import '../mcp/error-codes.js';
-import '../session/error-codes.js';
-import './error-codes.js';
-import '../systemPrompt/error-codes.js';
-import '../tools/error-codes.js';
-import '../preferences/error-codes.js';
-import '../agent/registry/error-codes.js';
-
+import { DextoRuntimeError, DextoValidationError } from '../errors/index.js';
 /**
  * Storage error factory with typed methods for creating storage-specific errors
- * Each method creates a properly typed DextoRuntimeError with STORAGE scope
+ * Includes cache, database, and blob storage errors
+ * Each method creates a properly typed error with STORAGE scope
  */
-declare class StorageError {
+export declare class StorageError {
     /**
      * Connection failed error
      */
@@ -31,6 +18,20 @@ declare class StorageError {
     static notConnected(backendType: string): DextoRuntimeError<{
         backendType: string;
     }>;
+    /**
+     * Storage manager not initialized
+     */
+    static managerNotInitialized(method: string): DextoRuntimeError<{
+        method: string;
+        hint: string;
+    }>;
+    /**
+     * Storage manager not connected
+     */
+    static managerNotConnected(method: string): DextoRuntimeError<{
+        method: string;
+        hint: string;
+    }>;
     /**
      * Read operation failed
      */
@@ -58,6 +59,61 @@ declare class StorageError {
     static migrationFailed(reason: string, details?: Record<string, unknown>): DextoRuntimeError<{
         reason: string;
     }>;
+    /**
+     * Invalid database configuration
+     */
+    static databaseInvalidConfig(message: string, context?: Record<string, unknown>): DextoValidationError;
+    /**
+     * Invalid blob configuration
+     */
+    static blobInvalidConfig(message: string, context?: Record<string, unknown>): DextoValidationError;
+    /**
+     * Blob size exceeded maximum
+     */
+    static blobSizeExceeded(size: number, maxSize: number): DextoRuntimeError;
+    /**
+     * Total blob storage size exceeded
+     */
+    static blobTotalSizeExceeded(totalSize: number, maxTotalSize: number): DextoRuntimeError;
+    /**
+     * Invalid blob input
+     */
+    static blobInvalidInput(input: unknown, reason: string): DextoRuntimeError;
+    /**
+     * Blob encoding error
+     */
+    static blobEncodingError(operation: string, error: unknown): DextoRuntimeError;
+    /**
+     * Blob not found
+     */
+    static blobNotFound(reference: string): DextoRuntimeError;
+    /**
+     * Invalid blob reference
+     */
+    static blobInvalidReference(reference: string, reason: string): DextoRuntimeError;
+    /**
+     * Blob access denied
+     */
+    static blobAccessDenied(reference: string, operation: string): DextoRuntimeError;
+    /**
+     * Blob data corrupted
+     */
+    static blobCorrupted(reference: string, reason: string): DextoRuntimeError;
+    /**
+     * Blob backend not connected
+     */
+    static blobBackendNotConnected(backendType: string): DextoRuntimeError;
+    /**
+     * Blob backend unavailable
+     */
+    static blobBackendUnavailable(backendType: string, error: unknown): DextoRuntimeError;
+    /**
+     * Blob cleanup failed
+     */
+    static blobCleanupFailed(backendType: string, error: unknown): DextoRuntimeError;
+    /**
+     * Blob operation failed
+     */
+    static blobOperationFailed(operation: string, backendType: string, error: unknown): DextoRuntimeError;
 }
-
-export { StorageError };
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/storage/errors.ts"],"names":[],"mappings":"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"}

package/dist/storage/errors.js

@@ -1,4 +1,5 @@
-import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
+import "../chunk-C6A6W6XS.js";
+import { DextoRuntimeError, DextoValidationError } from "../errors/index.js";
 import { ErrorScope, ErrorType } from "../errors/types.js";
 import { StorageErrorCode } from "./error-codes.js";
 class StorageError {
@@ -26,6 +27,30 @@ class StorageError {
       { backendType }
     );
   }
+  /**
+   * Storage manager not initialized
+   */
+  static managerNotInitialized(method) {
+    return new DextoRuntimeError(
+      StorageErrorCode.MANAGER_NOT_INITIALIZED,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `StorageManager is not initialized. Call initialize() before ${method}()`,
+      { method, hint: "Call await manager.initialize() first" }
+    );
+  }
+  /**
+   * Storage manager not connected
+   */
+  static managerNotConnected(method) {
+    return new DextoRuntimeError(
+      StorageErrorCode.MANAGER_NOT_CONNECTED,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `StorageManager is not connected. Call connect() before ${method}()`,
+      { method, hint: "Call await manager.connect() after initialize()" }
+    );
+  }
   /**
    * Read operation failed
    */
@@ -74,6 +99,185 @@ class StorageError {
       { reason, ...details }
     );
   }
+  /**
+   * Invalid database configuration
+   */
+  static databaseInvalidConfig(message, context) {
+    return new DextoValidationError([
+      {
+        code: StorageErrorCode.DATABASE_INVALID_CONFIG,
+        message,
+        scope: ErrorScope.STORAGE,
+        type: ErrorType.USER,
+        severity: "error",
+        context: context || {}
+      }
+    ]);
+  }
+  // ==================== Blob Storage Errors ====================
+  /**
+   * Invalid blob configuration
+   */
+  static blobInvalidConfig(message, context) {
+    return new DextoValidationError([
+      {
+        code: StorageErrorCode.BLOB_INVALID_CONFIG,
+        message,
+        scope: ErrorScope.STORAGE,
+        type: ErrorType.USER,
+        severity: "error",
+        context: context || {}
+      }
+    ]);
+  }
+  /**
+   * Blob size exceeded maximum
+   */
+  static blobSizeExceeded(size, maxSize) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_SIZE_EXCEEDED,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Blob size ${size} bytes exceeds maximum ${maxSize} bytes`,
+      { size, maxSize }
+    );
+  }
+  /**
+   * Total blob storage size exceeded
+   */
+  static blobTotalSizeExceeded(totalSize, maxTotalSize) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_TOTAL_SIZE_EXCEEDED,
+      ErrorScope.STORAGE,
+      ErrorType.SYSTEM,
+      `Total storage size ${totalSize} bytes exceeds maximum ${maxTotalSize} bytes`,
+      { totalSize, maxTotalSize }
+    );
+  }
+  /**
+   * Invalid blob input
+   */
+  static blobInvalidInput(input, reason) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_INVALID_INPUT,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Invalid blob input: ${reason}`,
+      { inputType: typeof input, reason }
+    );
+  }
+  /**
+   * Blob encoding error
+   */
+  static blobEncodingError(operation, error) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_ENCODING_ERROR,
+      ErrorScope.STORAGE,
+      ErrorType.SYSTEM,
+      `Blob ${operation} failed: encoding error`,
+      { operation, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob not found
+   */
+  static blobNotFound(reference) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_NOT_FOUND,
+      ErrorScope.STORAGE,
+      ErrorType.NOT_FOUND,
+      `Blob not found: ${reference}`,
+      { reference }
+    );
+  }
+  /**
+   * Invalid blob reference
+   */
+  static blobInvalidReference(reference, reason) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_INVALID_REFERENCE,
+      ErrorScope.STORAGE,
+      ErrorType.USER,
+      `Invalid blob reference '${reference}': ${reason}`,
+      { reference, reason }
+    );
+  }
+  /**
+   * Blob access denied
+   */
+  static blobAccessDenied(reference, operation) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_ACCESS_DENIED,
+      ErrorScope.STORAGE,
+      ErrorType.FORBIDDEN,
+      `Access denied for blob ${operation}: ${reference}`,
+      { reference, operation }
+    );
+  }
+  /**
+   * Blob data corrupted
+   */
+  static blobCorrupted(reference, reason) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_CORRUPTED,
+      ErrorScope.STORAGE,
+      ErrorType.SYSTEM,
+      `Blob data corrupted: ${reference} (${reason})`,
+      { reference, reason }
+    );
+  }
+  /**
+   * Blob backend not connected
+   */
+  static blobBackendNotConnected(backendType) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_BACKEND_NOT_CONNECTED,
+      ErrorScope.STORAGE,
+      ErrorType.THIRD_PARTY,
+      `Blob backend ${backendType} is not connected`,
+      { backendType }
+    );
+  }
+  /**
+   * Blob backend unavailable
+   */
+  static blobBackendUnavailable(backendType, error) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_BACKEND_UNAVAILABLE,
+      ErrorScope.STORAGE,
+      ErrorType.THIRD_PARTY,
+      `Blob backend ${backendType} is unavailable`,
+      { backendType, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob cleanup failed
+   */
+  static blobCleanupFailed(backendType, error) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_CLEANUP_FAILED,
+      ErrorScope.STORAGE,
+      ErrorType.SYSTEM,
+      `Blob cleanup failed for backend ${backendType}`,
+      { backendType, originalError: error instanceof Error ? error.message : String(error) }
+    );
+  }
+  /**
+   * Blob operation failed
+   */
+  static blobOperationFailed(operation, backendType, error) {
+    return new DextoRuntimeError(
+      StorageErrorCode.BLOB_OPERATION_FAILED,
+      ErrorScope.STORAGE,
+      ErrorType.SYSTEM,
+      `Blob ${operation} failed for backend ${backendType}`,
+      {
+        operation,
+        backendType,
+        originalError: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
 }
 export {
   StorageError

package/dist/storage/index.cjs

@@ -18,16 +18,35 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var storage_exports = {};
 __export(storage_exports, {
-  MemoryBackend: () => import_memory_backend.MemoryBackend,
+  BLOB_STORE_TYPES: () => import_schemas.BLOB_STORE_TYPES,
+  BlobStoreConfigSchema: () => import_schemas2.BlobStoreConfigSchema,
+  CACHE_TYPES: () => import_schemas.CACHE_TYPES,
+  CacheConfigSchema: () => import_schemas2.CacheConfigSchema,
+  DATABASE_TYPES: () => import_schemas.DATABASE_TYPES,
+  DatabaseConfigSchema: () => import_schemas2.DatabaseConfigSchema,
+  MemoryCacheStore: () => import_memory_cache_store.MemoryCacheStore,
+  MemoryDatabaseStore: () => import_memory_database_store.MemoryDatabaseStore,
   StorageManager: () => import_storage_manager.StorageManager,
-  createStorageBackends: () => import_storage_manager.createStorageBackends
+  StorageSchema: () => import_schemas2.StorageSchema,
+  createStorageManager: () => import_storage_manager.createStorageManager
 });
 module.exports = __toCommonJS(storage_exports);
 var import_storage_manager = require("./storage-manager.js");
-var import_memory_backend = require("./backend/memory-backend.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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MemoryBackend,
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  CACHE_TYPES,
+  CacheConfigSchema,
+  DATABASE_TYPES,
+  DatabaseConfigSchema,
+  MemoryCacheStore,
+  MemoryDatabaseStore,
   StorageManager,
-  createStorageBackends
+  StorageSchema,
+  createStorageManager
 });