@juspay/neurolink 9.51.3 → 9.52.0

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

package/dist/lib/providers/amazonBedrock.d.ts

@@ -8,7 +8,12 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;
     private conversationHistory;
     private region;
-    constructor(modelName?: string, neurolink?: NeuroLink, region?: string);
+    constructor(modelName?: string, neurolink?: NeuroLink, region?: string, credentials?: {
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        sessionToken?: string;
+        region?: string;
+    });
     /**
      * Perform initial health check to catch credential/connectivity issues early
      * This prevents the health check failure we saw in production logs

package/dist/lib/providers/amazonBedrock.js

@@ -18,9 +18,10 @@ export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
     conversationHistory = [];
     region;
-    constructor(modelName, neurolink, region) {
+    constructor(modelName, neurolink, region, credentials) {
         super(modelName, "bedrock", neurolink);
-        this.region = region || process.env.AWS_REGION || "us-east-1";
+        this.region =
+            credentials?.region || region || process.env.AWS_REGION || "us-east-1";
         logger.debug("[AmazonBedrockProvider] Starting constructor with extensive logging for debugging");
         // Log environment variables for debugging
         logger.debug(`[AmazonBedrockProvider] Environment check: AWS_REGION=${process.env.AWS_REGION || "undefined"}, AWS_ACCESS_KEY_ID=${process.env.AWS_ACCESS_KEY_ID ? "SET" : "undefined"}, AWS_SECRET_ACCESS_KEY=${process.env.AWS_SECRET_ACCESS_KEY ? "SET" : "undefined"}`);
@@ -35,6 +36,17 @@ export class AmazonBedrockProvider extends BaseProvider {
                 // 2. Environment variables
                 // 3. AWS config files
                 // 4. Instance metadata
+                ...(credentials?.accessKeyId && credentials?.secretAccessKey
+                    ? {
+                        credentials: {
+                            accessKeyId: credentials.accessKeyId,
+                            secretAccessKey: credentials.secretAccessKey,
+                            ...(credentials.sessionToken
+                                ? { sessionToken: credentials.sessionToken }
+                                : {}),
+                        },
+                    }
+                    : {}),
             });
             logger.debug(`[AmazonBedrockProvider] Successfully created BedrockRuntimeClient with model: ${this.modelName}, region: ${this.region}`);
         }

package/dist/lib/providers/amazonSagemaker.d.ts

@@ -17,7 +17,13 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     private sagemakerModel;
     private sagemakerConfig;
     private modelConfig;
-    constructor(modelName?: string, endpointName?: string, region?: string, neurolink?: NeuroLink);
+    constructor(modelName?: string, endpointName?: string, region?: string, neurolink?: NeuroLink, credentials?: {
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        sessionToken?: string;
+        region?: string;
+        endpoint?: string;
+    });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     protected getAISDKModel(): LanguageModel;

package/dist/lib/providers/amazonSagemaker.js

@@ -17,11 +17,29 @@ export class AmazonSageMakerProvider extends BaseProvider {
     sagemakerModel;
     sagemakerConfig;
     modelConfig;
-    constructor(modelName, endpointName, region, neurolink) {
+    constructor(modelName, endpointName, region, neurolink, credentials) {
         super(modelName, "sagemaker", neurolink);
         try {
-            // Load and validate configuration
-            this.sagemakerConfig = getSageMakerConfig(region);
+            // Load and validate configuration, then overlay per-request credentials
+            const baseConfig = getSageMakerConfig(credentials?.region ?? region);
+            this.sagemakerConfig = {
+                ...baseConfig,
+                ...(credentials?.region !== undefined && {
+                    region: credentials.region,
+                }),
+                ...(credentials?.accessKeyId !== undefined && {
+                    accessKeyId: credentials.accessKeyId,
+                }),
+                ...(credentials?.secretAccessKey !== undefined && {
+                    secretAccessKey: credentials.secretAccessKey,
+                }),
+                ...(credentials?.sessionToken !== undefined && {
+                    sessionToken: credentials.sessionToken,
+                }),
+                ...(credentials?.endpoint !== undefined && {
+                    endpoint: credentials.endpoint,
+                }),
+            };
             this.modelConfig = getSageMakerModelConfig(endpointName || getDefaultSageMakerEndpoint());
             // Create the SageMaker LanguageModel implementation.
             // SageMakerLanguageModel implements SageMakerAsLanguageModel which is

package/dist/lib/providers/anthropic.d.ts

@@ -41,7 +41,10 @@ export declare class AnthropicProvider extends BaseProvider {
      * @param sdk - Optional NeuroLink SDK instance
      * @param config - Optional configuration options for auth, subscription tier, and beta features
      */
-    constructor(modelName?: string, sdk?: unknown, config?: AnthropicProviderConfig);
+    constructor(modelName?: string, sdk?: unknown, config?: AnthropicProviderConfig, credentials?: {
+        apiKey?: string;
+        oauthToken?: string;
+    });
     /**
      * Get authentication headers based on current auth method and configuration.
      *

package/dist/lib/providers/anthropic.js

@@ -219,14 +219,27 @@ export class AnthropicProvider extends BaseProvider {
      * @param sdk - Optional NeuroLink SDK instance
      * @param config - Optional configuration options for auth, subscription tier, and beta features
      */
-    constructor(modelName, sdk, config) {
-        // Pre-compute effective model with tier validation before calling super
-        const oauthToken = config?.oauthToken ?? getOAuthToken();
+    constructor(modelName, sdk, config, credentials) {
+        // Pre-compute effective model with tier validation before calling super.
+        //
+        // When per-request credentials supply an apiKey (without oauthToken),
+        // force api_key auth — skip OAuth detection entirely so the caller's
+        // key is used rather than a stale OAuth token from ~/.neurolink/.
+        const forceApiKey = !!(credentials?.apiKey && !credentials?.oauthToken);
+        const oauthToken = forceApiKey
+            ? null
+            : ((credentials?.oauthToken
+                ? { accessToken: credentials.oauthToken }
+                : null) ??
+                config?.oauthToken ??
+                getOAuthToken());
         // Resolve auth method FIRST so that tier detection uses the chosen method.
         // If ANTHROPIC_AUTH_METHOD=api_key wins over an existing OAuth token, the
         // tier must reflect api_key mode (full model access) rather than the OAuth
         // token's subscription level.
-        const authMethod = config?.authMethod ?? detectAuthMethod(oauthToken);
+        const authMethod = forceApiKey
+            ? "api_key"
+            : (config?.authMethod ?? detectAuthMethod(oauthToken));
         const subscriptionTier = config?.subscriptionTier ??
             (authMethod === "oauth" ? detectSubscriptionTier(oauthToken) : "api");
         const targetModel = modelName || getDefaultAnthropicModel();
@@ -306,7 +319,7 @@ export class AnthropicProvider extends BaseProvider {
         }
         else {
             // Traditional API key authentication
-            const apiKeyToUse = config?.apiKey ?? getAnthropicApiKey();
+            const apiKeyToUse = credentials?.apiKey ?? config?.apiKey ?? getAnthropicApiKey();
             anthropic = createAnthropic({
                 apiKey: apiKeyToUse,
                 headers,

package/dist/lib/providers/azureOpenai.d.ts

@@ -2,13 +2,14 @@ import { type LanguageModel } from "ai";
 import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { NeurolinkCredentials } from "../types/providers.js";
 export declare class AzureOpenAIProvider extends BaseProvider {
     private apiKey;
     private resourceName;
     private deployment;
     private apiVersion;
     private azureProvider;
-    constructor(modelName?: string, sdk?: unknown);
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["azure"]);
     getProviderName(): AIProviderName;
     getDefaultModel(): string;
     /**

package/dist/lib/providers/azureOpenai.js

@@ -14,22 +14,27 @@ export class AzureOpenAIProvider extends BaseProvider {
     deployment;
     apiVersion;
     azureProvider;
-    constructor(modelName, sdk) {
+    constructor(modelName, sdk, _region, credentials) {
         super(modelName, "azure", sdk);
-        this.apiKey = process.env.AZURE_OPENAI_API_KEY || "";
+        this.apiKey = credentials?.apiKey || process.env.AZURE_OPENAI_API_KEY || "";
         const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "";
-        this.resourceName = endpoint
+        const envResourceName = endpoint
             .replace("https://", "")
             .replace(/\/+$/, "") // Remove trailing slashes
             .replace(".openai.azure.com", "")
             .replace(".cognitiveservices.azure.com", "");
+        this.resourceName = credentials?.resourceName || envResourceName;
         this.deployment =
-            modelName ||
+            credentials?.deploymentName ||
+                modelName ||
                 process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
                 "gpt-4o";
-        this.apiVersion = process.env.AZURE_API_VERSION || APIVersions.AZURE_LATEST;
+        this.apiVersion =
+            credentials?.apiVersion ||
+                process.env.AZURE_API_VERSION ||
+                APIVersions.AZURE_LATEST;
         // Configuration validation - now using consolidated utility
         if (!this.apiKey) {
             validateApiKey(createAzureAPIKeyConfig());

package/dist/lib/providers/googleAiStudio.d.ts

@@ -36,7 +36,10 @@ import type { ZodUnknownSchema } from "../types/typeAliases.js";
  *       Solution: Simplify schema or use disableTools: true
  */
 export declare class GoogleAIStudioProvider extends BaseProvider {
-    constructor(modelName?: string, sdk?: unknown);
+    private credentials?;
+    constructor(modelName?: string, sdk?: unknown, credentials?: {
+        apiKey?: string;
+    });
     getProviderName(): AIProviderName;
     getDefaultModel(): string;
     /**

package/dist/lib/providers/googleAiStudio.js

@@ -65,8 +65,10 @@ async function createGoogleGenAIClient(apiKey) {
  *       Solution: Simplify schema or use disableTools: true
  */
 export class GoogleAIStudioProvider extends BaseProvider {
-    constructor(modelName, sdk) {
+    credentials;
+    constructor(modelName, sdk, credentials) {
         super(modelName, "google-ai", sdk);
+        this.credentials = credentials;
         logger.debug("GoogleAIStudioProvider initialized", {
             model: this.modelName,
             provider: this.providerName,
@@ -432,11 +434,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
         }
         this.validateStreamOptions(options);
         const startTime = Date.now();
-        const apiKey = this.getApiKey();
-        // Ensure environment variable is set for @ai-sdk/google
-        if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
-            process.env.GOOGLE_GENERATIVE_AI_API_KEY = apiKey;
-        }
         const model = await this.getAISDKModelWithMiddleware(options);
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
@@ -1214,7 +1211,9 @@ export class GoogleAIStudioProvider extends BaseProvider {
         }
     }
     getApiKey() {
-        const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+        const apiKey = this.credentials?.apiKey ||
+            process.env.GOOGLE_AI_API_KEY ||
+            process.env.GOOGLE_GENERATIVE_AI_API_KEY;
         if (!apiKey) {
             throw new AuthenticationError("GOOGLE_AI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY environment variable is not set", this.providerName);
         }

package/dist/lib/providers/googleVertex.d.ts

@@ -3,6 +3,7 @@ import type { ZodType } from "zod";
 import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
+import type { NeurolinkCredentials } from "../types/providers.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * Vertex Model Aliases
@@ -70,13 +71,14 @@ export declare class GoogleVertexProvider extends BaseProvider {
     private location;
     private registeredTools;
     private toolContext;
+    private credentials;
     private static modelConfigCache;
     private static modelConfigCacheTime;
     private static readonly CACHE_DURATION;
     private static readonly MAX_CACHE_SIZE;
     private static maxTokensCache;
     private static maxTokensCacheTime;
-    constructor(modelName?: string, _providerName?: string, sdk?: unknown, region?: string);
+    constructor(modelName?: string, _providerName?: string, sdk?: unknown, region?: string, credentials?: NeurolinkCredentials["vertex"]);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**