@juspay/neurolink 9.94.1 → 9.94.3

package/dist/utils/csvUtils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared, RFC-4180-aware delimiter-separated-value helpers.
+ *
+ * Consolidates quote-aware field counting/splitting that was previously
+ * duplicated across csvProcessor.ts and fileDetector.ts (#359), and adds
+ * delimiter detection so TSV / semicolon / pipe files parse correctly (#361).
+ * Keeping these in one module prevents the same quoting edge case from having
+ * to be fixed in three places and drifting out of sync.
+ */
+/** Delimiter candidates, in tie-break preference order (comma first). */
+export declare const CANDIDATE_DELIMITERS: readonly [",", "\t", ";", "|"];
+/**
+ * Split a single line into fields, respecting RFC-4180 quoting: a delimiter
+ * inside a `"…"` quoted field does not split, and `""` is an escaped quote.
+ */
+export declare function splitCSVFields(line: string, delimiter?: string): string[];
+/** Count fields in a single line, respecting RFC-4180 quoting. */
+export declare function countCSVColumns(line: string, delimiter?: string): number;
+/**
+ * Detect the delimiter of DSV content by testing comma/tab/semicolon/pipe
+ * against up to 5 sampled non-empty lines and keeping the candidate with the
+ * most consistent (>1) column count. Comma wins ties and the "nothing splits"
+ * case, so plain CSVs are never reclassified. An optional extension hint
+ * (`tsv` → tab, `psv` → pipe) breaks ambiguity in the file's favor.
+ */
+export declare function detectDelimiter(lines: string[], extensionHint?: string): string;

package/dist/utils/csvUtils.js

@@ -0,0 +1,84 @@
+/**
+ * Shared, RFC-4180-aware delimiter-separated-value helpers.
+ *
+ * Consolidates quote-aware field counting/splitting that was previously
+ * duplicated across csvProcessor.ts and fileDetector.ts (#359), and adds
+ * delimiter detection so TSV / semicolon / pipe files parse correctly (#361).
+ * Keeping these in one module prevents the same quoting edge case from having
+ * to be fixed in three places and drifting out of sync.
+ */
+/** Delimiter candidates, in tie-break preference order (comma first). */
+export const CANDIDATE_DELIMITERS = [",", "\t", ";", "|"];
+/**
+ * Split a single line into fields, respecting RFC-4180 quoting: a delimiter
+ * inside a `"…"` quoted field does not split, and `""` is an escaped quote.
+ */
+export function splitCSVFields(line, delimiter = ",") {
+    const fields = [];
+    let field = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                field += '"';
+                i++; // consume the escaped quote
+                continue;
+            }
+            inQuotes = !inQuotes;
+        }
+        else if (ch === delimiter && !inQuotes) {
+            fields.push(field);
+            field = "";
+        }
+        else {
+            field += ch;
+        }
+    }
+    fields.push(field);
+    return fields;
+}
+/** Count fields in a single line, respecting RFC-4180 quoting. */
+export function countCSVColumns(line, delimiter = ",") {
+    return splitCSVFields(line, delimiter).length;
+}
+/**
+ * Detect the delimiter of DSV content by testing comma/tab/semicolon/pipe
+ * against up to 5 sampled non-empty lines and keeping the candidate with the
+ * most consistent (>1) column count. Comma wins ties and the "nothing splits"
+ * case, so plain CSVs are never reclassified. An optional extension hint
+ * (`tsv` → tab, `psv` → pipe) breaks ambiguity in the file's favor.
+ */
+export function detectDelimiter(lines, extensionHint) {
+    const sample = lines.filter((l) => l.trim() !== "").slice(0, 5);
+    if (sample.length === 0) {
+        return ",";
+    }
+    const hint = extensionHint?.toLowerCase().replace(/^\./, "");
+    const hinted = hint === "tsv" ? "\t" : hint === "psv" ? "|" : undefined;
+    let best = ",";
+    let bestScore = -1;
+    for (const delim of CANDIDATE_DELIMITERS) {
+        const counts = sample.map((l) => countCSVColumns(l, delim));
+        const headerCols = counts[0];
+        if (headerCols <= 1) {
+            continue; // this delimiter doesn't split the header — not the delimiter
+        }
+        const consistent = counts.every((c) => c === headerCols);
+        // Prefer: a matching extension hint, then consistency, then more columns,
+        // with a small comma bias so comma stays the default on ties.
+        const score = (delim === hinted ? 1000 : 0) +
+            (consistent ? 100 : 0) +
+            headerCols +
+            (delim === "," ? 0.5 : 0);
+        if (score > bestScore) {
+            bestScore = score;
+            best = delim;
+        }
+    }
+    // Nothing split multi-column, but the extension says otherwise — honor it.
+    if (bestScore < 0 && hinted) {
+        return hinted;
+    }
+    return best;
+}

package/dist/utils/errorHandling.d.ts

@@ -51,6 +51,10 @@ export declare const ERROR_CODES: {
     readonly INVALID_PPT_LOGO_PATH: "INVALID_PPT_LOGO_PATH";
     readonly INVALID_PPT_MODE: "INVALID_PPT_MODE";
     readonly INVALID_PPT_PROMPT: "INVALID_PPT_PROMPT";
+    readonly CSV_INVALID_INPUT: "CSV_INVALID_INPUT";
+    readonly CSV_ROW_INVALID: "CSV_ROW_INVALID";
+    readonly CSV_FILE_ACCESS_FAILED: "CSV_FILE_ACCESS_FAILED";
+    readonly CSV_PARSE_FAILED: "CSV_PARSE_FAILED";
 };
 /**
  * Enhanced error class with structured information
@@ -128,6 +132,25 @@ export declare class ErrorFactory {
      * Create an invalid configuration error (e.g., NaN for numeric values)
      */
     static invalidConfiguration(configName: string, reason: string, context?: Record<string, unknown>): NeuroLinkError;
+    /**
+     * Create an invalid CSV input error (e.g. an empty filePath/csvString argument).
+     */
+    static csvInvalidInput(message: string): NeuroLinkError;
+    /**
+     * Create a CSV row-shape violation error (#384) — a parsed row that isn't a
+     * string-keyed object with string values.
+     */
+    static csvRowInvalid(message: string, rowNumber: number): NeuroLinkError;
+    /**
+     * Create a CSV file access error (bad path, permissions, ENOENT/EACCES) (#375).
+     */
+    static csvFileAccessFailed(message: string, filePath: string, originalError?: Error): NeuroLinkError;
+    /**
+     * Create a CSV read/parse failure error (#375) — source stream errors and
+     * csv-parser errors both route through this, carrying the enriched
+     * `buildCsvParseErrorMessage` context in `message`.
+     */
+    static csvParseFailed(message: string, context: Record<string, unknown>, originalError?: Error): NeuroLinkError;
     /**
      * Create an invalid video resolution error
      */

package/dist/utils/errorHandling.js

@@ -66,6 +66,11 @@ export const ERROR_CODES = {
     INVALID_PPT_LOGO_PATH: "INVALID_PPT_LOGO_PATH",
     INVALID_PPT_MODE: "INVALID_PPT_MODE",
     INVALID_PPT_PROMPT: "INVALID_PPT_PROMPT",
+    // CSV validation/parsing errors (#1199)
+    CSV_INVALID_INPUT: "CSV_INVALID_INPUT",
+    CSV_ROW_INVALID: "CSV_ROW_INVALID",
+    CSV_FILE_ACCESS_FAILED: "CSV_FILE_ACCESS_FAILED",
+    CSV_PARSE_FAILED: "CSV_PARSE_FAILED",
 };
 /**
  * Enhanced error class with structured information
@@ -259,6 +264,66 @@ export class ErrorFactory {
         });
     }
     // ============================================================================
+    // CSV VALIDATION/PARSING ERRORS (#1199)
+    // ============================================================================
+    /**
+     * Create an invalid CSV input error (e.g. an empty filePath/csvString argument).
+     */
+    static csvInvalidInput(message) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.CSV_INVALID_INPUT,
+            message,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: {},
+        });
+    }
+    /**
+     * Create a CSV row-shape violation error (#384) — a parsed row that isn't a
+     * string-keyed object with string values.
+     */
+    static csvRowInvalid(message, rowNumber) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.CSV_ROW_INVALID,
+            message,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: { rowNumber },
+        });
+    }
+    /**
+     * Create a CSV file access error (bad path, permissions, ENOENT/EACCES) (#375).
+     */
+    static csvFileAccessFailed(message, filePath, originalError) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.CSV_FILE_ACCESS_FAILED,
+            message,
+            category: ErrorCategory.RESOURCE,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { filePath },
+            originalError,
+        });
+    }
+    /**
+     * Create a CSV read/parse failure error (#375) — source stream errors and
+     * csv-parser errors both route through this, carrying the enriched
+     * `buildCsvParseErrorMessage` context in `message`.
+     */
+    static csvParseFailed(message, context, originalError) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.CSV_PARSE_FAILED,
+            message,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context,
+            originalError,
+        });
+    }
+    // ============================================================================
     // VIDEO VALIDATION ERRORS
     // ============================================================================
     /**

package/dist/utils/multimodalOptionsBuilder.d.ts

@@ -50,11 +50,7 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
         csvFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
         pdfFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
     };
-    csvOptions: {
-        maxRows?: number;
-        formatStyle?: "raw" | "markdown" | "json";
-        includeHeaders?: boolean;
-    } | undefined;
+    csvOptions: import("../index.js").CSVProcessorOptions | undefined;
     systemPrompt: string | undefined;
     conversationHistory: import("../index.js").ChatMessage[] | undefined;
     provider: string;

package/dist/utils/textEncoding.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Buffer → string decoding with encoding detection (#362).
+ *
+ * Order of resolution:
+ *   1. Explicit override (any iconv-lite label).
+ *   2. Deterministic BOM sniff (UTF-8 / UTF-16 LE / UTF-16 BE).
+ *   3. `chardet` statistical detection, mapped to an iconv-lite label.
+ *   4. Fallback to UTF-8 (preserves the historical hard-coded default).
+ *
+ * Decoding always goes through `iconv-lite`, and any residual BOM is stripped
+ * from the decoded string so it can't glue onto the first token.
+ */
+import type { DecodedBuffer } from "../types/index.js";
+/** Strip a leading BOM (U+FEFF) from an already-decoded string. */
+export declare function stripBomString(text: string): string;
+/**
+ * Decode a buffer to text, detecting the encoding unless overridden.
+ *
+ * @param isCompleteBuffer - Whether `buffer` is the entire source (default
+ *   `true`). Pass `false` when `buffer` is only a peeked prefix (e.g. a
+ *   streaming head-sniff) — the ASCII fast path still commits to "utf-8" for
+ *   the peeked bytes (unchanged behavior), but reports a lower confidence
+ *   since later bytes not yet seen could still be non-ASCII (#1199).
+ */
+export declare function decodeBuffer(buffer: Buffer, override?: string, isCompleteBuffer?: boolean): DecodedBuffer;

package/dist/utils/textEncoding.js

@@ -0,0 +1,140 @@
+/**
+ * Buffer → string decoding with encoding detection (#362).
+ *
+ * Order of resolution:
+ *   1. Explicit override (any iconv-lite label).
+ *   2. Deterministic BOM sniff (UTF-8 / UTF-16 LE / UTF-16 BE).
+ *   3. `chardet` statistical detection, mapped to an iconv-lite label.
+ *   4. Fallback to UTF-8 (preserves the historical hard-coded default).
+ *
+ * Decoding always goes through `iconv-lite`, and any residual BOM is stripped
+ * from the decoded string so it can't glue onto the first token.
+ */
+import chardet from "chardet";
+import iconv from "iconv-lite";
+import { logger } from "./logger.js";
+/** Strip a leading BOM (U+FEFF) from an already-decoded string. */
+export function stripBomString(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+/** Deterministic BOM detection from the raw bytes. Returns null when absent. */
+function sniffBom(buffer) {
+    if (buffer.length >= 3 &&
+        buffer[0] === 0xef &&
+        buffer[1] === 0xbb &&
+        buffer[2] === 0xbf) {
+        return "utf-8";
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+        return "utf-16le";
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
+        return "utf-16be";
+    }
+    return null;
+}
+/**
+ * Map a chardet label to an iconv-lite-supported label. Returns null when the
+ * label is unknown/unsupported so the caller falls back to UTF-8.
+ */
+function toIconvLabel(detected) {
+    if (!detected) {
+        return null;
+    }
+    const normalized = detected.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const map = {
+        utf8: "utf-8",
+        utf16le: "utf-16le",
+        utf16be: "utf-16be",
+        ascii: "utf-8", // ASCII is a strict UTF-8 subset
+        windows1252: "windows-1252",
+        iso88591: "latin1",
+        latin1: "latin1",
+        iso88592: "iso-8859-2",
+        windows1251: "windows-1251",
+        koi8r: "koi8-r",
+        gb18030: "gb18030",
+        big5: "big5",
+        shiftjis: "shift_jis",
+        euckr: "euc-kr",
+        eucjp: "euc-jp",
+    };
+    const label = map[normalized] ?? detected;
+    return iconv.encodingExists(label) ? label : null;
+}
+/**
+ * Decode a buffer to text, detecting the encoding unless overridden.
+ *
+ * @param isCompleteBuffer - Whether `buffer` is the entire source (default
+ *   `true`). Pass `false` when `buffer` is only a peeked prefix (e.g. a
+ *   streaming head-sniff) — the ASCII fast path still commits to "utf-8" for
+ *   the peeked bytes (unchanged behavior), but reports a lower confidence
+ *   since later bytes not yet seen could still be non-ASCII (#1199).
+ */
+export function decodeBuffer(buffer, override, isCompleteBuffer = true) {
+    // 1. Explicit override wins outright.
+    if (override && iconv.encodingExists(override)) {
+        return {
+            text: stripBomString(iconv.decode(buffer, override)),
+            encoding: override,
+            confidence: 100,
+        };
+    }
+    if (override && !iconv.encodingExists(override)) {
+        logger.warn(`[textEncoding] Unsupported encoding override "${override}"; falling back to detection.`);
+    }
+    // 2. BOM is authoritative when present.
+    const bom = sniffBom(buffer);
+    if (bom) {
+        return {
+            text: stripBomString(iconv.decode(buffer, bom)),
+            encoding: bom,
+            confidence: 100,
+        };
+    }
+    // 2b. Pure-ASCII fast path — chardet often reports ASCII as ISO-8859-1, but
+    // ASCII is a strict UTF-8 subset and decodes identically, so report "utf-8"
+    // to preserve the historical default for plain-ASCII files.
+    let ascii = true;
+    for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] >= 0x80) {
+            ascii = false;
+            break;
+        }
+    }
+    if (ascii) {
+        return {
+            text: stripBomString(iconv.decode(buffer, "utf-8")),
+            encoding: "utf-8",
+            // A partial peek being pure-ASCII only proves the peeked prefix is
+            // ASCII, not the whole file — a later chunk could still switch to a
+            // legacy encoding. Only report full certainty when `buffer` is known
+            // to be the complete source.
+            confidence: isCompleteBuffer ? 100 : 60,
+        };
+    }
+    // 3. Statistical detection.
+    let detected = null;
+    try {
+        detected = chardet.detect(buffer);
+    }
+    catch (error) {
+        logger.debug(`[textEncoding] chardet failed: ${String(error)}`);
+    }
+    const label = toIconvLabel(detected);
+    if (label) {
+        return {
+            text: stripBomString(iconv.decode(buffer, label)),
+            encoding: label,
+            // chardet gives a winner but not a numeric score via detect(); treat a
+            // confident non-UTF-8 hit as reasonably (not fully) certain.
+            confidence: label === "utf-8" ? 100 : 80,
+        };
+    }
+    // 4. Fallback: historical UTF-8 default.
+    return {
+        text: stripBomString(iconv.decode(buffer, "utf-8")),
+        encoding: "utf-8",
+        confidence: 0,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.94.1",
+  "version": "9.94.3",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -358,6 +358,7 @@
     "adm-zip": "^0.5.16",
     "ai": "^6.0.134",
     "chalk": "^5.6.2",
+    "chardet": "2.1.1",
     "croner": "^9.1.0",
     "csv-parser": "^3.2.0",
     "dotenv": "^17.3.1",
@@ -365,6 +366,7 @@
     "fast-xml-parser": "^5.7.0",
     "google-auth-library": "^10.6.1",
     "hono": "^4.12.21",
+    "iconv-lite": "0.7.2",
     "inquirer": "^13.3.0",
     "jose": "^6.1.3",
     "js-yaml": "^4.2.0",