@juspay/neurolink 9.51.3 → 9.52.0

package/dist/mcp/toolDiscoveryService.js

@@ -26,9 +26,20 @@ export class ToolDiscoveryService extends EventEmitter {
     toolRegistry = new Map();
     serverTools = new Map();
     discoveryInProgress = new Set();
+    /** Optional normalizer applied to every tool output before it is returned. */
+    outputNormalizer;
     constructor() {
         super();
     }
+    /**
+     * Attach a McpOutputNormalizer.
+     * When set, every raw callTool() result is passed through the normalizer
+     * before being returned. Oversized outputs are replaced with compact
+     * surrogates according to the configured strategy.
+     */
+    setOutputNormalizer(normalizer) {
+        this.outputNormalizer = normalizer;
+    }
     /**
      * Discover tools from an external MCP server
      */
@@ -361,6 +372,26 @@ export class ToolDiscoveryService extends EventEmitter {
                             arguments: parameters,
                         }), timeout, new Error(`Tool execution timeout: ${toolName}`));
                         callSpan.setStatus({ code: SpanStatusCode.OK });
+                        // ── MCP output normalization ──────────────────────────────────
+                        // Intercept here — after receive, before cache, before memory,
+                        // before LLM context injection. Returns a compact surrogate when
+                        // the payload exceeds mcp.outputLimits.maxBytes.
+                        if (this.outputNormalizer) {
+                            try {
+                                const normalized = await this.outputNormalizer.normalize(callResult, { toolName, serverId });
+                                callSpan.setAttribute("mcp.output.strategy", normalized.isExternalized ? "externalize" : "inline");
+                                if (normalized.isExternalized) {
+                                    callSpan.setAttribute("mcp.output.original_bytes", normalized.originalBytes);
+                                }
+                                return normalized.result;
+                            }
+                            catch (normErr) {
+                                mcpLogger.warn(`[ToolDiscoveryService] McpOutputNormalizer failed for ` +
+                                    `${toolName}: ${normErr instanceof Error ? normErr.message : String(normErr)} ` +
+                                    `— returning raw result`);
+                            }
+                        }
+                        // ── end normalization ─────────────────────────────────────────
                         return callResult;
                     }
                     catch (err) {
@@ -385,7 +416,7 @@ export class ToolDiscoveryService extends EventEmitter {
             }
             mcpLogger.debug(`[ToolDiscoveryService] Tool execution completed: ${toolName}`, {
                 duration,
-                hasContent: !!result.content,
+                hasContent: !!result?.content,
             });
             return {
                 success: true,

package/dist/memory/memoryRetrievalTools.d.ts

@@ -7,14 +7,21 @@
  * @module
  */
 import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
+import type { ArtifactStore } from "../artifacts/artifactStore.js";
 /**
  * Factory function that creates memory retrieval tools bound to a memory manager.
- * @param memoryManager - The Redis conversation memory manager instance
+ *
+ * @param memoryManager  Redis conversation memory manager instance.
+ * @param artifactStore  Optional artifact store for externalized MCP outputs.
+ *                       When provided, retrieve_context gains an `artifactId`
+ *                       parameter that fetches the full payload written by
+ *                       McpOutputNormalizer under strategy="externalize".
  * @returns Record of tool name to Vercel AI SDK tool definition
  */
-export declare function createMemoryRetrievalTools(memoryManager: RedisConversationMemoryManager): {
+export declare function createMemoryRetrievalTools(memoryManager: RedisConversationMemoryManager | undefined, artifactStore?: ArtifactStore): {
     retrieve_context: import("ai").Tool<{
-        sessionId: string;
+        sessionId?: string | undefined;
+        artifactId?: string | undefined;
         messageId?: string | undefined;
         role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
         lastN?: number | undefined;
@@ -22,14 +29,62 @@ export declare function createMemoryRetrievalTools(memoryManager: RedisConversat
         limit?: number | undefined;
         search?: string | undefined;
     }, {
+        error: string;
+        artifactId: string;
+        content?: undefined;
+        totalSize?: undefined;
+        hasMore?: undefined;
+        offset?: undefined;
+        limit?: undefined;
+        sessionId?: undefined;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
+        artifactId: string;
+        content: string;
+        totalSize: number;
+        hasMore: boolean;
+        offset: number;
+        limit: number;
+        error?: undefined;
+        sessionId?: undefined;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
+        error: string;
+        artifactId?: undefined;
+        content?: undefined;
+        totalSize?: undefined;
+        hasMore?: undefined;
+        offset?: undefined;
+        limit?: undefined;
+        sessionId?: undefined;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
         error: string;
         sessionId: string;
+        artifactId?: undefined;
+        content?: undefined;
+        totalSize?: undefined;
+        hasMore?: undefined;
+        offset?: undefined;
+        limit?: undefined;
         messageId?: undefined;
         messages?: undefined;
         totalMessages?: undefined;
     } | {
         error: string;
         messageId: string;
+        artifactId?: undefined;
+        content?: undefined;
+        totalSize?: undefined;
+        hasMore?: undefined;
+        offset?: undefined;
+        limit?: undefined;
         sessionId?: undefined;
         messages?: undefined;
         totalMessages?: undefined;
@@ -70,13 +125,13 @@ export declare function createMemoryRetrievalTools(memoryManager: RedisConversat
         })[];
         totalMessages: number;
         error?: undefined;
+        artifactId?: undefined;
+        content?: undefined;
+        totalSize?: undefined;
+        hasMore?: undefined;
+        offset?: undefined;
+        limit?: undefined;
         sessionId?: undefined;
         messageId?: undefined;
-    } | {
-        error: string;
-        sessionId?: undefined;
-        messageId?: undefined;
-        messages?: undefined;
-        totalMessages?: undefined;
     }>;
 };

package/dist/memory/memoryRetrievalTools.js

@@ -9,6 +9,7 @@
 import { tool } from "ai";
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
+import { withTimeout } from "../utils/errorHandling.js";
 import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
 import { getMetricsAggregator } from "../observability/index.js";
 /** Maximum characters returned per retrieval request */
@@ -19,18 +20,36 @@ const MAX_RETRIEVAL_LIMIT = 200_000;
 const MAX_SEARCH_MATCHES = 50;
 /**
  * Factory function that creates memory retrieval tools bound to a memory manager.
- * @param memoryManager - The Redis conversation memory manager instance
+ *
+ * @param memoryManager  Redis conversation memory manager instance.
+ * @param artifactStore  Optional artifact store for externalized MCP outputs.
+ *                       When provided, retrieve_context gains an `artifactId`
+ *                       parameter that fetches the full payload written by
+ *                       McpOutputNormalizer under strategy="externalize".
  * @returns Record of tool name to Vercel AI SDK tool definition
  */
-export function createMemoryRetrievalTools(memoryManager) {
+export function createMemoryRetrievalTools(memoryManager, artifactStore) {
     return {
         retrieve_context: tool({
-            description: "Retrieve messages from conversation memory. Use this to access full tool " +
-                "outputs when a result was truncated, review previous assistant responses, " +
-                "or search through conversation history. Supports filtering by role, " +
-                "pagination for large content, and regex search within messages.",
+            description: "Retrieve messages from conversation memory, or fetch the full payload of " +
+                "an externalized MCP tool output by artifact ID. Use this to:\n" +
+                "• Access full tool outputs when a result was truncated or externalized\n" +
+                "• Review previous assistant responses\n" +
+                "• Search through conversation history\n" +
+                "Supports filtering by role, pagination for large content, and regex search.\n" +
+                "To fetch an externalized artifact, provide `artifactId` (omit sessionId).",
             inputSchema: z.object({
-                sessionId: z.string().describe("Session ID for the conversation"),
+                sessionId: z
+                    .string()
+                    .optional()
+                    .describe("Session ID for conversation history retrieval. " +
+                    "Required unless artifactId is provided."),
+                artifactId: z
+                    .string()
+                    .optional()
+                    .describe("Artifact ID from an externalized MCP tool output " +
+                    "(visible in the tool output as neurolinkArtifactId=<id>). " +
+                    "When provided, returns the full stored payload directly."),
                 messageId: z
                     .string()
                     .optional()
@@ -64,19 +83,68 @@ export function createMemoryRetrievalTools(memoryManager) {
                     "Returns matching lines with line numbers."),
             }),
             execute: async (args) => {
+                // ── Artifact resolution path ────────────────────────────────────────
+                // When the caller supplies an artifactId we short-circuit to the
+                // artifact store (bypassing Redis) and return the full payload with
+                // optional offset/limit pagination.
+                if (args.artifactId) {
+                    if (!artifactStore) {
+                        logger.warn("[MemoryRetrievalTools] retrieve_context called with artifactId " +
+                            "but no ArtifactStore is configured");
+                        return {
+                            error: "Artifact store not configured — " +
+                                "mcp.outputLimits.strategy must be set to 'externalize' to use artifactId retrieval",
+                            artifactId: args.artifactId,
+                        };
+                    }
+                    const content = await withTimeout(artifactStore.retrieve(args.artifactId), 10_000, new Error(`ArtifactStore.retrieve() timed out for artifact "${args.artifactId}"`));
+                    if (content === null) {
+                        return {
+                            error: "Artifact not found or has expired",
+                            artifactId: args.artifactId,
+                        };
+                    }
+                    const charLimit = Math.min(args.limit ?? DEFAULT_RETRIEVAL_LIMIT, MAX_RETRIEVAL_LIMIT);
+                    const start = args.offset ?? 0;
+                    const slice = content.slice(start, start + charLimit);
+                    return {
+                        artifactId: args.artifactId,
+                        content: slice,
+                        totalSize: content.length,
+                        hasMore: start + charLimit < content.length,
+                        offset: start,
+                        limit: charLimit,
+                    };
+                }
+                // ── End artifact resolution ─────────────────────────────────────────
+                if (!args.sessionId) {
+                    return {
+                        error: "sessionId is required when artifactId is not provided",
+                    };
+                }
+                if (!memoryManager) {
+                    return {
+                        error: "Session history retrieval requires Redis conversation memory — " +
+                            "enable mcp.conversationMemory with a Redis backend, or use " +
+                            "artifactId to retrieve an externalized MCP tool output.",
+                    };
+                }
                 const span = SpanSerializer.createSpan(SpanType.MEMORY, "memory.retrieve", {
                     "memory.operation": "retrieve",
                     "memory.store": "redis",
                     "memory.query": args.search || args.messageId || `lastN:${args.lastN ?? "all"}`,
                 });
                 const startTime = Date.now();
+                // args.sessionId is guaranteed non-null here — we returned early above
+                // when it was missing. Cast via string coercion to satisfy eslint.
+                const sessionId = String(args.sessionId);
                 try {
-                    const conversation = await memoryManager.getSessionRaw(args.sessionId);
+                    const conversation = await withTimeout(memoryManager.getSessionRaw(sessionId), 10_000, new Error(`getSessionRaw() timed out for session "${sessionId}"`));
                     if (!conversation) {
                         span.durationMs = Date.now() - startTime;
                         const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
                         getMetricsAggregator().recordSpan(endedSpan);
-                        return { error: "Session not found", sessionId: args.sessionId };
+                        return { error: "Session not found", sessionId };
                     }
                     let messages = conversation.messages;
                     // Filter by specific messageId

package/dist/neurolink.d.ts

@@ -47,6 +47,8 @@ export declare class NeuroLink {
     private mcpToolBatcher?;
     private mcpEnhancedDiscovery?;
     private mcpToolMiddlewares;
+    /** Artifact store for externalized MCP tool outputs (set when strategy=externalize). */
+    private mcpArtifactStore?;
     private _disableToolCacheForCurrentRequest;
     private mcpEnhancementsConfig?;
     private toolCircuitBreakers;
@@ -71,6 +73,27 @@ export declare class NeuroLink {
     private authProvider?;
     private pendingAuthConfig?;
     private authInitPromise?;
+    private credentials?;
+    /**
+     * Merge instance-level credentials with per-call credentials.
+     *
+     * Semantics: **deep merge at the provider level.** For each provider key
+     * present in both `this.credentials` and `callCredentials`, the per-call
+     * fields are merged ON TOP of the instance-level fields, so fields not
+     * mentioned in the per-call slice are preserved.
+     *
+     * Example:
+     * ```
+     * instance:  { openai: { apiKey: "key1", baseURL: "url1" } }
+     * per-call:  { openai: { apiKey: "key2" } }
+     * merged:    { openai: { apiKey: "key2", baseURL: "url1" } }   // baseURL preserved
+     * ```
+     *
+     * Providers present only in one source are carried through unchanged.
+     * Unrelated providers (not overridden in callCredentials) are carried through
+     * from instance credentials unchanged.
+     */
+    private resolveCredentials;
     private hitlManager?;
     private _sessionCostUsd;
     private fileRegistry;

package/dist/neurolink.js

@@ -40,6 +40,8 @@ import { ToolCallBatcher } from "./mcp/batching/index.js";
 import { ToolResultCache } from "./mcp/caching/index.js";
 import { EnhancedToolDiscovery } from "./mcp/enhancedToolDiscovery.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
+import { McpOutputNormalizer, DEFAULT_MAX_MCP_OUTPUT_BYTES, DEFAULT_WARN_MCP_OUTPUT_BYTES, } from "./mcp/mcpOutputNormalizer.js";
+import { LocalTempArtifactStore } from "./artifacts/artifactStore.js";
 import { ToolRouter } from "./mcp/routing/index.js";
 // Import direct tools server for automatic registration
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
@@ -216,6 +218,8 @@ export class NeuroLink {
     mcpToolBatcher;
     mcpEnhancedDiscovery;
     mcpToolMiddlewares = [];
+    /** Artifact store for externalized MCP tool outputs (set when strategy=externalize). */
+    mcpArtifactStore;
     _disableToolCacheForCurrentRequest = false;
     mcpEnhancementsConfig;
     // Enhanced error handling support
@@ -255,6 +259,60 @@ export class NeuroLink {
     authProvider;
     pendingAuthConfig;
     authInitPromise;
+    // Per-provider credential overrides (instance-level default)
+    credentials;
+    /**
+     * Merge instance-level credentials with per-call credentials.
+     *
+     * Semantics: **deep merge at the provider level.** For each provider key
+     * present in both `this.credentials` and `callCredentials`, the per-call
+     * fields are merged ON TOP of the instance-level fields, so fields not
+     * mentioned in the per-call slice are preserved.
+     *
+     * Example:
+     * ```
+     * instance:  { openai: { apiKey: "key1", baseURL: "url1" } }
+     * per-call:  { openai: { apiKey: "key2" } }
+     * merged:    { openai: { apiKey: "key2", baseURL: "url1" } }   // baseURL preserved
+     * ```
+     *
+     * Providers present only in one source are carried through unchanged.
+     * Unrelated providers (not overridden in callCredentials) are carried through
+     * from instance credentials unchanged.
+     */
+    resolveCredentials(callCredentials) {
+        if (!this.credentials && !callCredentials) {
+            return undefined;
+        }
+        if (!this.credentials) {
+            return callCredentials;
+        }
+        if (!callCredentials) {
+            return this.credentials;
+        }
+        // Per-provider deep merge: for each provider key in the per-call
+        // override, merge its fields on top of the instance-level slice so
+        // individual fields (e.g. baseURL) are preserved when only apiKey
+        // is overridden per-call.
+        const merged = { ...this.credentials };
+        for (const key of Object.keys(callCredentials)) {
+            const instanceSlice = this.credentials[key];
+            const callSlice = callCredentials[key];
+            if (instanceSlice &&
+                callSlice &&
+                typeof instanceSlice === "object" &&
+                typeof callSlice === "object") {
+                merged[key] = {
+                    ...instanceSlice,
+                    ...callSlice,
+                };
+            }
+            else {
+                merged[key] = callSlice ?? instanceSlice;
+            }
+        }
+        return merged;
+    }
     // HITL (Human-in-the-Loop) support
     hitlManager;
     // Accumulated cost in USD across all generate() calls on this instance
@@ -595,6 +653,10 @@ export class NeuroLink {
         if (config?.auth) {
             this.pendingAuthConfig = config.auth;
         }
+        // Store per-provider credential overrides
+        if (config?.credentials) {
+            this.credentials = config.credentials;
+        }
         // Store task config for lazy initialization
         this._taskManagerConfig = config?.tasks;
         // Eagerly create TaskManager and register tools if config is provided
@@ -818,6 +880,25 @@ export class NeuroLink {
             });
         }
         // ToolRouter — lazy-initialized when 2+ external servers exist (see addExternalMCPServer)
+        // McpOutputNormalizer — active when mcp.outputLimits is configured
+        if (mcpConfig?.outputLimits) {
+            const strategy = mcpConfig.outputLimits.strategy ?? "externalize";
+            const maxBytes = mcpConfig.outputLimits.maxBytes ?? DEFAULT_MAX_MCP_OUTPUT_BYTES;
+            const warnBytes = mcpConfig.outputLimits.warnBytes ?? DEFAULT_WARN_MCP_OUTPUT_BYTES;
+            let artifactStore;
+            if (strategy === "externalize") {
+                artifactStore = new LocalTempArtifactStore();
+                this.mcpArtifactStore = artifactStore;
+                logger.debug("[NeuroLink] MCP artifact store initialized (local-temp)");
+            }
+            const normalizer = new McpOutputNormalizer({ strategy, maxBytes, warnBytes }, artifactStore);
+            this.externalServerManager.setOutputNormalizer(normalizer);
+            logger.debug("[NeuroLink] MCP output normalizer initialized", {
+                strategy,
+                maxBytes,
+                warnBytes,
+            });
+        }
     }
     /**
      * Register file reference tools with the MCP tool registry.
@@ -937,90 +1018,46 @@ export class NeuroLink {
                 "redis" in memConfig &&
                 !!memConfig.redis) ||
             process.env.STORAGE_TYPE === "redis";
-        if (!memConfig?.enabled || !hasRedisConfig) {
-            logger.debug("[NeuroLink] Skipping memory retrieval tools — requires Redis conversation memory");
+        const hasArtifactStore = !!this.mcpArtifactStore;
+        // Register when Redis is configured OR when an artifact store exists.
+        // Artifact store alone is sufficient for the artifactId retrieval path —
+        // session history retrieval just returns a clear error when Redis is absent.
+        if ((!memConfig?.enabled || !hasRedisConfig) && !hasArtifactStore) {
+            logger.debug("[NeuroLink] Skipping memory retrieval tools — requires Redis conversation memory or an artifact store");
             return;
         }
-        const tools = {
-            retrieve_context: {
-                description: "Retrieve messages from conversation memory. Use this to access full tool " +
-                    "outputs when a result was truncated, review previous assistant responses, " +
-                    "or search through conversation history.",
-                execute: async (params) => {
-                    // Lazy access: conversationMemory is initialized on first generate() call
-                    const memoryManager = this.conversationMemory;
-                    if (!memoryManager || !("getSessionRaw" in memoryManager)) {
-                        return {
-                            success: false,
-                            error: "Memory retrieval not available — Redis memory manager not initialized",
-                            metadata: {
-                                toolName: "retrieve_context",
-                                serverId: "direct",
-                                executionTime: 0,
-                            },
-                        };
-                    }
-                    const actualTools = createMemoryRetrievalTools(memoryManager);
-                    const result = await actualTools.retrieve_context.execute(params, {
-                        toolCallId: "memory-retrieval",
-                        messages: [],
-                    });
-                    // Check if the tool itself reported an error
-                    const hasError = result &&
-                        typeof result === "object" &&
-                        "error" in result &&
-                        !("messages" in result);
-                    const errorMsg = hasError
-                        ? result.error
-                        : undefined;
-                    return {
-                        success: !hasError,
-                        data: result,
-                        ...(errorMsg ? { error: errorMsg } : {}),
-                        metadata: {
-                            toolName: "retrieve_context",
-                            serverId: "direct",
-                            executionTime: 0,
-                        },
-                    };
-                },
+        // Extract the canonical tool definition (schema + description) from the
+        // memoryRetrievalTools factory. We pass undefined as the memoryManager here
+        // because we only need the Zod inputSchema and description at registration
+        // time — the actual manager is resolved lazily at execution time.
+        const canonicalTools = createMemoryRetrievalTools(undefined, this.mcpArtifactStore);
+        const retrieveContextDef = canonicalTools.retrieve_context;
+        // Register via this.registerTool() so the tool ends up in the "user-defined"
+        // category inside toolRegistry. getCustomTools() returns that category, which
+        // is what ToolsManager reads to build the tool schema sent to the LLM.
+        // (Tools registered via toolRegistry.registerTool() directly land in the
+        // "built-in" category and are never included in the LLM's tool schema.)
+        this.registerTool("retrieve_context", {
+            name: "retrieve_context",
+            description: retrieveContextDef.description ?? "Retrieve context or artifacts",
+            // Pass the Zod schema so ToolsManager gives the LLM full parameter types.
+            // registerTool() detects isZodSchema on inputSchema and preserves it.
+            inputSchema: retrieveContextDef
+                .inputSchema,
+            execute: async (params) => {
+                // Lazy: conversationMemory is initialized on the first generate() call.
+                // When only an artifact store is present (no Redis), memoryManager is
+                // undefined — createMemoryRetrievalTools handles that via an explicit guard.
+                const memoryManager = this.conversationMemory;
+                const tools = createMemoryRetrievalTools(memoryManager, this.mcpArtifactStore);
+                // Return the result directly so the LLM receives clean output instead
+                // of a nested { success, data, metadata } wrapper.
+                // Bounded by TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS so a stalled Redis or
+                // filesystem backend never hangs the tool call indefinitely.
+                return await withTimeout(tools.retrieve_context.execute(params, { toolCallId: "memory-retrieval", messages: [] }), TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS, ErrorFactory.toolTimeout("retrieve_context", TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS));
             },
-        };
-        const registrations = Object.entries(tools).map(async ([toolName, toolDef]) => {
-            const toolId = `direct.${toolName}`;
-            const toolInfo = {
-                name: toolName,
-                description: toolDef.description,
-                inputSchema: {},
-                serverId: "direct",
-                category: "built-in",
-            };
-            await this.toolRegistry.registerTool(toolId, toolInfo, {
-                execute: async (params) => {
-                    try {
-                        return await toolDef.execute(params);
-                    }
-                    catch (error) {
-                        // Known limitation: this non-throwing error path returns
-                        // { success: false } without recording errorCategories in
-                        // toolExecutionMetrics. These are internal memory-tool failures
-                        // (low frequency), so the risk of metric gaps is minimal.
-                        // A full fix would require access to the metrics map here,
-                        // which is not available in the registration closure.
-                        return {
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                            metadata: { toolName, serverId: "direct", executionTime: 0 },
-                        };
-                    }
-                },
-                description: toolDef.description,
-                inputSchema: {},
-            });
-        });
-        void Promise.all(registrations).then(() => {
-            logger.info("[NeuroLink] Memory retrieval tools registered");
         });
+        logger.info("[NeuroLink] Memory retrieval tools registered");
     }
     /** Format memory context for prompt inclusion */
     formatMemoryContext(memoryContext, currentInput) {
@@ -2143,6 +2180,7 @@ Current user's request: ${currentInput}`;
                 }
             }
             logger.debug("[NeuroLink] Graceful shutdown completed");
+            this.credentials = undefined;
         }
         catch (error) {
             logger.error("[NeuroLink] Shutdown failed:", error);
@@ -2671,6 +2709,7 @@ Current user's request: ${currentInput}`;
             skipToolPromptInjection: options.skipToolPromptInjection,
             middleware: options.middleware,
             conversationMessages: options.conversationMessages,
+            credentials: options.credentials,
         };
         const extraContext = options;
         if (extraContext.sessionId || extraContext.userId) {
@@ -2805,7 +2844,7 @@ Current user's request: ${currentInput}`;
         const { extractPPTContext, getEffectivePPTProvider } = await import("./features/ppt/utils.js");
         // Get provider instance for content planning
         const requestedProvider = (options.provider || "vertex");
-        const provider = await AIProviderFactory.createProvider(requestedProvider, options.model, true, this);
+        const provider = await AIProviderFactory.createProvider(requestedProvider, options.model, true, this, undefined, this.resolveCredentials(options.credentials));
         // Resolve effective PPT provider (may auto-select if current is not PPT-compatible)
         const effectiveProvider = await getEffectivePPTProvider(provider, requestedProvider, options.model || "default", this);
         // Extract PPT context from options
@@ -3839,7 +3878,7 @@ Current user's request: ${currentInput}`;
     }
     async generateWithMCPProvider(context) {
         const { options, requestId, functionTag, tryMCPStartTime, providerName, availableTools, enhancedSystemPrompt, conversationMessages, } = context;
-        const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, this, options.region);
+        const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, this, options.region, this.resolveCredentials(options.credentials));
         provider.setTraceContext(this._metricsTraceContext);
         this.emitter.emit("connected");
         this.emitter.emit("message", `${providerName} provider initialized successfully`);
@@ -4035,7 +4074,8 @@ Current user's request: ${currentInput}`;
                 }
                 const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
                 this, // Pass SDK instance
-                options.region);
+                options.region, // Pass region parameter
+                this.resolveCredentials(options.credentials));
                 // Propagate trace context for parent-child span hierarchy
                 provider.setTraceContext(this._metricsTraceContext);
                 // ADD: Emit connection events for successful provider creation (Bedrock-compatible)
@@ -4783,7 +4823,7 @@ Current user's request: ${currentInput}`;
             reason: errorMsg,
         });
         try {
-            const fallbackProvider = await AIProviderFactory.createProvider(fallbackRoute.provider, fallbackRoute.model);
+            const fallbackProvider = await AIProviderFactory.createProvider(fallbackRoute.provider, fallbackRoute.model, true, undefined, undefined, this.resolveCredentials(enhancedOptions.credentials));
             // Ensure fallback provider can execute tools
             fallbackProvider.setupToolExecutor({
                 customTools: this.getCustomTools(),
@@ -4946,7 +4986,8 @@ Current user's request: ${currentInput}`;
         const providerName = await getBestProvider(options.provider);
         const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
         this, // Pass SDK instance
-        options.region);
+        options.region, // Pass region parameter
+        this.resolveCredentials(options.credentials));
         // Propagate trace context for parent-child span hierarchy
         provider.setTraceContext(this._metricsTraceContext);
         // Enable tool execution for the provider using BaseProvider method
@@ -5161,7 +5202,7 @@ Current user's request: ${currentInput}`;
         const originalPrompt = options.input.text;
         const responseTime = Date.now() - startTime;
         const providerName = await getBestProvider(options.provider);
-        const provider = await AIProviderFactory.createProvider(providerName, options.model);
+        const provider = await AIProviderFactory.createProvider(providerName, options.model, true, undefined, undefined, this.resolveCredentials(options.credentials));
         const fallbackStreamResult = await provider.stream({
             input: { text: options.input.text },
             model: options.model,
@@ -8523,6 +8564,7 @@ Current user's request: ${currentInput}`;
                 this.mcpInitialized = false;
                 this.mcpInitPromise = null;
                 this.conversationMemoryNeedsInit = false;
+                this.credentials = undefined;
                 logger.debug("[NeuroLink] Initialization state reset successfully");
             }
             catch (error) {