@juspay/neurolink 13.5.0 → 13.5.1

package/dist/processors/index.js

@@ -64,6 +64,10 @@
  * });
  * ```
  */
+// Imported on its own, this entry starts tracing at its first span, as the
+// main entry does. The import sits here rather than in the shared tracers so
+// that the client entry stays free of the OpenTelemetry Node SDK.
+import "../services/server/ai/observability/instrumentation.js";
 // =============================================================================
 // BASE PROCESSOR INFRASTRUCTURE (single source of truth for ALL types)
 // =============================================================================

package/dist/processors/registry/ProcessorRegistry.d.ts

@@ -44,6 +44,7 @@
  * ```
  */
 import type { FileInfo, ProcessorFileProcessingResult, ProcessedFileBase, ProcessOptions, ProcessorMatch, RegistryOptions, RegistryProcessResult, ProcessorRegistration } from "../../types/index.js";
+import "../../services/server/ai/observability/instrumentation.js";
 /**
  * Central registry for file processors.
  * Uses singleton pattern and priority-based selection.

package/dist/processors/registry/ProcessorRegistry.js

@@ -45,6 +45,10 @@
  */
 import { withSpan } from "../../telemetry/withSpan.js";
 import { tracers } from "../../telemetry/tracers.js";
+// Starts tracing at the first span, as this module always did: the shared
+// tracers only start what a loaded entry registered, and this path can be
+// imported without the package entry. The client entry stays free of it.
+import "../../services/server/ai/observability/instrumentation.js";
 // =============================================================================
 // UTILITY FUNCTIONS
 // =============================================================================
@@ -404,6 +408,7 @@ export class ProcessorRegistry {
         return withSpan({
             name: "neurolink.processor.processFile",
             tracer: tracers.processor,
+            observationType: "span",
             attributes: {
                 "processor.filename": fileInfo.name ?? "unknown",
                 "processor.mimetype": fileInfo.mimetype ?? "unknown",

package/dist/providers/amazonBedrock/client.js

@@ -279,9 +279,9 @@ export class AmazonBedrockProvider extends BaseProvider {
             }
             throw error;
         }
-        // Emit generation:end so Pipeline B (Langfuse) creates a GENERATION observation.
-        // Bedrock bypasses the Vercel AI SDK so experimental_telemetry is never injected;
-        // we emit the event manually to fill that gap.
+        // Emit generation:end for the event listeners and the in-process metrics
+        // aggregator. Bedrock bypasses the Vercel AI SDK so nothing else emits it;
+        // its Langfuse GENERATION observations are the loop's own per-step spans.
         const generateEmitter = this.neurolink?.getEventEmitter();
         if (generateEmitter) {
             generateEmitter.emit("generation:end", {
@@ -383,6 +383,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 }),
             });
             const { resultPromise } = runAgenticLoop(adapter, conversation, {
+                operation: "generate",
                 tools: this.toEngineTools(tools),
                 abortSignal: signal,
                 // `toEngineTools` adds no deadline of its own, so this is the only
@@ -1261,6 +1262,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 },
             };
             return runAgenticLoop(adapter, conversation, {
+                operation: "stream",
                 tools: this.toEngineTools(tools),
                 abortSignal: signal,
                 // `toEngineTools` adds no deadline of its own, so this is the only
@@ -1368,8 +1370,8 @@ export class AmazonBedrockProvider extends BaseProvider {
                     // Analytics is resolved off `settled` above, so it lands whether or
                     // not anyone drains the stream.
                     // Bedrock bypasses the Vercel AI SDK, so experimental_telemetry is
-                    // never injected and generation:end is emitted by hand for
-                    // Pipeline B (Langfuse).
+                    // never injected and generation:end is emitted by hand for the
+                    // event listeners and the in-process metrics aggregator.
                     if (streamEmitter) {
                         // #1741: tell the orchestration's finally block this stream's
                         // `generation:end` has already been emitted here, exactly as the

package/dist/providers/amazonSagemaker.js

@@ -13,6 +13,7 @@ import { hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGener
 import { generationName } from "../telemetry/observationNames.js";
 import { observeGeneration } from "../telemetry/observation.js";
 import { tracers } from "../telemetry/tracers.js";
+import { markFailure } from "../telemetry/withSpan.js";
 // SageMaker-specific imports
 import { getDefaultSageMakerEndpoint, getSageMakerConfig, getSageMakerModel, getSageMakerModelConfig, } from "./sagemaker/config.js";
 import { handleSageMakerError, SageMakerError } from "./sagemaker/errors.js";
@@ -375,10 +376,18 @@ export class AmazonSageMakerProvider extends BaseProvider {
                     span.setStatus({ code: SpanStatusCode.OK });
                 }
                 catch (error) {
-                    span.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: error instanceof Error ? error.message : String(error),
-                    });
+                    markFailure(span, error);
+                    // markFailure leaves an abort at WARNING; the released pump ended
+                    // every failure at ERROR, an abort included.
+                    try {
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    catch {
+                        // An error whose text cannot be read is already recorded above.
+                    }
                     channel.error(error);
                 }
                 finally {
@@ -390,14 +399,25 @@ export class AmazonSageMakerProvider extends BaseProvider {
                         settleFinishReason("unknown");
                         settleUsage({ inputTokens: 0, outputTokens: 0 });
                     }
-                    observeGeneration(span, {
-                        ...call,
-                        output: text,
-                        usage: tokens,
-                        finishReason: finish,
-                        completionStartTime: firstChunkAt,
-                    });
-                    span.end();
+                    // Recording is best effort and span.end() must follow it either
+                    // way: this pump is detached, so nothing else would catch a throw.
+                    try {
+                        observeGeneration(span, {
+                            ...call,
+                            output: text,
+                            usage: tokens,
+                            finishReason: finish,
+                            completionStartTime: firstChunkAt,
+                        });
+                    }
+                    catch (error) {
+                        logger.debug("[SageMaker] Failed to record the stream generation", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    finally {
+                        span.end();
+                    }
                 }
             })();
             return {

package/dist/providers/anthropic/client.js

@@ -2208,6 +2208,7 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 : undefined;
             const { stream, resultPromise } = runAgenticLoop(adapter, payload.messages.slice(), {
+                operation: "stream",
                 tools: engineTools,
                 ...(abortSignal ? { abortSignal } : {}),
                 ...(activeSpan ? { span: activeSpan } : {}),

package/dist/providers/anthropic/loopAdapter.js

@@ -401,9 +401,13 @@ export function createAnthropicLoopAdapter(config) {
                             ? params.thinking.budget_tokens
                             : undefined,
                     },
-                    input: {
-                        system: params.system,
-                        messages: sanitizeAnthropicMessagesForTrace(params.messages),
+                    // Read only by a recording span, so a request nobody traces is not
+                    // copied and sanitized on every step.
+                    get input() {
+                        return {
+                            system: params.system,
+                            messages: sanitizeAnthropicMessagesForTrace(params.messages),
+                        };
                     },
                 },
             };

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/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;
     /**