@juspay/neurolink 9.94.4 → 9.94.6

package/dist/lib/utils/logSanitize.js

@@ -15,6 +15,7 @@
  *     jina_ (Jina), fish- (Fish Audio)
  *   - Generic key=value pairs: api_key=…, access_token: …, secret_key=…
  */
+import { basename, resolve as resolvePath } from "path";
 const TOKEN_PREFIXES = [
     "sk",
     "pk",
@@ -156,12 +157,161 @@ export function safeDebugSerialize(value, maxLen = 10_000) {
  * for diagnostics. Use this for any `baseURL`/endpoint a caller may have
  * supplied with inline credentials. The match is global, so every `//…@`
  * authority in the string is redacted (e.g. a proxy chain or a URL embedded
- * in a query parameter), not just the first.
+ * in a query parameter), not just the first. IPv6 literal hosts (`//u:p@[::1]/x`)
+ * and percent-encoded userinfo (`//u:p%40x@host/x`) are handled naturally —
+ * neither `[`/`]` nor `%` stop either pass below, so the bracketed host or
+ * encoded byte just rides along as part of the (non-redacted) remainder.
+ *
+ * This is best-effort defense-in-depth for free-form logging, deliberately
+ * regex-based so it can scrub *multiple* embedded authorities out of
+ * arbitrary text (a real URL parser only ever parses one URL at a time).
+ * It is NOT the primary protection for user-facing errors — that's
+ * {@link redactUrlForError}, which parses the single input via `new URL()`
+ * and reconstructs from protocol+host+pathname, never touching userinfo at
+ * all. Prefer that function whenever the input is known to be exactly one
+ * URL.
+ *
+ * Two passes, deliberately:
+ *  1. Well-formed authorities — credentials with no raw `/` — bounded at the
+ *     authority's first `/` (or string end). Greedy backtracking naturally
+ *     absorbs multiple `@` segments within one authority (e.g. `//a@b@host`
+ *     → `//***@host`) while leaving a second, separate `//...@` authority
+ *     elsewhere in the string (e.g. one embedded in a query parameter)
+ *     untouched, because pass 1's own exclusion of `/` stops it at the first
+ *     `/`, before it can ever reach a nested authority.
+ *  2. Malformed authorities whose credentials contain an unescaped `/`
+ *     (e.g. `//user:sec/ret@host/path`) — pass 1 can't find an `@` before
+ *     hitting that `/`, so this pass allows `/` and redacts up to the last
+ *     remaining `@`. It stops before any *nested* `//` (via a negative
+ *     lookahead) rather than excluding a specific character like `*` —
+ *     excluding a literal character is what let a password containing both
+ *     `/` and `*` (e.g. `//user:pa*ss/word@host/path`, legal under RFC 3986)
+ *     slip through both passes entirely in an earlier version of this
+ *     function.
  *
  * @param url - The URL (or URL-shaped string) to redact.
  */
 export function redactUrlCredentials(url) {
-    return url.replace(/\/\/[^/@]+@/g, "//***@");
+    const wellFormed = url.replace(/\/\/[^/\s"'<>]*@/g, "//***@");
+    return wellFormed.replace(/\/\/(?:(?!\/\/)[^\s"'<>])*@/g, "//***@");
+}
+/**
+ * Reduce a URL to its origin + pathname for safe inclusion in error messages
+ * and logs, dropping the query string and fragment — where presigned-URL
+ * signatures, SAS tokens, and other secrets commonly live — while keeping
+ * enough of the URL (scheme, host, path) for the error to stay diagnostic.
+ *
+ * Falls back to a best-effort redacted string (query/fragment and
+ * `user:pass@` stripped) when the input isn't a parseable absolute URL.
+ * Either way the result is capped at 200 chars so a very long host/path
+ * can't blow up the error message.
+ *
+ * @param url - The URL (or URL-shaped string) to redact.
+ */
+export function redactUrlForError(url) {
+    const truncate = (s) => s.length > 200 ? `${s.slice(0, 200)}…` : s;
+    try {
+        const parsed = new URL(url);
+        // Reconstruct explicitly from protocol + host + pathname — never
+        // parsed.username/parsed.password, and never parsed.href (which
+        // re-serializes any embedded userinfo) — so a `user:pass@host` in the
+        // input can't leak into a diagnostic error message.
+        return truncate(`${parsed.protocol}//${parsed.host}${parsed.pathname}`);
+    }
+    catch {
+        // Unparseable input: `new URL()` gave us nothing to work with, so
+        // best-effort drop the query/fragment (where secrets like tokens live)
+        // and strip any `//user:pass@` segment before falling back to the raw
+        // string — never echo the input completely unredacted.
+        const withoutQueryOrFragment = url.split(/[?#]/)[0];
+        return truncate(redactUrlCredentials(withoutQueryOrFragment));
+    }
+}
+/**
+ * Scrub any embedded absolute URLs out of free-form text — typically the
+ * `.message` of an underlying network/DNS/TLS error thrown by `fetch`,
+ * undici's `request()`, or Node's resolver, all of which frequently embed
+ * the full request URL (query string, credentials, and all) verbatim.
+ * Interpolating that message raw into a thrown or logged error would leak a
+ * presigned URL's token even after the explicit URL argument was already
+ * redacted via {@link redactUrlForError}. Finds each `scheme://…` run in the
+ * text and replaces it with its redacted form.
+ *
+ * @param text - Free-form text (typically `Error.message`) to scrub.
+ */
+export function redactUrlsInText(text) {
+    return text.replace(/[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s"'<>)]+/g, (match) => redactUrlForError(match));
+}
+/**
+ * Redact every occurrence of `filePath` from an error message, checking both
+ * the path exactly as given and its `path.resolve()`'d form.
+ *
+ * Node's own fs errors (ENOENT/EACCES) embed the exact string passed to the
+ * fs call, so a plain substring match usually suffices — but wrapped or
+ * lower-level errors sometimes normalize the path first (relative→absolute,
+ * trailing-slash variations), which an exact-match-only redaction would miss.
+ * This is defense-in-depth, not a guarantee: a `realpath`-resolved (symlink-
+ * following) variant can still differ from both forms and would slip through.
+ *
+ * @param message  - The error message to scrub.
+ * @param filePath - The path to redact (both as given and resolved).
+ */
+export function redactPathFromMessage(message, filePath) {
+    const safeName = basename(filePath);
+    // Longest-first: the resolved (absolute) form always contains the relative
+    // form as a substring, so redacting the relative form first would only
+    // strip the trailing segment of an absolute path and leave its parent
+    // directory behind (e.g. "/Users/me/project/foo/bar.png" redacting
+    // "foo/bar.png" first leaves "/Users/me/project/bar.png"). Redacting the
+    // longer resolved variant first removes the whole absolute path in one
+    // pass, so the shorter relative pass below has nothing left to match.
+    return message
+        .split(resolvePath(filePath))
+        .join(safeName)
+        .split(filePath)
+        .join(safeName);
+}
+/**
+ * Build a sanitized copy of a network/URL/file error, safe to attach as
+ * `Error.cause` on a rethrow.
+ *
+ * Redacting only the OUTER thrown error's message isn't enough: if the RAW
+ * underlying error is attached as `cause`, anything that walks the cause
+ * chain (cause-aware logging, telemetry spans) can still recover an
+ * unredacted URL/path/secret via `error.cause.message`. This returns a NEW
+ * `Error` whose message has been through {@link redactUrlsInText} — and,
+ * when `options.filePath` is supplied, {@link redactPathFromMessage} too, so
+ * a filesystem error's ENOENT/EACCES text doesn't leak the host's directory
+ * layout via the cause chain the way the outer message already avoids.
+ * `.name` and `.code` (`NodeJS.ErrnoException`) are copied over so retry
+ * classification (e.g. `isRetryableNetworkError`) still works when it
+ * inspects the cause. The raw original is never referenced by the result.
+ *
+ * Handles non-`Error` thrown values too (a raw string/object can just as
+ * easily carry an unredacted URL or path) by running their `String()` form
+ * through the same redaction before wrapping.
+ *
+ * @param error   - The raw underlying error (or thrown value) to sanitize.
+ * @param options - `filePath`: a known filesystem path to redact to its
+ *                  basename, in addition to URL redaction.
+ */
+export function sanitizeErrorCause(error, options) {
+    const redact = (text) => {
+        const urlSafe = redactUrlsInText(text);
+        return options?.filePath
+            ? redactPathFromMessage(urlSafe, options.filePath)
+            : urlSafe;
+    };
+    if (!(error instanceof Error)) {
+        return new Error(redact(String(error)));
+    }
+    const sanitized = new Error(redact(error.message));
+    sanitized.name = error.name;
+    const code = error.code;
+    if (code !== undefined) {
+        sanitized.code = code;
+    }
+    return sanitized;
 }
 /**
  * Recursively sanitize a record/array, returning a structurally identical

package/dist/lib/utils/messageBuilder.js

@@ -5,12 +5,12 @@ import { MultimodalLogger, ProviderImageAdapter, } from "../adapters/providerIma
 import { CONVERSATION_INSTRUCTIONS, STRUCTURED_OUTPUT_INSTRUCTIONS, } from "../config/conversationMemory.js";
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
 import { enforceAggregateFileBudget, FILE_READ_BUDGET_PERCENT, } from "../context/fileTokenBudget.js";
-import { SIZE_TIER_THRESHOLDS } from "../types/index.js";
+import { isCSVContent, SIZE_TIER_THRESHOLDS } from "../types/index.js";
 import { tracers, ATTR, withSpan } from "../telemetry/index.js";
-import { NeuroLinkError } from "./errorHandling.js";
+import { ErrorFactory, NeuroLinkError, withTimeout } from "./errorHandling.js";
 import { FileDetector } from "./fileDetector.js";
 import { getImageCache } from "./imageCache.js";
-import { ImageProcessor } from "./imageProcessor.js";
+import { ImageProcessor, imageUtils } from "./imageProcessor.js";
 import { logger } from "./logger.js";
 import { PDFImageConverter, PDFProcessor } from "./pdfProcessor.js";
 import { urlDownloadRateLimiter } from "./rateLimiter.js";
@@ -860,7 +860,11 @@ export async function processUnifiedFilesArray(options, maxSize, provider) {
             }
             catch (error) {
                 const errMsg = error instanceof Error ? error.message : String(error);
-                logger.error(`[NEUROLINK] File skipped/failed: ${filename} — reason: ${errMsg}`);
+                // #273: don't silently drop a failed file — log, then throw so the
+                // caller learns the file couldn't be processed (matches the explicit
+                // pdf/csv paths' fail-loud behavior).
+                logger.error(`[NEUROLINK] File processing failed: ${filename} — reason: ${errMsg}`);
+                throw ErrorFactory.fileProcessingFailed(filename, error instanceof Error ? error : new Error(errMsg));
             }
         }
         span.setAttribute(ATTR.FILE_INCLUDED_COUNT, includedCount);
@@ -935,10 +939,12 @@ async function processExplicitCsvFiles(options) {
             logger.info(`[CSV] ✅ Processed: ${filename}`);
         }
         catch (error) {
-            logger.error(`[CSV] ❌ Failed:`, error);
             const filename = extractFilename(csvFile, i);
-            options.input.text += `\n\n## CSV Data Error: Failed to process "${filename}"`;
-            options.input.text += `\nReason: ${error instanceof Error ? error.message : "Unknown error"}`;
+            const errMsg = error instanceof Error ? error.message : String(error);
+            // #273: fail loud instead of embedding the error into the prompt text
+            // (which the model would then "analyze"). Log, then throw.
+            logger.error(`[CSV] ❌ Failed to process ${filename}: ${errMsg}`);
+            throw ErrorFactory.csvProcessingFailed(filename, error instanceof Error ? error : new Error(errMsg));
         }
     }
 }
@@ -1067,6 +1073,18 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     // local const so TypeScript sees the definite (non-optional) type in the
     // rest of this function, avoiding 60+ "possibly undefined" errors.
     const inp = options.input;
+    // #284: audioFiles/videoFiles have no dedicated processor — route them
+    // through the same auto-detecting `files` pipeline that already
+    // understands "audio"/"video" FileDetector results (see
+    // appendDetectedFileResult), instead of silently dropping them once
+    // detectMultimodal() routes an audio/video-only request here.
+    if (inp.audioFiles?.length || inp.videoFiles?.length) {
+        inp.files = [
+            ...(inp.files || []),
+            ...(inp.audioFiles || []),
+            ...(inp.videoFiles || []),
+        ];
+    }
     // Compute provider-specific max PDF size once for consistent validation
     const pdfConfig = PDFProcessor.getProviderConfig(provider);
     const maxSize = pdfConfig
@@ -1088,6 +1106,13 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     const hasPDFs = pdfFiles.length > 0;
     // If no images or PDFs, use standard message building and convert to MultimodalChatMessage[]
     if (!hasImages && !hasPDFs) {
+        // #289: CSV content[] items don't need vision, so they never reach the
+        // multimodal converter below — process them into the prompt text here
+        // (otherwise a `content: [{type:"csv"}]`-only request silently drops it).
+        const csvContentItems = inp.content?.filter(isCSVContent) ?? [];
+        if (csvContentItems.length > 0) {
+            inp.text = await appendCsvContentToText(csvContentItems, inp.text ?? "");
+        }
         if (inp.csvFiles) {
             inp.csvFiles = [];
         }
@@ -1216,6 +1241,47 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
         throw error;
     }
 }
+/**
+ * Timeout for detecting/parsing an in-memory CSV `content[]` buffer (#325
+ * review, round 2). Bounds a stalled detector rather than blocking the
+ * request indefinitely.
+ */
+const CSV_CONTENT_DETECTION_TIMEOUT_MS = 30_000;
+/**
+ * #289: process CSV `content[]` items into appended prompt text. CSV is
+ * delivered to the model as text (like the explicit `csvFiles` path), so this
+ * is shared by both the no-vision gate and the multimodal converter.
+ */
+async function appendCsvContentToText(csvItems, baseText) {
+    let text = baseText;
+    for (const csv of csvItems) {
+        const raw = csv.data;
+        if (raw === undefined) {
+            continue;
+        }
+        // #325: raw CSV text (e.g. "a,b\n1,2") is not base64 — decoding it as
+        // base64 silently corrupts the content. Only treat the string as base64
+        // when it actually validates as such; otherwise treat it as literal
+        // UTF-8 CSV text, matching how Buffer inputs are already handled as-is.
+        const buffer = typeof raw === "string"
+            ? imageUtils.isValidBase64(raw)
+                ? Buffer.from(raw, "base64")
+                : Buffer.from(raw, "utf-8")
+            : raw;
+        const name = csv.metadata?.filename || "data.csv";
+        // #325 review (round 2): a stalled/hung detector must not block the
+        // request indefinitely — wrap with the project's standard withTimeout.
+        const result = await withTimeout(FileDetector.detectAndProcess(buffer, {
+            allowedTypes: ["csv"],
+            csvOptions: {
+                maxRows: csv.metadata?.maxRows,
+                formatStyle: csv.metadata?.formatStyle,
+            },
+        }), CSV_CONTENT_DETECTION_TIMEOUT_MS, new Error(`Timed out processing CSV content "${name}" after ${CSV_CONTENT_DETECTION_TIMEOUT_MS}ms`));
+        text += `${text ? "\n\n" : ""}## CSV Data from ${name}\n${result.content}`;
+    }
+    return text;
+}
 /**
  * Convert advanced content format to provider-specific format
  */
@@ -1223,14 +1289,19 @@ async function convertContentToProviderFormat(content, provider, _model) {
     const textContent = content.find((c) => c.type === "text");
     const imageContent = content.filter((c) => c.type === "image");
     const pdfContent = content.filter((c) => c.type === "pdf");
+    const csvContent = content.filter(isCSVContent);
     // Allow empty text when multimodal content is present (enables image-only or PDF-only queries)
-    const text = textContent?.text || "";
+    let text = textContent?.text || "";
+    // #289: CSV content[] items were silently dropped — fold each into the text.
+    if (csvContent.length > 0) {
+        text = await appendCsvContentToText(csvContent, text);
+    }
     const hasMultimodal = imageContent.length > 0 || pdfContent.length > 0;
     // Validate that we have at least some content
     if (!hasMultimodal && !text) {
         throw new Error("Content must include either text or multimodal content");
     }
-    // Text-only case
+    // Text-only case (CSV has already been folded into `text`)
     if (imageContent.length === 0 && pdfContent.length === 0) {
         return text;
     }

package/dist/types/generate.d.ts

@@ -53,6 +53,7 @@ export type GenerateOptions = {
         images?: Array<Buffer | string | ImageWithAltText>;
         csvFiles?: Array<Buffer | string>;
         pdfFiles?: Array<Buffer | string>;
+        audioFiles?: Array<Buffer | string>;
         videoFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string | FileWithMetadata>;
         content?: Content[];

package/dist/types/multimodal.d.ts

@@ -419,15 +419,46 @@ export type MultimodalInput = {
     segments?: DirectorSegment[];
 };
 /**
- * Content format for multimodal messages (used internally)
- * Compatible with Vercel AI SDK message format
+ * Content format for multimodal messages (used internally).
+ *
+ * #325: the loose `[key: string]: unknown` index signature has been replaced
+ * with the concrete fields the codebase actually reads/writes across the
+ * text / image / file / tool-call / tool-result shapes. This keeps the broad
+ * structural compatibility the internal pipeline relies on (a single object
+ * type, not a strict discriminated union that would force narrowing at every
+ * consumer) while removing the "any key is allowed" hole that let typos and
+ * unrelated keys through unchecked.
  */
 export type MessageContent = {
     type: string;
+    /** Text content (`type: "text"`). */
     text?: string;
+    /** Base64 / data-URI image (`type: "image"`). */
     image?: string;
+    /** MIME type for image/file parts. */
     mimeType?: string;
-    [key: string]: unknown;
+    /** Raw file bytes or base64 (`type: "file"`/document parts). */
+    data?: string | Buffer;
+    /** File name for document/file parts. */
+    name?: string;
+    /** File name (alias used by some file parts). */
+    filename?: string;
+    /** Tool-call identifier (`type: "tool-call"`/`"tool-result"`). */
+    toolCallId?: string;
+    /** Tool name (`type: "tool-call"`/`"tool-result"`). */
+    toolName?: string;
+    /** Tool-call arguments (`type: "tool-call"`). */
+    args?: Record<string, unknown>;
+    /** Tool-result payload (`type: "tool-result"`). */
+    result?: unknown;
+    /** Whether a tool-result represents an error (`type: "tool-result"`). */
+    isError?: boolean;
+    /**
+     * Provider-specific per-block options (e.g. Anthropic cache_control).
+     * Read as `item.providerOptions` when converting `MessageContent[]` to
+     * `ModelMessage[]` in `MessageBuilder.ts`.
+     */
+    providerOptions?: Record<string, unknown>;
 };
 /**
  * Extended chat message for multimodal support (internal use)

package/dist/types/stream.d.ts

@@ -193,6 +193,7 @@ export type StreamOptions = {
         images?: Array<Buffer | string | ImageWithAltText>;
         csvFiles?: Array<Buffer | string>;
         pdfFiles?: Array<Buffer | string>;
+        audioFiles?: Array<Buffer | string>;
         videoFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string | FileWithMetadata>;
         content?: Content[];

package/dist/utils/errorHandling.d.ts

@@ -35,6 +35,9 @@ export declare const ERROR_CODES: {
     readonly IMAGE_TOO_SMALL: "IMAGE_TOO_SMALL";
     readonly INVALID_IMAGE_FORMAT: "INVALID_IMAGE_FORMAT";
     readonly INVALID_IMAGE_SIZE: "INVALID_IMAGE_SIZE";
+    readonly IMAGE_BUFFER_INVALID: "IMAGE_BUFFER_INVALID";
+    readonly FILE_PROCESSING_FAILED: "FILE_PROCESSING_FAILED";
+    readonly CSV_PROCESSING_FAILED: "CSV_PROCESSING_FAILED";
     readonly PDF_PAGE_LIMIT_EXCEEDED: "PDF_PAGE_LIMIT_EXCEEDED";
     readonly RATE_LIMITER_QUEUE_FULL: "RATE_LIMITER_QUEUE_FULL";
     readonly RATE_LIMITER_QUEUE_TIMEOUT: "RATE_LIMITER_QUEUE_TIMEOUT";
@@ -216,6 +219,13 @@ export declare class ErrorFactory {
      * Create an invalid image format error
      */
     static invalidImageFormat(): NeuroLinkError;
+    /**
+     * Create an image buffer validation error: empty, undersized, or a
+     * truncated buffer detected by `ImageProcessor.validateBufferNotEmpty()`.
+     * Takes the fully-formed message so call sites keep their specific
+     * byte-count detail instead of a fixed generic message.
+     */
+    static imageBufferInvalid(message: string): NeuroLinkError;
     /**
      * Create a rate limiter queue full error
      */
@@ -287,6 +297,18 @@ export declare class ErrorFactory {
      * generic `Error` instances.
      */
     static proxyWorkerLifecycle(message: string, context?: Record<string, unknown>): NeuroLinkError;
+    /**
+     * Create a generic file-processing-failed error (e.g. an unrecognized or
+     * corrupt file in `processUnifiedFilesArray`). Preserves the original error
+     * as `originalError` (stack + message copied onto the new error's context).
+     */
+    static fileProcessingFailed(filename: string, originalError: Error): NeuroLinkError;
+    /**
+     * Create a generic CSV-processing-failed error (explicit `csvFiles` path,
+     * distinct from `fileProcessingFailed` so callers can classify CSV-specific
+     * failures separately). Preserves the original error as `originalError`.
+     */
+    static csvProcessingFailed(filename: string, originalError: Error): NeuroLinkError;
 }
 /**
  * Timeout wrapper for async operations

package/dist/utils/errorHandling.js

@@ -46,6 +46,10 @@ export const ERROR_CODES = {
     IMAGE_TOO_SMALL: "IMAGE_TOO_SMALL",
     INVALID_IMAGE_FORMAT: "INVALID_IMAGE_FORMAT",
     INVALID_IMAGE_SIZE: "INVALID_IMAGE_SIZE",
+    IMAGE_BUFFER_INVALID: "IMAGE_BUFFER_INVALID",
+    // Generic file/CSV processing errors
+    FILE_PROCESSING_FAILED: "FILE_PROCESSING_FAILED",
+    CSV_PROCESSING_FAILED: "CSV_PROCESSING_FAILED",
     // PDF validation errors
     PDF_PAGE_LIMIT_EXCEEDED: "PDF_PAGE_LIMIT_EXCEEDED",
     // Rate limiter errors
@@ -627,6 +631,22 @@ export class ErrorFactory {
             },
         });
     }
+    /**
+     * Create an image buffer validation error: empty, undersized, or a
+     * truncated buffer detected by `ImageProcessor.validateBufferNotEmpty()`.
+     * Takes the fully-formed message so call sites keep their specific
+     * byte-count detail instead of a fixed generic message.
+     */
+    static imageBufferInvalid(message) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.IMAGE_BUFFER_INVALID,
+            message,
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: false,
+            context: { field: "input.images" },
+        });
+    }
     // ============================================================================
     // RATE LIMITER ERRORS
     // ============================================================================
@@ -924,6 +944,41 @@ export class ErrorFactory {
             context: context || {},
         });
     }
+    // ============================================================================
+    // GENERIC FILE / CSV PROCESSING ERRORS
+    // ============================================================================
+    /**
+     * Create a generic file-processing-failed error (e.g. an unrecognized or
+     * corrupt file in `processUnifiedFilesArray`). Preserves the original error
+     * as `originalError` (stack + message copied onto the new error's context).
+     */
+    static fileProcessingFailed(filename, originalError) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.FILE_PROCESSING_FAILED,
+            message: `Failed to process file "${filename}": ${originalError.message}`,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { filename },
+            originalError,
+        });
+    }
+    /**
+     * Create a generic CSV-processing-failed error (explicit `csvFiles` path,
+     * distinct from `fileProcessingFailed` so callers can classify CSV-specific
+     * failures separately). Preserves the original error as `originalError`.
+     */
+    static csvProcessingFailed(filename, originalError) {
+        return new NeuroLinkError({
+            code: ERROR_CODES.CSV_PROCESSING_FAILED,
+            message: `Failed to process CSV file "${filename}": ${originalError.message}`,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+            context: { filename },
+            originalError,
+        });
+    }
 }
 /**
  * Timeout wrapper for async operations