@juspay/neurolink 12.14.6 → 12.14.8

package/dist/proxy/requestLogger.js

@@ -21,6 +21,7 @@ import { SeverityNumber } from "@opentelemetry/api-logs";
 import { configureProxyLifecycleLogger } from "./proxyLifecycle.js";
 import { notifyProxyFinalLog, notifyProxyAttemptLog } from "./proxyActivity.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
+import { resolveProxyLogTraceContext, proxyLogContext, } from "./proxyTraceContext.js";
 let logDir = null;
 let logEnabled = false;
 const pendingLogOperations = new Set();
@@ -184,6 +185,12 @@ export function initRequestLogger(enabled = true, customLogsDir) {
     }
 }
 export async function logRequest(entry) {
+    if (!entry.traceId || entry.traceFlags === undefined) {
+        const traceCtx = resolveProxyLogTraceContext(entry);
+        if (traceCtx) {
+            Object.assign(entry, traceCtx);
+        }
+    }
     entry.terminalOutcome ??=
         entry.errorType === "client_cancelled" || entry.responseStatus === 499
             ? "client_cancelled"
@@ -196,17 +203,6 @@ export async function logRequest(entry) {
     if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
-    // Only use OtelBridge if traceId not already provided by caller.
-    // Deferred .then() callbacks lose async context, so OtelBridge would
-    // return undefined and overwrite the valid traceId the caller passed.
-    if (!entry.traceId) {
-        const bridge = new OtelBridge();
-        const traceCtx = bridge.getCurrentTraceContext();
-        if (traceCtx) {
-            entry.traceId = traceCtx.traceId;
-            entry.spanId = traceCtx.spanId;
-        }
-    }
     if (isProxyOtelOnly()) {
         await emitOtlpLogRecord(entry);
         return;
@@ -228,12 +224,12 @@ export async function logRequest(entry) {
  * or OTLP-derived dashboard panels.
  */
 export async function logRequestAttempt(entry) {
-    if (!entry.traceId) {
-        const bridge = new OtelBridge();
-        const traceCtx = bridge.getCurrentTraceContext();
+    if (!entry.traceId || entry.traceFlags === undefined) {
+        const traceCtx = resolveProxyLogTraceContext(entry);
         if (traceCtx) {
             entry.traceId = traceCtx.traceId;
             entry.spanId = traceCtx.spanId;
+            entry.traceFlags = traceCtx.traceFlags;
         }
     }
     notifyProxyAttemptLog(entry);
@@ -313,6 +309,7 @@ function emitOtlpLogRecord(entry) {
             : SeverityNumber.INFO;
         const severityText = isError ? (isRateLimit ? "WARN" : "ERROR") : "INFO";
         otelLogger.emit({
+            context: proxyLogContext(entry),
             severityNumber,
             severityText,
             body: isProxyOtelOnly()
@@ -453,6 +450,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
         const captureId = entry.captureId ?? randomUUID();
         const emit = (chunk, chunkIndex, totalChunks) => {
             otelLogger.emit({
+                context: proxyLogContext(entry),
                 severityNumber: (entry.responseStatus ?? 0) >= 400
                     ? SeverityNumber.WARN
                     : SeverityNumber.INFO,
@@ -516,9 +514,13 @@ function emitOtlpBodyLogRecord(entry, stored) {
         return undefined;
     });
 }
+/** Cheap gate for response observers; avoid copying diagnostics on the serving path. */
+export function isProxyBodyCaptureEnabled() {
+    return logEnabled && (Boolean(logDir) || isProxyOtelOnly());
+}
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export async function logBodyCapture(entry) {
-    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
+    if (!isProxyBodyCaptureEnabled()) {
         return;
     }
     // Borrowed traffic is somebody else's conversation. Capturing it would leave
@@ -526,12 +528,16 @@ export async function logBodyCapture(entry) {
     // not something a share token can be read as consenting to. The request is
     // still logged; only the bodies are dropped.
     if (isBorrowedRequest()) {
+        emitProxyOtelEvent("body_capture_index", {
+            timestamp: entry.timestamp,
+            requestId: entry.requestId,
+            captureId: entry.captureId ?? randomUUID(),
+            phase: entry.phase,
+            bodyDelivery: { status: "policy_excluded", reason: "borrowed_traffic" },
+        });
         return;
     }
-    const bridge = new OtelBridge();
-    const traceCtx = entry.traceId && entry.spanId
-        ? { traceId: entry.traceId, spanId: entry.spanId }
-        : bridge.getCurrentTraceContext();
+    const traceCtx = resolveProxyLogTraceContext(entry);
     const destination = logDir;
     // Publication callbacks retain metadata and the bounded redacted result,
     // never the original unbounded body while a sink is slow.
@@ -573,6 +579,7 @@ export async function logBodyCapture(entry) {
             originalRedactedBodyBytes: stored.originalRedactedBodyBytes,
             bodyWriteFailed: stored.bodyWriteFailed,
             captureError: processed.error,
+            captureAdmission: processed.admission,
             captureQueueWaitMs: processed.queueWaitMs,
             captureProcessingMs: processed.processingMs,
             metadata: processed.error ? undefined : metadata.metadata,
@@ -580,12 +587,14 @@ export async function logBodyCapture(entry) {
         if (traceCtx) {
             indexEntry.traceId = traceCtx.traceId;
             indexEntry.spanId = traceCtx.spanId;
+            indexEntry.traceFlags = traceCtx.traceFlags;
         }
         if (isProxyOtelOnly()) {
             const delivery = await emitOtlpBodyLogRecord({
                 ...metadata,
                 traceId: traceCtx?.traceId ?? metadata.traceId,
                 spanId: traceCtx?.spanId ?? metadata.spanId,
+                traceFlags: traceCtx?.traceFlags ?? metadata.traceFlags,
             }, stored);
             indexEntry.bodyDelivery = delivery ?? {
                 status: processed.error
@@ -612,6 +621,7 @@ export async function logBodyCapture(entry) {
             ...metadata,
             traceId: traceCtx?.traceId ?? metadata.traceId,
             spanId: traceCtx?.spanId ?? metadata.spanId,
+            traceFlags: traceCtx?.traceFlags ?? metadata.traceFlags,
         }, stored);
     };
     const operation = trackLogOperation(captureProxyBody(entry, destination, consume));

package/dist/proxy/restartControl.d.ts

@@ -1,4 +1,4 @@
-import type { ProxyRestartControlIdentity, ProxyRestartControlOptions, ProxyRestartResult } from "../types/index.js";
+import type { ProxyRestartControlIdentity, ProxyRestartControlOptions, ProxyRestartResult, ProxySupervisorTelemetry } from "../types/index.js";
 /**
  * Own restart completion in the supervisor, so a disconnected CLI cannot leave
  * admission closed. The control socket is private to the service's OS user.
@@ -8,5 +8,7 @@ export declare function startProxyRestartControl(options: ProxyRestartControlOpt
     identity: ProxyRestartControlIdentity;
     close: () => Promise<void>;
 }>;
+/** Query the private supervisor endpoint with a short, bounded read; never restart. */
+export declare function requestProxySupervisorTelemetry(identity: ProxyRestartControlIdentity | undefined, expectedPid: number): Promise<ProxySupervisorTelemetry>;
 /** Perform one local control operation; never fall back to killing a process. */
 export declare function requestProxyRestart(identity: ProxyRestartControlIdentity, check: boolean): Promise<ProxyRestartResult>;

package/dist/proxy/restartControl.js

@@ -1,8 +1,35 @@
 import { createServer, request } from "node:http";
-import { chmod, mkdir, rm } from "node:fs/promises";
+import { chmod, mkdir, rm, lstat } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
+const processTelemetrySchema = z.object({
+    pid: z.number().int().positive(),
+    checkedAt: z.string().datetime(),
+    configuredSink: z.enum(["otel", "file"]),
+    lifecycleSink: z.string(),
+    otelInitialized: z.boolean(),
+    stdio: z.object({
+        stdout: z.enum(["file", "non_file", "unavailable"]),
+        stderr: z.enum(["file", "non_file", "unavailable"]),
+    }),
+    exportDropped: z.number().int().nonnegative(),
+    exportUnconfirmed: z.number().int().nonnegative(),
+});
+/** A worker-only restart cannot repair inherited supervisor log descriptors. */
+function assertSupervisorLogging(status, snapshot) {
+    if (status.observability.requestLogs.diskEnabled === false &&
+        (!snapshot ||
+            snapshot.configuredSink !== "otel" ||
+            snapshot.lifecycleSink !== "otel" ||
+            !snapshot.otelInitialized ||
+            snapshot.stdio.stdout !== "non_file" ||
+            snapshot.stdio.stderr !== "non_file")) {
+        throw new Error(snapshot
+            ? "Supervisor logging is not OTel-only. Worker replacement cannot complete the logging cutover; activate the configured supervisor service first."
+            : "Supervisor telemetry is unavailable, so OTel-only logging cannot be proven. Activate the configured supervisor service first.");
+    }
+}
 const statusSchema = z.object({
     pid: z.number().int().positive(),
     version: z.string(),
@@ -99,6 +126,7 @@ export async function startProxyRestartControl(options) {
             }
             previousWorkerPid = active.pid;
             const status = statusSchema.parse(await options.getStatus());
+            assertSupervisorLogging(status, options.getTelemetry?.());
             if (status.pid !== previousWorkerPid ||
                 status.version !== active.version) {
                 throw new Error("Serving worker identity changed during preflight; retry the check.");
@@ -181,6 +209,26 @@ export async function startProxyRestartControl(options) {
             res.writeHead(400, { connection: "close" }).end();
             return;
         }
+        if (req.method === "GET" && req.url === "/telemetry") {
+            req.resume();
+            try {
+                const snapshot = options.getTelemetry?.();
+                if (!snapshot) {
+                    res.writeHead(404).end();
+                    return;
+                }
+                const payload = JSON.stringify(snapshot);
+                res.writeHead(200, {
+                    "content-type": "application/json",
+                    connection: "close",
+                });
+                res.end(payload);
+            }
+            catch {
+                res.writeHead(503, { connection: "close" }).end();
+            }
+            return;
+        }
         if (!((req.method === "GET" && req.url === "/check") ||
             (req.method === "POST" && req.url === "/restart"))) {
             res.writeHead(404).end();
@@ -238,6 +286,75 @@ export async function startProxyRestartControl(options) {
         },
     };
 }
+/** Query the private supervisor endpoint with a short, bounded read; never restart. */
+export async function requestProxySupervisorTelemetry(identity, expectedPid) {
+    if (!identity) {
+        return { status: "unavailable", reason: "supervisor_upgrade_required" };
+    }
+    try {
+        if (!identity.socketPath.endsWith(`/restart-${expectedPid}-${identity.instanceId}.sock`)) {
+            throw new Error("identity");
+        }
+        const socket = await lstat(identity.socketPath);
+        if (!socket.isSocket() ||
+            (socket.mode & 0o077) !== 0 ||
+            (process.getuid && socket.uid !== process.getuid())) {
+            throw new Error("socket");
+        }
+        const snapshot = await new Promise((resolve, reject) => {
+            const req = request({
+                socketPath: identity.socketPath,
+                path: "/telemetry",
+                method: "GET",
+                headers: {
+                    "x-neurolink-instance": identity.instanceId,
+                    connection: "close",
+                },
+            });
+            const timer = setTimeout(() => req.destroy(new Error("timeout")), 1000);
+            req.once("error", (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+            req.once("response", (res) => {
+                let body = "";
+                res.setEncoding("utf8");
+                res.on("data", (chunk) => {
+                    body += chunk;
+                    if (body.length > 8192) {
+                        req.destroy(new Error("size"));
+                    }
+                });
+                res.once("error", (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                });
+                res.once("end", () => {
+                    clearTimeout(timer);
+                    try {
+                        if (res.statusCode !== 200) {
+                            throw new Error("unsupported");
+                        }
+                        const value = processTelemetrySchema.parse(JSON.parse(body));
+                        if (value.pid !== expectedPid ||
+                            Math.abs(Date.now() - Date.parse(value.checkedAt)) > 5000) {
+                            throw new Error("stale");
+                        }
+                        resolve(value);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+            req.end();
+        });
+        return { status: "available", process: snapshot };
+    }
+    catch {
+        return { status: "unavailable", reason: "supervisor_telemetry_unverified" };
+    }
+}
 /** Perform one local control operation; never fall back to killing a process. */
 export async function requestProxyRestart(identity, check) {
     return new Promise((resolve, reject) => {

package/dist/proxy/sseInterceptor.js

@@ -15,6 +15,7 @@
  *   upstreamResponse.body.pipeThrough(stream).pipeTo(clientWritable);
  *   const data = await telemetry; // resolves on stream end
  */
+import { hasUsefulClaudeContent } from "./claudeOutputObservation.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -172,6 +173,8 @@ function finalize(acc) {
         messageId: acc.messageId,
         messageStopReceived: acc.messageStopReceived,
         firstUsefulOutputAt: acc.firstUsefulOutputAt,
+        firstUsefulOutputEvent: acc.firstUsefulOutputEvent,
+        observationIncomplete: acc.observationIncomplete,
         model: acc.model,
         usage: {
             inputTokens: acc.inputTokens,
@@ -191,6 +194,7 @@ function finalize(acc) {
             ? { streamErrorMessage: acc.streamErrorMessage }
             : {}),
         ...(acc.rawTextChunks ? { rawText: acc.rawTextChunks.join("") } : {}),
+        rawTextTruncated: acc.rawTextTruncated,
     };
 }
 // ---------------------------------------------------------------------------
@@ -320,12 +324,17 @@ function processEvent(acc, event) {
     if (!event.data) {
         return;
     }
+    if (event.data.length > 1024 * 1024) {
+        acc.observationIncomplete = true;
+        return;
+    }
     let parsed;
     try {
         parsed = JSON.parse(event.data);
     }
     catch {
         // Malformed JSON — skip silently, bytes already forwarded to client
+        acc.observationIncomplete = true;
         return;
     }
     const payloadType = parsed && typeof parsed === "object" && "type" in parsed
@@ -357,11 +366,52 @@ function processEvent(acc, event) {
             typeof delta === "object" &&
             (("text" in delta &&
                 typeof delta.text === "string" &&
-                delta.text.length > 0) ||
+                delta.text.trim().length > 0) ||
                 ("partial_json" in delta &&
                     typeof delta.partial_json === "string" &&
-                    delta.partial_json.length > 0))) {
-            acc.firstUsefulOutputAt ??= Date.now();
+                    delta.partial_json.trim().length > 0) ||
+                ("refusal" in delta &&
+                    typeof delta.refusal === "string" &&
+                    delta.refusal.trim().length > 0))) {
+            if (acc.firstUsefulOutputAt === undefined) {
+                acc.firstUsefulOutputAt = now;
+                acc.firstUsefulOutputEvent = `content_block_delta.${"text" in delta ? "text" : "refusal" in delta ? "refusal" : "partial_json"}`;
+            }
+        }
+    }
+    if (acc.firstUsefulOutputAt === undefined &&
+        parsed &&
+        typeof parsed === "object") {
+        const payload = parsed;
+        if (eventType === "message_start" &&
+            hasUsefulClaudeContent(payload.message)) {
+            acc.firstUsefulOutputAt = now;
+            acc.firstUsefulOutputEvent = "message_start.content";
+        }
+        const block = payload.content_block;
+        if (eventType === "content_block_start" &&
+            block &&
+            typeof block === "object") {
+            const content = block;
+            if ((typeof content.text === "string" && content.text.trim().length > 0) ||
+                (typeof content.refusal === "string" &&
+                    content.refusal.trim().length > 0) ||
+                ((content.type === "tool_use" || content.type === "server_tool_use") &&
+                    content.input &&
+                    typeof content.input === "object" &&
+                    Object.keys(content.input).length > 0)) {
+                acc.firstUsefulOutputAt = now;
+                acc.firstUsefulOutputEvent = "content_block_start";
+            }
+        }
+        // A completed zero-argument tool call is useful even when no input delta was sent.
+        if (eventType === "content_block_stop" &&
+            typeof payload.index === "number") {
+            const content = acc.contentBlocks.find((block) => block.index === payload.index);
+            if (content?.type === "tool_use" && content.toolName) {
+                acc.firstUsefulOutputAt = now;
+                acc.firstUsefulOutputEvent = "content_block_stop.tool_use";
+            }
         }
     }
     switch (eventType) {
@@ -403,6 +453,7 @@ export function createSSEInterceptor(options = {}) {
     const captureRawText = options.captureRawText ?? false;
     const acc = createAccumulator(captureRawText);
     let sseBuffer = "";
+    let discardingFrame = false;
     let resolved = false;
     const decoder = new TextDecoder();
     let resolveTelemetry;
@@ -415,6 +466,9 @@ export function createSSEInterceptor(options = {}) {
             return;
         }
         resolved = true;
+        if (sseBuffer.trim()) {
+            acc.observationIncomplete = true;
+        }
         resolveTelemetry(finalize(acc));
     }
     const transform = new TransformStream({
@@ -427,8 +481,22 @@ export function createSSEInterceptor(options = {}) {
             const decodedChunk = decoder.decode(chunk, { stream: true });
             appendRawTextChunk(acc, decodedChunk);
             sseBuffer += decodedChunk;
+            if (discardingFrame) {
+                const boundary = /\r\n\r\n|\n\n|\r\r/.exec(sseBuffer);
+                if (!boundary) {
+                    sseBuffer = sseBuffer.slice(-4);
+                    return;
+                }
+                sseBuffer = sseBuffer.slice(boundary.index + boundary[0].length);
+                discardingFrame = false;
+            }
             const { events, remainder } = extractSSEEvents(sseBuffer);
             sseBuffer = remainder;
+            if (sseBuffer.length > 1024 * 1024) {
+                acc.observationIncomplete = true;
+                discardingFrame = true;
+                sseBuffer = sseBuffer.slice(-4);
+            }
             for (const event of events) {
                 processEvent(acc, event);
             }

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -1,14 +1,3 @@
-/**
- * Claude-Compatible Proxy Routes
- *
- * Exposes Anthropic-compatible /v1/messages, /v1/models, and /v1/messages/count_tokens
- * endpoints. ALL requests are routed through ctx.neurolink.generate() / ctx.neurolink.stream()
- * -- no direct HTTP calls to Anthropic.
- *
- * An optional ModelRouter can remap incoming model names to different
- * provider/model pairs (e.g. "claude-sonnet-4-20250514" -> vertex/gemini-2.5-pro).
- * Without a router, models are passed through to the Anthropic provider.
- */
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";

package/dist/server/routes/claudeProxyRoutes.js

@@ -1,3 +1,4 @@
+import { claudeOutputLogFields, observeClaudeJsonOutput, observeClaudeStreamOutput, } from "../../proxy/claudeOutputObservation.js";
 /**
  * Claude-Compatible Proxy Routes
  *
@@ -2437,7 +2438,7 @@ async function handleClaudePassthroughStreamResponse(args) {
             ])
                 .then(([data, clientBody, rawOutcome]) => {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
-                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+                observeClaudeStreamOutput(ctx.metadata, data);
                 const failure = getStreamFailureDetails(terminalOutcome);
                 capturedTracer.setUsage({
                     inputTokens: data.usage.inputTokens,
@@ -2482,6 +2483,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     phase: "upstream_response",
                     headers: responseHeaders,
                     body: data.rawText ?? "",
+                    sourceTruncated: data.rawTextTruncated,
                     bodySize: data.totalBytesReceived,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: "passthrough",
@@ -2494,6 +2496,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     phase: "client_response",
                     headers: responseHeaders,
                     body: clientBody.text,
+                    sourceTruncated: clientBody.truncated,
                     bodySize: clientBody.totalBytes,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: "passthrough",
@@ -2539,7 +2542,7 @@ async function handleClaudePassthroughStreamResponse(args) {
             ])
                 .then(([data, clientBody, rawOutcome]) => {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
-                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+                observeClaudeStreamOutput(ctx.metadata, data);
                 const failure = getStreamFailureDetails(terminalOutcome);
                 finalizeStream(failure?.status ?? response.status, failure?.errorType, failure?.message, {
                     inputTokens: data.usage.inputTokens,
@@ -2551,6 +2554,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     phase: "upstream_response",
                     headers: responseHeaders,
                     body: data.rawText ?? "",
+                    sourceTruncated: data.rawTextTruncated,
                     bodySize: data.totalBytesReceived,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: "passthrough",
@@ -2563,6 +2567,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     phase: "client_response",
                     headers: responseHeaders,
                     body: clientBody.text,
+                    sourceTruncated: clientBody.truncated,
                     bodySize: clientBody.totalBytes,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: "passthrough",
@@ -2603,7 +2608,7 @@ async function handleClaudePassthroughStreamResponse(args) {
     });
 }
 async function handleClaudePassthroughJsonResponse(args) {
-    const { bodyStr, response, tracer, requestStartTime, upstreamSpan, upstreamResponseHeaders, logProxyBody, logFinalRequest, } = args;
+    const { ctx, bodyStr, response, tracer, requestStartTime, upstreamSpan, upstreamResponseHeaders, logProxyBody, logFinalRequest, } = args;
     const responseText = await response.text();
     tracer?.logUpstreamResponseBody(responseText);
     logProxyBody({
@@ -2631,6 +2636,7 @@ async function handleClaudePassthroughJsonResponse(args) {
         durationMs: Date.now() - requestStartTime,
     });
     const responseJson = JSON.parse(responseText);
+    observeClaudeJsonOutput(ctx.metadata, responseJson);
     if (tracer && responseJson && typeof responseJson === "object") {
         const usage = responseJson.usage;
         if (usage) {
@@ -3569,6 +3575,8 @@ async function executeClaudeFallbackTranslation(args) {
         for (const frame of serializer.finish(resolvedUsage.output, reason)) {
             frames.push(frame);
         }
+        ctx.metadata.firstUsefulOutputAt = Date.now();
+        ctx.metadata.firstUsefulOutputEvent = "translated_response.ready";
         // Telemetry AFTER validation — not before like the old lazy path
         tracer?.end(200, Date.now() - requestStartTime);
         logFinalRequest(200, "", providerLabel, undefined, undefined, {
@@ -3609,6 +3617,7 @@ async function executeClaudeFallbackTranslation(args) {
     };
     tracer?.end(200, Date.now() - requestStartTime);
     const clientResponse = serializeClaudeResponse(internal, body.model);
+    observeClaudeJsonOutput(ctx.metadata, clientResponse);
     logFinalRequest(200, "", providerLabel, undefined, undefined, {
         inputTokens: internal.usage?.input,
         outputTokens: internal.usage?.output,
@@ -3855,6 +3864,7 @@ async function executeClaudeCodexFallback(args) {
     };
     tracer?.end(200, Date.now() - requestStartTime);
     const clientResponse = serializeClaudeResponse(internal, body.model);
+    observeClaudeJsonOutput(ctx.metadata, clientResponse);
     logFinalRequest(200, accountLabel, accountType, undefined, undefined, {
         inputTokens: parsed.usage?.input,
         outputTokens: parsed.usage?.output,
@@ -4476,6 +4486,7 @@ async function handleAnthropicSuccessfulResponse(args) {
         });
     }
     return handleAnthropicJsonSuccessResponse({
+        ctx,
         account,
         response,
         responseHeaders,
@@ -4758,7 +4769,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             telemetryDone = Promise.all([telemetry, clientCapture, streamOutcome])
                 .then(([data, clientBody, rawOutcome]) => {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
-                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+                observeClaudeStreamOutput(ctx.metadata, data);
                 recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account, logAttempt);
                 capturedTracer.setUsage({
                     inputTokens: data.usage.inputTokens,
@@ -4823,6 +4834,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     phase: "upstream_response",
                     headers: responseHeaders,
                     body: data.rawText ?? "",
+                    sourceTruncated: data.rawTextTruncated,
                     bodySize: data.totalBytesReceived,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: capturedAccountLabel,
@@ -4835,6 +4847,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     phase: "client_response",
                     headers: responseHeaders,
                     body: clientBody.text,
+                    sourceTruncated: clientBody.truncated,
                     bodySize: clientBody.totalBytes,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: capturedAccountLabel,
@@ -4888,7 +4901,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
             ])
                 .then(([data, clientBody, rawOutcome]) => {
                 const terminalOutcome = mergeStreamTerminalOutcome(rawOutcome, data.streamErrorMessage, data.messageStopReceived);
-                ctx.metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+                observeClaudeStreamOutput(ctx.metadata, data);
                 recordCommittedAnthropicStreamAttemptFailure(terminalOutcome, account, logAttempt);
                 const failure = getStreamFailureDetails(terminalOutcome);
                 const usage = {
@@ -4911,6 +4924,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     phase: "upstream_response",
                     headers: responseHeaders,
                     body: data.rawText ?? "",
+                    sourceTruncated: data.rawTextTruncated,
                     bodySize: data.totalBytesReceived,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: capturedAccountLabel,
@@ -4923,6 +4937,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     phase: "client_response",
                     headers: responseHeaders,
                     body: clientBody.text,
+                    sourceTruncated: clientBody.truncated,
                     bodySize: clientBody.totalBytes,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: capturedAccountLabel,
@@ -4944,6 +4959,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     phase: "client_response",
                     headers: responseHeaders,
                     body: clientBody.text,
+                    sourceTruncated: clientBody.truncated,
                     bodySize: clientBody.totalBytes,
                     contentType: responseHeaders["content-type"] ?? "text/event-stream",
                     account: account.label,
@@ -4995,7 +5011,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
     };
 }
 async function handleAnthropicJsonSuccessResponse(args) {
-    const { account, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
+    const { ctx, account, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     const responseText = await response.text();
     logAttempt(response.status, undefined, undefined, {
         attemptDurationMs: Date.now() - fetchStartMs,
@@ -5026,6 +5042,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
         durationMs: Date.now() - requestStartTime,
     });
     const responseJson = JSON.parse(responseText);
+    observeClaudeJsonOutput(ctx.metadata, responseJson);
     // Settlement is not diagnostics. It ran inside the tracer branch, so a node
     // with tracing off served every borrowed request for free and the lender's
     // ledger never moved — settle from the response itself instead.
@@ -5087,7 +5104,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
     return { response: responseJson };
 }
 async function handleAnthropicSuccessfulNonStreamRetryResponse(args) {
-    const { account, accountState, requestedModel, retryResp, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
+    const { ctx, account, accountState, requestedModel, retryResp, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logAttempt, logProxyBody, logFinalRequest, } = args;
     const retryQuota = parseQuotaHeaders(retryResp.headers, {
         model: requestedModel,
     });
@@ -5145,6 +5162,7 @@ async function handleAnthropicSuccessfulNonStreamRetryResponse(args) {
         durationMs: Date.now() - requestStartTime,
     });
     const retryJson = JSON.parse(retryText);
+    observeClaudeJsonOutput(ctx.metadata, retryJson);
     // A response served after an auth retry is a served response: it costs the
     // lender's account exactly what any other one does.
     settleFromResponseUsage(account, retryJson);
@@ -5267,6 +5285,7 @@ async function handleAnthropicAuthRetry(args) {
                     })
                     : {
                         response: await handleAnthropicSuccessfulNonStreamRetryResponse({
+                            ctx,
                             account,
                             accountState,
                             requestedModel: body.model,
@@ -6004,11 +6023,7 @@ function createClaudeRequestRuntimeContext(args) {
             ...buildClientAttribution(ctx.headers),
             responseStatus: status,
             responseTimeMs: Date.now() - requestStartTime,
-            ...(typeof ctx.metadata.firstUsefulOutputAt === "number"
-                ? {
-                    firstUsefulOutputMs: Math.max(0, ctx.metadata.firstUsefulOutputAt - requestStartTime),
-                }
-                : {}),
+            ...claudeOutputLogFields(ctx.metadata, requestStartTime),
             ...(errorType ? { errorType } : {}),
             ...(errorMessage ? { errorMessage } : {}),
             ...(extra?.errorCode ? { errorCode: extra.errorCode } : {}),