@juspay/neurolink 7.50.0 → 7.51.1

package/dist/providers/openAI.js

@@ -9,6 +9,7 @@ import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
+import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
 // Configuration helpers - now using consolidated utility
@@ -248,7 +249,8 @@ export class OpenAIProvider extends BaseProvider {
             const hasMultimodalInput = !!(options.input?.images?.length ||
                 options.input?.content?.length ||
                 options.input?.files?.length ||
-                options.input?.csvFiles?.length);
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`OpenAI: Detected multimodal input, using multimodal message builder`, {
@@ -261,26 +263,7 @@ export class OpenAIProvider extends BaseProvider {
                     hasCSVFiles: !!options.input?.csvFiles?.length,
                     csvFileCount: options.input?.csvFiles?.length || 0,
                 });
-                // Create multimodal options for buildMultimodalMessagesArray
-                const multimodalOptions = {
-                    input: {
-                        text: options.input?.text || "",
-                        images: options.input?.images,
-                        content: options.input?.content,
-                        files: options.input?.files,
-                        csvFiles: options.input?.csvFiles,
-                    },
-                    csvOptions: options.csvOptions,
-                    systemPrompt: options.systemPrompt,
-                    conversationHistory: options.conversationMessages,
-                    provider: this.providerName,
-                    model: this.modelName,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    enableAnalytics: options.enableAnalytics,
-                    enableEvaluation: options.enableEvaluation,
-                    context: options.context,
-                };
+                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
                 const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
                 // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
                 messages = convertToCoreMessages(mm);

package/dist/providers/openaiCompatible.js

@@ -5,6 +5,9 @@ import { logger } from "../utils/logger.js";
 import { 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 { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
+import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 // Constants
 const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
 // Configuration helpers
@@ -157,13 +160,46 @@ export class OpenAICompatibleProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Check for multimodal input (images, PDFs, CSVs, files)
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
+            let messages;
+            if (hasMultimodalInput) {
+                logger.debug(`OpenAI Compatible: Detected multimodal input, using multimodal message builder`, {
+                    hasImages: !!options.input?.images?.length,
+                    imageCount: options.input?.images?.length || 0,
+                    hasContent: !!options.input?.content?.length,
+                    contentCount: options.input?.content?.length || 0,
+                    hasFiles: !!options.input?.files?.length,
+                    fileCount: options.input?.files?.length || 0,
+                    hasCSVFiles: !!options.input?.csvFiles?.length,
+                    csvFileCount: options.input?.csvFiles?.length || 0,
+                    hasPDFFiles: !!options.input?.pdfFiles?.length,
+                    pdfFileCount: options.input?.pdfFiles?.length || 0,
+                });
+                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
+                const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
+                messages = convertToCoreMessages(mm);
+            }
+            else {
+                logger.debug(`OpenAI Compatible: Text-only input, using standard message builder`);
+                messages = await buildMessagesArray(options);
+            }
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             const result = streamText({
                 model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                messages: messages,
+                ...(options.maxTokens !== null && options.maxTokens !== undefined
+                    ? { maxTokens: options.maxTokens }
+                    : {}),
+                ...(options.temperature !== null && options.temperature !== undefined
+                    ? { temperature: options.temperature }
+                    : {}),
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,

package/dist/sdk/toolRegistration.js

@@ -2,6 +2,7 @@
  * NeuroLink SDK Tool Registration API
  * Simple interface for developers to register custom tools
  */
+import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { createMCPServerInfo } from "../utils/mcpDefaults.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";

package/dist/types/content.d.ts

@@ -39,10 +39,23 @@ export type CSVContent = {
         description?: string;
     };
 };
+/**
+ * PDF document content type for multimodal messages
+ */
+export type PDFContent = {
+    type: "pdf";
+    data: Buffer | string;
+    metadata?: {
+        filename?: string;
+        pages?: number;
+        version?: string;
+        description?: string;
+    };
+};
 /**
  * Union type for all content types
  */
-export type Content = TextContent | ImageContent | CSVContent;
+export type Content = TextContent | ImageContent | CSVContent | PDFContent;
 /**
  * Vision capability information for providers
  */

package/dist/types/fileTypes.d.ts

@@ -43,6 +43,10 @@ export type FileProcessingResult = {
         columnNames?: string[];
         sampleData?: string;
         hasEmptyColumns?: boolean;
+        version?: string;
+        estimatedPages?: number | null;
+        provider?: string;
+        apiType?: PDFAPIType;
     };
 };
 /**
@@ -53,6 +57,29 @@ export type CSVProcessorOptions = {
     formatStyle?: "raw" | "markdown" | "json";
     includeHeaders?: boolean;
 };
+/**
+ * PDF API types for different providers
+ */
+export type PDFAPIType = "document" | "files-api" | "unsupported";
+/**
+ * PDF provider configuration
+ */
+export interface PDFProviderConfig {
+    maxSizeMB: number;
+    maxPages: number;
+    supportsNative: boolean;
+    requiresCitations: boolean | "auto";
+    apiType: PDFAPIType;
+}
+/**
+ * PDF processor options
+ */
+export type PDFProcessorOptions = {
+    provider?: string;
+    model?: string;
+    maxSizeMB?: number;
+    bedrockApiMode?: "converse" | "invokeModel";
+};
 /**
  * File detector options
  */
@@ -62,4 +89,21 @@ export type FileDetectorOptions = {
     allowedTypes?: FileType[];
     csvOptions?: CSVProcessorOptions;
     confidenceThreshold?: number;
+    provider?: string;
 };
+/**
+ * Google AI Studio Files API types
+ */
+export interface GoogleFilesAPIUploadResult {
+    file: {
+        name: string;
+        displayName: string;
+        mimeType: string;
+        sizeBytes: string;
+        createTime: string;
+        updateTime: string;
+        expirationTime: string;
+        sha256Hash: string;
+        uri: string;
+    };
+}

package/dist/types/generateTypes.d.ts

@@ -16,6 +16,7 @@ export type GenerateOptions = {
         text: string;
         images?: Array<Buffer | string>;
         csvFiles?: Array<Buffer | string>;
+        pdfFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string>;
         content?: Array<TextContent | ImageContent>;
     };

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;
+}