@juspay/neurolink 9.51.3 → 9.52.0

package/dist/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/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/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/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/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/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/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/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/session/globalSessionState.js

@@ -1,6 +1,33 @@
 import { nanoid } from "nanoid";
 import { NeuroLink } from "../neurolink.js";
 import { buildObservabilityConfigFromEnv } from "../utils/observabilityHelpers.js";
+/**
+ * Build mcp.outputLimits config from environment variables.
+ * Reads NEUROLINK_MCP_OUTPUT_STRATEGY and NEUROLINK_MCP_MAX_OUTPUT_BYTES.
+ * Returns undefined when neither variable is set (no overhead).
+ */
+function buildMcpOutputLimitsFromEnv() {
+    const strategyRaw = process.env.NEUROLINK_MCP_OUTPUT_STRATEGY;
+    const maxBytesRaw = process.env.NEUROLINK_MCP_MAX_OUTPUT_BYTES;
+    const warnBytesRaw = process.env.NEUROLINK_MCP_WARN_OUTPUT_BYTES;
+    if (!strategyRaw && !maxBytesRaw) {
+        return undefined;
+    }
+    const strategy = strategyRaw === "inline" || strategyRaw === "externalize"
+        ? strategyRaw
+        : "externalize"; // safe default when only maxBytes is set
+    const maxBytes = maxBytesRaw ? parseInt(maxBytesRaw, 10) : undefined;
+    const warnBytes = warnBytesRaw ? parseInt(warnBytesRaw, 10) : undefined;
+    return {
+        strategy,
+        ...(maxBytes !== undefined && Number.isFinite(maxBytes) && maxBytes >= 0
+            ? { maxBytes }
+            : {}),
+        ...(warnBytes !== undefined && Number.isFinite(warnBytes) && warnBytes >= 0
+            ? { warnBytes }
+            : {}),
+    };
+}
 export class GlobalSessionManager {
     static instance;
     loopSession = null;
@@ -25,6 +52,14 @@ export class GlobalSessionManager {
         if (observabilityConfig) {
             neurolinkOptions.observability = observabilityConfig;
         }
+        // Add MCP output limits from environment variables (CLI usage)
+        const mcpOutputLimits = buildMcpOutputLimitsFromEnv();
+        if (mcpOutputLimits) {
+            neurolinkOptions.mcp = {
+                ...neurolinkOptions.mcp,
+                outputLimits: mcpOutputLimits,
+            };
+        }
         this.loopSession = {
             neurolinkInstance: new NeuroLink(neurolinkOptions),
             sessionId,
@@ -99,7 +134,15 @@ export class GlobalSessionManager {
         }
         // Create new NeuroLink with observability config from environment (CLI usage)
         const observabilityConfig = buildObservabilityConfigFromEnv();
-        return new NeuroLink(observabilityConfig ? { observability: observabilityConfig } : undefined);
+        const mcpOutputLimits = buildMcpOutputLimitsFromEnv();
+        const options = {};
+        if (observabilityConfig) {
+            options.observability = observabilityConfig;
+        }
+        if (mcpOutputLimits) {
+            options.mcp = { outputLimits: mcpOutputLimits };
+        }
+        return new NeuroLink(Object.keys(options).length ? options : undefined);
     }
     getCurrentSessionId() {
         return this.getLoopSession()?.sessionId;

package/dist/types/artifactTypes.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Artifact Store Types (canonical location)
+ *
+ * Types for the MCP large-output artifact storage system.
+ * When mcp.outputLimits.strategy = "externalize", oversized MCP tool outputs
+ * are stored as artifacts and the model receives a compact surrogate instead.
+ *
+ * @module types/artifactTypes
+ */
+/** Metadata recorded alongside a stored artifact. */
+export type ArtifactMeta = {
+    /** Tool name that produced the output. */
+    toolName: string;
+    /** MCP server ID. */
+    serverId: string;
+    /** Session that triggered the tool call (optional). */
+    sessionId?: string;
+    /** Serialized byte size of the full payload. */
+    sizeBytes: number;
+    /** Whether the payload is valid JSON or plain text. */
+    contentType: "json" | "text";
+    /** Unix epoch ms when the artifact was created. */
+    createdAt: number;
+};
+/** Lightweight descriptor returned after a successful ArtifactStore.store(). */
+export type ArtifactRef = {
+    /** UUID v4 — stable identifier used in surrogate results and metadata. */
+    id: string;
+    /** First N characters of the payload (for surrogate headers). */
+    preview: string;
+    /** Full serialized byte size. */
+    sizeBytes: number;
+    /** Stored metadata. */
+    meta: ArtifactMeta;
+};
+/**
+ * Pluggable storage contract for externalized MCP tool outputs.
+ *
+ * Default backend: LocalTempArtifactStore (filesystem, single-process).
+ * Future backends can implement this interface for S3, Redis blobs, etc.
+ */
+export interface ArtifactStore {
+    /**
+     * Persist a payload and return a lightweight reference.
+     * @param payload  Serialized tool output (JSON string or plain text).
+     * @param meta     Descriptor without `createdAt` (assigned internally).
+     */
+    store(payload: string, meta: Omit<ArtifactMeta, "createdAt">): Promise<ArtifactRef>;
+    /**
+     * Retrieve the full payload by artifact ID.
+     * Returns `null` if the artifact is not found or has been cleaned up.
+     */
+    retrieve(id: string): Promise<string | null>;
+    /** Delete a single artifact. No-op if the ID does not exist. */
+    delete(id: string): Promise<void>;
+    /**
+     * Delete all artifacts older than `olderThanMs` milliseconds.
+     * Returns the number of artifacts deleted.
+     */
+    cleanup(olderThanMs: number): Promise<number>;
+    /** Generate a short preview string from a serialized payload. */
+    generatePreview(payload: string): string;
+}

package/dist/types/artifactTypes.js

@@ -0,0 +1,10 @@
+/**
+ * Artifact Store Types (canonical location)
+ *
+ * Types for the MCP large-output artifact storage system.
+ * When mcp.outputLimits.strategy = "externalize", oversized MCP tool outputs
+ * are stored as artifacts and the model receives a compact surrogate instead.
+ *
+ * @module types/artifactTypes
+ */
+export {};

package/dist/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.
@@ -90,6 +97,38 @@ export type MCPEnhancementsConfig = {
     };
     /** Global tool middleware applied to every tool execution. Default: empty. */
     middleware?: ToolMiddleware[];
+    /**
+     * Large MCP tool output handling.
+     *
+     * MCP servers can return arbitrarily large payloads. Without limits these
+     * are loaded entirely into memory, cached in full, stored whole in Redis, and
+     * injected into the LLM context window — all of which silently fail at scale.
+     *
+     * When configured, NeuroLink intercepts oversized outputs at the tool boundary
+     * (before caching and before memory persistence) and applies the chosen
+     * strategy so the model receives a compact surrogate instead of a firehose.
+     *
+     * Two strategies:
+     *  - "inline"      Keep sending the full payload to the model regardless of
+     *                  size. A warning is emitted above warnBytes.
+     *  - "externalize" Store the full payload on disk as an artifact and return a
+     *                  compact surrogate with a head/tail preview and an artifact
+     *                  ID. The model uses `retrieve_context` with that ID to read
+     *                  the full output on demand, with offset/limit pagination.
+     *
+     * Defaults (when `outputLimits` is set):
+     *  strategy  = "externalize"
+     *  maxBytes  = 100 KB (100 * 1024)
+     *  warnBytes =  50 KB  (50 * 1024)
+     */
+    outputLimits?: {
+        /** What to do when output exceeds maxBytes. Default: "externalize". */
+        strategy?: "inline" | "externalize";
+        /** Byte ceiling above which the strategy fires. Default: 102400 (100 KB). */
+        maxBytes?: number;
+        /** Bytes at which a warning is emitted even when still inline. Default: 51200 (50 KB). */
+        warnBytes?: number;
+    };
 };
 /**
  * Authentication configuration for NeuroLink SDK

package/dist/types/conversation.d.ts

@@ -231,6 +231,13 @@ export type ChatMessageMetadata = {
     toolOutputPreview?: string;
     /** Original byte size of the full tool output before any truncation */
     originalSize?: number;
+    /**
+     * Artifact store ID for an externalized MCP tool output.
+     * Set when `mcp.outputLimits.strategy = "externalize"` and the tool output
+     * exceeded `maxBytes`. Use retrieve_context with this ID to fetch the full
+     * payload from the local artifact store.
+     */
+    artifactId?: string;
 };
 /**
  * Chat message format for conversation history

package/dist/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/types/index.d.ts

@@ -6,6 +6,8 @@ export * from "./cli.js";
 export * from "./common.js";
 export type { AnalyticsConfig, BackupInfo, BackupMetadata, CacheConfig, ConfigUpdateOptions, ConfigValidationResult, FallbackConfig, MCPEnhancementsConfig, NeuroLinkConfig, PerformanceConfig, RetryConfig, ToolConfig, } from "./configTypes.js";
 export type { ExternalMCPConfigValidation, ExternalMCPManagerConfig, ExternalMCPOperationResult, ExternalMCPServerEvents, ExternalMCPServerHealth, ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolContext, ExternalMCPToolInfo, ExternalMCPToolResult, } from "./externalMcp.js";
+export type { ArtifactMeta, ArtifactRef, ArtifactStore, } from "./artifactTypes.js";
+export type { McpOutputContext, McpOutputNormalizerConfig, McpOutputStrategy, NormalizedMcpOutput, } from "./mcpOutputTypes.js";
 export type { AuthorizationUrlResult, CircuitBreakerConfig, CircuitBreakerEvents, CircuitBreakerState, CircuitBreakerStats, DiscoveredMcp, ExternalToolExecutionOptions, FlexibleValidationResult, HTTPRetryConfig, MCPClientResult, MCPConnectedServer, MCPDiscoveredServer, MCPExecutableTool, MCPOAuthConfig, MCPServerCategory, MCPServerConfig, MCPServerConnectionStatus, MCPServerInfo, MCPServerMetadata, MCPServerRegistryEntry, MCPServerStatus, MCPStatus, MCPToolInfo, MCPToolMetadata, MCPTransportType, McpMetadata, McpRegistry, NeuroLinkExecutionContext, NeuroLinkMCPServer, NeuroLinkMCPTool, OAuthClientInformation, OAuthTokens as McpOAuthTokens, RateLimitConfig, TokenBucketRateLimitConfig, TokenExchangeRequest, TokenStorage, ToolDiscoveryResult, ToolRegistryEvents, ToolValidationResult, } from "./mcpTypes.js";
 export type { ModelCapability, ModelFilter, ModelPricing, ModelResolutionContext, ModelStats, ModelUseCase, } from "./providers.js";
 export * from "./providers.js";

package/dist/types/mcpOutputTypes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * MCP Output Normalizer Types (canonical location)
+ *
+ * Types for the large MCP response handling system.
+ *
+ * @module types/mcpOutputTypes
+ */
+/**
+ * Two honest strategies for oversized MCP tool outputs:
+ *  - "inline"      Full payload always sent to the model (warning logged above warnBytes).
+ *  - "externalize" Full payload stored as an artifact; model receives a compact
+ *                  surrogate with head/tail preview and an artifact ID it can
+ *                  resolve via retrieve_context with offset/limit pagination.
+ */
+export type McpOutputStrategy = "inline" | "externalize";
+/** Configuration for McpOutputNormalizer. */
+export type McpOutputNormalizerConfig = {
+    strategy: McpOutputStrategy;
+    /** Byte ceiling above which the strategy fires. */
+    maxBytes: number;
+    /** Bytes at which a warning is emitted while still inline. */
+    warnBytes: number;
+};
+/** Contextual info passed alongside the raw MCP callResult. */
+export type McpOutputContext = {
+    toolName: string;
+    serverId: string;
+    sessionId?: string;
+};
+/** Value returned by McpOutputNormalizer.normalize(). */
+export type NormalizedMcpOutput = {
+    /** The result to substitute for the raw callResult. May be a surrogate. */
+    result: unknown;
+    /** Whether the full payload was written to the artifact store. */
+    isExternalized: boolean;
+    /** Artifact ID when isExternalized === true. */
+    artifactId?: string;
+    /** Serialized byte size of the original payload. */
+    originalBytes: number;
+};

package/dist/types/mcpOutputTypes.js

@@ -0,0 +1,8 @@
+/**
+ * MCP Output Normalizer Types (canonical location)
+ *
+ * Types for the large MCP response handling system.
+ *
+ * @module types/mcpOutputTypes
+ */
+export {};

package/dist/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.51.3",
+  "version": "9.52.0",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
@@ -81,6 +81,7 @@
     "test:servers": "npx tsx test/continuous-test-suite-servers.ts",
     "test:tracing": "npx tsx test/continuous-test-suite-tracing.ts",
     "test:tts": "npx tsx test/continuous-test-suite-tts.ts",
+    "test:credentials": "tsx test/continuous-test-suite-credentials.ts",
     "test:workflow": "npx tsx test/continuous-test-suite-workflow.ts",
     "test:ci": "pnpm run test && pnpm run test:client",
     "test:performance": "tsx tools/testing/performanceMonitor.ts",
@@ -229,8 +230,8 @@
     "adm-zip": "^0.5.16",
     "ai": "^6.0.134",
     "bullmq": "^5.52.2",
-    "croner": "^9.1.0",
     "chalk": "^5.6.2",
+    "croner": "^9.1.0",
     "csv-parser": "^3.2.0",
     "dotenv": "^17.3.1",
     "exceljs": "^4.4.0",