@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/providers/openaiCompatible.js

@@ -1,290 +0,0 @@
-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

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,215 +0,0 @@
-/**
- * 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,
-    });
-}