@juspay/neurolink 5.0.0 → 5.2.0

package/dist/lib/factories/provider-factory.d.ts

@@ -0,0 +1,72 @@
+import type { AIProvider, AIProviderName } from "../core/types.js";
+/**
+ * Provider constructor interface - supports both sync constructors and async factory functions
+ */
+type ProviderConstructor = {
+    new (modelName?: string, providerName?: any, sdk?: any): AIProvider;
+} | ((modelName?: string, providerName?: any, sdk?: any) => Promise<AIProvider>);
+/**
+ * Provider registration entry
+ */
+interface ProviderRegistration {
+    constructor: ProviderConstructor;
+    defaultModel?: string;
+    aliases?: string[];
+}
+/**
+ * True Factory Pattern implementation for AI Providers
+ * Uses registration-based approach to eliminate switch statements
+ * and enable dynamic provider registration
+ */
+export declare class ProviderFactory {
+    private static readonly providers;
+    private static initialized;
+    /**
+     * Register a provider with the factory
+     */
+    static registerProvider(name: AIProviderName | string, constructor: ProviderConstructor, defaultModel?: string, // Optional - provider can read from env
+    aliases?: string[]): void;
+    /**
+     * Create a provider instance
+     */
+    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: any): Promise<AIProvider>;
+    /**
+     * Check if a provider is registered
+     */
+    static hasProvider(providerName: string): boolean;
+    /**
+     * Get list of available providers
+     */
+    static getAvailableProviders(): string[];
+    /**
+     * Get provider registration info
+     */
+    static getProviderInfo(providerName: string): ProviderRegistration | undefined;
+    /**
+     * Normalize provider names using aliases (PHASE 1: Factory Pattern)
+     */
+    static normalizeProviderName(providerName: string): string | null;
+    /**
+     * Clear all registrations (mainly for testing)
+     */
+    static clearRegistrations(): void;
+    /**
+     * Ensure providers are initialized
+     */
+    private static ensureInitialized;
+    /**
+     * Initialize default providers
+     * NOTE: Providers are now registered by ProviderRegistry to avoid circular dependencies
+     */
+    private static initializeDefaultProviders;
+    /**
+     * Create the best available provider for the given name
+     * Used by NeuroLink SDK for streaming and generation
+     */
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+}
+/**
+ * Helper function to create providers with backward compatibility
+ */
+export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string): Promise<AIProvider>;
+export {};

package/dist/lib/factories/provider-factory.js

@@ -0,0 +1,144 @@
+import { logger } from "../utils/logger.js";
+/**
+ * True Factory Pattern implementation for AI Providers
+ * Uses registration-based approach to eliminate switch statements
+ * and enable dynamic provider registration
+ */
+export class ProviderFactory {
+    static providers = new Map();
+    static initialized = false;
+    /**
+     * Register a provider with the factory
+     */
+    static registerProvider(name, constructor, defaultModel, // Optional - provider can read from env
+    aliases = []) {
+        const registration = {
+            constructor,
+            defaultModel,
+            aliases,
+        };
+        // Register main name
+        this.providers.set(name.toLowerCase(), registration);
+        // Register aliases
+        aliases.forEach((alias) => {
+            this.providers.set(alias.toLowerCase(), registration);
+        });
+        logger.debug(`Registered provider: ${name} with model ${defaultModel || "from-env"}`);
+    }
+    /**
+     * Create a provider instance
+     */
+    static async createProvider(providerName, modelName, sdk) {
+        // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
+        const normalizedName = providerName.toLowerCase();
+        const registration = this.providers.get(normalizedName);
+        if (!registration) {
+            throw new Error(`Unknown provider: ${providerName}. Available providers: ${this.getAvailableProviders().join(", ")}`);
+        }
+        const model = modelName || registration.defaultModel;
+        try {
+            // Check if constructor is an async factory function or a class constructor
+            if (typeof registration.constructor === "function") {
+                // Check if it has a prototype (class constructor) or not (factory function)
+                if (registration.constructor.prototype &&
+                    registration.constructor.prototype.constructor ===
+                        registration.constructor) {
+                    // It's a class constructor
+                    return new registration.constructor(model, providerName, sdk);
+                }
+                else {
+                    // It's a factory function - call it and await if it returns a promise
+                    const result = registration.constructor(model, providerName, sdk);
+                    if (result && typeof result.then === "function") {
+                        // It's a Promise (async factory)
+                        return await result;
+                    }
+                    else {
+                        // It's a sync result, return it
+                        return result;
+                    }
+                }
+            }
+            else {
+                // Fallback - use as class constructor
+                return new registration.constructor(model, sdk);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to create provider ${providerName}:`, error);
+            throw new Error(`Failed to create provider ${providerName}: ${error}`);
+        }
+    }
+    /**
+     * Check if a provider is registered
+     */
+    static hasProvider(providerName) {
+        return this.providers.has(providerName.toLowerCase());
+    }
+    /**
+     * Get list of available providers
+     */
+    static getAvailableProviders() {
+        return Array.from(this.providers.keys()).filter((name, index, arr) => arr.indexOf(name) === index);
+    }
+    /**
+     * Get provider registration info
+     */
+    static getProviderInfo(providerName) {
+        return this.providers.get(providerName.toLowerCase());
+    }
+    /**
+     * Normalize provider names using aliases (PHASE 1: Factory Pattern)
+     */
+    static normalizeProviderName(providerName) {
+        const normalized = providerName.toLowerCase();
+        // Check direct registration
+        if (this.providers.has(normalized)) {
+            return normalized;
+        }
+        // Check aliases from all registrations
+        for (const [name, registration] of this.providers.entries()) {
+            if (registration.aliases?.includes(normalized)) {
+                return name;
+            }
+        }
+        return null;
+    }
+    /**
+     * Clear all registrations (mainly for testing)
+     */
+    static clearRegistrations() {
+        this.providers.clear();
+        this.initialized = false;
+    }
+    /**
+     * Ensure providers are initialized
+     */
+    static ensureInitialized() {
+        if (!this.initialized) {
+            this.initializeDefaultProviders();
+            this.initialized = true;
+        }
+    }
+    /**
+     * Initialize default providers
+     * NOTE: Providers are now registered by ProviderRegistry to avoid circular dependencies
+     */
+    static initializeDefaultProviders() {
+        logger.debug("BaseProvider factory pattern ready - providers registered by ProviderRegistry");
+        // No hardcoded registrations - all done dynamically by ProviderRegistry
+    }
+    /**
+     * Create the best available provider for the given name
+     * Used by NeuroLink SDK for streaming and generation
+     */
+    static async createBestProvider(providerName, modelName, enableMCP, sdk) {
+        return await this.createProvider(providerName, modelName, sdk);
+    }
+}
+/**
+ * Helper function to create providers with backward compatibility
+ */
+export async function createAIProvider(providerName, modelName) {
+    return await ProviderFactory.createProvider(providerName, modelName);
+}

package/dist/lib/factories/provider-generate-factory.d.ts

@@ -0,0 +1,20 @@
+import type { EnhancedProvider } from "../types/generate-types.js";
+import type { AIProvider } from "../core/types.js";
+/**
+ * Factory for enhancing providers with generate() capability using Proxy pattern
+ * Maintains 100% backward compatibility while adding new generate method
+ */
+export declare class ProviderGenerateFactory {
+    /**
+     * Enhance any provider with generate() method using TypeScript Proxy
+     */
+    static enhanceProvider<T extends AIProvider>(provider: T): T & EnhancedProvider;
+    /**
+     * Create the generate() method that internally uses generateText for performance parity
+     */
+    private static createGenerateMethod;
+    /**
+     * Enhance all providers from a registry
+     */
+    static enhanceAllProviders(providers: Map<string, AIProvider>): Map<string, AIProvider & EnhancedProvider>;
+}

package/dist/lib/factories/provider-generate-factory.js

@@ -0,0 +1,87 @@
+import { CompatibilityConversionFactory } from "./compatibility-factory.js";
+/**
+ * Factory for enhancing providers with generate() capability using Proxy pattern
+ * Maintains 100% backward compatibility while adding new generate method
+ */
+export class ProviderGenerateFactory {
+    /**
+     * Enhance any provider with generate() method using TypeScript Proxy
+     */
+    static enhanceProvider(provider) {
+        return new Proxy(provider, {
+            get(target, prop, receiver) {
+                if (prop === "generate") {
+                    return ProviderGenerateFactory.createGenerateMethod(target);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+            has(target, prop) {
+                if (prop === "generate") {
+                    return true;
+                }
+                return Reflect.has(target, prop);
+            },
+        });
+    }
+    /**
+     * Create the generate() method that internally uses generateText for performance parity
+     */
+    static createGenerateMethod(provider) {
+        return async (options) => {
+            // Validate input
+            if (!options.input?.text) {
+                throw new Error("Generate options must include input.text");
+            }
+            // Convert GenerateOptions to TextGenerationOptions
+            const textOptions = CompatibilityConversionFactory.convertGenerateToText_Options(options);
+            try {
+                // Use existing generate method for identical performance
+                const textResult = await provider.generate(textOptions);
+                // Convert back to GenerateResult format with type safety
+                const generateResult = {
+                    content: textResult?.content || "",
+                    outputs: { text: textResult?.content || "" },
+                    provider: textResult?.provider,
+                    model: textResult?.model,
+                    usage: textResult?.usage
+                        ? {
+                            inputTokens: textResult.usage?.promptTokens || 0,
+                            outputTokens: textResult.usage?.completionTokens || 0,
+                            totalTokens: textResult.usage?.totalTokens || 0,
+                        }
+                        : undefined,
+                    responseTime: textResult?.responseTime,
+                    toolsUsed: textResult?.toolsUsed,
+                    toolExecutions: textResult?.toolExecutions?.map((te) => ({
+                        name: te.toolName || te.name || "",
+                        input: te.input || {},
+                        output: te.output || te.result,
+                        duration: te.executionTime || te.duration || 0,
+                    })),
+                    enhancedWithTools: textResult?.enhancedWithTools,
+                    availableTools: textResult?.availableTools?.map((at) => ({
+                        name: at.name || "",
+                        description: at.description || "",
+                        parameters: at.parameters || {},
+                    })),
+                    analytics: textResult?.analytics,
+                    evaluation: textResult?.evaluation,
+                };
+                return generateResult;
+            }
+            catch (error) {
+                throw new Error(`Generate method failed: ${error}`);
+            }
+        };
+    }
+    /**
+     * Enhance all providers from a registry
+     */
+    static enhanceAllProviders(providers) {
+        const enhancedProviders = new Map();
+        for (const [name, provider] of providers) {
+            enhancedProviders.set(name, this.enhanceProvider(provider));
+        }
+        return enhancedProviders;
+    }
+}

package/dist/lib/factories/provider-registry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Configuration options for the provider registry
+ */
+export interface ProviderRegistryOptions {
+    /**
+     * Enable loading of manual MCP configurations from .mcp-config.json
+     * Should only be true for CLI mode, false for SDK mode
+     */
+    enableManualMCP?: boolean;
+}
+/**
+ * Provider Registry - registers all providers with the factory
+ * This is where we migrate providers one by one to the new pattern
+ */
+export declare class ProviderRegistry {
+    private static registered;
+    private static options;
+    /**
+     * Register all providers with the factory
+     */
+    static registerAllProviders(): Promise<void>;
+    /**
+     * Check if providers are registered
+     */
+    static isRegistered(): boolean;
+    /**
+     * Clear registrations (for testing)
+     */
+    static clearRegistrations(): void;
+    /**
+     * Set registry options (should be called before initialization)
+     */
+    static setOptions(options: ProviderRegistryOptions): void;
+    /**
+     * Get current registry options
+     */
+    static getOptions(): ProviderRegistryOptions;
+}

package/dist/lib/factories/provider-registry.js

@@ -0,0 +1,107 @@
+import { ProviderFactory } from "./provider-factory.js";
+// ✅ FINAL CIRCULAR DEPENDENCY FIX: Lazy loading all providers
+// Removed all static imports - providers loaded dynamically when needed
+// This breaks the circular dependency chain completely
+import { AIProviderName, GoogleAIModels, OpenAIModels } from "../core/types.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Provider Registry - registers all providers with the factory
+ * This is where we migrate providers one by one to the new pattern
+ */
+export class ProviderRegistry {
+    static registered = false;
+    static options = {
+        enableManualMCP: false, // Default to disabled for safety
+    };
+    /**
+     * Register all providers with the factory
+     */
+    static async registerAllProviders() {
+        if (this.registered) {
+            return;
+        }
+        try {
+            // ✅ LAZY LOADING: Register providers with dynamic import factory functions
+            const { ProviderFactory } = await import("./provider-factory.js");
+            // Register Google AI Studio Provider (our validated baseline)
+            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, providerName, sdk) => {
+                const { GoogleAIStudioProvider } = await import("../providers/google-ai-studio.js");
+                return new GoogleAIStudioProvider(modelName, sdk);
+            }, GoogleAIModels.GEMINI_2_5_FLASH, ["google-ai-studio", "google", "gemini", "google-ai"]);
+            // Register OpenAI provider
+            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, providerName, sdk) => {
+                const { OpenAIProvider } = await import("../providers/openAI.js");
+                return new OpenAIProvider(modelName);
+            }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
+            // Register Anthropic provider
+            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, providerName, sdk) => {
+                const { AnthropicProvider } = await import("../providers/anthropic.js");
+                return new AnthropicProvider(modelName, sdk);
+            }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
+            // Register Amazon Bedrock provider
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName) => {
+                const { AmazonBedrockProvider } = await import("../providers/amazon-bedrock.js");
+                return new AmazonBedrockProvider(modelName);
+            }, undefined, // Let provider read BEDROCK_MODEL from .env
+            ["bedrock", "aws"]);
+            // Register Azure OpenAI provider
+            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName) => {
+                const { AzureOpenAIProvider } = await import("../providers/azure-openai.js");
+                return new AzureOpenAIProvider(modelName);
+            }, "gpt-4o-mini", ["azure", "azure-openai"]);
+            // Register Google Vertex AI provider
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName) => {
+                const { GoogleVertexProvider } = await import("../providers/google-vertex.js");
+                return new GoogleVertexProvider(modelName);
+            }, "gemini-2.5-pro", ["vertex", "google-vertex"]);
+            // Register Hugging Face provider (Unified Router implementation)
+            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
+                const { HuggingFaceProvider } = await import("../providers/huggingFace.js");
+                return new HuggingFaceProvider(modelName);
+            }, process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium", ["huggingface", "hf"]);
+            // Register Mistral AI provider
+            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, providerName, sdk) => {
+                const { MistralProvider } = await import("../providers/mistral.js");
+                return new MistralProvider(modelName, sdk);
+            }, "mistral-large-latest", ["mistral"]);
+            // Register Ollama provider
+            ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName) => {
+                const { OllamaProvider } = await import("../providers/ollama.js");
+                return new OllamaProvider(modelName);
+            }, process.env.OLLAMA_MODEL || "llama3.1:8b", ["ollama", "local"]);
+            logger.debug("All providers registered successfully");
+            this.registered = true;
+        }
+        catch (error) {
+            logger.error("Failed to register providers:", error);
+            throw error;
+        }
+    }
+    /**
+     * Check if providers are registered
+     */
+    static isRegistered() {
+        return this.registered;
+    }
+    /**
+     * Clear registrations (for testing)
+     */
+    static clearRegistrations() {
+        ProviderFactory.clearRegistrations();
+        this.registered = false;
+    }
+    /**
+     * Set registry options (should be called before initialization)
+     */
+    static setOptions(options) {
+        this.options = { ...this.options, ...options };
+        logger.debug("Provider registry options updated:", this.options);
+    }
+    /**
+     * Get current registry options
+     */
+    static getOptions() {
+        return { ...this.options };
+    }
+}
+// Note: Providers are registered explicitly when needed to avoid circular dependencies

package/dist/lib/index.d.ts

@@ -9,13 +9,16 @@
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName, } from "./core/types.js";
+export type { GenerateOptions, GenerateResult, EnhancedProvider, } from "./types/generate-types.js";
+export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
+export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
+export type { SimpleTool, ToolContext } from "./sdk/tool-registration.js";
+export { createTool, createTypedTool, validateTool, } from "./sdk/tool-registration.js";
+export type { InMemoryMCPServerConfig, InMemoryToolInfo, InMemoryToolResult, } from "./types/mcp-types.js";
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
-export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
-export type { ProviderName } from "./providers/index.js";
-export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
-export type { TextGenerationOptions, StreamTextOptions, TextGenerationResult, } from "./neurolink.js";
+export type { ProviderStatus, MCPStatus, MCPServerInfo } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function
@@ -25,7 +28,7 @@ export declare const VERSION = "1.0.0";
  * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
- * const result = await provider.streamText('Hello, AI!');
+ * const result = await provider.stream({ input: { text: 'Hello, AI!' } });
  * ```
  */
 export declare function createAIProvider(providerName?: string, modelName?: string): Promise<import("./index.js").AIProvider>;

package/dist/lib/index.js

@@ -9,14 +9,14 @@
 // Core exports
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
+export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
+export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
+export { createTool, createTypedTool, validateTool, } from "./sdk/tool-registration.js";
 // Model enums
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
-// Provider exports
-export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
-export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 // Utility exports
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
-// Main NeuroLink wrapper class
+// Main NeuroLink wrapper class and diagnostic types
 export { NeuroLink } from "./neurolink.js";
 // Version
 export const VERSION = "1.0.0";
@@ -28,7 +28,7 @@ export const VERSION = "1.0.0";
  * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
- * const result = await provider.streamText('Hello, AI!');
+ * const result = await provider.stream({ input: { text: 'Hello, AI!' } });
  * ```
  */
 export async function createAIProvider(providerName, modelName) {

package/dist/lib/mcp/client.js

@@ -49,11 +49,11 @@ export class NeuroLinkMCPClient extends EventEmitter {
                             return result;
                         }
                         // If it's in Lighthouse format with content array
-                        if (result.content &&
-                            Array.isArray(result.content) &&
-                            result.content[0]?.text) {
+                        if (result.text &&
+                            Array.isArray(result.text) &&
+                            result.text[0]?.text) {
                             try {
-                                const data = JSON.parse(result.content[0].text);
+                                const data = JSON.parse(result.text[0].text);
                                 return {
                                     success: !result.isError,
                                     data,
@@ -69,7 +69,7 @@ export class NeuroLinkMCPClient extends EventEmitter {
                                 // If JSON parsing fails, return the text as-is
                                 return {
                                     success: !result.isError,
-                                    data: { text: result.content[0].text },
+                                    data: { text: result.text[0].text },
                                     metadata: {
                                         toolName,
                                         serverId,

package/dist/lib/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/lib/mcp/dynamic-orchestrator.js

@@ -199,11 +199,11 @@ export class DynamicOrchestrator extends MCPOrchestrator {
                 .replace("{previousResults}", previousResults || "None yet");
         try {
             // Use AI Core Server to get tool decision
-            const generateTextTool = aiCoreServer.tools["generate-text"];
-            if (!generateTextTool) {
-                throw new Error("generate-text tool not found");
+            const generateTool = aiCoreServer.tools["generate"];
+            if (!generateTool) {
+                throw new Error("generate tool not found");
             }
-            const aiResponse = await generateTextTool.execute({
+            const aiResponse = await generateTool.execute({
                 prompt: "Select the next tool to execute based on the context provided.",
                 systemPrompt,
                 provider: "google-ai", // Use fast model for decisions
@@ -279,11 +279,11 @@ ${executionSummary}
 Provide a clear, concise answer that addresses the user's request based on the tool results.`;
         try {
             // Use AI to generate final summary
-            const generateTextTool = aiCoreServer.tools["generate-text"];
-            if (!generateTextTool) {
-                throw new Error("generate-text tool not found");
+            const generateTool = aiCoreServer.tools["generate"];
+            if (!generateTool) {
+                throw new Error("generate tool not found");
             }
-            const aiResponse = await generateTextTool.execute({
+            const aiResponse = await generateTool.execute({
                 prompt: summaryPrompt,
                 provider: "google-ai",
                 model: "gemini-2.5-pro",

package/dist/lib/mcp/external-client.js

@@ -139,7 +139,7 @@ export class ExternalMCPClient extends EventEmitter {
             // Transform MCP response to NeuroLink format
             const result = {
                 success: !response.isError,
-                data: response.content || response.result || response,
+                data: response.text || response.result || response,
                 metadata: {
                     toolName,
                     serverId: this.config.name,
@@ -150,7 +150,7 @@ export class ExternalMCPClient extends EventEmitter {
                 },
             };
             if (response.isError) {
-                result.error = response.content?.[0]?.text || "Tool execution failed";
+                result.error = response.text?.[0]?.text || "Tool execution failed";
             }
             logger.debug(`[External MCP] Tool ${toolName} executed in ${executionTime}ms`);
             return result;

package/dist/lib/mcp/factory.d.ts

@@ -134,7 +134,7 @@ export interface MCPServerConfig {
  * });
  *
  * aiCoreServer.registerTool({
- *   name: 'generate-text',
+ *   name: 'generate',
  *   description: 'Generate text using AI providers',
  *   execute: async (params, context) => {
  *     // Tool implementation