@juspay/neurolink 7.7.1 → 7.9.0

package/dist/lib/providers/sagemaker/types.d.ts

@@ -0,0 +1,456 @@
+/**
+ * TypeScript type definitions for Amazon SageMaker Provider
+ *
+ * This module contains all interfaces and types for SageMaker integration
+ * with the NeuroLink ecosystem and Vercel AI SDK compatibility.
+ */
+/**
+ * AWS configuration options for SageMaker client
+ */
+export interface SageMakerConfig {
+    /** AWS region for SageMaker service */
+    region: string;
+    /** AWS access key ID */
+    accessKeyId: string;
+    /** AWS secret access key */
+    secretAccessKey: string;
+    /** AWS session token (optional, for temporary credentials) */
+    sessionToken?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Custom SageMaker endpoint URL (optional) */
+    endpoint?: string;
+}
+/**
+ * Model-specific configuration for SageMaker endpoints
+ */
+export interface SageMakerModelConfig {
+    /** SageMaker endpoint name */
+    endpointName: string;
+    /** Model type for request/response formatting */
+    modelType?: "llama" | "mistral" | "claude" | "huggingface" | "jumpstart" | "custom";
+    /** Content type for requests */
+    contentType?: string;
+    /** Accept header for responses */
+    accept?: string;
+    /** Custom attributes for the endpoint */
+    customAttributes?: string;
+    /** Input format specification */
+    inputFormat?: "huggingface" | "jumpstart" | "custom";
+    /** Output format specification */
+    outputFormat?: "huggingface" | "jumpstart" | "custom";
+    /** Maximum tokens for generation */
+    maxTokens?: number;
+    /** Temperature parameter */
+    temperature?: number;
+    /** Top-p parameter */
+    topP?: number;
+    /** Stop sequences */
+    stopSequences?: string[];
+    /** Initial concurrency for batch processing */
+    initialConcurrency?: number;
+    /** Maximum concurrency for batch processing */
+    maxConcurrency?: number;
+    /** Minimum concurrency for batch processing */
+    minConcurrency?: number;
+    /** Maximum concurrent detection tests */
+    maxConcurrentDetectionTests?: number;
+}
+/**
+ * SageMaker endpoint information and metadata
+ */
+export interface SageMakerEndpointInfo {
+    /** Endpoint name */
+    endpointName: string;
+    /** Endpoint ARN */
+    endpointArn: string;
+    /** Associated model name */
+    modelName: string;
+    /** EC2 instance type */
+    instanceType: string;
+    /** Endpoint creation timestamp */
+    creationTime: string;
+    /** Last modification timestamp */
+    lastModifiedTime: string;
+    /** Current endpoint status */
+    endpointStatus: "InService" | "Creating" | "Updating" | "SystemUpdating" | "RollingBack" | "Deleting" | "Failed";
+    /** Current instance count */
+    currentInstanceCount?: number;
+    /** Variant weights for A/B testing */
+    productionVariants?: Array<{
+        variantName: string;
+        modelName: string;
+        initialInstanceCount: number;
+        instanceType: string;
+        currentWeight?: number;
+    }>;
+}
+/**
+ * Token usage and billing information
+ */
+export interface SageMakerUsage {
+    /** Number of prompt tokens */
+    promptTokens: number;
+    /** Number of completion tokens */
+    completionTokens: number;
+    /** Total tokens used */
+    totalTokens: number;
+    /** Request processing time in milliseconds */
+    requestTime?: number;
+    /** Model inference time in milliseconds */
+    inferenceTime?: number;
+    /** Estimated cost in USD */
+    estimatedCost?: number;
+}
+/**
+ * Parameters for SageMaker endpoint invocation
+ */
+export interface InvokeEndpointParams {
+    /** Endpoint name to invoke */
+    EndpointName: string;
+    /** Request body as string or Uint8Array */
+    Body: string | Uint8Array;
+    /** Content type of the request */
+    ContentType?: string;
+    /** Accept header for response format */
+    Accept?: string;
+    /** Custom attributes for the request */
+    CustomAttributes?: string;
+    /** Target model for multi-model endpoints */
+    TargetModel?: string;
+    /** Target variant for A/B testing */
+    TargetVariant?: string;
+    /** Inference ID for request tracking */
+    InferenceId?: string;
+}
+/**
+ * Response from SageMaker endpoint invocation
+ */
+export interface InvokeEndpointResponse {
+    /** Response body */
+    Body?: Uint8Array;
+    /** Content type of the response */
+    ContentType?: string;
+    /** Invoked production variant */
+    InvokedProductionVariant?: string;
+    /** Custom attributes in the response */
+    CustomAttributes?: string;
+}
+/**
+ * Streaming response chunk from SageMaker
+ */
+export interface SageMakerStreamChunk {
+    /** Text content in the chunk */
+    content?: string;
+    /** Indicates if this is the final chunk */
+    done?: boolean;
+    /** Usage information (only in final chunk) */
+    usage?: SageMakerUsage;
+    /** Error information if chunk contains error */
+    error?: string;
+    /** Finish reason for generation */
+    finishReason?: "stop" | "length" | "tool-calls" | "content-filter" | "unknown";
+    /** Tool call in progress (Phase 2.3) */
+    toolCall?: SageMakerStreamingToolCall;
+    /** Tool result chunk (Phase 2.3) */
+    toolResult?: SageMakerStreamingToolResult;
+    /** Structured output streaming (Phase 2.3) */
+    structuredOutput?: SageMakerStructuredOutput;
+}
+/**
+ * Tool call information for function calling
+ */
+export interface SageMakerToolCall {
+    /** Tool call identifier */
+    id: string;
+    /** Tool/function name */
+    name: string;
+    /** Tool arguments as JSON object */
+    arguments: Record<string, unknown>;
+    /** Tool call type */
+    type: "function";
+}
+/**
+ * Tool result information
+ */
+export interface SageMakerToolResult {
+    /** Tool call identifier */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Tool result data */
+    result: unknown;
+    /** Execution status */
+    status: "success" | "error";
+    /** Error message if status is error */
+    error?: string;
+}
+/**
+ * Streaming tool call information (Phase 2.3)
+ */
+export interface SageMakerStreamingToolCall {
+    /** Tool call identifier */
+    id: string;
+    /** Tool/function name */
+    name?: string;
+    /** Partial or complete arguments as JSON string */
+    arguments?: string;
+    /** Tool call type */
+    type: "function";
+    /** Indicates if this tool call is complete */
+    complete?: boolean;
+    /** Delta text for incremental argument building */
+    argumentsDelta?: string;
+}
+/**
+ * Streaming tool result information (Phase 2.3)
+ */
+export interface SageMakerStreamingToolResult {
+    /** Tool call identifier */
+    toolCallId: string;
+    /** Tool name */
+    toolName: string;
+    /** Partial or complete result data */
+    result?: unknown;
+    /** Result delta for incremental responses */
+    resultDelta?: string;
+    /** Execution status */
+    status: "pending" | "running" | "success" | "error";
+    /** Error message if status is error */
+    error?: string;
+    /** Indicates if this result is complete */
+    complete?: boolean;
+}
+/**
+ * Structured output streaming information (Phase 2.3)
+ */
+export interface SageMakerStructuredOutput {
+    /** Partial JSON object being built */
+    partialObject?: Record<string, unknown>;
+    /** JSON delta text */
+    jsonDelta?: string;
+    /** Current parsing path (e.g., "user.name") */
+    currentPath?: string;
+    /** Schema validation errors */
+    validationErrors?: string[];
+    /** Indicates if JSON is complete and valid */
+    complete?: boolean;
+    /** JSON schema being validated against */
+    schema?: Record<string, unknown>;
+}
+/**
+ * Enhanced generation request options
+ */
+export interface SageMakerGenerationOptions {
+    /** Input prompt text */
+    prompt: string;
+    /** System prompt for context */
+    systemPrompt?: string;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature for randomness (0-1) */
+    temperature?: number;
+    /** Top-p nucleus sampling (0-1) */
+    topP?: number;
+    /** Top-k sampling */
+    topK?: number;
+    /** Stop sequences to end generation */
+    stopSequences?: string[];
+    /** Enable streaming response */
+    stream?: boolean;
+    /** Tools available for function calling */
+    tools?: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+    /** Tool choice mode */
+    toolChoice?: "auto" | "none" | {
+        type: "tool";
+        name: string;
+    };
+}
+/**
+ * Generation response from SageMaker
+ */
+export interface SageMakerGenerationResponse {
+    /** Generated text content */
+    text: string;
+    /** Token usage information */
+    usage: SageMakerUsage;
+    /** Finish reason for generation */
+    finishReason: "stop" | "length" | "tool-calls" | "content-filter" | "unknown";
+    /** Tool calls made during generation */
+    toolCalls?: SageMakerToolCall[];
+    /** Tool results if tools were executed */
+    toolResults?: SageMakerToolResult[];
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Model version or identifier */
+    modelVersion?: string;
+}
+/**
+ * Error codes specific to SageMaker operations
+ */
+export type SageMakerErrorCode = "VALIDATION_ERROR" | "MODEL_ERROR" | "INTERNAL_ERROR" | "SERVICE_UNAVAILABLE" | "CREDENTIALS_ERROR" | "NETWORK_ERROR" | "ENDPOINT_NOT_FOUND" | "THROTTLING_ERROR" | "UNKNOWN_ERROR";
+/**
+ * SageMaker-specific error information
+ */
+export interface SageMakerErrorInfo {
+    /** Error code */
+    code: SageMakerErrorCode;
+    /** Human-readable error message */
+    message: string;
+    /** HTTP status code if applicable */
+    statusCode?: number;
+    /** Original error from AWS SDK */
+    cause?: Error;
+    /** Endpoint name where error occurred */
+    endpoint?: string;
+    /** Request ID for debugging */
+    requestId?: string;
+    /** Retry suggestion */
+    retryable?: boolean;
+}
+/**
+ * Batch inference job configuration
+ */
+export interface BatchInferenceConfig {
+    /** Input S3 location */
+    inputS3Uri: string;
+    /** Output S3 location */
+    outputS3Uri: string;
+    /** SageMaker model name */
+    modelName: string;
+    /** Instance type for batch job */
+    instanceType: string;
+    /** Instance count for batch job */
+    instanceCount: number;
+    /** Maximum payload size in MB */
+    maxPayloadInMB?: number;
+    /** Batch strategy */
+    batchStrategy?: "MultiRecord" | "SingleRecord";
+}
+/**
+ * Model deployment configuration
+ */
+export interface ModelDeploymentConfig {
+    /** Model name */
+    modelName: string;
+    /** Endpoint name */
+    endpointName: string;
+    /** EC2 instance type */
+    instanceType: string;
+    /** Initial instance count */
+    initialInstanceCount: number;
+    /** Model data S3 location */
+    modelDataUrl: string;
+    /** Container image URI */
+    image: string;
+    /** IAM execution role ARN */
+    executionRoleArn: string;
+    /** Resource tags */
+    tags?: Record<string, string>;
+    /** Auto scaling configuration */
+    autoScaling?: {
+        minCapacity: number;
+        maxCapacity: number;
+        targetValue: number;
+        scaleUpCooldown: number;
+        scaleDownCooldown: number;
+    };
+}
+/**
+ * Endpoint metrics and monitoring data
+ */
+export interface EndpointMetrics {
+    /** Endpoint name */
+    endpointName: string;
+    /** Total invocations */
+    invocations: number;
+    /** Average latency in milliseconds */
+    averageLatency: number;
+    /** Error rate percentage */
+    errorRate: number;
+    /** CPU utilization percentage */
+    cpuUtilization?: number;
+    /** Memory utilization percentage */
+    memoryUtilization?: number;
+    /** Instance count */
+    instanceCount: number;
+    /** Timestamp of metrics */
+    timestamp: string;
+}
+/**
+ * Cost estimation data
+ */
+export interface CostEstimate {
+    /** Estimated cost in USD */
+    estimatedCost: number;
+    /** Currency code */
+    currency: string;
+    /** Cost breakdown */
+    breakdown: {
+        /** Instance hours cost */
+        instanceCost: number;
+        /** Request-based cost */
+        requestCost: number;
+        /** Total processing hours */
+        totalHours: number;
+    };
+    /** Time period for estimate */
+    period?: {
+        start: string;
+        end: string;
+    };
+}
+/**
+ * SageMaker generation result interface for better type safety
+ */
+export interface SageMakerGenerateResult {
+    text?: string;
+    reasoning?: string | Array<{
+        type: "text";
+        text: string;
+        signature?: string;
+    } | {
+        type: "redacted";
+        data: string;
+    }>;
+    files?: Array<{
+        data: string | Uint8Array;
+        mimeType: string;
+    }>;
+    logprobs?: Array<{
+        token: string;
+        logprob: number;
+        topLogprobs: Array<{
+            token: string;
+            logprob: number;
+        }>;
+    }>;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens?: number;
+    };
+    finishReason: "stop" | "length" | "content-filter" | "tool-calls" | "error" | "unknown";
+    warnings?: Array<{
+        type: "other";
+        message: string;
+    }>;
+    rawCall: {
+        rawPrompt: unknown;
+        rawSettings: Record<string, unknown>;
+    };
+    rawResponse?: {
+        headers?: Record<string, string>;
+    };
+    request?: {
+        body?: string;
+    };
+    toolCalls?: SageMakerToolCall[];
+    object?: unknown;
+}

package/dist/lib/providers/sagemaker/types.js

@@ -0,0 +1,7 @@
+/**
+ * TypeScript type definitions for Amazon SageMaker Provider
+ *
+ * This module contains all interfaces and types for SageMaker integration
+ * with the NeuroLink ecosystem and Vercel AI SDK compatibility.
+ */
+export {};

package/dist/lib/sdk/toolRegistration.d.ts

@@ -13,7 +13,7 @@ import type { JsonValue } from "../types/common.js";
  */
 declare const VALIDATION_CONFIG: {
     readonly NAME_MIN_LENGTH: 2;
-    readonly NAME_MAX_LENGTH: 50;
+    readonly NAME_MAX_LENGTH: number;
     readonly DESCRIPTION_MIN_LENGTH: 10;
     readonly DESCRIPTION_MAX_LENGTH: number;
     readonly RESERVED_NAMES: Set<string>;

package/dist/lib/sdk/toolRegistration.js

@@ -8,15 +8,19 @@ import { logger } from "../utils/logger.js";
 /**
  * Configuration constants for tool validation
  */
-const envValue = parseInt(process.env.NEUROLINK_TOOL_DESCRIPTION_MAX_LENGTH || "200", 10);
-const DEFAULT_DESCRIPTION_MAX_LENGTH = Number.isInteger(envValue) && envValue > 0 ? envValue : 200;
+const envDescValue = parseInt(process.env.NEUROLINK_TOOL_DESCRIPTION_MAX_LENGTH || "200", 10);
+// Allow 0 to mean unlimited (no length restriction)
+const DEFAULT_DESCRIPTION_MAX_LENGTH = Number.isInteger(envDescValue) && envDescValue >= 0 ? envDescValue : 200;
+const envNameValue = parseInt(process.env.NEUROLINK_TOOL_NAME_MAX_LENGTH || "50", 10);
+// Allow 0 to mean unlimited (no length restriction)
+const DEFAULT_NAME_MAX_LENGTH = Number.isInteger(envNameValue) && envNameValue >= 0 ? envNameValue : 50;
 /**
  * Enhanced validation configuration
  */
 const VALIDATION_CONFIG = {
     // Tool name constraints
     NAME_MIN_LENGTH: 2,
-    NAME_MAX_LENGTH: 50,
+    NAME_MAX_LENGTH: DEFAULT_NAME_MAX_LENGTH,
     // Description constraints
     DESCRIPTION_MIN_LENGTH: 10,
     DESCRIPTION_MAX_LENGTH: DEFAULT_DESCRIPTION_MAX_LENGTH,
@@ -210,7 +214,9 @@ function validateToolName(name) {
             `Minimum length: ${VALIDATION_CONFIG.NAME_MIN_LENGTH} characters. ` +
             `Example: 'get_data', 'send_email'`);
     }
-    if (trimmedName.length > VALIDATION_CONFIG.NAME_MAX_LENGTH) {
+    // Only check name length if limit is greater than 0 (0 means unlimited)
+    if (VALIDATION_CONFIG.NAME_MAX_LENGTH > 0 &&
+        trimmedName.length > VALIDATION_CONFIG.NAME_MAX_LENGTH) {
         throw new Error(`Tool name too long: '${name}' (${trimmedName.length} chars). ` +
             `Maximum length: ${VALIDATION_CONFIG.NAME_MAX_LENGTH} characters. ` +
             `Consider shortening: '${trimmedName.substring(0, 20)}...'`);
@@ -254,7 +260,9 @@ function validateToolDescription(name, description) {
             `The description should clearly explain what the tool does and when to use it. ` +
             `Example: "Fetches current weather data for a specified location using coordinates or city name"`);
     }
-    if (trimmedDescription.length > VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH) {
+    // Only check description length if limit is greater than 0 (0 means unlimited)
+    if (VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH > 0 &&
+        trimmedDescription.length > VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH) {
         throw new Error(`Tool '${name}' description too long: ${trimmedDescription.length} characters. ` +
             `Maximum length: ${VALIDATION_CONFIG.DESCRIPTION_MAX_LENGTH} characters. ` +
             `Current description: "${trimmedDescription.substring(0, 50)}..." ` +

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

@@ -12,7 +12,7 @@ export interface BaseCommandArgs {
     /** Enable debug output */
     debug?: boolean;
     /** Output format */
-    format?: "text" | "json" | "table";
+    format?: "text" | "json" | "table" | "yaml";
     /** Verbose output */
     verbose?: boolean;
     /** Quiet mode */
@@ -153,6 +153,41 @@ export interface OllamaCommandArgs extends BaseCommandArgs {
     /** Show model information */
     show?: boolean;
 }
+/**
+ * SageMaker command arguments
+ */
+export interface SageMakerCommandArgs extends BaseCommandArgs {
+    /** SageMaker endpoint name */
+    endpoint?: string;
+    /** Model name for the endpoint */
+    model?: string;
+    /** Test prompt for endpoint testing */
+    prompt?: string;
+    /** List endpoints */
+    list?: boolean;
+    /** Show configuration */
+    config?: boolean;
+    /** Setup configuration */
+    setup?: boolean;
+    /** Clear configuration cache */
+    clearCache?: boolean;
+    /** Run benchmark test */
+    benchmark?: boolean;
+    /** Duration for benchmark test (in seconds) */
+    duration?: number;
+    /** Concurrency level for benchmark */
+    concurrency?: number;
+    /** Number of requests for benchmark */
+    requests?: number;
+    /** Maximum tokens per request */
+    maxTokens?: number;
+    /** Validate endpoint configuration */
+    validate?: boolean;
+    /** AWS region override */
+    region?: string;
+    /** Force operation without confirmation */
+    force?: boolean;
+}
 /**
  * Provider status command arguments
  */

package/dist/lib/utils/providerHealth.js

@@ -229,11 +229,19 @@ export class ProviderHealthChecker {
      * Check model availability (if possible without making API calls)
      */
     static async checkModelAvailability(providerName, healthStatus) {
-        // For now, we'll do basic model name validation
-        // In the future, this could be enhanced with actual API calls
+        // Basic model name validation and recommendations
         const commonModels = this.getCommonModelsForProvider(providerName);
         if (commonModels.length > 0) {
-            healthStatus.recommendations.push(`Common models for ${providerName}: ${commonModels.slice(0, 3).join(", ")}`);
+            if (providerName === AIProviderName.VERTEX) {
+                // Provide more detailed information for Vertex AI
+                healthStatus.recommendations.push(`Available models for ${providerName}:\n` +
+                    `  Google Models: gemini-1.5-pro, gemini-1.5-flash\n` +
+                    `  Claude Models: claude-3-5-sonnet-20241022, claude-3-sonnet-20240229, claude-3-haiku-20240307, claude-3-opus-20240229\n` +
+                    `  Note: Claude models require Anthropic integration to be enabled in your Google Cloud project`);
+            }
+            else {
+                healthStatus.recommendations.push(`Common models for ${providerName}: ${commonModels.slice(0, 3).join(", ")}`);
+            }
         }
     }
     /**
@@ -408,7 +416,14 @@ export class ProviderHealthChecker {
             case AIProviderName.GOOGLE_AI:
                 return ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro"];
             case AIProviderName.VERTEX:
-                return ["gemini-1.5-pro", "gemini-1.5-flash"];
+                return [
+                    "gemini-1.5-pro",
+                    "gemini-1.5-flash",
+                    "claude-3-5-sonnet-20241022",
+                    "claude-3-sonnet-20240229",
+                    "claude-3-haiku-20240307",
+                    "claude-3-opus-20240229",
+                ];
             case AIProviderName.BEDROCK:
                 return [
                     "anthropic.claude-3-sonnet-20240229-v1:0",

package/dist/neurolink.d.ts

@@ -10,6 +10,7 @@ import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { SimpleTool } from "./sdk/toolRegistration.js";
 import type { InMemoryMCPServerConfig } from "./types/mcpTypes.js";
+import { EventEmitter } from "events";
 export interface ProviderStatus {
     provider: string;
     status: "working" | "failed" | "not-configured";
@@ -41,10 +42,19 @@ export interface MCPServerInfo {
 }
 export declare class NeuroLink {
     private mcpInitialized;
+    private emitter;
     private customTools;
     private inMemoryServers;
     private toolCircuitBreakers;
     private toolExecutionMetrics;
+    /**
+     * Helper method to emit tool end event in a consistent way
+     * Used by executeTool in both success and error paths
+     * @param toolName - Name of the tool
+     * @param startTime - Timestamp when tool execution started
+     * @param success - Whether the tool execution was successful
+     */
+    private emitToolEndEvent;
     constructor();
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
@@ -101,6 +111,11 @@ export declare class NeuroLink {
      * Future-ready for multi-modal capabilities with current text focus
      */
     stream(options: StreamOptions): Promise<StreamResult>;
+    /**
+     * Get the EventEmitter to listen to NeuroLink events
+     * @returns EventEmitter instance
+     */
+    getEventEmitter(): EventEmitter<[never]>;
     /**
      * Register a custom tool that will be available to all AI providers
      * @param name - Unique name for the tool