@juspay/neurolink 9.41.0 → 9.42.1

package/dist/proxy/sseInterceptor.d.ts

@@ -0,0 +1,97 @@
+/**
+ * SSE Stream Interceptor
+ *
+ * A zero-overhead TransformStream that taps Anthropic SSE streaming responses
+ * to extract telemetry data (token usage, model info, content blocks, thinking
+ * blocks, tool use) while passing every byte through to the client unmodified
+ * and without delay.
+ *
+ * The interceptor buffers partial SSE events internally (chunks may split
+ * across event boundaries) but never holds back any bytes from the readable
+ * side of the stream.
+ *
+ * Usage:
+ *   const { stream, telemetry } = createSSEInterceptor();
+ *   upstreamResponse.body.pipeThrough(stream).pipeTo(clientWritable);
+ *   const data = await telemetry; // resolves on stream end
+ */
+export type SSEContentBlock = {
+    index: number;
+    type: "text" | "thinking" | "tool_use" | "tool_result";
+    /** Accumulated text for text blocks. Capped at MAX_BLOCK_CONTENT_BYTES. */
+    text?: string;
+    /** Accumulated thinking content. Capped at MAX_BLOCK_CONTENT_BYTES. */
+    thinking?: string;
+    /** Tool name for tool_use blocks. */
+    toolName?: string;
+    /** Tool call id for tool_use blocks. */
+    toolId?: string;
+    /** Accumulated partial JSON input for tool_use blocks. Capped at MAX_BLOCK_CONTENT_BYTES. */
+    toolInput?: string;
+};
+export type SSETelemetry = {
+    /** Message id from message_start. */
+    messageId: string;
+    /** Model string from message_start. */
+    model: string;
+    /** Token usage aggregated from message_start + message_delta. */
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationInputTokens: number;
+        cacheReadInputTokens: number;
+        totalTokens: number;
+    };
+    /** All content blocks accumulated during the stream. */
+    contentBlocks: SSEContentBlock[];
+    /** Stop reason from message_delta, e.g. "end_turn". */
+    stopReason: string | null;
+    /** Stop sequence from message_delta, if any. */
+    stopSequence: string | null;
+    /** Total number of SSE events observed. */
+    eventCount: number;
+    /** Wall-clock duration from first byte to stream end (ms). */
+    streamDurationMs: number;
+    /** Total bytes received from upstream (raw SSE stream size). */
+    totalBytesReceived: number;
+    /**
+     * Raw SSE event log. For content_block_delta events only the type is
+     * stored (not the full data payload) to avoid excessive memory use.
+     * All other events store the full data string.
+     */
+    events: Array<{
+        type: string;
+        timestamp: number;
+        data: string;
+    }>;
+    /** Full raw SSE transcript, when captureRawText is enabled. */
+    rawText?: string;
+};
+export type SSEInterceptorResult = {
+    /** Pipe the upstream response through this stream. */
+    stream: TransformStream<Uint8Array, Uint8Array>;
+    /**
+     * Resolves with the accumulated telemetry when the stream finishes.
+     * If the stream errors, the promise resolves with whatever telemetry
+     * was gathered up to that point (never rejects).
+     */
+    telemetry: Promise<SSETelemetry>;
+};
+export type SSEInterceptorOptions = {
+    captureRawText?: boolean;
+};
+/**
+ * Create an SSE interceptor that extracts telemetry from an Anthropic
+ * streaming response while passing all bytes through unmodified.
+ *
+ * ```ts
+ * const { stream, telemetry } = createSSEInterceptor();
+ * upstreamResponse.body
+ *   .pipeThrough(stream)
+ *   .pipeTo(clientWritable);
+ *
+ * const data = await telemetry;
+ * console.log(data.usage.totalTokens);
+ * ```
+ */
+export declare function createSSEInterceptor(options?: SSEInterceptorOptions): SSEInterceptorResult;

package/dist/proxy/sseInterceptor.js

@@ -0,0 +1,426 @@
+/**
+ * SSE Stream Interceptor
+ *
+ * A zero-overhead TransformStream that taps Anthropic SSE streaming responses
+ * to extract telemetry data (token usage, model info, content blocks, thinking
+ * blocks, tool use) while passing every byte through to the client unmodified
+ * and without delay.
+ *
+ * The interceptor buffers partial SSE events internally (chunks may split
+ * across event boundaries) but never holds back any bytes from the readable
+ * side of the stream.
+ *
+ * Usage:
+ *   const { stream, telemetry } = createSSEInterceptor();
+ *   upstreamResponse.body.pipeThrough(stream).pipeTo(clientWritable);
+ *   const data = await telemetry; // resolves on stream end
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Maximum accumulated content per block before we stop appending (100 KB). */
+const MAX_BLOCK_CONTENT_BYTES = 100 * 1024;
+/** Maximum number of events to record in the event log to cap memory usage. */
+const MAX_EVENT_LOG_ENTRIES = 5000;
+const MAX_EVENT_DATA_BYTES = 2048;
+const MAX_RAW_TEXT_BYTES = 1024 * 1024;
+const TRUNCATION_MARKER = "...[TRUNCATED]";
+// ---------------------------------------------------------------------------
+// Internal SSE line parser
+// ---------------------------------------------------------------------------
+/**
+ * Incrementally parse SSE events from a growing buffer of text.
+ *
+ * SSE events are separated by a blank line (`\n\n`). Each event consists of
+ * field lines (`event: ...`, `data: ...`). We consume complete events and
+ * return them, leaving any trailing partial event in the buffer.
+ */
+function extractSSEEvents(buffer) {
+    const events = [];
+    // Split on double-newline boundaries. The last segment may be an
+    // incomplete event if the chunk was split mid-event.
+    let cursor = 0;
+    while (cursor < buffer.length) {
+        const boundary = buffer.indexOf("\n\n", cursor);
+        if (boundary === -1) {
+            // No more complete events — everything from cursor onward is partial.
+            break;
+        }
+        const rawBlock = buffer.slice(cursor, boundary);
+        cursor = boundary + 2; // skip past the \n\n
+        let eventType = "";
+        let dataValue = "";
+        const lines = rawBlock.split("\n");
+        for (const line of lines) {
+            if (line.startsWith("event: ")) {
+                eventType = line.slice(7).trim();
+            }
+            else if (line.startsWith("data: ")) {
+                dataValue = line.slice(6);
+            }
+            else if (line.startsWith("data:")) {
+                // handle `data:` with no space (edge case)
+                dataValue = line.slice(5);
+            }
+        }
+        if (eventType || dataValue) {
+            events.push({ event: eventType, data: dataValue });
+        }
+    }
+    return { events, remainder: buffer.slice(cursor) };
+}
+function createAccumulator(captureRawText) {
+    return {
+        messageId: "",
+        model: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: 0,
+        contentBlocks: [],
+        blockByteCounts: new Map(),
+        stopReason: null,
+        stopSequence: null,
+        eventCount: 0,
+        startTime: Date.now(),
+        totalBytesReceived: 0,
+        events: [],
+        rawTextChunks: captureRawText ? [] : undefined,
+        rawTextBytes: 0,
+        rawTextTruncated: false,
+        eventLogTruncated: false,
+    };
+}
+function utf8ByteLength(input) {
+    return Buffer.byteLength(input, "utf8");
+}
+function truncateUtf8String(input, maxBytes) {
+    if (utf8ByteLength(input) <= maxBytes) {
+        return input;
+    }
+    const markerBytes = utf8ByteLength(TRUNCATION_MARKER);
+    if (maxBytes <= 0 || maxBytes < markerBytes) {
+        return "";
+    }
+    let output = "";
+    let usedBytes = 0;
+    for (const char of input) {
+        const charBytes = utf8ByteLength(char);
+        if (usedBytes + charBytes + markerBytes > maxBytes) {
+            break;
+        }
+        output += char;
+        usedBytes += charBytes;
+    }
+    return `${output}${TRUNCATION_MARKER}`;
+}
+function truncateString(input, maxBytes) {
+    return truncateUtf8String(input, maxBytes);
+}
+function appendCappedFragment(current, fragment, currentBytes, maxBytes) {
+    const fragmentBytes = utf8ByteLength(fragment);
+    if (currentBytes >= maxBytes) {
+        return {
+            value: current && current.endsWith(TRUNCATION_MARKER)
+                ? current
+                : `${current ?? ""}${TRUNCATION_MARKER}`,
+            nextBytes: currentBytes + fragmentBytes,
+        };
+    }
+    const remainingBytes = maxBytes - currentBytes;
+    const nextBytes = currentBytes + fragmentBytes;
+    if (fragmentBytes <= remainingBytes) {
+        return {
+            value: `${current ?? ""}${fragment}`,
+            nextBytes,
+        };
+    }
+    return {
+        value: `${current ?? ""}${truncateUtf8String(fragment, remainingBytes)}`,
+        nextBytes,
+    };
+}
+function appendRawTextChunk(acc, chunk) {
+    if (!acc.rawTextChunks || acc.rawTextTruncated) {
+        return;
+    }
+    const remainingBytes = MAX_RAW_TEXT_BYTES - acc.rawTextBytes;
+    if (remainingBytes <= 0) {
+        acc.rawTextChunks.push(TRUNCATION_MARKER);
+        acc.rawTextTruncated = true;
+        return;
+    }
+    const chunkBytes = utf8ByteLength(chunk);
+    if (chunkBytes <= remainingBytes) {
+        acc.rawTextChunks.push(chunk);
+        acc.rawTextBytes += chunkBytes;
+        return;
+    }
+    acc.rawTextChunks.push(truncateUtf8String(chunk, remainingBytes));
+    acc.rawTextBytes = MAX_RAW_TEXT_BYTES;
+    acc.rawTextTruncated = true;
+}
+function getBlockContentBytes(block) {
+    return utf8ByteLength(block.text ?? block.thinking ?? block.toolInput ?? "");
+}
+function finalize(acc) {
+    const totalTokens = acc.inputTokens + acc.outputTokens;
+    return {
+        messageId: acc.messageId,
+        model: acc.model,
+        usage: {
+            inputTokens: acc.inputTokens,
+            outputTokens: acc.outputTokens,
+            cacheCreationInputTokens: acc.cacheCreationInputTokens,
+            cacheReadInputTokens: acc.cacheReadInputTokens,
+            totalTokens,
+        },
+        contentBlocks: acc.contentBlocks,
+        stopReason: acc.stopReason,
+        stopSequence: acc.stopSequence,
+        eventCount: acc.eventCount,
+        streamDurationMs: Date.now() - acc.startTime,
+        totalBytesReceived: acc.totalBytesReceived,
+        events: acc.events,
+        ...(acc.rawTextChunks ? { rawText: acc.rawTextChunks.join("") } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Event processors
+// ---------------------------------------------------------------------------
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function processMessageStart(acc, parsed) {
+    const msg = parsed.message;
+    if (!msg) {
+        return;
+    }
+    acc.messageId = msg.id ?? "";
+    acc.model = msg.model ?? "";
+    const usage = msg.usage;
+    if (usage) {
+        acc.inputTokens += usage.input_tokens ?? 0;
+        acc.outputTokens += usage.output_tokens ?? 0;
+        acc.cacheCreationInputTokens += usage.cache_creation_input_tokens ?? 0;
+        acc.cacheReadInputTokens += usage.cache_read_input_tokens ?? 0;
+    }
+}
+function processContentBlockStart(acc, parsed) {
+    const index = parsed.index ?? 0;
+    const block = parsed.content_block;
+    if (!block) {
+        return;
+    }
+    const blockType = block.type;
+    const entry = { index, type: blockType };
+    if (blockType === "text") {
+        entry.text = block.text ?? "";
+    }
+    else if (blockType === "thinking") {
+        entry.thinking = block.thinking ?? "";
+    }
+    else if (blockType === "tool_use") {
+        entry.toolName = block.name ?? "";
+        entry.toolId = block.id ?? "";
+        entry.toolInput = "";
+    }
+    acc.contentBlocks.push(entry);
+    acc.blockByteCounts.set(index, getBlockContentBytes(entry));
+}
+function processContentBlockDelta(acc, parsed) {
+    const index = parsed.index ?? 0;
+    const delta = parsed.delta;
+    if (!delta) {
+        return;
+    }
+    // Find the matching block
+    const block = acc.contentBlocks.find((b) => b.index === index);
+    if (!block) {
+        return;
+    }
+    const currentBytes = acc.blockByteCounts.get(index) ?? 0;
+    const capped = currentBytes >= MAX_BLOCK_CONTENT_BYTES;
+    if (delta.type === "text_delta" && delta.text !== null) {
+        const fragment = delta.text;
+        const updated = appendCappedFragment(block.text, fragment, currentBytes, MAX_BLOCK_CONTENT_BYTES);
+        acc.blockByteCounts.set(index, updated.nextBytes);
+        if (!capped || !block.text?.endsWith(TRUNCATION_MARKER)) {
+            block.text = updated.value;
+        }
+    }
+    else if (delta.type === "thinking_delta" && delta.thinking !== null) {
+        const fragment = delta.thinking;
+        const updated = appendCappedFragment(block.thinking, fragment, currentBytes, MAX_BLOCK_CONTENT_BYTES);
+        acc.blockByteCounts.set(index, updated.nextBytes);
+        if (!capped || !block.thinking?.endsWith(TRUNCATION_MARKER)) {
+            block.thinking = updated.value;
+        }
+    }
+    else if (delta.type === "input_json_delta" && delta.partial_json !== null) {
+        const fragment = delta.partial_json;
+        const updated = appendCappedFragment(block.toolInput, fragment, currentBytes, MAX_BLOCK_CONTENT_BYTES);
+        acc.blockByteCounts.set(index, updated.nextBytes);
+        if (!capped || !block.toolInput?.endsWith(TRUNCATION_MARKER)) {
+            block.toolInput = updated.value;
+        }
+    }
+}
+function processMessageDelta(acc, parsed) {
+    const delta = parsed.delta;
+    if (delta) {
+        acc.stopReason = delta.stop_reason ?? acc.stopReason;
+        acc.stopSequence = delta.stop_sequence ?? acc.stopSequence;
+    }
+    const usage = parsed.usage;
+    if (usage) {
+        // message_delta provides the final output_tokens count; treat it as
+        // additive because message_start reports output_tokens: 0 for the
+        // initial placeholder.
+        acc.outputTokens += usage.output_tokens ?? 0;
+    }
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+// ---------------------------------------------------------------------------
+// Dispatch a parsed SSE event to the appropriate handler
+// ---------------------------------------------------------------------------
+function processEvent(acc, event) {
+    acc.eventCount++;
+    const now = Date.now();
+    // For content_block_delta events, store only the event type to save memory.
+    // For all other events, store the full data string.
+    // Cap event log to prevent unbounded growth.
+    if (acc.events.length < MAX_EVENT_LOG_ENTRIES - 1) {
+        if (event.event === "content_block_delta") {
+            acc.events.push({ type: event.event, timestamp: now, data: "" });
+        }
+        else {
+            acc.events.push({
+                type: event.event,
+                timestamp: now,
+                data: truncateString(event.data, MAX_EVENT_DATA_BYTES),
+            });
+        }
+    }
+    else if (!acc.eventLogTruncated) {
+        acc.events.push({
+            type: "truncated",
+            timestamp: now,
+            data: TRUNCATION_MARKER,
+        });
+        acc.eventLogTruncated = true;
+    }
+    // Skip JSON parsing for events with no data payload
+    if (!event.data) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(event.data);
+    }
+    catch {
+        // Malformed JSON — skip silently, bytes already forwarded to client
+        return;
+    }
+    switch (event.event) {
+        case "message_start":
+            processMessageStart(acc, parsed);
+            break;
+        case "content_block_start":
+            processContentBlockStart(acc, parsed);
+            break;
+        case "content_block_delta":
+            processContentBlockDelta(acc, parsed);
+            break;
+        case "message_delta":
+            processMessageDelta(acc, parsed);
+            break;
+        // content_block_stop, message_stop, ping — no telemetry to extract
+        default:
+            break;
+    }
+}
+/**
+ * Create an SSE interceptor that extracts telemetry from an Anthropic
+ * streaming response while passing all bytes through unmodified.
+ *
+ * ```ts
+ * const { stream, telemetry } = createSSEInterceptor();
+ * upstreamResponse.body
+ *   .pipeThrough(stream)
+ *   .pipeTo(clientWritable);
+ *
+ * const data = await telemetry;
+ * console.log(data.usage.totalTokens);
+ * ```
+ */
+export function createSSEInterceptor(options = {}) {
+    const captureRawText = options.captureRawText ?? false;
+    const acc = createAccumulator(captureRawText);
+    let sseBuffer = "";
+    let resolved = false;
+    const decoder = new TextDecoder();
+    let resolveTelemetry;
+    const telemetryPromise = new Promise((resolve) => {
+        resolveTelemetry = resolve;
+    });
+    /** Resolve the telemetry promise exactly once. */
+    function settle() {
+        if (resolved) {
+            return;
+        }
+        resolved = true;
+        resolveTelemetry(finalize(acc));
+    }
+    const transform = new TransformStream({
+        transform(chunk, controller) {
+            // Forward the raw bytes immediately — zero delay to client.
+            controller.enqueue(chunk);
+            // Track total bytes received for bandwidth metrics.
+            acc.totalBytesReceived += chunk.byteLength;
+            // Decode and buffer for SSE parsing.
+            const decodedChunk = decoder.decode(chunk, { stream: true });
+            appendRawTextChunk(acc, decodedChunk);
+            sseBuffer += decodedChunk;
+            const { events, remainder } = extractSSEEvents(sseBuffer);
+            sseBuffer = remainder;
+            for (const event of events) {
+                processEvent(acc, event);
+            }
+        },
+        flush() {
+            const finalChunk = decoder.decode();
+            if (finalChunk) {
+                appendRawTextChunk(acc, finalChunk);
+                sseBuffer += finalChunk;
+            }
+            // Process any trailing data left in the buffer (e.g. a final event
+            // not followed by a double-newline).
+            if (sseBuffer.trim()) {
+                const { events } = extractSSEEvents(sseBuffer + "\n\n");
+                for (const event of events) {
+                    processEvent(acc, event);
+                }
+            }
+            settle();
+        },
+    });
+    // Wrap the writable side so we can intercept abort() — which does NOT
+    // trigger the TransformStream's flush() or cancel() callbacks.
+    const innerWriter = transform.writable.getWriter();
+    const writable = new WritableStream({
+        write(chunk) {
+            return innerWriter.write(chunk);
+        },
+        close() {
+            return innerWriter.close();
+        },
+        abort(reason) {
+            settle();
+            return innerWriter.abort(reason);
+        },
+    });
+    const stream = {
+        readable: transform.readable,
+        writable,
+    };
+    return { stream, telemetry: telemetryPromise };
+}

package/dist/proxy/usageStats.d.ts

@@ -4,9 +4,10 @@
  * In-memory only — resets on proxy restart.
  */
 import type { AccountStats, ProxyStats } from "../types/index.js";
-export declare function recordRequest(accountLabel: string, accountType: string): void;
-export declare function recordSuccess(accountLabel: string, accountType: string): void;
-export declare function recordError(accountLabel: string, accountType: string, status: number): void;
+export declare function recordAttempt(accountLabel: string, accountType: string): void;
+export declare function recordFinalSuccess(accountLabel?: string, accountType?: string): void;
+export declare function recordAttemptError(accountLabel: string, accountType: string, status: number): void;
+export declare function recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
 export declare function recordCooldown(accountLabel: string, accountType: string, cooldownUntil: number, backoffLevel: number): void;
 export declare function getStats(): ProxyStats;
 export declare function getAccountStats(label: string): AccountStats | undefined;

package/dist/proxy/usageStats.js

@@ -5,26 +5,29 @@
  */
 const stats = {
     startedAt: Date.now(),
+    totalAttempts: 0,
     totalRequests: 0,
     totalSuccess: 0,
     totalErrors: 0,
     totalRateLimits: 0,
     accounts: {},
 };
-export function recordRequest(accountLabel, accountType) {
-    ensureAccount(accountLabel, accountType).requestCount++;
-    ensureAccount(accountLabel, accountType).lastRequestAt = Date.now();
+export function recordAttempt(accountLabel, accountType) {
+    stats.totalAttempts++;
+    const acct = ensureAccount(accountLabel, accountType);
+    acct.attemptCount++;
+    acct.lastAttemptAt = Date.now();
 }
-export function recordSuccess(accountLabel, accountType) {
+export function recordFinalSuccess(accountLabel, accountType) {
     stats.totalRequests++;
     stats.totalSuccess++;
-    const acct = ensureAccount(accountLabel, accountType);
-    acct.successCount++;
-    acct.currentBackoffLevel = 0;
+    if (accountLabel && accountType) {
+        const acct = ensureAccount(accountLabel, accountType);
+        acct.successCount++;
+        acct.currentBackoffLevel = 0;
+    }
 }
-export function recordError(accountLabel, accountType, status) {
-    stats.totalRequests++;
-    stats.totalErrors++;
+export function recordAttemptError(accountLabel, accountType, status) {
     const acct = ensureAccount(accountLabel, accountType);
     acct.errorCount++;
     acct.lastErrorAt = Date.now();
@@ -33,6 +36,15 @@ export function recordError(accountLabel, accountType, status) {
         acct.rateLimitCount++;
     }
 }
+export function recordFinalError(_status, accountLabel, accountType) {
+    stats.totalRequests++;
+    stats.totalErrors++;
+    if (accountLabel && accountType) {
+        const acct = ensureAccount(accountLabel, accountType);
+        acct.errorCount++;
+        acct.lastErrorAt = Date.now();
+    }
+}
 export function recordCooldown(accountLabel, accountType, cooldownUntil, backoffLevel) {
     const acct = ensureAccount(accountLabel, accountType);
     acct.coolingUntil = cooldownUntil;
@@ -51,6 +63,7 @@ export function getAccountStats(label) {
 }
 export function resetStats() {
     stats.startedAt = Date.now();
+    stats.totalAttempts = 0;
     stats.totalRequests = 0;
     stats.totalSuccess = 0;
     stats.totalErrors = 0;
@@ -62,11 +75,11 @@ function ensureAccount(label, type) {
         stats.accounts[label] = {
             label,
             type,
-            requestCount: 0,
+            attemptCount: 0,
             successCount: 0,
             errorCount: 0,
             rateLimitCount: 0,
-            lastRequestAt: 0,
+            lastAttemptAt: 0,
             currentBackoffLevel: 0,
         };
     }

package/dist/rag/chunkers/MarkdownChunker.js

@@ -19,15 +19,23 @@ function detectTableRanges(lines) {
     const ranges = [];
     let i = 0;
     while (i < lines.length) {
+        const currentLine = lines[i];
+        const separatorLine = lines[i + 1];
         // 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])) {
+            currentLine !== undefined &&
+            separatorLine !== undefined &&
+            TABLE_ROW_RE.test(currentLine) &&
+            TABLE_SEPARATOR_RE.test(separatorLine)) {
             const start = i;
             // Advance past header + separator
             i += 2;
             // Consume remaining data rows
-            while (i < lines.length && TABLE_ROW_RE.test(lines[i])) {
+            while (i < lines.length) {
+                const row = lines[i];
+                if (row === undefined || !TABLE_ROW_RE.test(row)) {
+                    break;
+                }
                 i++;
             }
             ranges.push({ start, end: i - 1 });
@@ -231,8 +239,8 @@ export class MarkdownChunker extends BaseChunker {
             // Not a proper table (need header + separator + at least 1 data row)
             return [tableText];
         }
-        const headerRow = rows[0];
-        const separatorRow = rows[1];
+        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