@qduc/term2 0.13.0 → 0.15.0

package/dist/services/logging/provider-traffic.js

@@ -63,6 +63,14 @@ const sanitizeToolDefinitions = (tools) => {
         return 'unknown-tool';
     });
 };
+/**
+ * Placeholder written in place of any `encrypted_content` ciphertext. It is a
+ * visible marker rather than `''` on purpose: an empty string is
+ * indistinguishable from an item that never carried encrypted reasoning at
+ * all, which makes the log useless for confirming that encrypted reasoning is
+ * actually round-tripping on the Responses lane.
+ */
+export const ENCRYPTED_CONTENT_REDACTION = '<redacted>';
 const sanitizeReasoningDetails = (reasoningDetails) => {
     if (!Array.isArray(reasoningDetails))
         return reasoningDetails;
@@ -71,7 +79,7 @@ const sanitizeReasoningDetails = (reasoningDetails) => {
         if (!record)
             return item;
         if (record.type === 'reasoning.encrypted' && typeof record.data === 'string') {
-            return { ...record, data: '' };
+            return { ...record, data: ENCRYPTED_CONTENT_REDACTION };
         }
         return item;
     });
@@ -139,7 +147,8 @@ const redactEncryptedContent = (value) => {
         const record = value;
         const out = {};
         for (const [key, v] of Object.entries(record)) {
-            out[key] = key === 'encrypted_content' && typeof v === 'string' ? '' : redactEncryptedContent(v);
+            out[key] =
+                key === 'encrypted_content' && typeof v === 'string' ? ENCRYPTED_CONTENT_REDACTION : redactEncryptedContent(v);
         }
         return out;
     }
@@ -308,6 +317,12 @@ export async function summarizeReceivedTraffic(response) {
         // on-disk traffic artifact and passed to the winston debug log by
         // ProviderTraffic.recordResponseReceived, so it must be redacted here.
         const redactedParsed = redactEncryptedContent(parsed);
+        summary.wireShape =
+            Array.isArray(parsed.output) || asRecord(parsed.response)
+                ? 'responses'
+                : Array.isArray(parsed.choices)
+                    ? 'chat_completions'
+                    : 'unknown';
         if (!extractedText && !extractedReasoning && extractedToolCalls.length === 0 && !extractedId) {
             summary.fallbackBody = redactedParsed;
         }
@@ -329,6 +344,15 @@ export async function summarizeReceivedTraffic(response) {
     const toolArgsByKey = new Map();
     const toolKeyByIndex = new Map();
     const unknownFrameMap = new Map();
+    // The assembled payload is rendered in the wire shape it actually arrived in.
+    // Rendering a Responses stream as `choices[0].delta` (the old behaviour) hid
+    // exactly the things you open the log to check on that lane: whether
+    // reasoning items came back at all, and whether they carried encrypted
+    // content. See docs/plans/grok-responses-api.md.
+    let sawResponsesEvent = false;
+    let sawChatCompletionsFrame = false;
+    const responsesReasoningItems = [];
+    const responsesFunctionCallOrder = [];
     const blocks = raw.split(/\r?\n\r?\n/);
     for (const block of blocks) {
         const trimmed = block.trim();
@@ -364,6 +388,10 @@ export async function summarizeReceivedTraffic(response) {
         const response = asRecord(parsed.response);
         const choice = asRecord(parsed.choices?.[0]);
         const delta = asRecord(choice?.delta);
+        if (typeof parsed.type === 'string' && parsed.type.startsWith('response.'))
+            sawResponsesEvent = true;
+        if (Array.isArray(parsed.choices))
+            sawChatCompletionsFrame = true;
         sseResponseId =
             sseResponseId ?? firstDefinedString(parsed.id, response?.id, asRecord(choice?.message)?.id);
         const usageData = asRecord(parsed.usage) ?? asRecord(response?.usage);
@@ -414,6 +442,15 @@ export async function summarizeReceivedTraffic(response) {
                     if (typeof outputItem.call_id === 'string')
                         toolNameByKey.set(outputItem.call_id, name);
                 }
+                const callKey = firstDefinedString(outputItem.call_id, outputItem.id);
+                if (callKey && !responsesFunctionCallOrder.includes(callKey))
+                    responsesFunctionCallOrder.push(callKey);
+            }
+            if (outputItem.type === 'reasoning' && eventType.includes('done')) {
+                const itemId = typeof outputItem.id === 'string' ? outputItem.id : undefined;
+                if (!responsesReasoningItems.some((item) => item.id === itemId && itemId !== undefined)) {
+                    responsesReasoningItems.push(redactEncryptedContent(outputItem));
+                }
             }
             recognized = true;
         }
@@ -533,22 +570,56 @@ export async function summarizeReceivedTraffic(response) {
         };
     });
     summary.unknownFrames = [...unknownFrameMap.values()];
-    const hasAssembled = assembledContent !== undefined || assembledReasoning !== undefined || assembledToolCalls.length > 0;
+    const hasAssembled = assembledContent !== undefined ||
+        assembledReasoning !== undefined ||
+        assembledToolCalls.length > 0 ||
+        responsesReasoningItems.length > 0;
+    // Reasoning summary deltas are only worth re-emitting as their own item when
+    // the captured reasoning items didn't already carry the summary text.
+    const responsesReasoningItemsCarrySummary = responsesReasoningItems.some((item) => Array.isArray(item.summary) && item.summary.length > 0);
+    const wireShape = sawResponsesEvent
+        ? 'responses'
+        : sawChatCompletionsFrame
+            ? 'chat_completions'
+            : 'unknown';
+    summary.wireShape = wireShape;
     if (hasAssembled || sseResponseId || sseFinishReason || sseUsage) {
-        summary.payload = {
-            ...(sseResponseId ? { id: sseResponseId } : {}),
-            ...(sseUsage ? { usage: sseUsage } : {}),
-            choices: [
-                {
-                    ...(sseFinishReason ? { finish_reason: sseFinishReason } : {}),
-                    delta: {
-                        ...(assembledContent !== undefined ? { content: assembledContent } : {}),
-                        ...(assembledReasoning !== undefined ? { reasoning: assembledReasoning } : {}),
-                        ...(assembledToolCalls.length > 0 ? { tool_calls: assembledToolCalls } : {}),
-                    },
-                },
-            ],
-        };
+        summary.payload =
+            wireShape === 'responses'
+                ? {
+                    ...(sseResponseId ? { id: sseResponseId } : {}),
+                    ...(sseFinishReason ? { status: sseFinishReason } : {}),
+                    ...(sseUsage ? { usage: sseUsage } : {}),
+                    output: [
+                        ...responsesReasoningItems,
+                        ...(assembledReasoning !== undefined && !responsesReasoningItemsCarrySummary
+                            ? [{ type: 'reasoning', summary: [{ type: 'summary_text', text: assembledReasoning }] }]
+                            : []),
+                        ...(assembledContent !== undefined
+                            ? [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: assembledContent }] }]
+                            : []),
+                        ...assembledToolCalls.map((call) => ({
+                            type: 'function_call',
+                            call_id: call.id,
+                            ...(call.function.name !== undefined ? { name: call.function.name } : {}),
+                            arguments: call.function.arguments,
+                        })),
+                    ],
+                }
+                : {
+                    ...(sseResponseId ? { id: sseResponseId } : {}),
+                    ...(sseUsage ? { usage: sseUsage } : {}),
+                    choices: [
+                        {
+                            ...(sseFinishReason ? { finish_reason: sseFinishReason } : {}),
+                            delta: {
+                                ...(assembledContent !== undefined ? { content: assembledContent } : {}),
+                                ...(assembledReasoning !== undefined ? { reasoning: assembledReasoning } : {}),
+                                ...(assembledToolCalls.length > 0 ? { tool_calls: assembledToolCalls } : {}),
+                            },
+                        },
+                    ],
+                };
     }
     if (!summary.payload && summary.unknownFrames.length === 0) {
         summary.fallbackBody = raw;
@@ -564,65 +635,82 @@ export class ProviderTrafficArtifactStore {
     recordRequestStart(input) {
         const { dayDir, requestPath, sessionDirName } = this.#pathsFor(input);
         this.#requestPaths.set(input.requestId, requestPath);
-        const sentRecord = {
-            direction: 'sent',
-            requestId: input.requestId,
-            timestamp: input.timestamp,
-            provider: input.provider,
-            model: input.model,
-            ...(input.modelClass ? { modelClass: input.modelClass } : {}),
-            ...(input.modelWrapperClass ? { modelWrapperClass: input.modelWrapperClass } : {}),
-            sessionId: input.sessionId,
-            mode: input.mode ?? 'unknown',
-            ...(input.headers ? { headers: input.headers } : {}),
-            body: sanitizeSentTrafficBody(input.sentBody),
-        };
-        writeTrafficEnvelope(requestPath, { sent: sentRecord, received: emptyTrafficRecord() });
-        this.#upsertDailyIndex(dayDir, {
-            sessionId: input.sessionId,
-            sessionDir: sessionDirName,
-            firstRequestAt: input.timestamp,
-            lastRequestAt: input.timestamp,
-            requestCount: 1,
-            firstUserMessagePreview: normalizePreview(input.firstUserMessagePreview),
-            latestProvider: input.provider,
-            latestModel: input.model,
-            providersSeen: [input.provider],
-            modelsSeen: [input.model],
-            latestMode: input.mode ?? 'unknown',
-            modesSeen: [input.mode ?? 'unknown'],
-        });
+        try {
+            const sentRecord = {
+                direction: 'sent',
+                requestId: input.requestId,
+                timestamp: input.timestamp,
+                provider: input.provider,
+                model: input.model,
+                ...(input.modelClass ? { modelClass: input.modelClass } : {}),
+                ...(input.modelWrapperClass ? { modelWrapperClass: input.modelWrapperClass } : {}),
+                sessionId: input.sessionId,
+                mode: input.mode ?? 'unknown',
+                ...(input.headers ? { headers: input.headers } : {}),
+                body: sanitizeSentTrafficBody(input.sentBody),
+            };
+            writeTrafficEnvelope(requestPath, { sent: sentRecord, received: emptyTrafficRecord() });
+            this.#upsertDailyIndex(dayDir, {
+                sessionId: input.sessionId,
+                sessionDir: sessionDirName,
+                firstRequestAt: input.timestamp,
+                lastRequestAt: input.timestamp,
+                requestCount: 1,
+                firstUserMessagePreview: normalizePreview(input.firstUserMessagePreview),
+                latestProvider: input.provider,
+                latestModel: input.model,
+                providersSeen: [input.provider],
+                modelsSeen: [input.model],
+                latestMode: input.mode ?? 'unknown',
+                modesSeen: [input.mode ?? 'unknown'],
+            });
+        }
+        catch (error) {
+            // A start that did not fully land must not retain a stale correlation
+            // entry: a later completion falls back to #pathsFor and writes a fresh
+            // artifact instead of reusing a path the failed start never proved.
+            this.#requestPaths.delete(input.requestId);
+            throw error;
+        }
     }
     recordRequestComplete(input) {
         const { dayDir, requestPath: fallbackRequestPath, sessionDirName } = this.#pathsFor(input);
         const requestPath = this.#requestPaths.get(input.requestId) ?? fallbackRequestPath;
-        const receivedRecord = {
-            direction: 'received',
-            requestId: input.requestId,
-            timestamp: input.timestamp,
-            provider: input.provider,
-            model: input.model,
-            ...(input.modelClass ? { modelClass: input.modelClass } : {}),
-            ...(input.modelWrapperClass ? { modelWrapperClass: input.modelWrapperClass } : {}),
-            sessionId: input.sessionId,
-            mode: input.mode ?? 'unknown',
-            ...(input.receivedSummary ? { summary: input.receivedSummary } : {}),
-            ...(input.error ? { error: input.error } : {}),
-        };
-        const envelope = parseTrafficEnvelope(requestPath);
-        writeTrafficEnvelope(requestPath, {
-            sent: envelope.sent,
-            received: receivedRecord,
-        });
-        this.#requestPaths.delete(input.requestId);
-        this.#touchDailyIndex(dayDir, {
-            sessionId: input.sessionId,
-            sessionDir: sessionDirName,
-            lastRequestAt: input.timestamp,
-            latestProvider: input.provider,
-            latestModel: input.model,
-            latestMode: input.mode ?? 'unknown',
-        });
+        try {
+            const receivedRecord = {
+                direction: 'received',
+                requestId: input.requestId,
+                timestamp: input.timestamp,
+                provider: input.provider,
+                model: input.model,
+                ...(input.modelClass ? { modelClass: input.modelClass } : {}),
+                ...(input.modelWrapperClass ? { modelWrapperClass: input.modelWrapperClass } : {}),
+                sessionId: input.sessionId,
+                mode: input.mode ?? 'unknown',
+                ...(input.receivedSummary ? { summary: input.receivedSummary } : {}),
+                ...(input.error ? { error: input.error } : {}),
+            };
+            const envelope = parseTrafficEnvelope(requestPath);
+            writeTrafficEnvelope(requestPath, {
+                sent: envelope.sent,
+                received: receivedRecord,
+            });
+            this.#touchDailyIndex(dayDir, {
+                sessionId: input.sessionId,
+                sessionDir: sessionDirName,
+                lastRequestAt: input.timestamp,
+                latestProvider: input.provider,
+                latestModel: input.model,
+                latestMode: input.mode ?? 'unknown',
+            });
+        }
+        finally {
+            // Completion is the owner cleanup path for request correlation: the
+            // entry is released whether the artifact write succeeded or failed, so
+            // an abandoned or partially-written completion cannot leak map entries
+            // for the life of the process.
+            this.#requestPaths.delete(input.requestId);
+        }
     }
     #pathsFor(input) {
         const dateKey = input.timestamp.slice(0, 10);
@@ -640,11 +728,20 @@ export class ProviderTrafficArtifactStore {
         const indexPath = `${dayDir}/index.jsonl`;
         if (!fs.existsSync(indexPath))
             return [];
-        return fs
-            .readFileSync(indexPath, 'utf8')
-            .split('\n')
-            .filter((line) => line.trim())
-            .map((line) => JSON.parse(line));
+        const entries = [];
+        for (const line of fs.readFileSync(indexPath, 'utf8').split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // An unclean shutdown, disk-full write, or crash can leave a partial or
+            // malformed line behind. Recover by scanning and keeping only entries
+            // that parse as objects; the next index rewrite drops the bad lines.
+            const parsed = tryParseJson(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                entries.push(parsed);
+            }
+        }
+        return entries;
     }
     #writeDailyIndex(dayDir, entries) {
         fs.mkdirSync(dayDir, { recursive: true });
@@ -823,6 +920,33 @@ export class ProviderTraffic {
         this.sessionContextService = sessionContextService;
         this.store = store;
     }
+    /**
+     * Runs a diagnostic artifact-store operation, converting any store failure
+     * into exactly one structured warning so the primary provider operation
+     * proceeds unimpeded (Contract 07, C7.1). The warning itself must never
+     * throw back into the caller, so it carries its own residual boundary.
+     */
+    #runArtifactStoreOperation(operation, requestId, run) {
+        try {
+            run();
+        }
+        catch (error) {
+            try {
+                this.loggingService.warn('Provider traffic artifact write failed', {
+                    eventType: 'provider.traffic.artifact_write_failed',
+                    category: 'provider',
+                    phase: 'artifact_write',
+                    operation,
+                    requestId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            catch {
+                // Residual error boundary: if even the warning cannot be logged, the
+                // primary operation still must not fail.
+            }
+        }
+    }
     recordRequestStart(input) {
         const trafficContext = this.sessionContextService.getContext() ?? null;
         const isEvaluator = trafficContext?.evaluator === true;
@@ -833,20 +957,22 @@ export class ProviderTraffic {
         const mode = trafficContext?.mode ?? 'unknown';
         const firstUserMessagePreview = trafficContext?.firstUserMessagePreview;
         // 1. Write the sent request to artifact store directly
-        this.store.recordRequestStart({
-            requestId: input.requestId,
-            timestamp,
-            provider: input.provider,
-            model: input.model,
-            modelClass: input.modelClass,
-            modelWrapperClass: input.modelWrapperClass,
-            sessionId,
-            sessionStartedAt,
-            mode,
-            firstUserMessagePreview,
-            sentBody: input.sentBody,
-            headers: input.headers,
-            evaluator: isEvaluator,
+        this.#runArtifactStoreOperation('recordRequestStart', input.requestId, () => {
+            this.store.recordRequestStart({
+                requestId: input.requestId,
+                timestamp,
+                provider: input.provider,
+                model: input.model,
+                modelClass: input.modelClass,
+                modelWrapperClass: input.modelWrapperClass,
+                sessionId,
+                sessionStartedAt,
+                mode,
+                firstUserMessagePreview,
+                sentBody: input.sentBody,
+                headers: input.headers,
+                evaluator: isEvaluator,
+            });
         });
         const baseMeta = {
             requestId: input.requestId,
@@ -897,18 +1023,20 @@ export class ProviderTraffic {
         };
         if (input.error) {
             // 1. Write failure to artifact store
-            this.store.recordRequestComplete({
-                requestId: input.requestId,
-                timestamp,
-                provider: input.provider,
-                model: input.model,
-                modelClass: input.modelClass,
-                modelWrapperClass: input.modelWrapperClass,
-                sessionId,
-                sessionStartedAt,
-                mode,
-                error: input.error,
-                evaluator: isEvaluator,
+            this.#runArtifactStoreOperation('recordRequestComplete', input.requestId, () => {
+                this.store.recordRequestComplete({
+                    requestId: input.requestId,
+                    timestamp,
+                    provider: input.provider,
+                    model: input.model,
+                    modelClass: input.modelClass,
+                    modelWrapperClass: input.modelWrapperClass,
+                    sessionId,
+                    sessionStartedAt,
+                    mode,
+                    error: input.error,
+                    evaluator: isEvaluator,
+                });
             });
             // 2. Log failure to winston
             this.loggingService.error(`${input.provider} request failed`, {
@@ -964,19 +1092,26 @@ export class ProviderTraffic {
                 ...(text ? { text } : {}),
             };
         }
+        // The receive timing describes the exchange, not the payload, so it rides
+        // on the summary rather than being folded into any transport's parse.
+        if (input.receiveTiming) {
+            summary = { ...summary, receiveTiming: input.receiveTiming };
+        }
         // 1. Write complete payload to artifact store
-        this.store.recordRequestComplete({
-            requestId: input.requestId,
-            timestamp,
-            provider: input.provider,
-            model: input.model,
-            modelClass: input.modelClass,
-            modelWrapperClass: input.modelWrapperClass,
-            sessionId,
-            sessionStartedAt,
-            mode,
-            receivedSummary: summary,
-            evaluator: isEvaluator,
+        this.#runArtifactStoreOperation('recordRequestComplete', input.requestId, () => {
+            this.store.recordRequestComplete({
+                requestId: input.requestId,
+                timestamp,
+                provider: input.provider,
+                model: input.model,
+                modelClass: input.modelClass,
+                modelWrapperClass: input.modelWrapperClass,
+                sessionId,
+                sessionStartedAt,
+                mode,
+                receivedSummary: summary,
+                evaluator: isEvaluator,
+            });
         });
         // 2. Log response received via logging service for winston
         const summaryPayload = asRecord(summary.payload);
@@ -1007,21 +1142,30 @@ export class ProviderTraffic {
         const sessionStartedAt = trafficContext?.sessionStartedAt ?? timestamp;
         const mode = trafficContext?.mode ?? 'unknown';
         const firstUserMessagePreview = trafficContext?.firstUserMessagePreview;
-        const summary = { outcome: input.outcome, eventCount: input.eventCount };
-        this.store.recordRequestComplete({
-            requestId: input.requestId,
-            timestamp,
-            provider: input.provider,
-            model: input.model,
-            modelClass: input.modelClass,
-            modelWrapperClass: input.modelWrapperClass,
-            sessionId,
-            sessionStartedAt,
-            mode,
-            receivedSummary: summary,
-            evaluator: isEvaluator,
+        const summary = {
+            outcome: input.outcome,
+            eventCount: input.eventCount,
+            ...(input.diagnostics ? input.diagnostics : {}),
+        };
+        this.#runArtifactStoreOperation('recordRequestComplete', input.requestId, () => {
+            this.store.recordRequestComplete({
+                requestId: input.requestId,
+                timestamp,
+                provider: input.provider,
+                model: input.model,
+                modelClass: input.modelClass,
+                modelWrapperClass: input.modelWrapperClass,
+                sessionId,
+                sessionStartedAt,
+                mode,
+                receivedSummary: summary,
+                evaluator: isEvaluator,
+            });
         });
-        this.loggingService.debug(`${input.provider} response closed`, {
+        // The retained transcript belongs in the traffic artifact, not the app log.
+        const { events: _events, ...logSummary } = summary;
+        const logClosed = input.outcome === 'aborted' ? this.loggingService.warn : this.loggingService.debug;
+        logClosed.call(this.loggingService, `${input.provider} response closed`, {
             eventType: `${eventPrefix}.response.closed`,
             category: 'provider',
             phase: 'provider_response',
@@ -1036,7 +1180,7 @@ export class ProviderTraffic {
             model: input.model,
             modelClass: input.modelClass,
             modelWrapperClass: input.modelWrapperClass,
-            ...summary,
+            ...logSummary,
         });
     }
     recordRequestFailed(input) {
@@ -1070,19 +1214,26 @@ export class ProviderTraffic {
         if (input.wsMaxAttempts !== undefined) {
             errorDetails.wsMaxAttempts = input.wsMaxAttempts;
         }
+        // A transport-liveness timeout is only interpretable next to the budget it
+        // expired on, and the budget is user-configurable.
+        if (input.receiveTiming !== undefined) {
+            errorDetails.receiveTiming = input.receiveTiming;
+        }
         // 1. Write failure to artifact store
-        this.store.recordRequestComplete({
-            requestId: input.requestId,
-            timestamp,
-            provider: input.provider,
-            model: input.model,
-            modelClass: input.modelClass,
-            modelWrapperClass: input.modelWrapperClass,
-            sessionId,
-            sessionStartedAt,
-            mode,
-            error: errorDetails,
-            evaluator: isEvaluator,
+        this.#runArtifactStoreOperation('recordRequestComplete', input.requestId, () => {
+            this.store.recordRequestComplete({
+                requestId: input.requestId,
+                timestamp,
+                provider: input.provider,
+                model: input.model,
+                modelClass: input.modelClass,
+                modelWrapperClass: input.modelWrapperClass,
+                sessionId,
+                sessionStartedAt,
+                mode,
+                error: errorDetails,
+                evaluator: isEvaluator,
+            });
         });
         // 2. Log failure to winston
         this.loggingService.error(`${input.provider} request failed`, {