@juspay/neurolink 9.51.3 → 9.52.0

package/dist/cli/commands/mcp.d.ts

@@ -67,6 +67,12 @@ export declare class MCPCommandFactory {
      * Execute exec command
      */
     private static executeExec;
+    /**
+     * Run the actual MCP tool execution and format/write the output.
+     * Extracted to keep executeExec nesting within ESLint max-depth limit.
+     * Returns 0 on success, 1 on failure.
+     */
+    private static runExecTool;
     /**
      * Execute remove command
      */

package/dist/cli/commands/mcp.js

@@ -656,104 +656,146 @@ export class MCPCommandFactory {
                 }
             }
             const sdk = new NeuroLink();
-            await this.getMCPStatusWithTimeout(sdk);
-            // Check if server exists and is connected
-            const allServers = await sdk.listMCPServers();
-            const server = allServers.find((s) => s.name === serverName);
-            if (!server) {
-                if (spinner) {
-                    spinner.fail();
-                }
-                logger.error(chalk.red(`❌ Server not found: ${serverName}`));
-                process.exit(1);
-            }
-            if (server.status !== "connected") {
-                if (spinner) {
-                    spinner.fail();
-                }
-                logger.error(chalk.red(`❌ Server not connected: ${serverName}`));
-                logger.always(chalk.yellow("💡 Try: neurolink mcp test " + serverName));
-                process.exit(1);
-            }
-            // Check if tool exists
-            const tool = server.tools?.find((t) => t.name === toolName);
-            if (!tool) {
-                if (spinner) {
-                    spinner.fail();
-                }
-                logger.error(chalk.red(`❌ Tool not found: ${toolName}`));
-                if (server.tools?.length) {
-                    logger.always(chalk.blue("Available tools:"));
-                    server.tools.forEach((t) => {
-                        logger.always(`  • ${t.name}: ${t.description}`);
-                    });
-                }
-                process.exit(1);
-            }
-            // Execute the tool using the NeuroLink MCP tool registry
+            let exitCode = 0;
             try {
-                const { toolRegistry } = await import("../../lib/mcp/toolRegistry.js");
-                const executionResult = await toolRegistry.executeTool(toolName, params, {
-                    sessionId: `cli-${Date.now()}`,
-                    userId: process.env.USER || "cli-user",
-                    config: {
-                        domainType: "cli-execution",
-                        customData: { serverName },
-                    },
-                });
-                const result = {
-                    tool: toolName,
-                    server: serverName,
-                    params,
-                    result: executionResult,
-                    success: true,
-                    timestamp: new Date().toISOString(),
-                };
-                if (spinner) {
-                    spinner.succeed(chalk.green("✅ Tool executed successfully"));
-                }
-                // Display results
-                if (argv.format === "json") {
-                    logger.always(JSON.stringify(result, null, 2));
-                }
-                else {
-                    logger.always(chalk.green("🔧 Tool Execution Results:"));
-                    logger.always(`   Tool: ${chalk.cyan(toolName)}`);
-                    logger.always(`   Server: ${chalk.cyan(serverName)}`);
-                    logger.always(`   Result: ${JSON.stringify(executionResult, null, 2)}`);
-                    logger.always(`   Timestamp: ${result.timestamp}`);
-                }
-            }
-            catch (toolError) {
-                const errorMessage = toolError instanceof Error ? toolError.message : String(toolError);
-                if (spinner) {
-                    spinner.fail(chalk.red("❌ Tool execution failed"));
+                await this.getMCPStatusWithTimeout(sdk);
+                // Check if server exists and is connected
+                const allServers = await sdk.listMCPServers();
+                const server = allServers.find((s) => s.name === serverName);
+                if (!server) {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red(`❌ Server not found: ${serverName}`));
+                    exitCode = 1;
                 }
-                const result = {
-                    tool: toolName,
-                    server: serverName,
-                    params,
-                    _error: errorMessage,
-                    success: false,
-                    timestamp: new Date().toISOString(),
-                };
-                if (argv.format === "json") {
-                    logger.always(JSON.stringify(result, null, 2));
+                else if (server.status !== "connected") {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red(`❌ Server not connected: ${serverName}`));
+                    logger.always(chalk.yellow("💡 Try: neurolink mcp test " + serverName));
+                    exitCode = 1;
                 }
                 else {
-                    logger.error(chalk.red("🔧 Tool Execution Failed:"));
-                    logger.error(`   Tool: ${chalk.cyan(toolName)}`);
-                    logger.error(`   Server: ${chalk.cyan(serverName)}`);
-                    logger.error(`   Error: ${chalk.red(errorMessage)}`);
+                    // Check if tool exists
+                    const tool = server.tools?.find((t) => t.name === toolName);
+                    if (!tool) {
+                        if (spinner) {
+                            spinner.fail();
+                        }
+                        logger.error(chalk.red(`❌ Tool not found: ${toolName}`));
+                        if (server.tools?.length) {
+                            logger.always(chalk.blue("Available tools:"));
+                            server.tools.forEach((t) => {
+                                logger.always(`  • ${t.name}: ${t.description}`);
+                            });
+                        }
+                        exitCode = 1;
+                    }
+                    else {
+                        exitCode = await this.runExecTool(toolName, serverName, params, argv, spinner);
+                    }
                 }
-                process.exit(1);
             }
+            finally {
+                // Always shut down MCP connections to prevent lingering child processes
+                await sdk.shutdown().catch(() => undefined);
+            }
+            // Flush stdout/stderr before exit so buffered output (spinner lines,
+            // result text) is not truncated by process.exit(). process.exit() is
+            // still required because MCP stdio connections and health-check timers
+            // keep the Node.js event loop alive even after sdk.shutdown().
+            await new Promise((resolve) => {
+                process.stdout.write("", () => {
+                    process.stderr.write("", () => resolve());
+                });
+            });
+            process.exit(exitCode);
         }
         catch (_error) {
             logger.error(chalk.red(`❌ Exec command failed: ${_error.message}`));
             process.exit(1);
         }
     }
+    /**
+     * Run the actual MCP tool execution and format/write the output.
+     * Extracted to keep executeExec nesting within ESLint max-depth limit.
+     * Returns 0 on success, 1 on failure.
+     */
+    static async runExecTool(toolName, serverName, params, argv, spinner) {
+        const WARN_BYTES = 50 * 1024; // 50 KB
+        try {
+            const { toolRegistry } = await import("../../lib/mcp/toolRegistry.js");
+            const executionResult = await withTimeout(toolRegistry.executeTool(toolName, params, {
+                sessionId: `cli-${Date.now()}`,
+                userId: process.env.USER || "cli-user",
+                config: { domainType: "cli-execution", customData: { serverName } },
+            }), MCP_STATUS_TIMEOUT_MS, ErrorFactory.toolTimeout(toolName, MCP_STATUS_TIMEOUT_MS));
+            const result = {
+                tool: toolName,
+                server: serverName,
+                params,
+                result: executionResult,
+                success: true,
+                timestamp: new Date().toISOString(),
+            };
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Tool executed successfully"));
+            }
+            const resultJson = JSON.stringify(result, null, 2);
+            const resultBytes = Buffer.byteLength(resultJson, "utf-8");
+            const outputFile = argv.output;
+            if (outputFile) {
+                await fs.promises.writeFile(outputFile, resultJson, "utf-8");
+                logger.always(chalk.green(`✅ Result saved to: ${chalk.cyan(outputFile)}`));
+                logger.always(`   Size: ${resultBytes >= 1024 ? `${(resultBytes / 1024).toFixed(1)} KB` : `${resultBytes} B`}`);
+            }
+            else if (argv.format === "json") {
+                if (resultBytes > WARN_BYTES) {
+                    logger.warn(chalk.yellow(`⚠  Large result (${(resultBytes / 1024).toFixed(1)} KB). ` +
+                        `Use --output <file> to save to disk instead.`));
+                }
+                logger.always(resultJson);
+            }
+            else {
+                if (resultBytes > WARN_BYTES) {
+                    logger.warn(chalk.yellow(`⚠  Large result (${(resultBytes / 1024).toFixed(1)} KB). ` +
+                        `Use --output <file> to save to disk instead.`));
+                }
+                logger.always(chalk.green("🔧 Tool Execution Results:"));
+                logger.always(`   Tool: ${chalk.cyan(toolName)}`);
+                logger.always(`   Server: ${chalk.cyan(serverName)}`);
+                logger.always(`   Result: ${JSON.stringify(executionResult, null, 2)}`);
+                logger.always(`   Timestamp: ${result.timestamp}`);
+            }
+            return 0;
+        }
+        catch (toolError) {
+            const errorMessage = toolError instanceof Error ? toolError.message : String(toolError);
+            if (spinner) {
+                spinner.fail(chalk.red("❌ Tool execution failed"));
+            }
+            const result = {
+                tool: toolName,
+                server: serverName,
+                params,
+                _error: errorMessage,
+                success: false,
+                timestamp: new Date().toISOString(),
+            };
+            if (argv.format === "json") {
+                logger.always(JSON.stringify(result, null, 2));
+            }
+            else {
+                logger.error(chalk.red("🔧 Tool Execution Failed:"));
+                logger.error(`   Tool: ${chalk.cyan(toolName)}`);
+                logger.error(`   Server: ${chalk.cyan(serverName)}`);
+                logger.error(`   Error: ${chalk.red(errorMessage)}`);
+            }
+            return 1;
+        }
+    }
     /**
      * Execute remove command
      */

package/dist/cli/loop/optionsSchema.d.ts

@@ -5,4 +5,4 @@ import type { TextGenerationOptions } from "../../lib/types/index.js";
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "tts" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions" | "tts" | "thinkingConfig" | "requestId" | "fileRegistry" | "abortSignal" | "toolFilter" | "excludeTools" | "toolChoice" | "prepareStep" | "credentials">, OptionSchema>;

package/dist/core/factory.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, SupportedModelName } from "../types/index.js";
+import type { AIProvider, SupportedModelName, NeurolinkCredentials } from "../types/index.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { UnknownRecord } from "../types/common.js";
 import type { ProviderPairResult } from "../types/typeAliases.js";
@@ -27,7 +27,7 @@ export declare class AIProviderFactory {
      * @param region - Optional region override for cloud providers
      * @returns AIProvider instance
      */
-    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
+    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord, region?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
     /**
      * Create a provider instance with specific provider enum and model
      * @param provider - Provider enum value

package/dist/core/factory.js

@@ -167,7 +167,7 @@ export class AIProviderFactory {
             return resolvedModelName;
         }
     }
-    static async createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag) {
+    static async createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag, credentials) {
         await withTimeout(ProviderRegistry.registerAllProviders(), 30_000, ErrorFactory.toolTimeout("provider-registration", 30_000));
         const normalizedName = this.normalizeProviderName(providerName);
         const finalModelName = resolvedModelName === "default" || resolvedModelName === null
@@ -179,7 +179,7 @@ export class AIProviderFactory {
             resolvedModelName: resolvedModelName || "not resolved",
             finalModelName: finalModelName || "using provider default",
         });
-        const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region), 30_000, ErrorFactory.toolTimeout(`provider-creation:${normalizedName}`, 30_000));
+        const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region, credentials), 30_000, ErrorFactory.toolTimeout(`provider-creation:${normalizedName}`, 30_000));
         return { normalizedName, finalModelName, provider };
     }
     /**
@@ -191,7 +191,7 @@ export class AIProviderFactory {
      * @param region - Optional region override for cloud providers
      * @returns AIProvider instance
      */
-    static async createProvider(providerName, modelName, enableMCP = true, sdk, region) {
+    static async createProvider(providerName, modelName, enableMCP = true, sdk, region, credentials) {
         const functionTag = "AIProviderFactory.createProvider";
         // Providers are registered via ProviderFactory.initialize() on first use
         return factoryTracer.startActiveSpan("neurolink.factory.createProvider", {
@@ -225,7 +225,7 @@ export class AIProviderFactory {
                 // The dynamic model provider now provides reliable functionality without hanging
                 let resolvedModelName = this.resolveModelFromEnvironment(providerName, modelName, functionTag);
                 resolvedModelName = await this.resolveDynamicModelName(providerName, modelName, resolvedModelName, functionTag);
-                const { normalizedName, finalModelName, provider } = await this.createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag);
+                const { normalizedName, finalModelName, provider } = await this.createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag, credentials);
                 // Summary logging in format expected by debugging tools
                 logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
                 logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);

package/dist/core/redisConversationMemoryManager.js

@@ -7,6 +7,7 @@ import { tracers } from "../telemetry/tracers.js";
 import { randomUUID } from "crypto";
 import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
 import { generateToolOutputPreview } from "../context/toolOutputLimits.js";
+import { NEUROLINK_ARTIFACT_ID_KEY } from "../mcp/mcpOutputNormalizer.js";
 import { SummarizationEngine } from "../context/summarizationEngine.js";
 import { NeuroLink } from "../neurolink.js";
 import { ConversationMemoryError } from "../types/conversation.js";
@@ -1320,11 +1321,30 @@ User message: "${userMessage}"`;
                     maxBytes: this.config?.contextCompaction?.maxToolOutputBytes,
                     maxLines: this.config?.contextCompaction?.maxToolOutputLines,
                 });
+                // Extract artifact ID if this result was externalized by McpOutputNormalizer.
+                // The surrogate carries `_meta.neurolinkArtifactId` on the raw result object.
+                let artifactId;
+                try {
+                    const rawResult = toolResult.result;
+                    if (rawResult && typeof rawResult === "object") {
+                        const meta = rawResult._meta;
+                        if (meta && typeof meta === "object") {
+                            const idValue = meta[NEUROLINK_ARTIFACT_ID_KEY];
+                            if (typeof idValue === "string") {
+                                artifactId = idValue;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore extraction errors — artifact ID is best-effort metadata
+                }
                 // Build metadata — only store preview when truncation occurred (no duplication)
                 const metadata = {
                     truncated,
                     ...(truncated && { toolOutputPreview: preview }),
                     ...(truncated && { originalSize }),
+                    ...(artifactId && { artifactId }),
                 };
                 // Build result — success/error metadata only, NOT the output data
                 const result = {

package/dist/factories/providerFactory.d.ts

@@ -1,6 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import type { UnknownRecord } from "../types/common.js";
-import type { AIProvider } from "../types/index.js";
+import type { AIProvider, NeurolinkCredentials } from "../types/index.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
@@ -33,7 +33,7 @@ export declare class ProviderFactory {
      * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
      * @param modelName - Model name (optional, uses provider-specific env var or registry default)
      */
-    static createProvider(providerName?: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
+    static createProvider(providerName?: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */
@@ -67,10 +67,10 @@ export declare class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord, credentials?: NeurolinkCredentials): Promise<AIProvider>;
 }
 /**
  * Helper function to create providers with backward compatibility
  */
-export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string): Promise<AIProvider>;
+export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string, credentials?: NeurolinkCredentials): Promise<AIProvider>;
 export {};

package/dist/factories/providerFactory.js

@@ -30,7 +30,7 @@ export class ProviderFactory {
      * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
      * @param modelName - Model name (optional, uses provider-specific env var or registry default)
      */
-    static async createProvider(providerName, modelName, sdk, region) {
+    static async createProvider(providerName, modelName, sdk, region, credentials) {
         // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
         // Use environment variable or default if not specified
         const resolvedProviderName = providerName ||
@@ -56,13 +56,26 @@ export class ProviderFactory {
             // Fallback to registry default if no env var
             model = model || registration.defaultModel;
         }
+        // Map registered provider names to NeurolinkCredentials keys.
+        // Most names match (openai, anthropic, vertex, bedrock, etc.)
+        // but some differ (google-ai → googleAiStudio, openai-compatible → openaiCompatible).
+        const credentialKeyMap = {
+            "google-ai": "googleAiStudio",
+            "openai-compatible": "openaiCompatible",
+            huggingface: "huggingFace",
+        };
+        const credKey = credentialKeyMap[normalizedName] ?? normalizedName;
+        // Extract provider-scoped credential slice (e.g. credentials.openai for OpenAI)
+        const scopedCredentials = credentials
+            ? credentials[credKey]
+            : undefined;
         try {
             if (typeof registration.constructor !== "function") {
                 throw new Error(`Invalid constructor for provider ${providerName}: not a function`);
             }
             let result;
             try {
-                const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region);
+                const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region, scopedCredentials);
                 // Handle both sync and async results
                 result =
                     factoryResult instanceof Promise
@@ -74,7 +87,7 @@ export class ProviderFactory {
                     registration.constructor.prototype.constructor ===
                         registration.constructor) {
                     try {
-                        result = new registration.constructor(model, resolvedProviderName, sdk, region);
+                        result = new registration.constructor(model, resolvedProviderName, sdk, region, scopedCredentials);
                     }
                     catch (constructorError) {
                         throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`, { cause: constructorError });
@@ -154,13 +167,13 @@ export class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static async createBestProvider(providerName, modelName, enableMCP, sdk) {
-        return await ProviderFactory.createProvider(providerName, modelName, sdk);
+    static async createBestProvider(providerName, modelName, enableMCP, sdk, credentials) {
+        return await ProviderFactory.createProvider(providerName, modelName, sdk, undefined, credentials);
     }
 }
 /**
  * Helper function to create providers with backward compatibility
  */
-export async function createAIProvider(providerName, modelName) {
-    return await ProviderFactory.createProvider(providerName, modelName);
+export async function createAIProvider(providerName, modelName, credentials) {
+    return await ProviderFactory.createProvider(providerName, modelName, undefined, undefined, credentials);
 }

package/dist/factories/providerRegistry.d.ts

@@ -13,6 +13,11 @@ export declare class ProviderRegistry {
     static registerAllProviders(): Promise<void>;
     /**
      * Internal registration implementation
+     *
+     * This method is a flat list of 13 provider registrations. Each registration
+     * is self-contained and extracting helpers would add indirection without
+     * reducing complexity — the function is long because there are many providers,
+     * not because any single registration is complex.
      */
     private static _doRegister;
     /**

package/dist/factories/providerRegistry.js

@@ -32,82 +32,101 @@ export class ProviderRegistry {
     }
     /**
      * Internal registration implementation
+     *
+     * This method is a flat list of 13 provider registrations. Each registration
+     * is self-contained and extracting helpers would add indirection without
+     * reducing complexity — the function is long because there are many providers,
+     * not because any single registration is complex.
      */
+    // eslint-disable-next-line max-lines-per-function
     static async _doRegister() {
         try {
             // Register providers with dynamic import factory functions
             const { ProviderFactory } = await import("./providerFactory.js");
             // Register Google AI Studio Provider (our validated baseline)
-            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk, _region, credentials) => {
+                const googleAiCreds = credentials;
                 const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio.js");
-                return new GoogleAIStudioProvider(modelName, sdk);
+                return new GoogleAIStudioProvider(modelName, sdk, googleAiCreds);
             }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai", "google-ai-studio"]);
             // Register OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk, _region, credentials) => {
+                const openaiCreds = credentials;
                 const { OpenAIProvider } = await import("../providers/openAI.js");
-                return new OpenAIProvider(modelName, sdk);
+                return new OpenAIProvider(modelName, sdk, undefined, openaiCreds);
             }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
             // Register Anthropic provider
-            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk, _region, credentials) => {
+                const anthropicCreds = credentials;
                 const { AnthropicProvider } = await import("../providers/anthropic.js");
-                return new AnthropicProvider(modelName, sdk);
+                return new AnthropicProvider(modelName, sdk, undefined, anthropicCreds);
             }, AnthropicModels.CLAUDE_SONNET_4_6, ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region) => {
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region, credentials) => {
+                const bedrockCreds = credentials;
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName, sdk, region);
+                return new AmazonBedrockProvider(modelName, sdk, region, bedrockCreds);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk, _region, credentials) => {
+                const azureCreds = credentials;
                 const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
-                return new AzureOpenAIProvider(modelName, sdk);
+                return new AzureOpenAIProvider(modelName, sdk, undefined, azureCreds);
             }, process.env.AZURE_MODEL ||
                 process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
                 "gpt-4o-mini", ["azure", "azureOpenai"]);
             // Register Google Vertex AI provider
-            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region) => {
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region, credentials) => {
+                const vertexCreds = credentials;
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
-                return new GoogleVertexProvider(modelName, providerName, sdk, region);
+                return new GoogleVertexProvider(modelName, providerName, sdk, region, vertexCreds);
             }, VertexModels.CLAUDE_4_6_SONNET, ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
-            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName, _providerName, _sdk, _region, credentials) => {
+                const hfCreds = credentials;
                 const { HuggingFaceProvider } = await import("../providers/huggingFace.js");
-                return new HuggingFaceProvider(modelName);
+                return new HuggingFaceProvider(modelName, undefined, hfCreds);
             }, process.env.HUGGINGFACE_MODEL ||
                 HuggingFaceModels.QWEN_2_5_72B_INSTRUCT, ["huggingface", "hf"]);
             // Register Mistral AI provider
-            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk, _region, credentials) => {
+                const mistralCreds = credentials;
                 const { MistralProvider } = await import("../providers/mistral.js");
-                return new MistralProvider(modelName, sdk);
+                return new MistralProvider(modelName, sdk, undefined, mistralCreds);
             }, MistralModels.MISTRAL_LARGE_LATEST, ["mistral"]);
             // Register Ollama provider
-            ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName, _providerName, _sdk, _region, credentials) => {
+                const ollamaCreds = credentials;
                 const { OllamaProvider } = await import("../providers/ollama.js");
-                return new OllamaProvider(modelName);
+                return new OllamaProvider(modelName, ollamaCreds);
             }, process.env.OLLAMA_MODEL || OllamaModels.LLAMA3_2_LATEST, ["ollama", "local"]);
             // Register LiteLLM provider
-            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk, _region, credentials) => {
+                const litellmCreds = credentials;
                 const { LiteLLMProvider } = await import("../providers/litellm.js");
-                return new LiteLLMProvider(modelName, sdk);
+                return new LiteLLMProvider(modelName, sdk, undefined, litellmCreds);
             }, process.env.LITELLM_MODEL || LiteLLMModels.OPENAI_GPT_4O_MINI, ["litellm"]);
             // Register OpenAI Compatible provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk, _region, credentials) => {
+                const openaiCompatCreds = credentials;
                 const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible.js");
-                return new OpenAICompatibleProvider(modelName, sdk);
+                return new OpenAICompatibleProvider(modelName, sdk, undefined, openaiCompatCreds);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "vllm", "compatible"]);
             // Register OpenRouter provider (300+ models from 60+ providers)
-            ProviderFactory.registerProvider(AIProviderName.OPENROUTER, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENROUTER, async (modelName, _providerName, sdk, _region, credentials) => {
+                const openrouterCreds = credentials;
                 const { OpenRouterProvider } = await import("../providers/openRouter.js");
-                return new OpenRouterProvider(modelName, sdk);
+                return new OpenRouterProvider(modelName, sdk, undefined, openrouterCreds);
             }, process.env.OPENROUTER_MODEL || "anthropic/claude-3-5-sonnet", ["openrouter", "or"]);
             // Register Amazon SageMaker provider
-            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region) => {
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region, credentials) => {
+                const sagemakerCreds = credentials;
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
-                return new AmazonSageMakerProvider(modelName, undefined, region);
+                return new AmazonSageMakerProvider(modelName, undefined, region, undefined, sagemakerCreds);
             }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
             logger.debug("All providers registered successfully");
             this.registered = true;

package/dist/lib/artifacts/artifactStore.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Artifact Store
+ *
+ * Pluggable storage for externalized MCP tool outputs.
+ *
+ * When `mcp.outputLimits.strategy = "externalize"` the full tool payload is
+ * written here instead of being sent inline to the LLM. The model receives a
+ * compact surrogate with a preview and an artifact ID. The full payload can be
+ * retrieved on demand via the `retrieve_context` tool.
+ *
+ * Architecture:
+ *   ArtifactStore (interface) — canonical types in src/lib/types/artifactTypes.ts
+ *   LocalTempArtifactStore   — single-process, filesystem-backed implementation
+ *
+ * Distributed backends (S3, Redis blobs) can be added later by implementing
+ * ArtifactStore from types/artifactTypes.ts.
+ *
+ * @module artifacts/artifactStore
+ */
+import type { ArtifactMeta, ArtifactRef, ArtifactStore } from "../types/artifactTypes.js";
+export type { ArtifactMeta, ArtifactRef, ArtifactStore, } from "../types/artifactTypes.js";
+/**
+ * Filesystem-backed artifact store using the OS temp directory.
+ *
+ * Files are written with mode 0o600 (owner read/write only).
+ * An in-memory index tracks metadata without a separate index file.
+ *
+ * Suitable for:
+ *  - CLI usage
+ *  - Single-process SDK deployments
+ *  - Multi-process deployments where each process manages its own artifacts
+ *    (artifacts created in one process are not visible to others)
+ *
+ * @example
+ * ```typescript
+ * const store = new LocalTempArtifactStore();
+ * const ref = await store.store(largeJson, {
+ *   toolName: "list_files",
+ *   serverId: "filesystem-server",
+ *   sizeBytes: Buffer.byteLength(largeJson),
+ *   contentType: "json",
+ * });
+ * // Later, via retrieve_context:
+ * const full = await store.retrieve(ref.id);
+ * ```
+ */
+export declare class LocalTempArtifactStore implements ArtifactStore {
+    private readonly dir;
+    private readonly index;
+    constructor(dir?: string);
+    generatePreview(payload: string): string;
+    store(payload: string, meta: Omit<ArtifactMeta, "createdAt">): Promise<ArtifactRef>;
+    retrieve(id: string): Promise<string | null>;
+    delete(id: string): Promise<void>;
+    cleanup(olderThanMs: number): Promise<number>;
+}