@juspay/neurolink 9.51.4 → 9.53.0

package/dist/lib/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/files/fileTools.d.ts

@@ -173,7 +173,7 @@ export declare function createFileTools(registry: FileReferenceRegistry): {
         } | undefined;
         columns?: string[] | undefined;
         entry_path?: string | undefined;
-        format?: "detailed" | "text" | "summary" | undefined;
+        format?: "text" | "detailed" | "summary" | undefined;
     }, {
         success: false;
         error: string | undefined;

package/dist/lib/neurolink.d.ts

@@ -73,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/lib/neurolink.js

@@ -28,9 +28,9 @@ import { getContextOverflowProvider, isContextOverflowError, parseProviderOverfl
 import { ContextBudgetExceededError } from "./context/errors.js";
 import { repairToolPairs } from "./context/toolPairRepair.js";
 import { SYSTEM_LIMITS } from "./core/constants.js";
-import { createToolEventPayload } from "./core/toolEvents.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import { AIProviderFactory } from "./core/factory.js";
+import { createToolEventPayload } from "./core/toolEvents.js";
 import { ProviderRegistry } from "./factories/providerRegistry.js";
 import { FileReferenceRegistry } from "./files/fileReferenceRegistry.js";
 import { createFileTools } from "./files/fileTools.js";
@@ -259,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
@@ -599,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
@@ -2122,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);
@@ -2646,10 +2705,12 @@ Current user's request: ${currentInput}`;
             region: options.region,
             tts: options.tts,
             fileRegistry: this.fileRegistry,
+            timeout: options.timeout,
             abortSignal: options.abortSignal,
             skipToolPromptInjection: options.skipToolPromptInjection,
             middleware: options.middleware,
             conversationMessages: options.conversationMessages,
+            credentials: options.credentials,
         };
         const extraContext = options;
         if (extraContext.sessionId || extraContext.userId) {
@@ -2784,7 +2845,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
@@ -3818,7 +3879,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`);
@@ -4014,7 +4075,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)
@@ -4047,7 +4109,26 @@ Current user's request: ${currentInput}`;
                     responseTime,
                     finishReason: result.finishReason,
                     toolsUsed: result.toolsUsed || [],
-                    enhancedWithTools: false,
+                    // Map toolExecutions from EnhancedGenerateResult shape ({name,input,output})
+                    // to TextGenerationResult shape ({toolName,executionTime,success}).
+                    // Preserve original timing/status when present, fall back to safe defaults.
+                    toolExecutions: result.toolExecutions?.map((te) => {
+                        const t = te;
+                        return {
+                            // Spread original fields first so normalized fields take precedence
+                            ...te,
+                            toolName: te.name,
+                            executionTime: typeof t.executionTime === "number"
+                                ? t.executionTime
+                                : typeof t.duration === "number"
+                                    ? t.duration
+                                    : 0,
+                            success: typeof t.success === "boolean"
+                                ? t.success
+                                : t.status === "success",
+                        };
+                    }),
+                    enhancedWithTools: !!result.toolExecutions?.length,
                     analytics: result.analytics,
                     evaluation: result.evaluation,
                     audio: result.audio,
@@ -4762,7 +4843,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(),
@@ -4925,7 +5006,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
@@ -5140,7 +5222,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,
@@ -8502,6 +8584,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;
     /**