@juspay/neurolink 12.30.2 → 12.31.0

package/dist/utils/htmlToMarkdown.js

@@ -0,0 +1,442 @@
+/**
+ * HTML to Markdown conversion for document processors.
+ *
+ * Scoped deliberately to the small, well-formed HTML subset that document
+ * converters emit (mammoth for DOCX): headings, paragraphs, emphasis, links,
+ * images, lists, block quotes, preformatted text and tables. It is not a
+ * general-purpose web-page converter, which is why the repository gains no
+ * dependency for it.
+ *
+ * @module utils/htmlToMarkdown
+ */
+/** Tags that never have a closing tag and so never open a scope. */
+const VOID_TAGS = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "source",
+    "track",
+    "wbr",
+]);
+const NAMED_ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+    nbsp: " ",
+};
+/**
+ * Decode the numeric and named character references a document converter can
+ * emit. Unknown references are left verbatim rather than dropped, so no text
+ * is silently lost.
+ */
+function decodeEntities(value) {
+    return value.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (match, body) => {
+        if (body.startsWith("#")) {
+            const codePoint = body.startsWith("#x") || body.startsWith("#X")
+                ? Number.parseInt(body.slice(2), 16)
+                : Number.parseInt(body.slice(1), 10);
+            if (Number.isNaN(codePoint) || codePoint < 0 || codePoint > 0x10ffff) {
+                return match;
+            }
+            try {
+                return String.fromCodePoint(codePoint);
+            }
+            catch {
+                return match;
+            }
+        }
+        const named = NAMED_ENTITIES[body.toLowerCase()];
+        return named ?? match;
+    });
+}
+/**
+ * Parse the HTML subset into a node tree.
+ *
+ * Unbalanced closing tags are ignored and unclosed elements are closed at the
+ * end of input, so malformed markup degrades to partial structure instead of
+ * throwing.
+ */
+function parseHtml(html) {
+    const root = {
+        kind: "element",
+        tag: "#root",
+        attrs: {},
+        children: [],
+    };
+    const stack = [root];
+    const tagPattern = /<\/?([a-zA-Z][a-zA-Z0-9-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+    let cursor = 0;
+    let match;
+    const pushText = (raw) => {
+        if (!raw) {
+            return;
+        }
+        const current = stack[stack.length - 1];
+        current.children.push({ kind: "text", value: decodeEntities(raw) });
+    };
+    while ((match = tagPattern.exec(html)) !== null) {
+        pushText(html.slice(cursor, match.index));
+        cursor = match.index + match[0].length;
+        const tag = match[1].toLowerCase();
+        const isClosing = match[0].startsWith("</");
+        const isSelfClosing = match[2].trimEnd().endsWith("/");
+        if (isClosing) {
+            // Only unwind if the tag is actually open, so a stray `</div>` is
+            // inert. Search from the top of the stack down so a closing tag
+            // matches the innermost (most recently opened) element with that
+            // name — `findIndex` would match the OUTERMOST one instead, and for
+            // nested same-tag elements (`<div><div>A</div>B</div>`) that pops both
+            // levels at once, reattaching everything after the real inner close to
+            // the wrong ancestor.
+            let openIndex = -1;
+            for (let i = stack.length - 1; i >= 0; i--) {
+                if (stack[i].tag === tag) {
+                    openIndex = i;
+                    break;
+                }
+            }
+            if (openIndex > 0) {
+                stack.length = openIndex;
+            }
+            continue;
+        }
+        const element = {
+            kind: "element",
+            tag,
+            attrs: parseAttributes(match[2]),
+            children: [],
+        };
+        stack[stack.length - 1].children.push(element);
+        if (!isSelfClosing && !VOID_TAGS.has(tag)) {
+            stack.push(element);
+        }
+    }
+    pushText(html.slice(cursor));
+    return root.children;
+}
+function parseAttributes(raw) {
+    const attrs = {};
+    const pattern = /([a-zA-Z_:][a-zA-Z0-9_.:-]*)\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>]+))/g;
+    let match;
+    while ((match = pattern.exec(raw)) !== null) {
+        const value = match[3] ?? match[4] ?? match[5] ?? "";
+        attrs[match[1].toLowerCase()] = decodeEntities(value);
+    }
+    return attrs;
+}
+function isElement(node) {
+    return node.kind === "element";
+}
+/** Collapse runs of whitespace the way an HTML renderer would. */
+function collapseWhitespace(value) {
+    return value
+        .replace(/\s+/g, " ")
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/**
+ * Format a link/image destination per CommonMark's angle-bracket form.
+ *
+ * A bare `(dest)` destination ends at the first whitespace or unbalanced
+ * `)`, so a value containing either — an `href`/`src` with a space, or one
+ * with unbalanced parentheses — would silently truncate or corrupt the
+ * surrounding `[text](dest)` / `![alt](dest)` markup. Wrapping in `<...>`
+ * makes the destination unambiguous; CommonMark requires any literal `<`
+ * or `>` inside that form to be escaped. Ordinary destinations (no
+ * whitespace or parens) are returned byte-identical to before.
+ */
+function formatLinkDestination(dest) {
+    if (!/[\s()]/.test(dest)) {
+        return dest;
+    }
+    // Backslash first: escaping only `<`/`>` turns `\>` into `\\>`, which
+    // CommonMark reads as a literal backslash followed by a bare `>`.
+    const escaped = dest
+        .replace(/\\/g, "\\\\")
+        .replace(/</g, "\\<")
+        .replace(/>/g, "\\>");
+    return `<${escaped}>`;
+}
+/** Render inline content (emphasis, links, images, line breaks) to markdown. */
+function renderInline(nodes) {
+    let out = "";
+    for (const node of nodes) {
+        if (node.kind === "text") {
+            out += collapseWhitespace(node.value);
+            continue;
+        }
+        switch (node.tag) {
+            case "script":
+            case "style":
+                break;
+            case "strong":
+            case "b": {
+                const inner = renderInline(node.children).trim();
+                out += inner ? `**${inner}**` : "";
+                break;
+            }
+            case "em":
+            case "i": {
+                const inner = renderInline(node.children).trim();
+                out += inner ? `*${inner}*` : "";
+                break;
+            }
+            case "code": {
+                const inner = renderInline(node.children).trim();
+                out += inner ? `\`${inner}\`` : "";
+                break;
+            }
+            case "a": {
+                const inner = renderInline(node.children).trim();
+                const href = node.attrs.href;
+                out += href ? `[${inner}](${formatLinkDestination(href)})` : inner;
+                break;
+            }
+            case "img": {
+                const alt = node.attrs.alt ?? "";
+                const src = node.attrs.src ?? "";
+                // A DOCX image is inlined as a multi-megabyte data URI; keep the
+                // alt text and drop the payload rather than flooding the prompt.
+                out += src.startsWith("data:")
+                    ? `![${alt}](embedded-image)`
+                    : `![${alt}](${formatLinkDestination(src)})`;
+                break;
+            }
+            case "br":
+                out += "\n";
+                break;
+            default:
+                out += renderInline(node.children);
+                break;
+        }
+    }
+    return out;
+}
+/**
+ * Extract a `<pre>` block's text content verbatim.
+ *
+ * `renderInline()` funnels every text node through `collapseWhitespace()`,
+ * which does `.replace(/\s+/g, " ")` — right for prose, destructive for
+ * code: it collapses every newline, tab and indentation run onto one line.
+ * This walks the same tree but keeps each text node's raw value, so a
+ * multi-line, indented code sample survives into the fenced block intact.
+ * A nested element (e.g. `<pre><code>…</code></pre>`) still contributes its
+ * text, but ignores inline markdown semantics like `**`/`*`/`` ` `` —
+ * `<pre>` content is literal code, not prose, and injecting markdown markers
+ * into it would corrupt the code rather than format it.
+ */
+function renderPreformattedText(nodes) {
+    let out = "";
+    for (const node of nodes) {
+        if (node.kind === "text") {
+            out += node.value;
+            continue;
+        }
+        if (node.tag === "script" || node.tag === "style") {
+            continue;
+        }
+        if (node.tag === "br") {
+            out += "\n";
+            continue;
+        }
+        out += renderPreformattedText(node.children);
+    }
+    return out;
+}
+/** Collect the `<tr>` rows under a table, seeing through thead/tbody/tfoot. */
+function collectRows(node) {
+    const rows = [];
+    for (const child of node.children.filter(isElement)) {
+        if (child.tag === "tr") {
+            rows.push(child);
+        }
+        else if (["thead", "tbody", "tfoot"].includes(child.tag)) {
+            rows.push(...collectRows(child));
+        }
+    }
+    return rows;
+}
+/** A pipe inside a cell would otherwise split it into two columns. */
+function escapeCell(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/\|/g, "\\|")
+        .replace(/\n/g, " ")
+        .trim();
+}
+function renderTable(node) {
+    const rows = collectRows(node);
+    if (rows.length === 0) {
+        return "";
+    }
+    const cellsOf = (row) => row.children
+        .filter(isElement)
+        .filter((cell) => cell.tag === "td" || cell.tag === "th")
+        .map((cell) => escapeCell(renderBlocks(cell.children).replace(/\n+/g, " ")));
+    // Markdown has no headerless table, so when the source marked no header row
+    // the first row is promoted — that is what a reader sees anyway.
+    const header = cellsOf(rows[0]);
+    const bodyRows = rows.slice(1).map(cellsOf);
+    const columnCount = Math.max(header.length, ...bodyRows.map((r) => r.length), 1);
+    const pad = (cells) => Array.from({ length: columnCount }, (_, i) => cells[i] ?? "");
+    const lines = [
+        `| ${pad(header).join(" | ")} |`,
+        `| ${Array.from({ length: columnCount }, () => "---").join(" | ")} |`,
+        ...bodyRows.map((cells) => `| ${pad(cells).join(" | ")} |`),
+    ];
+    return lines.join("\n");
+}
+function renderList(node, depth) {
+    const ordered = node.tag === "ol";
+    const items = node.children
+        .filter(isElement)
+        .filter((child) => child.tag === "li");
+    const indent = "  ".repeat(depth);
+    return items
+        .map((item, index) => {
+        const marker = ordered ? `${index + 1}.` : "-";
+        // Nested lists render themselves at the next depth; everything else on
+        // the item is inline content belonging to this bullet.
+        const nested = item.children
+            .filter(isElement)
+            .filter((child) => child.tag === "ul" || child.tag === "ol");
+        const own = item.children.filter((child) => !(isElement(child) && (child.tag === "ul" || child.tag === "ol")));
+        const label = renderBlocks(own).replace(/\n+/g, " ").trim();
+        const nestedText = nested
+            .map((child) => renderList(child, depth + 1))
+            .filter(Boolean)
+            .join("\n");
+        return [`${indent}${marker} ${label}`.trimEnd(), nestedText]
+            .filter(Boolean)
+            .join("\n");
+    })
+        .join("\n");
+}
+/** Render block-level content, separating blocks with a blank line. */
+function renderBlocks(nodes) {
+    const blocks = [];
+    let inlineBuffer = "";
+    const flushInline = () => {
+        const text = inlineBuffer.trim();
+        if (text) {
+            blocks.push(text);
+        }
+        inlineBuffer = "";
+    };
+    for (const node of nodes) {
+        if (node.kind === "text") {
+            inlineBuffer += collapseWhitespace(node.value);
+            continue;
+        }
+        const headingMatch = /^h([1-6])$/.exec(node.tag);
+        if (headingMatch) {
+            flushInline();
+            const level = Number.parseInt(headingMatch[1], 10);
+            const text = renderInline(node.children).replace(/\n+/g, " ").trim();
+            if (text) {
+                blocks.push(`${"#".repeat(level)} ${text}`);
+            }
+            continue;
+        }
+        switch (node.tag) {
+            case "script":
+            case "style":
+                flushInline();
+                break;
+            case "p": {
+                flushInline();
+                const text = renderBlocks(node.children).trim();
+                if (text) {
+                    blocks.push(text);
+                }
+                break;
+            }
+            case "ul":
+            case "ol": {
+                flushInline();
+                const text = renderList(node, 0);
+                if (text) {
+                    blocks.push(text);
+                }
+                break;
+            }
+            case "table": {
+                flushInline();
+                const text = renderTable(node);
+                if (text) {
+                    blocks.push(text);
+                }
+                break;
+            }
+            case "blockquote": {
+                flushInline();
+                const inner = renderBlocks(node.children).trim();
+                if (inner) {
+                    blocks.push(inner
+                        .split("\n")
+                        .map((line) => (line ? `> ${line}` : ">"))
+                        .join("\n"));
+                }
+                break;
+            }
+            case "pre": {
+                flushInline();
+                const inner = renderPreformattedText(node.children).replace(/^\n+|\n+$/g, "");
+                if (inner) {
+                    blocks.push(`\`\`\`\n${inner}\n\`\`\``);
+                }
+                break;
+            }
+            case "hr": {
+                flushInline();
+                blocks.push("---");
+                break;
+            }
+            case "div":
+            case "section":
+            case "article": {
+                flushInline();
+                const inner = renderBlocks(node.children).trim();
+                if (inner) {
+                    blocks.push(inner);
+                }
+                break;
+            }
+            default:
+                inlineBuffer += renderInline([node]);
+                break;
+        }
+    }
+    flushInline();
+    return blocks.join("\n\n");
+}
+/**
+ * Convert an HTML fragment to Markdown.
+ *
+ * @param html - HTML produced by a document converter
+ * @returns Markdown text, or an empty string when the fragment has no content
+ *
+ * @example
+ * ```typescript
+ * htmlToMarkdown("<h1>Title</h1><p>Body</p>"); // "# Title\n\nBody"
+ * ```
+ */
+export function htmlToMarkdown(html) {
+    if (!html || !html.trim()) {
+        return "";
+    }
+    return renderBlocks(parseHtml(html))
+        .replace(/[ \t]+$/gm, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}

package/dist/utils/messageBuilder.js

@@ -895,6 +895,9 @@ async function detectFileForUnifiedArray(file, options, provider, genericFileMax
             "unknown",
         ],
         csvOptions: options.csvOptions,
+        // Office options travel the same unified `files` path, so this is where a
+        // caller's sheet selection / format choice reaches the XLSX processor.
+        officeOptions: options.officeOptions,
         // #478: videos arrive through this unified `files` path, so this is
         // where the CLI's frame/quality/format request has to be handed on.
         videoOptions: options.videoOptions

package/dist/utils/multimodalOptionsBuilder.d.ts

@@ -16,6 +16,7 @@ import type { StreamOptions } from "../types/index.js";
  *   - input.videoFiles: Video files (Buffer | string paths)
  *   - csvOptions: CSV parsing options
  *   - videoOptions: Video frame/quality/format/transcription options
+ *   - officeOptions: DOCX/XLSX sheet selection and output-format options
  *   - systemPrompt: System-level instructions
  *   - conversationMessages: Chat history
  *   - temperature: Model temperature (0-1)
@@ -28,6 +29,7 @@ import type { StreamOptions } from "../types/index.js";
  * @returns {object} Normalized options object with:
  *   - input: { text, images, content, files, csvFiles, pdfFiles, audioFiles, videoFiles }
  *   - csvOptions: CSV processing options
+ *   - officeOptions: Office (DOCX/XLSX) processing options
  *   - systemPrompt: System prompt string
  *   - conversationHistory: Message history array
  *   - provider: Provider name
@@ -66,6 +68,7 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
         outputFormat?: import("../index.js").VisionImageOutputFormat;
     } | undefined;
     videoOptions: import("../index.js").VideoProcessorOptions | undefined;
+    officeOptions: import("../index.js").OfficeProcessorOptions | undefined;
     systemPrompt: string | undefined;
     conversationHistory: import("../index.js").ChatMessage[] | undefined;
     provider: string;

package/dist/utils/multimodalOptionsBuilder.js

@@ -15,6 +15,7 @@
  *   - input.videoFiles: Video files (Buffer | string paths)
  *   - csvOptions: CSV parsing options
  *   - videoOptions: Video frame/quality/format/transcription options
+ *   - officeOptions: DOCX/XLSX sheet selection and output-format options
  *   - systemPrompt: System-level instructions
  *   - conversationMessages: Chat history
  *   - temperature: Model temperature (0-1)
@@ -27,6 +28,7 @@
  * @returns {object} Normalized options object with:
  *   - input: { text, images, content, files, csvFiles, pdfFiles, audioFiles, videoFiles }
  *   - csvOptions: CSV processing options
+ *   - officeOptions: Office (DOCX/XLSX) processing options
  *   - systemPrompt: System prompt string
  *   - conversationHistory: Message history array
  *   - provider: Provider name
@@ -67,6 +69,10 @@ export function buildMultimodalOptions(options, providerName, modelName) {
         // `StreamOptions` never reach VideoProcessor on the Bedrock branch, and
         // it silently falls back to the duration-tier default.
         videoOptions: options.videoOptions,
+        // Same #1259 whitelist-drop bug class as audioFiles/videoFiles above:
+        // omitted here, Bedrock's multimodal generate()/stream() path always got
+        // sheetName/formatStyle undefined regardless of what the caller passed.
+        officeOptions: options.officeOptions,
         systemPrompt: options.systemPrompt,
         conversationHistory: options.conversationMessages,
         provider: providerName,

package/docs-site/static/search-index.json

@@ -3960,7 +3960,7 @@
 {"objectID":"534fbec3fbb29aa94fe464858c0906946aa7d909f9fa82dd2cc4c1f8d6821027","title":"Spans not being sent to Langfuse","url":"/docs/features/observability#spans-not-being-sent-to-langfuse","content":"Problem: Traces don't appear in Langfuse dashboard.\n\nSolution:\nVerify credentials are correct\nCheck health status:\nEnsure  is called before process exit\nCheck network connectivity to Langfuse endpoint","hierarchy":{"lvl0":"Features","lvl1":"Observability Guide","lvl2":"Spans not being sent to Langfuse","lvl3":""}},
 {"objectID":"bc1755900c005626bd213860a41c0169833cf8288e799f4cb83e4ee499aa9396","title":"API Reference","url":"/docs/features/observability#api-reference","content":"The following functions and types are exported from :\n\nFunctions:\n- Set context for Langfuse traces\n- Get current Langfuse context\n- Get OpenTelemetry tracer instance\n- Get span processors for external TracerProvider integration\n\nTypes:\n- Configuration options for Langfuse integration\n- GenAI semantic convention attributes","hierarchy":{"lvl0":"Features","lvl1":"Observability Guide","lvl2":"API Reference","lvl3":""}},
 {"objectID":"9a2c99612604332f4b2bc32fb673fe19412249aba74ad41f2ed2cfd84a8d1185","title":"See Also","url":"/docs/features/observability#see-also","content":"Telemetry Guide - OpenTelemetry setup with Jaeger\nEnterprise Monitoring - Prometheus and Grafana setup\nAnalytics Reference - Token and cost tracking","hierarchy":{"lvl0":"Features","lvl1":"Observability Guide","lvl2":"See Also","lvl3":""}},
-{"objectID":"1b22ff57a6c6e2525e50e02118d6029f5ee3779ef701e9fde1b7b97d1a782760","title":"Office Documents Support","url":"/docs/features/office-documents","content":"Office Documents Support\n\nNeuroLink provides seamless Office document support as a multimodal input type - attach DOCX, PPTX, and XLSX documents directly to your AI prompts for document analysis, data extraction, and content processing.\n\nOverview\n\nOffice document support in NeuroLink works as a native multimodal input - the system automatically processes Office files and passes them to the AI provider's document understanding capabilities. The system:\nValidates Office files using magic byte detection and format verification\nChecks provider compatibility (Bedrock, Vertex AI, Anthropic)\nVerifies file size limits per provider\nPasses documents directly to the provider's native document API\nWorks with providers that support native Office document processing\n\nKey Difference from PDF: Similar to PDF files, Office documents are sent as binary documents to providers with native document support. This enables analysis of formatted text, tables, charts, and embedded content within Office files.\n\nSupported File Types\n\n| Format                | Extension | MIME Type                                                                   | Description                                        |\n| --------------------- | --------- | --------------------------------------------------------------------------- | -------------------------------------------------- |\n| Word Document     |    |    | Microsoft Word documents with text, images, tables |\n| PowerPoint        |    |  | Presentations with slides, charts, images          |\n| Excel Spreadsheet |    |          | Spreadsheets with data, formulas, charts           |\n\nLegacy Formats:\n\n| Format         | Extension | MIME Type                  | Support            |\n| -------------- | --------- | -------------------------- | ------------------ |\n| Word (Legacy)  |     |        | Provider-dependent |\n| Excel (Legacy) |     |  | Provider-dependent |\n\nQuick Start\n\nSDK Usage\n\nCLI Usage\n\nAPI Reference\n\nGenerateOptions\n\nStreamOptions\n\nOfficeProcessorOptions\n\nFile Input Formats\n\nProvider Support\n\nSupported Providers\n\n| Provider             | Max Size | DOCX | PPTX | XLSX | DOC | XLS | Notes                                |\n| -------------------- | -------- | ---- | ---- | ---- | --- | --- | ------------------------------------ |\n| AWS Bedrock      | 5 MB     | ✅   | ✅   | ✅   | ✅  | ✅  | Full native support via Converse API |\n| Google Vertex AI | 5 MB     | ✅   | ⚠️   | ✅   | ⚠️  | ⚠️  | Best for DOCX and XLSX               |\n| Anthropic Claude | 5 MB     | ✅   | ⚠️   | ✅   | ⚠️  | ⚠️  | Via document API                     |\n\nUnsupported Providers\n\nThe following providers do not currently support native Office document processing:\nOpenAI (GPT-4o)\nGoogle AI Studio\nAzure OpenAI\nOllama (local models)\nLiteLLM\nMistral AI\nHugging Face\n\nError Message for Unsupported Providers:\n\nProvider-Specific Features\n\nAWS Bedrock (Recommended)\n\nBedrock offers the most comprehensive Office document support via the Converse API:\n\nSupported Document Formats in Bedrock Converse API:\nOffice formats: , , , \nOther formats: , , , , \n\nGoogle Vertex AI\n\nAnthropic Claude\n\nFeatures\nAuto-Detection\n\nUse the  array for automatic file type detection:\nMultiple Document Types\n\nProcess multiple Office documents in a single request:\nMixed Multimodal Inputs\n\nCombine Office documents with other file types:\n\nType Definitions\n\nOfficeFileType\n\nOfficeProcessingResult\n\nOfficeProviderConfig\n\nError Handling\n\nError Types\n\nError Handling Patterns\n\nMetadata Fields\n\nWhen processing Office documents, the following metadata is available:\n\n| Field               | Type             | Description                      |\n| ------------------- | ---------------- | -------------------------------- |\n|         |          | Detection confidence (0-100)     |\n|               |          | File size in bytes               |\n|           |          | Original filename                |\n|             |  | Detected Office format           |\n|           |          | Provider used for processing     |\n|     |          | Estimated page/slide/sheet count |\n|  |         | Whether document contains images |\n|          |         | Whether document contains charts |\n\nAccessing Metadata\n\nBest Practices\nChoose the Right Provider\nOptimize File Size\nUse Streaming for Large Documents\nBe Specific in Your Prompts\n\nLimitations\n\nFile Format Requirements\nMust be valid Office Open XML format (, , )\nMust be within provider size limits (typically 5MB)\nMust not be password-protected or encrypted\nLegacy formats (, , ) have limited support\n\nProvider Limitations\n\n| Limitation          | Description                 | Workaround                              |\n| ------------------- | --------------------------- | --------------------------------------- |\n| Size limits         | Most providers limit to 5MB | Split large documents or convert to PDF |\n| Password protection | Not supported               | Remove password before processing       |\n| Macros              | VBA macros are ignored ","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"","lvl3":""}},
+{"objectID":"1b22ff57a6c6e2525e50e02118d6029f5ee3779ef701e9fde1b7b97d1a782760","title":"Office Documents Support","url":"/docs/features/office-documents","content":"Office Documents Support\n\nNeuroLink provides seamless Office document support as a multimodal input type - attach DOCX, PPTX, and XLSX documents directly to your AI prompts for document analysis, data extraction, and content processing.\n\nOverview\n\nOffice document support in NeuroLink works as a native multimodal input - the system automatically processes Office files and passes them to the AI provider's document understanding capabilities. The system:\nValidates Office files using magic byte detection and format verification\nChecks provider compatibility (Bedrock, Vertex AI, Anthropic)\nVerifies file size limits per provider\nPasses documents directly to the provider's native document API\nWorks with providers that support native Office document processing\n\nKey Difference from PDF: Similar to PDF files, Office documents are sent as binary documents to providers with native document support. This enables analysis of formatted text, tables, charts, and embedded content within Office files.\n\nSupported File Types\n\n| Format                | Extension | MIME Type                                                                   | Description                                        |\n| --------------------- | --------- | --------------------------------------------------------------------------- | -------------------------------------------------- |\n| Word Document     |    |    | Microsoft Word documents with text, images, tables |\n| PowerPoint        |    |  | Presentations with slides, charts, images          |\n| Excel Spreadsheet |    |          | Spreadsheets with data, formulas, charts           |\n\nLegacy Formats:\n\n| Format         | Extension | MIME Type                  | Support            |\n| -------------- | --------- | -------------------------- | ------------------ |\n| Word (Legacy)  |     |        | Provider-dependent |\n| Excel (Legacy) |     |  | Provider-dependent |\n\nQuick Start\n\nSDK Usage\n\nCLI Usage\n\nAPI Reference\n\nGenerateOptions\n\nStreamOptions\n\nOfficeProcessorOptions\n\nOnly  and  are read by the XLSX pipeline today; the\nother fields are declared but not yet consumed.\n\nDOCX structure and metrics\n\nA  is converted to Markdown before it reaches the model, so headings,\nordered and unordered lists, and tables survive as structure rather than being\nflattened into prose. Each document is prefixed with a metrics line:\n\nThis needs no configuration and applies to every provider, because the\nconversion happens while the prompt is built rather than in a provider adapter.\n\nSelecting and formatting spreadsheet data\n\nNaming a sheet that does not exist does not silently fall back to every sheet —\nthe prompt reports the miss and lists the available sheet names.\n\nFile Input Formats\n\nProvider Support\n\nSupported Providers\n\n| Provider             | Max Size | DOCX | PPTX | XLSX | DOC | XLS | Notes                                |\n| -------------------- | -------- | ---- | ---- | ---- | --- | --- | ------------------------------------ |\n| AWS Bedrock      | 5 MB     | ✅   | ✅   | ✅   | ✅  | ✅  | Full native support via Converse API |\n| Google Vertex AI | 5 MB     | ✅   | ⚠️   | ✅   | ⚠️  | ⚠️  | Best for DOCX and XLSX               |\n| Anthropic Claude | 5 MB     | ✅   | ⚠️   | ✅   | ⚠️  | ⚠️  | Via document API                     |\n\nUnsupported Providers\n\nThe following providers do not currently support native Office document processing:\nOpenAI (GPT-4o)\nGoogle AI Studio\nAzure OpenAI\nOllama (local models)\nLiteLLM\nMistral AI\nHugging Face\n\nError Message for Unsupported Providers:\n\nProvider-Specific Features\n\nAWS Bedrock (Recommended)\n\nBedrock offers the most comprehensive Office document support via the Converse API:\n\nSupported Document Formats in Bedrock Converse API:\nOffice formats: , , , \nOther formats: , , , , \n\nGoogle Vertex AI\n\nAnthropic Claude\n\nFeatures\nAuto-Detection\n\nUse the  array for automatic file type detection:\nMultiple Document Types\n\nProcess multiple Office documents in a single request:\nMixed Multimodal Inputs\n\nCombine Office documents with other file types:\n\nType Definitions\n\nOfficeFileType\n\nOfficeProcessingResult\n\nOfficeProviderConfig\n\nError Handling\n\nError Types\n\nError Handling Patterns\n\nMetadata Fields\n\nWhen processing Office documents, the following metadata is available:\n\n| Field               | Type             | Description                      |\n| ------------------- | ---------------- | -------------------------------- |\n|         |          | Detection confidence (0-100)     |\n|               |          | File size in bytes               |\n|           |          | Original filename                |\n|             |  | Detected Office format           |\n|           |          | Provider used for processing     |\n|     |          | Estimated page/slide/sheet count |\n|  |         | Whether document contains images |\n|          |         | Whether document contains charts |\n\nAccessing Metadata\n\nBest Practices\nChoose the Right Provider\nOptimize File Size\nUse Streaming for Large Documents\nBe Specific in ","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"","lvl3":""}},
 {"objectID":"20c3155d2c1f39db07b8ffb72304d589cb601d27d43fb6f6f81ec8e83b5af4f2","title":"Office Documents Support","url":"/docs/features/office-documents#office-documents-support","content":"NeuroLink provides seamless Office document support as a multimodal input type - attach DOCX, PPTX, and XLSX documents directly to your AI prompts for document analysis, data extraction, and content processing.","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Office Documents Support","lvl3":""}},
 {"objectID":"89922c3be7ba989417dd4f9aa76cf3c0497898b83d430c80f5809846a01ebcab","title":"Overview","url":"/docs/features/office-documents#overview","content":"Office document support in NeuroLink works as a native multimodal input - the system automatically processes Office files and passes them to the AI provider's document understanding capabilities. The system:\nValidates Office files using magic byte detection and format verification\nChecks provider compatibility (Bedrock, Vertex AI, Anthropic)\nVerifies file size limits per provider\nPasses documents directly to the provider's native document API\nWorks with providers that support native Office document processing\n\nKey Difference from PDF: Similar to PDF files, Office documents are sent as binary documents to providers with native document support. This enables analysis of formatted text, tables, charts, and embedded content within Office files.","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Overview","lvl3":""}},
 {"objectID":"0b9f9e62a508886292fe189b77c320798552f0b7ac01939ef46d03f3b78126a3","title":"Supported File Types","url":"/docs/features/office-documents#supported-file-types","content":"| Format                | Extension | MIME Type                                                                   | Description                                        |\n| --------------------- | --------- | --------------------------------------------------------------------------- | -------------------------------------------------- |\n| Word Document     |    |    | Microsoft Word documents with text, images, tables |\n| PowerPoint        |    |  | Presentations with slides, charts, images          |\n| Excel Spreadsheet |    |          | Spreadsheets with data, formulas, charts           |\n\nLegacy Formats:\n\n| Format         | Extension | MIME Type                  | Support            |\n| -------------- | --------- | -------------------------- | ------------------ |\n| Word (Legacy)  |     |        | Provider-dependent |\n| Excel (Legacy) |     |  | Provider-dependent |","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Supported File Types","lvl3":""}},
@@ -3972,6 +3972,10 @@
 {"objectID":"f2a3292cd8b2c1e4fd2b00bc931836682736f6e8f99e379912f3d570c7791916","title":"Auto-detect file types","url":"/docs/features/office-documents#auto-detect-file-types","content":"neurolink generate \"Analyze all documents\" --file report.docx --file data.xlsx --provider bedrock","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Auto-detect file types","lvl3":""}},
 {"objectID":"771290e410b0a74d826c5973de02a9a3064fa2b66543b83163fd06fc2be7b37d","title":"Stream mode with Office documents","url":"/docs/features/office-documents#stream-mode-with-office-documents","content":"neurolink stream \"Explain this document in detail\" --file document.docx --provider bedrock","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Stream mode with Office documents","lvl3":""}},
 {"objectID":"52189df50a2aa3edc4c43df6d16b7390207ec0b8eaca625c0b90a45190f6f45c","title":"attachments are only available on generate and stream.","url":"/docs/features/office-documents#attachments-are-only-available-on-generate-and-stream","content":"`","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"attachments are only available on generate and stream.","lvl3":""}},
+{"objectID":"beeb0b5e0c628bc0390e7579cc89c3dcb929894cffeb7a04bb8df96f6c8beb50","title":"OfficeProcessorOptions","url":"/docs/features/office-documents#officeprocessoroptions","content":"Only  and  are read by the XLSX pipeline today; the\nother fields are declared but not yet consumed.","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"OfficeProcessorOptions","lvl3":""}},
+{"objectID":"67803d753a4af41df778c73ea9d4f3055339e3e9c2eaa77b082e5b95d0b5bff3","title":"DOCX structure and metrics","url":"/docs/features/office-documents#docx-structure-and-metrics","content":"A  is converted to Markdown before it reaches the model, so headings,\nordered and unordered lists, and tables survive as structure rather than being\nflattened into prose. Each document is prefixed with a metrics line:\n\n`\nDocument: 42 words, 9 paragraphs, 268 characters","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"DOCX structure and metrics","lvl3":""}},
+{"objectID":"e58480b8b9a182fd718393f62b8c0beaeb759f7d39ba9ca286a122ab959c66f1","title":"Adoption","url":"/docs/features/office-documents#adoption","content":"Merchant onboarding automated\nSettlement latency reduced\n\n| Region | Merchants | Volume |\n| --- | --- | --- |\n| APAC | 128 | 44200 |\n`\n\nThis needs no configuration and applies to every provider, because the\nconversion happens while the prompt is built rather than in a provider adapter.","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Adoption","lvl3":""}},
+{"objectID":"4db4bf0a8dc60ff49e53fb0ea30ad888573cf4b2fc31a8664bd6fab88bb05235","title":"Selecting and formatting spreadsheet data","url":"/docs/features/office-documents#selecting-and-formatting-spreadsheet-data","content":"Naming a sheet that does not exist does not silently fall back to every sheet —\nthe prompt reports the miss and lists the available sheet names.","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Selecting and formatting spreadsheet data","lvl3":""}},
 {"objectID":"12b894726ee0b402bad0c3fd17ca5de929c1c2402385ae027effd650cc104429","title":"Supported Providers","url":"/docs/features/office-documents#supported-providers","content":"| Provider             | Max Size | DOCX | PPTX | XLSX | DOC | XLS | Notes                                |\n| -------------------- | -------- | ---- | ---- | ---- | --- | --- | ------------------------------------ |\n| AWS Bedrock      | 5 MB     | ✅   | ✅   | ✅   | ✅  | ✅  | Full native support via Converse API |\n| Google Vertex AI | 5 MB     | ✅   | ⚠️   | ✅   | ⚠️  | ⚠️  | Best for DOCX and XLSX               |\n| Anthropic Claude | 5 MB     | ✅   | ⚠️   | ✅   | ⚠️  | ⚠️  | Via document API                     |","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Supported Providers","lvl3":""}},
 {"objectID":"05fac2c6f487c6f16a0adbb2535b4675b18732ba064cf3febdcc1539df29e9d8","title":"Unsupported Providers","url":"/docs/features/office-documents#unsupported-providers","content":"The following providers do not currently support native Office document processing:\nOpenAI (GPT-4o)\nGoogle AI Studio\nAzure OpenAI\nOllama (local models)\nLiteLLM\nMistral AI\nHugging Face\n\nError Message for Unsupported Providers:","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"Unsupported Providers","lvl3":""}},
 {"objectID":"abafed9b3d4d95d62c55f7c337d36384f6ae83e392f8c5640e412a4478ca8d3f","title":"AWS Bedrock (Recommended)","url":"/docs/features/office-documents#aws-bedrock-recommended","content":"Bedrock offers the most comprehensive Office document support via the Converse API:\n\nSupported Document Formats in Bedrock Converse API:\nOffice formats: , , , \nOther formats: , , , ,","hierarchy":{"lvl0":"Features","lvl1":"Office Documents Support","lvl2":"AWS Bedrock (Recommended)","lvl3":""}},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.30.2",
+  "version": "12.31.0",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -255,6 +255,7 @@
     "test:mcp-result-cache": "pnpm exec tsx test/continuous-test-suite-mcp-result-cache.ts",
     "test:mcp-breaker-resolved-errors": "pnpm exec tsx test/continuous-test-suite-mcp-breaker-resolved-errors.ts",
     "test:archive:security": "pnpm exec tsx test/continuous-test-suite-archive-security.ts",
+    "test:office": "pnpm exec tsx test/continuous-test-suite-office.ts",
     "test:office:security": "pnpm exec tsx test/continuous-test-suite-office-security.ts",
     "test:vision-image-format": "pnpm exec tsx test/continuous-test-suite-vision-image-format.ts",
     "test:image-exif": "pnpm exec tsx test/continuous-test-suite-image-exif.ts",