@juspay/neurolink 9.1.1 → 9.3.0

package/dist/providers/openAI.js

@@ -2,14 +2,14 @@ import { createOpenAI } from "@ai-sdk/openai";
 import { streamText } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
-import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
+import { logger } from "../utils/logger.js";
+import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -54,6 +54,13 @@ export class OpenAIProvider extends BaseProvider {
     getDefaultModel() {
         return getOpenAIModel();
     }
+    /**
+     * Get the default embedding model for OpenAI
+     * @returns The default OpenAI embedding model name
+     */
+    getDefaultEmbeddingModel() {
+        return process.env.OPENAI_EMBEDDING_MODEL || "text-embedding-3-small";
+    }
     /**
      * Returns the Vercel AI SDK model instance for OpenAI
      */
@@ -218,9 +225,12 @@ export class OpenAIProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            // Get tools consistently with generate method
+            // Get tools - options.tools is pre-merged by BaseProvider.stream() with
+            // base tools (MCP/built-in) + user-provided tools (RAG, etc.)
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const allTools = shouldUseTools ? await this.getAllTools() : {};
+            const allTools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             // OpenAI-specific fix: Validate tools format and filter out problematic ones
             let tools = this.validateAndFilterToolsForOpenAI(allTools);
             // OpenAI max tools limit - configurable via environment variable
@@ -446,6 +456,50 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for text using OpenAI text-embedding models
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: text-embedding-3-small)
+     * @returns Promise resolving to the embedding vector
+     */
+    async embed(text, modelName) {
+        const embeddingModelName = modelName || "text-embedding-3-small";
+        logger.debug("Generating embedding", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            textLength: text.length,
+        });
+        try {
+            // Create embedding model using the AI SDK
+            const { embed } = await import("ai");
+            // Create the OpenAI provider
+            const openai = createOpenAI({
+                apiKey: getOpenAIApiKey(),
+                fetch: createProxyFetch(),
+            });
+            // Get the text embedding model
+            const embeddingModel = openai.textEmbeddingModel(embeddingModelName);
+            // Generate the embedding
+            const result = await embed({
+                model: embeddingModel,
+                value: text,
+            });
+            logger.debug("Embedding generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                embeddingDimension: result.embedding.length,
+            });
+            return result.embedding;
+        }
+        catch (error) {
+            logger.error("Embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                textLength: text.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
 }
 // Export for factory registration
 export default OpenAIProvider;

package/dist/providers/openRouter.d.ts

@@ -1,8 +1,8 @@
+import { type LanguageModelV1, type Schema } from "ai";
 import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
 import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * OpenRouter Provider - BaseProvider Implementation
  * Provides access to 300+ models from 60+ providers via OpenRouter unified gateway

package/dist/providers/openRouter.js

@@ -1,13 +1,13 @@
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { streamText, Output } from "ai";
+import { Output, streamText } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
-import { getProviderModel } from "../utils/providerConfig.js";
-import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { logger } from "../utils/logger.js";
+import { getProviderModel } from "../utils/providerConfig.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 // Constants
 const MODELS_DISCOVERY_TIMEOUT_MS = 5000; // 5 seconds for model discovery
 // Configuration helpers
@@ -203,8 +203,12 @@ export class OpenRouterProvider extends BaseProvider {
             const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options);
             // Get all available tools (direct + MCP + external) for streaming
+            // BaseProvider.stream() pre-merges base tools + external tools into options.tools
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? options.tools ||
+                    (await this.getAllTools())
+                : {};
             logger.debug(`OpenRouter: Tools for streaming`, {
                 shouldUseTools,
                 toolCount: Object.keys(tools).length,

package/dist/rag/ChunkerFactory.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Chunker Factory
+ *
+ * Factory for creating chunker instances with configuration.
+ * Follows the BaseFactory pattern for consistent lifecycle management.
+ */
+import { BaseFactory } from "../core/infrastructure/index.js";
+import type { Chunker, ChunkerConfig, ChunkerMetadata, ChunkingStrategy } from "./types.js";
+/**
+ * Chunker Factory
+ *
+ * Creates chunker instances based on strategy with configuration support.
+ * Uses lazy loading via dynamic imports to avoid circular dependencies.
+ */
+export declare class ChunkerFactory extends BaseFactory<Chunker, ChunkerConfig> {
+    private static instance;
+    private metadataMap;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): ChunkerFactory;
+    /**
+     * Reset singleton (for testing)
+     */
+    static resetInstance(): void;
+    /**
+     * Register all default chunkers
+     */
+    protected registerAll(): Promise<void>;
+    /**
+     * Register a chunker with metadata and aliases
+     */
+    registerChunker(strategy: ChunkingStrategy | string, factory: (config?: ChunkerConfig) => Promise<Chunker>, metadata: ChunkerMetadata): void;
+    /**
+     * Create a chunker by strategy name or alias
+     */
+    createChunker(strategyOrAlias: string, config?: ChunkerConfig): Promise<Chunker>;
+    /**
+     * Get metadata for a chunker
+     */
+    getChunkerMetadata(strategyOrAlias: string): ChunkerMetadata | undefined;
+    /**
+     * Get default configuration for a chunker
+     */
+    getDefaultConfig(strategyOrAlias: string): ChunkerConfig | undefined;
+    /**
+     * Get available chunking strategies (not including aliases)
+     */
+    getAvailableStrategies(): Promise<ChunkingStrategy[]>;
+    /**
+     * Get all aliases mapped to their strategies
+     */
+    getStrategyAliases(): Map<string, string>;
+    /**
+     * Check if a strategy exists
+     */
+    hasStrategy(strategyOrAlias: string): boolean;
+    /**
+     * Get chunkers suitable for a use case
+     */
+    getChunkersForUseCase(useCase: string): ChunkingStrategy[];
+    /**
+     * Get all chunker metadata
+     */
+    getAllMetadata(): Map<string, ChunkerMetadata>;
+    /**
+     * Clear factory and metadata
+     */
+    clear(): void;
+}
+/**
+ * Global chunker factory singleton
+ */
+export declare const chunkerFactory: ChunkerFactory;
+/**
+ * Convenience function to create a chunker
+ */
+export declare function createChunker(strategyOrAlias: string, config?: ChunkerConfig): Promise<Chunker>;
+/**
+ * Convenience function to get available strategies
+ */
+export declare function getAvailableStrategies(): Promise<ChunkingStrategy[]>;
+/**
+ * Convenience function to get chunker metadata
+ */
+export declare function getChunkerMetadata(strategyOrAlias: string): ChunkerMetadata | undefined;
+/**
+ * Convenience function to get default config
+ */
+export declare function getDefaultConfig(strategyOrAlias: string): ChunkerConfig | undefined;

package/dist/rag/ChunkerFactory.js

@@ -0,0 +1,320 @@
+/**
+ * Chunker Factory
+ *
+ * Factory for creating chunker instances with configuration.
+ * Follows the BaseFactory pattern for consistent lifecycle management.
+ */
+import { BaseFactory } from "../core/infrastructure/index.js";
+import { logger } from "../utils/logger.js";
+import { ChunkingError, RAGErrorCodes } from "./errors/RAGError.js";
+/**
+ * Default chunker metadata entries
+ */
+const DEFAULT_CHUNKER_METADATA = {
+    character: {
+        description: "Splits text into fixed-size character chunks with optional overlap",
+        defaultConfig: { maxSize: 1000, overlap: 100 },
+        supportedOptions: ["maxSize", "overlap", "minSize"],
+        useCases: ["Simple text processing", "Fixed-size chunks needed"],
+        aliases: ["char", "fixed-size", "fixed"],
+    },
+    recursive: {
+        description: "Recursively splits text using ordered separators",
+        defaultConfig: {
+            maxSize: 1000,
+            overlap: 100,
+            separators: ["\n\n", "\n", ". ", " ", ""],
+        },
+        supportedOptions: ["maxSize", "overlap", "separators", "keepSeparators"],
+        useCases: ["General text documents", "Default choice"],
+        aliases: ["recursive-character", "langchain-default"],
+    },
+    sentence: {
+        description: "Splits text by sentence boundaries",
+        defaultConfig: { maxSize: 1000, overlap: 1 },
+        supportedOptions: [
+            "maxSize",
+            "overlap",
+            "boundaryDetection",
+            "maxSentences",
+        ],
+        useCases: ["Q&A applications", "Sentence-level analysis"],
+        aliases: ["sent", "sentence-based"],
+    },
+    token: {
+        description: "Splits text by token count using a specific tokenizer",
+        defaultConfig: { maxSize: 512, overlap: 50 },
+        supportedOptions: ["maxSize", "overlap", "tokenizer", "maxTokens"],
+        useCases: ["Token-aware splitting", "Model-specific chunks"],
+        aliases: ["tok", "tokenized"],
+    },
+    markdown: {
+        description: "Splits markdown content by headers and structural elements",
+        defaultConfig: { maxSize: 1000, overlap: 0 },
+        supportedOptions: ["maxSize", "headerLevels", "splitCodeBlocks"],
+        useCases: ["Documentation processing", "README files"],
+        aliases: ["md", "markdown-header"],
+    },
+    html: {
+        description: "Splits HTML content by semantic tags",
+        defaultConfig: { maxSize: 1000, overlap: 0 },
+        supportedOptions: [
+            "maxSize",
+            "splitTags",
+            "stripTags",
+            "preserveAttributes",
+        ],
+        useCases: ["Web content processing", "HTML documents"],
+        aliases: ["html-tag", "web"],
+    },
+    json: {
+        description: "Splits JSON documents by object boundaries",
+        defaultConfig: { maxSize: 1000, overlap: 0 },
+        supportedOptions: ["maxSize", "maxDepth", "chunkKeys"],
+        useCases: ["API response processing", "Structured data"],
+        aliases: ["json-object", "structured"],
+    },
+    latex: {
+        description: "Splits LaTeX documents by sections and environments",
+        defaultConfig: { maxSize: 1000, overlap: 0 },
+        supportedOptions: ["maxSize", "environments", "splitMathBlocks"],
+        useCases: ["Academic papers", "Scientific documents"],
+        aliases: ["tex", "latex-section"],
+    },
+    semantic: {
+        description: "Uses LLM to identify semantically meaningful split points",
+        defaultConfig: { maxSize: 1000, overlap: 100 },
+        supportedOptions: [
+            "maxSize",
+            "modelName",
+            "provider",
+            "similarityThreshold",
+        ],
+        useCases: ["Advanced semantic understanding", "AI-enhanced chunking"],
+        aliases: ["llm", "ai-semantic"],
+    },
+    "semantic-markdown": {
+        description: "Combines markdown splitting with semantic similarity",
+        defaultConfig: { maxSize: 1000, overlap: 100 },
+        supportedOptions: ["maxSize", "similarityThreshold", "maxMergeSize"],
+        useCases: ["Context-aware documentation", "Knowledge bases"],
+        aliases: ["semantic-md", "smart-markdown"],
+    },
+};
+/**
+ * Chunker Factory
+ *
+ * Creates chunker instances based on strategy with configuration support.
+ * Uses lazy loading via dynamic imports to avoid circular dependencies.
+ */
+export class ChunkerFactory extends BaseFactory {
+    static instance = null;
+    metadataMap = new Map();
+    constructor() {
+        super();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!ChunkerFactory.instance) {
+            ChunkerFactory.instance = new ChunkerFactory();
+        }
+        return ChunkerFactory.instance;
+    }
+    /**
+     * Reset singleton (for testing)
+     */
+    static resetInstance() {
+        if (ChunkerFactory.instance) {
+            ChunkerFactory.instance.clear();
+            ChunkerFactory.instance = null;
+        }
+    }
+    /**
+     * Register all default chunkers
+     */
+    async registerAll() {
+        // Register character chunker
+        this.registerChunker("character", async (config) => {
+            const { CharacterChunker } = await import("./chunkers/CharacterChunker.js");
+            return new CharacterChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.character);
+        // Register recursive chunker
+        this.registerChunker("recursive", async (config) => {
+            const { RecursiveChunker } = await import("./chunkers/RecursiveChunker.js");
+            return new RecursiveChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.recursive);
+        // Register sentence chunker
+        this.registerChunker("sentence", async (config) => {
+            const { SentenceChunker } = await import("./chunkers/SentenceChunker.js");
+            return new SentenceChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.sentence);
+        // Register token chunker
+        this.registerChunker("token", async (config) => {
+            const { TokenChunker } = await import("./chunkers/TokenChunker.js");
+            return new TokenChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.token);
+        // Register markdown chunker
+        this.registerChunker("markdown", async (config) => {
+            const { MarkdownChunker } = await import("./chunkers/MarkdownChunker.js");
+            return new MarkdownChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.markdown);
+        // Register HTML chunker
+        this.registerChunker("html", async (config) => {
+            const { HTMLChunker } = await import("./chunkers/HTMLChunker.js");
+            return new HTMLChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.html);
+        // Register JSON chunker
+        this.registerChunker("json", async (config) => {
+            const { JSONChunker } = await import("./chunkers/JSONChunker.js");
+            return new JSONChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.json);
+        // Register LaTeX chunker
+        this.registerChunker("latex", async (config) => {
+            const { LaTeXChunker } = await import("./chunkers/LaTeXChunker.js");
+            return new LaTeXChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.latex);
+        // Register semantic chunker (placeholder - uses recursive as fallback)
+        this.registerChunker("semantic", async (config) => {
+            // TODO: Implement dedicated SemanticChunker with LLM support
+            // For now, fall back to RecursiveChunker with semantic defaults
+            const { RecursiveChunker } = await import("./chunkers/RecursiveChunker.js");
+            return new RecursiveChunker(config);
+        }, DEFAULT_CHUNKER_METADATA.semantic);
+        // Register semantic-markdown chunker
+        this.registerChunker("semantic-markdown", async (config) => {
+            const { SemanticMarkdownChunker } = await import("./chunkers/SemanticMarkdownChunker.js");
+            return new SemanticMarkdownChunker(config);
+        }, DEFAULT_CHUNKER_METADATA["semantic-markdown"]);
+        logger.debug(`[ChunkerFactory] Registered ${this.items.size} chunking strategies`);
+    }
+    /**
+     * Register a chunker with metadata and aliases
+     */
+    registerChunker(strategy, factory, metadata) {
+        // Store metadata
+        this.metadataMap.set(strategy, metadata);
+        // Register with aliases
+        this.register(strategy, factory, metadata.aliases, { metadata });
+        logger.debug(`[ChunkerFactory] Registered chunker '${strategy}' with aliases: ${metadata.aliases?.join(", ") ?? "none"}`);
+    }
+    /**
+     * Create a chunker by strategy name or alias
+     */
+    async createChunker(strategyOrAlias, config) {
+        await this.ensureInitialized();
+        const resolvedName = this.resolveName(strategyOrAlias);
+        if (!this.has(resolvedName)) {
+            const available = this.getAvailable();
+            throw new ChunkingError(`Unknown chunking strategy: '${strategyOrAlias}'. Available strategies: ${available.join(", ")}`, {
+                code: RAGErrorCodes.CHUNKING_STRATEGY_NOT_FOUND,
+                details: {
+                    requestedStrategy: strategyOrAlias,
+                    availableStrategies: available,
+                },
+            });
+        }
+        try {
+            const chunker = await this.create(resolvedName, config);
+            logger.debug(`[ChunkerFactory] Created chunker '${resolvedName}' with config:`, config);
+            return chunker;
+        }
+        catch (error) {
+            throw new ChunkingError(`Failed to create chunker '${resolvedName}': ${error instanceof Error ? error.message : String(error)}`, {
+                code: RAGErrorCodes.CHUNKING_ERROR,
+                cause: error instanceof Error ? error : undefined,
+                details: { strategy: resolvedName, config },
+            });
+        }
+    }
+    /**
+     * Get metadata for a chunker
+     */
+    getChunkerMetadata(strategyOrAlias) {
+        const resolvedName = this.resolveName(strategyOrAlias);
+        return this.metadataMap.get(resolvedName);
+    }
+    /**
+     * Get default configuration for a chunker
+     */
+    getDefaultConfig(strategyOrAlias) {
+        const metadata = this.getChunkerMetadata(strategyOrAlias);
+        return metadata?.defaultConfig;
+    }
+    /**
+     * Get available chunking strategies (not including aliases)
+     */
+    async getAvailableStrategies() {
+        await this.ensureInitialized();
+        return this.getAvailable();
+    }
+    /**
+     * Get all aliases mapped to their strategies
+     */
+    getStrategyAliases() {
+        return this.getAliases();
+    }
+    /**
+     * Check if a strategy exists
+     */
+    hasStrategy(strategyOrAlias) {
+        const resolved = this.resolveName(strategyOrAlias);
+        return this.has(resolved);
+    }
+    /**
+     * Get chunkers suitable for a use case
+     */
+    getChunkersForUseCase(useCase) {
+        const matches = [];
+        const useCaseLower = useCase.toLowerCase();
+        for (const [strategy, metadata] of this.metadataMap) {
+            const hasMatch = metadata.useCases?.some((uc) => uc.toLowerCase().includes(useCaseLower)) ?? false;
+            if (hasMatch) {
+                matches.push(strategy);
+            }
+        }
+        return matches;
+    }
+    /**
+     * Get all chunker metadata
+     */
+    getAllMetadata() {
+        return new Map(this.metadataMap);
+    }
+    /**
+     * Clear factory and metadata
+     */
+    clear() {
+        super.clear();
+        this.metadataMap.clear();
+    }
+}
+/**
+ * Global chunker factory singleton
+ */
+export const chunkerFactory = ChunkerFactory.getInstance();
+/**
+ * Convenience function to create a chunker
+ */
+export async function createChunker(strategyOrAlias, config) {
+    return chunkerFactory.createChunker(strategyOrAlias, config);
+}
+/**
+ * Convenience function to get available strategies
+ */
+export async function getAvailableStrategies() {
+    return chunkerFactory.getAvailableStrategies();
+}
+/**
+ * Convenience function to get chunker metadata
+ */
+export function getChunkerMetadata(strategyOrAlias) {
+    return chunkerFactory.getChunkerMetadata(strategyOrAlias);
+}
+/**
+ * Convenience function to get default config
+ */
+export function getDefaultConfig(strategyOrAlias) {
+    return chunkerFactory.getDefaultConfig(strategyOrAlias);
+}

package/dist/rag/ChunkerRegistry.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Chunker Registry
+ *
+ * Centralized registry for all chunking strategies with metadata
+ * and discovery capabilities. Follows the BaseRegistry pattern.
+ */
+import { BaseRegistry } from "../core/infrastructure/index.js";
+import type { Chunker, ChunkerConfig, ChunkerMetadata, ChunkingStrategy } from "./types.js";
+/**
+ * Chunker Registry
+ *
+ * Manages registration and discovery of all chunking strategies.
+ * Extends BaseRegistry for consistent lifecycle management.
+ */
+export declare class ChunkerRegistry extends BaseRegistry<Chunker, ChunkerMetadata> {
+    private static instance;
+    private aliasMap;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): ChunkerRegistry;
+    /**
+     * Reset singleton (for testing)
+     */
+    static resetInstance(): void;
+    /**
+     * Register all default chunkers
+     */
+    protected registerAll(): Promise<void>;
+    /**
+     * Register a chunker with aliases
+     */
+    registerChunker(strategy: ChunkingStrategy | string, factory: () => Promise<Chunker>, metadata: ChunkerMetadata): void;
+    /**
+     * Resolve strategy name from alias
+     */
+    resolveStrategy(nameOrAlias: string): ChunkingStrategy;
+    /**
+     * Get a chunker by strategy name or alias
+     */
+    getChunker(strategyOrAlias: string): Promise<Chunker>;
+    /**
+     * Get list of available chunker strategies
+     */
+    getAvailableChunkers(): Promise<ChunkingStrategy[]>;
+    /**
+     * Get metadata for a specific chunker
+     */
+    getChunkerMetadata(strategyOrAlias: string): ChunkerMetadata | undefined;
+    /**
+     * Get all aliases for a strategy
+     */
+    getAliasesForStrategy(strategy: ChunkingStrategy): string[];
+    /**
+     * Get all registered aliases
+     */
+    getAllAliases(): Map<string, ChunkingStrategy>;
+    /**
+     * Check if a strategy or alias exists
+     */
+    hasChunker(strategyOrAlias: string): boolean;
+    /**
+     * Get chunkers by use case
+     */
+    getChunkersByUseCase(useCase: string): ChunkingStrategy[];
+    /**
+     * Get default configuration for a chunker
+     */
+    getDefaultConfig(strategyOrAlias: string): ChunkerConfig | undefined;
+    /**
+     * Clear the registry (also clears aliases)
+     */
+    clear(): void;
+}
+/**
+ * Global chunker registry singleton
+ */
+export declare const chunkerRegistry: ChunkerRegistry;
+/**
+ * Convenience function to get available chunkers
+ */
+export declare function getAvailableChunkers(): Promise<ChunkingStrategy[]>;
+/**
+ * Convenience function to get chunker by strategy
+ */
+export declare function getChunker(strategyOrAlias: string): Promise<Chunker>;
+/**
+ * Convenience function to get chunker metadata
+ */
+export declare function getChunkerMetadata(strategyOrAlias: string): ChunkerMetadata | undefined;