@dexto/core 1.1.10 → 1.2.0

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

@@ -0,0 +1,352 @@
+import "../../chunk-C6A6W6XS.js";
+import { promises as fs } from "fs";
+import path from "path";
+import { logger } from "../../logger/index.js";
+import { ResourceError } from "../errors.js";
+class FileSystemResourceHandler {
+  config;
+  resourcesCache = /* @__PURE__ */ new Map();
+  visitedPaths = /* @__PURE__ */ new Set();
+  fileCount = 0;
+  canonicalRoots = [];
+  blobStoragePath;
+  constructor(config, blobStoragePath) {
+    this.config = config;
+    this.blobStoragePath = blobStoragePath;
+  }
+  getType() {
+    return "filesystem";
+  }
+  async initialize(_services) {
+    this.canonicalRoots = [];
+    for (const configPath of this.config.paths) {
+      try {
+        const canonicalRoot = await fs.realpath(path.resolve(configPath));
+        this.canonicalRoots.push(canonicalRoot);
+      } catch (error) {
+        logger.warn(
+          `Failed to canonicalize root path '${configPath}': ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    await this.buildResourceCache();
+  }
+  async listResources() {
+    return Array.from(this.resourcesCache.values());
+  }
+  canHandle(uri) {
+    return uri.startsWith("fs://");
+  }
+  isPathAllowed(canonicalPath) {
+    return this.canonicalRoots.some((root) => {
+      const normalizedPath = path.normalize(canonicalPath);
+      const normalizedRoot = path.normalize(root);
+      return normalizedPath.startsWith(normalizedRoot + path.sep) || normalizedPath === normalizedRoot;
+    });
+  }
+  /**
+   * Check if a path is a blob storage directory that should be excluded
+   * from filesystem resource scanning to avoid conflicts with BlobResourceHandler
+   */
+  isBlobStorageDirectory(canonicalPath) {
+    if (!this.blobStoragePath) {
+      return false;
+    }
+    const normalizedPath = path.normalize(canonicalPath);
+    const normalizedBlobPath = path.normalize(this.blobStoragePath);
+    return normalizedPath === normalizedBlobPath || normalizedPath.startsWith(normalizedBlobPath + path.sep);
+  }
+  async readResource(uri) {
+    if (!this.canHandle(uri)) {
+      throw ResourceError.noSuitableProvider(uri);
+    }
+    const filePath = uri.replace("fs://", "");
+    const resolvedPath = path.resolve(filePath);
+    let canonicalPath;
+    try {
+      canonicalPath = await fs.realpath(resolvedPath);
+    } catch (_error) {
+      throw ResourceError.resourceNotFound(uri);
+    }
+    if (!this.isPathAllowed(canonicalPath)) {
+      throw ResourceError.accessDenied(uri);
+    }
+    try {
+      const stat = await fs.stat(canonicalPath);
+      if (stat.size > 10 * 1024 * 1024) {
+        throw ResourceError.readFailed(uri, `File too large (${stat.size} bytes)`);
+      }
+      if (this.isBinaryFile(canonicalPath)) {
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: "text/plain",
+              text: `[Binary file: ${path.basename(canonicalPath)} (${stat.size} bytes)]`
+            }
+          ],
+          _meta: {
+            isBinary: true,
+            size: stat.size,
+            originalMimeType: this.getMimeType(canonicalPath)
+          }
+        };
+      }
+      const content = await fs.readFile(canonicalPath, "utf-8");
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: this.getMimeType(canonicalPath),
+            text: content
+          }
+        ],
+        _meta: { size: stat.size }
+      };
+    } catch (error) {
+      throw ResourceError.readFailed(uri, error);
+    }
+  }
+  isBinaryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const binaryExtensions = [
+      ".exe",
+      ".dll",
+      ".so",
+      ".dylib",
+      ".bin",
+      ".dat",
+      ".db",
+      ".sqlite",
+      ".jpg",
+      ".jpeg",
+      ".png",
+      ".gif",
+      ".bmp",
+      ".ico",
+      ".tiff",
+      ".webp",
+      ".mp3",
+      ".mp4",
+      ".avi",
+      ".mov",
+      ".wmv",
+      ".flv",
+      ".mkv",
+      ".webm",
+      ".pdf",
+      ".zip",
+      ".tar",
+      ".gz",
+      ".7z",
+      ".rar",
+      ".dmg",
+      ".iso",
+      ".woff",
+      ".woff2",
+      ".ttf",
+      ".otf",
+      ".eot",
+      ".class",
+      ".jar",
+      ".war",
+      ".ear",
+      ".o",
+      ".obj",
+      ".lib",
+      ".a"
+    ];
+    return binaryExtensions.includes(ext);
+  }
+  async refresh() {
+    await this.buildResourceCache();
+  }
+  async buildResourceCache() {
+    if (!this.config) return;
+    this.resourcesCache.clear();
+    this.visitedPaths.clear();
+    this.fileCount = 0;
+    const { maxFiles, paths } = this.config;
+    for (const configPath of paths) {
+      if (this.fileCount >= maxFiles) {
+        logger.warn(`Reached maximum file limit (${maxFiles}), stopping scan`);
+        break;
+      }
+      try {
+        const root = await fs.realpath(path.resolve(configPath));
+        await this.scanPath(root, 0, root);
+      } catch (error) {
+        logger.warn(
+          `Failed to scan path '${configPath}': ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    logger.debug(
+      `FileSystem resources cached: ${this.resourcesCache.size} resources (${this.fileCount} files scanned)`
+    );
+  }
+  async scanPath(targetPath, currentDepth, rootBase) {
+    const resolvedPath = path.resolve(targetPath);
+    let canonical;
+    try {
+      canonical = await fs.realpath(resolvedPath);
+    } catch {
+      return;
+    }
+    if (!this.isPathAllowed(canonical)) return;
+    if (this.isBlobStorageDirectory(canonical)) {
+      return;
+    }
+    const { maxDepth, maxFiles, includeHidden, includeExtensions } = this.config;
+    if (this.fileCount >= maxFiles) return;
+    if (currentDepth > maxDepth) {
+      logger.silly(`Skipping path due to depth limit (${maxDepth}): ${canonical}`);
+      return;
+    }
+    if (this.visitedPaths.has(canonical)) return;
+    this.visitedPaths.add(canonical);
+    try {
+      const stat = await fs.stat(canonical);
+      if (stat.isFile()) {
+        if (!this.shouldIncludeFile(canonical, includeExtensions, includeHidden)) return;
+        const uri = `fs://${canonical.replace(/\\/g, "/")}`;
+        this.resourcesCache.set(uri, {
+          uri,
+          name: this.generateCleanFileName(canonical),
+          description: "Filesystem resource",
+          source: "internal",
+          size: stat.size,
+          lastModified: stat.mtime
+        });
+        this.fileCount++;
+        return;
+      }
+      if (stat.isDirectory()) {
+        const entries = await fs.readdir(canonical);
+        for (const entry of entries) {
+          const entryPath = path.join(canonical, entry);
+          await this.scanPath(
+            entryPath,
+            currentDepth + 1,
+            rootBase ?? this.canonicalRoots.find((r) => canonical.startsWith(r))
+          );
+        }
+      }
+    } catch (error) {
+      logger.debug(
+        `Skipping inaccessible path: ${canonical} - ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  shouldIncludeFile(filePath, includeExtensions, includeHidden) {
+    const basename = path.basename(filePath).toLowerCase();
+    const ext = path.extname(filePath).toLowerCase();
+    if (basename.startsWith(".")) {
+      if (!includeHidden) {
+        const allowedDotfiles = [
+          ".gitignore",
+          ".env",
+          ".env.example",
+          ".npmignore",
+          ".dockerignore",
+          ".editorconfig"
+        ];
+        if (!allowedDotfiles.includes(basename)) return false;
+      }
+      if (basename === ".env" || basename.startsWith(".env.")) return true;
+    }
+    if (!ext) {
+      const commonNoExtFiles = [
+        "dockerfile",
+        "makefile",
+        "readme",
+        "license",
+        "changelog",
+        "contributing"
+      ];
+      return commonNoExtFiles.some((common) => basename.includes(common));
+    }
+    if (basename === ".gitignore") return true;
+    return includeExtensions.includes(ext);
+  }
+  /**
+   * Generate a clean, user-friendly filename from a potentially messy path
+   */
+  generateCleanFileName(filePath) {
+    const basename = path.basename(filePath);
+    if (basename.startsWith("Screenshot ") && basename.includes(" at ")) {
+      const match = basename.match(/^Screenshot (\d{4}-\d{2}-\d{2}).*?(\.[^.]+)$/);
+      if (match) {
+        return `Screenshot ${match[1]}${match[2]}`;
+      }
+    }
+    if (basename.length > 50) {
+      const ext = path.extname(basename);
+      const nameWithoutExt = path.basename(basename, ext);
+      const patterns = [
+        /Screenshot.*(\d{4}-\d{2}-\d{2})/,
+        /([A-Za-z\s]+\d{4}-\d{2}-\d{2})/,
+        /(image|photo|file).*(\d+)/i
+      ];
+      for (const pattern of patterns) {
+        const match = nameWithoutExt.match(pattern);
+        if (match) {
+          return `${match[1] || match[0]}${ext}`;
+        }
+      }
+      if (nameWithoutExt.length > 30) {
+        return `${nameWithoutExt.substring(0, 30)}...${ext}`;
+      }
+    }
+    return basename;
+  }
+  getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+      ".txt": "text/plain",
+      ".md": "text/markdown",
+      ".markdown": "text/markdown",
+      ".html": "text/html",
+      ".htm": "text/html",
+      ".css": "text/css",
+      ".js": "text/javascript",
+      ".mjs": "text/javascript",
+      ".jsx": "text/javascript",
+      ".ts": "text/typescript",
+      ".tsx": "text/typescript",
+      ".vue": "text/x-vue",
+      ".json": "application/json",
+      ".xml": "text/xml",
+      ".yaml": "text/yaml",
+      ".yml": "text/yaml",
+      ".toml": "text/toml",
+      ".ini": "text/plain",
+      ".cfg": "text/plain",
+      ".conf": "text/plain",
+      ".py": "text/x-python",
+      ".rb": "text/x-ruby",
+      ".php": "text/x-php",
+      ".java": "text/x-java",
+      ".kt": "text/x-kotlin",
+      ".swift": "text/x-swift",
+      ".go": "text/x-go",
+      ".rs": "text/x-rust",
+      ".cpp": "text/x-c++",
+      ".c": "text/x-c",
+      ".h": "text/x-c",
+      ".hpp": "text/x-c++",
+      ".sh": "text/x-shellscript",
+      ".bash": "text/x-shellscript",
+      ".zsh": "text/x-shellscript",
+      ".fish": "text/x-shellscript",
+      ".sql": "text/x-sql",
+      ".rst": "text/x-rst",
+      ".tex": "text/x-tex",
+      ".dockerfile": "text/x-dockerfile"
+    };
+    return mimeTypes[ext] || "text/plain";
+  }
+}
+export {
+  FileSystemResourceHandler
+};

package/dist/resources/handlers/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,15 @@
+import type { ResourceMetadata } from '../types.js';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { BlobStore } from '../../storage/blob/types.js';
+export type InternalResourceServices = {
+    blobStore: BlobStore;
+};
+export interface InternalResourceHandler {
+    getType(): string;
+    initialize(services: InternalResourceServices): Promise<void>;
+    listResources(): Promise<ResourceMetadata[]>;
+    readResource(uri: string): Promise<ReadResourceResult>;
+    canHandle(uri: string): boolean;
+    refresh?(): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resources/handlers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,MAAM,MAAM,wBAAwB,GAAG;IACnC,SAAS,EAAE,SAAS,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,uBAAuB;IACpC,OAAO,IAAI,MAAM,CAAC;IAClB,UAAU,CAAC,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,aAAa,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC7C,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACvD,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B"}

package/dist/resources/index.cjs

@@ -0,0 +1,58 @@
+"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 resources_exports = {};
+__export(resources_exports, {
+  InternalResourceConfigSchema: () => import_schemas.InternalResourceConfigSchema,
+  InternalResourcesProvider: () => import_internal_provider.InternalResourcesProvider,
+  InternalResourcesSchema: () => import_schemas.InternalResourcesSchema,
+  ResourceError: () => import_errors.ResourceError,
+  ResourceErrorCodes: () => import_error_codes.ResourceErrorCodes,
+  ResourceManager: () => import_manager.ResourceManager,
+  createInternalResourceHandler: () => import_factory.createInternalResourceHandler,
+  expandMessageReferences: () => import_reference_parser.expandMessageReferences,
+  formatResourceContent: () => import_reference_parser.formatResourceContent,
+  getInternalResourceHandlerTypes: () => import_factory.getInternalResourceHandlerTypes,
+  isInternalResourcesEnabled: () => import_schemas.isInternalResourcesEnabled,
+  parseResourceReferences: () => import_reference_parser.parseResourceReferences,
+  resolveResourceReferences: () => import_reference_parser.resolveResourceReferences
+});
+module.exports = __toCommonJS(resources_exports);
+var import_manager = require("./manager.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+var import_internal_provider = require("./internal-provider.js");
+var import_factory = require("./handlers/factory.js");
+var import_reference_parser = require("./reference-parser.js");
+var import_schemas = require("./schemas.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalResourceConfigSchema,
+  InternalResourcesProvider,
+  InternalResourcesSchema,
+  ResourceError,
+  ResourceErrorCodes,
+  ResourceManager,
+  createInternalResourceHandler,
+  expandMessageReferences,
+  formatResourceContent,
+  getInternalResourceHandlerTypes,
+  isInternalResourcesEnabled,
+  parseResourceReferences,
+  resolveResourceReferences
+});

package/dist/resources/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Resource management module exports
+ * Organized into thematic sub-barrels for better tree-shaking and maintainability
+ */
+export type { ResourceSource, ResourceMetadata, ResourceProvider, ResourceSet } from './types.js';
+export type { InternalResourcesConfig, ValidatedInternalResourcesConfig, ValidatedInternalResourceConfig, ValidatedFileSystemResourceConfig, ValidatedBlobResourceConfig, } from './schemas.js';
+export { ResourceManager } from './manager.js';
+export { ResourceError } from './errors.js';
+export { ResourceErrorCodes } from './error-codes.js';
+export type { InternalResourceHandler, InternalResourceServices } from './handlers/types.js';
+export { InternalResourcesProvider } from './internal-provider.js';
+export { createInternalResourceHandler, getInternalResourceHandlerTypes, } from './handlers/factory.js';
+/**
+ * Resource References
+ *
+ * Resource references allow you to include resource content in messages using @ syntax:
+ *
+ * Syntax:
+ * - Simple name: @filename.txt
+ * - URI with brackets: @<file:///path/to/file.txt>
+ * - Server-scoped: @servername:resource-identifier
+ *
+ * Important: @ symbols are ONLY treated as resource references if they:
+ * 1. Are at the start of the message, OR
+ * 2. Are preceded by whitespace (space, tab, newline)
+ *
+ * This means email addresses like "user@example.com" are automatically ignored
+ * without requiring any escape sequences. No special handling needed!
+ *
+ * Examples:
+ * - "@myfile.txt" → resource reference (at start)
+ * - "Check @myfile.txt" → resource reference (after space)
+ * - "user@example.com" → literal text (no leading space)
+ * - "See @file1.txt and email user@example.com" → only @file1.txt is a reference
+ */
+export type { ResourceReference, ResourceExpansionResult } from './reference-parser.js';
+export { parseResourceReferences, resolveResourceReferences, expandMessageReferences, formatResourceContent, } from './reference-parser.js';
+export { InternalResourceConfigSchema, InternalResourcesSchema, isInternalResourcesEnabled, } from './schemas.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElG,YAAY,EACR,uBAAuB,EACvB,gCAAgC,EAChC,+BAA+B,EAC/B,iCAAiC,EACjC,2BAA2B,GAC9B,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGtD,YAAY,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EACH,6BAA6B,EAC7B,+BAA+B,GAClC,MAAM,uBAAuB,CAAC;AAG/B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,YAAY,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACxF,OAAO,EACH,uBAAuB,EACvB,yBAAyB,EACzB,uBAAuB,EACvB,qBAAqB,GACxB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,GAC7B,MAAM,cAAc,CAAC"}

package/dist/resources/index.js

@@ -0,0 +1,35 @@
+import "../chunk-C6A6W6XS.js";
+import { ResourceManager } from "./manager.js";
+import { ResourceError } from "./errors.js";
+import { ResourceErrorCodes } from "./error-codes.js";
+import { InternalResourcesProvider } from "./internal-provider.js";
+import {
+  createInternalResourceHandler,
+  getInternalResourceHandlerTypes
+} from "./handlers/factory.js";
+import {
+  parseResourceReferences,
+  resolveResourceReferences,
+  expandMessageReferences,
+  formatResourceContent
+} from "./reference-parser.js";
+import {
+  InternalResourceConfigSchema,
+  InternalResourcesSchema,
+  isInternalResourcesEnabled
+} from "./schemas.js";
+export {
+  InternalResourceConfigSchema,
+  InternalResourcesProvider,
+  InternalResourcesSchema,
+  ResourceError,
+  ResourceErrorCodes,
+  ResourceManager,
+  createInternalResourceHandler,
+  expandMessageReferences,
+  formatResourceContent,
+  getInternalResourceHandlerTypes,
+  isInternalResourcesEnabled,
+  parseResourceReferences,
+  resolveResourceReferences
+};

package/dist/resources/internal-provider.cjs

@@ -0,0 +1,141 @@
+"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 internal_provider_exports = {};
+__export(internal_provider_exports, {
+  InternalResourcesProvider: () => InternalResourcesProvider
+});
+module.exports = __toCommonJS(internal_provider_exports);
+var import_logger = require("../logger/index.js");
+var import_factory = require("./handlers/factory.js");
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+class InternalResourcesProvider {
+  config;
+  handlers = /* @__PURE__ */ new Map();
+  services;
+  constructor(config, services) {
+    this.config = config;
+    this.services = services;
+    import_logger.logger.debug(
+      `InternalResourcesProvider initialized with config: ${JSON.stringify(config)}`
+    );
+  }
+  async initialize() {
+    if (!this.config.enabled || this.config.resources.length === 0) {
+      import_logger.logger.debug("Internal resources disabled or no resources configured");
+      return;
+    }
+    for (const resourceConfig of this.config.resources) {
+      try {
+        const parsedConfig = import_schemas.InternalResourceConfigSchema.parse(resourceConfig);
+        const handler = (0, import_factory.createInternalResourceHandler)(parsedConfig, this.services);
+        await handler.initialize(this.services);
+        this.handlers.set(resourceConfig.type, handler);
+        import_logger.logger.debug(`Initialized ${resourceConfig.type} resource handler`);
+      } catch (error) {
+        import_logger.logger.error(`Failed to initialize ${resourceConfig.type} resource handler`, error);
+      }
+    }
+    import_logger.logger.debug(
+      `InternalResourcesProvider initialized with ${this.handlers.size} resource handlers`
+    );
+  }
+  getSource() {
+    return "internal";
+  }
+  async listResources() {
+    const allResources = [];
+    for (const [type, handler] of this.handlers.entries()) {
+      try {
+        const resources = await handler.listResources();
+        allResources.push(...resources);
+      } catch (error) {
+        import_logger.logger.error(
+          `Failed to list resources from ${type} handler: ${error instanceof Error ? error.message : String(error)}`,
+          error
+        );
+      }
+    }
+    return allResources;
+  }
+  async hasResource(uri) {
+    for (const handler of this.handlers.values()) {
+      if (handler.canHandle(uri)) return true;
+    }
+    return false;
+  }
+  async readResource(uri) {
+    for (const [type, handler] of this.handlers.entries()) {
+      if (handler.canHandle(uri)) {
+        try {
+          return await handler.readResource(uri);
+        } catch (error) {
+          import_logger.logger.error(
+            `Failed to read resource ${uri} from ${type} handler: ${error instanceof Error ? error.message : String(error)}`,
+            error
+          );
+          throw error;
+        }
+      }
+    }
+    throw import_errors.ResourceError.noSuitableProvider(uri);
+  }
+  async refresh() {
+    for (const [type, handler] of this.handlers.entries()) {
+      if (handler.refresh) {
+        try {
+          await handler.refresh();
+          import_logger.logger.debug(`Refreshed ${type} resource handler`);
+        } catch (error) {
+          import_logger.logger.error(
+            `Failed to refresh ${type} resource handler: ${error instanceof Error ? error.message : String(error)}`,
+            error
+          );
+        }
+      }
+    }
+  }
+  async addResourceConfig(config) {
+    try {
+      const parsedConfig = import_schemas.InternalResourceConfigSchema.parse(config);
+      const handler = (0, import_factory.createInternalResourceHandler)(parsedConfig, this.services);
+      await handler.initialize(this.services);
+      this.handlers.set(config.type, handler);
+      this.config.resources.push(parsedConfig);
+      import_logger.logger.info(`Added new ${config.type} resource handler`);
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to add ${config.type} resource handler: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async removeResourceHandler(type) {
+    if (this.handlers.has(type)) {
+      this.handlers.delete(type);
+      this.config.resources = this.config.resources.filter((r) => r.type !== type);
+      import_logger.logger.info(`Removed ${type} resource handler`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalResourcesProvider
+});