@juspay/neurolink 9.2.0 → 9.4.0

package/dist/lib/neurolink.js

@@ -13,39 +13,38 @@ try {
 catch {
     // Environment variables should be set externally in production
 }
-import { AIProviderFactory } from "./core/factory.js";
+import { EventEmitter } from "events";
 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 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 { runWorkflow } from "./workflow/core/workflowRunner.js";
+import { getWorkflow } from "./workflow/core/workflowRegistry.js";
+// Core types imported from core/types.js
 /**
  * NeuroLink - Universal AI Development Platform
  *
@@ -1152,9 +1151,19 @@ Current user's request: ${currentInput}`;
      * @returns The original prompt text as a string.
      */
     _extractOriginalPrompt(optionsOrPrompt) {
-        return typeof optionsOrPrompt === "string"
-            ? optionsOrPrompt
-            : optionsOrPrompt.input.text;
+        if (typeof optionsOrPrompt === "string") {
+            return optionsOrPrompt;
+        }
+        // Handle messages format (for workflow compatibility)
+        const anyOptions = optionsOrPrompt;
+        if (anyOptions.messages && anyOptions.messages.length > 0) {
+            const lastMessage = anyOptions.messages[anyOptions.messages.length - 1];
+            return typeof lastMessage.content === "string"
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+        }
+        // Handle input.text format
+        return optionsOrPrompt.input?.text || "";
     }
     /**
      * Generate AI content using the best available provider with MCP tool integration.
@@ -1381,6 +1390,10 @@ Current user's request: ${currentInput}`;
         if (!options.input?.text || typeof options.input.text !== "string") {
             throw new Error("Input text is required and must be a non-empty string");
         }
+        // Check if workflow is requested
+        if (options.workflow || options.workflowConfig) {
+            return await this.generateWithWorkflow(options);
+        }
         // Set session and user IDs from context for Langfuse spans and execute with proper async scoping
         return await this.setLangfuseContextFromOptions(options, async () => {
             if (this.conversationMemoryConfig?.conversationMemory?.mem0Enabled &&
@@ -1449,6 +1462,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 +1505,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,
@@ -1572,6 +1619,246 @@ Current user's request: ${currentInput}`;
             return generateResult;
         });
     }
+    /**
+     * Generate with workflow engine integration
+     * Returns both original and processed responses for AB testing
+     */
+    async generateWithWorkflow(options) {
+        const workflowStartTime = Date.now();
+        logger.debug("[NeuroLink] Executing workflow generation", {
+            workflowId: options.workflow,
+            hasInlineConfig: !!options.workflowConfig,
+            prompt: options.input.text.substring(0, 100),
+            startTime: workflowStartTime,
+        });
+        // Determine workflow configuration
+        let workflowConfig;
+        if (options.workflowConfig) {
+            // Use inline config
+            workflowConfig = options.workflowConfig;
+        }
+        else if (options.workflow) {
+            // Look up predefined workflow
+            workflowConfig = getWorkflow(options.workflow);
+            if (!workflowConfig) {
+                throw new Error(`Workflow '${options.workflow}' not found in registry`);
+            }
+        }
+        else {
+            throw new Error("Either workflow or workflowConfig must be provided");
+        }
+        // Execute workflow
+        const workflowResult = await runWorkflow(workflowConfig, {
+            prompt: options.input.text,
+            conversationHistory: options.conversationHistory,
+            timeout: options.timeout,
+            verbose: false,
+            metadata: options.context,
+        });
+        // Build GenerateResult with workflow data
+        const generateResult = {
+            // Primary output (backward compatible) - use the original best response
+            content: workflowResult.content,
+            // Provider info from selected response
+            provider: workflowResult.selectedResponse?.provider ||
+                workflowConfig.models[0]?.provider,
+            model: workflowResult.selectedResponse?.model ||
+                workflowConfig.models[0]?.model,
+            // Basic usage info
+            usage: workflowResult.usage
+                ? {
+                    input: workflowResult.usage.totalInputTokens,
+                    output: workflowResult.usage.totalOutputTokens,
+                    total: workflowResult.usage.totalTokens,
+                }
+                : undefined,
+            // Performance
+            responseTime: workflowResult.totalTime,
+            // Workflow-specific data
+            workflow: {
+                originalResponse: workflowResult.originalContent || workflowResult.content, // Original unmodified best response
+                processedResponse: workflowResult.content, // After conditioning (with metadata)
+                ensembleResponses: workflowResult.ensembleResponses.map((r) => ({
+                    provider: r.provider,
+                    model: r.model,
+                    content: r.content,
+                    responseTime: r.responseTime,
+                    status: r.status,
+                    error: r.error,
+                })),
+                judgeScores: workflowResult.judgeScores
+                    ? {
+                        scores: workflowResult.judgeScores.scores,
+                        reasoning: workflowResult.reasoning,
+                        selectedModel: `${workflowResult.selectedResponse?.provider}-${workflowResult.selectedResponse?.model}`,
+                    }
+                    : undefined,
+                selectedModel: `${workflowResult.selectedResponse?.provider}-${workflowResult.selectedResponse?.model}`,
+                metrics: {
+                    totalTime: workflowResult.totalTime,
+                    ensembleTime: workflowResult.ensembleTime,
+                    judgeTime: workflowResult.judgeTime,
+                    conditioningTime: workflowResult.conditioningTime,
+                },
+                workflowId: workflowResult.workflow,
+                workflowName: workflowResult.workflowName,
+            },
+        };
+        logger.debug("[NeuroLink] Workflow generation complete", {
+            workflowId: workflowResult.workflow,
+            selectedModel: generateResult.workflow?.selectedModel,
+            score: workflowResult.score,
+            totalTime: workflowResult.totalTime,
+        });
+        return generateResult;
+    }
+    /**
+     * Stream with workflow engine integration
+     * Progressive streaming: yields preliminary response (first model) then final synthesis
+     */
+    async streamWithWorkflow(options, startTime) {
+        logger.debug("[NeuroLink] Executing workflow streaming (progressive)", {
+            workflowId: options.workflow,
+            hasInlineConfig: !!options.workflowConfig,
+            prompt: options.input.text.substring(0, 100),
+        });
+        // Determine workflow configuration
+        let workflowConfig;
+        if (options.workflowConfig) {
+            workflowConfig = options.workflowConfig;
+        }
+        else if (options.workflow) {
+            workflowConfig = getWorkflow(options.workflow);
+            if (!workflowConfig) {
+                throw new Error(`Workflow '${options.workflow}' not found in registry`);
+            }
+        }
+        else {
+            throw new Error("Either workflow or workflowConfig must be provided");
+        }
+        // Import streaming workflow runner
+        const { runWorkflowWithStreaming } = await import("./workflow/core/workflowRunner.js");
+        // Execute workflow with progressive streaming
+        const workflowStream = runWorkflowWithStreaming(workflowConfig, {
+            prompt: options.input.text,
+            conversationHistory: options.conversationHistory,
+            timeout: options.timeout,
+            verbose: false,
+            metadata: options.context,
+            streaming: true,
+        });
+        // Store final result for metadata
+        let finalResult = null;
+        let preliminaryTime = 0;
+        // Create a generator that yields progressive chunks
+        const stream = (async function* () {
+            for await (const chunk of workflowStream) {
+                if (chunk.type === "preliminary") {
+                    preliminaryTime = Date.now() - startTime;
+                    logger.debug("[NeuroLink] Streaming preliminary response", {
+                        responseTime: preliminaryTime,
+                        contentLength: chunk.content.length,
+                    });
+                    yield {
+                        content: chunk.content,
+                        type: "preliminary",
+                    };
+                }
+                else if (chunk.type === "final") {
+                    finalResult = chunk.partialResult ?? null;
+                    const finalTime = Date.now() - startTime;
+                    logger.debug("[NeuroLink] Streaming final synthesis", {
+                        responseTime: finalTime,
+                        contentLength: chunk.content.length,
+                    });
+                    yield {
+                        content: chunk.content,
+                        type: "final",
+                    };
+                }
+            }
+        })();
+        const streamResult = {
+            stream,
+            // Provider info (will be from final result)
+            provider: workflowConfig.models[0]?.provider,
+            model: workflowConfig.models[0]?.model,
+            // Metadata
+            metadata: {
+                streamId: `workflow-${workflowConfig.id}-${Date.now()}`,
+                startTime,
+                responseTime: 0, // Will be updated after stream completes
+            },
+            // Note: Workflow data will be populated after stream completes
+            // For now, return placeholder that will be updated via stream metadata
+        };
+        // Wrap stream to capture final result and populate metadata
+        const originalStream = streamResult.stream;
+        streamResult.stream = (async function* () {
+            for await (const chunk of originalStream) {
+                yield chunk;
+            }
+            // After stream completes, update result with final workflow data
+            if (finalResult) {
+                const result = finalResult;
+                const responseTime = Date.now() - startTime;
+                // Update usage if available
+                if (result.usage) {
+                    streamResult.usage = {
+                        input: result.usage.totalInputTokens,
+                        output: result.usage.totalOutputTokens,
+                        total: result.usage.totalTokens,
+                    };
+                }
+                // Update metadata
+                streamResult.metadata = {
+                    ...streamResult.metadata,
+                    totalChunks: 2, // Preliminary + final
+                    responseTime,
+                    preliminaryTime,
+                };
+                // Build workflow data with proper type safety
+                const ensembleResponses = result.ensembleResponses?.map((r) => ({
+                    provider: r.provider,
+                    model: r.model,
+                    content: r.content,
+                    responseTime: r.responseTime,
+                    status: r.status,
+                    error: r.error,
+                })) ?? [];
+                const judgeScores = result.judgeScores
+                    ? {
+                        scores: result.judgeScores.scores,
+                        reasoning: result.reasoning ?? "",
+                        selectedModel: result.selectedResponse
+                            ? `${result.selectedResponse.provider}-${result.selectedResponse.model}`
+                            : "unknown",
+                    }
+                    : undefined;
+                streamResult.workflow = {
+                    originalResponse: result.originalContent ?? result.content ?? "",
+                    processedResponse: result.content ?? "",
+                    ensembleResponses,
+                    judgeScores,
+                    selectedModel: result.selectedResponse
+                        ? `${result.selectedResponse.provider}-${result.selectedResponse.model}`
+                        : "unknown",
+                    metrics: {
+                        totalTime: result.totalTime ?? responseTime,
+                        ensembleTime: result.ensembleTime ?? 0,
+                        judgeTime: result.judgeTime,
+                        conditioningTime: result.conditioningTime,
+                    },
+                    workflowId: result.workflow ?? workflowConfig.id,
+                    workflowName: result.workflowName ?? workflowConfig.name,
+                };
+            }
+        })();
+        logger.debug("[NeuroLink] Workflow streaming initialized", {
+            workflowId: workflowConfig.id,
+        });
+        return streamResult;
+    }
     /**
      * BACKWARD COMPATIBILITY: Legacy generateText method
      * Internally calls generate() and converts result format
@@ -2105,6 +2392,10 @@ Current user's request: ${currentInput}`;
         const originalPrompt = options.input.text; // Store the original prompt for memory storage
         await this.validateStreamInput(options);
         this.emitStreamStartEvents(options, startTime);
+        // Check if workflow is requested
+        if (options.workflow || options.workflowConfig) {
+            return await this.streamWithWorkflow(options, startTime);
+        }
         // Set session and user IDs from context for Langfuse spans and execute with proper async scoping
         return await this.setLangfuseContextFromOptions(options, async () => {
             let enhancedOptions;
@@ -2184,6 +2475,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 +2654,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 +2881,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 +4231,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 +4838,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/lib/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/lib/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,5 +1186,53 @@ 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);
+        }
+    }
 }
 //# sourceMappingURL=amazonBedrock.js.map

package/dist/lib/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