@juspay/neurolink 9.14.0 → 9.16.0

package/dist/lib/providers/openAI.js

@@ -1,5 +1,6 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { streamText } from "ai";
+import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -7,6 +8,7 @@ import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { logger } from "../utils/logger.js";
+import { calculateCost } from "../utils/pricing.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
@@ -17,6 +19,7 @@ const getOpenAIApiKey = () => {
 const getOpenAIModel = () => {
     return getProviderModel("OPENAI_MODEL", "gpt-4o");
 };
+const streamTracer = trace.getTracer("neurolink.provider.openai");
 /**
  * OpenAI Provider v2 - BaseProvider Implementation
  * Migrated to use factory pattern with exact Google AI provider pattern
@@ -274,27 +277,82 @@ export class OpenAIProvider extends BaseProvider {
                     : "no-tools",
             });
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            const result = await streamText({
-                model,
-                messages: messages,
-                temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
-                tools,
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
-                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                onStepFinish: ({ toolCalls, toolResults }) => {
-                    logger.info("Tool execution completed", { toolResults, toolCalls });
-                    // Handle tool execution storage
-                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                        logger.warn("[OpenAIProvider] Failed to store tool executions", {
-                            provider: this.providerName,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    });
+            // Wrap streamText in an OTel span to capture provider-level latency and token usage
+            const streamSpan = streamTracer.startSpan("neurolink.provider.streamText", {
+                kind: SpanKind.CLIENT,
+                attributes: {
+                    "gen_ai.system": "openai",
+                    "gen_ai.request.model": model.modelId || this.modelName || "unknown",
                 },
             });
+            let result;
+            try {
+                result = streamText({
+                    model,
+                    messages: messages,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                    maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
+                    tools,
+                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                    toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
+                    abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                    onStepFinish: ({ toolCalls, toolResults }) => {
+                        logger.info("Tool execution completed", {
+                            toolResults,
+                            toolCalls,
+                        });
+                        // Handle tool execution storage
+                        this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                            logger.warn("[OpenAIProvider] Failed to store tool executions", {
+                                provider: this.providerName,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        });
+                    },
+                });
+            }
+            catch (streamError) {
+                streamSpan.end();
+                throw streamError;
+            }
+            // Collect token usage and finish reason asynchronously when the stream completes,
+            // then end the span. This avoids blocking the stream consumer.
+            result.usage
+                .then((usage) => {
+                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+                const cost = calculateCost(this.providerName, this.modelName, {
+                    input: usage.promptTokens || 0,
+                    output: usage.completionTokens || 0,
+                    total: (usage.promptTokens || 0) + (usage.completionTokens || 0),
+                });
+                if (cost && cost > 0) {
+                    streamSpan.setAttribute("neurolink.cost", cost);
+                }
+            })
+                .catch(() => {
+                // Usage may not be available if the stream is aborted
+            });
+            result.finishReason
+                .then((reason) => {
+                streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
+            })
+                .catch(() => {
+                // Finish reason may not be available if the stream is aborted
+            });
+            result.text
+                .then(() => {
+                streamSpan.end();
+            })
+                .catch((err) => {
+                streamSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+                streamSpan.end();
+            });
             timeoutController?.cleanup();
             // Debug the actual result structure
             logger.debug(`OpenAI: streamText result structure:`, {

package/dist/lib/providers/sagemaker/parsers.js

@@ -9,6 +9,7 @@ import { createStructuredOutputParser, isStructuredContent, } from "./structured
 import { SageMakerError } from "./errors.js";
 import { logger } from "../../utils/logger.js";
 import { randomUUID } from "crypto";
+import { estimateTokens } from "../../utils/tokenEstimation.js";
 /**
  * Constants for JSON parsing and validation
  */
@@ -623,9 +624,8 @@ function extractApiErrorMessage(errorData) {
  * Utility function to estimate token usage when not provided
  */
 export function estimateTokenUsage(prompt, completion) {
-    // Rough estimation: ~4 characters per token for English text
-    const promptTokens = Math.ceil(prompt.length / 4);
-    const completionTokens = Math.ceil(completion.length / 4);
+    const promptTokens = estimateTokens(prompt, "sagemaker");
+    const completionTokens = estimateTokens(completion, "sagemaker");
     return {
         promptTokens,
         completionTokens,

package/dist/lib/providers/sagemaker/streaming.js

@@ -7,6 +7,7 @@
 import { ReadableStream } from "stream/web";
 import { handleSageMakerError, SageMakerError } from "./errors.js";
 import { logger } from "../../utils/logger.js";
+import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { createSageMakerDetector, } from "./detection.js";
 import { StreamingParserFactory } from "./parsers.js";
 /**
@@ -320,9 +321,8 @@ export async function createSyntheticStream(text, usage, options = {}) {
  * @returns Estimated usage information
  */
 export function estimateTokenUsage(prompt, completion) {
-    // Simple estimation: ~4 characters per token (rough average for English)
-    const promptTokens = Math.ceil(prompt.length / 4);
-    const completionTokens = Math.ceil(completion.length / 4);
+    const promptTokens = estimateTokens(prompt, "sagemaker");
+    const completionTokens = estimateTokens(completion, "sagemaker");
     return {
         promptTokens,
         completionTokens,

package/dist/lib/proxy/proxyFetch.js

@@ -4,31 +4,84 @@
  * Lightweight implementation extracted from research of major proxy packages
  */
 import { logger } from "../utils/logger.js";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/tracers.js";
 import { shouldBypassProxy } from "./utils/noProxyUtils.js";
+const fetchTracer = tracers.http;
+/**
+ * Extract hostname from a URL string for safe logging (no auth tokens or paths).
+ * Returns "[unknown]" if parsing fails.
+ */
+function extractHostname(url) {
+    try {
+        const urlStr = typeof url === "string"
+            ? url
+            : url instanceof URL
+                ? url.href
+                : url.url;
+        const parsed = new URL(urlStr);
+        return parsed.hostname;
+    }
+    catch {
+        return "[unknown]";
+    }
+}
 /**
  * Retry-aware fetch wrapper for transient network errors (ECONNRESET, ETIMEDOUT, socket hang up).
  * Protects all LLM API calls and token refreshes that go through createProxyFetch().
+ * Instrumented with OpenTelemetry spans for retry visibility.
  */
 async function fetchWithRetry(url, init, maxRetries = 3, baseDelay = 500) {
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const hostname = extractHostname(url);
+    return fetchTracer.startActiveSpan("neurolink.http.fetchWithRetry", async (span) => {
+        span.setAttribute("http.request.max_retries", maxRetries);
+        span.setAttribute("http.request.hostname", hostname);
+        span.setAttribute("http.request.method", init?.method || "GET");
+        let totalAttempts = 0;
         try {
-            return await fetch(url, init);
-        }
-        catch (error) {
-            const err = error;
-            const isRetryable = err?.code === "ECONNRESET" ||
-                err?.code === "ETIMEDOUT" ||
-                err?.message?.includes("socket hang up") ||
-                err?.message?.includes("network socket disconnected");
-            if (!isRetryable || attempt === maxRetries) {
-                throw error;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                totalAttempts = attempt + 1;
+                try {
+                    const response = await fetch(url, init);
+                    // Record success attributes
+                    span.setAttribute("http.request.total_attempts", totalAttempts);
+                    span.setAttribute("http.response.status_code", response.status);
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    const err = error;
+                    const isRetryable = err?.code === "ECONNRESET" ||
+                        err?.code === "ETIMEDOUT" ||
+                        err?.message?.includes("socket hang up") ||
+                        err?.message?.includes("network socket disconnected");
+                    if (!isRetryable || attempt === maxRetries) {
+                        // Final failure — record on span and rethrow
+                        span.setAttribute("http.request.total_attempts", totalAttempts);
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err?.message || err?.code || "fetchWithRetry final failure",
+                        });
+                        span.recordException(error instanceof Error ? error : new Error(String(error)));
+                        throw error;
+                    }
+                    // Transient error — add retry event and continue loop
+                    const delay = baseDelay * Math.pow(2, attempt);
+                    span.addEvent("http.request.retry", {
+                        "retry.attempt": attempt + 1,
+                        "retry.delay_ms": delay,
+                        "retry.error": (err?.code || err?.message || String(error)).slice(0, 256),
+                    });
+                    logger.debug(`[fetchWithRetry] Transient error (${err?.code || err?.message}), retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+                    await new Promise((r) => setTimeout(r, delay));
+                }
             }
-            const delay = baseDelay * Math.pow(2, attempt);
-            logger.debug(`[fetchWithRetry] Transient error (${err?.code || err?.message}), retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
-            await new Promise((r) => setTimeout(r, delay));
+            throw new Error("fetchWithRetry exhausted"); // unreachable
         }
-    }
-    throw new Error("fetchWithRetry exhausted"); // unreachable
+        finally {
+            span.end();
+        }
+    });
 }
 /**
  * Parse request body to readable format for debug logging
@@ -69,22 +122,6 @@ const SENSITIVE_HEADERS = new Set([
     "cookie",
     "set-cookie",
 ]);
-/**
- * Extract all headers as plain object with sensitive values redacted
- */
-function getAllHeaders(headers) {
-    if (!headers) {
-        return {};
-    }
-    const entries = headers instanceof Headers
-        ? [...headers.entries()]
-        : Array.isArray(headers)
-            ? headers
-            : Object.entries(headers);
-    return Object.fromEntries(entries.map(([key, value]) => SENSITIVE_HEADERS.has(key.toLowerCase())
-        ? [key, `${value.substring(0, 4)}***`]
-        : [key, value]));
-}
 /**
  * Clone response and read body + headers for debug logging
  */
@@ -287,13 +324,11 @@ export function createProxyFetch() {
                     ? input.href
                     : input.url;
             if (logger.shouldLog("debug")) {
-                const { parsed: requestBody, size: bodySize, type: bodyType, } = parseBody(init?.body);
+                const { size: bodySize, type: bodyType } = parseBody(init?.body);
                 logger.debug("[Observability] HTTP request to LLM provider", {
                     requestId: reqId,
                     url,
                     method: init?.method || "POST",
-                    headers: getAllHeaders(init?.headers),
-                    body: requestBody,
                     bodySize,
                     bodyType,
                 });
@@ -308,10 +343,10 @@ export function createProxyFetch() {
                         status: response.status,
                         statusText: response.statusText,
                         durationMs: Date.now() - startTs,
-                        headers: responseHeaders,
-                        body: responseBody,
-                        bodySize: responseSize,
+                        contentLength: responseSize,
+                        hasContent: !!responseBody,
                         bodyType: responseType,
+                        responseHeaders,
                     });
                 }
                 return response;
@@ -345,13 +380,11 @@ export function createProxyFetch() {
                 : input.url;
         // Request logging with sensitive header redaction — gated behind debug check
         if (logger.shouldLog("debug")) {
-            const { parsed: requestBody, size: bodySize, type: bodyType, } = parseBody(init?.body);
+            const { size: bodySize, type: bodyType } = parseBody(init?.body);
             logger.debug("[Observability] HTTP request to LLM provider", {
                 requestId,
                 url: targetUrl,
                 method: init?.method || "POST",
-                headers: getAllHeaders(init?.headers),
-                body: requestBody,
                 bodySize,
                 bodyType,
             });
@@ -392,7 +425,7 @@ export function createProxyFetch() {
                 // Create/reuse proxy agent (HTTP/HTTPS/SOCKS)
                 const agentCache = globalThis.__NL_PROXY_AGENT_CACHE__ ??
                     (globalThis.__NL_PROXY_AGENT_CACHE__ = new Map());
-                const cacheKey = maskProxyUrl(proxyUrl) ?? proxyUrl; // credentials stripped for key
+                const cacheKey = maskProxyUrl(proxyUrl) ?? proxyUrl; // mask credentials in cache key
                 const dispatcher = agentCache.get(cacheKey) || (await createProxyAgent(proxyUrl));
                 agentCache.set(cacheKey, dispatcher);
                 logger.debug(`[Proxy Fetch] ✅ ENHANCED PROXY AGENT CREATED`, {
@@ -431,11 +464,11 @@ export function createProxyFetch() {
                         status: response?.status,
                         statusText: response?.statusText,
                         durationMs: Date.now() - requestStartTime,
-                        headers: responseHeaders,
-                        body: responseBody,
-                        bodySize: responseSize,
+                        contentLength: responseSize,
+                        hasContent: !!responseBody,
                         bodyType: responseType,
                         proxied: true,
+                        responseHeaders,
                     });
                 }
                 logger.debug(`[Proxy Fetch] ENHANCED PROXY SUCCESS`, {
@@ -481,11 +514,11 @@ export function createProxyFetch() {
                     status: response.status,
                     statusText: response.statusText,
                     durationMs: Date.now() - requestStartTime,
-                    headers: responseHeaders,
-                    body: responseBody,
-                    bodySize: responseSize,
+                    contentLength: responseSize,
+                    hasContent: !!responseBody,
                     bodyType: responseType,
                     proxied: false,
+                    responseHeaders,
                 });
             }
             return response;

package/dist/lib/rag/ChunkerFactory.js

@@ -50,7 +50,7 @@ const DEFAULT_CHUNKER_METADATA = {
     },
     markdown: {
         description: "Splits markdown content by headers and structural elements",
-        defaultConfig: { maxSize: 1000, overlap: 0 },
+        defaultConfig: { maxSize: 1000, overlap: 50 },
         supportedOptions: ["maxSize", "headerLevels", "splitCodeBlocks"],
         useCases: ["Documentation processing", "README files"],
         aliases: ["md", "markdown-header"],

package/dist/lib/rag/chunkers/MarkdownChunker.d.ts

@@ -2,6 +2,8 @@
  * Markdown Chunker
  *
  * Splits markdown content by headers and structural elements.
+ * Preserves markdown tables by detecting table boundaries and splitting
+ * on row boundaries when a table exceeds the max chunk size.
  */
 import type { Chunk, ChunkerConfig, ChunkingStrategy } from "../types.js";
 import { BaseChunker } from "./BaseChunker.js";
@@ -12,4 +14,24 @@ export declare class MarkdownChunker extends BaseChunker {
     readonly strategy: ChunkingStrategy;
     getDefaultConfig(): ChunkerConfig;
     protected doChunk(content: string, config: ChunkerConfig): Promise<Chunk[]>;
+    /**
+     * Split content while preserving markdown tables.
+     *
+     * Strategy:
+     * 1. Identify table blocks in the content.
+     * 2. Split content into segments: non-table text and table blocks.
+     * 3. Non-table text is split using paragraph/sentence boundaries (existing logic).
+     * 4. Tables that fit in a chunk are kept intact.
+     * 5. Oversized tables are split on row boundaries, repeating the header row.
+     */
+    private splitContentTableAware;
+    /**
+     * Split a table on row boundaries, repeating header + separator in each chunk.
+     */
+    private splitTableByRows;
+    /**
+     * Split non-table text using paragraph and sentence boundaries.
+     * This is the original splitContent logic extracted for reuse.
+     */
+    private splitPlainContent;
 }

package/dist/lib/rag/chunkers/MarkdownChunker.js

@@ -2,8 +2,42 @@
  * Markdown Chunker
  *
  * Splits markdown content by headers and structural elements.
+ * Preserves markdown tables by detecting table boundaries and splitting
+ * on row boundaries when a table exceeds the max chunk size.
  */
 import { BaseChunker, DEFAULT_CHUNKER_CONFIG } from "./BaseChunker.js";
+/** Matches a markdown table separator row like |---|---| or |:--:|---:| */
+const TABLE_SEPARATOR_RE = /^\|[\s:]*-+[\s:]*(\|[\s:]*-+[\s:]*)*\|?\s*$/;
+/** Matches a line that looks like a table row (starts with |) */
+const TABLE_ROW_RE = /^\|.+\|?\s*$/;
+/**
+ * Detect contiguous table blocks in text.
+ * Returns an array of { start, end } line index ranges (inclusive).
+ * A table is a sequence of lines where the second line is a separator.
+ */
+function detectTableRanges(lines) {
+    const ranges = [];
+    let i = 0;
+    while (i < lines.length) {
+        // A table needs at least a header row + separator
+        if (i + 1 < lines.length &&
+            TABLE_ROW_RE.test(lines[i]) &&
+            TABLE_SEPARATOR_RE.test(lines[i + 1])) {
+            const start = i;
+            // Advance past header + separator
+            i += 2;
+            // Consume remaining data rows
+            while (i < lines.length && TABLE_ROW_RE.test(lines[i])) {
+                i++;
+            }
+            ranges.push({ start, end: i - 1 });
+        }
+        else {
+            i++;
+        }
+    }
+    return ranges;
+}
 /**
  * Markdown Chunker
  */
@@ -13,7 +47,7 @@ export class MarkdownChunker extends BaseChunker {
         return {
             ...DEFAULT_CHUNKER_CONFIG,
             maxSize: 1000,
-            overlap: 0,
+            overlap: 50,
         };
     }
     async doChunk(content, config) {
@@ -74,16 +108,14 @@ export class MarkdownChunker extends BaseChunker {
             if (!fullContent) {
                 continue;
             }
-            // Split if too large
+            // Split if too large — use table-aware splitting
             if (fullContent.length > maxSize) {
-                const subChunks = this.splitBySizeWithOverlap(fullContent, maxSize, 0);
+                const subChunks = this.splitContentTableAware(fullContent, maxSize);
                 for (const sub of subChunks) {
-                    const startOffset = content.indexOf(sub.text, offset);
-                    chunks.push(this.createChunk(sub.text, chunks.length, startOffset >= 0 ? startOffset : offset, startOffset >= 0
-                        ? startOffset + sub.text.length
-                        : offset + sub.text.length, "unknown", { sectionContext: section.header }));
+                    const startOffset = content.indexOf(sub, offset);
+                    chunks.push(this.createChunk(sub, chunks.length, startOffset >= 0 ? startOffset : offset, startOffset >= 0 ? startOffset + sub.length : offset + sub.length, "unknown", { sectionContext: section.header }));
                     if (startOffset >= 0) {
-                        offset = startOffset + 1;
+                        offset = startOffset + sub.length;
                     }
                 }
             }
@@ -93,9 +125,181 @@ export class MarkdownChunker extends BaseChunker {
                     ? startOffset + fullContent.length
                     : offset + fullContent.length, "unknown", { sectionContext: section.header }));
                 if (startOffset >= 0) {
-                    offset = startOffset + 1;
+                    offset = startOffset + fullContent.length;
+                }
+            }
+        }
+        return chunks;
+    }
+    /**
+     * Split content while preserving markdown tables.
+     *
+     * Strategy:
+     * 1. Identify table blocks in the content.
+     * 2. Split content into segments: non-table text and table blocks.
+     * 3. Non-table text is split using paragraph/sentence boundaries (existing logic).
+     * 4. Tables that fit in a chunk are kept intact.
+     * 5. Oversized tables are split on row boundaries, repeating the header row.
+     */
+    splitContentTableAware(content, maxSize) {
+        const lines = content.split("\n");
+        const tableRanges = detectTableRanges(lines);
+        // If no tables, fall back to existing splitting logic
+        if (tableRanges.length === 0) {
+            return this.splitPlainContent(content, maxSize, this.config.overlap ?? 0);
+        }
+        // Build segments: alternating non-table and table blocks
+        const segments = [];
+        let lineIdx = 0;
+        for (const range of tableRanges) {
+            // Non-table text before this table
+            if (lineIdx < range.start) {
+                const text = lines.slice(lineIdx, range.start).join("\n").trim();
+                if (text) {
+                    segments.push({ text, isTable: false });
+                }
+            }
+            // The table itself
+            const tableText = lines.slice(range.start, range.end + 1).join("\n");
+            segments.push({ text: tableText, isTable: true });
+            lineIdx = range.end + 1;
+        }
+        // Trailing non-table text
+        if (lineIdx < lines.length) {
+            const text = lines.slice(lineIdx).join("\n").trim();
+            if (text) {
+                segments.push({ text, isTable: false });
+            }
+        }
+        // Now produce chunks, trying to pack segments together up to maxSize
+        const result = [];
+        let current = "";
+        for (const seg of segments) {
+            if (!seg.isTable) {
+                // Non-table text: try to append, split if needed
+                const pieces = this.splitPlainContent(seg.text, maxSize, this.config.overlap ?? 0);
+                for (const piece of pieces) {
+                    if (current.length === 0) {
+                        current = piece;
+                    }
+                    else if (current.length + 1 + piece.length <= maxSize) {
+                        current += "\n" + piece;
+                    }
+                    else {
+                        result.push(current);
+                        current = piece;
+                    }
+                }
+            }
+            else {
+                // Table block
+                if (seg.text.length <= maxSize) {
+                    // Table fits — try to append to current chunk
+                    if (current.length === 0) {
+                        current = seg.text;
+                    }
+                    else if (current.length + 2 + seg.text.length <= maxSize) {
+                        current += "\n\n" + seg.text;
+                    }
+                    else {
+                        result.push(current);
+                        current = seg.text;
+                    }
+                }
+                else {
+                    // Oversized table — flush current, then split table on row boundaries
+                    if (current) {
+                        result.push(current);
+                        current = "";
+                    }
+                    const tableChunks = this.splitTableByRows(seg.text, maxSize);
+                    result.push(...tableChunks);
+                }
+            }
+        }
+        if (current) {
+            result.push(current);
+        }
+        return result.length > 0 ? result : [content];
+    }
+    /**
+     * Split a table on row boundaries, repeating header + separator in each chunk.
+     */
+    splitTableByRows(tableText, maxSize) {
+        const rows = tableText.split("\n");
+        if (rows.length < 3) {
+            // Not a proper table (need header + separator + at least 1 data row)
+            return [tableText];
+        }
+        const headerRow = rows[0];
+        const separatorRow = rows[1];
+        const headerBlock = headerRow + "\n" + separatorRow;
+        const dataRows = rows.slice(2);
+        // If even the header doesn't fit, fall back to size-based split
+        if (headerBlock.length > maxSize) {
+            return this.splitPlainContent(tableText, maxSize, this.config.overlap ?? 0);
+        }
+        const chunks = [];
+        let currentChunk = headerBlock;
+        for (const row of dataRows) {
+            // Guard: single row exceeds budget — flush and emit as standalone chunk
+            const singleRowChunk = `${headerBlock}\n${row}`;
+            if (singleRowChunk.length > maxSize) {
+                if (currentChunk.length > headerBlock.length) {
+                    chunks.push(currentChunk);
+                }
+                chunks.push(singleRowChunk);
+                currentChunk = headerBlock;
+                continue;
+            }
+            const candidate = currentChunk + "\n" + row;
+            if (candidate.length <= maxSize) {
+                currentChunk = candidate;
+            }
+            else {
+                // Flush current chunk (skip if it only contains the header)
+                if (currentChunk.length > headerBlock.length) {
+                    chunks.push(currentChunk);
+                }
+                // Start new chunk with header repeated
+                currentChunk = headerBlock + "\n" + row;
+            }
+        }
+        if (currentChunk.length > headerBlock.length) {
+            chunks.push(currentChunk);
+        }
+        return chunks.length > 0 ? chunks : [tableText];
+    }
+    /**
+     * Split non-table text using paragraph and sentence boundaries.
+     * This is the original splitContent logic extracted for reuse.
+     */
+    splitPlainContent(content, maxSize, overlap = 0) {
+        if (content.length <= maxSize) {
+            return [content];
+        }
+        const chunks = [];
+        let start = 0;
+        while (start < content.length) {
+            let end = Math.min(start + maxSize, content.length);
+            if (end < content.length) {
+                const searchStart = Math.max(start, end - 200);
+                const searchText = content.slice(searchStart, end);
+                // Look for paragraph break first
+                const paragraphBreak = searchText.lastIndexOf("\n\n");
+                if (paragraphBreak > 0) {
+                    end = searchStart + paragraphBreak;
+                }
+                else {
+                    // Look for sentence break
+                    const sentenceBreak = searchText.search(/[.!?]\s+[A-Z]/);
+                    if (sentenceBreak > 0) {
+                        end = searchStart + sentenceBreak + 1;
+                    }
                 }
             }
+            chunks.push(content.slice(start, end));
+            start = Math.max(start + 1, end - overlap);
         }
         return chunks;
     }