@dexto/core 1.1.10 → 1.2.0

package/dist/resources/errors.js

@@ -0,0 +1,132 @@
+import "../chunk-C6A6W6XS.js";
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { ResourceErrorCodes } from "./error-codes.js";
+class ResourceError {
+  static redactUri(uri) {
+    try {
+      const u = new URL(uri);
+      if (u.username) u.username = "***";
+      if (u.password) u.password = "***";
+      u.searchParams.forEach((_, k) => {
+        if (/token|key|secret|sig|pwd|password/i.test(k)) u.searchParams.set(k, "***");
+      });
+      return u.toString();
+    } catch {
+      return uri.replace(/\/\/([^@]+)@/, "//***@").replace(/((?:token|key|secret|sig|pwd|password)=)[^&]*/gi, "$1***");
+    }
+  }
+  static toMessageAndRaw(reason) {
+    if (reason instanceof Error) {
+      return {
+        message: reason.message,
+        raw: { name: reason.name, message: reason.message, stack: reason.stack }
+      };
+    }
+    if (typeof reason === "string") return { message: reason, raw: reason };
+    try {
+      return { message: JSON.stringify(reason), raw: reason };
+    } catch {
+      return { message: String(reason), raw: reason };
+    }
+  }
+  // URI format and parsing errors
+  static invalidUriFormat(uri, expected) {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.INVALID_URI_FORMAT,
+      ErrorScope.RESOURCE,
+      ErrorType.USER,
+      `Invalid resource URI format: '${ResourceError.redactUri(uri)}'${expected ? ` (expected ${expected})` : ""}`,
+      { uri: ResourceError.redactUri(uri), uriRaw: uri, expected },
+      expected ? `Use format: ${expected}` : "Check the resource URI format"
+    );
+  }
+  static emptyUri() {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.EMPTY_URI,
+      ErrorScope.RESOURCE,
+      ErrorType.USER,
+      "Resource URI cannot be empty",
+      {},
+      "Provide a valid resource URI"
+    );
+  }
+  // Resource discovery and access errors
+  static resourceNotFound(uri) {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.RESOURCE_NOT_FOUND,
+      ErrorScope.RESOURCE,
+      ErrorType.NOT_FOUND,
+      `Resource not found: '${ResourceError.redactUri(uri)}'`,
+      { uri: ResourceError.redactUri(uri), uriRaw: uri },
+      "Check that the resource exists and is accessible"
+    );
+  }
+  static providerNotInitialized(providerType, uri) {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.PROVIDER_NOT_INITIALIZED,
+      ErrorScope.RESOURCE,
+      ErrorType.SYSTEM,
+      `${providerType} resource provider not initialized for: '${ResourceError.redactUri(uri)}'`,
+      { providerType, uri: ResourceError.redactUri(uri), uriRaw: uri },
+      "Ensure the resource provider is properly configured"
+    );
+  }
+  static providerNotAvailable(providerType) {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.PROVIDER_NOT_AVAILABLE,
+      ErrorScope.RESOURCE,
+      ErrorType.SYSTEM,
+      `${providerType} resource provider is not available`,
+      { providerType },
+      "Check resource provider configuration and availability"
+    );
+  }
+  // Content access errors
+  static readFailed(uri, reason) {
+    const { message: reasonMsg, raw: reasonRaw } = ResourceError.toMessageAndRaw(reason);
+    return new DextoRuntimeError(
+      ResourceErrorCodes.READ_FAILED,
+      ErrorScope.RESOURCE,
+      ErrorType.SYSTEM,
+      `Failed to read resource '${ResourceError.redactUri(uri)}': ${reasonMsg}`,
+      { uri: ResourceError.redactUri(uri), uriRaw: uri, reason: reasonMsg, reasonRaw },
+      "Check resource permissions and availability"
+    );
+  }
+  static accessDenied(uri) {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.ACCESS_DENIED,
+      ErrorScope.RESOURCE,
+      ErrorType.FORBIDDEN,
+      `Access denied to resource: '${ResourceError.redactUri(uri)}'`,
+      { uri: ResourceError.redactUri(uri), uriRaw: uri },
+      "Ensure you have permission to access this resource"
+    );
+  }
+  // Provider coordination errors
+  static noSuitableProvider(uri) {
+    return new DextoRuntimeError(
+      ResourceErrorCodes.NO_SUITABLE_PROVIDER,
+      ErrorScope.RESOURCE,
+      ErrorType.NOT_FOUND,
+      `No suitable provider found for resource: '${ResourceError.redactUri(uri)}'`,
+      { uri: ResourceError.redactUri(uri), uriRaw: uri },
+      "Check that the resource type is supported"
+    );
+  }
+  static providerError(providerType, operation, reason) {
+    const { message: reasonMsg, raw: reasonRaw } = ResourceError.toMessageAndRaw(reason);
+    return new DextoRuntimeError(
+      ResourceErrorCodes.PROVIDER_ERROR,
+      ErrorScope.RESOURCE,
+      ErrorType.SYSTEM,
+      `${providerType} provider failed during ${operation}: ${reasonMsg}`,
+      { providerType, operation, reason: reasonMsg, reasonRaw },
+      "Check provider configuration and logs for details"
+    );
+  }
+}
+export {
+  ResourceError
+};

package/dist/resources/handlers/blob-handler.cjs

@@ -0,0 +1,230 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var blob_handler_exports = {};
+__export(blob_handler_exports, {
+  BlobResourceHandler: () => BlobResourceHandler
+});
+module.exports = __toCommonJS(blob_handler_exports);
+var import_logger = require("../../logger/index.js");
+var import_errors = require("../errors.js");
+class BlobResourceHandler {
+  config;
+  blobStore;
+  constructor(config, blobStore) {
+    this.config = config;
+    this.blobStore = blobStore;
+  }
+  getType() {
+    return "blob";
+  }
+  async initialize(_services) {
+    import_logger.logger.debug("BlobResourceHandler initialized with BlobStore");
+  }
+  async listResources() {
+    import_logger.logger.debug("\u{1F50D} BlobResourceHandler.listResources() called");
+    try {
+      const stats = await this.blobStore.getStats();
+      import_logger.logger.debug(`\u{1F4CA} BlobStore stats: ${stats.count} blobs, backend: ${stats.backendType}`);
+      const resources = [];
+      try {
+        const blobs = await this.blobStore.listBlobs();
+        import_logger.logger.debug(`\u{1F4C4} Found ${blobs.length} individual blobs`);
+        for (const blob of blobs) {
+          if (blob.metadata.source === "system") {
+            continue;
+          }
+          const displayName = this.generateBlobDisplayName(blob.metadata, blob.id);
+          const friendlyType = this.getFriendlyType(blob.metadata.mimeType);
+          resources.push({
+            uri: blob.uri,
+            name: displayName,
+            description: `${friendlyType} (${this.formatSize(blob.metadata.size)})${blob.metadata.source ? ` \u2022 ${blob.metadata.source}` : ""}`,
+            source: "internal",
+            size: blob.metadata.size,
+            mimeType: blob.metadata.mimeType,
+            lastModified: new Date(blob.metadata.createdAt),
+            metadata: {
+              type: "blob",
+              source: blob.metadata.source,
+              hash: blob.metadata.hash,
+              createdAt: blob.metadata.createdAt,
+              originalName: blob.metadata.originalName
+            }
+          });
+        }
+      } catch (error) {
+        import_logger.logger.warn(`Failed to list individual blobs: ${String(error)}`);
+      }
+      import_logger.logger.debug(`\u2705 BlobResourceHandler returning ${resources.length} resources`);
+      return resources;
+    } catch (error) {
+      import_logger.logger.warn(`Failed to list blob resources: ${String(error)}`);
+      return [];
+    }
+  }
+  canHandle(uri) {
+    return uri.startsWith("blob:");
+  }
+  async readResource(uri) {
+    if (!this.canHandle(uri)) {
+      throw import_errors.ResourceError.noSuitableProvider(uri);
+    }
+    try {
+      const blobId = uri.substring(5);
+      if (!blobId) {
+        throw import_errors.ResourceError.readFailed(uri, new Error("Invalid blob URI: missing blob ID"));
+      }
+      if (blobId === "store") {
+        const stats = await this.blobStore.getStats();
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(stats, null, 2)
+            }
+          ]
+        };
+      }
+      const result = await this.blobStore.retrieve(blobId, "base64");
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: result.metadata.mimeType || "application/octet-stream",
+            blob: result.data
+            // base64 data from retrieve call
+          }
+        ],
+        _meta: {
+          size: result.metadata.size,
+          createdAt: result.metadata.createdAt,
+          originalName: result.metadata.originalName,
+          source: result.metadata.source
+        }
+      };
+    } catch (error) {
+      if (error instanceof import_errors.ResourceError) {
+        throw error;
+      }
+      throw import_errors.ResourceError.readFailed(uri, error);
+    }
+  }
+  async refresh() {
+    try {
+      await this.blobStore.cleanup();
+      import_logger.logger.debug("Blob store cleanup completed");
+    } catch (error) {
+      import_logger.logger.warn(`Blob store cleanup failed: ${String(error)}`);
+    }
+  }
+  getBlobStore() {
+    return this.blobStore;
+  }
+  /**
+   * Generate a user-friendly display name for a blob with proper file extension
+   */
+  generateBlobDisplayName(metadata, _blobId) {
+    if (metadata.originalName && metadata.originalName.includes(".")) {
+      return metadata.originalName;
+    }
+    let baseName = metadata.originalName || this.generateNameFromType(metadata.mimeType, metadata.source);
+    const extension = this.getExtensionFromMimeType(metadata.mimeType);
+    if (extension && !baseName.toLowerCase().endsWith(extension)) {
+      baseName += extension;
+    }
+    return baseName;
+  }
+  /**
+   * Generate a descriptive base name from MIME type and source
+   */
+  generateNameFromType(mimeType, source) {
+    if (mimeType.startsWith("image/")) {
+      if (source === "user") return "uploaded-image";
+      if (source === "tool") return "generated-image";
+      return "image";
+    }
+    if (mimeType.startsWith("text/")) {
+      if (source === "tool") return "tool-output";
+      return "text-file";
+    }
+    if (mimeType.startsWith("application/pdf")) {
+      return "document";
+    }
+    if (mimeType.startsWith("audio/")) {
+      return "audio-file";
+    }
+    if (mimeType.startsWith("video/")) {
+      return "video-file";
+    }
+    if (source === "user") return "user-upload";
+    if (source === "tool") return "tool-result";
+    return "file";
+  }
+  /**
+   * Get file extension from MIME type
+   */
+  getExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+      "image/jpeg": ".jpg",
+      "image/png": ".png",
+      "image/gif": ".gif",
+      "image/webp": ".webp",
+      "image/svg+xml": ".svg",
+      "text/plain": ".txt",
+      "text/markdown": ".md",
+      "text/html": ".html",
+      "text/css": ".css",
+      "application/json": ".json",
+      "application/pdf": ".pdf",
+      "application/xml": ".xml",
+      "audio/mpeg": ".mp3",
+      "audio/wav": ".wav",
+      "video/mp4": ".mp4",
+      "video/webm": ".webm"
+    };
+    return mimeToExt[mimeType] || "";
+  }
+  /**
+   * Convert MIME type to user-friendly type description
+   */
+  getFriendlyType(mimeType) {
+    if (mimeType.startsWith("image/")) return "Image";
+    if (mimeType.startsWith("text/")) return "Text File";
+    if (mimeType.startsWith("audio/")) return "Audio File";
+    if (mimeType.startsWith("video/")) return "Video File";
+    if (mimeType === "application/pdf") return "PDF Document";
+    if (mimeType === "application/json") return "JSON Data";
+    return "File";
+  }
+  /**
+   * Format file size in human-readable format
+   */
+  formatSize(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BlobResourceHandler
+});

package/dist/resources/handlers/blob-handler.d.ts

@@ -0,0 +1,38 @@
+import type { ResourceMetadata } from '../types.js';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { BlobStore } from '../../storage/blob/types.js';
+import type { ValidatedBlobResourceConfig } from '../schemas.js';
+import type { InternalResourceHandler, InternalResourceServices } from './types.js';
+export declare class BlobResourceHandler implements InternalResourceHandler {
+    private config;
+    private blobStore;
+    constructor(config: ValidatedBlobResourceConfig, blobStore: BlobStore);
+    getType(): string;
+    initialize(_services: InternalResourceServices): Promise<void>;
+    listResources(): Promise<ResourceMetadata[]>;
+    canHandle(uri: string): boolean;
+    readResource(uri: string): Promise<ReadResourceResult>;
+    refresh(): Promise<void>;
+    getBlobStore(): BlobStore;
+    /**
+     * Generate a user-friendly display name for a blob with proper file extension
+     */
+    private generateBlobDisplayName;
+    /**
+     * Generate a descriptive base name from MIME type and source
+     */
+    private generateNameFromType;
+    /**
+     * Get file extension from MIME type
+     */
+    private getExtensionFromMimeType;
+    /**
+     * Convert MIME type to user-friendly type description
+     */
+    private getFriendlyType;
+    /**
+     * Format file size in human-readable format
+     */
+    private formatSize;
+}
+//# sourceMappingURL=blob-handler.d.ts.map

package/dist/resources/handlers/blob-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-handler.d.ts","sourceRoot":"","sources":["../../../src/resources/handlers/blob-handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAsB,MAAM,6BAA6B,CAAC;AACjF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEpF,qBAAa,mBAAoB,YAAW,uBAAuB;IAC/D,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,SAAS,CAAY;gBAEjB,MAAM,EAAE,2BAA2B,EAAE,SAAS,EAAE,SAAS;IAKrE,OAAO,IAAI,MAAM;IAIX,UAAU,CAAC,SAAS,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;IAK9D,aAAa,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAsDlD,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAsDtD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAW9B,YAAY,IAAI,SAAS;IAIzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA0B5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,UAAU;CAOrB"}

package/dist/resources/handlers/blob-handler.js

@@ -0,0 +1,207 @@
+import "../../chunk-C6A6W6XS.js";
+import { logger } from "../../logger/index.js";
+import { ResourceError } from "../errors.js";
+class BlobResourceHandler {
+  config;
+  blobStore;
+  constructor(config, blobStore) {
+    this.config = config;
+    this.blobStore = blobStore;
+  }
+  getType() {
+    return "blob";
+  }
+  async initialize(_services) {
+    logger.debug("BlobResourceHandler initialized with BlobStore");
+  }
+  async listResources() {
+    logger.debug("\u{1F50D} BlobResourceHandler.listResources() called");
+    try {
+      const stats = await this.blobStore.getStats();
+      logger.debug(`\u{1F4CA} BlobStore stats: ${stats.count} blobs, backend: ${stats.backendType}`);
+      const resources = [];
+      try {
+        const blobs = await this.blobStore.listBlobs();
+        logger.debug(`\u{1F4C4} Found ${blobs.length} individual blobs`);
+        for (const blob of blobs) {
+          if (blob.metadata.source === "system") {
+            continue;
+          }
+          const displayName = this.generateBlobDisplayName(blob.metadata, blob.id);
+          const friendlyType = this.getFriendlyType(blob.metadata.mimeType);
+          resources.push({
+            uri: blob.uri,
+            name: displayName,
+            description: `${friendlyType} (${this.formatSize(blob.metadata.size)})${blob.metadata.source ? ` \u2022 ${blob.metadata.source}` : ""}`,
+            source: "internal",
+            size: blob.metadata.size,
+            mimeType: blob.metadata.mimeType,
+            lastModified: new Date(blob.metadata.createdAt),
+            metadata: {
+              type: "blob",
+              source: blob.metadata.source,
+              hash: blob.metadata.hash,
+              createdAt: blob.metadata.createdAt,
+              originalName: blob.metadata.originalName
+            }
+          });
+        }
+      } catch (error) {
+        logger.warn(`Failed to list individual blobs: ${String(error)}`);
+      }
+      logger.debug(`\u2705 BlobResourceHandler returning ${resources.length} resources`);
+      return resources;
+    } catch (error) {
+      logger.warn(`Failed to list blob resources: ${String(error)}`);
+      return [];
+    }
+  }
+  canHandle(uri) {
+    return uri.startsWith("blob:");
+  }
+  async readResource(uri) {
+    if (!this.canHandle(uri)) {
+      throw ResourceError.noSuitableProvider(uri);
+    }
+    try {
+      const blobId = uri.substring(5);
+      if (!blobId) {
+        throw ResourceError.readFailed(uri, new Error("Invalid blob URI: missing blob ID"));
+      }
+      if (blobId === "store") {
+        const stats = await this.blobStore.getStats();
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "application/json",
+              text: JSON.stringify(stats, null, 2)
+            }
+          ]
+        };
+      }
+      const result = await this.blobStore.retrieve(blobId, "base64");
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: result.metadata.mimeType || "application/octet-stream",
+            blob: result.data
+            // base64 data from retrieve call
+          }
+        ],
+        _meta: {
+          size: result.metadata.size,
+          createdAt: result.metadata.createdAt,
+          originalName: result.metadata.originalName,
+          source: result.metadata.source
+        }
+      };
+    } catch (error) {
+      if (error instanceof ResourceError) {
+        throw error;
+      }
+      throw ResourceError.readFailed(uri, error);
+    }
+  }
+  async refresh() {
+    try {
+      await this.blobStore.cleanup();
+      logger.debug("Blob store cleanup completed");
+    } catch (error) {
+      logger.warn(`Blob store cleanup failed: ${String(error)}`);
+    }
+  }
+  getBlobStore() {
+    return this.blobStore;
+  }
+  /**
+   * Generate a user-friendly display name for a blob with proper file extension
+   */
+  generateBlobDisplayName(metadata, _blobId) {
+    if (metadata.originalName && metadata.originalName.includes(".")) {
+      return metadata.originalName;
+    }
+    let baseName = metadata.originalName || this.generateNameFromType(metadata.mimeType, metadata.source);
+    const extension = this.getExtensionFromMimeType(metadata.mimeType);
+    if (extension && !baseName.toLowerCase().endsWith(extension)) {
+      baseName += extension;
+    }
+    return baseName;
+  }
+  /**
+   * Generate a descriptive base name from MIME type and source
+   */
+  generateNameFromType(mimeType, source) {
+    if (mimeType.startsWith("image/")) {
+      if (source === "user") return "uploaded-image";
+      if (source === "tool") return "generated-image";
+      return "image";
+    }
+    if (mimeType.startsWith("text/")) {
+      if (source === "tool") return "tool-output";
+      return "text-file";
+    }
+    if (mimeType.startsWith("application/pdf")) {
+      return "document";
+    }
+    if (mimeType.startsWith("audio/")) {
+      return "audio-file";
+    }
+    if (mimeType.startsWith("video/")) {
+      return "video-file";
+    }
+    if (source === "user") return "user-upload";
+    if (source === "tool") return "tool-result";
+    return "file";
+  }
+  /**
+   * Get file extension from MIME type
+   */
+  getExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+      "image/jpeg": ".jpg",
+      "image/png": ".png",
+      "image/gif": ".gif",
+      "image/webp": ".webp",
+      "image/svg+xml": ".svg",
+      "text/plain": ".txt",
+      "text/markdown": ".md",
+      "text/html": ".html",
+      "text/css": ".css",
+      "application/json": ".json",
+      "application/pdf": ".pdf",
+      "application/xml": ".xml",
+      "audio/mpeg": ".mp3",
+      "audio/wav": ".wav",
+      "video/mp4": ".mp4",
+      "video/webm": ".webm"
+    };
+    return mimeToExt[mimeType] || "";
+  }
+  /**
+   * Convert MIME type to user-friendly type description
+   */
+  getFriendlyType(mimeType) {
+    if (mimeType.startsWith("image/")) return "Image";
+    if (mimeType.startsWith("text/")) return "Text File";
+    if (mimeType.startsWith("audio/")) return "Audio File";
+    if (mimeType.startsWith("video/")) return "Video File";
+    if (mimeType === "application/pdf") return "PDF Document";
+    if (mimeType === "application/json") return "JSON Data";
+    return "File";
+  }
+  /**
+   * Format file size in human-readable format
+   */
+  formatSize(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+  }
+}
+export {
+  BlobResourceHandler
+};

package/dist/resources/handlers/factory.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  createInternalResourceHandler: () => createInternalResourceHandler,
+  getInternalResourceHandlerTypes: () => getInternalResourceHandlerTypes
+});
+module.exports = __toCommonJS(factory_exports);
+var import_errors = require("../errors.js");
+var import_filesystem_handler = require("./filesystem-handler.js");
+var import_blob_handler = require("./blob-handler.js");
+function createInternalResourceHandler(config, services) {
+  const type = config.type;
+  if (type === "filesystem") {
+    const blobStoragePath = services.blobStore.getStoragePath();
+    return new import_filesystem_handler.FileSystemResourceHandler(config, blobStoragePath);
+  }
+  if (type === "blob") {
+    return new import_blob_handler.BlobResourceHandler(config, services.blobStore);
+  }
+  throw import_errors.ResourceError.providerError(
+    "Internal",
+    "createInternalResourceHandler",
+    `Unsupported internal resource handler type: ${type}`
+  );
+}
+function getInternalResourceHandlerTypes() {
+  return ["filesystem", "blob"];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInternalResourceHandler,
+  getInternalResourceHandlerTypes
+});

package/dist/resources/handlers/factory.d.ts

@@ -0,0 +1,11 @@
+import type { InternalResourceServices, InternalResourceHandler } from './types.js';
+import type { ValidatedInternalResourceConfig } from '../schemas.js';
+/**
+ * Factory function for creating internal resource handlers
+ */
+export declare function createInternalResourceHandler(config: ValidatedInternalResourceConfig, services: InternalResourceServices): InternalResourceHandler;
+/**
+ * Get all supported internal resource handler types
+ */
+export declare function getInternalResourceHandlerTypes(): string[];
+//# sourceMappingURL=factory.d.ts.map

package/dist/resources/handlers/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/resources/handlers/factory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACpF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,eAAe,CAAC;AAErE;;GAEG;AACH,wBAAgB,6BAA6B,CACzC,MAAM,EAAE,+BAA+B,EACvC,QAAQ,EAAE,wBAAwB,GACnC,uBAAuB,CAezB;AAED;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,EAAE,CAE1D"}