@juspay/neurolink 9.30.0 → 9.31.0

package/dist/client/providers/openaiCompatible.js

@@ -0,0 +1,290 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { NoOutputGeneratedError, streamText, } from "ai";
+import { BaseProvider } from "../core/baseProvider.js";
+import { logger } from "../utils/logger.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
+// Constants
+const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
+// Configuration helpers
+const getOpenAICompatibleConfig = () => {
+    const baseURL = process.env.OPENAI_COMPATIBLE_BASE_URL;
+    const apiKey = process.env.OPENAI_COMPATIBLE_API_KEY;
+    if (!baseURL) {
+        throw new Error("OPENAI_COMPATIBLE_BASE_URL environment variable is required. " +
+            "Please set it to your OpenAI-compatible endpoint (e.g., https://api.openrouter.ai/api/v1)");
+    }
+    if (!apiKey) {
+        throw new Error("OPENAI_COMPATIBLE_API_KEY environment variable is required. " +
+            "Please set it to your API key for the OpenAI-compatible service.");
+    }
+    return {
+        baseURL,
+        apiKey,
+    };
+};
+/**
+ * Returns the default model name for OpenAI Compatible endpoints.
+ *
+ * Returns undefined if no model is specified via OPENAI_COMPATIBLE_MODEL environment variable,
+ * which triggers auto-discovery from the /v1/models endpoint.
+ */
+const getDefaultOpenAICompatibleModel = () => {
+    return process.env.OPENAI_COMPATIBLE_MODEL || undefined;
+};
+// ModelsResponse type now imported from ../types/providerSpecific.js
+/**
+ * OpenAI Compatible Provider - BaseProvider Implementation
+ * Provides access to one of the OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ */
+export class OpenAICompatibleProvider extends BaseProvider {
+    model;
+    config;
+    discoveredModel;
+    customOpenAI;
+    constructor(modelName, sdk) {
+        super(modelName, "openai-compatible", sdk);
+        // Initialize OpenAI Compatible configuration
+        this.config = getOpenAICompatibleConfig();
+        // Create OpenAI SDK instance configured for custom endpoint
+        // This allows us to use OpenAI-compatible API by simply changing the baseURL
+        this.customOpenAI = createOpenAI({
+            baseURL: this.config.baseURL,
+            apiKey: this.config.apiKey,
+            fetch: createProxyFetch(),
+        });
+        logger.debug("OpenAI Compatible Provider initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+            baseURL: this.config.baseURL,
+        });
+    }
+    getProviderName() {
+        return "openai-compatible";
+    }
+    getDefaultModel() {
+        // Return empty string when no model is explicitly configured to enable auto-discovery
+        return getDefaultOpenAICompatibleModel() || "";
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for OpenAI Compatible endpoints
+     * Handles auto-discovery if no model was specified
+     */
+    async getAISDKModel() {
+        // If model instance doesn't exist yet, create it
+        if (!this.model) {
+            let modelToUse;
+            // Check if a model was explicitly specified via constructor or env var
+            const explicitModel = this.modelName || getDefaultOpenAICompatibleModel();
+            // Treat empty string as no model specified (trigger auto-discovery)
+            if (explicitModel && explicitModel.trim() !== "") {
+                // Use the explicitly specified model
+                modelToUse = explicitModel;
+                logger.debug(`Using specified model: ${modelToUse}`);
+            }
+            else {
+                // No model specified, auto-discover from endpoint
+                try {
+                    const availableModels = await this.getAvailableModels();
+                    if (availableModels.length > 0) {
+                        this.discoveredModel = availableModels[0];
+                        modelToUse = this.discoveredModel;
+                        logger.info(`🔍 Auto-discovered model: ${modelToUse} from ${availableModels.length} available models`);
+                    }
+                    else {
+                        // Fall back to a common default if no models discovered
+                        modelToUse = FALLBACK_OPENAI_COMPATIBLE_MODEL;
+                        logger.warn(`No models discovered, using fallback: ${modelToUse}`);
+                    }
+                }
+                catch (error) {
+                    logger.warn("Model auto-discovery failed, using fallback:", error);
+                    modelToUse = FALLBACK_OPENAI_COMPATIBLE_MODEL;
+                }
+            }
+            // Create the model instance
+            this.model = this.customOpenAI(modelToUse);
+        }
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`OpenAI Compatible request timed out: ${error.message}`);
+        }
+        // Check for timeout by error name and message as fallback
+        const errorRecord = error;
+        if (errorRecord?.name === "TimeoutError" ||
+            (typeof errorRecord?.message === "string" &&
+                errorRecord.message.includes("Timeout"))) {
+            return new Error(`OpenAI Compatible request timed out: ${errorRecord?.message || "Unknown timeout"}`);
+        }
+        if (typeof errorRecord?.message === "string") {
+            if (errorRecord.message.includes("ECONNREFUSED") ||
+                errorRecord.message.includes("Failed to fetch")) {
+                return new Error(`OpenAI Compatible endpoint not available. Please check your OPENAI_COMPATIBLE_BASE_URL: ${this.config.baseURL}`);
+            }
+            if (errorRecord.message.includes("API_KEY_INVALID") ||
+                errorRecord.message.includes("Invalid API key") ||
+                errorRecord.message.includes("Unauthorized")) {
+                return new Error("Invalid OpenAI Compatible API key. Please check your OPENAI_COMPATIBLE_API_KEY environment variable.");
+            }
+            if (errorRecord.message.includes("rate limit")) {
+                return new Error("OpenAI Compatible rate limit exceeded. Please try again later.");
+            }
+            if (errorRecord.message.includes("model") &&
+                (errorRecord.message.includes("not found") ||
+                    errorRecord.message.includes("does not exist"))) {
+                return new Error(`Model '${this.modelName}' not available on OpenAI Compatible endpoint. ` +
+                    "Please check available models or use getAvailableModels() to see supported models.");
+            }
+        }
+        return new Error(`OpenAI Compatible error: ${errorRecord?.message || "Unknown error"}`);
+    }
+    /**
+     * OpenAI Compatible endpoints support tools for compatible models
+     */
+    supportsTools() {
+        return true;
+    }
+    /**
+     * Provider-specific streaming implementation
+     * Note: This is only used when tools are disabled
+     */
+    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!
+            const result = streamText({
+                model,
+                messages: messages,
+                ...(options.maxTokens !== null && options.maxTokens !== undefined
+                    ? { maxOutputTokens: options.maxTokens }
+                    : {}),
+                ...(options.temperature !== null && options.temperature !== undefined
+                    ? { temperature: options.temperature }
+                    : {}),
+                tools,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                onStepFinish: (event) => {
+                    this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
+                        logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
+            });
+            timeoutController?.cleanup();
+            // Transform stream to match StreamResult interface
+            const transformedStream = async function* () {
+                try {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                }
+                catch (streamError) {
+                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    if (NoOutputGeneratedError.isInstance(streamError)) {
+                        logger.warn("OpenAI-compatible: Stream produced no output (NoOutputGeneratedError)");
+                        return;
+                    }
+                    throw streamError;
+                }
+            };
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
+                requestId: `openai-compatible-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `openai-compatible-${Date.now()}`,
+                },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    /**
+     * Get available models from OpenAI Compatible endpoint
+     *
+     * Fetches from the /v1/models endpoint to discover available models.
+     * This is useful for auto-discovery when no model is specified.
+     */
+    async getAvailableModels() {
+        try {
+            const modelsUrl = new URL("/v1/models", this.config.baseURL).toString();
+            logger.debug(`Fetching available models from: ${modelsUrl}`);
+            const proxyFetch = createProxyFetch();
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), 5000);
+            const response = await proxyFetch(modelsUrl, {
+                headers: {
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(t);
+            if (!response.ok) {
+                logger.warn(`Models endpoint returned ${response.status}: ${response.statusText}`);
+                return this.getFallbackModels();
+            }
+            const data = await response.json();
+            if (!data.data || !Array.isArray(data.data)) {
+                logger.warn("Invalid models response format");
+                return this.getFallbackModels();
+            }
+            const models = data.data.map((model) => model.id).filter(Boolean);
+            logger.debug(`Discovered ${models.length} models:`, models);
+            return models.length > 0 ? models : this.getFallbackModels();
+        }
+        catch (error) {
+            logger.warn(`Failed to fetch models from OpenAI Compatible endpoint:`, error);
+            return this.getFallbackModels();
+        }
+    }
+    /**
+     * Get the first available model for auto-selection
+     */
+    async getFirstAvailableModel() {
+        const models = await this.getAvailableModels();
+        return models[0] || FALLBACK_OPENAI_COMPATIBLE_MODEL;
+    }
+    /**
+     * Fallback models when discovery fails
+     */
+    getFallbackModels() {
+        return [
+            "gpt-4o",
+            "gpt-4o-mini",
+            "gpt-4-turbo",
+            FALLBACK_OPENAI_COMPATIBLE_MODEL,
+            "claude-3-5-sonnet",
+            "claude-3-haiku",
+            "gemini-pro",
+        ];
+    }
+}

package/dist/client/providers/providerTypeUtils.js

@@ -0,0 +1,46 @@
+/**
+ * Shared type utilities for AI SDK provider integration.
+ *
+ * Provides type-safe helpers to bridge between the AI SDK's generic types
+ * and NeuroLink's internal type system without resorting to `as any` casts.
+ */
+/**
+ * Type guard: checks whether a LanguageModel value is an object with `modelId`
+ * (i.e. LanguageModelV2 or LanguageModelV3) rather than a bare string ID.
+ */
+function isLanguageModelObject(model) {
+    return typeof model === "object" && model !== null && "modelId" in model;
+}
+/**
+ * Extract the model identifier from a LanguageModel value.
+ *
+ * `LanguageModel` in AI SDK v6 is `string | LanguageModelV2 | LanguageModelV3`.
+ * When it's a string it IS the model ID; when it's an object, `.modelId` holds it.
+ *
+ * @param model  - The LanguageModel value (string or object).
+ * @param fallback - Value returned when the model ID cannot be determined.
+ */
+export function getModelId(model, fallback = "unknown") {
+    if (typeof model === "string") {
+        return model;
+    }
+    if (isLanguageModelObject(model)) {
+        return model.modelId;
+    }
+    return fallback;
+}
+/**
+ * Adapt an AI SDK `StreamTextResult` (generic, parameterised by TOOLS & OUTPUT)
+ * to the simpler NeuroLink `StreamTextResult` expected by the analytics collector.
+ *
+ * The AI SDK result is a structural superset of our local type — every field our
+ * analytics code reads (`textStream`, `text`, `usage`, `response`, `finishReason`,
+ * `toolResults`, `toolCalls`) exists on the SDK result with compatible types.
+ * This function performs the structural down-cast without `as any`.
+ */
+export function toAnalyticsStreamResult(result) {
+    // The AI SDK v6 result is a structural superset of our StreamTextResult.
+    // Both use PromiseLike for async fields and compatible usage shapes
+    // (extractTokenUsage handles both v4 and v6 field names).
+    return result;
+}

package/dist/client/providers/sagemaker/adaptive-semaphore.js

@@ -0,0 +1,215 @@
+/**
+ * Adaptive Semaphore Utility
+ *
+ * Provides a sophisticated semaphore implementation with dynamic concurrency adjustment
+ * for optimal resource utilization and performance tuning based on response times and error rates.
+ */
+import { logger } from "../../utils/logger.js";
+/**
+ * Adaptive semaphore that automatically adjusts concurrency based on performance metrics
+ */
+export class AdaptiveSemaphore {
+    count;
+    waiters = [];
+    currentConcurrency;
+    activeRequests = 0;
+    completedCount = 0;
+    errorCount = 0;
+    responseTimes = [];
+    maxConcurrency;
+    minConcurrency;
+    constructor(config) {
+        this.currentConcurrency = config.initialConcurrency;
+        this.count = config.initialConcurrency;
+        this.maxConcurrency = config.maxConcurrency;
+        this.minConcurrency = config.minConcurrency;
+        logger.debug("AdaptiveSemaphore initialized", {
+            initialConcurrency: config.initialConcurrency,
+            maxConcurrency: config.maxConcurrency,
+            minConcurrency: config.minConcurrency,
+        });
+    }
+    /**
+     * Acquire a semaphore permit, waiting if necessary
+     */
+    async acquire() {
+        return new Promise((resolve) => {
+            if (this.count > 0) {
+                this.count--;
+                this.activeRequests++;
+                resolve();
+            }
+            else {
+                this.waiters.push(() => {
+                    this.count--;
+                    this.activeRequests++;
+                    resolve();
+                });
+            }
+        });
+    }
+    /**
+     * Release a semaphore permit and wake up waiting requests
+     */
+    release() {
+        this.activeRequests--;
+        if (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            if (waiter) {
+                this.count++; // Increment count before calling waiter so waiter can decrement it
+                waiter();
+            }
+        }
+        else {
+            this.count++;
+        }
+    }
+    /**
+     * Record successful completion with response time for adaptive adjustment
+     */
+    recordSuccess(responseTimeMs) {
+        this.completedCount++;
+        this.responseTimes.push(responseTimeMs);
+        // Keep only recent response times for calculation (last 10 responses)
+        if (this.responseTimes.length > 10) {
+            this.responseTimes.shift();
+        }
+        this.adjustConcurrencyBasedOnPerformance(responseTimeMs, false);
+    }
+    /**
+     * Record error for adaptive adjustment
+     */
+    recordError(responseTimeMs) {
+        this.errorCount++;
+        if (responseTimeMs) {
+            this.responseTimes.push(responseTimeMs);
+            if (this.responseTimes.length > 10) {
+                this.responseTimes.shift();
+            }
+        }
+        this.adjustConcurrencyBasedOnPerformance(responseTimeMs || 0, true);
+    }
+    /**
+     * Manually adjust concurrency level
+     */
+    adjustConcurrency(newLimit) {
+        const clampedLimit = Math.max(this.minConcurrency, Math.min(this.maxConcurrency, newLimit));
+        const diff = clampedLimit - (this.currentConcurrency - this.count);
+        this.count += diff;
+        this.currentConcurrency = clampedLimit;
+        logger.debug("Concurrency adjusted", {
+            newConcurrency: clampedLimit,
+            previousConcurrency: this.currentConcurrency - diff,
+            availableCount: this.count,
+            activeRequests: this.activeRequests,
+        });
+        // Wake up waiting requests if we increased concurrency
+        while (this.count > 0 && this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            if (waiter) {
+                waiter();
+            }
+        }
+    }
+    /**
+     * Get current performance metrics
+     */
+    getMetrics() {
+        const averageResponseTime = this.responseTimes.length > 0
+            ? this.responseTimes.reduce((sum, time) => sum + time, 0) /
+                this.responseTimes.length
+            : 0;
+        return {
+            activeRequests: this.activeRequests,
+            currentConcurrency: this.currentConcurrency,
+            completedCount: this.completedCount,
+            errorCount: this.errorCount,
+            averageResponseTime,
+            waitingCount: this.waiters.length,
+        };
+    }
+    /**
+     * Reset metrics for new batch or session
+     */
+    resetMetrics() {
+        this.completedCount = 0;
+        this.errorCount = 0;
+        this.responseTimes = [];
+    }
+    /**
+     * Automatically adjust concurrency based on performance indicators
+     */
+    adjustConcurrencyBasedOnPerformance(responseTimeMs, isError) {
+        const metrics = this.getMetrics();
+        if (isError) {
+            // On error, reduce concurrency to be more conservative
+            if (this.currentConcurrency > this.minConcurrency) {
+                this.adjustConcurrency(Math.max(this.minConcurrency, this.currentConcurrency - 1));
+                logger.warn("Reduced concurrency due to error", {
+                    newConcurrency: this.currentConcurrency,
+                    errorCount: this.errorCount,
+                });
+            }
+            return;
+        }
+        // Only adjust after we have some data to work with
+        if (this.completedCount < 3) {
+            return;
+        }
+        const fastResponseThreshold = 2000; // 2 seconds
+        const slowResponseThreshold = 5000; // 5 seconds
+        if (responseTimeMs < fastResponseThreshold &&
+            metrics.averageResponseTime < fastResponseThreshold &&
+            this.currentConcurrency < this.maxConcurrency) {
+            // Fast responses and no bottleneck - increase concurrency
+            this.adjustConcurrency(Math.min(this.maxConcurrency, this.currentConcurrency + 1));
+            logger.debug("Increased concurrency due to fast responses", {
+                newConcurrency: this.currentConcurrency,
+                averageResponseTime: metrics.averageResponseTime,
+            });
+        }
+        else if (responseTimeMs > slowResponseThreshold &&
+            this.currentConcurrency > this.minConcurrency) {
+            // Slow responses - decrease concurrency
+            this.adjustConcurrency(Math.max(this.minConcurrency, this.currentConcurrency - 1));
+            logger.debug("Decreased concurrency due to slow responses", {
+                newConcurrency: this.currentConcurrency,
+                responseTime: responseTimeMs,
+            });
+        }
+    }
+    /**
+     * Check if semaphore is idle (no active or waiting requests)
+     */
+    isIdle() {
+        return this.activeRequests === 0 && this.waiters.length === 0;
+    }
+    /**
+     * Get current concurrency limit
+     */
+    getCurrentConcurrency() {
+        return this.currentConcurrency;
+    }
+    /**
+     * Get number of active requests
+     */
+    getActiveRequestCount() {
+        return this.activeRequests;
+    }
+    /**
+     * Get number of waiting requests
+     */
+    getWaitingRequestCount() {
+        return this.waiters.length;
+    }
+}
+/**
+ * Factory function to create an adaptive semaphore with default configuration
+ */
+export function createAdaptiveSemaphore(initialConcurrency, maxConcurrency = 10, minConcurrency = 1) {
+    return new AdaptiveSemaphore({
+        initialConcurrency,
+        maxConcurrency,
+        minConcurrency,
+    });
+}