@juspay/neurolink 5.1.0 → 5.2.0

package/dist/lib/types/stream-types.d.ts

@@ -1,6 +1,25 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Tool, Schema } from "ai";
 import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+/**
+ * Interface for tool execution calls
+ */
+export interface ToolCall {
+    toolName: string;
+    parameters: Record<string, any>;
+    id?: string;
+}
+/**
+ * Interface for tool execution results
+ */
+export interface ToolResult {
+    toolName: string;
+    status: "success" | "failure";
+    output?: any;
+    error?: string;
+    id?: string;
+    executionTime?: number;
+}
 /**
  * Stream function options interface - Primary method for streaming content
  * Future-ready for multi-modal capabilities while maintaining text focus
@@ -26,6 +45,7 @@ export interface StreamOptions {
     tools?: Record<string, Tool>;
     timeout?: number | string;
     disableTools?: boolean;
+    maxSteps?: number;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
     context?: Record<string, any>;
@@ -46,30 +66,22 @@ export interface StreamResult {
     }>;
     provider?: string;
     model?: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    finishReason?: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
     metadata?: {
         streamId?: string;
         startTime?: number;
         totalChunks?: number;
         estimatedDuration?: number;
+        responseTime?: number;
+        fallback?: boolean;
     };
-    toolCalls?: Array<{
-        toolCallId: string;
-        toolName: string;
-        args: Record<string, any>;
-    }>;
-    toolsUsed?: string[];
-    toolExecutions?: Array<{
-        name: string;
-        input: Record<string, any>;
-        output: any;
-        duration: number;
-    }>;
-    enhancedWithTools?: boolean;
-    availableTools?: Array<{
-        name: string;
-        description: string;
-        parameters: Record<string, any>;
-    }>;
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
 }

package/dist/lib/types/universal-provider-options.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Universal Provider Options Interface (Phase 1: Factory Pattern)
+ * Based on TypeScript factory pattern best practices for AI provider abstraction
+ */
+/**
+ * Base configuration interface for all AI providers
+ * Uses Parameter Object Pattern for flexible, extensible configuration
+ */
+export interface UniversalProviderOptions {
+    prompt?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    enableAnalytics?: boolean;
+    enableEvaluation?: boolean;
+    context?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    extensionOptions?: Record<string, unknown>;
+}
+/**
+ * Generic provider options (without providerType)
+ */
+export type GenericProviderOptions = Omit<UniversalProviderOptions, "providerType">;
+/**
+ * Provider-specific configuration extensions
+ * Discriminated union pattern for type-safe provider configs
+ */
+export interface OpenAIProviderOptions extends UniversalProviderOptions {
+    providerType: "openai";
+    organization?: string;
+    seed?: number;
+    topP?: number;
+}
+export interface GoogleAIProviderOptions extends UniversalProviderOptions {
+    providerType: "google-ai";
+    topK?: number;
+    candidateCount?: number;
+    stopSequences?: string[];
+}
+export interface AnthropicProviderOptions extends UniversalProviderOptions {
+    providerType: "anthropic";
+    topK?: number;
+    stopSequences?: string[];
+}
+export interface BedrockProviderOptions extends UniversalProviderOptions {
+    providerType: "bedrock";
+    inferenceProfileArn?: string;
+    region?: string;
+}
+/**
+ * Discriminated union for type-safe provider configuration
+ * Enables compile-time type checking for provider-specific options
+ */
+export type ProviderSpecificOptions = OpenAIProviderOptions | GoogleAIProviderOptions | AnthropicProviderOptions | BedrockProviderOptions;
+/**
+ * Factory configuration interface
+ * Supports both universal and provider-specific parameters
+ */
+export interface ProviderFactoryConfig {
+    providerName: string;
+    modelName?: string;
+    options?: UniversalProviderOptions | ProviderSpecificOptions;
+    enableMCP?: boolean;
+}
+/**
+ * Parameter normalization utilities
+ * Converts between different parameter formats for backward compatibility
+ */
+export declare class ParameterNormalizer {
+    /**
+     * Normalize legacy parameter formats to universal format
+     */
+    static normalizeToUniversal(optionsOrPrompt: UniversalProviderOptions | string): UniversalProviderOptions;
+    /**
+     * Retrieve the provider type if it exists, otherwise return null
+     */
+    private static getProviderType;
+    /**
+     * Extract provider-specific parameters safely
+     */
+    static extractProviderOptions<T extends ProviderSpecificOptions>(options: UniversalProviderOptions | ProviderSpecificOptions, providerType: T["providerType"]): T | GenericProviderOptions;
+    /**
+     * Merge default values with user-provided options
+     */
+    static mergeWithDefaults(options: UniversalProviderOptions, defaults: Partial<UniversalProviderOptions>): UniversalProviderOptions;
+}

package/dist/lib/types/universal-provider-options.js

@@ -0,0 +1,53 @@
+/**
+ * Universal Provider Options Interface (Phase 1: Factory Pattern)
+ * Based on TypeScript factory pattern best practices for AI provider abstraction
+ */
+/**
+ * Parameter normalization utilities
+ * Converts between different parameter formats for backward compatibility
+ */
+export class ParameterNormalizer {
+    /**
+     * Normalize legacy parameter formats to universal format
+     */
+    static normalizeToUniversal(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            return { prompt: optionsOrPrompt };
+        }
+        return optionsOrPrompt;
+    }
+    /**
+     * Retrieve the provider type if it exists, otherwise return null
+     */
+    static getProviderType(options) {
+        return "providerType" in options ? options.providerType : null;
+    }
+    /**
+     * Extract provider-specific parameters safely
+     */
+    static extractProviderOptions(options, providerType) {
+        const currentProviderType = ParameterNormalizer.getProviderType(options);
+        if (currentProviderType === providerType) {
+            return options;
+        }
+        // Handle case where options has providerType but doesn't match
+        if (currentProviderType !== null) {
+            const { providerType: _providerType, ...genericOptions } = options;
+            return genericOptions;
+        }
+        // Options don't have providerType, return as generic
+        return options;
+    }
+    /**
+     * Merge default values with user-provided options
+     */
+    static mergeWithDefaults(options, defaults) {
+        return {
+            ...defaults,
+            ...options,
+            // Merge nested objects
+            context: { ...defaults.context, ...options.context },
+            metadata: { ...defaults.metadata, ...options.metadata },
+        };
+    }
+}

package/dist/mcp/config.js

@@ -3,15 +3,36 @@
  * Central registry for all MCP servers following Lighthouse patterns
  * Handles built-in servers only - auto-discovery handled by unified registry
  */
-import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
 import { utilityServer } from "./servers/utilities/utility-server.js";
 import { logger } from "../utils/logger.js";
+/**
+ * Lazy-loaded AI Core Server to avoid circular dependencies
+ */
+let aiCoreServerCache = null;
+async function getAICoreServer() {
+    if (!aiCoreServerCache) {
+        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
+        aiCoreServerCache = aiCoreServer;
+    }
+    return aiCoreServerCache;
+}
+/**
+ * Lazy-loaded Direct Tools Server to avoid circular dependencies
+ */
+let directToolsServerCache = null;
+async function getDirectToolsServer() {
+    if (!directToolsServerCache) {
+        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
+        directToolsServerCache = directToolsServer;
+    }
+    return directToolsServerCache;
+}
 /**
  * Built-in MCP servers (kept for backward compatibility)
  * Add new servers here as they are created
  */
 export const allServers = [
-    aiCoreServer,
+    // aiCoreServer will be added dynamically in getServers()
     utilityServer,
     // Add more servers as they are created
 ];
@@ -25,8 +46,12 @@ export const mcpConfig = {
      */
     getServers: async () => {
         const activeServers = [];
+        // Get all servers including dynamically loaded ones
+        const aiCoreServer = await getAICoreServer();
+        const directToolsServer = await getDirectToolsServer();
+        const servers = [aiCoreServer, directToolsServer, ...allServers];
         // Include built-in servers with filtering
-        for (const server of allServers) {
+        for (const server of servers) {
             const implementedTools = {};
             let hasImplementedTools = false;
             for (const toolName in server.tools) {

package/dist/mcp/function-calling.js

@@ -58,7 +58,7 @@ export async function getAvailableFunctionTools() {
     const toolMap = new Map();
     try {
         // Add overall timeout for the entire function
-        const overallTimeoutMs = 5000; // 5 seconds max for everything
+        const overallTimeoutMs = process.env.NODE_ENV === "test" ? 30000 : 15000; // 30s for tests, 15s for production
         let overallTimeoutId;
         const overallTimeoutPromise = new Promise((_, reject) => {
             overallTimeoutId = setTimeout(() => {

package/dist/mcp/initialize-tools.d.ts

@@ -13,7 +13,7 @@ export declare const initializeMCPTools: (sessionId: string, client: NeuroLinkMC
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export declare function getAllAvailableTools(): Promise<Array<{
+export declare function getAllAvailableTools(inMemoryServers?: Map<string, any>): Promise<Array<{
     serverId: string;
     serverTitle: string;
     toolName: string;

package/dist/mcp/initialize-tools.js

@@ -140,8 +140,52 @@ export const initializeMCPTools = async (sessionId, client, context) => {
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export async function getAllAvailableTools() {
+export async function getAllAvailableTools(inMemoryServers) {
     const tools = [];
+    // Add in-memory server tools first
+    if (inMemoryServers) {
+        for (const [serverId, serverConfig] of inMemoryServers) {
+            const server = serverConfig.server;
+            if (server && server.tools) {
+                // Handle both Map and object formats
+                const toolEntries = server.tools instanceof Map
+                    ? Array.from(server.tools.entries())
+                    : Object.entries(server.tools || {});
+                for (const [toolName, toolInfo] of toolEntries) {
+                    const prefix = `${serverId}_`;
+                    const finalToolName = toolName.length > 64 - prefix.length
+                        ? toolName.substring(0, 64 - prefix.length)
+                        : toolName;
+                    const namespacedName = sanitizeToolName(`${prefix}${finalToolName}`);
+                    // Handle different tool info structures
+                    let description = `Tool from ${serverId}`;
+                    let isImplemented = true;
+                    if (toolInfo) {
+                        // Check if it's a tool info object with description
+                        if (typeof toolInfo.description === "string") {
+                            description = toolInfo.description;
+                        }
+                        else if (typeof toolInfo === "function") {
+                            // It's a raw function, no description available
+                            description = `${toolName} from ${serverId}`;
+                        }
+                        // Check implementation status
+                        if (typeof toolInfo.isImplemented === "boolean") {
+                            isImplemented = toolInfo.isImplemented;
+                        }
+                    }
+                    tools.push({
+                        serverId,
+                        serverTitle: server.title || serverId,
+                        toolName,
+                        namespacedName,
+                        description,
+                        isImplemented,
+                    });
+                }
+            }
+        }
+    }
     const servers = await mcpConfig.getServers();
     servers.forEach((server) => {
         Object.entries(server.tools).forEach(([toolName, tool]) => {

package/dist/mcp/initialize.js

@@ -5,6 +5,7 @@
  */
 import { toolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { mcpLogger } from "./logging.js";
+import { ServiceRegistry } from "../core/service-registry.js";
 let isInitialized = false;
 /**
  * Initialize NeuroLink MCP system by registering built-in servers
@@ -15,19 +16,28 @@ export async function initializeNeuroLinkMCP(targetRegistry) {
     }
     mcpLogger.debug("Initializing built-in MCP servers...");
     try {
+        // First, register AIProviderFactory in ServiceRegistry to break circular dependencies
+        ServiceRegistry.register("AIProviderFactory", async () => {
+            const { AIProviderFactory } = await import("../core/factory.js");
+            return AIProviderFactory;
+        });
+        mcpLogger.debug("Registered AIProviderFactory in ServiceRegistry");
         // Import utility server dynamically to avoid circular dependencies
-        // Note: AI core server temporarily disabled due to circular dependency issues
         const { utilityServer } = await import("./servers/utilities/utility-server.js");
         // Register built-in NeuroLink servers with specified registry (or default)
         const registry = targetRegistry || toolRegistry;
         await registry.registerServer(utilityServer.id, utilityServer);
         mcpLogger.debug(`Registered neurolink-utility server with built-in tools in ${targetRegistry ? "target" : "default"} registry`);
-        // TODO: Re-enable AI core server once circular dependencies are resolved
-        // const { aiCoreServer } = await import('./servers/ai-providers/ai-core-server.js');
-        // await registry.registerServer(aiCoreServer.id, aiCoreServer);
-        // mcpLogger.debug('Registered neurolink-ai-core server with AI tools');
+        // Now safe to import and register AI core server
+        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
+        await registry.registerServer(aiCoreServer.id, aiCoreServer);
+        mcpLogger.debug("Registered neurolink-ai-core server with AI tools");
+        // Register direct tools server
+        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
+        await registry.registerServer(directToolsServer.id, directToolsServer);
+        mcpLogger.debug("Registered neurolink-direct server with direct tools");
         const stats = await registry.getStats();
-        mcpLogger.info(`Initialization complete: ${stats.totalServers} server, ${stats.totalTools} tools available`);
+        mcpLogger.info(`Initialization complete: ${stats.totalServers} servers, ${stats.totalTools} tools available`);
         isInitialized = true;
     }
     catch (error) {

package/dist/mcp/servers/agent/direct-tools-server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * NeuroLink Direct Tools Server
+ * Wraps the agent direct tools as an MCP server for proper registration
+ */
+/**
+ * Direct Tools Server - Agent direct tools for immediate use
+ */
+export declare const directToolsServer: import("../../factory.js").NeuroLinkMCPServer;

package/dist/mcp/servers/agent/direct-tools-server.js

@@ -0,0 +1,109 @@
+/**
+ * NeuroLink Direct Tools Server
+ * Wraps the agent direct tools as an MCP server for proper registration
+ */
+import { createMCPServer } from "../../factory.js";
+import { directAgentTools } from "../../../agent/direct-tools.js";
+import { logger } from "../../../utils/logger.js";
+/**
+ * Direct Tools Server - Agent direct tools for immediate use
+ */
+export const directToolsServer = createMCPServer({
+    id: "neurolink-direct",
+    title: "NeuroLink Direct Tools Server",
+    description: "Provides direct agent tools for immediate execution",
+    category: "integrations",
+    version: "1.0.0",
+});
+/**
+ * Wrap each direct tool and register it with the server
+ */
+Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
+    // The toolDef is a Vercel AI SDK Tool object
+    // Extract properties from the Tool object
+    const toolSpec = toolDef._spec || toolDef;
+    const description = toolSpec.description || `Direct tool: ${toolName}`;
+    const inputSchema = toolSpec.parameters;
+    const execute = toolSpec.execute;
+    directToolsServer.registerTool({
+        name: toolName,
+        description: description,
+        category: getToolCategory(toolName),
+        inputSchema: inputSchema,
+        isImplemented: true,
+        execute: async (params, context) => {
+            const startTime = Date.now();
+            try {
+                logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
+                // Execute the direct tool
+                const result = await execute(params);
+                // Convert direct tool result to ToolResult format
+                if (result.success) {
+                    return {
+                        success: true,
+                        data: result,
+                        usage: {
+                            executionTime: Date.now() - startTime,
+                        },
+                        metadata: {
+                            toolName,
+                            serverId: "neurolink-direct",
+                            sessionId: context.sessionId,
+                        },
+                    };
+                }
+                else {
+                    return {
+                        success: false,
+                        data: null,
+                        error: result.error || "Unknown error",
+                        usage: {
+                            executionTime: Date.now() - startTime,
+                        },
+                        metadata: {
+                            toolName,
+                            serverId: "neurolink-direct",
+                            sessionId: context.sessionId,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                logger.error(`[Direct Tools] Error executing ${toolName}:`, error);
+                return {
+                    success: false,
+                    data: null,
+                    error: error instanceof Error ? error.message : String(error),
+                    usage: {
+                        executionTime: Date.now() - startTime,
+                    },
+                    metadata: {
+                        toolName,
+                        serverId: "neurolink-direct",
+                        sessionId: context.sessionId,
+                    },
+                };
+            }
+        },
+    });
+});
+/**
+ * Get tool category based on tool name
+ */
+function getToolCategory(toolName) {
+    switch (toolName) {
+        case "getCurrentTime":
+            return "time";
+        case "calculateMath":
+            return "math";
+        case "readFile":
+        case "writeFile":
+        case "listDirectory":
+        case "searchFiles":
+            return "filesystem";
+        default:
+            return "utility";
+    }
+}
+// Log successful registration
+logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);

package/dist/mcp/servers/ai-providers/ai-core-server.js

@@ -5,7 +5,7 @@
  */
 import { z } from "zod";
 import { createMCPServer } from "../../factory.js";
-import { AIProviderFactory } from "../../../core/factory.js";
+import { ServiceRegistry } from "../../../core/service-registry.js";
 import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
 import { logger } from "../../../utils/logger.js";
 import { analyzeAIUsageTool, benchmarkProviderPerformanceTool, optimizePromptParametersTool, } from "./ai-analysis-tools.js";
@@ -86,6 +86,8 @@ aiCoreServer.registerTool({
             logger.debug(`[AI-Core] Starting text generation: "${params.prompt.substring(0, 50)}..."`);
             // Use existing AIProviderFactory with best provider selection
             const selectedProvider = params.provider || (await getBestProvider(params.provider));
+            // Get AIProviderFactory from ServiceRegistry to avoid circular dependency
+            const AIProviderFactory = await ServiceRegistry.get("AIProviderFactory");
             const provider = await AIProviderFactory.createBestProvider(selectedProvider);
             // Generate text using existing NeuroLink patterns
             const result = await provider.generate({

package/dist/mcp/servers/ai-providers/ai-workflow-tools.d.ts

@@ -88,14 +88,14 @@ export declare const workflowToolSchemas: {
     }, "strip", z.ZodTypeAny, {
         aiOutput: string;
         expectedBehavior: string;
-        outputType: "text" | "code" | "conversation" | "structured-data";
+        outputType: "text" | "code" | "structured-data" | "conversation";
         includeFixSuggestions: boolean;
         context?: string | undefined;
     }, {
         aiOutput: string;
         expectedBehavior: string;
         context?: string | undefined;
-        outputType?: "text" | "code" | "conversation" | "structured-data" | undefined;
+        outputType?: "text" | "code" | "structured-data" | "conversation" | undefined;
         includeFixSuggestions?: boolean | undefined;
     }>;
 };

package/dist/mcp/unified-registry.d.ts

@@ -26,6 +26,10 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
      * Load servers from .mcp-config.json
      */
     private loadManualConfig;
+    /**
+     * Connect to manually configured servers
+     */
+    private connectManualServers;
     /**
      * Enable or disable auto-discovery
      */

package/dist/mcp/unified-registry.js

@@ -4,7 +4,7 @@
 import { MCPRegistry } from "./registry.js";
 import { discoverMCPServers, autoRegisterMCPServers, } from "./auto-discovery.js";
 import { unifiedRegistryLogger } from "./logging.js";
-import { MCPToolRegistry, } from "./tool-registry.js";
+import { MCPToolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { TransportManager, TransportConfigSchema, } from "./transport-manager.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { ErrorManager } from "./error-manager.js";
@@ -31,8 +31,18 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     async initialize(options = {}) {
         unifiedRegistryLogger.info("Initializing unified MCP registry...");
-        // Load manual configuration first
-        await this.loadManualConfig();
+        // Import ProviderRegistry to check options
+        const { ProviderRegistry } = await import("../factories/provider-registry.js");
+        const registryOptions = ProviderRegistry.getOptions();
+        // Only load manual config if explicitly enabled (CLI mode)
+        if (registryOptions.enableManualMCP) {
+            unifiedRegistryLogger.info("Manual MCP config enabled - loading .mcp-config.json");
+            await this.loadManualConfig();
+            await this.connectManualServers();
+        }
+        else {
+            unifiedRegistryLogger.debug("Manual MCP config disabled - skipping .mcp-config.json");
+        }
         if (this.autoDiscoveryEnabled) {
             const result = await autoRegisterMCPServers(options);
             unifiedRegistryLogger.info(`Auto-discovery complete: ${result.registered} registered, ${result.failed} failed`);
@@ -96,6 +106,29 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
             unifiedRegistryLogger.error("Failed to load manual config:", error instanceof Error ? error.message : String(error));
         }
     }
+    /**
+     * Connect to manually configured servers
+     */
+    async connectManualServers() {
+        for (const [serverId, serverConfig] of this.manualServers.entries()) {
+            try {
+                unifiedRegistryLogger.info(`Connecting to manual server: ${serverId}`);
+                // Use addExternalServer method which properly establishes connections
+                await this.addExternalServer(serverId, {
+                    type: "stdio",
+                    command: serverConfig.command || "npx",
+                    args: serverConfig.args || [],
+                    env: serverConfig.env,
+                });
+                unifiedRegistryLogger.info(`Successfully connected manual server: ${serverId}`);
+            }
+            catch (error) {
+                unifiedRegistryLogger.error(`Failed to connect manual server ${serverId}:`, error instanceof Error ? error.message : String(error));
+                // Remove from available servers if connection fails
+                this.availableServers.delete(serverId);
+            }
+        }
+    }
     /**
      * Enable or disable auto-discovery
      */
@@ -142,8 +175,8 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
     async listAllTools() {
         const allTools = [];
         try {
-            // FIXED: Get built-in tools from base registry
-            const builtInTools = await super.listTools();
+            // FIXED: Get built-in tools from defaultToolRegistry where they are actually registered
+            const builtInTools = await defaultToolRegistry.listTools();
             allTools.push(...builtInTools.map((tool) => ({
                 ...tool,
                 id: tool.name,
@@ -151,7 +184,7 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
                 source: "built-in",
                 isExternal: false,
             })));
-            unifiedRegistryLogger.debug(`Found ${builtInTools.length} built-in tools`);
+            unifiedRegistryLogger.debug(`Found ${builtInTools.length} built-in tools from defaultToolRegistry`);
         }
         catch (error) {
             unifiedRegistryLogger.warn("Failed to get built-in tools:", error);
@@ -195,10 +228,10 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
      */
     async executeTool(toolName, args, context) {
         unifiedRegistryLogger.info(`Executing tool: ${toolName}`);
-        // STEP 1: Try built-in tools first
+        // STEP 1: Try built-in tools first from defaultToolRegistry
         try {
-            const result = await super.executeTool(toolName, args, context);
-            unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via built-in registry`);
+            const result = await defaultToolRegistry.executeTool(toolName, args, context);
+            unifiedRegistryLogger.info(`Tool ${toolName} executed successfully via defaultToolRegistry`);
             return result;
         }
         catch (builtInError) {