@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/core/factory.js

@@ -1,364 +0,0 @@
-// ✅ CIRCULAR DEPENDENCY FIX: Remove barrel export import
-// Providers are now managed via ProviderFactory instead of direct imports
-import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import { tracers } from "../telemetry/tracers.js";
-import { ProviderFactory } from "../factories/providerFactory.js";
-import { ProviderRegistry } from "../factories/providerRegistry.js";
-import { getBestProvider } from "../utils/providerUtils.js";
-import { logger } from "../utils/logger.js";
-import { dynamicModelProvider } from "./dynamicModels.js";
-import { withTimeout, ErrorFactory } from "../utils/errorHandling.js";
-import { AIProviderName } from "../constants/enums.js";
-const componentIdentifier = "aiProviderFactory";
-const factoryTracer = tracers.factory;
-/**
- * Factory for creating AI provider instances with centralized configuration
- */
-export class AIProviderFactory {
-    /**
-     * Normalize provider name using ProviderFactory
-     */
-    static normalizeProviderName(providerName) {
-        // Use ProviderFactory registration - no more legacy switch statements
-        const normalized = ProviderFactory.normalizeProviderName(providerName);
-        if (normalized) {
-            return normalized;
-        }
-        // If not found in factory, return as-is (will be handled by factory error handling)
-        return providerName.toLowerCase();
-    }
-    /**
-     * Initialize dynamic model provider with timeout protection
-     * Prevents hanging on non-responsive endpoints
-     */
-    static async initializeDynamicProviderWithTimeout() {
-        const functionTag = "AIProviderFactory.initializeDynamicProviderWithTimeout";
-        const INIT_TIMEOUT = 10000; // 10 seconds total timeout for initialization
-        try {
-            await withTimeout(dynamicModelProvider.initialize(), INIT_TIMEOUT, ErrorFactory.toolTimeout("dynamic-provider-init", INIT_TIMEOUT));
-            logger.debug(`[${functionTag}] Dynamic model provider initialized successfully`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.warn(`[${functionTag}] Dynamic model provider initialization failed`, {
-                error: errorMessage,
-                fallback: "Using static model defaults",
-            });
-            // Don't throw - graceful degradation to static models
-            // This ensures the factory continues to work even if dynamic models fail
-        }
-    }
-    static resolveModelFromEnvironment(providerName, modelName, functionTag) {
-        if (modelName && modelName !== "default") {
-            logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
-            return modelName;
-        }
-        logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
-        const normalizedProvider = providerName.toLowerCase();
-        const envConfigs = [
-            {
-                match: ["bedrock"],
-                label: "Bedrock",
-                vars: ["BEDROCK_MODEL", "BEDROCK_MODEL_ID"],
-            },
-            {
-                match: ["vertex"],
-                label: "Vertex",
-                vars: ["VERTEX_MODEL"],
-            },
-            {
-                match: ["azure"],
-                label: "Azure",
-                vars: [
-                    "AZURE_OPENAI_MODEL",
-                    "AZURE_OPENAI_DEPLOYMENT",
-                    "AZURE_OPENAI_DEPLOYMENT_ID",
-                ],
-            },
-            {
-                match: ["openai", "gpt", "chatgpt", "openai-compat"],
-                label: "OpenAI",
-                vars: ["OPENAI_MODEL"],
-            },
-            {
-                match: ["anthropic", "claude", "anthropic-claude"],
-                label: "Anthropic",
-                vars: ["ANTHROPIC_MODEL"],
-            },
-            {
-                match: ["google", "gemini"],
-                label: "Google AI",
-                vars: ["GOOGLE_AI_MODEL"],
-            },
-            {
-                match: ["mistral"],
-                label: "Mistral",
-                vars: ["MISTRAL_MODEL"],
-            },
-            {
-                match: ["ollama"],
-                label: "Ollama",
-                vars: ["OLLAMA_MODEL"],
-            },
-            {
-                match: ["litellm"],
-                label: "LiteLLM",
-                vars: ["LITELLM_MODEL"],
-            },
-        ];
-        const envConfig = envConfigs.find((config) => config.match.some((match) => normalizedProvider.includes(match)));
-        if (!envConfig) {
-            logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
-            return modelName;
-        }
-        const matchedVar = envConfig.vars.find((name) => process.env[name]);
-        const envModel = matchedVar ? process.env[matchedVar] : undefined;
-        if (envModel) {
-            logger.debug(`[${functionTag}] Environment variable found for ${envConfig.label}`, {
-                envVariable: matchedVar,
-                resolvedModel: envModel,
-            });
-            return envModel;
-        }
-        logger.debug(`[${functionTag}] No ${envConfig.label} environment variables found (${envConfig.vars.join(", ")})`);
-        return modelName;
-    }
-    static async resolveDynamicModelName(providerName, modelName, resolvedModelName, functionTag) {
-        if ((resolvedModelName && resolvedModelName !== "default") ||
-            (modelName && modelName !== "default")) {
-            logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
-                resolvedModelName: resolvedModelName || "none",
-                reason: "Model already resolved from environment variables or explicit parameter",
-            });
-            return resolvedModelName;
-        }
-        logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
-            currentResolvedModel: resolvedModelName || "none",
-            reason: "No environment variable found and no explicit model provided",
-        });
-        try {
-            const normalizedProvider = this.normalizeProviderName(providerName);
-            if (dynamicModelProvider.needsRefresh()) {
-                logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
-                await this.initializeDynamicProviderWithTimeout();
-            }
-            const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
-            if (!dynamicModel) {
-                logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
-                    provider: normalizedProvider,
-                    requestedModel: modelName || "default",
-                });
-                return resolvedModelName;
-            }
-            logger.debug(`[${functionTag}] Resolved dynamic model`, {
-                provider: normalizedProvider,
-                requestedModel: modelName || "default",
-                resolvedModel: dynamicModel.id,
-                displayName: dynamicModel.displayName,
-                pricing: dynamicModel.pricing.input,
-            });
-            return dynamicModel.id;
-        }
-        catch (resolveError) {
-            logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
-                error: resolveError instanceof Error
-                    ? resolveError.message
-                    : String(resolveError),
-            });
-            return resolvedModelName;
-        }
-    }
-    static async createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag, credentials) {
-        await withTimeout(ProviderRegistry.registerAllProviders(), 30_000, ErrorFactory.toolTimeout("provider-registration", 30_000));
-        const normalizedName = this.normalizeProviderName(providerName);
-        const finalModelName = resolvedModelName === "default" || resolvedModelName === null
-            ? undefined
-            : resolvedModelName;
-        logger.debug(`[${functionTag}] Final provider configuration`, {
-            originalProviderName: providerName,
-            normalizedProviderName: normalizedName,
-            resolvedModelName: resolvedModelName || "not resolved",
-            finalModelName: finalModelName || "using provider default",
-        });
-        const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region, credentials), 30_000, ErrorFactory.toolTimeout(`provider-creation:${normalizedName}`, 30_000));
-        return { normalizedName, finalModelName, provider };
-    }
-    /**
-     * Create a provider instance for the specified provider type
-     * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
-     * @param modelName - Optional model name override
-     * @param enableMCP - Optional flag to enable MCP integration (default: true)
-     * @param sdk - SDK instance
-     * @param region - Optional region override for cloud providers
-     * @returns AIProvider instance
-     */
-    static async createProvider(providerName, modelName, enableMCP = true, sdk, region, credentials) {
-        const functionTag = "AIProviderFactory.createProvider";
-        // Providers are registered via ProviderFactory.initialize() on first use
-        return factoryTracer.startActiveSpan("neurolink.factory.createProvider", {
-            kind: SpanKind.INTERNAL,
-            attributes: {
-                "provider.name": providerName,
-                "model.name": modelName || "default",
-                "mcp.enabled": enableMCP,
-            },
-        }, async (span) => {
-            logger.debug(`[${functionTag}] Provider creation started`, {
-                providerName,
-                modelName: modelName || "default",
-                enableMCP,
-                environmentVariables: {
-                    BEDROCK_MODEL: process.env.BEDROCK_MODEL || "not set",
-                    BEDROCK_MODEL_ID: process.env.BEDROCK_MODEL_ID || "not set",
-                    VERTEX_MODEL: process.env.VERTEX_MODEL || "not set",
-                    OPENAI_MODEL: process.env.OPENAI_MODEL || "not set",
-                },
-            });
-            try {
-                // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
-                //
-                // ✅ FIXED: Hanging issues resolved with comprehensive timeout implementation
-                // - Added robust timeout handling (3s localhost, 5s GitHub, 1s local file)
-                // - Implemented health checks for localhost endpoints
-                // - Added graceful degradation when all sources fail
-                // - Enhanced error handling and logging for debugging
-                //
-                // The dynamic model provider now provides reliable functionality without hanging
-                let resolvedModelName = this.resolveModelFromEnvironment(providerName, modelName, functionTag);
-                resolvedModelName = await this.resolveDynamicModelName(providerName, modelName, resolvedModelName, functionTag);
-                const { normalizedName, finalModelName, provider } = await this.createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag, credentials);
-                // Summary logging in format expected by debugging tools
-                logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
-                logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);
-                logger.debug(componentIdentifier, "Pure factory pattern provider created", {
-                    providerName: normalizedName,
-                    modelName: finalModelName,
-                    factoryUsed: true,
-                });
-                span.setAttribute("provider.resolved_name", normalizedName);
-                if (finalModelName) {
-                    span.setAttribute("model.resolved_name", finalModelName);
-                }
-                logger.debug(`[${functionTag}] Provider creation succeeded`, {
-                    providerName,
-                    modelName: finalModelName || "default",
-                    providerType: provider.constructor.name,
-                    mcpEnabled: enableMCP,
-                });
-                span.setStatus({ code: SpanStatusCode.OK });
-                return provider;
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
-                span.recordException(error instanceof Error ? error : new Error(String(error)));
-                logger.debug(`[${functionTag}] Provider creation failed`, {
-                    providerName,
-                    modelName: modelName || "default",
-                    error: errorMessage,
-                });
-                throw error;
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-    /**
-     * Create a provider instance with specific provider enum and model
-     * @param provider - Provider enum value
-     * @param model - Specific model enum value
-     * @returns AIProvider instance
-     */
-    static async createProviderWithModel(provider, model) {
-        const functionTag = "AIProviderFactory.createProviderWithModel";
-        logger.debug(`[${functionTag}] Provider model creation started`, {
-            provider,
-            model,
-        });
-        try {
-            const providerInstance = await this.createProvider(provider, model);
-            logger.debug(`[${functionTag}] Provider model creation succeeded`, {
-                provider,
-                model,
-                providerType: providerInstance.constructor.name,
-            });
-            return providerInstance;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.debug(`[${functionTag}] Provider model creation failed`, {
-                provider,
-                model,
-                error: errorMessage,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Create the best available provider automatically
-     * @param requestedProvider - Optional preferred provider
-     * @param modelName - Optional model name override
-     * @param enableMCP - Optional flag to enable MCP integration (default: true)
-     * @returns AIProvider instance
-     */
-    static async createBestProvider(requestedProvider, modelName, enableMCP = true, sdk) {
-        const functionTag = "AIProviderFactory.createBestProvider";
-        try {
-            const bestProvider = await getBestProvider(requestedProvider);
-            logger.debug(`[${functionTag}] Best provider selected`, {
-                requestedProvider: requestedProvider || "auto",
-                selectedProvider: bestProvider,
-                modelName: modelName || "default",
-                enableMCP,
-            });
-            return await this.createProvider(bestProvider, modelName, enableMCP, sdk);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.debug(`[${functionTag}] Best provider selection failed`, {
-                requestedProvider: requestedProvider || "auto",
-                error: errorMessage,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Create primary and fallback provider instances
-     * @param primaryProvider - Primary provider name
-     * @param fallbackProvider - Fallback provider name
-     * @param modelName - Optional model name override
-     * @param enableMCP - Optional flag to enable MCP integration (default: true)
-     * @returns Object with primary and fallback providers
-     */
-    static async createProviderWithFallback(primaryProvider, fallbackProvider, modelName, enableMCP = true) {
-        const functionTag = "AIProviderFactory.createProviderWithFallback";
-        logger.debug(`[${functionTag}] Fallback provider setup started`, {
-            primaryProvider,
-            fallbackProvider,
-            modelName: modelName || "default",
-            enableMCP,
-        });
-        try {
-            const primary = await this.createProvider(primaryProvider, modelName, enableMCP);
-            const fallback = await this.createProvider(fallbackProvider, modelName, enableMCP);
-            logger.debug(`[${functionTag}] Fallback provider setup succeeded`, {
-                primaryProvider,
-                fallbackProvider,
-                modelName: modelName || "default",
-                enableMCP,
-            });
-            return { primary, fallback };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.debug(`[${functionTag}] Fallback provider setup failed`, {
-                primaryProvider,
-                fallbackProvider,
-                error: errorMessage,
-            });
-            throw error;
-        }
-    }
-}
-//# sourceMappingURL=factory.js.map

package/dist/lib/core/geminiLoopAdapter.d.ts

@@ -1,20 +0,0 @@
-/**
- * Shared Gemini adapter onto the agentic loop engine.
- *
- * Lives in `core/` rather than inside either provider's folder because two
- * providers use it: Google AI Studio (Task 9) and Vertex Gemini (Task 10).
- * Both issue the same wire call — `models.generateContentStream` — and consume
- * the same response shape, so one `executeStep` serves four hand-rolled loops
- * (each provider has a streaming one and a near-duplicate inside `generate()`).
- *
- * Function-name sanitization stays entirely on this side of the engine
- * boundary, which is the design decision Task 7 recorded rather than a
- * shortcut. Google requires function names to match a restricted pattern, so
- * declarations are built with sanitized names and the model calls back with
- * those same sanitized names. The engine only ever sees plain string names, so
- * this adapter translates sanitized -> original before returning `toolCalls`,
- * and original -> sanitized when writing `functionResponse` parts. Neither the
- * engine nor any other adapter needs to know sanitization happened.
- */
-import type { AgenticLoopAdapter, GeminiLoopAdapterConfig, GeminiStepRaw, GeminiTurnContent } from "../types/index.js";
-export declare function createGeminiLoopAdapter(config: GeminiLoopAdapterConfig): AgenticLoopAdapter<GeminiTurnContent[], GeminiStepRaw>;

package/dist/lib/core/geminiLoopAdapter.js

@@ -1,171 +0,0 @@
-/**
- * Shared Gemini adapter onto the agentic loop engine.
- *
- * Lives in `core/` rather than inside either provider's folder because two
- * providers use it: Google AI Studio (Task 9) and Vertex Gemini (Task 10).
- * Both issue the same wire call — `models.generateContentStream` — and consume
- * the same response shape, so one `executeStep` serves four hand-rolled loops
- * (each provider has a streaming one and a near-duplicate inside `generate()`).
- *
- * Function-name sanitization stays entirely on this side of the engine
- * boundary, which is the design decision Task 7 recorded rather than a
- * shortcut. Google requires function names to match a restricted pattern, so
- * declarations are built with sanitized names and the model calls back with
- * those same sanitized names. The engine only ever sees plain string names, so
- * this adapter translates sanitized -> original before returning `toolCalls`,
- * and original -> sanitized when writing `functionResponse` parts. Neither the
- * engine nor any other adapter needs to know sanitization happened.
- */
-import { collectStreamChunksIncremental, extractTextFromParts, mapGeminiFinishReason, pushModelResponseToHistory, refreshNativeToolDeclarations, } from "../providers/googleNativeGemini3/utils.js";
-export function createGeminiLoopAdapter(config) {
-    /**
-     * Sanitized wire name -> the name the caller registered. Rebuilt per step
-     * because mid-turn discovery can add entries between steps.
-     */
-    const originalNameFor = (sanitized) => config.declarations?.originalNameMap?.get(sanitized) ?? sanitized;
-    const sanitizedNameFor = (original) => {
-        const map = config.declarations?.originalNameMap;
-        if (!map) {
-            return original;
-        }
-        for (const [sanitized, name] of map) {
-            if (name === original) {
-                return sanitized;
-            }
-        }
-        return original;
-    };
-    return {
-        providerLabel: config.providerLabel,
-        maxSteps: config.maxSteps,
-        ...(config.toolFailureBreaker
-            ? { toolFailureBreaker: config.toolFailureBreaker }
-            : {}),
-        /**
-         * Mid-turn discovery: `search_tools` hydrates new tools into the live
-         * record between steps, and Gemini only calls what the request declared,
-         * so the declarations are refreshed before each step is built. This is
-         * why `resolveToolOnMiss` exists as well — a tool discovered during a
-         * step is callable in the same step, before the next refresh.
-         */
-        buildStepRequest(conversation, step) {
-            if (config.declarations) {
-                refreshNativeToolDeclarations(config.liveTools, config.declarations);
-            }
-            return { raw: config.buildRequest(conversation, step) };
-        },
-        /**
-         * The engine decides WHEN to reclaim; the provider decides HOW. Wiring
-         * this is not optional dressing: both loops append a model turn and a
-         * tool turn every step, so without it a long agentic run overflows the
-         * context window mid-turn and loses the work already done.
-         */
-        ...(config.planReclaim
-            ? {
-                planReclaim: (conversation, step) => {
-                    const reclaimed = config.planReclaim?.(conversation, step);
-                    return reclaimed ? { conversation: reclaimed } : undefined;
-                },
-            }
-            : {}),
-        /**
-         * A step that produced no text, no function calls, and a
-         * MALFORMED_FUNCTION_CALL finish reason is a transient formatting
-         * failure, not a finished turn. Vertex retries it once with a corrective
-         * note rather than hard-ending on empty content — automated RCA turns
-         * were dying at step 2-4 on this and being mislabelled as step-cap exits.
-         *
-         * Opt-in: AI Studio has no such retry today and gaining one silently
-         * would be a behaviour change, not a migration.
-         */
-        ...(config.enableMalformedRetry && config.buildMalformedRetryNote
-            ? {
-                isMalformedStep: (stepResult) => stepResult.toolCalls.length === 0 &&
-                    !stepResult.text &&
-                    stepResult.rawStopReason === "MALFORMED_FUNCTION_CALL",
-                buildMalformedRetryNote: config.buildMalformedRetryNote,
-            }
-            : {}),
-        resolveToolOnMiss: (name) => {
-            const tool = config.liveTools?.[name];
-            const execute = tool?.execute;
-            if (!execute) {
-                return undefined;
-            }
-            // Wrapped because the hook types `opts` as `unknown`, and a function
-            // declaring a narrower options type is not assignable to one accepting
-            // `unknown`. One assertion at the boundary, never a double assertion.
-            return {
-                execute: async (args, opts) => execute(args, opts),
-            };
-        },
-        async executeStep(request, channel, signal) {
-            const rawStream = await config.sendStep(request.raw, signal);
-            // `collectStreamChunksIncremental` wants a StreamChannel but only ever
-            // calls `.push`, so the engine's push-only channel satisfies it. The
-            // helper is reused rather than reimplemented precisely because it also
-            // owns usage extraction and thought-signature preservation.
-            const collected = await collectStreamChunksIncremental(rawStream, {
-                push: (chunk) => channel.push(chunk),
-            });
-            // The provider's context guard calibrates from real per-step counts;
-            // `inputTokens` is this step's full prompt size, which is what it
-            // projects the next request from.
-            config.noteUsage?.(collected.inputTokens, collected.outputTokens);
-            const text = extractTextFromParts(collected.rawResponseParts);
-            // Names cross the engine boundary in their ORIGINAL form.
-            const toolCalls = collected.stepFunctionCalls.map((call, index) => ({
-                id: `${config.providerLabel}_${index}_${call.name}`,
-                name: originalNameFor(call.name),
-                args: call.args,
-            }));
-            return {
-                text,
-                toolCalls,
-                usage: {
-                    inputTokens: collected.inputTokens,
-                    outputTokens: collected.outputTokens,
-                    ...(collected.cacheReadTokens
-                        ? { cacheReadTokens: collected.cacheReadTokens }
-                        : {}),
-                    ...(collected.reasoningTokens
-                        ? { reasoningTokens: collected.reasoningTokens }
-                        : {}),
-                },
-                rawStopReason: collected.finishReason,
-                raw: {
-                    rawResponseParts: collected.rawResponseParts,
-                    stepFunctionCalls: collected.stepFunctionCalls,
-                },
-            };
-        },
-        buildToolResultMessages(conversation, stepResult, toolResults) {
-            // Copied before `pushModelResponseToHistory` mutates it: the engine
-            // treats the conversation as a value it hands in and gets back, so
-            // mutating the caller's array in place would make a retried or
-            // reclaimed step see history it should not.
-            const next = [...conversation];
-            pushModelResponseToHistory(next, stepResult.raw.rawResponseParts, stepResult.raw.stepFunctionCalls);
-            next.push({
-                role: "user",
-                parts: toolResults.map((result) => ({
-                    functionResponse: {
-                        // Back to the sanitized wire name the model actually called.
-                        name: sanitizedNameFor(result.name),
-                        response: result.error
-                            ? { error: result.error }
-                            : { result: result.output },
-                    },
-                })),
-            });
-            return next;
-        },
-        mapFinishReason(rawStopReason, hadToolCallsAtCap) {
-            const mapped = mapGeminiFinishReason(rawStopReason);
-            // A turn cut off at the step cap ended because of the cap, not because
-            // the last response said "STOP".
-            return hadToolCallsAtCap && mapped === "stop" ? "tool-calls" : mapped;
-        },
-    };
-}
-//# sourceMappingURL=geminiLoopAdapter.js.map

package/dist/lib/core/handlerRegistry.d.ts

@@ -1,29 +0,0 @@
-/**
- * Generic provider-name → handler registry shared by every media-generation
- * ecosystem (TTS, STT, Realtime, Video, Music, Avatar). Each ecosystem's own
- * processor class composes one instance of this class instead of hand-rolling
- * its own `Map<string, THandler>` plus register/supports/get/list methods.
- *
- * Centralizes only the behavior that was byte-identical across all six
- * hand-rolled registries: input validation, name normalization (lowercase),
- * the overwrite-warning log line, and the four lookup/list/clear operations.
- * Registration-outcome debug logging (whose exact phrasing differs per
- * ecosystem — e.g. "Registered TTS handler..." vs "Registered video
- * handler...") and any ecosystem-specific extra logging (e.g. TTS/STT's
- * `supports()` diagnostics) stay in the owning processor's own wrapper
- * methods; this class does not attempt to unify those.
- */
-export declare class HandlerRegistry<THandler> {
-    private readonly scopeName;
-    private readonly handlers;
-    /**
-     * @param scopeName Log-line prefix, e.g. "TTSProcessor" — matches the
-     *   `[ClassName]` prefix each processor already uses in its own logs.
-     */
-    constructor(scopeName: string);
-    register(providerName: string, handler: THandler): void;
-    supports(providerName: string): boolean;
-    get(providerName: string): THandler | undefined;
-    list(): string[];
-    clear(): void;
-}

package/dist/lib/core/handlerRegistry.js

@@ -1,62 +0,0 @@
-import { logger } from "../utils/logger.js";
-import { sanitizeForLog } from "../utils/logSanitize.js";
-/**
- * Generic provider-name → handler registry shared by every media-generation
- * ecosystem (TTS, STT, Realtime, Video, Music, Avatar). Each ecosystem's own
- * processor class composes one instance of this class instead of hand-rolling
- * its own `Map<string, THandler>` plus register/supports/get/list methods.
- *
- * Centralizes only the behavior that was byte-identical across all six
- * hand-rolled registries: input validation, name normalization (lowercase),
- * the overwrite-warning log line, and the four lookup/list/clear operations.
- * Registration-outcome debug logging (whose exact phrasing differs per
- * ecosystem — e.g. "Registered TTS handler..." vs "Registered video
- * handler...") and any ecosystem-specific extra logging (e.g. TTS/STT's
- * `supports()` diagnostics) stay in the owning processor's own wrapper
- * methods; this class does not attempt to unify those.
- */
-export class HandlerRegistry {
-    scopeName;
-    handlers = new Map();
-    /**
-     * @param scopeName Log-line prefix, e.g. "TTSProcessor" — matches the
-     *   `[ClassName]` prefix each processor already uses in its own logs.
-     */
-    constructor(scopeName) {
-        this.scopeName = scopeName;
-    }
-    register(providerName, handler) {
-        if (!providerName) {
-            throw new Error("Provider name is required");
-        }
-        if (!handler) {
-            throw new Error("Handler is required");
-        }
-        const key = providerName.toLowerCase();
-        if (this.handlers.has(key)) {
-            // Every caller today passes a literal provider slug, but this class is
-            // generic over an arbitrary string — sanitize before logging it so a
-            // future caller building the key from untrusted input can't leak a
-            // bearer token/API key through this warning.
-            logger.warn(`[${this.scopeName}] Overwriting existing handler for provider: ${sanitizeForLog(key)}`);
-        }
-        this.handlers.set(key, handler);
-    }
-    supports(providerName) {
-        if (!providerName) {
-            return false;
-        }
-        return this.handlers.has(providerName.toLowerCase());
-    }
-    get(providerName) {
-        return this.handlers.get(providerName.toLowerCase());
-    }
-    list() {
-        return Array.from(this.handlers.keys());
-    }
-    clear() {
-        this.handlers.clear();
-        logger.debug(`[${this.scopeName}] Cleared all handlers`);
-    }
-}
-//# sourceMappingURL=handlerRegistry.js.map

package/dist/lib/core/infrastructure/baseError.d.ts

@@ -1,21 +0,0 @@
-import type { ErrorCode } from "../../types/index.js";
-export declare class NeuroLinkFeatureError extends Error {
-    readonly code: ErrorCode;
-    readonly feature: string;
-    readonly retryable: boolean;
-    readonly details?: Record<string, unknown>;
-    readonly cause?: Error;
-    constructor(message: string, code: ErrorCode, feature: string, options?: {
-        retryable?: boolean;
-        details?: Record<string, unknown>;
-        cause?: Error;
-    });
-}
-export declare function createErrorFactory<TCodes extends Record<string, string>>(feature: string, codes: TCodes): {
-    codes: TCodes;
-    create: (code: keyof TCodes, message: string, options?: {
-        retryable?: boolean;
-        details?: Record<string, unknown>;
-        cause?: Error;
-    }) => NeuroLinkFeatureError;
-};