@juspay/neurolink 7.7.0 → 7.8.0

package/dist/cli/factories/commandFactory.js

@@ -28,6 +28,7 @@ export class CLICommandFactory {
                 "ollama",
                 "mistral",
                 "litellm",
+                "sagemaker",
             ],
             default: "auto",
             description: "AI provider to use (auto-selects best available)",

package/dist/cli/index.js

@@ -9,6 +9,7 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import chalk from "chalk";
 import { addOllamaCommands } from "./commands/ollama.js";
+import { addSageMakerCommands } from "./commands/sagemaker.js";
 import { CLICommandFactory } from "./factories/commandFactory.js";
 import { logger } from "../lib/utils/logger.js";
 // Load environment variables from .env file
@@ -228,6 +229,8 @@ const cli = yargs(args)
     .command(CLICommandFactory.createCompletionCommand());
 // Add Ollama Commands
 addOllamaCommands(cli);
+// Add SageMaker Commands
+addSageMakerCommands(cli);
 // Execute CLI
 (async () => {
     try {

package/dist/cli/utils/interactiveSetup.js

@@ -176,6 +176,34 @@ export const PROVIDER_CONFIGS = [
             },
         ],
     },
+    {
+        id: AIProviderName.SAGEMAKER,
+        name: "Amazon SageMaker",
+        description: "Custom models deployed on Amazon SageMaker endpoints",
+        envVars: [
+            {
+                key: "AWS_ACCESS_KEY_ID",
+                prompt: "AWS Access Key ID",
+                secure: true,
+            },
+            {
+                key: "AWS_SECRET_ACCESS_KEY",
+                prompt: "AWS Secret Access Key",
+                secure: true,
+            },
+            {
+                key: "AWS_REGION",
+                prompt: "AWS Region",
+                default: "us-east-1",
+                secure: false,
+            },
+            {
+                key: "SAGEMAKER_DEFAULT_ENDPOINT",
+                prompt: "SageMaker Endpoint Name",
+                secure: false,
+            },
+        ],
+    },
 ];
 /**
  * Run the interactive setup wizard

package/dist/core/baseProvider.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
-import type { Tool, LanguageModel } from "ai";
+import type { Tool, LanguageModelV1 } from "ai";
 import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue, UnknownRecord } from "../types/common.js";
@@ -419,7 +419,7 @@ export declare abstract class BaseProvider implements AIProvider {
      * REQUIRED: Every provider MUST implement this method
      * Returns the Vercel AI SDK model instance for this provider
      */
-    protected abstract getAISDKModel(): LanguageModel | Promise<LanguageModel>;
+    protected abstract getAISDKModel(): LanguageModelV1 | Promise<LanguageModelV1>;
     /**
      * Get all available tools - direct tools are ALWAYS available
      * MCP tools are added when available (without blocking)

package/dist/core/types.d.ts

@@ -51,6 +51,7 @@ export declare enum AIProviderName {
     OLLAMA = "ollama",
     MISTRAL = "mistral",
     LITELLM = "litellm",
+    SAGEMAKER = "sagemaker",
     AUTO = "auto"
 }
 /**

package/dist/core/types.js

@@ -14,6 +14,7 @@ export var AIProviderName;
     AIProviderName["OLLAMA"] = "ollama";
     AIProviderName["MISTRAL"] = "mistral";
     AIProviderName["LITELLM"] = "litellm";
+    AIProviderName["SAGEMAKER"] = "sagemaker";
     AIProviderName["AUTO"] = "auto";
 })(AIProviderName || (AIProviderName = {}));
 /**

package/dist/factories/providerRegistry.js

@@ -82,6 +82,11 @@ export class ProviderRegistry {
                 return new OpenAICompatibleProvider(modelName, sdk);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "openrouter", "vllm", "compatible"]);
+            // Register Amazon SageMaker provider
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, providerName, sdk) => {
+                const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
+                return new AmazonSageMakerProvider(modelName);
+            }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
             logger.debug("All providers registered successfully");
             this.registered = true;
         }

package/dist/lib/core/baseProvider.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
-import type { Tool, LanguageModel } from "ai";
+import type { Tool, LanguageModelV1 } from "ai";
 import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue, UnknownRecord } from "../types/common.js";
@@ -419,7 +419,7 @@ export declare abstract class BaseProvider implements AIProvider {
      * REQUIRED: Every provider MUST implement this method
      * Returns the Vercel AI SDK model instance for this provider
      */
-    protected abstract getAISDKModel(): LanguageModel | Promise<LanguageModel>;
+    protected abstract getAISDKModel(): LanguageModelV1 | Promise<LanguageModelV1>;
     /**
      * Get all available tools - direct tools are ALWAYS available
      * MCP tools are added when available (without blocking)

package/dist/lib/core/types.d.ts

@@ -51,6 +51,7 @@ export declare enum AIProviderName {
     OLLAMA = "ollama",
     MISTRAL = "mistral",
     LITELLM = "litellm",
+    SAGEMAKER = "sagemaker",
     AUTO = "auto"
 }
 /**

package/dist/lib/core/types.js

@@ -14,6 +14,7 @@ export var AIProviderName;
     AIProviderName["OLLAMA"] = "ollama";
     AIProviderName["MISTRAL"] = "mistral";
     AIProviderName["LITELLM"] = "litellm";
+    AIProviderName["SAGEMAKER"] = "sagemaker";
     AIProviderName["AUTO"] = "auto";
 })(AIProviderName || (AIProviderName = {}));
 /**

package/dist/lib/factories/providerRegistry.js

@@ -82,6 +82,11 @@ export class ProviderRegistry {
                 return new OpenAICompatibleProvider(modelName, sdk);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "openrouter", "vllm", "compatible"]);
+            // Register Amazon SageMaker provider
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, providerName, sdk) => {
+                const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
+                return new AmazonSageMakerProvider(modelName);
+            }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
             logger.debug("All providers registered successfully");
             this.registered = true;
         }

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

@@ -0,0 +1,67 @@
+/**
+ * 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 type { ZodType, ZodTypeDef } from "zod";
+import type { Schema, LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import { BaseProvider } from "../core/baseProvider.js";
+/**
+ * Amazon SageMaker Provider extending BaseProvider
+ */
+export declare class AmazonSageMakerProvider extends BaseProvider {
+    private sagemakerModel;
+    private sagemakerConfig;
+    private modelConfig;
+    constructor(modelName?: string, endpointName?: string);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected getAISDKModel(): LanguageModelV1;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected handleProviderError(error: unknown): Error;
+    /**
+     * Get SageMaker-specific provider information
+     */
+    getSageMakerInfo(): {
+        endpointName: string;
+        modelType: string;
+        region: string;
+        configured: boolean;
+    };
+    /**
+     * Test basic configuration
+     */
+    testConnection(): Promise<{
+        connected: boolean;
+        error?: string;
+    }>;
+    /**
+     * Public method to get the AI SDK model for CLI and external usage
+     */
+    getModel(): Promise<LanguageModelV1>;
+    /**
+     * Test connectivity to the SageMaker endpoint
+     */
+    testConnectivity(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get model capabilities and information
+     */
+    getModelCapabilities(): {
+        capabilities: {
+            streaming: boolean;
+            toolCalling: boolean;
+            structuredOutput: boolean;
+            batchInference: boolean;
+            supportedResponseFormats: string[];
+            supportedToolTypes: string[];
+            maxBatchSize: number;
+        };
+    };
+}
+export default AmazonSageMakerProvider;

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/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;