@juspay/neurolink 9.30.0 → 9.31.1

package/dist/lib/observability/retryPolicy.d.ts

@@ -2,6 +2,7 @@
  * Retry Policy
  * Configurable retry strategies for observability exporters
  */
+import type { RetryPolicy } from "../types/observability.js";
 /**
  * Result of a retry decision
  */
@@ -28,19 +29,7 @@ export type RetryContext = {
     /** Additional metadata */
     metadata?: Record<string, unknown>;
 };
-/**
- * Retry policy interface
- */
-export interface RetryPolicy {
-    /** Policy name for identification */
-    readonly name: string;
-    /** Decide whether to retry */
-    shouldRetry(context: RetryContext): RetryDecision;
-    /** Maximum attempts allowed */
-    readonly maxAttempts: number;
-    /** Maximum total time allowed for retries */
-    readonly maxTotalTimeMs: number;
-}
+export type { RetryPolicy };
 /**
  * Base retry policy with common configuration
  */

package/dist/lib/observability/sampling/samplers.d.ts

@@ -4,17 +4,8 @@
  */
 import type { SamplerConfig, SamplingRule } from "../types/exporterTypes.js";
 import type { SpanData } from "../types/spanTypes.js";
-/**
- * Sampler interface for controlling which spans are exported
- */
-export interface Sampler {
-    /** Sampler name for identification */
-    readonly name: string;
-    /** Determine if a span should be sampled */
-    shouldSample(span: SpanData): boolean;
-    /** Get sampling decision description */
-    getDescription(): string;
-}
+import type { Sampler } from "../../types/observability.js";
+export type { Sampler };
 /**
  * Always sample all spans
  */

package/dist/lib/observability/spanProcessor.d.ts

@@ -4,20 +4,8 @@
  * Fills the 9% gap in pattern compliance
  */
 import type { SpanAttributes, SpanData } from "./types/index.js";
-/**
- * Span processor interface
- * Allows for composable span processing pipelines
- */
-export interface SpanProcessor {
-    /** Processor name for identification */
-    readonly name: string;
-    /** Process a span before export, returns null to drop the span */
-    process(span: SpanData): SpanData | null;
-    /** Optional async processing (for external lookups, etc.) */
-    processAsync?(span: SpanData): Promise<SpanData | null>;
-    /** Shutdown the processor (cleanup resources) */
-    shutdown?(): Promise<void>;
-}
+import type { SpanProcessor } from "../types/observability.js";
+export type { SpanProcessor };
 /**
  * No-op processor that passes spans through unchanged
  */

package/dist/lib/processors/base/BaseFileProcessor.js

@@ -388,7 +388,7 @@ export class BaseFileProcessor {
                     buffer = Buffer.from(await gunzipAsync(buffer));
                 }
                 catch (gzipError) {
-                    throw new Error(`Failed to decompress gzip response: ${gzipError instanceof Error ? gzipError.message : String(gzipError)}`);
+                    throw new Error(`Failed to decompress gzip response: ${gzipError instanceof Error ? gzipError.message : String(gzipError)}`, { cause: gzipError });
                 }
             }
             return buffer;

package/dist/lib/processors/document/OpenDocumentProcessor.js

@@ -53,8 +53,8 @@ export class OpenDocumentProcessor extends BaseFileProcessor {
     buildProcessedResult(buffer, fileInfo) {
         const ext = this.getExtension(fileInfo.name);
         const format = this.detectFormat(ext);
-        let textContent = "";
-        let paragraphCount = 0;
+        let textContent;
+        let paragraphCount;
         let truncated = false;
         try {
             // Dynamically import adm-zip to avoid issues if not available
@@ -81,7 +81,9 @@ export class OpenDocumentProcessor extends BaseFileProcessor {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Unknown error";
-            throw new Error(`Failed to extract OpenDocument content: ${message}`);
+            throw new Error(`Failed to extract OpenDocument content: ${message}`, {
+                cause: error,
+            });
         }
         return {
             textContent,

package/dist/lib/processors/media/VideoProcessor.js

@@ -53,6 +53,8 @@ import { pipeline } from "stream/promises";
 import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { FileErrorCode } from "../errors/index.js";
+import { tracers, ATTR, withSpan } from "../../telemetry/index.js";
+import { logger } from "../../utils/logger.js";
 // =============================================================================
 // FFMPEG PATH INITIALIZATION
 // =============================================================================
@@ -282,130 +284,184 @@ export class VideoProcessor extends BaseFileProcessor {
      * @returns Processing result with extracted video data or error
      */
     async processFile(fileInfo, options) {
-        // Ensure ffmpeg paths are initialized before any processing
-        await initFfmpegPaths();
-        // Temp directory for this processing run
-        const tempDir = join(tmpdir(), `neurolink-video-${randomUUID()}`);
-        let tempCreated = false;
-        try {
-            // Step 1: Validate file type and size
-            const validationResult = this.validateFileWithResult(fileInfo);
-            if (!validationResult.success) {
-                return { success: false, error: validationResult.error };
-            }
-            // Step 2: Get file buffer
-            let buffer;
-            if (fileInfo.buffer) {
-                buffer = fileInfo.buffer;
-            }
-            else if (fileInfo.url) {
-                const downloadResult = await this.downloadFileWithRetry(fileInfo, options);
-                if (!downloadResult.success) {
-                    return { success: false, error: downloadResult.error };
+        const filename = this.getFilename(fileInfo);
+        const sizeBytes = fileInfo.size || fileInfo.buffer?.length || 0;
+        return withSpan({
+            name: "neurolink.file.video.process",
+            tracer: tracers.file,
+            attributes: {
+                [ATTR.FILE_NAME]: filename,
+                [ATTR.FILE_MIMETYPE]: fileInfo.mimetype || "video/mp4",
+                [ATTR.FILE_SIZE_BYTES]: sizeBytes,
+            },
+        }, async (span) => {
+            logger.info(`[NEUROLINK] Video processing started: ${filename} (${(sizeBytes / (1024 * 1024)).toFixed(2)} MB, ${fileInfo.mimetype || "video/mp4"})`);
+            // Ensure ffmpeg paths are initialized before any processing
+            await initFfmpegPaths();
+            // Temp directory for this processing run
+            const tempDir = join(tmpdir(), `neurolink-video-${randomUUID()}`);
+            let tempCreated = false;
+            try {
+                // Step 1: Validate file type and size
+                const validationResult = this.validateFileWithResult(fileInfo);
+                if (!validationResult.success) {
+                    const validationErrMsg = validationResult.error?.message || "Validation failed";
+                    span.setAttribute(ATTR.FILE_SUCCESS, false);
+                    span.setAttribute(ATTR.FILE_ERROR, validationErrMsg);
+                    logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${validationErrMsg}`);
+                    return { success: false, error: validationResult.error };
+                }
+                // Step 2: Get file buffer
+                let buffer;
+                if (fileInfo.buffer) {
+                    buffer = fileInfo.buffer;
                 }
-                if (!downloadResult.data) {
+                else if (fileInfo.url) {
+                    const downloadResult = await this.downloadFileWithRetry(fileInfo, options);
+                    if (!downloadResult.success) {
+                        const downloadErrMsg = downloadResult.error?.message || "Download failed";
+                        span.setAttribute(ATTR.FILE_SUCCESS, false);
+                        span.setAttribute(ATTR.FILE_ERROR, downloadErrMsg);
+                        logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${downloadErrMsg}`);
+                        return { success: false, error: downloadResult.error };
+                    }
+                    if (!downloadResult.data) {
+                        const errMsg = "Download succeeded but returned no data";
+                        span.setAttribute(ATTR.FILE_SUCCESS, false);
+                        span.setAttribute(ATTR.FILE_ERROR, errMsg);
+                        logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${errMsg}`);
+                        return {
+                            success: false,
+                            error: this.createError(FileErrorCode.DOWNLOAD_FAILED, {
+                                reason: errMsg,
+                            }),
+                        };
+                    }
+                    buffer = downloadResult.data;
+                    // Validate actual downloaded size
+                    if (!this.validateFileSize(buffer.length)) {
+                        const errMsg = `File too large: ${(buffer.length / (1024 * 1024)).toFixed(2)} MB (max: ${this.config.maxSizeMB} MB)`;
+                        span.setAttribute(ATTR.FILE_SUCCESS, false);
+                        span.setAttribute(ATTR.FILE_ERROR, errMsg);
+                        logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${errMsg}`);
+                        return {
+                            success: false,
+                            error: this.createError(FileErrorCode.FILE_TOO_LARGE, {
+                                sizeMB: (buffer.length / (1024 * 1024)).toFixed(2),
+                                maxMB: this.config.maxSizeMB,
+                                type: this.config.fileTypeName,
+                            }),
+                        };
+                    }
+                }
+                else {
+                    const errMsg = "No buffer or URL provided for file";
+                    span.setAttribute(ATTR.FILE_SUCCESS, false);
+                    span.setAttribute(ATTR.FILE_ERROR, errMsg);
+                    logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${errMsg}`);
                     return {
                         success: false,
                         error: this.createError(FileErrorCode.DOWNLOAD_FAILED, {
-                            reason: "Download succeeded but returned no data",
+                            reason: errMsg,
                         }),
                     };
                 }
-                buffer = downloadResult.data;
-                // Validate actual downloaded size
-                if (!this.validateFileSize(buffer.length)) {
+                // Step 3: Write buffer to temp file (ffmpeg needs a file path)
+                await fs.mkdir(tempDir, { recursive: true });
+                tempCreated = true;
+                const extension = this.getExtensionFromFileInfo(fileInfo);
+                const tempVideoPath = join(tempDir, `input${extension}`);
+                await this.writeBufferToFile(buffer, tempVideoPath);
+                // Step 4: Extract metadata via ffprobe
+                const probeResult = await this.probeVideo(tempVideoPath);
+                if (!probeResult.success) {
+                    const errMsg = probeResult.error || "ffprobe failed";
+                    span.setAttribute(ATTR.FILE_SUCCESS, false);
+                    span.setAttribute(ATTR.FILE_ERROR, errMsg);
+                    logger.warn(`[NEUROLINK] Video skipped/failed: ${filename} — reason: ${errMsg}`);
                     return {
                         success: false,
-                        error: this.createError(FileErrorCode.FILE_TOO_LARGE, {
-                            sizeMB: (buffer.length / (1024 * 1024)).toFixed(2),
-                            maxMB: this.config.maxSizeMB,
-                            type: this.config.fileTypeName,
+                        error: this.createError(FileErrorCode.PROCESSING_FAILED, {
+                            fileType: "video",
+                            reason: probeResult.error,
                         }),
                     };
                 }
-            }
-            else {
+                const probeData = probeResult.data;
+                const metadata = this.buildMetadata(probeData, buffer.length);
+                // Record video-specific metadata on span
+                span.setAttribute(ATTR.VIDEO_DURATION_SEC, metadata.duration);
+                span.setAttribute(ATTR.VIDEO_WIDTH, metadata.width);
+                span.setAttribute(ATTR.VIDEO_HEIGHT, metadata.height);
+                span.setAttribute(ATTR.VIDEO_CODEC, metadata.codec);
+                span.setAttribute(ATTR.VIDEO_HAS_SUBTITLES, metadata.subtitleTracks > 0);
+                // Step 5: Extract keyframes
+                let keyframes = [];
+                try {
+                    keyframes = await this.extractKeyframes(tempVideoPath, tempDir, metadata.duration);
+                }
+                catch {
+                    // Non-fatal: continue without keyframes if extraction fails
+                    // (e.g., audio-only file in a video container)
+                    logger.warn(`[NEUROLINK] Video keyframe extraction failed for ${filename}, continuing without keyframes`);
+                }
+                span.setAttribute(ATTR.VIDEO_KEYFRAMES_EXTRACTED, keyframes.length);
+                // Step 6: Extract subtitles
+                let subtitleText;
+                if (metadata.subtitleTracks > 0) {
+                    try {
+                        subtitleText = await this.extractSubtitles(tempVideoPath, tempDir);
+                    }
+                    catch {
+                        // Non-fatal: continue without subtitles if extraction fails
+                    }
+                }
+                // Step 7: Build textContent for LLM
+                const textContent = this.buildTextContent(metadata, keyframes.length, subtitleText, this.getFilename(fileInfo));
+                span.setAttribute(ATTR.VIDEO_TEXT_CONTENT_LENGTH, textContent.length);
+                span.setAttribute(ATTR.FILE_OUTPUT_LENGTH, textContent.length);
+                span.setAttribute(ATTR.FILE_SUCCESS, true);
+                logger.info(`[NEUROLINK] Video processed: ${filename} → ${textContent.length} bytes text + ${keyframes.length} keyframes ` +
+                    `(${metadata.durationFormatted}, ${metadata.width}x${metadata.height}, ${metadata.codec})`);
+                // Step 8: Return structured result
                 return {
-                    success: false,
-                    error: this.createError(FileErrorCode.DOWNLOAD_FAILED, {
-                        reason: "No buffer or URL provided for file",
-                    }),
+                    success: true,
+                    data: {
+                        buffer,
+                        mimetype: fileInfo.mimetype || "video/mp4",
+                        size: fileInfo.size,
+                        filename: this.getFilename(fileInfo),
+                        textContent,
+                        keyframes,
+                        metadata,
+                        subtitleText,
+                        hasKeyframes: keyframes.length > 0,
+                        frameCount: keyframes.length,
+                    },
                 };
             }
-            // Step 3: Write buffer to temp file (ffmpeg needs a file path)
-            await fs.mkdir(tempDir, { recursive: true });
-            tempCreated = true;
-            const extension = this.getExtensionFromFileInfo(fileInfo);
-            const tempVideoPath = join(tempDir, `input${extension}`);
-            await this.writeBufferToFile(buffer, tempVideoPath);
-            // Step 4: Extract metadata via ffprobe
-            const probeResult = await this.probeVideo(tempVideoPath);
-            if (!probeResult.success) {
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                span.setAttribute(ATTR.FILE_SUCCESS, false);
+                span.setAttribute(ATTR.FILE_ERROR, errMsg);
+                logger.error(`[NEUROLINK] Video processing failed: ${filename} — ${errMsg}`);
                 return {
                     success: false,
                     error: this.createError(FileErrorCode.PROCESSING_FAILED, {
                         fileType: "video",
-                        reason: probeResult.error,
-                    }),
+                        error: errMsg,
+                    }, error instanceof Error ? error : undefined),
                 };
             }
-            const probeData = probeResult.data;
-            const metadata = this.buildMetadata(probeData, buffer.length);
-            // Step 5: Extract keyframes
-            let keyframes = [];
-            try {
-                keyframes = await this.extractKeyframes(tempVideoPath, tempDir, metadata.duration);
-            }
-            catch {
-                // Non-fatal: continue without keyframes if extraction fails
-                // (e.g., audio-only file in a video container)
-            }
-            // Step 6: Extract subtitles
-            let subtitleText;
-            if (metadata.subtitleTracks > 0) {
-                try {
-                    subtitleText = await this.extractSubtitles(tempVideoPath, tempDir);
-                }
-                catch {
-                    // Non-fatal: continue without subtitles if extraction fails
+            finally {
+                // Step 8: Clean up temp files
+                if (tempCreated) {
+                    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {
+                        // Ignore cleanup errors - temp files will be cleaned by OS eventually
+                    });
                 }
             }
-            // Step 7: Build textContent for LLM
-            const textContent = this.buildTextContent(metadata, keyframes.length, subtitleText, this.getFilename(fileInfo));
-            // Step 8: Return structured result
-            return {
-                success: true,
-                data: {
-                    buffer,
-                    mimetype: fileInfo.mimetype || "video/mp4",
-                    size: fileInfo.size,
-                    filename: this.getFilename(fileInfo),
-                    textContent,
-                    keyframes,
-                    metadata,
-                    subtitleText,
-                    hasKeyframes: keyframes.length > 0,
-                    frameCount: keyframes.length,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: this.createError(FileErrorCode.PROCESSING_FAILED, {
-                    fileType: "video",
-                    error: error instanceof Error ? error.message : String(error),
-                }, error instanceof Error ? error : undefined),
-            };
-        }
-        finally {
-            // Step 8: Clean up temp files
-            if (tempCreated) {
-                await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {
-                    // Ignore cleanup errors - temp files will be cleaned by OS eventually
-                });
-            }
-        }
+        });
     }
     // ===========================================================================
     // METADATA EXTRACTION

package/dist/lib/providers/amazonBedrock.js

@@ -580,9 +580,13 @@ export class AmazonBedrockProvider extends BaseProvider {
         const result = {};
         for (const [name, tool] of Object.entries(aiTools)) {
             if ("description" in tool && tool.description) {
+                // Extract schema from legacy `parameters` (AI SDK v3/v4) or current `inputSchema` (v6)
+                const legacyTool = tool;
+                const extractedParams = legacyTool.parameters ??
+                    tool.inputSchema;
                 result[name] = {
                     description: tool.description,
-                    parameters: "parameters" in tool ? tool.parameters : undefined,
+                    parameters: extractedParams,
                     execute: async (params) => {
                         if ("execute" in tool && tool.execute) {
                             const result = await tool.execute(params, {
@@ -826,6 +830,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                             message: "Generate method returned null result",
                         });
                         streamSpan.end();
+                        // eslint-disable-next-line preserve-caught-error
                         throw new Error("Generate method returned null result");
                     }
                     streamSpan.setAttribute("gen_ai.response.stop_reason", "fallback_end_turn");
@@ -1388,18 +1393,20 @@ export class AmazonBedrockProvider extends BaseProvider {
             clearTimeout(timeoutId);
             const errorObj = error;
             if (isAbortError(error)) {
-                throw new Error("Bedrock health check timed out after 10 seconds");
+                throw new Error("Bedrock health check timed out after 10 seconds", {
+                    cause: error,
+                });
             }
             const errorMessage = typeof errorObj.message === "string" ? errorObj.message : "";
             if (errorMessage.includes("UnauthorizedOperation") ||
                 errorMessage.includes("AccessDenied")) {
-                throw new Error("Bedrock access denied. Check your AWS credentials and IAM permissions for bedrock:ListFoundationModels");
+                throw new Error("Bedrock access denied. Check your AWS credentials and IAM permissions for bedrock:ListFoundationModels", { cause: error });
             }
             if (errorObj.code === "ECONNREFUSED" || errorObj.code === "ENOTFOUND") {
-                throw new Error("Unable to connect to Bedrock service. Check your network connectivity and AWS region configuration");
+                throw new Error("Unable to connect to Bedrock service. Check your network connectivity and AWS region configuration", { cause: error });
             }
             logger.error("❌ [AmazonBedrockProvider] Health check failed:", error);
-            throw new Error(`Bedrock health check failed: ${errorMessage || "Unknown error"}`);
+            throw new Error(`Bedrock health check failed: ${errorMessage || "Unknown error"}`, { cause: error });
         }
         finally {
             clearTimeout(timeoutId);

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

@@ -4,8 +4,8 @@
  * This module provides a simplified SageMaker provider that extends BaseProvider
  * and integrates with the NeuroLink ecosystem using existing patterns.
  */
-import type { LanguageModelV1, Schema } from "ai";
-import type { ZodType, ZodTypeDef } from "zod";
+import type { LanguageModel, Schema } from "ai";
+import type { ZodType } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -20,8 +20,8 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     constructor(modelName?: string, endpointName?: string, region?: string, neurolink?: NeuroLink);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
-    protected getAISDKModel(): LanguageModelV1;
-    protected executeStream(_options: StreamOptions, _analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected getAISDKModel(): LanguageModel;
+    protected executeStream(_options: StreamOptions, _analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
     protected formatProviderError(error: unknown): Error;
     /**
      * Get SageMaker-specific provider information
@@ -42,7 +42,7 @@ export declare class AmazonSageMakerProvider extends BaseProvider {
     /**
      * Public method to get the AI SDK model for CLI and external usage
      */
-    getModel(): Promise<LanguageModelV1>;
+    getModel(): Promise<LanguageModel>;
     /**
      * Test connectivity to the SageMaker endpoint
      */

package/dist/lib/providers/amazonSagemaker.js

@@ -23,8 +23,12 @@ export class AmazonSageMakerProvider extends BaseProvider {
             // Load and validate configuration
             this.sagemakerConfig = getSageMakerConfig(region);
             this.modelConfig = getSageMakerModelConfig(endpointName || getDefaultSageMakerEndpoint());
-            // Create the proper LanguageModel (v2) implementation
-            this.sagemakerModel = new SageMakerLanguageModel(this.modelName, this.sagemakerConfig, this.modelConfig);
+            // Create the SageMaker LanguageModel implementation.
+            // SageMakerLanguageModel implements SageMakerAsLanguageModel which is
+            // structurally compatible with LanguageModelV2 (specificationVersion "v2",
+            // modelId, provider, supportedUrls, doGenerate, doStream).
+            const smModel = new SageMakerLanguageModel(this.modelName, this.sagemakerConfig, this.modelConfig);
+            this.sagemakerModel = smModel;
             logger.debug("Amazon SageMaker Provider initialized", {
                 modelName: this.modelName,
                 endpointName: this.modelConfig.endpointName,

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

@@ -1,4 +1,4 @@
-import { type LanguageModelV1 } from "ai";
+import { type LanguageModel } from "ai";
 import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { TextGenerationOptions, EnhancedGenerateResult } from "../types/generateTypes.js";
@@ -129,7 +129,7 @@ export declare class AnthropicProvider extends BaseProvider {
     /**
      * Returns the Vercel AI SDK model instance for Anthropic
      */
-    getAISDKModel(): LanguageModelV1;
+    getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
     /**
      * Override generate to refresh the OAuth token before delegating to
@@ -138,7 +138,7 @@ export declare class AnthropicProvider extends BaseProvider {
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     isAvailable(): Promise<boolean>;
-    getModel(): LanguageModelV1;
+    getModel(): LanguageModel;
 }
 export { ModelAccessError, isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
 export { ANTHROPIC_BETA_HEADERS };