@juspay/neurolink 7.47.3 → 7.48.1

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

@@ -589,3 +589,472 @@ export declare const ModelAliases: {
  * Default provider configurations
  */
 export declare const DEFAULT_PROVIDER_CONFIGS: AIModelProviderConfig[];
+/**
+ * Adaptive semaphore configuration for concurrency management
+ */
+export type AdaptiveSemaphoreConfig = {
+    initialConcurrency: number;
+    maxConcurrency: number;
+    minConcurrency: number;
+};
+/**
+ * Metrics for adaptive semaphore performance tracking
+ */
+export type AdaptiveSemaphoreMetrics = {
+    activeRequests: number;
+    currentConcurrency: number;
+    completedCount: number;
+    errorCount: number;
+    averageResponseTime: number;
+    waitingCount: number;
+};
+/**
+ * AWS configuration options for SageMaker client
+ */
+export type 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 type 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 type 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 type SageMakerUsage = {
+    /** Number of prompt tokens */
+    promptTokens: number;
+    /** Number of completion tokens */
+    completionTokens: number;
+    /** Total tokens used */
+    total: 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type 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 type for better type safety
+ */
+export type 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/providers/sagemaker/adaptive-semaphore.d.ts

@@ -4,19 +4,7 @@
  * 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;
-}
+import type { AdaptiveSemaphoreConfig, AdaptiveSemaphoreMetrics } from "../../types/providers.js";
 /**
  * Adaptive semaphore that automatically adjusts concurrency based on performance metrics
  */

package/dist/providers/sagemaker/client.d.ts

@@ -4,7 +4,7 @@
  * This module provides a wrapper around the AWS SDK SageMaker Runtime client
  * with enhanced error handling, retry logic, and NeuroLink-specific features.
  */
-import type { SageMakerConfig, InvokeEndpointParams, InvokeEndpointResponse } from "./types.js";
+import type { SageMakerConfig, InvokeEndpointParams, InvokeEndpointResponse } from "../../types/providers.js";
 import type { ConnectionResult } from "../../types/typeAliases.js";
 /**
  * Enhanced SageMaker Runtime client with retry logic and error handling

package/dist/providers/sagemaker/config.d.ts

@@ -4,7 +4,7 @@
  * This module handles loading, validation, and management of SageMaker
  * configuration from environment variables, files, and defaults.
  */
-import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
+import type { SageMakerConfig, SageMakerModelConfig } from "../../types/providers.js";
 /**
  * Load and validate SageMaker configuration from environment variables
  *

package/dist/providers/sagemaker/detection.d.ts

@@ -4,7 +4,7 @@
  * This module provides intelligent detection of SageMaker endpoint capabilities
  * including model type identification and streaming protocol support.
  */
-import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
+import type { SageMakerConfig, SageMakerModelConfig } from "../../types/providers.js";
 /**
  * Streaming capability information for an endpoint
  */

package/dist/providers/sagemaker/errors.d.ts

@@ -4,7 +4,7 @@
  * This module provides comprehensive error handling, categorization,
  * and user-friendly error messages for SageMaker operations.
  */
-import type { SageMakerErrorCode, SageMakerErrorInfo } from "./types.js";
+import type { SageMakerErrorCode, SageMakerErrorInfo } from "../../types/providers.js";
 /**
  * Custom error class for SageMaker-specific errors
  */

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

@@ -9,7 +9,7 @@ export { AmazonSageMakerProvider } from "../amazonSagemaker.js";
 export { SageMakerRuntimeClient, createSageMakerRuntimeClient, testSageMakerConnectivity, } from "./client.js";
 export { getSageMakerConfig, getSageMakerModelConfig, getDefaultSageMakerEndpoint, getSageMakerModel, validateAWSCredentials, getConfigurationSummary, clearConfigurationCache, loadConfigurationFromFile, checkSageMakerConfiguration, } from "./config.js";
 export { SageMakerError, handleSageMakerError, createValidationError, createCredentialsError, createNetworkError, isRetryableError, getRetryDelay, } from "./errors.js";
-export type { SageMakerConfig, SageMakerModelConfig, SageMakerEndpointInfo, SageMakerUsage, InvokeEndpointParams, InvokeEndpointResponse, SageMakerStreamChunk, SageMakerToolCall, SageMakerToolResult, SageMakerGenerationOptions, SageMakerGenerationResponse, SageMakerErrorCode, SageMakerErrorInfo, BatchInferenceConfig, ModelDeploymentConfig, EndpointMetrics, CostEstimate, } from "./types.js";
+export type { SageMakerConfig, SageMakerModelConfig, SageMakerEndpointInfo, SageMakerUsage, InvokeEndpointParams, InvokeEndpointResponse, SageMakerStreamChunk, SageMakerToolCall, SageMakerToolResult, SageMakerGenerationOptions, SageMakerGenerationResponse, SageMakerErrorCode, SageMakerErrorInfo, BatchInferenceConfig, ModelDeploymentConfig, EndpointMetrics, CostEstimate, } from "../../types/providers.js";
 /**
  * Factory function to create a SageMaker Provider
  *

package/dist/providers/sagemaker/language-model.d.ts

@@ -5,7 +5,7 @@
  * integration with the Vercel AI SDK.
  */
 import type { LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1StreamPart } from "ai";
-import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
+import type { SageMakerConfig, SageMakerModelConfig } from "../../types/providers.js";
 import type { ConnectivityResult } from "../../types/typeAliases.js";
 /**
  * SageMaker Language Model implementing LanguageModelV1 interface
@@ -131,7 +131,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "custom" | "huggingface" | "mistral" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "custom" | "huggingface" | "mistral" | "llama" | "claude" | "jumpstart" | undefined;
         region: string;
     };
     /**
@@ -178,7 +178,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "custom" | "huggingface" | "mistral" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "custom" | "huggingface" | "mistral" | "llama" | "claude" | "jumpstart" | undefined;
         region: string;
     };
 }

package/dist/providers/sagemaker/parsers.d.ts

@@ -4,7 +4,7 @@
  * This module provides protocol-specific parsers for different streaming
  * formats used by SageMaker endpoints (HuggingFace, LLaMA, custom models).
  */
-import type { SageMakerStreamChunk, SageMakerUsage, SageMakerStructuredOutput } from "./types.js";
+import type { SageMakerStreamChunk, SageMakerUsage, SageMakerStructuredOutput } from "../../types/providers.js";
 import { type StructuredOutputParser } from "./structured-parser.js";
 /**
  * Shared bracket counting state and utilities

package/dist/providers/sagemaker/streaming.d.ts

@@ -5,7 +5,7 @@
  * and model-specific parsing for various SageMaker deployment patterns.
  */
 import { ReadableStream } from "stream/web";
-import type { SageMakerStreamChunk, SageMakerUsage, SageMakerConfig } from "./types.js";
+import type { SageMakerStreamChunk, SageMakerUsage, SageMakerConfig } from "../../types/providers.js";
 /**
  * Create a SageMaker streaming response with automatic protocol detection
  *

package/dist/providers/sagemaker/structured-parser.d.ts

@@ -4,7 +4,7 @@
  * This module provides partial JSON parsing for streaming structured output
  * responses from SageMaker endpoints with real-time validation.
  */
-import type { SageMakerStructuredOutput } from "./types.js";
+import type { SageMakerStructuredOutput } from "../../types/providers.js";
 /**
  * Partial JSON parser for streaming structured output
  */