@juspay/neurolink 7.7.1 → 7.9.0

package/dist/lib/providers/amazonSagemaker.js

@@ -0,0 +1,149 @@
+/**
+ * Amazon SageMaker Provider Implementation (Simplified)
+ *
+ * This module provides a simplified SageMaker provider that extends BaseProvider
+ * and integrates with the NeuroLink ecosystem using existing patterns.
+ */
+import { BaseProvider } from "../core/baseProvider.js";
+import { logger } from "../utils/logger.js";
+// SageMaker-specific imports
+import { getSageMakerConfig, getSageMakerModelConfig, getDefaultSageMakerEndpoint, getSageMakerModel, } from "./sagemaker/config.js";
+import { handleSageMakerError, SageMakerError } from "./sagemaker/errors.js";
+import { SageMakerLanguageModel } from "./sagemaker/language-model.js";
+/**
+ * Amazon SageMaker Provider extending BaseProvider
+ */
+export class AmazonSageMakerProvider extends BaseProvider {
+    sagemakerModel;
+    sagemakerConfig;
+    modelConfig;
+    constructor(modelName, endpointName) {
+        super(modelName, "sagemaker");
+        try {
+            // Load and validate configuration
+            this.sagemakerConfig = getSageMakerConfig();
+            this.modelConfig = getSageMakerModelConfig(endpointName || getDefaultSageMakerEndpoint());
+            // Create the proper LanguageModel (v2) implementation
+            this.sagemakerModel = new SageMakerLanguageModel(this.modelName, this.sagemakerConfig, this.modelConfig);
+            logger.debug("Amazon SageMaker Provider initialized", {
+                modelName: this.modelName,
+                endpointName: this.modelConfig.endpointName,
+                region: this.sagemakerConfig.region,
+                provider: this.providerName,
+            });
+        }
+        catch (error) {
+            logger.error("Failed to initialize SageMaker provider", {
+                error: error instanceof Error ? error.message : String(error),
+                modelName,
+                endpointName,
+            });
+            throw handleSageMakerError(error);
+        }
+    }
+    getProviderName() {
+        return "sagemaker";
+    }
+    getDefaultModel() {
+        return getSageMakerModel();
+    }
+    getAISDKModel() {
+        return this.sagemakerModel;
+    }
+    async executeStream(options, analysisSchema) {
+        try {
+            // For now, throw an error indicating this is not yet implemented
+            throw new SageMakerError("SageMaker streaming not yet fully implemented. Coming in next phase.", "MODEL_ERROR", 501, undefined, this.modelConfig.endpointName);
+        }
+        catch (error) {
+            throw this.handleProviderError(error);
+        }
+    }
+    handleProviderError(error) {
+        if (error instanceof SageMakerError) {
+            return error;
+        }
+        if (error instanceof Error && error.name === "TimeoutError") {
+            return new SageMakerError(`SageMaker request timed out. Consider increasing timeout.`, "NETWORK_ERROR", 408, error, this.modelConfig.endpointName);
+        }
+        return handleSageMakerError(error, this.modelConfig.endpointName);
+    }
+    /**
+     * Get SageMaker-specific provider information
+     */
+    getSageMakerInfo() {
+        return {
+            endpointName: this.modelConfig.endpointName,
+            modelType: this.modelConfig.modelType || "custom",
+            region: this.sagemakerConfig.region,
+            configured: !!(this.sagemakerConfig.accessKeyId && this.sagemakerConfig.secretAccessKey),
+        };
+    }
+    /**
+     * Test basic configuration
+     */
+    async testConnection() {
+        try {
+            // Basic validation test
+            if (!this.sagemakerConfig.accessKeyId ||
+                !this.sagemakerConfig.secretAccessKey) {
+                return {
+                    connected: false,
+                    error: "AWS credentials not configured",
+                };
+            }
+            if (!this.modelConfig.endpointName ||
+                this.modelConfig.endpointName === "default-endpoint") {
+                return {
+                    connected: false,
+                    error: "SageMaker endpoint not configured",
+                };
+            }
+            // For now, just return that configuration looks valid
+            return {
+                connected: true,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Public method to get the AI SDK model for CLI and external usage
+     */
+    async getModel() {
+        return this.getAISDKModel();
+    }
+    /**
+     * Test connectivity to the SageMaker endpoint
+     */
+    async testConnectivity() {
+        const model = this.sagemakerModel;
+        return model.testConnectivity
+            ? await model.testConnectivity()
+            : { success: false, error: "Test method not available" };
+    }
+    /**
+     * Get model capabilities and information
+     */
+    getModelCapabilities() {
+        const model = this.sagemakerModel;
+        return model.getModelCapabilities
+            ? model.getModelCapabilities()
+            : {
+                capabilities: {
+                    streaming: true,
+                    toolCalling: true,
+                    structuredOutput: true,
+                    batchInference: true,
+                    supportedResponseFormats: ["text", "json_object"],
+                    supportedToolTypes: ["function"],
+                    maxBatchSize: 10,
+                },
+            };
+    }
+}
+export default AmazonSageMakerProvider;

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

@@ -108,6 +108,10 @@ export declare class GoogleVertexProvider extends BaseProvider {
             maxTokens: number;
         };
     };
+    /**
+     * Get model suggestions when a model is not found
+     */
+    private getModelSuggestions;
 }
 export default GoogleVertexProvider;
 export { GoogleVertexProvider as GoogleVertexAI };

package/dist/lib/providers/googleVertex.js

@@ -40,9 +40,9 @@ const getVertexLocation = () => {
         "us-central1");
 };
 const getDefaultVertexModel = () => {
-    // Use gemini-1.5-pro as default - stable and widely supported model
+    // Use gemini-2.5-flash as default - latest and best price-performance model
     // Override with VERTEX_MODEL environment variable if needed
-    return process.env.VERTEX_MODEL || "gemini-1.5-pro";
+    return process.env.VERTEX_MODEL || "gemini-2.5-flash";
 };
 const hasGoogleCredentials = () => {
     return !!(process.env.GOOGLE_APPLICATION_CREDENTIALS ||
@@ -276,7 +276,8 @@ export class GoogleVertexProvider extends BaseProvider {
             return new Error(`❌ Google Vertex AI Permission Denied\n\nYour Google Cloud credentials don't have permission to access Vertex AI.\n\nRequired Steps:\n1. Ensure your service account has Vertex AI User role\n2. Check if Vertex AI API is enabled in your project\n3. Verify your project ID is correct\n4. Confirm your location/region has Vertex AI available`);
         }
         if (message.includes("NOT_FOUND")) {
-            return new Error(`❌ Google Vertex AI Model Not Found\n\n${message}\n\nCheck:\n1. Model name is correct (e.g., 'gemini-1.5-pro')\n2. Model is available in your region (${this.location})\n3. Your project has access to the model\n4. Model supports your request parameters`);
+            const modelSuggestions = this.getModelSuggestions(this.modelName);
+            return new Error(`❌ Google Vertex AI Model Not Found\n\n${message}\n\nModel '${this.modelName}' is not available.\n\nSuggested alternatives:\n${modelSuggestions}\n\nTroubleshooting:\n1. Check model name spelling and format\n2. Verify model is available in your region (${this.location})\n3. Ensure your project has access to the model\n4. For Claude models, enable Anthropic integration in Google Cloud Console`);
         }
         if (message.includes("QUOTA_EXCEEDED")) {
             return new Error(`❌ Google Vertex AI Quota Exceeded\n\n${message}\n\nSolutions:\n1. Check your Vertex AI quotas in Google Cloud Console\n2. Request quota increase if needed\n3. Try a different model or reduce request frequency\n4. Consider using a different region`);
@@ -520,6 +521,46 @@ export class GoogleVertexProvider extends BaseProvider {
             },
         };
     }
+    /**
+     * Get model suggestions when a model is not found
+     */
+    getModelSuggestions(requestedModel) {
+        const availableModels = {
+            google: [
+                "gemini-2.5-pro",
+                "gemini-2.5-flash",
+                "gemini-2.5-flash-lite",
+                "gemini-2.0-flash-001",
+                "gemini-1.5-pro",
+                "gemini-1.5-flash"
+            ],
+            claude: [
+                "claude-sonnet-4@20250514",
+                "claude-opus-4@20250514",
+                "claude-3-5-sonnet-20241022",
+                "claude-3-5-haiku-20241022",
+                "claude-3-sonnet-20240229",
+                "claude-3-haiku-20240307",
+                "claude-3-opus-20240229",
+            ],
+        };
+        let suggestions = "\n🤖 Google Models (always available):\n";
+        availableModels.google.forEach((model) => {
+            suggestions += `  • ${model}\n`;
+        });
+        suggestions += "\n🧠 Claude Models (requires Anthropic integration):\n";
+        availableModels.claude.forEach((model) => {
+            suggestions += `  • ${model}\n`;
+        });
+        // If the requested model looks like a Claude model, provide specific guidance
+        if (requestedModel && requestedModel.toLowerCase().includes("claude")) {
+            suggestions += `\n💡 Tip: "${requestedModel}" appears to be a Claude model.\n`;
+            suggestions +=
+                "Ensure Anthropic integration is enabled in your Google Cloud project.\n";
+            suggestions += "Try using an available Claude model from the list above.";
+        }
+        return suggestions;
+    }
 }
 export default GoogleVertexProvider;
 // Re-export for compatibility

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

@@ -4,6 +4,7 @@
  */
 export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex.js";
 export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock.js";
+export { AmazonSageMakerProvider as AmazonSageMaker } from "./amazonSagemaker.js";
 export { OpenAIProvider as OpenAI } from "./openAI.js";
 export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible.js";
 export { AnthropicProvider as AnthropicProvider } from "./anthropic.js";
@@ -12,6 +13,7 @@ export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio.js";
 export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
 export { OllamaProvider as Ollama } from "./ollama.js";
 export { MistralProvider as MistralAI } from "./mistral.js";
+export { LiteLLMProvider as LiteLLM } from "./litellm.js";
 export type { AIProvider } from "../core/types.js";
 /**
  * Provider registry for dynamic provider instantiation
@@ -19,6 +21,7 @@ export type { AIProvider } from "../core/types.js";
 export declare const PROVIDERS: {
     readonly vertex: "GoogleVertexAI";
     readonly bedrock: "AmazonBedrock";
+    readonly sagemaker: "AmazonSageMaker";
     readonly openai: "OpenAI";
     readonly "openai-compatible": "OpenAICompatible";
     readonly anthropic: "AnthropicProvider";
@@ -27,6 +30,7 @@ export declare const PROVIDERS: {
     readonly huggingface: "HuggingFace";
     readonly ollama: "Ollama";
     readonly mistral: "MistralAI";
+    readonly litellm: "LiteLLM";
 };
 /**
  * Type for valid provider names

package/dist/lib/providers/index.js

@@ -4,6 +4,7 @@
  */
 export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex.js";
 export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock.js";
+export { AmazonSageMakerProvider as AmazonSageMaker } from "./amazonSagemaker.js";
 export { OpenAIProvider as OpenAI } from "./openAI.js";
 export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible.js";
 export { AnthropicProvider as AnthropicProvider } from "./anthropic.js";
@@ -12,12 +13,14 @@ export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio.js";
 export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
 export { OllamaProvider as Ollama } from "./ollama.js";
 export { MistralProvider as MistralAI } from "./mistral.js";
+export { LiteLLMProvider as LiteLLM } from "./litellm.js";
 /**
  * Provider registry for dynamic provider instantiation
  */
 export const PROVIDERS = {
     vertex: "GoogleVertexAI",
     bedrock: "AmazonBedrock",
+    sagemaker: "AmazonSageMaker",
     openai: "OpenAI",
     "openai-compatible": "OpenAICompatible",
     anthropic: "AnthropicProvider",
@@ -26,6 +29,7 @@ export const PROVIDERS = {
     huggingface: "HuggingFace",
     ollama: "Ollama",
     mistral: "MistralAI",
+    litellm: "LiteLLM",
 };
 /**
  * List of all available provider names

package/dist/lib/providers/sagemaker/adaptive-semaphore.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */
+export interface AdaptiveSemaphoreConfig {
+    initialConcurrency: number;
+    maxConcurrency: number;
+    minConcurrency: number;
+}
+export interface AdaptiveSemaphoreMetrics {
+    activeRequests: number;
+    currentConcurrency: number;
+    completedCount: number;
+    errorCount: number;
+    averageResponseTime: number;
+    waitingCount: number;
+}
+/**
+ * Adaptive semaphore that automatically adjusts concurrency based on performance metrics
+ */
+export declare class AdaptiveSemaphore {
+    private count;
+    private waiters;
+    private currentConcurrency;
+    private activeRequests;
+    private completedCount;
+    private errorCount;
+    private responseTimes;
+    private readonly maxConcurrency;
+    private readonly minConcurrency;
+    constructor(config: AdaptiveSemaphoreConfig);
+    /**
+     * Acquire a semaphore permit, waiting if necessary
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release a semaphore permit and wake up waiting requests
+     */
+    release(): void;
+    /**
+     * Record successful completion with response time for adaptive adjustment
+     */
+    recordSuccess(responseTimeMs: number): void;
+    /**
+     * Record error for adaptive adjustment
+     */
+    recordError(responseTimeMs?: number): void;
+    /**
+     * Manually adjust concurrency level
+     */
+    adjustConcurrency(newLimit: number): void;
+    /**
+     * Get current performance metrics
+     */
+    getMetrics(): AdaptiveSemaphoreMetrics;
+    /**
+     * Reset metrics for new batch or session
+     */
+    resetMetrics(): void;
+    /**
+     * Automatically adjust concurrency based on performance indicators
+     */
+    private adjustConcurrencyBasedOnPerformance;
+    /**
+     * Check if semaphore is idle (no active or waiting requests)
+     */
+    isIdle(): boolean;
+    /**
+     * Get current concurrency limit
+     */
+    getCurrentConcurrency(): number;
+    /**
+     * Get number of active requests
+     */
+    getActiveRequestCount(): number;
+    /**
+     * Get number of waiting requests
+     */
+    getWaitingRequestCount(): number;
+}
+/**
+ * Factory function to create an adaptive semaphore with default configuration
+ */
+export declare function createAdaptiveSemaphore(initialConcurrency: number, maxConcurrency?: number, minConcurrency?: number): AdaptiveSemaphore;

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

@@ -0,0 +1,212 @@
+/**
+ * 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();
+            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();
+            this.count--;
+            this.activeRequests++;
+            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,
+    });
+}