@juspay/neurolink 12.14.6 → 12.14.8

package/dist/cli/commands/proxy.js

@@ -12,6 +12,7 @@ import { applyAllClients, restoreAllClients, } from "../proxy-clients/registry.j
 import { resolveProxyConfigPath } from "../../proxy/proxyConfig.js";
 import { redactUrlsInText, sanitizeForLog, } from "../../utils/logSanitize.js";
 import { withTimeout } from "../../utils/async/withTimeout.js";
+import { startProxyHttpTrace } from "../../proxy/proxyTracer.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
 import { configureProxyKeepAliveDispatcher } from "../../proxy/proxyDispatcher.js";
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
@@ -24,7 +25,8 @@ import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../proxy/workerLog.js";
 import { startRollingProxyServer } from "../../proxy/rollingProxyServer.js";
-import { startProxyRestartControl } from "../../proxy/restartControl.js";
+import { startProxyRestartControl, requestProxySupervisorTelemetry, } from "../../proxy/restartControl.js";
+import { getProxyProcessTelemetry } from "../../proxy/processTelemetry.js";
 import { isProxyAuxiliaryRequest } from "../../proxy/proxyRequestKind.js";
 import { spawnProxySocketWorker } from "../../proxy/rollingWorkerProcess.js";
 import { PROXY_ROLLING_SUPERVISOR_ENV, PROXY_SOCKET_WORKER_ENV, } from "../../proxy/rollingWorkerProtocol.js";
@@ -837,13 +839,36 @@ function spawnProxyUpdater(host, port, parentPid, rollingSupervisor = false) {
         workerLog.close();
     }
 }
-async function runProxyTelemetryManager(command) {
+async function runProxyTelemetryManager(command, argv) {
     const { existsSync } = await import("fs");
     if (!existsSync(PROXY_TELEMETRY_SCRIPT_PATH)) {
         throw new Error("Proxy telemetry helper files were not found in this installation. Reinstall NeuroLink with observability assets included.");
     }
     await new Promise((resolve, reject) => {
-        const child = spawn("bash", [PROXY_TELEMETRY_SCRIPT_PATH, command], {
+        const queryCommand = command === "doctor" || command === "query";
+        const queryArgs = [];
+        if (queryCommand && argv) {
+            for (const [key, option] of [
+                ["since", "--since"],
+                ["until", "--until"],
+                ["kind", "--kind"],
+                ["format", "--format"],
+                ["maxRows", "--max-rows"],
+                ["proxyUrl", "--proxy-url"],
+            ]) {
+                if (argv[key] !== undefined) {
+                    queryArgs.push(option, String(argv[key]));
+                }
+            }
+        }
+        const child = spawn(queryCommand ? process.execPath : "bash", queryCommand
+            ? [
+                join(dirname(PROXY_TELEMETRY_SCRIPT_PATH), command === "doctor"
+                    ? "check-proxy-telemetry.mjs"
+                    : "query-proxy-history.mjs"),
+                ...queryArgs,
+            ]
+            : [PROXY_TELEMETRY_SCRIPT_PATH, command], {
             stdio: "inherit",
             env: process.env,
         });
@@ -1078,6 +1103,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
             rejectForUpdate: readiness.drainingForUpdate,
         };
         requestMetadata.set(c.req.raw, metadata);
+        const httpTrace = startProxyHttpTrace(metadata, Object.fromEntries(c.req.raw.headers));
         const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
             metadata.terminalResult = entry;
         }, (entry) => {
@@ -1087,6 +1113,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
             ? () => undefined
             : beginProxyRequest();
         const finish = () => {
+            httpTrace.end(metadata.terminalResult?.responseStatus ?? c.res.status, metadata.terminalResult?.terminalOutcome ?? "unknown", metadata.terminalErrorType);
             stopObservingFinalLog();
             finishActivity();
             // Borrowed traffic holds a concurrency slot for the lifetime of the
@@ -1099,7 +1126,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
         // them at acceptance instead of publishing misleading placeholder values;
         // subsequent events carry the parsed metadata under the same request ID.
         try {
-            await persistProxyLifecycleAcceptance({
+            await httpTrace.run(() => persistProxyLifecycleAcceptance({
                 requestId: metadata.requestId,
                 method: metadata.method,
                 path: metadata.path,
@@ -1107,8 +1134,8 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                 requestBytes,
                 elapsedMs: 0,
                 monotonicMs: startedMonotonicMs,
-            });
-            await next();
+            }));
+            await httpTrace.run(next);
             const responseStatus = c.res.status;
             logProxyLifecycleEvent({
                 event: "response_headers",
@@ -1169,12 +1196,12 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                     let accountingTimedOut = false;
                     let accountingFailed = false;
                     try {
-                        accountingFailed = await notifyRouteTerminal({
+                        accountingFailed = await httpTrace.run(() => notifyRouteTerminal({
                             outcome,
                             error,
                             observedBodyBytes,
                             responseChunks,
-                        });
+                        }));
                     }
                     catch {
                         accountingTimedOut = true;
@@ -1231,6 +1258,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         errorCode: final?.errorCode ?? metadata.terminalErrorCode,
                     });
                     stopObservingFinalLog();
+                    httpTrace.end(final?.responseStatus ?? responseStatus, terminalOutcome, final?.errorType ?? metadata.terminalErrorType);
                 },
             });
         }
@@ -1259,6 +1287,9 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                 errorType: error instanceof Error ? error.name : "unknown_error",
                 errorCode: getProxyRuntimeErrorCode(error),
             });
+            httpTrace.end(getProxyRuntimeErrorCode(error) === "PROXY_TELEMETRY_UNAVAILABLE"
+                ? 503
+                : 502, "handler_error", error instanceof Error ? error.name : "unknown_error");
             throw error;
         }
     };
@@ -1331,8 +1362,9 @@ export async function createProxyStartApp(params) {
                 accountKey: attempt?.accountKey,
                 provider: attempt?.provider,
                 transportScope: attempt?.transportScope,
-                traceId: attempt?.traceId,
-                spanId: attempt?.spanId,
+                traceId: attempt?.traceId ?? metadata.traceId,
+                spanId: attempt?.spanId ?? metadata.spanId,
+                traceFlags: attempt?.traceFlags ?? metadata.traceFlags,
                 responseStatus: status,
                 responseTimeMs: Date.now() - metadata.startedAt,
                 errorType,
@@ -1342,6 +1374,9 @@ export async function createProxyStartApp(params) {
             logBodyCapture({
                 timestamp: new Date().toISOString(),
                 requestId: metadata.requestId,
+                traceId: attempt?.traceId ?? metadata.traceId,
+                spanId: attempt?.spanId ?? metadata.spanId,
+                traceFlags: attempt?.traceFlags ?? metadata.traceFlags,
                 model: metadata.model,
                 stream: metadata.stream,
                 phase: "client_response",
@@ -2042,6 +2077,10 @@ export async function createProxyStartApp(params) {
                 };
             })(),
             observability: {
+                process: getProxyProcessTelemetry(),
+                supervisor: supervisorState?.pid
+                    ? await requestProxySupervisorTelemetry(supervisorState.restartControl, supervisorState.pid)
+                    : { status: "not_applicable" },
                 lifecycle: getProxyLifecycleLoggerSnapshot(),
                 requestLogs: getRequestLoggerSnapshot(),
             },
@@ -2859,6 +2898,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         restartControl = await startProxyRestartControl({
             stateDir: join(homedir(), ".neurolink"),
             server: rollingServer,
+            getTelemetry: getProxyProcessTelemetry,
             log: (message) => logger.warn(message),
             isUpdatePending: () => !!rollingReplacement || !!loadUpdateState()?.pendingRestartVersion,
             getInstalledVersion: async () => {
@@ -3553,6 +3593,8 @@ export const proxyStatusCommand = {
 // PROXY TELEMETRY COMMAND
 // =============================================================================
 const PROXY_TELEMETRY_ACTIONS = [
+    "doctor",
+    "query",
     "setup",
     "start",
     "stop",
@@ -3562,12 +3604,37 @@ const PROXY_TELEMETRY_ACTIONS = [
 ];
 export const proxyTelemetryCommand = {
     command: "telemetry <action>",
-    describe: "Manage the local OpenObserve stack and dashboard for proxy observability",
+    describe: "Query and verify stored OTel telemetry or manage the local observability stack",
     builder: (yargs) => yargs
         .positional("action", {
         type: "string",
         choices: [...PROXY_TELEMETRY_ACTIONS],
-        describe: "Telemetry action: setup, start, stop, status, logs, or import-dashboard",
+        describe: "Telemetry action: doctor, query, setup, start, stop, status, logs, or import-dashboard",
+    })
+        .option("since", {
+        type: "string",
+        description: "Inclusive ISO timestamp for stored telemetry",
+    })
+        .option("until", {
+        type: "string",
+        description: "Exclusive ISO timestamp for stored telemetry",
+    })
+        .option("kind", {
+        type: "string",
+        description: "Metadata kind for query, such as request_final or telemetry_delivery",
+    })
+        .option("format", {
+        type: "string",
+        choices: ["json", "text"],
+        description: "Doctor report format; query always returns JSON",
+    })
+        .option("max-rows", {
+        type: "number",
+        description: "Explicit bounded history record limit",
+    })
+        .option("proxy-url", {
+        type: "string",
+        description: "Proxy endpoint used by the read-only doctor",
     })
         .option("quiet", {
         type: "boolean",
@@ -3575,19 +3642,21 @@ export const proxyTelemetryCommand = {
         default: false,
         description: "Suppress the local CLI spinner and delegate directly",
     })
+        .example("neurolink proxy telemetry doctor --format json", "Verify field coverage, stored captures, trace correlation, and delivery evidence")
+        .example("neurolink proxy telemetry query --since 2026-09-15T00:00:00Z --kind request_final", "Read stored OTLP metadata without scanning proxy log files")
         .example("neurolink proxy telemetry setup", "Start OpenObserve, start the OTEL collector, and import the dashboard")
         .example("neurolink proxy telemetry start", "Start the local proxy telemetry stack without re-importing the dashboard")
         .example("neurolink proxy telemetry stop", "Stop the local OpenObserve and OTEL collector containers"),
     handler: async (argv) => {
         const action = argv.action;
-        const spinner = argv.quiet
+        const spinner = argv.quiet || action === "doctor" || action === "query"
             ? null
             : ora(`Running proxy telemetry ${action}...`).start();
         try {
             if (spinner) {
                 spinner.stop();
             }
-            await runProxyTelemetryManager(action);
+            await runProxyTelemetryManager(action, argv);
             if (spinner) {
                 spinner.succeed(`proxy telemetry ${action} completed`);
             }

package/dist/proxy/bodyCaptureProcessing.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { mkdir, chmod, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { promisify } from "node:util";
+import { sanitizeForLog } from "../utils/logSanitize.js";
 import { gzip as gzipCallback } from "node:zlib";
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
 /** Maximum redacted body bytes persisted per capture entry. */
@@ -43,6 +44,15 @@ function redactHeaders(headers) {
     return redacted;
 }
 const SENSITIVE_BODY_KEY = /^(?:password|access_token|refresh_token|api_key|apiKey|secret|authorization|token|credential|x-api-key)$/i;
+/** Error messages may contain nested JSON encoded as a string. */
+function redactNestedValue(key, value) {
+    if (SENSITIVE_BODY_KEY.test(key)) {
+        return "[REDACTED]";
+    }
+    return typeof value === "string"
+        ? sanitizeForLog(value.replace(SENSITIVE_BODY_KEYS, '$1"[REDACTED]"'), value.length)
+        : value;
+}
 /** Redact every value under a sensitive key, including objects and arrays. */
 function redactBody(body) {
     if (body === undefined || body === null) {
@@ -54,11 +64,44 @@ function redactBody(body) {
             value = JSON.parse(body);
         }
         catch {
-            // Non-JSON bodies (including SSE transcripts) keep the legacy fallback.
-            return body.replace(SENSITIVE_BODY_KEYS, '$1"[REDACTED]"');
+            if (/^(?:event|data):/m.test(body)) {
+                // Redact whole SSE data values, including nested credentials. Never
+                // retain a truncated/invalid JSON tail whose secret cannot be parsed.
+                return body
+                    .split(/\r\n\r\n|\n\n|\r\r/)
+                    .map((frame) => {
+                    const lines = frame.split(/\r\n|\n|\r/);
+                    const data = lines
+                        .filter((line) => line.startsWith("data:"))
+                        .map((line) => line.slice(5).trimStart())
+                        .join("\n");
+                    if (!data || data === "[DONE]") {
+                        return frame;
+                    }
+                    let redacted;
+                    try {
+                        redacted = JSON.stringify(JSON.parse(data), redactNestedValue);
+                    }
+                    catch {
+                        redacted = "[UNPARSEABLE DATA REDACTED]";
+                    }
+                    return [
+                        ...lines.filter((line) => !line.startsWith("data:")),
+                        `data: ${redacted}`,
+                    ].join("\n");
+                })
+                    .join("\n\n");
+            }
+            // Invalid or truncated structured JSON must not expose an unterminated
+            // credential value that a quoted-string regex cannot safely redact.
+            if (/^\s*[[{]/.test(body)) {
+                return "[UNPARSEABLE DATA REDACTED]";
+            }
+            // Plain-text bodies retain the existing credential-field redaction.
+            return sanitizeForLog(body.replace(SENSITIVE_BODY_KEYS, '$1"[REDACTED]"'), body.length);
         }
     }
-    return JSON.stringify(value, (key, nested) => SENSITIVE_BODY_KEY.test(key) ? "[REDACTED]" : nested);
+    return JSON.stringify(value, redactNestedValue);
 }
 /**
  * Restrict request and phase identifiers to characters safe for artifact
@@ -208,6 +251,7 @@ export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
     const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
     const prepared = prepareRedactedBody(entry.body, limit);
+    prepared.truncated ||= entry.sourceTruncated === true;
     if (logDir === null) {
         return {
             headers,

package/dist/proxy/bodyCaptureWorker.js

@@ -1,5 +1,5 @@
 import { Worker } from "node:worker_threads";
-const MAX_PENDING = 16;
+const MAX_PENDING = 64;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
 // Bound retained UTF-16 strings rather than a 3x UTF-8 guess. This accommodates
 // the observed 7.3 MB JSON requests while retaining a 32 MiB aggregate pool.
@@ -18,6 +18,8 @@ const snapshot = {
     pendingBytes: 0,
     maxPending: MAX_PENDING,
     maxPendingBytes: MAX_PENDING_BYTES,
+    highWaterPending: 0,
+    highWaterBytes: 0,
     rejectionReasons: {},
 };
 const pending = new Map();
@@ -27,7 +29,7 @@ const pending = new Map();
  * Conservatively bound clone size and traversal work without invoking
  * getters or serializers.
  */
-function estimateCloneBytes(value) {
+function estimateCloneBytes(value, maxEntryBytes) {
     const stack = [value];
     const seen = new Set();
     let bytes = 0, nodes = 0;
@@ -35,8 +37,8 @@ function estimateCloneBytes(value) {
         if (++nodes > 100_000) {
             throw new Error("body_capture_traversal_limit");
         }
-        if (bytes > MAX_ENTRY_BYTES) {
-            throw new Error("body_capture_entry_too_large");
+        if (bytes > maxEntryBytes) {
+            return bytes;
         }
         const item = stack.pop();
         if (typeof item === "string") {
@@ -66,8 +68,8 @@ function estimateCloneBytes(value) {
             if (stack.length > 100_000) {
                 throw new Error("body_capture_traversal_limit");
             }
-            if (bytes > MAX_ENTRY_BYTES) {
-                throw new Error("body_capture_entry_too_large");
+            if (bytes > maxEntryBytes) {
+                return bytes;
             }
         }
     }
@@ -133,10 +135,13 @@ function getWorker() {
 /** Bounded bulk capture. Failures are indexed; never fall back to blocking work. */
 export async function captureProxyBody(entry, logDir, consume) {
     snapshot.attempted += 1;
+    // An OTel capture can use the existing byte pool when it is otherwise idle.
+    // Raising the slot count does not raise the aggregate retained-memory bound.
+    const maxEntryBytes = logDir === null ? MAX_PENDING_BYTES : MAX_ENTRY_BYTES;
     let bytes;
     let admissionError;
     try {
-        bytes = estimateCloneBytes(entry);
+        bytes = estimateCloneBytes(entry, maxEntryBytes);
     }
     catch (error) {
         bytes = Infinity;
@@ -150,20 +155,39 @@ export async function captureProxyBody(entry, logDir, consume) {
                 ? error.message
                 : "body_capture_unsupported_value";
     }
-    if (bytes > MAX_ENTRY_BYTES ||
+    if (bytes > maxEntryBytes ||
         snapshot.pending >= MAX_PENDING ||
         snapshot.pendingBytes + bytes > MAX_PENDING_BYTES ||
         Date.now() < retryAfter) {
         snapshot.rejected += 1;
-        const error = bytes > MAX_ENTRY_BYTES
+        const error = bytes > maxEntryBytes
             ? (admissionError ?? "body_capture_entry_too_large")
             : Date.now() < retryAfter
                 ? "body_worker_backoff"
                 : "body_capture_queue_full";
         snapshot.lastError = error;
+        snapshot.lastRejectedAt = new Date().toISOString();
         snapshot.rejectionReasons[error] =
             (snapshot.rejectionReasons[error] ?? 0) + 1;
-        return consume({ error, stored: { bodyWriteFailed: true } });
+        return consume({
+            error,
+            stored: { bodyWriteFailed: true },
+            admission: {
+                limitingResource: bytes > maxEntryBytes
+                    ? "entry"
+                    : Date.now() < retryAfter
+                        ? "worker"
+                        : snapshot.pending >= MAX_PENDING
+                            ? "captures"
+                            : "bytes",
+                estimatedBytes: Number.isFinite(bytes) ? bytes : undefined,
+                maxEntryBytes,
+                pending: snapshot.pending,
+                pendingBytes: snapshot.pendingBytes,
+                maxPending: MAX_PENDING,
+                maxPendingBytes: MAX_PENDING_BYTES,
+            },
+        });
     }
     let current;
     try {
@@ -207,7 +231,9 @@ export async function captureProxyBody(entry, logDir, consume) {
             },
         });
         snapshot.pending += 1;
+        snapshot.highWaterPending = Math.max(snapshot.highWaterPending, snapshot.pending);
         snapshot.pendingBytes += bytes;
+        snapshot.highWaterBytes = Math.max(snapshot.highWaterBytes, snapshot.pendingBytes);
         current.ref();
         try {
             current.postMessage({ id, entry, logDir, queuedAt: Date.now() });
@@ -248,6 +274,9 @@ export const __bodyCaptureWorkerTestHooks = {
             pending: 0,
             pendingBytes: 0,
             lastError: undefined,
+            lastRejectedAt: undefined,
+            highWaterPending: 0,
+            highWaterBytes: 0,
             rejectionReasons: {},
         });
     },

package/dist/proxy/claudeOutputObservation.d.ts

@@ -0,0 +1,9 @@
+import type { RequestLogEntry, SSETelemetry } from "../types/index.js";
+/** Content visible to the caller; thinking and empty text are not useful output. */
+export declare function hasUsefulClaudeContent(value: unknown): boolean;
+/** A complete JSON response becomes observable when its body has been read. */
+export declare function observeClaudeJsonOutput(metadata: Record<string, unknown>, value: unknown, at?: number): void;
+/** Keep unavailable observations distinct from a complete stream with no output. */
+export declare function observeClaudeStreamOutput(metadata: Record<string, unknown>, data: SSETelemetry): void;
+/** Final records always explain whether useful-output latency was observed. */
+export declare function claudeOutputLogFields(metadata: Record<string, unknown>, requestStartTime: number): Pick<RequestLogEntry, "firstUsefulOutputMs" | "firstUsefulOutputStatus" | "firstUsefulOutputEvent" | "firstUsefulOutputUnavailableReason">;

package/dist/proxy/claudeOutputObservation.js

@@ -0,0 +1,85 @@
+/** Content visible to the caller; thinking and empty text are not useful output. */
+export function hasUsefulClaudeContent(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const block = value;
+    if (Array.isArray(block.content)) {
+        return block.content.some(hasUsefulClaudeContent);
+    }
+    if (block.type === "thinking" || block.type === "redacted_thinking") {
+        return false;
+    }
+    if (typeof block.text === "string" && block.text.trim().length > 0) {
+        return true;
+    }
+    if (typeof block.refusal === "string" && block.refusal.trim().length > 0) {
+        return true;
+    }
+    return ((block.type === "tool_use" || block.type === "server_tool_use") &&
+        typeof block.name === "string" &&
+        block.name.length > 0 &&
+        block.input !== undefined);
+}
+/** A complete JSON response becomes observable when its body has been read. */
+export function observeClaudeJsonOutput(metadata, value, at = Date.now()) {
+    if (!value ||
+        typeof value !== "object" ||
+        !Array.isArray(value.content)) {
+        metadata.firstUsefulOutputStatus = "not_observed";
+        metadata.firstUsefulOutputUnavailableReason = "unrecognized_response";
+        return;
+    }
+    if (hasUsefulClaudeContent(value)) {
+        metadata.firstUsefulOutputAt = at;
+        metadata.firstUsefulOutputStatus = "observed";
+        metadata.firstUsefulOutputEvent = "json_response.content";
+    }
+    else {
+        metadata.firstUsefulOutputStatus = "no_useful_output";
+        delete metadata.firstUsefulOutputAt;
+        delete metadata.firstUsefulOutputEvent;
+    }
+    delete metadata.firstUsefulOutputUnavailableReason;
+}
+/** Keep unavailable observations distinct from a complete stream with no output. */
+export function observeClaudeStreamOutput(metadata, data) {
+    delete metadata.firstUsefulOutputAt;
+    delete metadata.firstUsefulOutputEvent;
+    delete metadata.firstUsefulOutputUnavailableReason;
+    if (!data.observationIncomplete && data.firstUsefulOutputAt !== undefined) {
+        metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+        metadata.firstUsefulOutputEvent = data.firstUsefulOutputEvent;
+        metadata.firstUsefulOutputStatus = "observed";
+    }
+    else if (!data.observationIncomplete && data.messageStopReceived) {
+        metadata.firstUsefulOutputStatus = "no_useful_output";
+    }
+    else {
+        metadata.firstUsefulOutputStatus = "not_observed";
+        metadata.firstUsefulOutputUnavailableReason = data.observationIncomplete
+            ? "incomplete_observation"
+            : "stream_incomplete";
+    }
+}
+/** Final records always explain whether useful-output latency was observed. */
+export function claudeOutputLogFields(metadata, requestStartTime) {
+    const at = metadata.firstUsefulOutputAt;
+    if (typeof at === "number" && Number.isFinite(at)) {
+        return {
+            firstUsefulOutputMs: Math.max(0, at - requestStartTime),
+            firstUsefulOutputStatus: "observed",
+            firstUsefulOutputEvent: typeof metadata.firstUsefulOutputEvent === "string"
+                ? metadata.firstUsefulOutputEvent
+                : "translated_output",
+        };
+    }
+    return metadata.firstUsefulOutputStatus === "no_useful_output"
+        ? { firstUsefulOutputStatus: "no_useful_output" }
+        : {
+            firstUsefulOutputStatus: "not_observed",
+            firstUsefulOutputUnavailableReason: typeof metadata.firstUsefulOutputUnavailableReason === "string"
+                ? metadata.firstUsefulOutputUnavailableReason
+                : "response_not_observed",
+        };
+}