@juspay/neurolink 12.17.1 → 12.17.3

package/dist/constants/contextWindows.d.ts

@@ -52,6 +52,8 @@ export declare function registerRuntimeOutputCeiling(provider: string, model: st
  * undefined when the serving infrastructure has not advertised one.
  */
 export declare function getRuntimeOutputCeiling(provider: string, model?: string): number | undefined;
+/** Remove a model ceiling that discovery no longer advertises as valid. */
+export declare function clearRuntimeOutputCeiling(provider: string, model: string): void;
 /** Test hook: clear runtime-discovered output ceilings (state is module-global). */
 export declare function clearRuntimeOutputCeilings(): void;
 /**

package/dist/constants/contextWindows.js

@@ -425,6 +425,10 @@ export function getRuntimeOutputCeiling(provider, model) {
     }
     return RUNTIME_OUTPUT_CEILINGS.get(`${provider}:${model}`);
 }
+/** Remove a model ceiling that discovery no longer advertises as valid. */
+export function clearRuntimeOutputCeiling(provider, model) {
+    RUNTIME_OUTPUT_CEILINGS.delete(`${provider}:${model}`);
+}
 /** Test hook: clear runtime-discovered output ceilings (state is module-global). */
 export function clearRuntimeOutputCeilings() {
     RUNTIME_OUTPUT_CEILINGS.clear();

package/dist/neurolink.js

@@ -5899,7 +5899,10 @@ Current user's request: ${currentInput}`;
             toolsUsed: result.toolsUsed || [],
             toolCalls: result.toolCalls ?? [],
             toolExecutions: transformedToolExecutions,
-            enhancedWithTools: Boolean(hasToolExecutions),
+            // A tool RAN (toolsUsed), not merely dispatched (toolExecutions can
+            // include failed/never-found calls) — see hasToolExecutions above,
+            // which still gates the null-result check and must not change.
+            enhancedWithTools: !!(result.toolsUsed && result.toolsUsed.length > 0),
             availableTools: transformToolsForMCP(transformToolsToExpectedFormat(availableTools)),
             audio: result.audio,
             ttsMetadata: result.ttsMetadata,
@@ -6060,7 +6063,8 @@ Current user's request: ${currentInput}`;
                             executionTime: te.durationMs,
                             success: !te.isError,
                         })),
-                        enhancedWithTools: !!poolResult.toolExecutions?.length,
+                        // A tool RAN (toolsUsed), not merely dispatched.
+                        enhancedWithTools: !!poolResult.toolsUsed?.length,
                         analytics: poolResult.analytics,
                         evaluation: poolResult.evaluation,
                         audio: poolResult.audio,
@@ -6432,7 +6436,8 @@ Current user's request: ${currentInput}`;
                         executionTime: te.durationMs,
                         success: !te.isError,
                     })),
-                    enhancedWithTools: !!result.toolExecutions?.length,
+                    // A tool RAN (toolsUsed), not merely dispatched.
+                    enhancedWithTools: !!result.toolsUsed?.length,
                     analytics: result.analytics,
                     evaluation: result.evaluation,
                     audio: result.audio,

package/dist/providers/openaiChatCompletionsBase.js

@@ -899,57 +899,66 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         // Omit the tools for a pass that only has to reformat an answer the
         // model has already given. Dropping them is what makes `response_format`
         // legal again on a vendor that refuses the two together.
-        withTools = true) => runNativeGenerateLoop({
-            doGenerate,
-            ...createNativeGenerateGuard({
-                provider: this.providerName,
-                availableInputTokens: getAvailableInputTokens(this.providerName, modelId, options.maxTokens ?? undefined),
-                // Runs on every step of the generate loop, so a cyclic or
-                // oversized tool schema must not throw the turn away. Shares the
-                // estimator's own serializer: its fallback over-reports, which
-                // makes the guard fire rather than silently size the overhead at
-                // nothing.
-                getFixedOverheadTokens: () => estimateTokens(serializeForEstimate({
-                    tools: v3Tools,
-                    responseFormat: format,
-                }), this.providerName),
-            }),
-            conversation: conv,
-            ...(withTools && v3Tools ? { tools: v3Tools } : {}),
-            toolsRecord,
-            ...(withTools && hasTools && options.toolChoice
-                ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
-                : {}),
-            // The per-call `timeout` keeps its per-MODEL-CALL meaning once
-            // `turnTimeoutMs` owns the whole-turn deadline, and it reaches the
-            // model layer only through this channel. Without it each step fell
-            // back to the provider default, so a caller asking for a short
-            // per-call timeout got the default on every request.
-            ...(typeof options.timeout === "number"
-                ? {
-                    providerOptions: {
-                        neurolink: { timeoutMs: options.timeout },
-                    },
-                }
-                : {}),
-            ...(format ? { responseFormat: format } : {}),
-            maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-            ...(options.maxTokens ? { maxOutputTokens: options.maxTokens } : {}),
-            ...(options.temperature !== undefined
-                ? { temperature: options.temperature }
-                : {}),
-            ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
-            ...(options.toolTimeoutMs !== undefined
-                ? { toolTimeoutMs: options.toolTimeoutMs }
-                : {}),
-            // withProviderRetry + handleProviderError are what the ai loop
-            // supplied around each call: without them a 429 surfaces as a raw
-            // upstream string instead of a RateLimitError, and a throttle is
-            // never retried.
-            runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`).catch((err) => {
-                throw this.handleProviderError(err);
-            }),
-        }, toolExecutionSummaries);
+        withTools = true) => {
+            return runNativeGenerateLoop({
+                doGenerate,
+                ...createNativeGenerateGuard({
+                    provider: this.providerName,
+                    availableInputTokens: getAvailableInputTokens(this.providerName, modelId, options.maxTokens ?? undefined),
+                    // Runs on every step of the generate loop, so a cyclic or
+                    // oversized tool schema must not throw the turn away. Shares the
+                    // estimator's own serializer: its fallback over-reports, which
+                    // makes the guard fire rather than silently size the overhead at
+                    // nothing.
+                    // Charge the guard only for what this pass actually sends. A
+                    // reformat pass runs with `withTools === false` and omits `tools`
+                    // from the request (see the spread below), so counting them here
+                    // over-reports the fixed overhead. That inflation is not cosmetic:
+                    // it feeds `planLoopGuardReclaim`, so a large tool schema can push
+                    // the estimate past the reclaim threshold and drop older tool
+                    // exchanges out of a reformat request that would have fit.
+                    getFixedOverheadTokens: () => estimateTokens(serializeForEstimate({
+                        ...(withTools && v3Tools ? { tools: v3Tools } : {}),
+                        responseFormat: format,
+                    }), this.providerName),
+                }),
+                conversation: conv,
+                ...(withTools && v3Tools ? { tools: v3Tools } : {}),
+                toolsRecord,
+                ...(withTools && hasTools && options.toolChoice
+                    ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
+                    : {}),
+                // The per-call `timeout` keeps its per-MODEL-CALL meaning once
+                // `turnTimeoutMs` owns the whole-turn deadline, and it reaches the
+                // model layer only through this channel. Without it each step fell
+                // back to the provider default, so a caller asking for a short
+                // per-call timeout got the default on every request.
+                ...(typeof options.timeout === "number"
+                    ? {
+                        providerOptions: {
+                            neurolink: { timeoutMs: options.timeout },
+                        },
+                    }
+                    : {}),
+                ...(format ? { responseFormat: format } : {}),
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                ...(options.maxTokens ? { maxOutputTokens: options.maxTokens } : {}),
+                ...(options.temperature !== undefined
+                    ? { temperature: options.temperature }
+                    : {}),
+                ...(options.abortSignal ? { abortSignal: options.abortSignal } : {}),
+                ...(options.toolTimeoutMs !== undefined
+                    ? { toolTimeoutMs: options.toolTimeoutMs }
+                    : {}),
+                // withProviderRetry + handleProviderError are what the ai loop
+                // supplied around each call: without them a 429 surfaces as a raw
+                // upstream string instead of a RateLimitError, and a throttle is
+                // never retried.
+                runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`).catch((err) => {
+                    throw this.handleProviderError(err);
+                }),
+            }, toolExecutionSummaries);
+        };
         // Structured output rides `response_format` first. When a vendor rejects
         // that outright — a tools/JSON-mode conflict, or a schema its constrained
         // decoder will not accept — the recovery is to ask for the same object in

package/dist/proxy/anthropicBudgetResponse.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyTokenBudgetLease } from "../types/index.js";
+/** Observe consumed bytes only: no tee, eager draining, or unbounded SSE frame. */
+export declare function observeAnthropicBudgetResponse(response: Response, lease: ProxyTokenBudgetLease, onSettlement: () => void, signal?: AbortSignal): Response;

package/dist/proxy/anthropicBudgetResponse.js

@@ -0,0 +1,153 @@
+import { settleProxyTokenBudget } from "./proxyTokenBudget.js";
+/** Observe consumed bytes only: no tee, eager draining, or unbounded SSE frame. */
+export function observeAnthropicBudgetResponse(response, lease, onSettlement, signal) {
+    if (lease.snapshot.scope === "disabled") {
+        return response;
+    }
+    let finishing;
+    let terminalSeen = false;
+    let finalOutputUsageSeen = false;
+    let logicalFailureSeen = false;
+    let input;
+    let output;
+    let cachedRead = 0;
+    let cachedWrite = 0;
+    let pending = "";
+    let oversized = false;
+    const isSse = response.headers
+        .get("content-type")
+        ?.includes("text/event-stream");
+    const decoder = new TextDecoder();
+    const readUsage = (text) => {
+        try {
+            const event = JSON.parse(text);
+            if (event?.type === "message_stop") {
+                terminalSeen = true;
+            }
+            if (event?.type === "error") {
+                logicalFailureSeen = true;
+            }
+            const usage = event?.usage ?? event?.message?.usage;
+            if (!usage || typeof usage !== "object") {
+                return;
+            }
+            const valid = (n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
+            if (valid(usage.input_tokens)) {
+                input = Math.max(input ?? 0, usage.input_tokens);
+            }
+            if (valid(usage.output_tokens)) {
+                if (event?.type === "message_delta") {
+                    finalOutputUsageSeen = true;
+                }
+                output = Math.max(output ?? 0, usage.output_tokens);
+            }
+            if (valid(usage.cache_read_input_tokens)) {
+                cachedRead = Math.max(cachedRead, usage.cache_read_input_tokens);
+            }
+            if (valid(usage.cache_creation_input_tokens)) {
+                cachedWrite = Math.max(cachedWrite, usage.cache_creation_input_tokens);
+            }
+        }
+        catch {
+            /* Incomplete/oversized frames keep the conservative reservation. */
+        }
+    };
+    const observe = (text) => {
+        if (!isSse) {
+            if (!oversized && pending.length + text.length <= 1024 * 1024) {
+                pending += text;
+            }
+            else {
+                oversized = true;
+                pending = "";
+            }
+            return;
+        }
+        // Split large chunks without retaining a large frame between pulls.
+        for (const part of text.split(/(?<=\n)/u)) {
+            if (!oversized && pending.length + part.length <= 64 * 1024) {
+                pending += part;
+            }
+            else {
+                oversized = true;
+                pending = "";
+            }
+            if (part.endsWith("\n")) {
+                if (!oversized && pending.startsWith("data:")) {
+                    readUsage(pending.slice(5).trim());
+                }
+                pending = "";
+                oversized = false;
+            }
+        }
+    };
+    const finish = (normal) => {
+        if (finishing) {
+            return finishing;
+        }
+        finishing = (async () => {
+            signal?.removeEventListener("abort", onAbort);
+            if (normal) {
+                observe(decoder.decode());
+                if (!oversized && pending) {
+                    readUsage(isSse && pending.startsWith("data:")
+                        ? pending.slice(5).trim()
+                        : pending);
+                }
+            }
+            const actual = normal &&
+                !logicalFailureSeen &&
+                (!isSse || (terminalSeen && finalOutputUsageSeen)) &&
+                input !== undefined &&
+                output !== undefined
+                ? input + output + cachedRead + cachedWrite
+                : undefined;
+            try {
+                await settleProxyTokenBudget(lease, actual);
+            }
+            finally {
+                onSettlement();
+            }
+        })();
+        return finishing;
+    };
+    const onAbort = () => {
+        void finish(false).catch(() => undefined);
+    };
+    if (signal?.aborted) {
+        onAbort();
+    }
+    else {
+        signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    if (!response.body) {
+        void finish(false).catch(() => undefined);
+        return response;
+    }
+    const reader = response.body.getReader();
+    return new Response(new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await reader.read();
+                if (next.done) {
+                    await finish(true);
+                    controller.close();
+                    return;
+                }
+                observe(decoder.decode(next.value, { stream: true }));
+                controller.enqueue(next.value);
+            }
+            catch (error) {
+                await finish(false).catch(() => undefined);
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            await Promise.allSettled([reader.cancel(reason), finish(false)]);
+        },
+    }, { highWaterMark: 0 }), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -10,6 +10,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     bytes?: number;
     truncated: boolean;
     originalBytes?: number;
+    unparseableFrames: number;
 };
 /**
  * Expose the same header-redaction policy to replay and metadata

package/dist/proxy/bodyCaptureProcessing.js

@@ -54,7 +54,7 @@ function redactNestedValue(key, value) {
         : value;
 }
 /** Redact every value under a sensitive key, including objects and arrays. */
-function redactBody(body) {
+function redactBody(body, redaction) {
     if (body === undefined || body === null) {
         return undefined;
     }
@@ -83,6 +83,7 @@ function redactBody(body) {
                         redacted = JSON.stringify(JSON.parse(data), redactNestedValue);
                     }
                     catch {
+                        redaction.unparseableFrames++;
                         redacted = "[UNPARSEABLE DATA REDACTED]";
                     }
                     return [
@@ -95,6 +96,7 @@ function redactBody(body) {
             // Invalid or truncated structured JSON must not expose an unterminated
             // credential value that a quoted-string regex cannot safely redact.
             if (/^\s*[[{]/.test(body)) {
+                redaction.unparseableFrames++;
                 return "[UNPARSEABLE DATA REDACTED]";
             }
             // Plain-text bodies retain the existing credential-field redaction.
@@ -175,13 +177,15 @@ export function splitUtf8StringByBytes(input, maxBytes) {
  * ceiling.
  */
 function prepareRedactedBody(body, maxBytes = MAX_CAPTURED_BODY_BYTES) {
-    const redacted = redactBody(body);
+    const redaction = { unparseableFrames: 0 };
+    const redacted = redactBody(body, redaction);
     if (redacted === undefined) {
-        return { truncated: false };
+        return { truncated: false, ...redaction };
     }
     return {
         ...truncateUtf8String(redacted, maxBytes),
         originalBytes: utf8ByteLength(redacted),
+        ...redaction,
     };
 }
 /**
@@ -251,11 +255,25 @@ export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
     const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
     const prepared = prepareRedactedBody(entry.body, limit);
-    prepared.truncated ||= entry.sourceTruncated === true;
+    // Structured objects no longer carry their wire byte representation. Do not
+    // serialize a second unredacted copy merely to manufacture a byte count.
+    const inputRetainedBytes = typeof entry.body === "string" ? utf8ByteLength(entry.body) : undefined;
+    const captureMetadata = {
+        sourceTruncated: entry.sourceTruncated === true,
+        processingTruncated: prepared.truncated,
+        inputRetainedBytes,
+        inputEncoding: typeof entry.body === "string"
+            ? "utf8_text"
+            : "structured_object",
+        redactionLossy: prepared.unparseableFrames > 0,
+        unparseableRedactedFrames: prepared.unparseableFrames,
+    };
+    prepared.truncated ||= captureMetadata.sourceTruncated;
     if (logDir === null) {
         return {
             headers,
             stored: {
+                ...captureMetadata,
                 redactedBody: prepared.value,
                 redactedBodyBytes: prepared.bytes,
                 bodyTruncated: prepared.truncated,
@@ -281,6 +299,7 @@ export async function processProxyBodyCapture(entry, logDir) {
         headers,
         stored: {
             ...stored,
+            ...captureMetadata,
             bodyCaptureLimitBytes: limit,
             originalRedactedBodyBytes: prepared.originalBytes,
         },

package/dist/proxy/bodyCaptureWorker.js

@@ -37,6 +37,7 @@ const snapshot = {
     rejectionReasons: {},
 };
 const pending = new Map();
+const publishingSince = new Map();
 const otelAdmissionWaiters = [];
 let admissionRetryTimer;
 /** Atomically reserve the active clone/publication lease. */
@@ -111,7 +112,7 @@ function waitForOtelAdmission(bytes) {
             drainOtelAdmissionWaiters();
         }, OTEL_ADMISSION_WAIT_MS);
         timer.unref?.();
-        otelAdmissionWaiters.push({ bytes, resolve, timer });
+        otelAdmissionWaiters.push({ bytes, queuedAt: Date.now(), resolve, timer });
     });
 }
 function releaseCapture(bytes) {
@@ -276,6 +277,7 @@ export async function captureProxyBody(entry, logDir, consume) {
         return consume({
             error,
             stored: { bodyWriteFailed: true },
+            admissionWaitMs: Math.max(0, Date.now() - queuedAt),
             admission: {
                 limitingResource: bytes > maxEntryBytes
                     ? "entry"
@@ -293,6 +295,7 @@ export async function captureProxyBody(entry, logDir, consume) {
             },
         });
     }
+    const admittedAt = Date.now();
     let current;
     try {
         current = getWorker();
@@ -312,14 +315,19 @@ export async function captureProxyBody(entry, logDir, consume) {
         timer.unref();
         pending.set(id, {
             timer,
+            startedAt: Date.now(),
             resolve: (result) => {
                 // Keep the byte/count lease through index writes and OTLP publication,
                 // so completed worker results cannot form an unbounded parent backlog.
+                publishingSince.set(id, Date.now());
+                result.admissionWaitMs = Math.max(0, admittedAt - queuedAt);
+                result.workerQueueWaitMs = Math.max(0, (result.queueWaitMs ?? 0) - result.admissionWaitMs);
                 void consume(result)
                     .catch(() => {
                     result.error ??= "body_capture_publication_failed";
                 })
                     .finally(() => {
+                    publishingSince.delete(id);
                     releaseCapture(bytes);
                     if (result.error || result.stored.bodyWriteFailed) {
                         snapshot.failed += 1;
@@ -351,7 +359,17 @@ export async function captureProxyBody(entry, logDir, consume) {
  * retained publication work.
  */
 export function getBodyCaptureWorkerSnapshot() {
-    return { ...snapshot, rejectionReasons: { ...snapshot.rejectionReasons } };
+    const now = Date.now();
+    const oldestAge = (times) => times.length ? Math.max(0, now - Math.min(...times)) : 0;
+    return {
+        ...snapshot,
+        rejectionReasons: { ...snapshot.rejectionReasons },
+        processing: pending.size,
+        publishing: publishingSince.size,
+        oldestAdmissionWaitMs: oldestAge(otelAdmissionWaiters.map((waiter) => waiter.queuedAt)),
+        oldestProcessingMs: oldestAge([...pending.values()].map((task) => task.startedAt)),
+        oldestPublicationMs: oldestAge([...publishingSince.values()]),
+    };
 }
 /** Isolated tests point at a separately executed built worker. */
 export const __bodyCaptureWorkerTestHooks = {

package/dist/proxy/codexFallback.d.ts

@@ -10,8 +10,18 @@ import type { ClaudeRequest, CodexFallbackResult, CodexFallbackStream, CodexReas
 export declare class CodexFallbackResponseError extends Error {
     readonly status: number;
     readonly responseBody: string;
+    readonly code?: string;
+    readonly retryable?: boolean;
     constructor(status: number, responseBody: string);
 }
+/** A provider terminal event, preserved through the format adapter. */
+export declare class CodexFallbackStreamError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryable?: boolean;
+    readonly usage?: CodexFallbackResult["usage"];
+    constructor(payload: Record<string, unknown>, eventType: string, usage?: CodexFallbackResult["usage"]);
+}
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
 export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string, reasoningEffort?: CodexReasoningEffort): CodexResponsesRequest;
 /**