@juspay/neurolink 12.14.7 → 12.14.9

package/dist/proxy/processTelemetry.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyProcessTelemetrySnapshot } from "../types/index.js";
+/** Inspect this process, not the launcher configuration intended for its successor. */
+export declare function getProxyProcessTelemetry(): ProxyProcessTelemetrySnapshot;

package/dist/proxy/processTelemetry.js

@@ -0,0 +1,25 @@
+import { fstatSync } from "node:fs";
+import { getProxyOtelLogSnapshot, isProxyOtelOnly } from "./otelLogSink.js";
+import { getProxyLifecycleLoggerSnapshot } from "./proxyLifecycle.js";
+/** Inspect this process, not the launcher configuration intended for its successor. */
+export function getProxyProcessTelemetry() {
+    const descriptor = (fd) => {
+        try {
+            return fstatSync(fd).isFile() ? "file" : "non_file";
+        }
+        catch {
+            return "unavailable";
+        }
+    };
+    const logs = getProxyOtelLogSnapshot();
+    return {
+        pid: process.pid,
+        checkedAt: new Date().toISOString(),
+        configuredSink: isProxyOtelOnly() ? "otel" : "file",
+        lifecycleSink: getProxyLifecycleLoggerSnapshot().sink ?? "unavailable",
+        otelInitialized: logs.initialized,
+        stdio: { stdout: descriptor(1), stderr: descriptor(2) },
+        exportDropped: logs.queues.reduce((n, q) => n + q.dropped, 0),
+        exportUnconfirmed: logs.queues.reduce((n, q) => n + q.exportUnconfirmed, 0),
+    };
+}

package/dist/proxy/rawStreamCapture.js

@@ -1,5 +1,9 @@
 /** Maximum bytes to capture before stopping accumulation (1 MB). */
 const MAX_CAPTURE_BYTES = 1024 * 1024;
+// Payload accounting across concurrent stream observers, independent of the
+// worker's clone/publication pool. Never retain an unbounded number of prefixes.
+const MAX_PENDING_CAPTURE_BYTES = 16 * 1024 * 1024;
+let pendingCaptureBytes = 0;
 const TRUNCATION_MARKER = "\n...[TRUNCATED]";
 export function createRawStreamCapture() {
     const decoder = new TextDecoder();
@@ -17,21 +21,13 @@ export function createRawStreamCapture() {
             return;
         }
         resolved = true;
-        const finalChunk = decoder.decode();
-        if (finalChunk) {
-            if (capturedBytes < MAX_CAPTURE_BYTES) {
-                const remainingBytes = MAX_CAPTURE_BYTES - capturedBytes;
-                chunks.push(finalChunk.slice(0, remainingBytes));
-                capturedBytes += Math.min(finalChunk.length, remainingBytes);
-            }
-            else if (!truncated) {
-                chunks.push(TRUNCATION_MARKER);
-                truncated = true;
-            }
-        }
+        const text = chunks.map((chunk) => decoder.decode(chunk, { stream: true })).join("") +
+            (truncated ? "" : decoder.decode());
+        pendingCaptureBytes -= capturedBytes;
+        chunks.length = 0;
         resolveCapture({
             totalBytes,
-            text: chunks.join(""),
+            text: text + (truncated ? TRUNCATION_MARKER : ""),
             truncated,
         });
     }
@@ -39,21 +35,16 @@ export function createRawStreamCapture() {
         transform(chunk, controller) {
             controller.enqueue(chunk);
             totalBytes += chunk.byteLength;
-            if (capturedBytes < MAX_CAPTURE_BYTES) {
-                const decoded = decoder.decode(chunk, { stream: true });
-                const remainingBytes = MAX_CAPTURE_BYTES - capturedBytes;
-                const slice = decoded.slice(0, remainingBytes);
+            if (!truncated && capturedBytes < MAX_CAPTURE_BYTES) {
+                const remainingBytes = Math.min(MAX_CAPTURE_BYTES - capturedBytes, Math.max(0, MAX_PENDING_CAPTURE_BYTES - pendingCaptureBytes));
+                // Buffer.slice is a view; copy to avoid retaining the whole wire chunk.
+                const slice = Uint8Array.from(chunk.subarray(0, remainingBytes));
                 chunks.push(slice);
-                capturedBytes += Math.min(decoded.length, remainingBytes);
-                if (decoded.length > remainingBytes && !truncated) {
-                    chunks.push(TRUNCATION_MARKER);
-                    truncated = true;
-                }
-            }
-            else if (!truncated) {
-                chunks.push(TRUNCATION_MARKER);
-                truncated = true;
+                capturedBytes += slice.byteLength;
+                pendingCaptureBytes += slice.byteLength;
+                truncated = slice.byteLength < chunk.byteLength;
             }
+            truncated ||= totalBytes > MAX_CAPTURE_BYTES;
         },
         flush() {
             settle();

package/dist/proxy/requestLogger.d.ts

@@ -35,6 +35,8 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     truncated: boolean;
     originalBytes?: number;
 };
+/** Cheap gate for response observers; avoid copying diagnostics on the serving path. */
+export declare function isProxyBodyCaptureEnabled(): boolean;
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;
 /**

package/dist/proxy/requestLogger.js

@@ -514,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

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 } : {}),