@juspay/neurolink 9.51.4 → 9.53.0

package/dist/lib/providers/googleVertex.js

@@ -96,9 +96,9 @@ const hasGoogleCredentials = () => {
 // Module-level cache for runtime-created credentials file to avoid per-request writes
 let cachedCredentialsPath = null;
 // Enhanced Vertex settings creation with authentication fallback and proxy support
-const createVertexSettings = async (region) => {
-    const location = region || getVertexLocation();
-    const project = getVertexProjectId();
+const createVertexSettings = async (region, credentials) => {
+    const location = credentials?.location || region || getVertexLocation();
+    const project = credentials?.projectId || getVertexProjectId();
     const baseSettings = {
         project,
         location,
@@ -115,6 +115,35 @@ const createVertexSettings = async (region) => {
             project,
         });
     }
+    // ── Per-request credentials (highest priority, never touches module-level cache) ──
+    if (credentials) {
+        // Express Mode: API key auth (Vertex Express)
+        if (credentials.apiKey) {
+            return { ...baseSettings, apiKey: credentials.apiKey };
+        }
+        // Resolve client_email / private_key from inline fields or serviceAccountKey JSON
+        const resolvedClientEmail = credentials.clientEmail ||
+            (credentials.serviceAccountKey
+                ? JSON.parse(credentials.serviceAccountKey)
+                    .client_email
+                : undefined);
+        const resolvedPrivateKey = credentials.privateKey ||
+            (credentials.serviceAccountKey
+                ? JSON.parse(credentials.serviceAccountKey)
+                    .private_key
+                : undefined);
+        if (resolvedClientEmail && resolvedPrivateKey) {
+            return {
+                ...baseSettings,
+                googleAuthOptions: {
+                    credentials: {
+                        client_email: resolvedClientEmail,
+                        private_key: resolvedPrivateKey.replace(/\\n/g, "\n"),
+                    },
+                },
+            };
+        }
+    }
     // 🎯 OPTION 2: Create credentials file from environment variables at runtime
     // This solves the problem where GOOGLE_APPLICATION_CREDENTIALS exists in ZSHRC locally
     // but the file doesn't exist on production servers
@@ -290,20 +319,21 @@ const createVertexSettings = async (region) => {
     return baseSettings;
 };
 // Create Anthropic-specific Vertex settings with the same authentication and proxy support
-const createVertexAnthropicSettings = async (region) => {
+const createVertexAnthropicSettings = async (region, credentials) => {
     // The @ai-sdk/google-vertex SDK constructs Anthropic URLs as:
     //   https://{location}-aiplatform.googleapis.com/...
     // When location is "global", this creates "https://global-aiplatform.googleapis.com"
     // which is invalid. The correct global endpoint omits the region prefix entirely.
     // Since the SDK doesn't handle this, redirect "global" to "us-east5" for Anthropic.
     const anthropicRegion = !region || region === "global" ? "us-east5" : region;
-    const baseVertexSettings = await createVertexSettings(anthropicRegion);
+    const baseVertexSettings = await createVertexSettings(anthropicRegion, credentials);
     // GoogleVertexAnthropicProviderSettings extends GoogleVertexProviderSettings
     // so we can use the same settings with proper typing
     return {
         project: baseVertexSettings.project,
         location: baseVertexSettings.location,
         fetch: baseVertexSettings.fetch,
+        ...(baseVertexSettings.apiKey && { apiKey: baseVertexSettings.apiKey }),
         ...(baseVertexSettings.googleAuthOptions && {
             googleAuthOptions: baseVertexSettings.googleAuthOptions,
         }),
@@ -397,6 +427,7 @@ export class GoogleVertexProvider extends BaseProvider {
     location;
     registeredTools = new Map();
     toolContext = {};
+    credentials;
     // Memory-managed cache for model configuration lookups to avoid repeated calls
     // Uses WeakMap for automatic cleanup and bounded LRU for recently used models
     static modelConfigCache = new Map();
@@ -406,15 +437,17 @@ export class GoogleVertexProvider extends BaseProvider {
     // Memory-managed cache for maxTokens handling decisions to optimize streaming performance
     static maxTokensCache = new Map();
     static maxTokensCacheTime = 0;
-    constructor(modelName, _providerName, sdk, region) {
+    constructor(modelName, _providerName, sdk, region, credentials) {
         super(modelName, "vertex", sdk);
+        this.credentials = credentials;
         // Validate Google Cloud credentials - now using consolidated utility
-        if (!hasGoogleCredentials()) {
+        // Skip env-var validation when per-request credentials are provided
+        if (!credentials && !hasGoogleCredentials()) {
             validateApiKey(createGoogleAuthConfig());
         }
         // Initialize Google Cloud configuration
-        this.projectId = getVertexProjectId();
-        this.location = region || getVertexLocation();
+        this.projectId = credentials?.projectId || getVertexProjectId();
+        this.location = credentials?.location || region || getVertexLocation();
         logger.debug("[GoogleVertexProvider] Constructor initialized", {
             regionParam: region,
             resolvedLocation: this.location,
@@ -549,7 +582,7 @@ export class GoogleVertexProvider extends BaseProvider {
             message: "Starting Vertex settings creation with network configuration analysis",
         });
         try {
-            const vertexSettings = await createVertexSettings(this.location);
+            const vertexSettings = await createVertexSettings(this.location, this.credentials);
             const vertexSettingsEndTime = process.hrtime.bigint();
             const vertexSettingsDurationNs = vertexSettingsEndTime - vertexSettingsStartTime;
             logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V009_VERTEX_SETTINGS_SUCCESS`, {
@@ -1084,8 +1117,11 @@ export class GoogleVertexProvider extends BaseProvider {
      * Create @google/genai client configured for Vertex AI
      */
     async createVertexGenAIClient(regionOverride) {
-        const project = getVertexProjectId();
-        const location = regionOverride || this.location || getVertexLocation();
+        const project = this.credentials?.projectId || getVertexProjectId();
+        const location = this.credentials?.location ||
+            regionOverride ||
+            this.location ||
+            getVertexLocation();
         const mod = await import("@google/genai");
         const ctor = mod.GoogleGenAI;
         if (!ctor) {
@@ -1099,7 +1135,42 @@ export class GoogleVertexProvider extends BaseProvider {
             });
         }
         const Ctor = ctor;
-        // Use vertexai mode with project and location
+        // Per-request credentials: Express Mode (API key)
+        if (this.credentials?.apiKey) {
+            // Cast via unknown because GoogleGenAIClass union doesn't include apiKey+vertexai
+            return new Ctor({
+                vertexai: true,
+                project,
+                location,
+                apiKey: this.credentials.apiKey,
+            });
+        }
+        // Per-request credentials: inline service account
+        if (this.credentials?.clientEmail || this.credentials?.serviceAccountKey) {
+            const clientEmail = this.credentials.clientEmail ||
+                (this.credentials.serviceAccountKey
+                    ? JSON.parse(this.credentials.serviceAccountKey).client_email
+                    : undefined);
+            const privateKey = this.credentials.privateKey ||
+                (this.credentials.serviceAccountKey
+                    ? JSON.parse(this.credentials.serviceAccountKey).private_key
+                    : undefined);
+            if (clientEmail && privateKey) {
+                // Cast via unknown because GoogleGenAIClass union doesn't include googleAuthOptions
+                return new Ctor({
+                    vertexai: true,
+                    project,
+                    location,
+                    googleAuthOptions: {
+                        credentials: {
+                            client_email: clientEmail,
+                            private_key: privateKey.replace(/\\n/g, "\n"),
+                        },
+                    },
+                });
+            }
+        }
+        // Fallback: env-var / ADC auth
         return new Ctor({
             vertexai: true,
             project,
@@ -1849,7 +1920,15 @@ export class GoogleVertexProvider extends BaseProvider {
             return null;
         }
         // 2. Authentication Validation
-        const authValidation = await this.validateVertexAuthentication();
+        // Per-request credentials bypass env-var auth checks entirely
+        const hasPerRequestAuth = this.credentials &&
+            (this.credentials.apiKey ||
+                this.credentials.clientEmail ||
+                this.credentials.privateKey ||
+                this.credentials.serviceAccountKey);
+        const authValidation = hasPerRequestAuth
+            ? { isValid: true, method: "per_request_credentials", issues: [] }
+            : await this.validateVertexAuthentication();
         if (!authValidation.isValid) {
             logger.error("[GoogleVertexProvider] ❌ Authentication validation failed", {
                 validationId,
@@ -1927,7 +2006,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 projectId: projectValidation.projectId,
                 region: projectValidation.region,
             });
-            const vertexAnthropicSettings = await createVertexAnthropicSettings(this.location);
+            const vertexAnthropicSettings = await createVertexAnthropicSettings(this.location, this.credentials);
             // 7. Settings Validation
             if (!vertexAnthropicSettings.project ||
                 !vertexAnthropicSettings.location) {
@@ -2844,7 +2923,7 @@ export class GoogleVertexProvider extends BaseProvider {
         });
         try {
             // Create the Vertex provider with current settings
-            const vertexSettings = await createVertexSettings(this.location);
+            const vertexSettings = await createVertexSettings(this.location, this.credentials);
             const vertex = createVertex(vertexSettings);
             // Get the text embedding model
             const embeddingModel = vertex.textEmbeddingModel(embeddingModelName);
@@ -2883,7 +2962,7 @@ export class GoogleVertexProvider extends BaseProvider {
             count: texts.length,
         });
         try {
-            const vertexSettings = await createVertexSettings(this.location);
+            const vertexSettings = await createVertexSettings(this.location, this.credentials);
             const vertex = createVertex(vertexSettings);
             const embeddingModel = vertex.textEmbeddingModel(embeddingModelName);
             const result = await embedMany({

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

@@ -2,6 +2,7 @@ import { type LanguageModel, type Schema } from "ai";
 import type { ZodType } from "zod";
 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";
 /**
  * HuggingFace Provider - BaseProvider Implementation
@@ -9,7 +10,7 @@ import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
  */
 export declare class HuggingFaceProvider extends BaseProvider {
     private model;
-    constructor(modelName?: string);
+    constructor(modelName?: string, _sdk?: unknown, credentials?: NeurolinkCredentials["huggingFace"]);
     /**
      * HuggingFace Tool Calling Support (Enhanced 2025)
      *

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

@@ -1,6 +1,6 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { NoOutputGeneratedError, Output, streamText, } from "ai";
+import { NoOutputGeneratedError, Output, stepCountIs, streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.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());
@@ -162,7 +165,7 @@ export class LiteLLMProvider extends BaseProvider {
                     Object.keys(tools).length > 0 && {
                     tools,
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
-                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                    stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
@@ -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

@@ -1,5 +1,5 @@
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { NoOutputGeneratedError, Output, streamText, } from "ai";
+import { NoOutputGeneratedError, Output, stepCountIs, streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.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
@@ -236,7 +248,7 @@ export class OpenRouterProvider extends BaseProvider {
                     Object.keys(tools).length > 0 && {
                     tools,
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
-                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                    stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
@@ -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

@@ -1,6 +1,7 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { NoOutputGeneratedError, streamText, } from "ai";
+import { NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
@@ -45,10 +46,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({
@@ -179,6 +192,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                     : {}),
                 tools,
                 toolChoice: resolveToolChoice(options, tools, shouldUseTools),
+                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: (event) => {