@juspay/neurolink 10.10.8 → 10.10.10

package/dist/cli/factories/commandFactory.js

@@ -228,6 +228,11 @@ export class CLICommandFactory {
             type: "number",
             description: "Wall-clock cap (ms) for CSV parsing; returns partial rows on timeout (#379).",
         },
+        "csv-skip-empty-lines": {
+            type: "boolean",
+            default: true,
+            description: "Skip blank/whitespace-only CSV data rows in content and rowCount (default true). Use --no-csv-skip-empty-lines to preserve them (#373).",
+        },
         model: {
             type: "string",
             description: "Specific model to use (e.g. gemini-2.5-pro, gemini-2.5-flash)",
@@ -2441,6 +2446,7 @@ export class CLICommandFactory {
             sanitizeColumnNames: argv.csvSanitizeNames,
             columnNameCase: argv.csvNameCase,
             parseTimeoutMs: argv.csvParseTimeoutMs,
+            skipEmptyLines: argv.csvSkipEmptyLines,
         };
     }
     /**

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

@@ -41,6 +41,7 @@ import { SIZE_LIMITS_MB } from "../config/index.js";
 import { FileErrorCode } from "../errors/index.js";
 import { withTimeout } from "../../utils/timeout.js";
 import { formatMediaDuration } from "../../utils/mediaDuration.js";
+import { logger } from "../../utils/logger.js";
 import { tryImport } from "../../utils/tryImport.js";
 let _musicMetadata = null;
 async function loadMusicMetadata() {
@@ -264,6 +265,11 @@ export class AudioProcessor extends BaseFileProcessor {
                     transcript: transcriptionResult.transcript,
                     hasTranscript: transcriptionResult.hasTranscript,
                     transcriptionProvider: transcriptionResult.transcriptionProvider,
+                    ...(transcriptionResult.transcriptionSkippedReason
+                        ? {
+                            transcriptionSkippedReason: transcriptionResult.transcriptionSkippedReason,
+                        }
+                        : {}),
                     coverArt: coverArt ?? undefined,
                     buffer,
                     mimetype: fileInfo.mimetype || "audio/mpeg",
@@ -316,20 +322,25 @@ export class AudioProcessor extends BaseFileProcessor {
      * @returns Transcription result with transcript text, or empty result
      */
     async attemptTranscription(buffer, filename, mimetype) {
-        const emptyResult = {
-            transcript: undefined,
-            hasTranscript: false,
-            transcriptionProvider: undefined,
+        const skipped = (reason) => {
+            logger.warn(`[AudioProcessor] No transcript for ${filename}: ${reason}. ` +
+                `The model will receive metadata only.`);
+            return {
+                transcript: undefined,
+                hasTranscript: false,
+                transcriptionProvider: undefined,
+                transcriptionSkippedReason: reason,
+            };
         };
         // Check if OPENAI_API_KEY is available
         const apiKey = process.env.OPENAI_API_KEY;
         if (!apiKey) {
-            return emptyResult;
+            return skipped("OPENAI_API_KEY is not set, and Whisper is the only transcription backend wired up");
         }
         // Check file size (Whisper limit is 25MB)
         const fileSizeMB = buffer.length / (1024 * 1024);
         if (fileSizeMB > AUDIO_CONFIG.WHISPER_MAX_SIZE_MB) {
-            return emptyResult;
+            return skipped(`file is ${fileSizeMB.toFixed(1)}MB, over Whisper's ${AUDIO_CONFIG.WHISPER_MAX_SIZE_MB}MB limit — split or compress it`);
         }
         // Check if file format is supported by Whisper
         const ext = filename.split(".").pop()?.toLowerCase();
@@ -343,7 +354,7 @@ export class AudioProcessor extends BaseFileProcessor {
                 mimetype.startsWith("audio/ogg") ||
                 mimetype.startsWith("audio/x-m4a"));
         if (!isFormatSupported && !isMimeSupported) {
-            return emptyResult;
+            return skipped(`format is not one Whisper accepts (extension "${ext ?? "none"}", mimetype "${mimetype ?? "none"}"); supported: ${AUDIO_CONFIG.WHISPER_SUPPORTED_FORMATS.join(", ")}`);
         }
         try {
             // Dynamic imports to avoid loading these modules when transcription is not needed
@@ -351,26 +362,33 @@ export class AudioProcessor extends BaseFileProcessor {
             const openai = createOpenAI({ apiKey });
             const model = openai.transcription("whisper-1");
             // Wrap in withTimeout — large audio files can take a while, but a
-            // stalled request shouldn't block the processor forever. The outer
-            // catch swallows any error (transcription is best-effort), so a
-            // TimeoutError ends up in the same fallback path as other failures.
+            // stalled request shouldn't block the processor forever. A TimeoutError
+            // lands in the same handler as other failures below, which reports it as
+            // the reason rather than discarding it.
             const result = await withTimeout(experimental_transcribe({
                 model,
                 audio: buffer,
             }), AUDIO_CONFIG.TRANSCRIPTION_TIMEOUT_MS, "openai-whisper", "generate");
             if (result.text && result.text.trim().length > 0) {
+                logger.debug(`[AudioProcessor] Transcribed ${filename} via openai-whisper (${result.text.trim().length} chars)`);
                 return {
                     transcript: result.text.trim(),
                     hasTranscript: true,
                     transcriptionProvider: "openai-whisper",
+                    transcriptionSkippedReason: undefined,
                 };
             }
-            return emptyResult;
+            // A successful call that returned nothing is a legitimate outcome
+            // (silence, music, no speech) — distinct from a failure.
+            return skipped("Whisper returned an empty transcript for this audio");
         }
-        catch {
-            // Transcription is best-effort — never fail the entire processing pipeline
-            // Common failures: rate limiting, network issues, unsupported audio encoding
-            return emptyResult;
+        catch (error) {
+            // Transcription stays best-effort — a failure must never kill the whole
+            // processing pipeline. But discarding the error outright, as this block
+            // used to, made a bad API key, a rate limit and a network blip all look
+            // identical to "this file has no speech in it".
+            const message = error instanceof Error ? error.message : String(error);
+            return skipped(`transcription request failed — ${message}`);
         }
     }
     // ===========================================================================

package/dist/lib/skills/skillsManager.js

@@ -87,7 +87,14 @@ export class SkillsManager {
         // name-find would resolve non-deterministically to the stale deprecated one
         // across store backends. Fall back to any match only when no active skill
         // carries the name.
-        const entry = index.find((item) => item.name === idOrName && (item.status ?? "active") === "active") ?? index.find((item) => item.name === idOrName);
+        //
+        // Matched case-insensitively to agree with assertNameAvailable, which
+        // enforces uniqueness that way: names differing only in case cannot
+        // coexist, so a case-sensitive lookup could only fail to find a skill that
+        // is definitively there (`get("DEPLOY")` returned null for "deploy").
+        const wanted = idOrName.toLowerCase();
+        const entry = index.find((item) => item.name.toLowerCase() === wanted &&
+            (item.status ?? "active") === "active") ?? index.find((item) => item.name.toLowerCase() === wanted);
         return entry ? this.store.get(entry.id) : null;
     }
     /**
@@ -237,11 +244,23 @@ export class SkillsManager {
     }
     async assertNameAvailable(name, excludeId) {
         const index = await this.getIndex(true);
-        const clash = index.find((item) => item.id !== excludeId &&
-            item.name.toLowerCase() === name.toLowerCase() &&
-            (item.status ?? "active") === "active");
+        // Deliberately NOT filtered to active (#1139). Soft-delete only flips
+        // status to "deprecated" — the entry stays in the index, so allowing a new
+        // skill to take the name left two entries sharing it. Every name-based
+        // lookup (CLI `skills show/delete <name>`, the skill_update/skill_delete
+        // tools, the `:id`-or-name REST routes) then had to guess which one the
+        // caller meant, and iteration order differs across store backends.
+        //
+        // A deprecated skill's name therefore stays reserved. Reusing it requires
+        // hard-deleting the old skill first, which is the explicit choice the
+        // ambiguity demands.
+        const clash = index.find((item) => item.id !== excludeId && item.name.toLowerCase() === name.toLowerCase());
         if (clash) {
-            throw new Error(`A skill named "${name}" already exists`);
+            const suffix = (clash.status ?? "active") === "active"
+                ? ""
+                : ` (that name belongs to a deprecated skill, id ${clash.id}; ` +
+                    `remove it before reusing the name)`;
+            throw new Error(`A skill named "${name}" already exists${suffix}`);
         }
     }
 }

package/dist/lib/types/file.d.ts

@@ -200,6 +200,12 @@ export type CSVProcessorOptions = {
      * rather than hanging forever. Defaults: 30s for strings, 5min for files.
      */
     parseTimeoutMs?: number;
+    /**
+     * Skip blank / whitespace-only data rows (#373). Default `true`: blank lines
+     * are excluded from the returned content (including raw CSV text) and from
+     * `metadata.rowCount`. Set to `false` to preserve empty lines literally.
+     */
+    skipEmptyLines?: boolean;
 };
 /**
  * PDF API types for different providers
@@ -474,6 +480,10 @@ export type MultimodalPdfEntry = {
     password?: string;
     /** Per-page pixel ceiling for the image fallback (#260). */
     maxCanvasPixels?: number;
+    /** Render scale for the image fallback (#297). */
+    scale?: number;
+    /** Max pages converted by the image fallback (#297). */
+    maxPages?: number;
 };
 /** Result of PDF to image conversion. */
 export type PDFImageConversionResult = {

package/dist/lib/types/generate.d.ts

@@ -133,6 +133,17 @@ export type GenerateOptions = {
         password?: string;
         /** Max rendered-canvas pixels per page (#260 memory guard); oversized pages auto-downscale. */
         maxCanvasPixels?: number;
+        /**
+         * Render scale for the image fallback used by providers without native PDF
+         * support (#297). Higher is sharper but costs roughly the square in memory
+         * and tokens. Range 0.1-10; defaults to PDF_LIMITS.DEFAULT_SCALE (1.5).
+         */
+        scale?: number;
+        /**
+         * Max pages converted by the image fallback (#297). Pages beyond this are
+         * not sent to the model at all. Defaults to PDF_LIMITS.DEFAULT_MAX_PAGES (20).
+         */
+        maxPages?: number;
     };
     videoOptions?: {
         /** Frames to extract. Unset lets VideoProcessor pick from the clip's duration; clamped to 100. */
@@ -1265,6 +1276,10 @@ export type TextGenerationOptions = {
         password?: string;
         /** Max rendered-canvas pixels per page (#260 memory guard); oversized pages auto-downscale. */
         maxCanvasPixels?: number;
+        /** Render scale for the image fallback (#297); defaults to PDF_LIMITS.DEFAULT_SCALE. */
+        scale?: number;
+        /** Max pages converted by the image fallback (#297); defaults to PDF_LIMITS.DEFAULT_MAX_PAGES. */
+        maxPages?: number;
     };
     enableSummarization?: boolean;
     /**

package/dist/lib/types/processor.d.ts

@@ -703,6 +703,12 @@ export type ProcessedAudio = ProcessedFileBase & {
     transcript?: string;
     hasTranscript: boolean;
     transcriptionProvider?: string;
+    /**
+     * Why transcription produced nothing, when it did (#416). Absent on success.
+     * Lets a caller distinguish "this audio has no speech" from "the transcription
+     * backend was never reachable", which previously looked identical.
+     */
+    transcriptionSkippedReason?: string;
     coverArt?: Buffer;
 };
 /**

package/dist/lib/types/stream.d.ts

@@ -225,6 +225,17 @@ export type StreamOptions = {
         password?: string;
         /** Max rendered-canvas pixels per page (#260 memory guard); oversized pages auto-downscale. */
         maxCanvasPixels?: number;
+        /**
+         * Render scale for the image fallback used by providers without native PDF
+         * support (#297). Higher is sharper but costs roughly the square in memory
+         * and tokens. Range 0.1-10; defaults to PDF_LIMITS.DEFAULT_SCALE (1.5).
+         */
+        scale?: number;
+        /**
+         * Max pages converted by the image fallback (#297). Pages beyond this are
+         * not sent to the model at all. Defaults to PDF_LIMITS.DEFAULT_MAX_PAGES (20).
+         */
+        maxPages?: number;
     };
     videoOptions?: {
         /** Frames to extract. Unset lets VideoProcessor pick from the clip's duration; clamped to 100. */

package/dist/lib/utils/csvProcessor.d.ts

@@ -30,6 +30,18 @@ export declare function isValidCsvRow(row: unknown): row is CSVRow;
  * match) when a row violates the invariant.
  */
 export declare function assertValidCsvRow(row: unknown, rowNumber: number): asserts row is CSVRow;
+/**
+ * True when a parsed CSV row is blank: no keys, or every value is empty /
+ * whitespace-only (#373). Shared by the structured post-filter and by
+ * `streamParse` so blank rows do not consume `maxRows`.
+ */
+export declare function isBlankCsvDataRow(row: CSVRow): boolean;
+/**
+ * Raw-line counterpart of {@link isBlankCsvDataRow} (#373): a fully blank /
+ * whitespace line, or a delimiter-only line such as `,,` / `  ,  ` whose
+ * fields are all empty after a CSV-aware split.
+ */
+export declare function isBlankCsvRawLine(line: string, delimiter: string): boolean;
 /**
  * Detect if first line is CSV metadata (not actual data/headers)
  * Common patterns:
@@ -174,11 +186,17 @@ export declare class CSVProcessor {
     /**
      * Format parsed CSV data for LLM consumption
      * Only used for JSON and Markdown formats (raw format handled separately)
+     *
+     * @param columnNames - Optional schema headers (#373). When preserved blank
+     *   rows lead `rows`, Markdown must still use the real column names.
      */
     private static formatForLLM;
     /**
      * Format as markdown table
      * Best for small datasets (<100 rows)
+     *
+     * @param columnNames - Optional explicit headers (#373). Falls back to
+     *   `Object.keys(rows[0])` when omitted.
      */
     private static toMarkdownTable;
     /**
@@ -187,6 +205,7 @@ export declare class CSVProcessor {
      * @param sampleRows - Array of sample row objects
      * @param format - Output format for sample data
      * @param includeHeaders - Whether to include headers in CSV/markdown formats
+     * @param columnNames - Optional schema headers for csv/markdown (#373)
      * @returns Formatted sample data as string or array
      */
     private static formatSampleData;
@@ -195,6 +214,7 @@ export declare class CSVProcessor {
      *
      * @param rows - Array of row objects
      * @param includeHeaders - Whether to include header row
+     * @param columnNames - Optional explicit headers (#373)
      * @returns CSV formatted string
      */
     private static toCSVString;