@juspay/neurolink 9.2.0 → 9.3.0

package/dist/neurolink.js

@@ -13,39 +13,35 @@ try {
 catch {
     // Environment variables should be set externally in production
 }
-import { AIProviderFactory } from "./core/factory.js";
-import { isNonNullObject } from "./utils/typeUtils.js";
-import { isZodSchema } from "./utils/schemaConversion.js";
-import { AIProviderName } from "./constants/enums.js";
-import { mcpLogger } from "./utils/logger.js";
-import { SYSTEM_LIMITS } from "./core/constants.js";
-import { NANOSECOND_TO_MS_DIVISOR, TOOL_TIMEOUTS, RETRY_ATTEMPTS, RETRY_DELAYS, CIRCUIT_BREAKER, CIRCUIT_BREAKER_RESET_MS, MEMORY_THRESHOLDS, PROVIDER_TIMEOUTS, PERFORMANCE_THRESHOLDS, } from "./constants/index.js";
+import { EventEmitter } from "events";
 import pLimit from "p-limit";
-import { MCPToolRegistry } from "./mcp/toolRegistry.js";
-import { logger } from "./utils/logger.js";
-import { getBestProvider } from "./utils/providerUtils.js";
+import { CIRCUIT_BREAKER, CIRCUIT_BREAKER_RESET_MS, MEMORY_THRESHOLDS, NANOSECOND_TO_MS_DIVISOR, PERFORMANCE_THRESHOLDS, PROVIDER_TIMEOUTS, RETRY_ATTEMPTS, RETRY_DELAYS, TOOL_TIMEOUTS, } from "./constants/index.js";
+import { SYSTEM_LIMITS } from "./core/constants.js";
+import { AIProviderFactory } from "./core/factory.js";
 import { ProviderRegistry } from "./factories/providerRegistry.js";
-import { createCustomToolServerInfo, detectCategory, } from "./utils/mcpDefaults.js";
-// Factory processing imports
-import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryConfig, processStreamingFactoryOptions, createCleanStreamOptions, } from "./utils/factoryProcessing.js";
-// Tool detection and execution imports
-// Transformation utilities
-import { transformToolExecutions, transformToolExecutionsForMCP, transformAvailableTools, transformToolsForMCP, transformToolsToExpectedFormat, transformToolsToDescriptions, extractToolNames, transformParamsForLogging, optimizeToolForCollection, } from "./utils/transformationUtils.js";
-// Enhanced error handling imports
-import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
-import { EventEmitter } from "events";
-import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
-import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
-import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
-import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { HITLManager } from "./hitl/hitlManager.js";
+import { ExternalServerManager } from "./mcp/externalServerManager.js";
 // Import direct tools server for automatic registration
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
+import { MCPToolRegistry } from "./mcp/toolRegistry.js";
+import { initializeMem0 } from "./memory/mem0Initializer.js";
+import { flushOpenTelemetry, getLangfuseHealthStatus, initializeOpenTelemetry, isOpenTelemetryInitialized, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
+import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
+// Enhanced error handling imports
+import { CircuitBreaker, ErrorFactory, isRetriableError, logStructuredError, NeuroLinkError, withRetry, withTimeout, } from "./utils/errorHandling.js";
+// Factory processing imports
+import { createCleanStreamOptions, enhanceTextGenerationOptions, processFactoryOptions, processStreamingFactoryOptions, validateFactoryConfig, } from "./utils/factoryProcessing.js";
+import { logger, mcpLogger } from "./utils/logger.js";
+import { createCustomToolServerInfo, detectCategory, } from "./utils/mcpDefaults.js";
 // Import orchestration components
 import { ModelRouter } from "./utils/modelRouter.js";
+import { getBestProvider } from "./utils/providerUtils.js";
+import { isZodSchema } from "./utils/schemaConversion.js";
 import { BinaryTaskClassifier } from "./utils/taskClassifier.js";
-import { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, isOpenTelemetryInitialized, } from "./services/server/ai/observability/instrumentation.js";
-import { initializeMem0 } from "./memory/mem0Initializer.js";
+// Tool detection and execution imports
+// Transformation utilities
+import { extractToolNames, optimizeToolForCollection, transformAvailableTools, transformParamsForLogging, transformToolExecutions, transformToolExecutionsForMCP, transformToolsForMCP, transformToolsToDescriptions, transformToolsToExpectedFormat, } from "./utils/transformationUtils.js";
+import { isNonNullObject } from "./utils/typeUtils.js";
 /**
  * NeuroLink - Universal AI Development Platform
  *
@@ -1449,6 +1445,39 @@ Current user's request: ${currentInput}`;
                     // Continue with warning rather than throwing - graceful degradation
                 }
             }
+            // RAG Integration: If rag config is provided, prepare the RAG search tool
+            if (options.rag?.files?.length) {
+                try {
+                    const { prepareRAGTool } = await import("./rag/ragIntegration.js");
+                    const ragResult = await prepareRAGTool(options.rag, options.provider);
+                    // Inject the RAG tool into the tools record
+                    if (!options.tools) {
+                        options.tools = {};
+                    }
+                    options.tools[ragResult.toolName] =
+                        ragResult.tool;
+                    // Inject RAG-aware system prompt so the AI uses the RAG tool first
+                    const ragSystemInstruction = [
+                        `\n\nIMPORTANT: You have a tool called "${ragResult.toolName}" that searches through`,
+                        `${ragResult.filesLoaded} loaded document(s) containing ${ragResult.chunksIndexed} indexed chunks.`,
+                        `ALWAYS use the "${ragResult.toolName}" tool FIRST to answer the user's question before using any other tools.`,
+                        `This tool searches your local knowledge base of pre-loaded documents and is the primary source of truth.`,
+                        `Do NOT use websearchGrounding or any web search tools when the answer can be found in the loaded documents.`,
+                    ].join(" ");
+                    options.systemPrompt =
+                        (options.systemPrompt || "") + ragSystemInstruction;
+                    logger.info("[RAG] Tool injected into generate()", {
+                        toolName: ragResult.toolName,
+                        filesLoaded: ragResult.filesLoaded,
+                        chunksIndexed: ragResult.chunksIndexed,
+                    });
+                }
+                catch (error) {
+                    logger.warn("[RAG] Failed to prepare RAG tool, continuing without RAG", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
             // 🔧 CRITICAL FIX: Convert to TextGenerationOptions while preserving the input object for multimodal support
             const baseOptions = {
                 prompt: options.input.text,
@@ -1459,6 +1488,7 @@ Current user's request: ${currentInput}`;
                 systemPrompt: options.systemPrompt,
                 schema: options.schema,
                 output: options.output,
+                tools: options.tools, // Includes RAG tools if rag config was provided
                 disableTools: options.disableTools,
                 enableAnalytics: options.enableAnalytics,
                 enableEvaluation: options.enableEvaluation,
@@ -2184,6 +2214,39 @@ Current user's request: ${currentInput}`;
                         }
                     }
                 }
+                // RAG Integration: If rag config is provided, prepare the RAG search tool (stream)
+                if (options.rag?.files?.length) {
+                    try {
+                        const { prepareRAGTool } = await import("./rag/ragIntegration.js");
+                        const ragResult = await prepareRAGTool(options.rag, options.provider);
+                        // Inject the RAG tool into the tools record
+                        if (!options.tools) {
+                            options.tools = {};
+                        }
+                        options.tools[ragResult.toolName] =
+                            ragResult.tool;
+                        // Inject RAG-aware system prompt so the AI uses the RAG tool first
+                        const ragStreamInstruction = [
+                            `\n\nIMPORTANT: You have a tool called "${ragResult.toolName}" that searches through`,
+                            `${ragResult.filesLoaded} loaded document(s) containing ${ragResult.chunksIndexed} indexed chunks.`,
+                            `ALWAYS use the "${ragResult.toolName}" tool FIRST to answer the user's question before using any other tools.`,
+                            `This tool searches your local knowledge base of pre-loaded documents and is the primary source of truth.`,
+                            `Do NOT use websearchGrounding or any web search tools when the answer can be found in the loaded documents.`,
+                        ].join(" ");
+                        options.systemPrompt =
+                            (options.systemPrompt || "") + ragStreamInstruction;
+                        logger.info("[RAG] Tool injected into stream()", {
+                            toolName: ragResult.toolName,
+                            filesLoaded: ragResult.filesLoaded,
+                            chunksIndexed: ragResult.chunksIndexed,
+                        });
+                    }
+                    catch (error) {
+                        logger.warn("[RAG] Failed to prepare RAG tool, continuing without RAG", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
                 factoryResult = processStreamingFactoryOptions(options);
                 enhancedOptions = createCleanStreamOptions(options);
                 if (options.input?.text) {
@@ -2330,7 +2393,7 @@ Current user's request: ${currentInput}`;
                         if (self.conversationMemory && enhancedOptions.context?.sessionId) {
                             const sessionId = enhancedOptions.context?.sessionId;
                             const userId = enhancedOptions.context?.userId;
-                            let providerDetails = undefined;
+                            let providerDetails;
                             if (enhancedOptions.model) {
                                 providerDetails = {
                                     provider: providerName,
@@ -2557,7 +2620,7 @@ Current user's request: ${currentInput}`;
                     const sessionId = enhancedOptions?.context?.sessionId;
                     const userId = enhancedOptions?.context
                         ?.userId;
-                    let providerDetails = undefined;
+                    let providerDetails;
                     if (options.model) {
                         providerDetails = {
                             provider: providerName,
@@ -3907,7 +3970,10 @@ Current user's request: ${currentInput}`;
     async hasProviderEnvVars(providerName) {
         const { ProviderHealthChecker } = await import("./utils/providerHealth.js");
         try {
-            const health = await ProviderHealthChecker.checkProviderHealth(providerName, { includeConnectivityTest: false, cacheResults: false });
+            const health = await ProviderHealthChecker.checkProviderHealth(providerName, {
+                includeConnectivityTest: false,
+                cacheResults: false,
+            });
             return health.isConfigured && health.hasApiKey;
         }
         catch (error) {
@@ -4511,7 +4577,7 @@ Current user's request: ${currentInput}`;
             // Import the integration module
             const { initializeConversationMemory } = await import("./core/conversationMemoryInitializer.js");
             // Use the integration module to create the appropriate memory manager
-            const memoryManager = await initializeConversationMemory(this.conversationMemoryConfig, this.emitter);
+            const memoryManager = await initializeConversationMemory(this.conversationMemoryConfig);
             // Assign to conversationMemory with proper type to handle both memory manager types
             this.conversationMemory = memoryManager;
             // Reset the lazy init flag since we've now initialized

package/dist/providers/amazonBedrock.d.ts

@@ -1,9 +1,9 @@
 import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { NeuroLink } from "../neurolink.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/index.js";
-import { AIProviderName } from "../constants/enums.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { NeuroLink } from "../neurolink.js";
 export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;
     private conversationHistory;
@@ -17,6 +17,11 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     getAISDKModel(): never;
     getProviderName(): AIProviderName;
     getDefaultModel(): string;
+    /**
+     * Get the default embedding model for Amazon Bedrock
+     * @returns The default Bedrock embedding model name
+     */
+    protected getDefaultEmbeddingModel(): string;
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     private conversationLoop;
     private callBedrock;
@@ -40,4 +45,12 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      */
     checkBedrockHealth(): Promise<void>;
     handleProviderError(error: unknown): Error;
+    /**
+     * Generate embeddings for text using Amazon Bedrock embedding models
+     * Uses the native AWS SDK InvokeModel command for Titan embeddings
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
+     * @returns Promise resolving to the embedding vector
+     */
+    embed(text: string, modelName?: string): Promise<number[]>;
 }

package/dist/providers/amazonBedrock.js

@@ -1,14 +1,13 @@
-import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, ImageFormat, } from "@aws-sdk/client-bedrock-runtime";
 import { BedrockClient, ListFoundationModelsCommand, } from "@aws-sdk/client-bedrock";
+import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, ImageFormat, } from "@aws-sdk/client-bedrock-runtime";
+import path from "path";
+import { createAnalytics } from "../core/analytics.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { AIProviderName } from "../constants/enums.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { logger } from "../utils/logger.js";
-import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { createAnalytics } from "../core/analytics.js";
-import path from "path";
+import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 // Bedrock-specific types now imported from ../types/providerSpecific.js
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
@@ -88,6 +87,15 @@ export class AmazonBedrockProvider extends BaseProvider {
     getDefaultModel() {
         return (process.env.BEDROCK_MODEL || "anthropic.claude-3-sonnet-20240229-v1:0");
     }
+    /**
+     * Get the default embedding model for Amazon Bedrock
+     * @returns The default Bedrock embedding model name
+     */
+    getDefaultEmbeddingModel() {
+        return (process.env.BEDROCK_EMBEDDING_MODEL ||
+            process.env.AWS_EMBEDDING_MODEL ||
+            "amazon.titan-embed-text-v2:0");
+    }
     // Override the main generate method to implement conversation management
     async generate(optionsOrPrompt) {
         logger.debug("[AmazonBedrockProvider] generate() called with conversation management");
@@ -158,7 +166,6 @@ export class AmazonBedrockProvider extends BaseProvider {
                 logger.debug(`[AmazonBedrockProvider] Handle response result:`, result);
                 if (result.shouldContinue) {
                     logger.debug(`[AmazonBedrockProvider] Continuing conversation loop...`);
-                    continue;
                 }
                 else {
                     logger.debug(`[AmazonBedrockProvider] Conversation completed with final text`);
@@ -876,7 +883,9 @@ export class AmazonBedrockProvider extends BaseProvider {
             logger.info(`🔍 [AmazonBedrockProvider] Message ${index}: role=${msg.role}, content=${JSON.stringify(msg.content)}`);
         });
         // Get all available tools
-        const aiTools = await this.getAllTools();
+        // BaseProvider.stream() pre-merges base tools + external tools into options.tools
+        const aiTools = options.tools ||
+            (await this.getAllTools());
         const allTools = this.convertAISDKToolsToToolDefinitions(aiTools);
         const toolConfig = this.formatToolsForBedrock(allTools);
         const convertedMessages = this.convertToAWSMessages(this.conversationHistory);
@@ -1177,4 +1186,52 @@ export class AmazonBedrockProvider extends BaseProvider {
         }
         return new Error(`AWS Bedrock error: ${message}`);
     }
+    /**
+     * Generate embeddings for text using Amazon Bedrock embedding models
+     * Uses the native AWS SDK InvokeModel command for Titan embeddings
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
+     * @returns Promise resolving to the embedding vector
+     */
+    async embed(text, modelName) {
+        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+        logger.debug("Generating embedding", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            textLength: text.length,
+        });
+        try {
+            const { InvokeModelCommand } = await import("@aws-sdk/client-bedrock-runtime");
+            // Titan Embed models expect a specific input format
+            const requestBody = JSON.stringify({
+                inputText: text,
+            });
+            const command = new InvokeModelCommand({
+                modelId: embeddingModelName,
+                contentType: "application/json",
+                accept: "application/json",
+                body: requestBody,
+            });
+            const response = await this.bedrockClient.send(command);
+            // Parse the response
+            const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+            if (!responseBody.embedding || !Array.isArray(responseBody.embedding)) {
+                throw new Error("Invalid embedding response from Bedrock");
+            }
+            logger.debug("Embedding generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                embeddingDimension: responseBody.embedding.length,
+            });
+            return responseBody.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);
+        }
+    }
 }

package/dist/providers/anthropic.d.ts

@@ -1,8 +1,8 @@
 import { type LanguageModelV1 } from "ai";
-import type { ValidationSchema } from "../types/typeAliases.js";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { ValidationSchema } from "../types/typeAliases.js";
 /**
  * Anthropic Provider v2 - BaseProvider Implementation
  * Fixed syntax and enhanced with proper error handling

package/dist/providers/anthropic.js

@@ -1,13 +1,13 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
-import { AIProviderName, AnthropicModels } from "../constants/enums.js";
+import { AnthropicModels } 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, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
+import { logger } from "../utils/logger.js";
+import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
     return validateApiKey(createAnthropicConfig());
@@ -88,9 +88,12 @@ export class AnthropicProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            // ✅ Get tools for streaming (same as 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 tools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);

package/dist/providers/googleAiStudio.d.ts

@@ -1,9 +1,9 @@
-import { type Schema, type LanguageModelV1 } from "ai";
-import type { ZodUnknownSchema } from "../types/typeAliases.js";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { TextGenerationOptions, EnhancedGenerateResult } from "../types/generateTypes.js";
+import { type LanguageModelV1, type Schema } from "ai";
+import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { ZodUnknownSchema } from "../types/typeAliases.js";
 /**
  * Google AI Studio provider implementation using BaseProvider
  * Migrated from original GoogleAIStudio class to new factory pattern

package/dist/providers/googleAiStudio.js

@@ -1,16 +1,16 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText } from "ai";
-import { AIProviderName, GoogleAIModels, ErrorCategory, ErrorSeverity, } from "../constants/enums.js";
-import { NeuroLinkError, ERROR_CODES } from "../utils/errorHandling.js";
+import { ErrorCategory, ErrorSeverity, GoogleAIModels, } 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, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
+import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
+import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
 import { convertZodToJsonSchema, inlineJsonSchema, isZodSchema, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -424,9 +424,12 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            // Get tools consistently with generate method
+            // Get tools consistently with generate method (include user-provided RAG tools)
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
+            const baseTools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? { ...baseTools, ...(options.tools || {}) }
+                : {};
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);

package/dist/providers/googleVertex.d.ts

@@ -1,9 +1,9 @@
+import { type LanguageModel, type LanguageModelV1, type Schema } from "ai";
 import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1, type LanguageModel } from "ai";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { TextGenerationOptions, EnhancedGenerateResult } from "../types/generateTypes.js";
+import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * Google Vertex AI Provider v2 - BaseProvider Implementation
  *
@@ -64,6 +64,11 @@ export declare class GoogleVertexProvider extends BaseProvider {
     constructor(modelName?: string, _providerName?: string, sdk?: unknown, region?: string);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
+    /**
+     * Get the default embedding model for Google Vertex
+     * @returns The default Vertex AI embedding model name
+     */
+    protected getDefaultEmbeddingModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Google Vertex
      * Creates fresh model instances for each request
@@ -237,6 +242,13 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns A promise that resolves to the generation result, including the image data.
      */
     protected executeImageGeneration(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
+    /**
+     * Generate embeddings for text using Google Vertex AI text-embedding models
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: text-embedding-004)
+     * @returns Promise resolving to the embedding vector
+     */
+    embed(text: string, modelName?: string): Promise<number[]>;
     /**
      * Get model suggestions when a model is not found
      */

package/dist/providers/googleVertex.js

@@ -1,24 +1,24 @@
 import { createVertex, } from "@ai-sdk/google-vertex";
 import { createVertexAnthropic, } from "@ai-sdk/google-vertex/anthropic";
-import { streamText, Output, } from "ai";
-import { AIProviderName, ErrorCategory, ErrorSeverity, } from "../constants/enums.js";
-import { NeuroLinkError, ERROR_CODES } from "../utils/errorHandling.js";
+import { Output, streamText, } from "ai";
+import dns from "dns";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { ErrorCategory, ErrorSeverity, } 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, ProviderError } from "../types/errors.js";
-import { DEFAULT_MAX_STEPS, GLOBAL_LOCATION_MODELS, DEFAULT_TOOL_MAX_RETRIES, } from "../core/constants.js";
+import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
-import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, ProviderError } from "../types/errors.js";
+import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
+import { FileDetector } from "../utils/fileDetector.js";
+import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
+import { createGoogleAuthConfig, createVertexProjectConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import dns from "dns";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { FileDetector } from "../utils/fileDetector.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 // Import proper types for multimodal message handling
 // Enhanced Anthropic support with direct imports
 // Using the dual provider architecture from Vercel AI SDK
@@ -339,6 +339,15 @@ export class GoogleVertexProvider extends BaseProvider {
     getDefaultModel() {
         return getDefaultVertexModel();
     }
+    /**
+     * Get the default embedding model for Google Vertex
+     * @returns The default Vertex AI embedding model name
+     */
+    getDefaultEmbeddingModel() {
+        return (process.env.VERTEX_EMBEDDING_MODEL ||
+            process.env.GOOGLE_EMBEDDING_MODEL ||
+            "text-embedding-004");
+    }
     /**
      * Returns the Vercel AI SDK model instance for Google Vertex
      * Creates fresh model instances for each request
@@ -702,11 +711,16 @@ export class GoogleVertexProvider extends BaseProvider {
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            // Get all available tools (direct + MCP + external) for streaming
+            // Get all available tools (direct + MCP + external + user-provided RAG tools) for streaming
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
+            const baseStreamTools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? { ...baseStreamTools, ...(options.tools || {}) }
+                : {};
             logger.debug(`${functionTag}: Tools for streaming`, {
                 shouldUseTools,
+                baseToolCount: Object.keys(baseStreamTools).length,
+                externalToolCount: Object.keys(options.tools || {}).length,
                 toolCount: Object.keys(tools).length,
                 toolNames: Object.keys(tools),
             });
@@ -2747,6 +2761,48 @@ export class GoogleVertexProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for text using Google Vertex AI text-embedding models
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: text-embedding-004)
+     * @returns Promise resolving to the embedding vector
+     */
+    async embed(text, modelName) {
+        const embeddingModelName = modelName || "text-embedding-004";
+        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 Vertex provider with current settings
+            const vertexSettings = await createVertexSettings(this.location);
+            const vertex = createVertex(vertexSettings);
+            // Get the text embedding model
+            const embeddingModel = vertex.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);
+        }
+    }
     /**
      * Get model suggestions when a model is not found
      */

package/dist/providers/litellm.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 type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * LiteLLM Provider - BaseProvider Implementation
  * Provides access to 100+ models via LiteLLM proxy server