@juspay/neurolink 12.12.5 → 12.12.7

package/dist/providers/openaiChatCompletionsBase.js

@@ -66,6 +66,73 @@ const yieldsSchemaValidObject = (text, schema) => {
     const coerced = coerceJsonToSchema(text, schema);
     return coerced !== null && schemaAccepts(schema, coerced.structuredData);
 };
+// Pull one native chunk at a time and forward cancellation to its iterator.
+const chunksToV3Stream = (source, completion, cancel) => {
+    const iterator = source[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    controller.enqueue(await completion);
+                    controller.close();
+                }
+                else if (next.value.reasoning) {
+                    controller.enqueue({
+                        type: "reasoning-delta",
+                        delta: next.value.reasoning,
+                    });
+                }
+                else {
+                    controller.enqueue({ type: "text-delta", delta: next.value.content });
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            cancel();
+            await iterator.return?.();
+        },
+    });
+};
+async function* v3StreamToChunks(stream, onFinish) {
+    const reader = stream.getReader();
+    let done = false;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                done = true;
+                return;
+            }
+            const part = next.value;
+            if (part.type === "text-delta") {
+                yield { content: part.delta };
+            }
+            else if (part.type === "reasoning-delta") {
+                yield { content: "", reasoning: part.delta };
+            }
+            else if (part.type === "finish") {
+                onFinish(part);
+            }
+            else if (part.type === "error") {
+                throw part.error;
+            }
+        }
+    }
+    finally {
+        try {
+            if (!done) {
+                await reader.cancel();
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
 export class OpenAIChatCompletionsProvider extends BaseProvider {
     config;
     resolvedModel;
@@ -946,7 +1013,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         let wireNameMaps;
         let openAITools;
         let openAIToolChoice;
-        let conversation;
+        // The prompt is kept in its pre-wire shape. Model middleware transforms
+        // `params.prompt`, and the conversion to the chat-completions wire format
+        // has to happen AFTER that or the transform would be discarded.
+        let promptMessages;
         try {
             modelId = await this.resolveModelName();
             const shouldUseTools = !options.disableTools && this.supportsTools();
@@ -962,8 +1032,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ? buildToolsForOpenAI(toolsRecord, wireNameMaps?.toWire)
                 : undefined;
             openAIToolChoice = mapNeuroLinkToolChoice(resolveToolChoice(options, toolsRecord, shouldUseTools), wireNameMaps?.toWire);
-            const initialMessages = await this.buildMessagesForStream(options);
-            conversation = messageBuilderToOpenAI(initialMessages, wireNameMaps?.toWire);
+            promptMessages = (await this.buildMessagesForStream(options));
         }
         catch (setupErr) {
             timeoutController?.cleanup();
@@ -979,26 +1048,136 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const channel = createStreamChannel();
         // Per-provider lifecycle hook (e.g. OTel span wrap for LiteLLM).
         const lifecycle = this.onStreamStart(modelId);
-        const loopPromise = this.runStreamLoop({
-            maxSteps,
+        // Model middleware on the streaming path.
+        //
+        // The base model below is not `buildDelegatingModel()`'s — that one's
+        // `doGenerate` is a single wire call and its `doStream` is a stub. This
+        // one's `doStream` starts the real multi-step stream loop, which is what
+        // "produce the stream for this request" means here. Wrapping it gives the
+        // streaming path the contract the generate path has always had:
+        // `transformParams` can rewrite the prompt before a byte is sent, and
+        // `wrapStream` can observe, filter, or replace the stream outright.
+        //
+        // Honoured on the way back in: `prompt`, `maxOutputTokens`, `temperature`
+        // and `topP`. `tools` is offered read-only — a middleware that rewrites it
+        // gets a WARN rather than a silent drop, because re-deriving the wire tool
+        // list here would diverge from `buildToolsForOpenAI`.
+        const v3Tools = openAITools?.map((t) => ({
+            type: "function",
+            name: t.function.name,
+            description: t.function.description,
+            inputSchema: t.function.parameters,
+        }));
+        const v3Params = {
+            prompt: promptMessages,
+            ...(v3Tools ? { tools: v3Tools } : {}),
+            ...(options.maxTokens !== undefined
+                ? { maxOutputTokens: options.maxTokens }
+                : {}),
+            ...(options.temperature !== undefined
+                ? { temperature: options.temperature }
+                : {}),
+            ...(options.topP !== undefined ? { topP: options.topP } : {}),
+        };
+        let loopPromise;
+        const providerNameForLoop = this.providerName;
+        const streamBaseModel = {
+            specificationVersion: "v3",
+            provider: providerNameForLoop,
             modelId,
-            url,
-            fetchImpl,
-            abortSignal,
-            options,
-            conversation,
-            openAITools,
-            openAIToolChoice,
-            toolsRecord,
-            toolNameFromWire: wireNameMaps?.fromWire,
-            emitter,
-            toolsUsed,
-            toolExecutionSummaries,
-            pushChunk: channel.push,
-            closeChannel: channel.close,
-            resolveUsage,
-            resolveFinish,
-        });
+            supportedUrls: {},
+            doGenerate: async (params) => {
+                const model = await this.getAISDKModel();
+                if (typeof model === "string") {
+                    throw new Error("Native model handle required");
+                }
+                return model.doGenerate(params);
+            },
+            doStream: async (params) => {
+                if (params?.tools !== undefined && params.tools !== v3Tools) {
+                    logger.warn(`${providerNameForLoop}: middleware rewrote 'tools' on the streaming path; tool rewrites are not applied to the wire request yet — the original tool list was sent.`);
+                }
+                const transformedPrompt = Array.isArray(params?.prompt)
+                    ? params.prompt
+                    : promptMessages;
+                const conversation = messageBuilderToOpenAI(transformedPrompt, wireNameMaps?.toWire);
+                const sampled = {
+                    ...options,
+                    ...(typeof params?.maxOutputTokens === "number"
+                        ? { maxTokens: params.maxOutputTokens }
+                        : {}),
+                    ...(typeof params?.temperature === "number"
+                        ? { temperature: params.temperature }
+                        : {}),
+                    ...(typeof params?.topP === "number" ? { topP: params.topP } : {}),
+                };
+                loopPromise = this.runStreamLoop({
+                    maxSteps,
+                    modelId,
+                    url,
+                    fetchImpl,
+                    abortSignal,
+                    options: sampled,
+                    conversation,
+                    openAITools,
+                    openAIToolChoice,
+                    toolsRecord,
+                    toolNameFromWire: wireNameMaps?.fromWire,
+                    emitter,
+                    toolsUsed,
+                    toolExecutionSummaries,
+                    pushChunk: channel.push,
+                    closeChannel: channel.close,
+                    resolveUsage,
+                    resolveFinish,
+                });
+                const completion = loopPromise.then(() => Promise.all([usagePromise, finishPromise]).then(([usage, reason]) => ({
+                    type: "finish",
+                    finishReason: { unified: reason },
+                    usage: {
+                        inputTokens: {
+                            total: usage.promptTokens,
+                            cacheRead: usage.cacheReadTokens,
+                        },
+                        outputTokens: { total: usage.completionTokens },
+                    },
+                })));
+                // The producer can reject before the consumer pulls its terminal event.
+                void completion.catch(() => undefined);
+                return {
+                    stream: chunksToV3Stream(channel.iterable, completion, () => consumerAbortController.abort()),
+                };
+            },
+        };
+        // A middleware chain that blocks (guardrails' precall path) returns its own
+        // stream without calling `doStream`, so the loop may never start. Every
+        // later reader of `loopPromise` has to tolerate that.
+        let chunkSource;
+        try {
+            const wrappedStreamModel = await this.applyMiddlewareToModel(streamBaseModel, options);
+            if (typeof wrappedStreamModel === "string") {
+                throw new Error("Native stream model handle required");
+            }
+            const { stream } = await wrappedStreamModel.doStream(v3Params);
+            chunkSource = v3StreamToChunks(stream, (part) => {
+                if (!loopPromise) {
+                    const input = part.usage.inputTokens.total ?? 0;
+                    const output = part.usage.outputTokens.total ?? 0;
+                    resolveUsage({
+                        promptTokens: input,
+                        completionTokens: output,
+                        totalTokens: input + output,
+                    });
+                    resolveFinish(part.finishReason.unified);
+                }
+            });
+        }
+        catch (error) {
+            consumerAbortController.abort();
+            channel.close();
+            timeoutController?.cleanup();
+            throw error;
+        }
         // Closure-scoped capture: the runStreamLoop's catch block stashes the
         // underlying provider error here so we can pass it through to
         // buildNoOutputSentinel for richer telemetry (matches the pattern in
@@ -1025,7 +1204,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const transformedStream = async function* () {
             let contentYielded = 0;
             try {
-                for await (const chunk of channel.iterable) {
+                for await (const chunk of chunkSource) {
                     if ("content" in chunk &&
                         typeof chunk.content === "string" &&
                         chunk.content.length > 0) {
@@ -1034,6 +1213,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     yield chunk;
                 }
                 // Surface any error that the loop threw after we drained the channel.
+                // `loopPromise` is undefined when a middleware blocked the request
+                // before `doStream` ran, in which case there is no loop to surface.
                 await loopPromise;
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
@@ -1062,6 +1243,15 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 throw streamError;
             }
             finally {
+                if (!loopPromise) {
+                    resolveUsage({
+                        promptTokens: 0,
+                        completionTokens: 0,
+                        totalTokens: 0,
+                    });
+                    resolveFinish("stop");
+                }
+                timeoutController?.cleanup();
                 if (!consumerAbortController.signal.aborted) {
                     consumerAbortController.abort();
                 }
@@ -1101,7 +1291,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             }))),
         });
         loopPromise
-            .finally(() => timeoutController?.cleanup())
+            ?.finally(() => timeoutController?.cleanup())
             .catch((error) => {
             captureProviderError(error);
         });

package/dist/proxy/codexUsage.d.ts

@@ -39,7 +39,7 @@
  * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
  * observed", never "zero tokens".
  */
-import type { CodexStreamUsage } from "../types/index.js";
+import type { CodexStreamUsage, CodexStreamEvidence } from "../types/index.js";
 /**
  * Pull usage out of one parsed SSE `data:` payload.
  *
@@ -65,4 +65,5 @@ export declare function scanCodexSSEForUsage(text: string): CodexStreamUsage | n
 export declare function createCodexUsageTap(): {
     stream: TransformStream<Uint8Array, Uint8Array>;
     usage: Promise<CodexStreamUsage | null>;
+    evidence: () => CodexStreamEvidence;
 };

package/dist/proxy/codexUsage.js

@@ -40,6 +40,8 @@
  * observed", never "zero tokens".
  */
 import { appendFileSync } from "node:fs";
+import { extractSSEEvents } from "./sseInterceptor.js";
+import { sanitizeForLog } from "../utils/logSanitize.js";
 const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
     ? Math.floor(value)
     : 0;
@@ -161,6 +163,68 @@ function createCaptureSink() {
  * none was. It never rejects.
  */
 export function createCodexUsageTap() {
+    const evidence = { completed: false, terminalBytes: 0 };
+    let totalBytes = 0;
+    const inspectEvidence = (events) => {
+        for (const frame of events) {
+            try {
+                const event = JSON.parse(frame.data);
+                if (!event || typeof event !== "object") {
+                    continue;
+                }
+                const seen = extractCodexUsage(event);
+                if (seen) {
+                    latest = seen;
+                }
+                const type = event.type ?? frame.event;
+                if ((type === "response.output_text.delta" ||
+                    type === "response.function_call_arguments.delta") &&
+                    typeof event.delta === "string" &&
+                    event.delta.length > 0) {
+                    evidence.firstUsefulOutputAt ??= Date.now();
+                }
+                if (type === "response.completed") {
+                    evidence.completed = true;
+                    evidence.terminalBytes = totalBytes;
+                }
+                else if (type === "error" ||
+                    type === "response.failed" ||
+                    type === "response.incomplete") {
+                    evidence.errorType = "stream_error";
+                    const response = event.response;
+                    const details = response && typeof response === "object"
+                        ? response
+                        : event;
+                    const rawError = details.error;
+                    const error = rawError && typeof rawError === "object"
+                        ? rawError
+                        : details;
+                    const incomplete = details.incomplete_details;
+                    const reason = incomplete &&
+                        typeof incomplete === "object" &&
+                        "reason" in incomplete
+                        ? incomplete.reason
+                        : undefined;
+                    evidence.errorCode =
+                        typeof error.code === "string"
+                            ? sanitizeForLog(error.code).slice(0, 200)
+                            : typeof reason === "string"
+                                ? sanitizeForLog(reason).slice(0, 200)
+                                : String(type);
+                    evidence.errorMessage =
+                        typeof error.message === "string"
+                            ? sanitizeForLog(error.message).slice(0, 200)
+                            : type === "response.incomplete"
+                                ? "Codex reported an incomplete response"
+                                : "Codex reported a stream failure";
+                    evidence.terminalBytes = totalBytes;
+                }
+            }
+            catch {
+                // Unknown frames cannot establish successful completion.
+            }
+        }
+    };
     let settleUsage = () => { };
     const usage = new Promise((resolve) => {
         settleUsage = resolve;
@@ -179,40 +243,33 @@ export function createCodexUsageTap() {
     const capture = createCaptureSink();
     let carry = "";
     let latest = null;
-    /**
-     * Ceiling on the unterminated tail we are willing to hold.
-     *
-     * `carry` normally holds a fraction of one SSE line, because every newline
-     * flushes it. A stream that never sends one — a hung upstream, a
-     * non-SSE body relayed by mistake — would otherwise grow it without bound
-     * for the life of the request. One `response.completed` event is a few
-     * hundred bytes, so a megabyte is far past any real event, and dropping the
-     * tail costs at most the usage reading this tap is allowed to miss anyway.
-     */
+    // Bound malformed unterminated events without ever withholding relay bytes.
     const CARRY_LIMIT_CHARS = 1024 * 1024;
+    let discardingEvent = false;
     const transformer = {
         transform(chunk, controller) {
             // Bytes go out first and unconditionally: nothing below can delay or
             // alter what the client receives.
             controller.enqueue(chunk);
+            totalBytes += chunk.byteLength;
             try {
                 capture?.(chunk);
                 carry += decoder.decode(chunk, { stream: true });
-                // Keep only the trailing partial line; events are newline-delimited.
-                const lastBreak = carry.lastIndexOf("\n");
-                if (lastBreak === -1) {
-                    if (carry.length > CARRY_LIMIT_CHARS) {
-                        // No line break in a megabyte: this is not the SSE stream we can
-                        // read. Give up on the tail rather than grow forever.
-                        carry = "";
+                if (discardingEvent) {
+                    const boundary = /\r\n\r\n|\n\n|\r\r/.exec(carry);
+                    if (!boundary) {
+                        carry = carry.slice(-3);
+                        return;
                     }
-                    return;
+                    carry = carry.slice(boundary.index + boundary[0].length);
+                    discardingEvent = false;
                 }
-                const complete = carry.slice(0, lastBreak);
-                carry = carry.slice(lastBreak + 1);
-                const seen = scanCodexSSEForUsage(complete);
-                if (seen) {
-                    latest = seen;
+                const { events, remainder } = extractSSEEvents(carry);
+                carry = remainder;
+                inspectEvidence(events);
+                if (carry.length > CARRY_LIMIT_CHARS) {
+                    carry = carry.slice(-2);
+                    discardingEvent = true;
                 }
             }
             catch {
@@ -220,15 +277,7 @@ export function createCodexUsageTap() {
             }
         },
         flush() {
-            try {
-                const seen = scanCodexSSEForUsage(carry);
-                if (seen) {
-                    latest = seen;
-                }
-            }
-            catch {
-                // ignored — see above
-            }
+            // An event without its dispatch delimiter is incomplete on the wire.
             settle(latest);
         },
         /**
@@ -242,5 +291,5 @@ export function createCodexUsageTap() {
         },
     };
     const stream = new TransformStream(transformer);
-    return { stream, usage };
+    return { stream, usage, evidence: () => ({ ...evidence }) };
 }

package/dist/proxy/proxyActivity.d.ts

@@ -1,4 +1,7 @@
-import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver } from "../types/index.js";
+import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver, RequestLogEntry } from "../types/index.js";
+/** Join route accounting to the HTTP lifecycle without relying on write order. */
+export declare function observeProxyFinalLog(requestId: string, observer: (entry: RequestLogEntry) => void): () => void;
+export declare function notifyProxyFinalLog(entry: RequestLogEntry): void;
 export declare function registerProxyResponseObserver(metadata: object, observer: ProxyResponseTrackingObserver): void;
 export declare function takeProxyResponseObservers(metadata: object): ProxyResponseTrackingObserver[];
 /** Track one client-facing proxy request until its response body settles. */

package/dist/proxy/proxyActivity.js

@@ -8,6 +8,19 @@ let lastActivityAtMs = null;
 // response through one tracker, which fans these observers out at the point
 // where bytes actually leave the proxy.
 const responseObserversByMetadata = new WeakMap();
+const finalLogObservers = new Map();
+/** Join route accounting to the HTTP lifecycle without relying on write order. */
+export function observeProxyFinalLog(requestId, observer) {
+    finalLogObservers.set(requestId, observer);
+    return () => {
+        if (finalLogObservers.get(requestId) === observer) {
+            finalLogObservers.delete(requestId);
+        }
+    };
+}
+export function notifyProxyFinalLog(entry) {
+    finalLogObservers.get(entry.requestId)?.(entry);
+}
 export function registerProxyResponseObserver(metadata, observer) {
     const existing = responseObserversByMetadata.get(metadata);
     if (existing) {
@@ -69,12 +82,17 @@ export function isProxyActivityQuiet(snapshot, quietThresholdMs, nowMs = Date.no
 /** Keep activity open until the response body completes, errors, or is cancelled. */
 export function trackProxyResponse(response, finishRequest, observer) {
     if (!response.body) {
-        finishRequest();
-        safelyNotifyObserver(() => observer?.onTerminal?.({
-            outcome: "bodyless",
-            observedBodyBytes: 0,
-            responseChunks: 0,
-        }));
+        try {
+            const notified = observer?.onTerminal?.({
+                outcome: "bodyless",
+                observedBodyBytes: 0,
+                responseChunks: 0,
+            });
+            void Promise.resolve(notified).then(finishRequest, finishRequest);
+        }
+        catch {
+            finishRequest();
+        }
         return response;
     }
     const reader = response.body.getReader();
@@ -88,17 +106,25 @@ export function trackProxyResponse(response, finishRequest, observer) {
     void reader.closed.then(() => {
         sourceClosed = true;
     }, () => undefined);
-    const settle = (outcome) => {
+    const settle = (outcome, error) => {
         if (settled) {
             return;
         }
         settled = true;
-        finishRequest();
-        safelyNotifyObserver(() => observer?.onTerminal?.({
-            outcome,
-            observedBodyBytes,
-            responseChunks,
-        }));
+        // Keep drain accounting open through bounded terminal bookkeeping, but
+        // never hold back the client's response body while telemetry is written.
+        try {
+            const notified = observer?.onTerminal?.({
+                outcome,
+                error,
+                observedBodyBytes,
+                responseChunks,
+            });
+            void Promise.resolve(notified).then(finishRequest, finishRequest);
+        }
+        catch {
+            finishRequest();
+        }
     };
     const trackedBody = new ReadableStream({
         async pull(controller) {
@@ -120,7 +146,7 @@ export function trackProxyResponse(response, finishRequest, observer) {
                 }
             }
             catch (error) {
-                settle("stream_error");
+                settle("stream_error", error);
                 controller.error(error);
             }
         },