@juspay/neurolink 9.30.0 → 9.31.0

package/dist/lib/providers/openAI.js

@@ -1,5 +1,5 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { embed, embedMany, streamText, } from "ai";
+import { embed, embedMany, NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -12,6 +12,15 @@ import { calculateCost } from "../utils/pricing.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { getModelId } from "./providerTypeUtils.js";
+/**
+ * Retrieve a tool's schema, handling both AI SDK v6 (`inputSchema`) and
+ * legacy v4 (`parameters`) field names.
+ */
+function getToolSchema(tool) {
+    const t = tool;
+    return t.inputSchema ?? t.parameters;
+}
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -85,10 +94,11 @@ export class OpenAIProvider extends BaseProvider {
                         // Keep the original tool structure - AI SDK will handle Zod schema conversion internally
                         const processedTool = { ...tool };
                         // Validate that Zod schemas are properly structured for AI SDK processing
-                        if (tool.parameters && isZodSchema(tool.parameters)) {
+                        const toolSchema = getToolSchema(tool);
+                        if (toolSchema && isZodSchema(toolSchema)) {
                             logger.debug(`OpenAI: Tool ${name} has Zod schema - AI SDK will handle conversion`);
                             // Basic validation that the Zod schema has the required structure
-                            this.validateZodSchema(name, tool.parameters);
+                            this.validateZodSchema(name, toolSchema);
                         }
                         // Include the tool with original Zod schema for AI SDK processing
                         if (this.isValidToolStructure(processedTool)) {
@@ -96,7 +106,7 @@ export class OpenAIProvider extends BaseProvider {
                         }
                         else {
                             logger.warn(`OpenAI: Filtering out tool with invalid structure: ${name}`, {
-                                parametersType: typeof processedTool.parameters,
+                                parametersType: typeof getToolSchema(processedTool),
                                 hasDescription: !!processedTool.description,
                                 hasExecute: !!processedTool.execute,
                             });
@@ -152,7 +162,13 @@ export class OpenAIProvider extends BaseProvider {
         if (!toolObj.execute || typeof toolObj.execute !== "function") {
             return false;
         }
-        return this.isValidToolParameters(toolObj.parameters);
+        // AI SDK v6 uses inputSchema; v4 used parameters — check both
+        const schema = "inputSchema" in toolObj
+            ? toolObj.inputSchema
+            : "parameters" in toolObj
+                ? toolObj.parameters
+                : undefined;
+        return this.isValidToolParameters(schema);
     }
     /**
      * Validate tool parameters for OpenAI compatibility
@@ -244,10 +260,13 @@ export class OpenAIProvider extends BaseProvider {
                 tools = Object.fromEntries(toolEntries.slice(0, MAX_TOOLS));
             }
             // Count tools with Zod schemas for debugging
-            const zodToolsCount = Object.values(allTools).filter((tool) => tool &&
-                typeof tool === "object" &&
-                tool.parameters &&
-                isZodSchema(tool.parameters)).length;
+            const zodToolsCount = Object.values(allTools).filter((tool) => {
+                if (!tool || typeof tool !== "object") {
+                    return false;
+                }
+                const schema = getToolSchema(tool);
+                return schema !== null && schema !== undefined && isZodSchema(schema);
+            }).length;
             logger.info("OpenAI streaming tools", {
                 shouldUseTools,
                 allToolsCount: Object.keys(allTools).length,
@@ -272,7 +291,7 @@ export class OpenAIProvider extends BaseProvider {
                     ? {
                         name: Object.keys(tools)[0],
                         description: tools[Object.keys(tools)[0]]?.description,
-                        parametersType: typeof tools[Object.keys(tools)[0]]?.parameters,
+                        parametersType: typeof getToolSchema(tools[Object.keys(tools)[0]]),
                     }
                     : "no-tools",
             });
@@ -282,7 +301,7 @@ export class OpenAIProvider extends BaseProvider {
                 kind: SpanKind.CLIENT,
                 attributes: {
                     "gen_ai.system": "openai",
-                    "gen_ai.request.model": model.modelId || this.modelName || "unknown",
+                    "gen_ai.request.model": getModelId(model) || this.modelName || "unknown",
                 },
             });
             let result;
@@ -291,10 +310,10 @@ export class OpenAIProvider extends BaseProvider {
                     model,
                     messages: messages,
                     temperature: options.temperature,
-                    maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                    maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                     maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
                     tools,
-                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                    stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
@@ -319,14 +338,14 @@ export class OpenAIProvider extends BaseProvider {
             }
             // Collect token usage and finish reason asynchronously when the stream completes,
             // then end the span. This avoids blocking the stream consumer.
-            result.usage
+            Promise.resolve(result.usage)
                 .then((usage) => {
-                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
-                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
                 const cost = calculateCost(this.providerName, this.modelName, {
-                    input: usage.promptTokens || 0,
-                    output: usage.completionTokens || 0,
-                    total: (usage.promptTokens || 0) + (usage.completionTokens || 0),
+                    input: usage.inputTokens || 0,
+                    output: usage.outputTokens || 0,
+                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
                 });
                 if (cost && cost > 0) {
                     streamSpan.setAttribute("neurolink.cost", cost);
@@ -335,14 +354,14 @@ export class OpenAIProvider extends BaseProvider {
                 .catch(() => {
                 // Usage may not be available if the stream is aborted
             });
-            result.finishReason
+            Promise.resolve(result.finishReason)
                 .then((reason) => {
                 streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
             })
                 .catch(() => {
                 // Finish reason may not be available if the stream is aborted
             });
-            result.text
+            Promise.resolve(result.text)
                 .then(() => {
                 streamSpan.end();
             })
@@ -489,6 +508,12 @@ export class OpenAIProvider extends BaseProvider {
                     }
                 }
                 catch (streamError) {
+                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    // Treat as an empty stream rather than crashing with an unhandled rejection.
+                    if (NoOutputGeneratedError.isInstance(streamError)) {
+                        logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError)");
+                        return;
+                    }
                     logger.error(`OpenAI: Stream transformation error:`, streamError);
                     throw streamError;
                 }

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

@@ -1,5 +1,5 @@
-import { type LanguageModelV1, type Schema } from "ai";
-import type { ZodType, ZodTypeDef } from "zod";
+import { type LanguageModel, type Schema } from "ai";
+import type { ZodType } from "zod";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
@@ -21,7 +21,7 @@ export declare class OpenRouterProvider extends BaseProvider {
     /**
      * Returns the Vercel AI SDK model instance for OpenRouter
      */
-    protected getAISDKModel(): LanguageModelV1;
+    protected getAISDKModel(): LanguageModel;
     formatProviderError(error: unknown): Error;
     /**
      * OpenRouter supports tools for compatible models
@@ -32,7 +32,7 @@ export declare class OpenRouterProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
     /**
      * Get available models from OpenRouter API
      * Dynamically fetches from /api/v1/models endpoint with caching and fallback

package/dist/lib/providers/openRouter.js

@@ -1,5 +1,5 @@
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import { Output, streamText, } from "ai";
+import { NoOutputGeneratedError, Output, streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -71,6 +71,7 @@ export class OpenRouterProvider extends BaseProvider {
             ...(Object.keys(headers).length > 0 && { headers }),
         });
         // Initialize model with OpenRouter client
+        // OpenRouterChatLanguageModel implements LanguageModelV3 which is part of the LanguageModel union
         this.model = this.openRouterClient(this.modelName || getDefaultOpenRouterModel());
         logger.debug("OpenRouter Provider initialized", {
             modelName: this.modelName,
@@ -123,12 +124,19 @@ export class OpenRouterProvider extends BaseProvider {
             if (errorRecord.message.includes("insufficient_credits")) {
                 return new Error("Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits");
             }
+            // "No endpoints found" — model temporarily unavailable or unsupported parameters
+            // This is distinct from tool errors: it can happen on any request when the
+            // model has no available providers on OpenRouter (e.g., free-tier model down).
+            if (errorRecord.message.includes("No endpoints found")) {
+                return new Error(`No endpoints found for model '${this.modelName}' on OpenRouter. ` +
+                    "The model may be temporarily unavailable or does not support the requested parameters. " +
+                    "Try a different model or check availability at https://openrouter.ai/models");
+            }
             // Tool/function calling errors
             if (errorRecord.message.includes("tool use") ||
                 errorRecord.message.includes("tool_use") ||
                 errorRecord.message.includes("function_call") ||
-                errorRecord.message.includes("tools are not supported") ||
-                errorRecord.message.includes("No endpoints found")) {
+                errorRecord.message.includes("tools are not supported")) {
                 return new Error(`Model '${this.modelName}' does not support tool calling. ` +
                     "Use a tool-capable model like:\n" +
                     "  • google/gemini-2.0-flash-exp:free (free)\n" +
@@ -281,44 +289,64 @@ export class OpenRouterProvider extends BaseProvider {
                 }
             }
             const result = await streamText(streamOptions);
-            result.text.finally(() => timeoutController?.cleanup());
+            // Guard against NoOutputGeneratedError becoming an unhandled rejection.
+            Promise.resolve(result.text)
+                .catch((err) => {
+                logger.debug("Stream text promise rejected (expected for empty streams)", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            })
+                .finally(() => timeoutController?.cleanup());
             // Transform stream to content object stream using fullStream (handles both text and tool calls)
             const transformedStream = (async function* () {
-                // Try fullStream first (handles both text and tool calls), fallback to textStream
-                const streamToUse = result.fullStream || result.textStream;
-                for await (const chunk of streamToUse) {
-                    // Handle different chunk types from fullStream
-                    if (chunk && typeof chunk === "object") {
-                        // Check for error chunks first (critical error handling)
-                        if ("type" in chunk && chunk.type === "error") {
-                            const errorChunk = chunk;
-                            logger.error(`OpenRouter: Error chunk received:`, {
-                                errorType: errorChunk.type,
-                                errorDetails: errorChunk.error,
-                            });
-                            throw new Error(`OpenRouter streaming error: ${errorChunk.error?.message ||
-                                "Unknown error"}`);
-                        }
-                        if ("textDelta" in chunk) {
-                            // Text delta from fullStream
-                            const textDelta = chunk.textDelta;
-                            if (textDelta) {
-                                yield { content: textDelta };
+                try {
+                    // Try fullStream first (handles both text and tool calls), fallback to textStream
+                    const streamToUse = result.fullStream || result.textStream;
+                    for await (const chunk of streamToUse) {
+                        // Handle different chunk types from fullStream
+                        if (chunk && typeof chunk === "object") {
+                            // Check for error chunks first (critical error handling)
+                            if ("type" in chunk && chunk.type === "error") {
+                                const errorChunk = chunk;
+                                logger.error(`OpenRouter: Error chunk received:`, {
+                                    errorType: errorChunk.type,
+                                    errorDetails: errorChunk.error,
+                                });
+                                throw new Error(`OpenRouter streaming error: ${errorChunk.error?.message ||
+                                    "Unknown error"}`);
+                            }
+                            if ("textDelta" in chunk) {
+                                // Text delta from fullStream
+                                const textDelta = chunk.textDelta;
+                                if (textDelta) {
+                                    yield { content: textDelta };
+                                }
+                            }
+                            else if ("type" in chunk &&
+                                chunk.type === "tool-call" &&
+                                "toolCallId" in chunk) {
+                                // Tool call event - log for debugging
+                                const toolCallId = String(chunk.toolCallId);
+                                const toolName = "toolName" in chunk ? String(chunk.toolName) : "unknown";
+                                logger.debug("OpenRouter: Tool call", {
+                                    toolCallId,
+                                    toolName,
+                                });
                             }
                         }
-                        else if (chunk.type === "tool-call-streaming-start") {
-                            // Tool call streaming start event - log for debugging
-                            const toolCall = chunk;
-                            logger.debug("OpenRouter: Tool call streaming start", {
-                                toolCallId: toolCall.toolCallId,
-                                toolName: toolCall.toolName,
-                            });
+                        else if (typeof chunk === "string") {
+                            // Direct string chunk from textStream fallback
+                            yield { content: chunk };
                         }
                     }
-                    else if (typeof chunk === "string") {
-                        // Direct string chunk from textStream fallback
-                        yield { content: chunk };
+                }
+                catch (streamError) {
+                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    if (NoOutputGeneratedError.isInstance(streamError)) {
+                        logger.warn("OpenRouter: Stream produced no output (NoOutputGeneratedError)");
+                        return;
                     }
+                    throw streamError;
                 }
             })();
             // Create analytics promise that resolves after stream completion
@@ -445,7 +473,7 @@ export class OpenRouterProvider extends BaseProvider {
         catch (error) {
             clearTimeout(timeoutId);
             if (isAbortError(error)) {
-                throw new Error(`Request timed out after ${MODELS_DISCOVERY_TIMEOUT_MS / 1000} seconds`);
+                throw new Error(`Request timed out after ${MODELS_DISCOVERY_TIMEOUT_MS / 1000} seconds`, { cause: error });
             }
             throw error;
         }

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

@@ -1,4 +1,4 @@
-import { type Schema, type LanguageModelV1 } from "ai";
+import { type Schema, type LanguageModel } from "ai";
 import type { ZodUnknownSchema } from "../types/typeAliases.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
@@ -19,7 +19,7 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for OpenAI Compatible endpoints
      * Handles auto-discovery if no model was specified
      */
-    protected getAISDKModel(): Promise<LanguageModelV1>;
+    protected getAISDKModel(): Promise<LanguageModel>;
     protected formatProviderError(error: unknown): Error;
     /**
      * OpenAI Compatible endpoints support tools for compatible models

package/dist/lib/providers/openaiCompatible.js

@@ -1,12 +1,12 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { streamText } from "ai";
+import { NoOutputGeneratedError, streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Constants
 const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
 // Configuration helpers
@@ -172,18 +172,17 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 model,
                 messages: messages,
                 ...(options.maxTokens !== null && options.maxTokens !== undefined
-                    ? { maxTokens: options.maxTokens }
+                    ? { maxOutputTokens: options.maxTokens }
                     : {}),
                 ...(options.temperature !== null && options.temperature !== undefined
                     ? { temperature: options.temperature }
                     : {}),
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 tools,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                onStepFinish: ({ toolCalls, toolResults }) => {
-                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                onStepFinish: (event) => {
+                    this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {
                             provider: this.providerName,
                             error: error instanceof Error ? error.message : String(error),
@@ -194,12 +193,22 @@ export class OpenAICompatibleProvider extends BaseProvider {
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface
             const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
+                try {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                }
+                catch (streamError) {
+                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    if (NoOutputGeneratedError.isInstance(streamError)) {
+                        logger.warn("OpenAI-compatible: Stream produced no output (NoOutputGeneratedError)");
+                        return;
+                    }
+                    throw streamError;
                 }
             };
             // Create analytics promise that resolves after stream completion
-            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
                 requestId: `openai-compatible-stream-${Date.now()}`,
                 streamingMode: true,
             });

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

@@ -0,0 +1,28 @@
+/**
+ * Shared type utilities for AI SDK provider integration.
+ *
+ * Provides type-safe helpers to bridge between the AI SDK's generic types
+ * and NeuroLink's internal type system without resorting to `as any` casts.
+ */
+import type { LanguageModel, streamText } from "ai";
+import type { StreamTextResult } from "../types/streamTypes.js";
+/**
+ * Extract the model identifier from a LanguageModel value.
+ *
+ * `LanguageModel` in AI SDK v6 is `string | LanguageModelV2 | LanguageModelV3`.
+ * When it's a string it IS the model ID; when it's an object, `.modelId` holds it.
+ *
+ * @param model  - The LanguageModel value (string or object).
+ * @param fallback - Value returned when the model ID cannot be determined.
+ */
+export declare function getModelId(model: LanguageModel, fallback?: string): string;
+/**
+ * Adapt an AI SDK `StreamTextResult` (generic, parameterised by TOOLS & OUTPUT)
+ * to the simpler NeuroLink `StreamTextResult` expected by the analytics collector.
+ *
+ * The AI SDK result is a structural superset of our local type — every field our
+ * analytics code reads (`textStream`, `text`, `usage`, `response`, `finishReason`,
+ * `toolResults`, `toolCalls`) exists on the SDK result with compatible types.
+ * This function performs the structural down-cast without `as any`.
+ */
+export declare function toAnalyticsStreamResult(result: ReturnType<typeof streamText>): StreamTextResult;

package/dist/lib/providers/providerTypeUtils.js

@@ -0,0 +1,47 @@
+/**
+ * Shared type utilities for AI SDK provider integration.
+ *
+ * Provides type-safe helpers to bridge between the AI SDK's generic types
+ * and NeuroLink's internal type system without resorting to `as any` casts.
+ */
+/**
+ * Type guard: checks whether a LanguageModel value is an object with `modelId`
+ * (i.e. LanguageModelV2 or LanguageModelV3) rather than a bare string ID.
+ */
+function isLanguageModelObject(model) {
+    return typeof model === "object" && model !== null && "modelId" in model;
+}
+/**
+ * Extract the model identifier from a LanguageModel value.
+ *
+ * `LanguageModel` in AI SDK v6 is `string | LanguageModelV2 | LanguageModelV3`.
+ * When it's a string it IS the model ID; when it's an object, `.modelId` holds it.
+ *
+ * @param model  - The LanguageModel value (string or object).
+ * @param fallback - Value returned when the model ID cannot be determined.
+ */
+export function getModelId(model, fallback = "unknown") {
+    if (typeof model === "string") {
+        return model;
+    }
+    if (isLanguageModelObject(model)) {
+        return model.modelId;
+    }
+    return fallback;
+}
+/**
+ * Adapt an AI SDK `StreamTextResult` (generic, parameterised by TOOLS & OUTPUT)
+ * to the simpler NeuroLink `StreamTextResult` expected by the analytics collector.
+ *
+ * The AI SDK result is a structural superset of our local type — every field our
+ * analytics code reads (`textStream`, `text`, `usage`, `response`, `finishReason`,
+ * `toolResults`, `toolCalls`) exists on the SDK result with compatible types.
+ * This function performs the structural down-cast without `as any`.
+ */
+export function toAnalyticsStreamResult(result) {
+    // The AI SDK v6 result is a structural superset of our StreamTextResult.
+    // Both use PromiseLike for async fields and compatible usage shapes
+    // (extractTokenUsage handles both v4 and v6 field names).
+    return result;
+}
+//# sourceMappingURL=providerTypeUtils.js.map

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

@@ -81,7 +81,7 @@ export function getSageMakerConfig(region) {
     }
     catch (error) {
         if (error instanceof z.ZodError) {
-            const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`);
+            const errorMessages = error.issues.map((err) => `${String(err.path.join("."))}: ${err.message}`);
             throw new Error(`SageMaker configuration validation failed:\n${errorMessages.join("\n")}\n\n` +
                 `Please set the required environment variables:\n` +
                 `- AWS_ACCESS_KEY_ID: Your AWS access key\n` +
@@ -89,7 +89,7 @@ export function getSageMakerConfig(region) {
                 `- AWS_REGION: AWS region (default: us-east-1)\n` +
                 `- AWS_SESSION_TOKEN: Session token (optional, for temporary credentials)\n` +
                 `- SAGEMAKER_TIMEOUT: Request timeout in ms (optional, default: 30000)\n` +
-                `- SAGEMAKER_MAX_RETRIES: Max retry attempts (optional, default: 3)`);
+                `- SAGEMAKER_MAX_RETRIES: Max retry attempts (optional, default: 3)`, { cause: error });
         }
         throw error;
     }
@@ -140,8 +140,8 @@ export function getSageMakerModelConfig(endpointName) {
     }
     catch (error) {
         if (error instanceof z.ZodError) {
-            const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`);
-            throw new Error(`SageMaker model configuration validation failed for endpoint '${endpoint}':\n${errorMessages.join("\n")}`);
+            const errorMessages = error.issues.map((err) => `${String(err.path.join("."))}: ${err.message}`);
+            throw new Error(`SageMaker model configuration validation failed for endpoint '${endpoint}':\n${errorMessages.join("\n")}`, { cause: error });
         }
         throw error;
     }
@@ -284,7 +284,7 @@ export async function loadConfigurationFromFile(filePath) {
         return validatedConfig;
     }
     catch (error) {
-        throw new Error(`Failed to load SageMaker configuration from file '${filePath}': ${error instanceof Error ? error.message : "Unknown error"}`);
+        throw new Error(`Failed to load SageMaker configuration from file '${filePath}': ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
     }
 }
 /**

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

@@ -1,26 +1,36 @@
 /**
  * SageMaker Language Model Implementation
  *
- * This module implements the LanguageModelV1 interface for Amazon SageMaker
+ * This module implements the LanguageModel interface for Amazon SageMaker
  * integration with the Vercel AI SDK.
  */
-import type { LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1StreamPart } from "ai";
-import type { SageMakerConfig, SageMakerModelConfig } from "../../types/providers.js";
+import type { SageMakerAsLanguageModel, SageMakerConfig, SageMakerModelConfig } from "../../types/providers.js";
 import type { ConnectivityResult } from "../../types/typeAliases.js";
 /**
- * SageMaker Language Model implementing LanguageModelV1 interface
+ * SageMaker Language Model implementing LanguageModel interface
  *
  * Token Limit Behavior:
  * - When maxTokens is undefined, SageMaker uses the model's default token limits
  * - When maxTokens is specified, it sets max_new_tokens parameter explicitly
  * - This aligns with the unlimited-by-default token policy across all providers
  */
-export declare class SageMakerLanguageModel implements LanguageModelV1 {
-    readonly specificationVersion = "v1";
+export declare class SageMakerLanguageModel implements SageMakerAsLanguageModel {
+    /**
+     * Specification version for the AI SDK LanguageModel interface.
+     * Uses "v2" for structural compatibility with AI SDK v6's `LanguageModelV2`.
+     * The AI SDK checks this field to determine which interface version to use.
+     */
+    readonly specificationVersion: "v2";
     readonly provider = "sagemaker";
     readonly modelId: string;
     readonly supportsStreaming = true;
     readonly defaultObjectGenerationMode: "json";
+    /**
+     * Supported URL patterns by media type.
+     * SageMaker endpoints do not natively download URLs, so this is empty.
+     * Required by the LanguageModelV2 interface.
+     */
+    readonly supportedUrls: Record<string, RegExp[]>;
     private client;
     private config;
     private modelConfig;
@@ -28,7 +38,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
     /**
      * Generate text synchronously using SageMaker endpoint
      */
-    doGenerate(options: LanguageModelV1CallOptions): Promise<{
+    doGenerate(options: Record<string, unknown>): Promise<{
         text?: string;
         reasoning?: string | Array<{
             type: "text";
@@ -51,8 +61,8 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
             }>;
         }>;
         usage: {
-            promptTokens: number;
-            completionTokens: number;
+            inputTokens: number;
+            outputTokens: number;
             totalTokens?: number;
         };
         finishReason: "stop" | "length" | "content-filter" | "tool-calls" | "error" | "unknown";
@@ -74,8 +84,8 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
     /**
      * Generate text with streaming using SageMaker endpoint
      */
-    doStream(options: LanguageModelV1CallOptions): Promise<{
-        stream: ReadableStream<LanguageModelV1StreamPart>;
+    doStream(options: Record<string, unknown>): Promise<{
+        stream: ReadableStream<Record<string, unknown>>;
         rawCall: {
             rawPrompt: unknown;
             rawSettings: Record<string, unknown>;
@@ -129,7 +139,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
     getModelInfo(): {
         modelId: string;
         provider: string;
-        specificationVersion: string;
+        specificationVersion: "v2";
         endpointName: string;
         modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
         region: string;
@@ -176,7 +186,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         };
         modelId: string;
         provider: string;
-        specificationVersion: string;
+        specificationVersion: "v2";
         endpointName: string;
         modelType: "huggingface" | "mistral" | "custom" | "llama" | "claude" | "jumpstart" | undefined;
         region: string;