@juspay/neurolink 9.51.4 → 9.52.0

package/dist/lib/providers/huggingFace.js

@@ -14,21 +14,21 @@ const getHuggingFaceApiKey = () => {
 const getDefaultHuggingFaceModel = () => {
     return getProviderModel("HUGGINGFACE_MODEL", "microsoft/DialoGPT-medium");
 };
-// Note: hasHuggingFaceCredentials now directly imported from consolidated utility
+// Note: hasNeurolinkCredentials["huggingFace"] now directly imported from consolidated utility
 /**
  * HuggingFace Provider - BaseProvider Implementation
  * Using AI SDK with HuggingFace's OpenAI-compatible endpoint
  */
 export class HuggingFaceProvider extends BaseProvider {
     model;
-    constructor(modelName) {
+    constructor(modelName, _sdk, credentials) {
         super(modelName, "huggingface");
         // Get API key and validate
-        const apiKey = getHuggingFaceApiKey();
+        const apiKey = credentials?.apiKey ?? getHuggingFaceApiKey();
         // Create HuggingFace provider using unified router endpoint (2025) with proxy support
         const huggingface = createOpenAI({
             apiKey: apiKey,
-            baseURL: "https://router.huggingface.co/v1",
+            baseURL: credentials?.baseURL ?? "https://router.huggingface.co/v1",
             fetch: createProxyFetch(),
         });
         // Initialize model

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

@@ -9,10 +9,14 @@ import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
  */
 export declare class LiteLLMProvider extends BaseProvider {
     private model;
+    private credentials?;
     private static modelsCache;
     private static modelsCacheTime;
     private static readonly MODELS_CACHE_DURATION;
-    constructor(modelName?: string, sdk?: unknown);
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
+        apiKey?: string;
+        baseURL?: string;
+    });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/litellm.js

@@ -42,12 +42,15 @@ const getDefaultLiteLLMModel = () => {
  */
 export class LiteLLMProvider extends BaseProvider {
     model;
+    credentials;
     // Cache for available models to avoid repeated API calls
     static modelsCache = [];
     static modelsCacheTime = 0;
     static MODELS_CACHE_DURATION = 10 * 60 * 1000; // 10 minutes
-    constructor(modelName, sdk) {
+    constructor(modelName, sdk, _region, credentials) {
         super(modelName, "litellm", sdk);
+        // Store per-request credentials for use in embed/embedMany/fetchModelsFromAPI
+        this.credentials = credentials;
         // Initialize LiteLLM using OpenAI SDK with explicit configuration
         const config = getLiteLLMConfig();
         // Create OpenAI SDK instance configured for LiteLLM proxy
@@ -56,8 +59,8 @@ export class LiteLLMProvider extends BaseProvider {
         // with a custom baseURL and apiKey. This ensures all requests are routed through the LiteLLM
         // proxy, allowing access to multiple models and custom authentication.
         const customOpenAI = createOpenAI({
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
+            baseURL: credentials?.baseURL ?? config.baseURL,
+            apiKey: credentials?.apiKey ?? config.apiKey,
             fetch: createProxyFetch(),
         });
         this.model = customOpenAI.chat(this.modelName || getDefaultLiteLLMModel());
@@ -374,8 +377,8 @@ export class LiteLLMProvider extends BaseProvider {
             process.env.LITELLM_EMBEDDING_MODEL ||
             "gemini-embedding-001";
         const customOpenAI = createOpenAI({
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
+            baseURL: this.credentials?.baseURL ?? config.baseURL,
+            apiKey: this.credentials?.apiKey ?? config.apiKey,
             fetch: createProxyFetch(),
         });
         const embeddingModel = customOpenAI.textEmbeddingModel(embeddingModelName);
@@ -394,8 +397,8 @@ export class LiteLLMProvider extends BaseProvider {
             process.env.LITELLM_EMBEDDING_MODEL ||
             "gemini-embedding-001";
         const customOpenAI = createOpenAI({
-            baseURL: config.baseURL,
-            apiKey: config.apiKey,
+            baseURL: this.credentials?.baseURL ?? config.baseURL,
+            apiKey: this.credentials?.apiKey ?? config.apiKey,
             fetch: createProxyFetch(),
         });
         const embeddingModel = customOpenAI.textEmbeddingModel(embeddingModelName);
@@ -458,7 +461,9 @@ export class LiteLLMProvider extends BaseProvider {
     async fetchModelsFromAPI() {
         const functionTag = "LiteLLMProvider.fetchModelsFromAPI";
         const config = getLiteLLMConfig();
-        const modelsUrl = `${config.baseURL}/v1/models`;
+        const resolvedBaseURL = this.credentials?.baseURL ?? config.baseURL;
+        const resolvedApiKey = this.credentials?.apiKey ?? config.apiKey;
+        const modelsUrl = `${resolvedBaseURL}/v1/models`;
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
         try {
@@ -467,7 +472,7 @@ export class LiteLLMProvider extends BaseProvider {
             const response = await proxyFetch(modelsUrl, {
                 method: "GET",
                 headers: {
-                    Authorization: `Bearer ${config.apiKey}`,
+                    Authorization: `Bearer ${resolvedApiKey}`,
                     "Content-Type": "application/json",
                 },
                 signal: controller.signal,

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

@@ -1,6 +1,7 @@
 import { type LanguageModel } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { NeurolinkCredentials } from "../types/providers.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { ValidationSchema } from "../types/typeAliases.js";
 /**
@@ -9,7 +10,7 @@ import type { ValidationSchema } from "../types/typeAliases.js";
  */
 export declare class MistralProvider extends BaseProvider {
     private model;
-    constructor(modelName?: string, sdk?: unknown);
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["mistral"]);
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     getProviderName(): AIProviderName;
     getDefaultModel(): string;

package/dist/lib/providers/mistral.js

@@ -23,14 +23,14 @@ const getDefaultMistralModel = () => {
  */
 export class MistralProvider extends BaseProvider {
     model;
-    constructor(modelName, sdk) {
+    constructor(modelName, sdk, _region, credentials) {
         // Type guard for NeuroLink parameter validation
         const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
             ? sdk
             : undefined;
         super(modelName, "mistral", validatedNeurolink);
         // Initialize Mistral model with API key validation and proxy support
-        const apiKey = getMistralApiKey();
+        const apiKey = credentials?.apiKey ?? getMistralApiKey();
         const mistral = createMistral({
             apiKey: apiKey,
             fetch: createProxyFetch(),

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

@@ -18,7 +18,9 @@ export declare class OllamaProvider extends BaseProvider {
     private ollamaModel;
     private baseUrl;
     private timeout;
-    constructor(modelName?: string);
+    constructor(modelName?: string, credentials?: {
+        baseURL?: string;
+    });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/ollama.js

@@ -523,9 +523,9 @@ export class OllamaProvider extends BaseProvider {
     ollamaModel;
     baseUrl;
     timeout;
-    constructor(modelName) {
+    constructor(modelName, credentials) {
         super(modelName, "ollama");
-        this.baseUrl = getOllamaBaseUrl();
+        this.baseUrl = credentials?.baseURL ?? getOllamaBaseUrl();
         this.timeout = getOllamaTimeout();
         // Initialize Ollama model
         this.ollamaModel = new OllamaLanguageModel(this.modelName || getDefaultOllamaModel(), this.baseUrl, this.timeout);

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

@@ -10,7 +10,11 @@ import type { ValidationSchema } from "../types/typeAliases.js";
  */
 export declare class OpenAIProvider extends BaseProvider {
     private model;
-    constructor(modelName?: string, neurolink?: NeuroLink);
+    private credentials?;
+    constructor(modelName?: string, neurolink?: NeuroLink, _region?: string, credentials?: {
+        apiKey?: string;
+        baseURL?: string;
+    });
     /**
      * Check if this provider supports tool/function calling
      */

package/dist/lib/providers/openAI.js

@@ -36,11 +36,14 @@ const streamTracer = trace.getTracer("neurolink.provider.openai");
  */
 export class OpenAIProvider extends BaseProvider {
     model;
-    constructor(modelName, neurolink) {
+    credentials;
+    constructor(modelName, neurolink, _region, credentials) {
         super(modelName || getOpenAIModel(), AIProviderName.OPENAI, neurolink);
+        this.credentials = credentials;
         // Initialize OpenAI provider with proxy support
         const openai = createOpenAI({
-            apiKey: getOpenAIApiKey(),
+            apiKey: credentials?.apiKey ?? getOpenAIApiKey(),
+            ...(credentials?.baseURL ? { baseURL: credentials.baseURL } : {}),
             fetch: createProxyFetch(),
         });
         // Initialize model
@@ -554,9 +557,12 @@ export class OpenAIProvider extends BaseProvider {
         });
         try {
             // Create embedding model using the AI SDK
-            // Create the OpenAI provider
+            // Create the OpenAI provider, preferring per-instance credentials over env vars
             const openai = createOpenAI({
-                apiKey: getOpenAIApiKey(),
+                apiKey: this.credentials?.apiKey ?? getOpenAIApiKey(),
+                ...(this.credentials?.baseURL
+                    ? { baseURL: this.credentials.baseURL }
+                    : {}),
                 fetch: createProxyFetch(),
             });
             // Get the text embedding model
@@ -596,8 +602,12 @@ export class OpenAIProvider extends BaseProvider {
             count: texts.length,
         });
         try {
+            // Prefer per-instance credentials over env vars
             const openai = createOpenAI({
-                apiKey: getOpenAIApiKey(),
+                apiKey: this.credentials?.apiKey ?? getOpenAIApiKey(),
+                ...(this.credentials?.baseURL
+                    ? { baseURL: this.credentials.baseURL }
+                    : {}),
                 fetch: createProxyFetch(),
             });
             const embeddingModel = openai.textEmbeddingModel(embeddingModelName);

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

@@ -10,12 +10,16 @@ import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 export declare class OpenRouterProvider extends BaseProvider {
     private model;
     private openRouterClient;
+    private config;
     private static modelsCache;
     private static modelsCacheTime;
     private static readonly MODELS_CACHE_DURATION;
     private static toolCapableModels;
     private static capabilitiesCached;
-    constructor(modelName?: string, sdk?: unknown);
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
+        apiKey?: string;
+        baseURL?: string;
+    });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/openRouter.js

@@ -47,6 +47,7 @@ const getDefaultOpenRouterModel = () => {
 export class OpenRouterProvider extends BaseProvider {
     model;
     openRouterClient;
+    config;
     // Cache for available models to avoid repeated API calls
     static modelsCache = [];
     static modelsCacheTime = 0;
@@ -54,10 +55,20 @@ export class OpenRouterProvider extends BaseProvider {
     // Cache for model capabilities (which models support tools)
     static toolCapableModels = new Set();
     static capabilitiesCached = false;
-    constructor(modelName, sdk) {
+    constructor(modelName, sdk, _region, credentials) {
         super(modelName, AIProviderName.OPENROUTER, sdk);
-        // Initialize OpenRouter using the official SDK
-        const config = getOpenRouterConfig();
+        // Build config: prefer credentials over env vars to avoid throwing when env vars are absent
+        if (credentials?.apiKey) {
+            this.config = {
+                apiKey: credentials.apiKey,
+                referer: process.env.OPENROUTER_REFERER,
+                appName: process.env.OPENROUTER_APP_NAME,
+            };
+        }
+        else {
+            this.config = getOpenRouterConfig(); // throws if OPENROUTER_API_KEY missing
+        }
+        const config = this.config;
         // Build headers for attribution on openrouter.ai/activity dashboard
         const headers = {};
         if (config.referer) {
@@ -69,6 +80,7 @@ export class OpenRouterProvider extends BaseProvider {
         // Create OpenRouter client with optional attribution headers
         this.openRouterClient = createOpenRouter({
             apiKey: config.apiKey,
+            ...(credentials?.baseURL ? { baseURL: credentials.baseURL } : {}),
             ...(Object.keys(headers).length > 0 && { headers }),
         });
         // Initialize model with OpenRouter client
@@ -437,7 +449,7 @@ export class OpenRouterProvider extends BaseProvider {
      */
     async fetchModelsFromAPI() {
         const functionTag = "OpenRouterProvider.fetchModelsFromAPI";
-        const config = getOpenRouterConfig();
+        const config = this.config;
         const modelsUrl = "https://openrouter.ai/api/v1/models";
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), MODELS_DISCOVERY_TIMEOUT_MS);
@@ -499,7 +511,7 @@ export class OpenRouterProvider extends BaseProvider {
             return; // Already cached
         }
         try {
-            const config = getOpenRouterConfig();
+            const config = this.config;
             const modelsUrl = "https://openrouter.ai/api/v1/models";
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), MODELS_DISCOVERY_TIMEOUT_MS);

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

@@ -12,7 +12,10 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
     private config;
     private discoveredModel?;
     private customOpenAI;
-    constructor(modelName?: string, sdk?: unknown);
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
+        apiKey?: string;
+        baseURL?: string;
+    });
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/openaiCompatible.js

@@ -45,10 +45,22 @@ export class OpenAICompatibleProvider extends BaseProvider {
     config;
     discoveredModel;
     customOpenAI;
-    constructor(modelName, sdk) {
+    constructor(modelName, sdk, _region, credentials) {
         super(modelName, "openai-compatible", sdk);
-        // Initialize OpenAI Compatible configuration
-        this.config = getOpenAICompatibleConfig();
+        // Build config: prefer credentials over env vars to avoid throwing when env vars are absent
+        if (credentials?.apiKey && credentials?.baseURL) {
+            this.config = {
+                apiKey: credentials.apiKey,
+                baseURL: credentials.baseURL,
+            };
+        }
+        else {
+            const envConfig = getOpenAICompatibleConfig(); // throws if env vars missing
+            this.config = {
+                apiKey: credentials?.apiKey ?? envConfig.apiKey,
+                baseURL: credentials?.baseURL ?? envConfig.baseURL,
+            };
+        }
         // Create OpenAI SDK instance configured for custom endpoint
         // This allows us to use OpenAI-compatible API by simply changing the baseURL
         this.customOpenAI = createOpenAI({

package/dist/lib/types/configTypes.d.ts

@@ -11,6 +11,7 @@ import type { RoutingStrategy } from "../mcp/routing/index.js";
 import type { CacheStrategy } from "../mcp/caching/index.js";
 import type { ToolMiddleware } from "../mcp/toolIntegration.js";
 import type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./authTypes.js";
+import type { NeurolinkCredentials } from "./providers.js";
 /**
  * Main NeuroLink configuration type
  */
@@ -39,6 +40,12 @@ export type NeurolinkConstructorConfig = {
     auth?: NeuroLinkAuthConfig;
     /** TaskManager configuration (scheduled and self-running tasks) */
     tasks?: TaskManagerConfig;
+    /**
+     * Per-provider credential overrides.
+     * When set here, applies as the default for all generate()/stream() calls
+     * from this NeuroLink instance. Per-call credentials override these.
+     */
+    credentials?: NeurolinkCredentials;
 };
 /**
  * Configuration for MCP enhancement modules wired into generate()/stream() paths.

package/dist/lib/types/generateTypes.d.ts

@@ -11,6 +11,7 @@ import type { DirectorModeOptions, DirectorSegment, VideoGenerationResult, Video
 import type { PPTGenerationResult, PPTOutputOptions } from "./pptTypes.js";
 import type { TTSOptions, TTSResult } from "./ttsTypes.js";
 import type { StandardRecord, ValidationSchema, ZodUnknownSchema } from "./typeAliases.js";
+import type { NeurolinkCredentials } from "./providers.js";
 /**
  * Generate function options type - Primary method for content generation
  * Supports multimodal content while maintaining backward compatibility
@@ -424,6 +425,12 @@ export type GenerateOptions = {
     auth?: {
         token: string;
     };
+    /**
+     * Per-provider credential overrides for this request.
+     * Overrides instance-level credentials set in `new NeuroLink({ credentials })`.
+     * Unset providers fall through to instance credentials, then environment variables.
+     */
+    credentials?: NeurolinkCredentials;
     /**
      * Per-call memory control.
      *
@@ -942,6 +949,12 @@ export type TextGenerationOptions = {
         /** Thinking level (Gemini 3: minimal|low|medium|high). Ignored for Anthropic. */
         thinkingLevel?: "minimal" | "low" | "medium" | "high";
     };
+    /**
+     * Per-provider credential overrides for this request.
+     * Overrides instance-level credentials set in `new NeuroLink({ credentials })`.
+     * Unset providers fall through to instance credentials, then environment variables.
+     */
+    credentials?: NeurolinkCredentials;
     /**
      * Optional request identifier for observability and log correlation.
      * When provided, this ID is forwarded to spans, logs, and telemetry so

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

@@ -71,6 +71,81 @@ export type AWSCredentialConfig = {
     /** Optional service endpoint override (e.g., VPC/Gov endpoints) */
     endpoint?: string;
 };
+/**
+ * Per-provider credential overrides for generate() / stream() calls.
+ *
+ * When set on `NeurolinkConstructorConfig.credentials`, applies as the default
+ * for all calls from that NeuroLink instance. When set on
+ * `GenerateOptions.credentials` or `StreamOptions.credentials`, overrides the
+ * instance default for that single call.
+ *
+ * Unset providers fall through to environment variables (existing behaviour).
+ */
+export type NeurolinkCredentials = {
+    openai?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    anthropic?: {
+        apiKey?: string;
+        oauthToken?: string;
+    };
+    googleAiStudio?: {
+        apiKey?: string;
+    };
+    vertex?: {
+        projectId?: string;
+        location?: string;
+        /** Vertex Express Mode — simplified API-key auth */
+        apiKey?: string;
+        /** Full service-account JSON string */
+        serviceAccountKey?: string;
+        /** Inline service-account fields (alternative to serviceAccountKey) */
+        clientEmail?: string;
+        privateKey?: string;
+    };
+    bedrock?: {
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        sessionToken?: string;
+        region?: string;
+    };
+    sagemaker?: {
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        sessionToken?: string;
+        region?: string;
+        endpoint?: string;
+    };
+    azure?: {
+        apiKey?: string;
+        resourceName?: string;
+        deploymentName?: string;
+        apiVersion?: string;
+    };
+    mistral?: {
+        apiKey?: string;
+    };
+    huggingFace?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    openrouter?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    litellm?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    openaiCompatible?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    ollama?: {
+        baseURL?: string;
+    };
+};
 /**
  * AWS Credential Validation Result
  */

package/dist/lib/types/streamTypes.d.ts

@@ -9,7 +9,7 @@ import type { JsonValue, UnknownRecord } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { ChatMessage } from "./conversation.js";
 import type { AdditionalMemoryUser } from "./generateTypes.js";
-import type { AIModelProviderConfig } from "./providers.js";
+import type { AIModelProviderConfig, NeurolinkCredentials } from "./providers.js";
 import type { TTSChunk, TTSOptions } from "./ttsTypes.js";
 import type { StandardRecord, ValidationSchema } from "./typeAliases.js";
 /**
@@ -444,6 +444,12 @@ export type StreamOptions = {
     auth?: {
         token: string;
     };
+    /**
+     * Per-provider credential overrides for this request.
+     * Overrides instance-level credentials set in `new NeuroLink({ credentials })`.
+     * Unset providers fall through to instance credentials, then environment variables.
+     */
+    credentials?: NeurolinkCredentials;
     /**
      * Per-call memory control.
      *

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