@juspay/neurolink 13.4.10 → 13.5.1

package/dist/providers/decide/guards.d.ts

@@ -2,3 +2,9 @@ export declare const isRecord: (v: unknown) => v is Record<string, unknown>;
 export declare const asNumber: (v: unknown) => number | undefined;
 export declare const asNumberMap: (v: unknown) => Record<string, number> | undefined;
 export declare const asStringMap: (v: unknown) => Record<string, string> | undefined;
+/**
+ * A map whose values are shown as text: a string as is, anything else a JSON
+ * value can hold as its JSON text. A score legend echoes each level as the
+ * caller gave it, and a level may be a number or an object.
+ */
+export declare const asTextMap: (v: unknown) => Record<string, string> | undefined;

package/dist/providers/decide/guards.js

@@ -27,3 +27,25 @@ export const asStringMap = (v) => {
     }
     return out;
 };
+/**
+ * A map whose values are shown as text: a string as is, anything else a JSON
+ * value can hold as its JSON text. A score legend echoes each level as the
+ * caller gave it, and a level may be a number or an object.
+ */
+export const asTextMap = (v) => {
+    if (!isRecord(v)) {
+        return undefined;
+    }
+    const out = {};
+    for (const [k, raw] of Object.entries(v)) {
+        if (typeof raw === "string") {
+            out[k] = raw;
+            continue;
+        }
+        if (raw === undefined || typeof raw === "function") {
+            return undefined;
+        }
+        out[k] = JSON.stringify(raw);
+    }
+    return out;
+};

package/dist/providers/googleAiStudio/client.js

@@ -771,6 +771,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             name: "provider.stream",
             tracer: tracers.provider,
             detached: true,
+            rootWhenOrphaned: true,
             attributes: {
                 [ATTR.NL_MODEL]: modelName,
                 [ATTR.NL_PROVIDER]: this.providerName,
@@ -1474,6 +1475,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             name: "provider.generate",
             tracer: tracers.provider,
             detached: true,
+            rootWhenOrphaned: true,
             attributes: {
                 [ATTR.NL_MODEL]: modelName,
                 [ATTR.NL_PROVIDER]: this.providerName,

package/dist/providers/googleVertex/client.d.ts

@@ -520,11 +520,12 @@ export declare class GoogleVertexProvider extends BaseProvider {
     private preserveStreamResultAccessors;
     private withClaudeGeneration;
     /**
-     * Emit `generation:end` so the Pipeline B observability listener creates
-     * the corresponding `model.generation` span. Vertex bypasses the AI SDK
-     * (and therefore the experimental_telemetry plumbing), so this hand-off
-     * is the only way native Vertex calls show up in Langfuse / Pipeline B
-     * exporters. Mirrors the Bedrock + Ollama pattern.
+     * Emit `generation:end` so event listeners and the in-process metrics
+     * aggregator record the generation. Vertex bypasses the AI SDK (and
+     * therefore the experimental_telemetry plumbing), so nothing else emits it;
+     * the in-process store is never exported, and the Langfuse generation
+     * observations are the spans opened where each model call is made.
+     * Mirrors the Bedrock + Ollama pattern.
      */
     private emitGenerationEnd;
     /**

package/dist/providers/googleVertex/client.js

@@ -43,7 +43,9 @@ import { createStreamChannel } from "../../core/streamChannel.js";
 import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
-import { ATTR, spanContentAttribute, spanModelRequestAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
+import { ATTR, recordsSpanInputs, spanContentAttribute, spanModelRequestAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
+import { recordsSpanContent } from "../../telemetry/attributes.js";
+import { inTurnlessTree } from "../../telemetry/tracers.js";
 import { observe, observeGeneration, observeTrace, } from "../../telemetry/observation.js";
 import { withGeneration, withStepSpan } from "../../telemetry/withSpan.js";
 import { context as otelContext, SpanKind, SpanStatusCode, trace as otelTrace, } from "@opentelemetry/api";
@@ -1004,6 +1006,7 @@ export class GoogleVertexProvider extends BaseProvider {
             name: "provider.stream",
             tracer: tracers.provider,
             detached: true,
+            rootWhenOrphaned: true,
             attributes: {
                 [ATTR.NL_MODEL]: modelName,
                 [ATTR.NL_PROVIDER]: this.providerName,
@@ -3472,7 +3475,7 @@ export class GoogleVertexProvider extends BaseProvider {
         // Langfuse/OTel: the native SDK bypasses the Vercel AI SDK's
         // experimental_telemetry, so emit spans manually — one turn span, one
         // generation span per API call, one tool span per execution — all carrying
-        // langfuse.* attributes the LangfuseSpanProcessor maps to observations.
+        // the langfuse.* observation attributes ExporterSpanProcessor exports.
         // Usage lives ONLY on the generation spans (Langfuse sums usage across
         // observations for trace totals, so repeating it on the turn double-counts).
         const offeredToolNames = (tools ?? []).map((anthropicTool) => anthropicTool.name);
@@ -5515,12 +5518,20 @@ export class GoogleVertexProvider extends BaseProvider {
             name: "provider.generate",
             tracer: tracers.provider,
             detached: true,
+            rootWhenOrphaned: true,
             attributes: {
                 [ATTR.NL_MODEL]: modelName,
                 [ATTR.NL_PROVIDER]: this.providerName,
             },
         }, async (generateSpan) => {
             const generateStartTime = Date.now();
+            // Neither this span nor executeGeneration is an observation: the
+            // generation spans below carry the model call. Marked internal so no
+            // exporter of ours sends them as duplicates, except for the root a
+            // direct call opened for itself, which the loop hangs from.
+            if (!inTurnlessTree(generateSpan)) {
+                generateSpan.setAttribute(ATTR.NL_INTERNAL, true);
+            }
             // One dispatch decision for the whole override: Vertex's generate()
             // bypasses BaseProvider.generate(), so it re-runs the same
             // resolveRequestKind() the core call sites use rather than keeping
@@ -5597,15 +5608,21 @@ export class GoogleVertexProvider extends BaseProvider {
             const inputPrompt = mergedOptions.input?.text ||
                 mergedOptions.prompt ||
                 "";
-            // Set generation input before the call so error paths still carry the
-            // request; output is set after the native call resolves.
-            const generationInputAttribute = spanModelRequestAttribute({
-                ...(mergedOptions.systemPrompt
-                    ? { system: mergedOptions.systemPrompt }
-                    : {}),
-                prompt: inputPrompt,
-            });
-            generateSpan.setAttribute(LangfuseOtelSpanAttributes.OBSERVATION_INPUT, generationInputAttribute);
+            // A host exporter on the same provider reads the input and output of
+            // these two spans, so they follow the policy of a generation: masked,
+            // and left out when inputs (or all content) are not recorded. The
+            // input is set before the call so an error path still carries it.
+            const generationInputAttribute = recordsSpanInputs()
+                ? spanModelRequestAttribute({
+                    ...(mergedOptions.systemPrompt
+                        ? { system: mergedOptions.systemPrompt }
+                        : {}),
+                    prompt: inputPrompt,
+                })
+                : undefined;
+            if (generationInputAttribute !== undefined) {
+                generateSpan.setAttribute(LangfuseOtelSpanAttributes.OBSERVATION_INPUT, generationInputAttribute);
+            }
             try {
                 let result;
                 // Wrap the actual native generate call in `neurolink.executeGeneration`
@@ -5619,10 +5636,15 @@ export class GoogleVertexProvider extends BaseProvider {
                     detached: true,
                     attributes: {
                         [ATTR.NL_MODEL]: modelName,
+                        [ATTR.NL_INTERNAL]: true,
                         path: isAnthropicModel(modelName)
                             ? "native.anthropic"
                             : "native.google-genai",
-                        [LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: generationInputAttribute,
+                        ...(generationInputAttribute !== undefined
+                            ? {
+                                [LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: generationInputAttribute,
+                            }
+                            : {}),
                     },
                 }, async (executionSpan) => {
                     let nativeResult;
@@ -5640,7 +5662,9 @@ export class GoogleVertexProvider extends BaseProvider {
                         });
                         nativeResult = await this.runNativeGenerateWithMiddleware(mergedOptions, modelName, (effectiveOptions) => this.executeNativeGemini3GenerateWithSchemaFallback(effectiveOptions, modelName));
                     }
-                    executionSpan.setAttribute(LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT, spanContentAttribute(nativeResult?.content ?? ""));
+                    if (recordsSpanContent()) {
+                        executionSpan.setAttribute(LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT, spanContentAttribute(nativeResult?.content ?? ""));
+                    }
                     return nativeResult;
                 });
                 // Pipe through TTS-of-AI-response when caller asks for it. The
@@ -5648,7 +5672,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 // enabled / useAiResponse is false, so the cost is zero on
                 // non-TTS paths.
                 result = await this.synthesizeAIResponseIfNeeded(result, options);
-                generateSpan.setAttribute(LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT, spanContentAttribute(result?.content ?? ""));
+                if (recordsSpanContent()) {
+                    generateSpan.setAttribute(LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT, spanContentAttribute(result?.content ?? ""));
+                }
                 // Fire onFinish lifecycle callback for the native generate path.
                 // Pipeline A providers get this for free via the AI SDK middleware
                 // wrapper (LifecycleMiddleware); native @google/genai bypasses
@@ -6343,11 +6369,12 @@ export class GoogleVertexProvider extends BaseProvider {
         }));
     }
     /**
-     * Emit `generation:end` so the Pipeline B observability listener creates
-     * the corresponding `model.generation` span. Vertex bypasses the AI SDK
-     * (and therefore the experimental_telemetry plumbing), so this hand-off
-     * is the only way native Vertex calls show up in Langfuse / Pipeline B
-     * exporters. Mirrors the Bedrock + Ollama pattern.
+     * Emit `generation:end` so event listeners and the in-process metrics
+     * aggregator record the generation. Vertex bypasses the AI SDK (and
+     * therefore the experimental_telemetry plumbing), so nothing else emits it;
+     * the in-process store is never exported, and the Langfuse generation
+     * observations are the spans opened where each model call is made.
+     * Mirrors the Bedrock + Ollama pattern.
      */
     emitGenerationEnd(modelName, result, startTime, success, error, prompt) {
         const emitter = this.neurolink?.getEventEmitter();

package/dist/providers/openaiChatCompletionsBase.js

@@ -1946,9 +1946,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 // a blanket "stop" for every stream that drained without throwing.
                 streamMetadata.finishReason = toUnifiedFinishReason(rawFinishReason);
                 // No-output path: stream completed normally but yielded zero text.
-                // Build an enriched sentinel + stamp the active OTel span so
-                // Pipeline B (ContextEnricher) surfaces a WARNING-level Langfuse
-                // observation instead of silently succeeding.
+                // Build an enriched sentinel + stamp the active OTel span with the
+                // WARNING observation level, which ExporterSpanProcessor exports,
+                // so the observation does not read as a silent success.
                 if (contentYielded === 0 && toolsUsed.length === 0) {
                     logger.warn(`${providerName}: Stream produced no output — emitting enriched sentinel`);
                     const fauxNoOutput = new NoOutputGeneratedError({
@@ -2078,7 +2078,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
             };
         };
-        const stepSpans = new StepSpans();
+        const stepSpans = new StepSpans("stream");
         try {
             // May grow mid-turn: hydrated tools with wire-unsafe names need
             // reverse-mapping even when the initial name set required none.

package/dist/providers/systemOneDecision.d.ts

@@ -22,6 +22,12 @@ export declare function describeValidationErrors(detail: readonly unknown[]): st
  * belongs in an error message or a log, whatever the wording, so the
  * configured key, anything shaped like a LiteLLM key, any long hex run and any
  * embedded `data:` URL are all removed.
+ *
+ * Its request-validation errors also quote the request back (pydantic's
+ * `input_value=…`, the start of the state and questions), and its routing
+ * errors append the gateway's fallback table, which names every model group it
+ * serves. The first is the caller's data and the second is the gateway's, so
+ * both are cut.
  */
 export declare function redactCredentials(message: string, apiKey: string): string;
 /**
@@ -85,12 +91,14 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
      */
     protected readRetryAfterMs(_headers: Headers): number | undefined;
     /**
-     * The per-attempt timeout when the caller sets none. A provider whose latency
-     * grows with the number of questions or the size of the state scales the
-     * descriptor's allowance here. `stateTokens` is the local estimate, 0 when the
-     * descriptor sets no local limits.
+     * The per-attempt timeout when the caller sets none: the descriptor's
+     * `decideMs`, plus `decideMsPerKStateTokens` for every full 1,000 estimated
+     * state tokens when it declares that, since a long state takes longer to read
+     * and a flat budget would cut off a request well inside the model's window. A
+     * provider whose latency grows another way overrides this. `stateTokens` is
+     * the local estimate, 0 when the descriptor sets no local limits.
      */
-    protected defaultTimeoutMs(_questionCount: number, _stateTokens: number): number | undefined;
+    protected defaultTimeoutMs(_questionCount: number, stateTokens: number): number | undefined;
     /**
      * The part of a successful response that holds `answers`, `usage` and
      * `model`. The default is the response itself; a vendor that wraps every
@@ -101,6 +109,12 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
     /** Per-question confidence a transport reports outside the answer objects. */
     protected reportedConfidence(_payload: unknown): Record<string, number>;
     protected resolveResponseModel(payload: Record<string, unknown>, requestedModel: string): string;
+    /**
+     * The model this request goes to and is checked against: the call's own, else
+     * the instance's. A provider whose default cannot read some requests may pick
+     * another for them here.
+     */
+    protected resolveRequestModel(request: DecisionRequest): string;
     /** Extra fields for the credential-rejected warning. */
     protected diagnosticContext(): Record<string, unknown>;
     protected getProviderName(): AIProviderName;
@@ -126,8 +140,17 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
      */
     decide(request: DecisionRequest): Promise<DecisionResult>;
     /**
-     * Turn the request's images and video into data URLs, or refuse it. Refused
-     * as a non-retryable `invalid_request`: resending the same media cannot help.
+     * Refuse a question this provider does not read: a type it does not list in
+     * `decisionLimits.questionTypes` (absent means boolean, choice and score), or
+     * a choice or score past its per-question cap. Checked even when the limits
+     * are advisory, since a server that does not know a question type cannot
+     * answer it.
+     */
+    private assertSupportedQuestions;
+    /**
+     * Turn the request's images, video and audio into wire form, or refuse it.
+     * Refused as a non-retryable `invalid_request`: resending the same media
+     * cannot help.
      */
     private prepareMedia;
     /**

package/dist/providers/systemOneDecision.js

@@ -6,7 +6,7 @@ import { ProviderError } from "../types/index.js";
 import { prepareDecisionMedia } from "../utils/decisionMedia.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlsInText } from "../utils/logSanitize.js";
-import { estimateDecisionStateTokens, resolveDecisionLimitsReading, } from "../utils/decisionLimits.js";
+import { estimateDecisionStateTokens, resolveDecisionLimitsReading, unsupportedDecisionQuestion, } from "../utils/decisionLimits.js";
 import { systemOneDialect } from "./decide/dialects/systemOne.js";
 import { asNumber, isRecord } from "./decide/guards.js";
 /**
@@ -44,17 +44,31 @@ export function describeValidationErrors(detail) {
  * belongs in an error message or a log, whatever the wording, so the
  * configured key, anything shaped like a LiteLLM key, any long hex run and any
  * embedded `data:` URL are all removed.
+ *
+ * Its request-validation errors also quote the request back (pydantic's
+ * `input_value=…`, the start of the state and questions), and its routing
+ * errors append the gateway's fallback table, which names every model group it
+ * serves. The first is the caller's data and the second is the gateway's, so
+ * both are cut.
  */
 export function redactCredentials(message, apiKey) {
     const withoutKey = apiKey
         ? message.split(apiKey).join("[redacted]")
         : message;
-    return withoutKey
+    return (withoutKey
         .replace(/\.?\s*Received API Key\s*=[\s\S]*$/, "")
+        .replace(/\.?\s*Received Model Group=[\s\S]*$/, "")
+        .replace(/\s*No fallback model group found[\s\S]*$/, "")
+        // Greedy: the quoted value may itself contain ", input_type=", so only the
+        // last one is a delimiter the server wrote.
+        .replace(/input_value=[\s\S]*(?=, input_type=)/g, "input_value=[redacted]")
+        // Cut short by the server, a quoted value has no input_type after it, and
+        // may run over several lines; everything after it is the value.
+        .replace(/input_value=(?!\[redacted\])[\s\S]*/g, "input_value=[redacted]")
         .replace(/\bsk-[A-Za-z0-9._-]+/g, "[redacted]")
         .replace(/\b[0-9a-f]{32,}\b/gi, "[redacted]")
         .replace(/data:[a-z]+\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "[media]")
-        .trim();
+        .trim());
 }
 /**
  * Whether a failed `fetch` was one that refused a redirect. undici words every
@@ -151,13 +165,20 @@ export class SystemOneDecisionProvider extends BaseProvider {
         return undefined;
     }
     /**
-     * The per-attempt timeout when the caller sets none. A provider whose latency
-     * grows with the number of questions or the size of the state scales the
-     * descriptor's allowance here. `stateTokens` is the local estimate, 0 when the
-     * descriptor sets no local limits.
+     * The per-attempt timeout when the caller sets none: the descriptor's
+     * `decideMs`, plus `decideMsPerKStateTokens` for every full 1,000 estimated
+     * state tokens when it declares that, since a long state takes longer to read
+     * and a flat budget would cut off a request well inside the model's window. A
+     * provider whose latency grows another way overrides this. `stateTokens` is
+     * the local estimate, 0 when the descriptor sets no local limits.
      */
-    defaultTimeoutMs(_questionCount, _stateTokens) {
-        return this.getDescriptorDecideMs();
+    defaultTimeoutMs(_questionCount, stateTokens) {
+        const base = this.getDescriptorDecideMs();
+        const perK = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts
+            ?.decideMsPerKStateTokens;
+        return base === undefined || perK === undefined
+            ? base
+            : base + Math.floor(stateTokens / 1000) * perK;
     }
     /**
      * The part of a successful response that holds `answers`, `usage` and
@@ -175,6 +196,14 @@ export class SystemOneDecisionProvider extends BaseProvider {
     resolveResponseModel(payload, requestedModel) {
         return typeof payload.model === "string" ? payload.model : requestedModel;
     }
+    /**
+     * The model this request goes to and is checked against: the call's own, else
+     * the instance's. A provider whose default cannot read some requests may pick
+     * another for them here.
+     */
+    resolveRequestModel(request) {
+        return request.model ?? this.modelName ?? this.getDefaultModel();
+    }
     /** Extra fields for the credential-rejected warning. */
     diagnosticContext() {
         return {};
@@ -250,7 +279,8 @@ export class SystemOneDecisionProvider extends BaseProvider {
                 retryable: false,
             });
         }
-        const resolvedModel = request.model ?? this.modelName ?? this.getDefaultModel();
+        const resolvedModel = this.resolveRequestModel(request);
+        this.assertSupportedQuestions(request, resolvedModel);
         const stateTokens = this.assertWithinDecisionLimits(request, resolvedModel, questionEntries.length);
         const wireQuestions = Object.fromEntries(questionEntries.map(([id, question]) => [
             id,
@@ -393,12 +423,39 @@ export class SystemOneDecisionProvider extends BaseProvider {
         });
     }
     /**
-     * Turn the request's images and video into data URLs, or refuse it. Refused
-     * as a non-retryable `invalid_request`: resending the same media cannot help.
+     * Refuse a question this provider does not read: a type it does not list in
+     * `decisionLimits.questionTypes` (absent means boolean, choice and score), or
+     * a choice or score past its per-question cap. Checked even when the limits
+     * are advisory, since a server that does not know a question type cannot
+     * answer it.
+     */
+    assertSupportedQuestions(request, model) {
+        const descriptor = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName);
+        const limits = descriptor
+            ? resolveDecisionLimitsReading(descriptor, model)
+            : null;
+        for (const [id, question] of Object.entries(request.questions)) {
+            const problem = unsupportedDecisionQuestion(question, limits);
+            if (problem !== undefined) {
+                throw this.decisionError({
+                    kind: "invalid_request",
+                    message: `${this.vendorLabel()} cannot answer question "${id}": ${problem}.`,
+                    retryable: false,
+                });
+            }
+        }
+    }
+    /**
+     * Turn the request's images, video and audio into wire form, or refuse it.
+     * Refused as a non-retryable `invalid_request`: resending the same media
+     * cannot help.
      */
     async prepareMedia(request) {
         const limits = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.decisionLimits;
-        const prepared = await prepareDecisionMedia(request, limits?.media, this.vendorLabel(), listMediaDecisionProviders({ video: request.video !== undefined }));
+        const prepared = await prepareDecisionMedia(request, limits?.media, this.vendorLabel(), listMediaDecisionProviders({
+            video: request.video !== undefined,
+            audio: request.audio !== undefined,
+        }));
         if (prepared.status === "refused") {
             throw this.decisionError({
                 kind: "invalid_request",
@@ -423,7 +480,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
         if (bytes > limit) {
             throw this.decisionError({
                 kind: "invalid_request",
-                message: `The request is ${bytes} bytes; ${this.vendorLabel()} accepts at most ${limit}. Send fewer or smaller images${media?.video ? ", or a shorter video" : ""}.`,
+                message: `The request is ${bytes} bytes; ${this.vendorLabel()} accepts at most ${limit}. Send fewer or smaller images${media?.video ? ", or a shorter video" : ""}${media?.audio ? ", or a shorter audio clip" : ""}.`,
                 retryable: false,
             });
         }

package/dist/proxy/codexUsage.js

@@ -42,6 +42,14 @@
 import { appendFileSync } from "node:fs";
 import { extractSSEEvents } from "./sseInterceptor.js";
 import { sanitizeForLog } from "../utils/logSanitize.js";
+/**
+ * Characters of `response.output_item.done` payloads kept to stand in for a
+ * completed response that carries no output. Bounds what the tap holds for a
+ * stream whose items it cannot otherwise discard.
+ */
+const OUTPUT_ITEMS_LIMIT_CHARS = 1024 * 1024;
+/** Type of the item that stands where output items past the cap were left out. */
+const OMITTED_ITEMS_TYPE = "neurolink_output_omitted";
 const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
     ? Math.floor(value)
     : 0;
@@ -208,6 +216,42 @@ function createCaptureSink() {
 export function createCodexUsageTap() {
     const evidence = { completed: false, terminalBytes: 0 };
     let totalBytes = 0;
+    // Items announced by response.output_item.done. The terminal response may
+    // arrive with an empty or absent output, leaving these as the only record
+    // of what the model said.
+    const streamedItems = [];
+    let streamedItemChars = 0;
+    let omittedItems = 0;
+    // An item past the cap leaves a marker in its place, so the record reads as
+    // incomplete rather than as a shorter reply; adjacent omissions share one.
+    const omitItem = () => {
+        omittedItems += 1;
+        const last = streamedItems[streamedItems.length - 1];
+        if (last?.type === OMITTED_ITEMS_TYPE) {
+            streamedItems[streamedItems.length - 1] = {
+                ...last,
+                omitted_items: Number(last.omitted_items) + 1,
+            };
+            return;
+        }
+        const marker = {
+            type: OMITTED_ITEMS_TYPE,
+            omitted_items: 1,
+            note: `…[truncated: output items past ${OUTPUT_ITEMS_LIMIT_CHARS} characters are not recorded]`,
+        };
+        streamedItems.push(marker);
+        streamedItemChars += JSON.stringify(marker).length;
+    };
+    const withStreamedOutput = (response) => {
+        if ((Array.isArray(response.output) && response.output.length > 0) ||
+            streamedItems.length === 0) {
+            return response;
+        }
+        if (omittedItems > 0) {
+            evidence.outputItemsOmitted = true;
+        }
+        return { ...response, output: [...streamedItems] };
+    };
     const inspectEvidence = (events) => {
         for (const frame of events) {
             if (frame.data.trim() === "[DONE]") {
@@ -234,6 +278,19 @@ export function createCodexUsageTap() {
                         evidence.firstUsefulOutputEvent = String(type);
                     }
                 }
+                if (type === "response.output_item.done" &&
+                    event.item &&
+                    typeof event.item === "object" &&
+                    !Array.isArray(event.item)) {
+                    if (streamedItemChars + frame.data.length <=
+                        OUTPUT_ITEMS_LIMIT_CHARS) {
+                        streamedItems.push(event.item);
+                        streamedItemChars += frame.data.length;
+                    }
+                    else {
+                        omitItem();
+                    }
+                }
                 // Some clients/providers emit complete output items without deltas.
                 // Reasoning/control events are not useful client output. Recognize
                 // actual tool calls and text only, without inventing an earlier time.
@@ -277,8 +334,8 @@ export function createCodexUsageTap() {
                     type.startsWith("response.") &&
                     completedResponse &&
                     typeof completedResponse === "object" &&
-                    "output" in completedResponse) {
-                    evidence.response = completedResponse;
+                    ("output" in completedResponse || streamedItems.length > 0)) {
+                    evidence.response = withStreamedOutput(completedResponse);
                 }
                 if (type === "response.completed") {
                     evidence.completed = true;

package/dist/proxy/proxyTracer.d.ts

@@ -12,7 +12,7 @@
  * - calculateCost() from pricing.ts for cost tracking
  */
 import { type Span } from "@opentelemetry/api";
-import type { AccountSelectionContext, ProxyRequestContext, ProxyRequestOrigin, ResponseInfoContext, UpstreamAttemptContext, UsageContext, ProxyUsageAttributionOptions, RuntimeRequestMetadata, ProxyLogTraceContext } from "../types/index.js";
+import type { AccountSelectionContext, JsonValue, ProxyRequestContext, ProxyRequestOrigin, ResponseInfoContext, UpstreamAttemptContext, UsageContext, ProxyUsageAttributionOptions, RuntimeRequestMetadata, ProxyLogTraceContext } from "../types/index.js";
 declare class ProxyTracer {
     private readonly rootSpan;
     private readonly traceContext;
@@ -43,6 +43,12 @@ declare class ProxyTracer {
     private readonly requestedModel;
     private input?;
     private output?;
+    /** The parsed response outranks the raw upstream body that arrives after it. */
+    private outputIsParsed;
+    /** A model call made through `runModelCall` records the generation. */
+    private modelCallDelegated;
+    /** That call's records carry no content; fixed when the call starts. */
+    private modelContentWithheld;
     private responseModel?;
     private finishReason?;
     private firstOutputAt?;
@@ -65,6 +71,20 @@ declare class ProxyTracer {
     startUpstreamAttempt(ctx: UpstreamAttemptContext): Span;
     /** Span covering the SSE stream relay phase. */
     startStream(): Span;
+    /**
+     * Run a model call inside this request's trace context, so the spans it
+     * starts nest under the proxy root and carry the request's user and session.
+     * That call's generation holds usage and cost, so the root records none of
+     * its own. Its prompt and answer are request and response bodies, so its
+     * records carry them only with `NEUROLINK_PROXY_TRACE_BODY_LOGGING=true`.
+     */
+    runModelCall<T>(fn: () => T): T;
+    /**
+     * The delegated call's stream, read and closed under the same content rule:
+     * the call records its answer while the stream is consumed, which happens
+     * after `runModelCall` has returned.
+     */
+    modelStream<T>(iterator: AsyncIterator<T>): AsyncIterator<T>;
     /** Record account selection outcome on the root span. */
     setAccountSelection(ctx: AccountSelectionContext): void;
     /** Attribute fallback metrics to the account that actually served them. */
@@ -99,6 +119,8 @@ declare class ProxyTracer {
         attemptCount: number;
         reason: string;
     }): void;
+    /** Record the client request body as the input of the root and its generation. */
+    setRequestInput(body: JsonValue): void;
     /** Log the incoming client request body (redacted). */
     logRequestBody(body: string): void;
     /** Log the incoming client request headers (redacted). */
@@ -127,6 +149,8 @@ declare class ProxyTracer {
     getUsage(): UsageContext | undefined;
     /** End the root span with final HTTP status and duration, and emit OTEL metrics. */
     end(responseStatus: number, durationMs: number): void;
+    /** Bodies are only worth keeping while something is recording the span. */
+    private recordsBodies;
     private levelFor;
     private observeOutcome;
     /**