@dexto/core 1.3.0 → 1.5.0

package/dist/providers/base-registry.cjs

@@ -0,0 +1,147 @@
+"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 base_registry_exports = {};
+__export(base_registry_exports, {
+  BaseRegistry: () => BaseRegistry,
+  defaultErrorFactory: () => defaultErrorFactory
+});
+module.exports = __toCommonJS(base_registry_exports);
+var import_zod = require("zod");
+const defaultErrorFactory = {
+  alreadyRegistered: (type) => new Error(`Provider '${type}' is already registered`),
+  notFound: (type, availableTypes) => new Error(
+    `Provider '${type}' not found. Available: ${availableTypes.join(", ") || "none"}`
+  )
+};
+class BaseRegistry {
+  providers = /* @__PURE__ */ new Map();
+  errorFactory;
+  /**
+   * Create a new registry instance.
+   *
+   * @param errorFactory - Optional custom error factory for registry errors.
+   *                       If not provided, uses default Error instances.
+   */
+  constructor(errorFactory = defaultErrorFactory) {
+    this.errorFactory = errorFactory;
+  }
+  /**
+   * Register a provider.
+   *
+   * @param provider - The provider to register
+   * @throws Error if a provider with the same type is already registered
+   */
+  register(provider) {
+    if (this.providers.has(provider.type)) {
+      throw this.errorFactory.alreadyRegistered(provider.type);
+    }
+    this.providers.set(provider.type, provider);
+  }
+  /**
+   * Unregister a provider.
+   *
+   * @param type - The provider type to unregister
+   * @returns true if the provider was unregistered, false if it wasn't registered
+   */
+  unregister(type) {
+    return this.providers.delete(type);
+  }
+  /**
+   * Get a registered provider by type.
+   *
+   * @param type - The provider type identifier
+   * @returns The provider if found, undefined otherwise
+   */
+  get(type) {
+    return this.providers.get(type);
+  }
+  /**
+   * Check if a provider is registered.
+   *
+   * @param type - The provider type identifier
+   * @returns true if registered, false otherwise
+   */
+  has(type) {
+    return this.providers.has(type);
+  }
+  /**
+   * Get all registered provider types.
+   *
+   * @returns Array of provider type identifiers
+   */
+  getTypes() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Get all registered providers.
+   *
+   * @returns Array of providers
+   */
+  getAll() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * Get the number of registered providers.
+   *
+   * @returns Count of registered providers
+   */
+  get size() {
+    return this.providers.size;
+  }
+  /**
+   * Clear all registered providers.
+   * Primarily useful for testing.
+   */
+  clear() {
+    this.providers.clear();
+  }
+  /**
+   * Validate a configuration against a provider's schema.
+   *
+   * This method is only available for registries with providers that have
+   * a configSchema property. It:
+   * 1. Extracts the 'type' field to identify the provider
+   * 2. Looks up the provider in the registry
+   * 3. Validates the full config against the provider's schema
+   * 4. Returns the validated configuration
+   *
+   * @param config - Raw configuration object with a 'type' field
+   * @returns Validated configuration object
+   * @throws Error if type is missing, provider not found, or validation fails
+   */
+  validateConfig(config) {
+    const typeSchema = import_zod.z.object({ type: import_zod.z.string() }).passthrough();
+    const parsed = typeSchema.parse(config);
+    const provider = this.providers.get(parsed.type);
+    if (!provider) {
+      throw this.errorFactory.notFound(parsed.type, this.getTypes());
+    }
+    if (!("configSchema" in provider) || !provider.configSchema) {
+      throw new Error(
+        `Provider '${parsed.type}' does not support config validation (no configSchema)`
+      );
+    }
+    return provider.configSchema.parse(config);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseRegistry,
+  defaultErrorFactory
+});

package/dist/providers/base-registry.d.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+/**
+ * Base provider interface - all providers must have a type identifier.
+ */
+export interface BaseProvider {
+    /** Unique type identifier for this provider */
+    type: string;
+}
+/**
+ * Provider with config schema - for providers that support validateConfig.
+ */
+export interface ConfigurableProvider extends BaseProvider {
+    /** Zod schema for validating provider configuration */
+    configSchema: z.ZodType<any, any, any>;
+}
+/**
+ * Error factory interface for customizing registry errors.
+ * Each registry can provide its own error implementations.
+ */
+export interface RegistryErrorFactory {
+    /** Called when attempting to register a provider that already exists */
+    alreadyRegistered(type: string): Error;
+    /** Called when looking up a provider that doesn't exist (for validateConfig) */
+    notFound(type: string, availableTypes: string[]): Error;
+}
+/**
+ * Default error factory that throws plain Error instances.
+ * Used when no custom error factory is provided.
+ */
+export declare const defaultErrorFactory: RegistryErrorFactory;
+/**
+ * Generic base registry for provider patterns.
+ *
+ * This class provides common registry functionality used across Dexto's
+ * provider system (blob storage, compression, custom tools, etc.).
+ *
+ * Features:
+ * - Type-safe provider registration and retrieval
+ * - Duplicate registration prevention
+ * - Customizable error handling via error factory
+ * - Optional config validation for providers with schemas
+ *
+ * @template TProvider - The provider type (must extend BaseProvider)
+ *
+ * @example
+ * ```typescript
+ * // Define your provider interface
+ * interface MyProvider extends BaseProvider {
+ *   type: string;
+ *   configSchema: z.ZodType<any>;
+ *   create(config: any): MyInstance;
+ * }
+ *
+ * // Create a registry
+ * class MyRegistry extends BaseRegistry<MyProvider> {
+ *   constructor() {
+ *     super({
+ *       alreadyRegistered: (type) => new MyError(`Provider ${type} exists`),
+ *       notFound: (type, available) => new MyError(`Unknown: ${type}`),
+ *     });
+ *   }
+ * }
+ *
+ * // Use the registry
+ * const registry = new MyRegistry();
+ * registry.register(myProvider);
+ * const provider = registry.get('my-type');
+ * ```
+ */
+export declare class BaseRegistry<TProvider extends BaseProvider> {
+    protected providers: Map<string, TProvider>;
+    protected errorFactory: RegistryErrorFactory;
+    /**
+     * Create a new registry instance.
+     *
+     * @param errorFactory - Optional custom error factory for registry errors.
+     *                       If not provided, uses default Error instances.
+     */
+    constructor(errorFactory?: RegistryErrorFactory);
+    /**
+     * Register a provider.
+     *
+     * @param provider - The provider to register
+     * @throws Error if a provider with the same type is already registered
+     */
+    register(provider: TProvider): void;
+    /**
+     * Unregister a provider.
+     *
+     * @param type - The provider type to unregister
+     * @returns true if the provider was unregistered, false if it wasn't registered
+     */
+    unregister(type: string): boolean;
+    /**
+     * Get a registered provider by type.
+     *
+     * @param type - The provider type identifier
+     * @returns The provider if found, undefined otherwise
+     */
+    get(type: string): TProvider | undefined;
+    /**
+     * Check if a provider is registered.
+     *
+     * @param type - The provider type identifier
+     * @returns true if registered, false otherwise
+     */
+    has(type: string): boolean;
+    /**
+     * Get all registered provider types.
+     *
+     * @returns Array of provider type identifiers
+     */
+    getTypes(): string[];
+    /**
+     * Get all registered providers.
+     *
+     * @returns Array of providers
+     */
+    getAll(): TProvider[];
+    /**
+     * Get the number of registered providers.
+     *
+     * @returns Count of registered providers
+     */
+    get size(): number;
+    /**
+     * Clear all registered providers.
+     * Primarily useful for testing.
+     */
+    clear(): void;
+    /**
+     * Validate a configuration against a provider's schema.
+     *
+     * This method is only available for registries with providers that have
+     * a configSchema property. It:
+     * 1. Extracts the 'type' field to identify the provider
+     * 2. Looks up the provider in the registry
+     * 3. Validates the full config against the provider's schema
+     * 4. Returns the validated configuration
+     *
+     * @param config - Raw configuration object with a 'type' field
+     * @returns Validated configuration object
+     * @throws Error if type is missing, provider not found, or validation fails
+     */
+    validateConfig(config: unknown): any;
+}
+//# sourceMappingURL=base-registry.d.ts.map

package/dist/providers/base-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-registry.d.ts","sourceRoot":"","sources":["../../src/providers/base-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACtD,uDAAuD;IACvD,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACjC,wEAAwE;IACxE,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACvC,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;CAC3D;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,oBAMjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,YAAY,CAAC,SAAS,SAAS,YAAY;IACpD,SAAS,CAAC,SAAS,yBAAgC;IACnD,SAAS,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAE7C;;;;;OAKG;gBACS,YAAY,GAAE,oBAA0C;IAIpE;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI;IAOnC;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIxC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;;OAIG;IACH,QAAQ,IAAI,MAAM,EAAE;IAIpB;;;;OAIG;IACH,MAAM,IAAI,SAAS,EAAE;IAIrB;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,GAAG;CAqBvC"}

package/dist/providers/base-registry.js

@@ -0,0 +1,123 @@
+import "../chunk-PTJYTZNU.js";
+import { z } from "zod";
+const defaultErrorFactory = {
+  alreadyRegistered: (type) => new Error(`Provider '${type}' is already registered`),
+  notFound: (type, availableTypes) => new Error(
+    `Provider '${type}' not found. Available: ${availableTypes.join(", ") || "none"}`
+  )
+};
+class BaseRegistry {
+  providers = /* @__PURE__ */ new Map();
+  errorFactory;
+  /**
+   * Create a new registry instance.
+   *
+   * @param errorFactory - Optional custom error factory for registry errors.
+   *                       If not provided, uses default Error instances.
+   */
+  constructor(errorFactory = defaultErrorFactory) {
+    this.errorFactory = errorFactory;
+  }
+  /**
+   * Register a provider.
+   *
+   * @param provider - The provider to register
+   * @throws Error if a provider with the same type is already registered
+   */
+  register(provider) {
+    if (this.providers.has(provider.type)) {
+      throw this.errorFactory.alreadyRegistered(provider.type);
+    }
+    this.providers.set(provider.type, provider);
+  }
+  /**
+   * Unregister a provider.
+   *
+   * @param type - The provider type to unregister
+   * @returns true if the provider was unregistered, false if it wasn't registered
+   */
+  unregister(type) {
+    return this.providers.delete(type);
+  }
+  /**
+   * Get a registered provider by type.
+   *
+   * @param type - The provider type identifier
+   * @returns The provider if found, undefined otherwise
+   */
+  get(type) {
+    return this.providers.get(type);
+  }
+  /**
+   * Check if a provider is registered.
+   *
+   * @param type - The provider type identifier
+   * @returns true if registered, false otherwise
+   */
+  has(type) {
+    return this.providers.has(type);
+  }
+  /**
+   * Get all registered provider types.
+   *
+   * @returns Array of provider type identifiers
+   */
+  getTypes() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Get all registered providers.
+   *
+   * @returns Array of providers
+   */
+  getAll() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * Get the number of registered providers.
+   *
+   * @returns Count of registered providers
+   */
+  get size() {
+    return this.providers.size;
+  }
+  /**
+   * Clear all registered providers.
+   * Primarily useful for testing.
+   */
+  clear() {
+    this.providers.clear();
+  }
+  /**
+   * Validate a configuration against a provider's schema.
+   *
+   * This method is only available for registries with providers that have
+   * a configSchema property. It:
+   * 1. Extracts the 'type' field to identify the provider
+   * 2. Looks up the provider in the registry
+   * 3. Validates the full config against the provider's schema
+   * 4. Returns the validated configuration
+   *
+   * @param config - Raw configuration object with a 'type' field
+   * @returns Validated configuration object
+   * @throws Error if type is missing, provider not found, or validation fails
+   */
+  validateConfig(config) {
+    const typeSchema = z.object({ type: z.string() }).passthrough();
+    const parsed = typeSchema.parse(config);
+    const provider = this.providers.get(parsed.type);
+    if (!provider) {
+      throw this.errorFactory.notFound(parsed.type, this.getTypes());
+    }
+    if (!("configSchema" in provider) || !provider.configSchema) {
+      throw new Error(
+        `Provider '${parsed.type}' does not support config validation (no configSchema)`
+      );
+    }
+    return provider.configSchema.parse(config);
+  }
+}
+export {
+  BaseRegistry,
+  defaultErrorFactory
+};

package/dist/providers/discovery.cjs

@@ -0,0 +1,95 @@
+"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 discovery_exports = {};
+__export(discovery_exports, {
+  getProvidersByCategory: () => getProvidersByCategory,
+  hasProvider: () => hasProvider,
+  listAllProviders: () => listAllProviders
+});
+module.exports = __toCommonJS(discovery_exports);
+var import_blob = require("../storage/blob/index.js");
+var import_compaction = require("../context/compaction/index.js");
+var import_custom_tool_registry = require("../tools/custom-tool-registry.js");
+var import_constants = require("../tools/internal-tools/constants.js");
+var import_registry = require("../tools/internal-tools/registry.js");
+function listAllProviders() {
+  const blobProviders = import_blob.blobStoreRegistry.getProviders().map((provider) => {
+    const info = {
+      type: provider.type,
+      category: "blob"
+    };
+    if (provider.metadata) {
+      info.metadata = provider.metadata;
+    }
+    return info;
+  });
+  const compactionProviders = import_compaction.compactionRegistry.getAll().map((provider) => {
+    const info = {
+      type: provider.type,
+      category: "compaction"
+    };
+    if (provider.metadata) {
+      info.metadata = provider.metadata;
+    }
+    return info;
+  });
+  const customToolProviders = import_custom_tool_registry.customToolRegistry.getTypes().map((type) => {
+    const provider = import_custom_tool_registry.customToolRegistry.get(type);
+    const info = {
+      type,
+      category: "customTools"
+    };
+    if (provider?.metadata) {
+      info.metadata = provider.metadata;
+    }
+    return info;
+  });
+  const internalTools = import_constants.INTERNAL_TOOL_NAMES.map((name) => ({
+    name,
+    description: import_registry.INTERNAL_TOOL_REGISTRY[name].description
+  }));
+  return {
+    blob: blobProviders,
+    compaction: compactionProviders,
+    customTools: customToolProviders,
+    internalTools
+  };
+}
+function getProvidersByCategory(category) {
+  const allProviders = listAllProviders();
+  return allProviders[category];
+}
+function hasProvider(category, type) {
+  switch (category) {
+    case "blob":
+      return import_blob.blobStoreRegistry.has(type);
+    case "compaction":
+      return import_compaction.compactionRegistry.has(type);
+    case "customTools":
+      return import_custom_tool_registry.customToolRegistry.has(type);
+    default:
+      return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getProvidersByCategory,
+  hasProvider,
+  listAllProviders
+});

package/dist/providers/discovery.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Information about a registered provider.
+ */
+export interface DiscoveredProvider {
+    /** Provider type identifier (e.g., 'local', 's3', 'reactive-overflow') */
+    type: string;
+    /** Provider category */
+    category: 'blob' | 'compaction' | 'customTools';
+    /** Optional metadata about the provider */
+    metadata?: {
+        displayName?: string;
+        description?: string;
+        [key: string]: any;
+    } | undefined;
+}
+/**
+ * Information about an internal tool for discovery.
+ */
+export interface InternalToolDiscovery {
+    /** Tool name identifier (e.g., 'search_history', 'ask_user') */
+    name: string;
+    /** Human-readable description of what the tool does */
+    description: string;
+}
+/**
+ * Discovery result with providers grouped by category.
+ */
+export interface ProviderDiscovery {
+    /** Blob storage providers */
+    blob: DiscoveredProvider[];
+    /** Compaction strategy providers */
+    compaction: DiscoveredProvider[];
+    /** Custom tool providers */
+    customTools: DiscoveredProvider[];
+    /** Internal tools available for configuration */
+    internalTools: InternalToolDiscovery[];
+}
+/**
+ * Provider category type.
+ */
+export type ProviderCategory = 'blob' | 'compaction' | 'customTools';
+/**
+ * List all registered providers across all registries.
+ *
+ * This function is useful for debugging and building UIs that need to display
+ * available providers. It queries all provider registries and returns a
+ * comprehensive view of what's currently registered.
+ *
+ * @returns Object with providers grouped by category
+ *
+ * @example
+ * ```typescript
+ * const providers = listAllProviders();
+ * console.log('Available blob providers:', providers.blob);
+ * console.log('Available compaction providers:', providers.compaction);
+ * console.log('Available custom tool providers:', providers.customTools);
+ * ```
+ */
+export declare function listAllProviders(): ProviderDiscovery;
+/**
+ * Get all providers for a specific category.
+ *
+ * @param category - The provider category to query
+ * @returns Array of provider information for the specified category
+ *
+ * @example
+ * ```typescript
+ * const blobProviders = getProvidersByCategory('blob');
+ * blobProviders.forEach(p => {
+ *   console.log(`${p.type}: ${p.metadata?.displayName}`);
+ * });
+ * ```
+ */
+export declare function getProvidersByCategory(category: ProviderCategory): DiscoveredProvider[];
+/**
+ * Check if a specific provider exists in a category.
+ *
+ * @param category - The provider category to check
+ * @param type - The provider type identifier
+ * @returns True if the provider is registered, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (hasProvider('blob', 's3')) {
+ *   console.log('S3 blob storage is available');
+ * }
+ *
+ * if (hasProvider('compaction', 'reactive-overflow')) {
+ *   console.log('Reactive overflow compaction is available');
+ * }
+ * ```
+ */
+export declare function hasProvider(category: ProviderCategory, type: string): boolean;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/providers/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/providers/discovery.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IAEb,wBAAwB;IACxB,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa,CAAC;IAEhD,2CAA2C;IAC3C,QAAQ,CAAC,EACH;QACI,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,GACD,SAAS,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IAEb,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,6BAA6B;IAC7B,IAAI,EAAE,kBAAkB,EAAE,CAAC;IAE3B,oCAAoC;IACpC,UAAU,EAAE,kBAAkB,EAAE,CAAC;IAEjC,4BAA4B;IAC5B,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAElC,iDAAiD;IACjD,aAAa,EAAE,qBAAqB,EAAE,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,YAAY,GAAG,aAAa,CAAC;AAErE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,IAAI,iBAAiB,CAkDpD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,kBAAkB,EAAE,CAGvF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAW7E"}

package/dist/providers/discovery.js

@@ -0,0 +1,70 @@
+import "../chunk-PTJYTZNU.js";
+import { blobStoreRegistry } from "../storage/blob/index.js";
+import { compactionRegistry } from "../context/compaction/index.js";
+import { customToolRegistry } from "../tools/custom-tool-registry.js";
+import { INTERNAL_TOOL_NAMES } from "../tools/internal-tools/constants.js";
+import { INTERNAL_TOOL_REGISTRY } from "../tools/internal-tools/registry.js";
+function listAllProviders() {
+  const blobProviders = blobStoreRegistry.getProviders().map((provider) => {
+    const info = {
+      type: provider.type,
+      category: "blob"
+    };
+    if (provider.metadata) {
+      info.metadata = provider.metadata;
+    }
+    return info;
+  });
+  const compactionProviders = compactionRegistry.getAll().map((provider) => {
+    const info = {
+      type: provider.type,
+      category: "compaction"
+    };
+    if (provider.metadata) {
+      info.metadata = provider.metadata;
+    }
+    return info;
+  });
+  const customToolProviders = customToolRegistry.getTypes().map((type) => {
+    const provider = customToolRegistry.get(type);
+    const info = {
+      type,
+      category: "customTools"
+    };
+    if (provider?.metadata) {
+      info.metadata = provider.metadata;
+    }
+    return info;
+  });
+  const internalTools = INTERNAL_TOOL_NAMES.map((name) => ({
+    name,
+    description: INTERNAL_TOOL_REGISTRY[name].description
+  }));
+  return {
+    blob: blobProviders,
+    compaction: compactionProviders,
+    customTools: customToolProviders,
+    internalTools
+  };
+}
+function getProvidersByCategory(category) {
+  const allProviders = listAllProviders();
+  return allProviders[category];
+}
+function hasProvider(category, type) {
+  switch (category) {
+    case "blob":
+      return blobStoreRegistry.has(type);
+    case "compaction":
+      return compactionRegistry.has(type);
+    case "customTools":
+      return customToolRegistry.has(type);
+    default:
+      return false;
+  }
+}
+export {
+  getProvidersByCategory,
+  hasProvider,
+  listAllProviders
+};