@juspay/neurolink 9.68.17 → 9.68.19

package/dist/providers/mistral.js

@@ -1,135 +1,64 @@
-import { createMistral } from "@ai-sdk/mistral";
-import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
-import { isNeuroLink } from "../neurolink.js";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
-import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
+import { MistralModels } from "../constants/enums.js";
+import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
+import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { resolveToolChoice } from "../utils/toolChoice.js";
-import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
-import { stepCountIs } from "../utils/tool.js";
-import { streamText } from "../utils/generation.js";
-// Configuration helpers - now using consolidated utility
+import { TimeoutError } from "../utils/timeout.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
+const MISTRAL_DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
 const getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
 };
 const getDefaultMistralModel = () => {
-    // Default to vision-capable Mistral Small 2506 (June 2025) with multimodal support
-    return getProviderModel("MISTRAL_MODEL", "mistral-small-2506");
+    // Vision-capable Mistral Small (June 2025) with multimodal support.
+    return getProviderModel("MISTRAL_MODEL", MistralModels.MISTRAL_SMALL_2506);
 };
 /**
- * Mistral AI Provider v2 - BaseProvider Implementation
- * Supports official AI-SDK integration with all Mistral models
+ * Mistral AI Provider — direct HTTP, no AI SDK.
+ *
+ * OpenAI-compatible chat completions at api.mistral.ai/v1. All request/stream/
+ * tool-loop orchestration lives in `OpenAIChatCompletionsProvider`; this class
+ * only declares configuration and the provider-specific error mapping.
+ *
+ * Mistral's `/chat/completions` accepts `response_format: { type:
+ * "json_schema" }` on current models (mistral-small-2506 and newer), so no
+ * structured-output downgrade is needed — the base client's default
+ * pass-through is correct.
+ *
+ * @see https://docs.mistral.ai/api/
  */
-export class MistralProvider extends BaseProvider {
-    model;
+export class MistralProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName, sdk, _region, credentials) {
-        // Type guard for NeuroLink parameter validation
-        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
-        super(modelName, "mistral", validatedNeurolink);
-        // Initialize Mistral model with API key validation and proxy support
-        const apiKey = credentials?.apiKey ?? getMistralApiKey();
-        const mistral = createMistral({
-            apiKey: apiKey,
-            fetch: createProxyFetch(),
-        });
-        this.model = mistral(this.modelName);
-        logger.debug("Mistral Provider v2 initialized", {
+        // Trim the override before applying precedence. A blank/whitespace
+        // `credentials.apiKey` must NOT bypass `getMistralApiKey()` — that would
+        // build a client with an unusable bearer token and fail at request time
+        // with a confusing 401 instead of at construction time.
+        const overrideApiKey = credentials?.apiKey?.trim();
+        const apiKey = overrideApiKey && overrideApiKey.length > 0
+            ? overrideApiKey
+            : getMistralApiKey();
+        // Treat blank/whitespace overrides as unset so an empty
+        // `credentials.baseURL` or `MISTRAL_BASE_URL=` cannot silently override
+        // the default with "" (mirrors the apiKey precedence above).
+        const baseURL = credentials?.baseURL?.trim() ||
+            process.env.MISTRAL_BASE_URL?.trim() ||
+            MISTRAL_DEFAULT_BASE_URL;
+        super("mistral", modelName, sdk, { baseURL, apiKey });
+        logger.debug("Mistral Provider initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
+            baseURL: redactUrlCredentials(this.config.baseURL),
         });
     }
-    // generate() method is inherited from BaseProvider; this provider uses the base implementation for generation with tools
-    async executeStream(options, _analysisSchema) {
-        this.validateStreamOptions(options);
-        const startTime = Date.now();
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Get tools - options.tools is pre-merged by BaseProvider.stream()
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
-            // Build message array from options with multimodal support
-            // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
-            const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            // Reviewer follow-up: capture upstream provider errors via onError
-            // so the post-stream NoOutput sentinel carries the real cause.
-            let capturedProviderError;
-            const result = await streamText({
-                model,
-                messages: messages,
-                temperature: options.temperature,
-                maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
-                tools,
-                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
-                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                experimental_repairToolCall: this.getToolCallRepairFn(options),
-                onError: (event) => {
-                    capturedProviderError = event.error;
-                    logger.error("Mistral: Stream error", {
-                        error: event.error instanceof Error
-                            ? event.error.message
-                            : String(event.error),
-                    });
-                },
-                onStepFinish: ({ toolCalls, toolResults }) => {
-                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
-                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                        logger.warn("[MistralProvider] Failed to store tool executions", {
-                            provider: this.providerName,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    });
-                },
-            });
-            timeoutController?.cleanup();
-            // Transform string stream to content object stream using BaseProvider method
-            const transformedStream = this.createTextStream(result, () => capturedProviderError);
-            // Create analytics promise that resolves after stream completion
-            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
-                requestId: `mistral-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: {
-                    startTime,
-                    streamId: `mistral-${Date.now()}`,
-                },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
-    // ===================
-    // ABSTRACT METHOD IMPLEMENTATIONS
-    // ===================
+    // ===========================================================================
+    // Abstract hooks (required)
+    // ===========================================================================
     getProviderName() {
-        return this.providerName;
+        return "mistral";
     }
     getDefaultModel() {
         return getDefaultMistralModel();
     }
-    /**
-     * Returns the Vercel AI SDK model instance for Mistral
-     */
-    getAISDKModel() {
-        return this.model;
-    }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
             return new NetworkError(`Request timed out: ${error.message}`, "mistral");
@@ -139,35 +68,31 @@ export class MistralProvider extends BaseProvider {
             ? errorRecord.message
             : "Unknown error";
         if (message.includes("API_KEY_INVALID") ||
-            message.includes("Invalid API key")) {
+            message.includes("Invalid API key") ||
+            message.includes("Unauthorized") ||
+            message.includes("401")) {
             return new AuthenticationError("Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.", "mistral");
         }
-        if (message.includes("Rate limit exceeded")) {
+        if (message.includes("rate limit") ||
+            message.includes("Rate limit") ||
+            message.includes("429")) {
             return new RateLimitError("Mistral rate limit exceeded", "mistral");
         }
+        if (message.includes("model_not_found") || message.includes("404")) {
+            return new InvalidModelError(`Mistral model '${this.modelName}' not found.`, "mistral");
+        }
         return new ProviderError(`Mistral error: ${message}`, "mistral");
     }
-    /**
-     * Validate provider configuration
-     */
-    async validateConfiguration() {
-        try {
-            getMistralApiKey();
-            return true;
-        }
-        catch {
-            return false;
-        }
+    // ===========================================================================
+    // Optional hooks
+    // ===========================================================================
+    getFallbackModelName() {
+        return MistralModels.MISTRAL_SMALL_2506;
     }
-    /**
-     * Get provider-specific configuration
-     */
-    getConfiguration() {
-        return {
-            provider: this.providerName,
-            model: this.modelName,
-            defaultModel: getDefaultMistralModel(),
-        };
+    getFallbackModels() {
+        return [
+            MistralModels.MISTRAL_SMALL_2506,
+            MistralModels.MISTRAL_LARGE_LATEST,
+        ];
     }
 }
-export default MistralProvider;

package/dist/providers/openRouter.d.ts

@@ -1,60 +1,75 @@
-import type { ZodType } from "zod";
 import { AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { NeurolinkCredentials } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
- * OpenRouter Provider - BaseProvider Implementation
- * Provides access to 300+ models from 60+ providers via OpenRouter unified gateway
+ * OpenRouter Provider — direct HTTP, no AI SDK.
+ *
+ * OpenAI-compatible unified gateway to 300+ models from 60+ providers. All
+ * request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class declares configuration plus the
+ * OpenRouter-specific behaviour:
+ *
+ *   1. Attribution headers — optional `HTTP-Referer` / `X-Title` (from
+ *      `OPENROUTER_REFERER` / `OPENROUTER_APP_NAME`) are merged into every
+ *      request via `getAuthHeaders` so usage shows up on the openrouter.ai
+ *      activity dashboard.
+ *   2. Per-model tool gating — OpenRouter proxies many models with varying
+ *      tool support, so `supportsTools()` consults a cached capability set
+ *      (populated by `cacheModelCapabilities()`) and falls back to a
+ *      conservative known-capable pattern list.
+ *   3. Dynamic model discovery — `getAvailableModels()` fetches the live
+ *      `/models` list (10-minute cache) with a hardcoded fallback.
+ *
+ * @see https://openrouter.ai/docs
  */
-export declare class OpenRouterProvider extends BaseProvider {
-    private model;
-    private openRouterClient;
-    private config;
+export declare class OpenRouterProvider extends OpenAIChatCompletionsProvider {
+    private readonly referer?;
+    private readonly appName?;
     private static modelsCache;
     private static modelsCacheTime;
     private static readonly MODELS_CACHE_DURATION;
     private static toolCapableModels;
     private static capabilitiesCached;
-    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: {
-        apiKey?: string;
-        baseURL?: string;
-    });
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["openrouter"]);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
+    protected formatProviderError(error: unknown): Error;
+    protected getFallbackModelName(): string;
     /**
-     * Returns the Vercel AI SDK model instance for OpenRouter
+     * Attribution headers are merged into every request alongside the bearer
+     * token so OpenRouter can attribute usage on its activity dashboard.
      */
-    protected getAISDKModel(): LanguageModel;
-    formatProviderError(error: unknown): Error;
+    protected getAuthHeaders(): Record<string, string>;
     /**
-     * OpenRouter supports tools for compatible models
-     * Checks cached model capabilities or uses known patterns as fallback
+     * OpenRouter proxies models with varying tool support. Use cached
+     * capabilities when available (populated by `cacheModelCapabilities()`),
+     * otherwise fall back to a conservative known-capable pattern list and
+     * disable tools for unknown models.
      */
     supportsTools(): boolean;
     /**
-     * Provider-specific streaming implementation
-     * Note: This is only used when tools are disabled
+     * Models/capabilities endpoint, derived from the configured `baseURL` so a
+     * custom OpenRouter-compatible gateway is honoured for discovery too.
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
+    private getModelsUrl;
     /**
-     * Get available models from OpenRouter API
-     * Dynamically fetches from /api/v1/models endpoint with caching and fallback
+     * Get available models from the OpenRouter `/models` endpoint, with a
+     * 10-minute cache and a hardcoded fallback when the fetch fails.
      */
     getAvailableModels(): Promise<string[]>;
     /**
-     * Fetch available models from OpenRouter API /api/v1/models endpoint
+     * Fetch available models from the OpenRouter `/models` endpoint.
      * @private
      */
     private fetchModelsFromAPI;
     /**
-     * Type guard to validate the models API response structure
+     * Type guard to validate the models API response structure.
      * @private
      */
     private isValidModelsResponse;
     /**
-     * Fetch and cache model capabilities from OpenRouter API
-     * Call this to enable accurate tool support detection
+     * Fetch and cache model capabilities from the OpenRouter `/models` endpoint.
+     * Call this to enable accurate per-model tool support detection.
      */
     cacheModelCapabilities(): Promise<void>;
 }