@juspay/neurolink 7.49.0 → 7.51.0

package/dist/types/providers.d.ts

@@ -441,6 +441,19 @@ export type BedrockToolResult = {
  */
 export type BedrockContentBlock = {
     text?: string;
+    image?: {
+        format: "png" | "jpeg" | "gif" | "webp";
+        source: {
+            bytes?: Uint8Array | Buffer;
+        };
+    };
+    document?: {
+        format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+        name: string;
+        source: {
+            bytes?: Uint8Array | Buffer;
+        };
+    };
     toolUse?: BedrockToolUse;
     toolResult?: BedrockToolResult;
 };
@@ -555,6 +568,37 @@ export type ModelsResponse = {
         owned_by?: string;
     }>;
 };
+/**
+ * Ollama tool call structure
+ */
+export type OllamaToolCall = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+/**
+ * Ollama tool result structure
+ */
+export type OllamaToolResult = {
+    tool_call_id: string;
+    content: string;
+};
+/**
+ * Ollama message structure for conversation and tool execution
+ */
+export type OllamaMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    tool_calls?: OllamaToolCall[];
+    images?: string[];
+};
 /**
  * Default model aliases for easy reference
  */

package/dist/types/streamTypes.d.ts

@@ -126,6 +126,7 @@ export interface StreamOptions {
         audio?: AudioInputSpec;
         images?: Array<Buffer | string>;
         csvFiles?: Array<Buffer | string>;
+        pdfFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string>;
         content?: Array<TextContent | ImageContent>;
     };

package/dist/types/tools.js

@@ -2,6 +2,7 @@
  * Type definitions for NeuroLink tool system, including parameter schemas,
  * argument patterns, execution metadata, context, and result types.
  */
+import { z } from "zod";
 /**
  * Type guard for tool result
  */

package/dist/utils/fileDetector.js

@@ -8,6 +8,7 @@ import { readFile, stat } from "fs/promises";
 import { logger } from "./logger.js";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
+import { PDFProcessor } from "./pdfProcessor.js";
 /**
  * Format file size in human-readable units
  */
@@ -56,7 +57,7 @@ export class FileDetector {
         const content = await this.loadContent(input, detection, options);
         // Extract CSV-specific options from FileDetectorOptions
         const csvOptions = options?.csvOptions;
-        return await this.processFile(content, detection, csvOptions);
+        return await this.processFile(content, detection, csvOptions, options?.provider);
     }
     /**
      * Detect file type using multi-strategy approach
@@ -119,12 +120,14 @@ export class FileDetector {
     /**
      * Route to appropriate processor
      */
-    static async processFile(content, detection, options) {
+    static async processFile(content, detection, options, provider) {
         switch (detection.type) {
             case "csv":
                 return await CSVProcessor.process(content, options);
             case "image":
                 return await ImageProcessor.process(content);
+            case "pdf":
+                return await PDFProcessor.process(content, { provider });
             case "text":
                 return {
                     type: "text",
@@ -354,7 +357,7 @@ class ExtensionStrategy {
             mimeType: this.getMimeType(ext),
             extension: ext,
             source: this.detectSource(input),
-            metadata: { confidence: type ? 70 : 0 },
+            metadata: { confidence: type ? 85 : 0 },
         };
     }
     getExtension(input) {

package/dist/utils/messageBuilder.js

@@ -7,6 +7,7 @@ import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemory.js";
 import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerImageAdapter.js";
 import { logger } from "./logger.js";
 import { FileDetector } from "./fileDetector.js";
+import { PDFProcessor } from "./pdfProcessor.js";
 import { request } from "undici";
 import { readFileSync, existsSync } from "fs";
 /**
@@ -32,6 +33,10 @@ function isValidContentItem(item) {
             (contentItem.mimeType === undefined ||
                 typeof contentItem.mimeType === "string"));
     }
+    if (contentItem.type === "file") {
+        return (Buffer.isBuffer(contentItem.data) &&
+            typeof contentItem.mimeType === "string");
+    }
     return false;
 }
 /**
@@ -52,6 +57,15 @@ function convertContentItem(item) {
             ...(contentItem.mimeType && { mimeType: contentItem.mimeType }),
         };
     }
+    if (contentItem.type === "file" &&
+        Buffer.isBuffer(contentItem.data) &&
+        contentItem.mimeType) {
+        return {
+            type: "file",
+            data: contentItem.data,
+            mimeType: contentItem.mimeType,
+        };
+    }
     return null;
 }
 /**
@@ -268,7 +282,7 @@ export async function buildMessagesArray(options) {
                 const filename = extractFilename(file);
                 try {
                     const result = await FileDetector.detectAndProcess(file, {
-                        maxSize: 10 * 1024 * 1024,
+                        maxSize: 50 * 1024 * 1024,
                         allowedTypes: ["csv"],
                         csvOptions: csvOptions,
                     });
@@ -310,6 +324,11 @@ export async function buildMessagesArray(options) {
  * Detects when images are present and routes through provider adapter
  */
 export async function buildMultimodalMessagesArray(options, provider, model) {
+    // Compute provider-specific max PDF size once for consistent validation
+    const pdfConfig = PDFProcessor.getProviderConfig(provider);
+    const maxSize = pdfConfig
+        ? pdfConfig.maxSizeMB * 1024 * 1024
+        : 10 * 1024 * 1024;
     // Process unified files array (auto-detect)
     if (options.input.files && options.input.files.length > 0) {
         logger.info(`[FileDetector] Processing ${options.input.files.length} file(s) with auto-detection`);
@@ -317,9 +336,10 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
         for (const file of options.input.files) {
             try {
                 const result = await FileDetector.detectAndProcess(file, {
-                    maxSize: 10 * 1024 * 1024,
-                    allowedTypes: ["csv", "image"],
+                    maxSize,
+                    allowedTypes: ["csv", "image", "pdf"],
                     csvOptions: options.csvOptions,
+                    provider: provider,
                 });
                 if (result.type === "csv") {
                     const filename = extractFilename(file);
@@ -344,6 +364,13 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
                     ];
                     logger.info(`[FileDetector] ✅ Image: ${result.mimeType}`);
                 }
+                else if (result.type === "pdf") {
+                    options.input.pdfFiles = [
+                        ...(options.input.pdfFiles || []),
+                        result.content,
+                    ];
+                    logger.info(`[FileDetector] ✅ PDF: ${extractFilename(file)}`);
+                }
             }
             catch (error) {
                 logger.error(`[FileDetector] ❌ Failed to process file:`, error);
@@ -384,17 +411,46 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
             }
         }
     }
+    // Track PDF files for multimodal processing (NOT text conversion)
+    const pdfFiles = [];
+    // Process explicit PDF files array
+    if (options.input.pdfFiles && options.input.pdfFiles.length > 0) {
+        logger.info(`[PDF] Processing ${options.input.pdfFiles.length} explicit PDF file(s) for ${provider}`);
+        for (let i = 0; i < options.input.pdfFiles.length; i++) {
+            const pdfFile = options.input.pdfFiles[i];
+            const filename = extractFilename(pdfFile, i);
+            try {
+                const result = await FileDetector.detectAndProcess(pdfFile, {
+                    maxSize,
+                    allowedTypes: ["pdf"],
+                    provider: provider,
+                });
+                if (Buffer.isBuffer(result.content)) {
+                    pdfFiles.push({ buffer: result.content, filename });
+                    logger.info(`[PDF] ✅ Queued for multimodal: ${filename}`);
+                }
+            }
+            catch (error) {
+                logger.error(`[PDF] ❌ Failed to process ${filename}:`, error);
+                throw error;
+            }
+        }
+    }
     // Check if this is a multimodal request
     const hasImages = (options.input.images && options.input.images.length > 0) ||
         (options.input.content &&
             options.input.content.some((c) => c.type === "image"));
-    // If no images, use standard message building and convert to MultimodalChatMessage[]
-    if (!hasImages) {
-        // Clear csvFiles and files arrays to prevent duplication
+    const hasPDFs = pdfFiles.length > 0;
+    // If no images or PDFs, use standard message building and convert to MultimodalChatMessage[]
+    if (!hasImages && !hasPDFs) {
+        // Clear csvFiles, pdfFiles, and files arrays to prevent duplication
         // (already processed and added to options.input.text above)
         if (options.input.csvFiles) {
             options.input.csvFiles = [];
         }
+        if (options.input.pdfFiles) {
+            options.input.pdfFiles = [];
+        }
         if (options.input.files) {
             options.input.files = [];
         }
@@ -441,9 +497,10 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
             // Advanced content format - convert to provider-specific format
             userContent = await convertContentToProviderFormat(options.input.content, provider, model);
         }
-        else if (options.input.images && options.input.images.length > 0) {
-            // Simple images format - convert to provider-specific format
-            userContent = await convertSimpleImagesToProviderFormat(options.input.text, options.input.images, provider, model);
+        else if ((options.input.images && options.input.images.length > 0) ||
+            pdfFiles.length > 0) {
+            // Simple images/PDFs format - convert to provider-specific format
+            userContent = await convertMultimodalToProviderFormat(options.input.text, options.input.images || [], pdfFiles, provider, model);
         }
         else {
             // Text-only fallback
@@ -664,6 +721,35 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
     });
     return content;
 }
+/**
+ * Convert multimodal content (images + PDFs) to provider format
+ */
+async function convertMultimodalToProviderFormat(text, images, pdfFiles, provider, model) {
+    const content = [
+        { type: "text", text },
+    ];
+    // Add images if present
+    if (images.length > 0) {
+        const imageContent = await convertSimpleImagesToProviderFormat("", images, provider, model);
+        if (Array.isArray(imageContent)) {
+            imageContent.forEach((item) => {
+                if (item.type !== "text") {
+                    content.push(item);
+                }
+            });
+        }
+    }
+    // Add PDFs using Vercel AI SDK standard format (works for all providers)
+    content.push(...pdfFiles.map((pdf) => {
+        logger.info(`[PDF] ✅ Added to content (Vercel AI SDK format): ${pdf.filename}`);
+        return {
+            type: "file",
+            data: pdf.buffer,
+            mimeType: "application/pdf",
+        };
+    }));
+    return content;
+}
 /**
  * Extract filename from file input
  */

package/dist/utils/multimodalOptionsBuilder.d.ts

@@ -0,0 +1,67 @@
+import type { StreamOptions } from "../types/streamTypes.js";
+/**
+ * Builds a normalized multimodal options payload for streaming providers.
+ *
+ * This utility extracts and normalizes multimodal input fields from StreamOptions
+ * into a consistent format that can be consumed by buildMultimodalMessagesArray.
+ *
+ * @param {StreamOptions} options - Stream options containing:
+ *   - input.text: Main text prompt
+ *   - input.images: Image files (Buffer | string paths/URLs)
+ *   - input.content: Advanced multimodal content array
+ *   - input.files: Auto-detected file types
+ *   - input.csvFiles: CSV files for tabular data
+ *   - input.pdfFiles: PDF documents (Buffer | string paths)
+ *   - csvOptions: CSV parsing options
+ *   - systemPrompt: System-level instructions
+ *   - conversationMessages: Chat history
+ *   - temperature: Model temperature (0-1)
+ *   - maxTokens: Maximum output tokens
+ *   - enableAnalytics: Enable analytics tracking
+ *   - enableEvaluation: Enable response evaluation
+ *   - context: Additional context data
+ * @param {string} providerName - Provider identifier (e.g., "vertex", "openai", "anthropic")
+ * @param {string} modelName - Model identifier (e.g., "gemini-2.5-flash", "gpt-4o")
+ * @returns {object} Normalized options object with:
+ *   - input: { text, images, content, files, csvFiles, pdfFiles }
+ *   - csvOptions: CSV processing options
+ *   - systemPrompt: System prompt string
+ *   - conversationHistory: Message history array
+ *   - provider: Provider name
+ *   - model: Model name
+ *   - temperature: Temperature value
+ *   - maxTokens: Token limit
+ *   - enableAnalytics: Analytics flag
+ *   - enableEvaluation: Evaluation flag
+ *   - context: Context data
+ *
+ * @example
+ * ```typescript
+ * const opts = buildMultimodalOptions(streamOptions, "vertex", "gemini-2.5-flash");
+ * const messages = await buildMultimodalMessagesArray(opts, "vertex", "gemini-2.5-flash");
+ * ```
+ */
+export declare function buildMultimodalOptions(options: StreamOptions, providerName: string, modelName: string): {
+    input: {
+        text: string;
+        images: (string | Buffer<ArrayBufferLike>)[] | undefined;
+        content: (import("../types/content.js").TextContent | import("../types/content.js").ImageContent)[] | undefined;
+        files: (string | Buffer<ArrayBufferLike>)[] | undefined;
+        csvFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
+        pdfFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
+    };
+    csvOptions: {
+        maxRows?: number;
+        formatStyle?: "raw" | "markdown" | "json";
+        includeHeaders?: boolean;
+    } | undefined;
+    systemPrompt: string | undefined;
+    conversationHistory: import("../types/conversation.js").ChatMessage[] | undefined;
+    provider: string;
+    model: string;
+    temperature: number | undefined;
+    maxTokens: number | undefined;
+    enableAnalytics: boolean | undefined;
+    enableEvaluation: boolean | undefined;
+    context: import("../types/common.js").UnknownRecord | undefined;
+};

package/dist/utils/multimodalOptionsBuilder.js

@@ -0,0 +1,64 @@
+/**
+ * Builds a normalized multimodal options payload for streaming providers.
+ *
+ * This utility extracts and normalizes multimodal input fields from StreamOptions
+ * into a consistent format that can be consumed by buildMultimodalMessagesArray.
+ *
+ * @param {StreamOptions} options - Stream options containing:
+ *   - input.text: Main text prompt
+ *   - input.images: Image files (Buffer | string paths/URLs)
+ *   - input.content: Advanced multimodal content array
+ *   - input.files: Auto-detected file types
+ *   - input.csvFiles: CSV files for tabular data
+ *   - input.pdfFiles: PDF documents (Buffer | string paths)
+ *   - csvOptions: CSV parsing options
+ *   - systemPrompt: System-level instructions
+ *   - conversationMessages: Chat history
+ *   - temperature: Model temperature (0-1)
+ *   - maxTokens: Maximum output tokens
+ *   - enableAnalytics: Enable analytics tracking
+ *   - enableEvaluation: Enable response evaluation
+ *   - context: Additional context data
+ * @param {string} providerName - Provider identifier (e.g., "vertex", "openai", "anthropic")
+ * @param {string} modelName - Model identifier (e.g., "gemini-2.5-flash", "gpt-4o")
+ * @returns {object} Normalized options object with:
+ *   - input: { text, images, content, files, csvFiles, pdfFiles }
+ *   - csvOptions: CSV processing options
+ *   - systemPrompt: System prompt string
+ *   - conversationHistory: Message history array
+ *   - provider: Provider name
+ *   - model: Model name
+ *   - temperature: Temperature value
+ *   - maxTokens: Token limit
+ *   - enableAnalytics: Analytics flag
+ *   - enableEvaluation: Evaluation flag
+ *   - context: Context data
+ *
+ * @example
+ * ```typescript
+ * const opts = buildMultimodalOptions(streamOptions, "vertex", "gemini-2.5-flash");
+ * const messages = await buildMultimodalMessagesArray(opts, "vertex", "gemini-2.5-flash");
+ * ```
+ */
+export function buildMultimodalOptions(options, providerName, modelName) {
+    return {
+        input: {
+            text: options.input?.text || "",
+            images: options.input?.images,
+            content: options.input?.content,
+            files: options.input?.files,
+            csvFiles: options.input?.csvFiles,
+            pdfFiles: options.input?.pdfFiles,
+        },
+        csvOptions: options.csvOptions,
+        systemPrompt: options.systemPrompt,
+        conversationHistory: options.conversationMessages,
+        provider: providerName,
+        model: modelName,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        enableAnalytics: options.enableAnalytics,
+        enableEvaluation: options.enableEvaluation,
+        context: options.context,
+    };
+}

package/dist/utils/pdfProcessor.d.ts

@@ -0,0 +1,10 @@
+import type { FileProcessingResult, PDFProviderConfig, PDFProcessorOptions } from "../types/fileTypes.js";
+export declare class PDFProcessor {
+    private static readonly PDF_SIGNATURE;
+    static process(content: Buffer, options?: PDFProcessorOptions): Promise<FileProcessingResult>;
+    static supportsNativePDF(provider: string): boolean;
+    static getProviderConfig(provider: string): PDFProviderConfig | null;
+    private static isValidPDF;
+    private static extractBasicMetadata;
+    static estimateTokens(pageCount: number, mode?: "text-only" | "visual"): number;
+}

package/dist/utils/pdfProcessor.js

@@ -0,0 +1,198 @@
+import { logger } from "./logger.js";
+const PDF_PROVIDER_CONFIGS = {
+    anthropic: {
+        maxSizeMB: 5,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "document",
+    },
+    bedrock: {
+        maxSizeMB: 5,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: "auto",
+        apiType: "document",
+    },
+    "google-vertex": {
+        maxSizeMB: 5,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "document",
+    },
+    vertex: {
+        maxSizeMB: 5,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "document",
+    },
+    "google-ai-studio": {
+        maxSizeMB: 2000,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    gemini: {
+        maxSizeMB: 2000,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    "google-ai": {
+        maxSizeMB: 2000,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    openai: {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    azure: {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    "azure-openai": {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    litellm: {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    "openai-compatible": {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    mistral: {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    "hugging-face": {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+    huggingface: {
+        maxSizeMB: 10,
+        maxPages: 100,
+        supportsNative: true,
+        requiresCitations: false,
+        apiType: "files-api",
+    },
+};
+export class PDFProcessor {
+    // PDF magic bytes: %PDF-
+    static PDF_SIGNATURE = Buffer.from("%PDF-", "ascii");
+    static async process(content, options) {
+        const provider = (options?.provider || "unknown").toLowerCase();
+        const config = PDF_PROVIDER_CONFIGS[provider];
+        if (!this.isValidPDF(content)) {
+            throw new Error("Invalid PDF file format. File must start with %PDF- header.");
+        }
+        if (!config || !config.supportsNative) {
+            const supportedProviders = Object.keys(PDF_PROVIDER_CONFIGS)
+                .filter((p) => PDF_PROVIDER_CONFIGS[p].supportsNative)
+                .join(", ");
+            throw new Error(`PDF files are not currently supported with ${provider} provider.\n` +
+                `Supported providers: ${supportedProviders}\n` +
+                `Current provider: ${provider}\n\n` +
+                `Options:\n` +
+                `1. Switch to a supported provider (--provider openai or --provider vertex)\n` +
+                `2. Convert your PDF to text manually`);
+        }
+        const sizeMB = content.length / (1024 * 1024);
+        if (sizeMB > config.maxSizeMB) {
+            throw new Error(`PDF size ${sizeMB.toFixed(2)}MB exceeds ${config.maxSizeMB}MB limit for ${provider}`);
+        }
+        const metadata = this.extractBasicMetadata(content);
+        if (metadata.estimatedPages && metadata.estimatedPages > config.maxPages) {
+            logger.warn(`[PDF] PDF appears to have ${metadata.estimatedPages}+ pages. ` +
+                `${provider} supports up to ${config.maxPages} pages.`);
+        }
+        if (provider === "bedrock" && options?.bedrockApiMode === "converse") {
+            logger.info("[PDF] Using Bedrock Converse API. " +
+                "Visual PDF analysis requires citations enabled. " +
+                "Text-only mode: ~1,000 tokens/3 pages. " +
+                "Visual mode: ~7,000 tokens/3 pages.");
+        }
+        logger.info("[PDF] ✅ Validated PDF file", {
+            provider,
+            size: `${sizeMB.toFixed(2)}MB`,
+            version: metadata.version,
+            estimatedPages: metadata.estimatedPages,
+            apiType: config.apiType,
+        });
+        return {
+            type: "pdf",
+            content,
+            mimeType: "application/pdf",
+            metadata: {
+                confidence: 100,
+                size: content.length,
+                ...metadata,
+                provider,
+                apiType: config.apiType,
+            },
+        };
+    }
+    static supportsNativePDF(provider) {
+        const config = PDF_PROVIDER_CONFIGS[provider];
+        return config?.supportsNative || false;
+    }
+    static getProviderConfig(provider) {
+        return PDF_PROVIDER_CONFIGS[provider] || null;
+    }
+    static isValidPDF(buffer) {
+        if (buffer.length < 5) {
+            return false;
+        }
+        return buffer.subarray(0, 5).equals(this.PDF_SIGNATURE);
+    }
+    static extractBasicMetadata(buffer) {
+        const headerSize = Math.min(10000, buffer.length);
+        const header = buffer.toString("utf-8", 0, headerSize);
+        const versionMatch = header.match(/%PDF-(\d\.\d)/);
+        const version = versionMatch ? versionMatch[1] : "unknown";
+        const pageMatches = header.match(/\/Type\s*\/Page[^s]/g);
+        const estimatedPages = pageMatches ? pageMatches.length : null;
+        return {
+            version,
+            estimatedPages,
+            filename: undefined,
+        };
+    }
+    static estimateTokens(pageCount, mode = "visual") {
+        if (mode === "text-only") {
+            return Math.ceil((pageCount / 3) * 1000);
+        }
+        else {
+            return Math.ceil((pageCount / 3) * 7000);
+        }
+    }
+}