@juspay/neurolink 7.29.1 → 7.29.3

package/dist/lib/providers/huggingFace.js

@@ -147,7 +147,7 @@ export class HuggingFaceProvider extends BaseProvider {
      * Prepare stream options with HuggingFace-specific enhancements
      * Handles tool calling optimizations and model-specific formatting
      */
-    prepareStreamOptions(options, analysisSchema) {
+    prepareStreamOptions(options, _analysisSchema) {
         const modelSupportsTools = this.supportsTools();
         // If model doesn't support tools, disable them completely
         if (!modelSupportsTools) {

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

@@ -10,7 +10,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 export declare class MistralProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, sdk?: unknown);
-    protected executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/mistral.js

@@ -2,7 +2,7 @@ import { createMistral } from "@ai-sdk/mistral";
 import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
@@ -40,7 +40,7 @@ export class MistralProvider extends BaseProvider {
         });
     }
     // generate() method is inherited from BaseProvider; this provider uses the base implementation for generation with tools
-    async executeStream(options, analysisSchema) {
+    async executeStream(options, _analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const timeout = this.getTimeout(options);

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

@@ -62,6 +62,10 @@ export declare class OllamaProvider extends BaseProvider {
      * Convert AI SDK tools format to Ollama's function calling format
      */
     private convertToolsToOllamaFormat;
+    /**
+     * Process individual stream data chunk from Ollama
+     */
+    private processOllamaStreamData;
     /**
      * Create stream generator for Ollama chat API with tool call support
      */

package/dist/lib/providers/ollama.js

@@ -1,9 +1,9 @@
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { modelConfig } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
 const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
 const FALLBACK_OLLAMA_MODEL = "llama3.2:latest"; // Used when primary model fails
@@ -197,7 +197,9 @@ class OllamaLanguageModel {
                             }
                         }
                         catch (error) {
-                            // Ignore JSON parse errors for incomplete chunks
+                            logger.error("Error parsing Ollama stream response", {
+                                error,
+                            });
                         }
                     }
                 }
@@ -368,7 +370,7 @@ export class OllamaProvider extends BaseProvider {
      * Execute streaming without tools using the generate API
      * Fallback for non-tool scenarios or when chat API is unavailable
      */
-    async executeStreamWithoutTools(options, analysisSchema) {
+    async executeStreamWithoutTools(options, _analysisSchema) {
         const response = await proxyFetch(`${this.baseUrl}/api/generate`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -423,10 +425,32 @@ export class OllamaProvider extends BaseProvider {
             },
         }));
     }
+    /**
+     * Process individual stream data chunk from Ollama
+     */
+    processOllamaStreamData(data) {
+        const dataRecord = data;
+        const choices = dataRecord.choices;
+        const delta = choices?.[0]?.delta;
+        let content = "";
+        if (delta?.content && typeof delta.content === "string") {
+            content += delta.content;
+        }
+        if (delta?.tool_calls) {
+            // Handle tool calls - for now, we'll include them as content
+            // Future enhancement: Execute tools and return results
+            const toolCallDescription = this.formatToolCallForDisplay(delta.tool_calls);
+            if (toolCallDescription) {
+                content += toolCallDescription;
+            }
+        }
+        const shouldReturn = !!choices?.[0]?.finish_reason;
+        return content ? { content, shouldReturn } : { shouldReturn };
+    }
     /**
      * Create stream generator for Ollama chat API with tool call support
      */
-    async *createOllamaChatStream(response, tools) {
+    async *createOllamaChatStream(response, _tools) {
         const reader = response.body?.getReader();
         if (!reader) {
             throw new Error("No response body");
@@ -450,24 +474,18 @@ export class OllamaProvider extends BaseProvider {
                         }
                         try {
                             const data = JSON.parse(dataLine);
-                            const delta = data.choices?.[0]?.delta;
-                            if (delta?.content) {
-                                yield { content: delta.content };
-                            }
-                            if (delta?.tool_calls) {
-                                // Handle tool calls - for now, we'll include them as content
-                                // Future enhancement: Execute tools and return results
-                                const toolCallDescription = this.formatToolCallForDisplay(delta.tool_calls);
-                                if (toolCallDescription) {
-                                    yield { content: toolCallDescription };
-                                }
+                            const result = this.processOllamaStreamData(data);
+                            if (result?.content) {
+                                yield { content: result.content };
                             }
-                            if (data.choices?.[0]?.finish_reason) {
+                            if (result?.shouldReturn) {
                                 return;
                             }
                         }
                         catch (error) {
-                            // Ignore JSON parse errors for incomplete chunks
+                            logger.error("Error parsing Ollama stream response", {
+                                error,
+                            });
                         }
                     }
                 }
@@ -536,7 +554,9 @@ export class OllamaProvider extends BaseProvider {
                             }
                         }
                         catch (error) {
-                            // Ignore JSON parse errors for incomplete chunks
+                            logger.error("Error parsing Ollama stream response", {
+                                error,
+                            });
                         }
                     }
                 }

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

@@ -23,6 +23,6 @@ export declare class OpenAIProvider extends BaseProvider {
      * For details on the changes and migration steps, refer to the BaseProvider documentation
      * and the migration guide in the project repository.
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
 }
 export default OpenAIProvider;

package/dist/lib/providers/openAI.js

@@ -3,7 +3,7 @@ import { streamText } from "ai";
 import { AIProviderName } from "../core/types.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
@@ -82,7 +82,7 @@ export class OpenAIProvider extends BaseProvider {
      * For details on the changes and migration steps, refer to the BaseProvider documentation
      * and the migration guide in the project repository.
      */
-    async executeStream(options, analysisSchema) {
+    async executeStream(options, _analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const timeout = this.getTimeout(options);

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

@@ -55,7 +55,10 @@ export class AdaptiveSemaphore {
         this.activeRequests--;
         if (this.waiters.length > 0) {
             const waiter = this.waiters.shift();
-            waiter();
+            if (waiter) {
+                this.count++; // Increment count before calling waiter so waiter can decrement it
+                waiter();
+            }
         }
         else {
             this.count++;
@@ -103,9 +106,9 @@ export class AdaptiveSemaphore {
         // 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();
+            if (waiter) {
+                waiter();
+            }
         }
     }
     /**

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

@@ -142,7 +142,11 @@ export class SageMakerRuntimeClient {
             });
             // Return the response with streaming body
             if (!response.Body) {
-                throw new SageMakerError("No response body received from streaming endpoint", "MODEL_ERROR", 500, undefined, params.EndpointName);
+                throw new SageMakerError("No response body received from streaming endpoint", {
+                    code: "MODEL_ERROR",
+                    statusCode: 500,
+                    endpoint: params.EndpointName,
+                });
             }
             // Convert AWS response stream to async iterable of Uint8Array
             const streamIterable = this.convertAWSStreamToIterable(response.Body);
@@ -345,7 +349,10 @@ export class SageMakerRuntimeClient {
                 error: error instanceof Error ? error.message : String(error),
                 streamType: typeof awsStream,
             });
-            throw new SageMakerError(`Stream conversion failed: ${error instanceof Error ? error.message : String(error)}`, "NETWORK_ERROR", 500);
+            throw new SageMakerError(`Stream conversion failed: ${error instanceof Error ? error.message : String(error)}`, {
+                code: "NETWORK_ERROR",
+                statusCode: 500,
+            });
         }
     }
     /**
@@ -417,7 +424,10 @@ export class SageMakerRuntimeClient {
      */
     ensureNotDisposed() {
         if (this.isDisposed) {
-            throw new SageMakerError("Cannot perform operation on disposed SageMaker client", "VALIDATION_ERROR", 400);
+            throw new SageMakerError("Cannot perform operation on disposed SageMaker client", {
+                code: "VALIDATION_ERROR",
+                statusCode: 400,
+            });
         }
     }
 }

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

@@ -99,7 +99,11 @@ export function getSageMakerModelConfig(endpointName) {
     const endpoint = endpointName || getDefaultSageMakerEndpoint();
     // Check cache first
     if (modelConfigCache.has(endpoint)) {
-        return modelConfigCache.get(endpoint);
+        const cachedConfig = modelConfigCache.get(endpoint);
+        if (!cachedConfig) {
+            throw new Error(`Model config for endpoint ${endpoint} not found in cache after existence check`);
+        }
+        return cachedConfig;
     }
     const config = {
         endpointName: endpoint,

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

@@ -9,7 +9,6 @@ import { logger } from "../../utils/logger.js";
 /**
  * Configurable constants for detection timing and performance
  */
-const DETECTION_TEST_DELAY_MS = 100; // Base delay between detection tests (ms)
 const DETECTION_STAGGER_DELAY_MS = 25; // Delay between staggered test starts (ms)
 const DETECTION_RATE_LIMIT_BACKOFF_MS = 200; // Initial backoff on rate limit detection (ms)
 /**
@@ -78,7 +77,7 @@ export class SageMakerDetector {
         ];
         // Run detection tests in parallel with intelligent rate limiting
         const testNames = ["HuggingFace", "LLaMA", "PyTorch", "TensorFlow"];
-        const results = await this.runDetectionTestsInParallel(detectionTests, testNames, endpointName);
+        const _results = await this.runDetectionTestsInParallel(detectionTests, testNames, endpointName);
         // Analyze results and determine most likely model type
         const scores = {
             huggingface: 0,
@@ -218,7 +217,7 @@ export class SageMakerDetector {
             }
         }
         catch (error) {
-            // Test failed, no evidence
+            logger.debug("HuggingFace signature test failed", { error });
         }
     }
     /**
@@ -245,7 +244,7 @@ export class SageMakerDetector {
                 evidence.push("llama: openai text_completion object");
             }
         }
-        catch (error) {
+        catch {
             // Test failed, no evidence
         }
     }
@@ -266,7 +265,7 @@ export class SageMakerDetector {
                 evidence.push("pytorch: prediction/output field pattern");
             }
         }
-        catch (error) {
+        catch {
             // Test failed, no evidence
         }
     }
@@ -290,7 +289,7 @@ export class SageMakerDetector {
                 evidence.push("tensorflow: serving predictions field");
             }
         }
-        catch (error) {
+        catch {
             // Test failed, no evidence
         }
     }
@@ -457,7 +456,10 @@ export class SageMakerDetector {
             release() {
                 if (this.waiters.length > 0) {
                     const waiter = this.waiters.shift();
-                    waiter();
+                    if (waiter) {
+                        this.count++; // Increment count before calling waiter so waiter can decrement it
+                        waiter();
+                    }
                 }
                 else {
                     this.count++;
@@ -477,7 +479,14 @@ export class SageMakerDetector {
                 return { status: "fulfilled", value: undefined };
             }
             catch (error) {
-                const result = await this.handleDetectionTestError(error, config.test, config.testName, config.endpointName, config.incrementRateLimit, config.maxRateLimitRetries, config.rateLimitState.count);
+                const result = await this.handleDetectionTestError(error, {
+                    test: config.test,
+                    testName: config.testName,
+                    endpointName: config.endpointName,
+                    incrementRateLimit: config.incrementRateLimit,
+                    maxRateLimitRetries: config.maxRateLimitRetries,
+                    rateLimitCount: config.rateLimitState.count,
+                });
                 return result;
             }
             finally {
@@ -498,8 +507,9 @@ export class SageMakerDetector {
     /**
      * Handle detection test errors with rate limiting and retry logic
      */
-    async handleDetectionTestError(error, test, testName, endpointName, incrementRateLimit, maxRateLimitRetries, rateLimitCount) {
+    async handleDetectionTestError(error, options) {
         const isRateLimit = this.isRateLimitError(error);
+        const { test, testName, endpointName, incrementRateLimit, maxRateLimitRetries, rateLimitCount, } = options;
         if (isRateLimit && rateLimitCount < maxRateLimitRetries) {
             return await this.retryWithBackoff(test, testName, endpointName, incrementRateLimit, rateLimitCount);
         }

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

@@ -15,7 +15,14 @@ export declare class SageMakerError extends Error {
     readonly endpoint?: string;
     readonly requestId?: string;
     readonly retryable: boolean;
-    constructor(message: string, code?: SageMakerErrorCode, statusCode?: number, cause?: Error, endpoint?: string, requestId?: string, retryable?: boolean);
+    constructor(message: string, options?: {
+        code?: SageMakerErrorCode;
+        statusCode?: number;
+        cause?: Error;
+        endpoint?: string;
+        requestId?: string;
+        retryable?: boolean;
+    });
     /**
      * Convert error to JSON for logging/serialization
      */

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

@@ -15,15 +15,15 @@ export class SageMakerError extends Error {
     endpoint;
     requestId;
     retryable;
-    constructor(message, code = "UNKNOWN_ERROR", statusCode, cause, endpoint, requestId, retryable = false) {
+    constructor(message, options = {}) {
         super(message);
         this.name = "SageMakerError";
-        this.code = code;
-        this.statusCode = statusCode;
-        this.cause = cause;
-        this.endpoint = endpoint;
-        this.requestId = requestId;
-        this.retryable = retryable;
+        this.code = options.code ?? "UNKNOWN_ERROR";
+        this.statusCode = options.statusCode;
+        this.cause = options.cause;
+        this.endpoint = options.endpoint;
+        this.requestId = options.requestId;
+        this.retryable = options.retryable ?? false;
         // Capture stack trace if available
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, SageMakerError);
@@ -83,41 +83,111 @@ export function handleSageMakerError(error, endpoint) {
         // AWS SDK specific errors using centralized constants
         if (errorName === "ValidationException" ||
             ERROR_KEYWORDS.VALIDATION.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.VALIDATION}: ${error.message}`, "VALIDATION_ERROR", 400, error, endpoint, extractRequestId(error), false);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.VALIDATION}: ${error.message}`, {
+                code: "VALIDATION_ERROR",
+                statusCode: 400,
+                cause: error,
+                endpoint,
+                requestId: extractRequestId(error),
+                retryable: false,
+            });
         }
         if (errorName === "ModelError" ||
             ERROR_KEYWORDS.MODEL.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.MODEL}: ${error.message}`, "MODEL_ERROR", 500, error, endpoint, extractRequestId(error), false);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.MODEL}: ${error.message}`, {
+                code: "MODEL_ERROR",
+                statusCode: 500,
+                cause: error,
+                endpoint,
+                requestId: extractRequestId(error),
+                retryable: false,
+            });
         }
         if (errorName === "InternalFailure" ||
             ERROR_KEYWORDS.INTERNAL.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.INTERNAL}: ${error.message}`, "INTERNAL_ERROR", 500, error, endpoint, extractRequestId(error), true);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.INTERNAL}: ${error.message}`, {
+                code: "INTERNAL_ERROR",
+                statusCode: 500,
+                cause: error,
+                endpoint,
+                requestId: extractRequestId(error),
+                retryable: true,
+            });
         }
         if (errorName === "ServiceUnavailable" ||
             ERROR_KEYWORDS.SERVICE_UNAVAILABLE.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.SERVICE_UNAVAILABLE}: ${error.message}`, "SERVICE_UNAVAILABLE", 503, error, endpoint, extractRequestId(error), true);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.SERVICE_UNAVAILABLE}: ${error.message}`, {
+                code: "SERVICE_UNAVAILABLE",
+                statusCode: 503,
+                cause: error,
+                endpoint,
+                requestId: extractRequestId(error),
+                retryable: true,
+            });
         }
         if (errorName === "ThrottlingException" ||
             ERROR_KEYWORDS.THROTTLING.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.THROTTLING}: ${error.message}`, "THROTTLING_ERROR", 429, error, endpoint, extractRequestId(error), true);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.THROTTLING}: ${error.message}`, {
+                code: "THROTTLING_ERROR",
+                statusCode: 429,
+                cause: error,
+                endpoint,
+                requestId: extractRequestId(error),
+                retryable: true,
+            });
         }
         if (errorName === "CredentialsError" ||
             ERROR_KEYWORDS.CREDENTIALS.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.CREDENTIALS}: ${error.message}`, "CREDENTIALS_ERROR", 401, error, endpoint, undefined, false);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.CREDENTIALS}: ${error.message}`, {
+                code: "CREDENTIALS_ERROR",
+                statusCode: 401,
+                cause: error,
+                endpoint,
+                requestId: undefined,
+                retryable: false,
+            });
         }
         if (errorName === "NetworkingError" ||
             ERROR_KEYWORDS.NETWORK.some((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.NETWORK}: ${error.message}`, "NETWORK_ERROR", 0, error, endpoint, undefined, true);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.NETWORK}: ${error.message}`, {
+                code: "NETWORK_ERROR",
+                statusCode: 0,
+                cause: error,
+                endpoint,
+                requestId: undefined,
+                retryable: true,
+            });
         }
         if (ERROR_KEYWORDS.ENDPOINT_NOT_FOUND.every((keyword) => errorMessage.includes(keyword))) {
-            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.ENDPOINT_NOT_FOUND}: ${error.message}`, "ENDPOINT_NOT_FOUND", 404, error, endpoint, extractRequestId(error), false);
+            return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.ENDPOINT_NOT_FOUND}: ${error.message}`, {
+                code: "ENDPOINT_NOT_FOUND",
+                statusCode: 404,
+                cause: error,
+                endpoint,
+                requestId: extractRequestId(error),
+                retryable: false,
+            });
         }
         // Generic error handling
-        return new SageMakerError(error.message, "UNKNOWN_ERROR", 500, error, endpoint, extractRequestId(error), false);
+        return new SageMakerError(error.message, {
+            code: "UNKNOWN_ERROR",
+            statusCode: 500,
+            cause: error,
+            endpoint,
+            requestId: extractRequestId(error),
+            retryable: false,
+        });
     }
     // Handle non-Error objects
     const errorMessage = typeof error === "string" ? error : "Unknown error occurred";
-    return new SageMakerError(errorMessage, "UNKNOWN_ERROR", 500, undefined, endpoint, undefined, false);
+    return new SageMakerError(errorMessage, {
+        code: "UNKNOWN_ERROR",
+        statusCode: 500,
+        cause: undefined,
+        endpoint,
+        requestId: undefined,
+        retryable: false,
+    });
 }
 /**
  * Extract request ID from AWS SDK error for debugging
@@ -160,7 +230,11 @@ export function createValidationError(message, field) {
     const fullMessage = field
         ? `${ERROR_MESSAGE_PREFIXES.VALIDATION_FIELD} '${field}': ${message}`
         : message;
-    return new SageMakerError(fullMessage, "VALIDATION_ERROR", 400);
+    return new SageMakerError(fullMessage, {
+        code: "VALIDATION_ERROR",
+        statusCode: 400,
+        retryable: false,
+    });
 }
 /**
  * Create a credentials error with setup guidance
@@ -169,7 +243,11 @@ export function createValidationError(message, field) {
  * @returns SageMakerError with credentials guidance
  */
 export function createCredentialsError(message) {
-    return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.CREDENTIALS_SETUP}: ${message}`, "CREDENTIALS_ERROR", 401, undefined, undefined, undefined, false);
+    return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.CREDENTIALS_SETUP}: ${message}`, {
+        code: "CREDENTIALS_ERROR",
+        statusCode: 401,
+        retryable: false,
+    });
 }
 /**
  * Create a network error with connectivity guidance
@@ -179,7 +257,12 @@ export function createCredentialsError(message) {
  * @returns SageMakerError with network guidance
  */
 export function createNetworkError(message, endpoint) {
-    return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.NETWORK_CONNECTION}: ${message}`, "NETWORK_ERROR", 0, undefined, endpoint, undefined, true);
+    return new SageMakerError(`${ERROR_MESSAGE_PREFIXES.NETWORK_CONNECTION}: ${message}`, {
+        code: "NETWORK_ERROR",
+        statusCode: 0,
+        endpoint,
+        retryable: true,
+    });
 }
 /**
  * Check if an error is retryable based on its characteristics

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

@@ -126,7 +126,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "mistral" | "huggingface" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "custom" | "huggingface" | "mistral" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
     /**
@@ -146,7 +146,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         usage: {
             promptTokens: number;
             completionTokens: number;
-            totalTokens: number;
+            total: number;
         };
         finishReason: "stop" | "length" | "content-filter" | "tool-calls" | "error" | "unknown";
     }>>;
@@ -173,7 +173,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "mistral" | "huggingface" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "custom" | "huggingface" | "mistral" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
 }

package/dist/lib/providers/sagemaker/language-model.js

@@ -8,7 +8,7 @@ import { randomUUID } from "crypto";
 import { SageMakerRuntimeClient } from "./client.js";
 import { handleSageMakerError } from "./errors.js";
 import { estimateTokenUsage, createSageMakerStream } from "./streaming.js";
-import { createAdaptiveSemaphore, } from "./adaptive-semaphore.js";
+import { createAdaptiveSemaphore } from "./adaptive-semaphore.js";
 import { logger } from "../../utils/logger.js";
 /**
  * Base synthetic streaming delay in milliseconds for simulating real-time response
@@ -147,7 +147,7 @@ export class SageMakerLanguageModel {
                 usage: {
                     promptTokens: usage.promptTokens,
                     completionTokens: usage.completionTokens,
-                    totalTokens: usage.totalTokens,
+                    totalTokens: usage.total,
                 },
                 finishReason,
                 rawCall: {
@@ -672,7 +672,7 @@ export class SageMakerLanguageModel {
                     usage: {
                         promptTokens: result.usage.promptTokens,
                         completionTokens: result.usage.completionTokens,
-                        totalTokens: result.usage.totalTokens ||
+                        total: result.usage.totalTokens ??
                             result.usage.promptTokens + result.usage.completionTokens,
                     },
                     finishReason: result.finishReason,
@@ -692,7 +692,7 @@ export class SageMakerLanguageModel {
                 // Create error result
                 results[index] = {
                     text: "",
-                    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+                    usage: { promptTokens: 0, completionTokens: 0, total: 0 },
                     finishReason: "error",
                     index,
                 };