codex-multi-auth 1.2.0 → 1.2.2

package/dist/lib/request/response-handler.js

@@ -1,16 +1,515 @@
 import { createLogger, logRequest, LOGGING_ENABLED } from "../logger.js";
 import { PLUGIN_NAME } from "../constants.js";
+import { isRecord } from "../utils.js";
 const log = createLogger("response-handler");
 const MAX_SSE_SIZE = 10 * 1024 * 1024; // 10MB limit to prevent memory exhaustion
 const DEFAULT_STREAM_STALL_TIMEOUT_MS = 45_000;
+const MAX_SYNTHESIZED_EVENT_INDEX = 255;
+function createParsedResponseState() {
+    return {
+        finalResponse: null,
+        lastPhase: null,
+        outputItems: new Map(),
+        outputText: new Map(),
+        outputTextPhases: new Map(),
+        phaseTextSegments: new Map(),
+        phaseSegmentOrder: new Map(),
+        phaseText: new Map(),
+        reasoningSummaryText: new Map(),
+        seenResponseIds: new Set(),
+        encounteredError: false,
+    };
+}
+function toMutableRecord(value) {
+    return isRecord(value) ? { ...value } : null;
+}
+function getNumberField(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+ * Read a trimmed, non-empty string field for identifier-like values.
+ *
+ * For textual payloads where whitespace is meaningful, use a field-specific
+ * accessor such as `getDeltaField` instead of reusing this helper.
+ */
+function getStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function getDeltaField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isValidSynthesizedIndex(index) {
+    return (index !== null &&
+        Number.isInteger(index) &&
+        index >= 0 &&
+        index <= MAX_SYNTHESIZED_EVENT_INDEX);
+}
+function cloneContentArray(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter(isRecord).map((part) => ({ ...part }));
+}
+function mergeRecord(base, update) {
+    if (!base)
+        return { ...update };
+    const merged = { ...base, ...update };
+    if ("content" in update || "content" in base) {
+        const updateContent = cloneContentArray(update.content);
+        merged.content =
+            updateContent.length > 0 || !("content" in base)
+                ? updateContent
+                : cloneContentArray(base.content);
+    }
+    return merged;
+}
+function makeOutputTextKey(outputIndex, contentIndex) {
+    if (!isValidSynthesizedIndex(outputIndex) ||
+        !isValidSynthesizedIndex(contentIndex)) {
+        return null;
+    }
+    return `${outputIndex}:${contentIndex}`;
+}
+function makePhaseTextSegmentKey(phase, outputTextKey) {
+    return `${phase}\u0000${outputTextKey}`;
+}
+function makeSummaryKey(outputIndex, summaryIndex) {
+    if (!isValidSynthesizedIndex(outputIndex) ||
+        !isValidSynthesizedIndex(summaryIndex)) {
+        return null;
+    }
+    return `${outputIndex}:${summaryIndex}`;
+}
+function getPartText(part) {
+    if (!isRecord(part))
+        return null;
+    const text = getStringField(part, "text");
+    if (text)
+        return text;
+    return null;
+}
+function capturePhase(state, phase) {
+    if (typeof phase !== "string" || phase.trim().length === 0)
+        return;
+    state.lastPhase = phase.trim();
+}
+function rememberPhaseSegmentOrder(state, phase, segmentKey) {
+    const existingOrder = state.phaseSegmentOrder.get(phase);
+    if (existingOrder?.includes(segmentKey)) {
+        return existingOrder;
+    }
+    const nextOrder = [...(existingOrder ?? []), segmentKey];
+    state.phaseSegmentOrder.set(phase, nextOrder);
+    return nextOrder;
+}
+function removePhaseSegmentOrder(state, phase, segmentKey) {
+    const existingOrder = state.phaseSegmentOrder.get(phase);
+    if (!existingOrder)
+        return;
+    const nextOrder = existingOrder.filter((key) => key !== segmentKey);
+    if (nextOrder.length === 0) {
+        state.phaseSegmentOrder.delete(phase);
+        return;
+    }
+    state.phaseSegmentOrder.set(phase, nextOrder);
+}
+function rebuildPhaseText(state, phase) {
+    const orderedKeys = state.phaseSegmentOrder.get(phase) ?? [];
+    const text = orderedKeys
+        .map((key) => state.phaseTextSegments.get(key) ?? "")
+        .filter((value) => value.length > 0)
+        .join("");
+    if (text.length === 0) {
+        state.phaseText.delete(phase);
+        return;
+    }
+    state.phaseText.set(phase, text);
+}
+function setPhaseTextSegment(state, phase, outputTextKey, text) {
+    const normalizedPhase = typeof phase === "string" && phase.trim().length > 0
+        ? phase.trim()
+        : state.outputTextPhases.get(outputTextKey) ?? null;
+    if (!normalizedPhase)
+        return;
+    state.outputTextPhases.set(outputTextKey, normalizedPhase);
+    state.lastPhase = normalizedPhase;
+    const segmentKey = makePhaseTextSegmentKey(normalizedPhase, outputTextKey);
+    if (!text || text.length === 0) {
+        state.phaseTextSegments.delete(segmentKey);
+        removePhaseSegmentOrder(state, normalizedPhase, segmentKey);
+        rebuildPhaseText(state, normalizedPhase);
+        return;
+    }
+    rememberPhaseSegmentOrder(state, normalizedPhase, segmentKey);
+    state.phaseTextSegments.set(segmentKey, text);
+    rebuildPhaseText(state, normalizedPhase);
+}
+function appendPhaseTextSegment(state, phase, outputTextKey, delta) {
+    if (!delta || delta.length === 0) {
+        return;
+    }
+    const normalizedPhase = typeof phase === "string" && phase.trim().length > 0
+        ? phase.trim()
+        : state.outputTextPhases.get(outputTextKey) ?? null;
+    if (!normalizedPhase)
+        return;
+    state.outputTextPhases.set(outputTextKey, normalizedPhase);
+    state.lastPhase = normalizedPhase;
+    const segmentKey = makePhaseTextSegmentKey(normalizedPhase, outputTextKey);
+    const phaseOrder = rememberPhaseSegmentOrder(state, normalizedPhase, segmentKey);
+    const existing = state.phaseTextSegments.get(segmentKey) ?? "";
+    state.phaseTextSegments.set(segmentKey, `${existing}${delta}`);
+    if (phaseOrder[phaseOrder.length - 1] === segmentKey) {
+        const existingPhaseText = state.phaseText.get(normalizedPhase) ?? "";
+        state.phaseText.set(normalizedPhase, `${existingPhaseText}${delta}`);
+        return;
+    }
+    rebuildPhaseText(state, normalizedPhase);
+}
+function upsertOutputItem(state, outputIndex, item) {
+    if (!isValidSynthesizedIndex(outputIndex) || !isRecord(item))
+        return;
+    const current = state.outputItems.get(outputIndex) ?? null;
+    const merged = mergeRecord(current, item);
+    state.outputItems.set(outputIndex, merged);
+    capturePhase(state, merged.phase);
+}
+function setOutputTextValue(state, outputIndex, contentIndex, text, phase = undefined) {
+    const key = makeOutputTextKey(outputIndex, contentIndex);
+    if (!key)
+        return;
+    if (!text) {
+        state.outputText.delete(key);
+        setPhaseTextSegment(state, phase, key, null);
+        return;
+    }
+    state.outputText.set(key, text);
+    setPhaseTextSegment(state, phase, key, text);
+}
+function appendOutputTextValue(state, outputIndex, contentIndex, delta, phase = undefined) {
+    if (!delta)
+        return;
+    const key = makeOutputTextKey(outputIndex, contentIndex);
+    if (!key)
+        return;
+    const existing = state.outputText.get(key) ?? "";
+    state.outputText.set(key, `${existing}${delta}`);
+    appendPhaseTextSegment(state, phase, key, delta);
+}
+function setReasoningSummaryValue(state, outputIndex, summaryIndex, text) {
+    const key = makeSummaryKey(outputIndex, summaryIndex);
+    if (!key)
+        return;
+    if (!text) {
+        state.reasoningSummaryText.delete(key);
+        return;
+    }
+    state.reasoningSummaryText.set(key, text);
+}
+function appendReasoningSummaryValue(state, outputIndex, summaryIndex, delta) {
+    if (!delta)
+        return;
+    const key = makeSummaryKey(outputIndex, summaryIndex);
+    if (!key)
+        return;
+    const existing = state.reasoningSummaryText.get(key) ?? "";
+    state.reasoningSummaryText.set(key, `${existing}${delta}`);
+}
+function ensureOutputItemAtIndex(output, index) {
+    if (!isValidSynthesizedIndex(index))
+        return null;
+    while (output.length <= index) {
+        output.push({});
+    }
+    const current = output[index];
+    if (!isRecord(current)) {
+        output[index] = {};
+    }
+    return isRecord(output[index]) ? output[index] : null;
+}
+function ensureContentPartAtIndex(item, index) {
+    if (!isValidSynthesizedIndex(index))
+        return null;
+    const content = Array.isArray(item.content) ? [...item.content] : [];
+    while (content.length <= index) {
+        content.push({});
+    }
+    const current = content[index];
+    if (!isRecord(current)) {
+        content[index] = {};
+    }
+    item.content = content;
+    return isRecord(content[index]) ? content[index] : null;
+}
+function applyAccumulatedOutputText(response, state) {
+    if (state.outputText.size === 0)
+        return;
+    const output = Array.isArray(response.output) ? [...response.output] : [];
+    for (const [key, text] of state.outputText.entries()) {
+        const [outputIndexText, contentIndexText] = key.split(":");
+        const outputIndex = Number.parseInt(outputIndexText ?? "", 10);
+        const contentIndex = Number.parseInt(contentIndexText ?? "", 10);
+        if (!isValidSynthesizedIndex(outputIndex) ||
+            !isValidSynthesizedIndex(contentIndex)) {
+            continue;
+        }
+        const item = ensureOutputItemAtIndex(output, outputIndex);
+        if (!item)
+            continue;
+        const part = ensureContentPartAtIndex(item, contentIndex);
+        if (!part)
+            continue;
+        if (!getStringField(part, "type")) {
+            part.type = "output_text";
+        }
+        if (typeof part.text === "string") {
+            setPhaseTextSegment(state, part.phase, key, part.text);
+            continue;
+        }
+        part.text = text;
+    }
+    if (output.length > 0) {
+        response.output = output;
+    }
+}
+function mergeOutputItemsIntoResponse(response, state) {
+    if (state.outputItems.size === 0)
+        return;
+    const output = Array.isArray(response.output) ? [...response.output] : [];
+    for (const [outputIndex, item] of state.outputItems.entries()) {
+        if (!isValidSynthesizedIndex(outputIndex))
+            continue;
+        while (output.length <= outputIndex) {
+            output.push({});
+        }
+        output[outputIndex] = mergeRecord(toMutableRecord(output[outputIndex]), item);
+    }
+    response.output = output;
+}
+function collectMessageOutputText(output) {
+    return output
+        .filter(isRecord)
+        .map((item) => {
+        if (item.type !== "message")
+            return "";
+        const content = Array.isArray(item.content) ? item.content : [];
+        return content
+            .filter(isRecord)
+            .map((part) => {
+            if (part.type !== "output_text")
+                return "";
+            return typeof part.text === "string" ? part.text : "";
+        })
+            .join("");
+    })
+        .filter((text) => text.length > 0)
+        .join("");
+}
+function collectReasoningSummaryText(output) {
+    return output
+        .filter(isRecord)
+        .map((item) => {
+        if (item.type !== "reasoning")
+            return "";
+        const summary = Array.isArray(item.summary) ? item.summary : [];
+        return summary
+            .filter(isRecord)
+            .map((part) => (typeof part.text === "string" ? part.text : ""))
+            .filter((text) => text.length > 0)
+            .join("\n\n");
+    })
+        .filter((text) => text.length > 0)
+        .join("\n\n");
+}
+function applyReasoningSummaries(response, state) {
+    if (state.reasoningSummaryText.size === 0)
+        return;
+    const output = Array.isArray(response.output) ? [...response.output] : [];
+    for (const [key, text] of state.reasoningSummaryText.entries()) {
+        const [outputIndexText, summaryIndexText] = key.split(":");
+        const outputIndex = Number.parseInt(outputIndexText ?? "", 10);
+        const summaryIndex = Number.parseInt(summaryIndexText ?? "", 10);
+        if (!isValidSynthesizedIndex(outputIndex) ||
+            !isValidSynthesizedIndex(summaryIndex)) {
+            continue;
+        }
+        const item = ensureOutputItemAtIndex(output, outputIndex);
+        if (!item)
+            continue;
+        const summary = Array.isArray(item.summary) ? [...item.summary] : [];
+        while (summary.length <= summaryIndex) {
+            summary.push({});
+        }
+        const current = summary[summaryIndex];
+        const nextPart = isRecord(current) ? { ...current } : {};
+        if (!getStringField(nextPart, "type")) {
+            nextPart.type = "summary_text";
+        }
+        if (typeof nextPart.text === "string") {
+            continue;
+        }
+        nextPart.text = text;
+        summary[summaryIndex] = nextPart;
+        item.summary = summary;
+        if (!getStringField(item, "type")) {
+            item.type = "reasoning";
+        }
+    }
+    if (output.length > 0) {
+        response.output = output;
+    }
+}
+function finalizeParsedResponse(state) {
+    const response = state.finalResponse ? { ...state.finalResponse } : null;
+    if (!response)
+        return null;
+    if (state.encounteredError)
+        return null;
+    mergeOutputItemsIntoResponse(response, state);
+    applyAccumulatedOutputText(response, state);
+    applyReasoningSummaries(response, state);
+    const output = Array.isArray(response.output) ? response.output : [];
+    if (typeof response.output_text !== "string") {
+        const outputText = collectMessageOutputText(output);
+        if (outputText.length > 0) {
+            response.output_text = outputText;
+        }
+    }
+    const reasoningSummaryText = collectReasoningSummaryText(output);
+    if (reasoningSummaryText.length > 0 &&
+        typeof response.reasoning_summary_text !== "string") {
+        response.reasoning_summary_text = reasoningSummaryText;
+    }
+    if (state.lastPhase && typeof response.phase !== "string") {
+        response.phase = state.lastPhase;
+    }
+    if (state.phaseText.size > 0) {
+        const phaseText = {};
+        for (const [phase, text] of state.phaseText.entries()) {
+            phaseText[phase] = text;
+            if (phase === "commentary")
+                response.commentary_text = text;
+            if (phase === "final_answer")
+                response.final_answer_text = text;
+        }
+        response.phase_text = phaseText;
+    }
+    return response;
+}
+function extractResponseId(response) {
+    if (!response || typeof response !== "object")
+        return null;
+    const candidate = response.id;
+    return typeof candidate === "string" && candidate.trim().length > 0
+        ? candidate.trim()
+        : null;
+}
+function notifyResponseId(state, onResponseId, response) {
+    const responseId = extractResponseId(response);
+    if (!responseId || !onResponseId || state.seenResponseIds.has(responseId))
+        return;
+    state.seenResponseIds.add(responseId);
+    try {
+        onResponseId(responseId);
+    }
+    catch (error) {
+        log.warn("Failed to persist response id from upstream event", {
+            error: String(error),
+            responseId,
+        });
+    }
+}
+function truncateDiagnosticText(value, maxLength = 400) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    return trimmed.length > maxLength ? `${trimmed.slice(0, maxLength)}...` : trimmed;
+}
+function logStreamDiagnostics(finalResponse) {
+    if (!LOGGING_ENABLED || !isRecord(finalResponse)) {
+        return;
+    }
+    const responseId = extractResponseId(finalResponse);
+    const phase = getStringField(finalResponse, "phase");
+    const commentaryText = truncateDiagnosticText(finalResponse.commentary_text);
+    const finalAnswerText = truncateDiagnosticText(finalResponse.final_answer_text);
+    const reasoningSummaryText = truncateDiagnosticText(finalResponse.reasoning_summary_text);
+    if (phase || commentaryText || finalAnswerText || reasoningSummaryText) {
+        logRequest("stream-diagnostics", {
+            ...(responseId ? { responseId } : {}),
+            ...(phase ? { phase } : {}),
+            ...(commentaryText ? { commentaryText } : {}),
+            ...(finalAnswerText ? { finalAnswerText } : {}),
+            ...(reasoningSummaryText ? { reasoningSummaryText } : {}),
+        });
+    }
+}
+function maybeCaptureResponseEvent(state, data, onResponseId) {
+    if (data.type === "error") {
+        log.error("SSE error event received", { error: data });
+        state.encounteredError = true;
+        return;
+    }
+    if (data.type === "response.done" || data.type === "response.completed") {
+        if (isRecord(data.response)) {
+            state.finalResponse = { ...data.response };
+        }
+        notifyResponseId(state, onResponseId, data.response);
+        return;
+    }
+    const eventRecord = toMutableRecord(data);
+    if (!eventRecord)
+        return;
+    const outputIndex = getNumberField(eventRecord, "output_index");
+    if (data.type === "response.output_item.added" || data.type === "response.output_item.done") {
+        upsertOutputItem(state, outputIndex, eventRecord.item);
+        return;
+    }
+    if (data.type === "response.output_text.delta") {
+        appendOutputTextValue(state, outputIndex, getNumberField(eventRecord, "content_index"), getDeltaField(eventRecord, "delta"), eventRecord.phase);
+        return;
+    }
+    if (data.type === "response.output_text.done") {
+        setOutputTextValue(state, outputIndex, getNumberField(eventRecord, "content_index"), getStringField(eventRecord, "text"), eventRecord.phase);
+        return;
+    }
+    if (data.type === "response.content_part.added" || data.type === "response.content_part.done") {
+        const part = toMutableRecord(eventRecord.part);
+        if (!part || getStringField(part, "type") !== "output_text") {
+            capturePhase(state, part?.phase);
+            return;
+        }
+        setOutputTextValue(state, outputIndex, getNumberField(eventRecord, "content_index"), getPartText(part), part.phase);
+        return;
+    }
+    if (data.type === "response.reasoning_summary_text.delta") {
+        appendReasoningSummaryValue(state, outputIndex, getNumberField(eventRecord, "summary_index"), getDeltaField(eventRecord, "delta"));
+        return;
+    }
+    if (data.type === "response.reasoning_summary_text.done") {
+        setReasoningSummaryValue(state, outputIndex, getNumberField(eventRecord, "summary_index"), getStringField(eventRecord, "text"));
+        return;
+    }
+    if (data.type === "response.reasoning_summary_part.added" ||
+        data.type === "response.reasoning_summary_part.done") {
+        setReasoningSummaryValue(state, outputIndex, getNumberField(eventRecord, "summary_index"), getPartText(eventRecord.part));
+        return;
+    }
+    capturePhase(state, eventRecord.phase);
+}
 /**
 
  * Parse SSE stream to extract final response
  * @param sseText - Complete SSE stream text
  * @returns Final response object or null if not found
  */
-function parseSseStream(sseText) {
+function parseSseStream(sseText, onResponseId) {
     const lines = sseText.split(/\r?\n/);
+    const state = createParsedResponseState();
     for (const line of lines) {
         const trimmedLine = line.trim();
         if (trimmedLine.startsWith('data: ')) {
@@ -19,20 +518,16 @@ function parseSseStream(sseText) {
                 continue;
             try {
                 const data = JSON.parse(payload);
-                if (data.type === 'error') {
-                    log.error("SSE error event received", { error: data });
+                maybeCaptureResponseEvent(state, data, onResponseId);
+                if (state.encounteredError)
                     return null;
-                }
-                if (data.type === 'response.done' || data.type === 'response.completed') {
-                    return data.response;
-                }
             }
             catch {
                 // Skip malformed JSON
             }
         }
     }
-    return null;
+    return finalizeParsedResponse(state);
 }
 /**
  * Convert SSE stream response to JSON for generateText()
@@ -63,10 +558,12 @@ export async function convertSseToJson(response, headers, options) {
             logRequest("stream-full", { fullContent: fullText });
         }
         // Parse SSE events to extract the final response
-        const finalResponse = parseSseStream(fullText);
+        const finalResponse = parseSseStream(fullText, options?.onResponseId);
         if (!finalResponse) {
             log.warn("Could not find final response in SSE stream");
-            logRequest("stream-error", { error: "No response.done event found" });
+            logRequest("stream-error", {
+                error: "No terminal response event found in SSE stream",
+            });
             // Return original stream if we can't parse
             return new Response(fullText, {
                 status: response.status,
@@ -74,6 +571,7 @@ export async function convertSseToJson(response, headers, options) {
                 headers: headers,
             });
         }
+        logStreamDiagnostics(finalResponse);
         // Return as plain JSON (not SSE)
         const jsonHeaders = new Headers(headers);
         jsonHeaders.set('content-type', 'application/json; charset=utf-8');
@@ -96,6 +594,50 @@ export async function convertSseToJson(response, headers, options) {
         reader.releaseLock();
     }
 }
+function createResponseIdCapturingStream(body, onResponseId) {
+    const decoder = new TextDecoder();
+    let bufferedText = "";
+    const state = createParsedResponseState();
+    const processBufferedLines = (flush = false) => {
+        if (state.encounteredError)
+            return;
+        const lines = bufferedText.split(/\r?\n/);
+        if (!flush) {
+            bufferedText = lines.pop() ?? "";
+        }
+        else {
+            bufferedText = "";
+        }
+        for (const rawLine of lines) {
+            const trimmedLine = rawLine.trim();
+            if (!trimmedLine.startsWith("data: "))
+                continue;
+            const payload = trimmedLine.slice(6).trim();
+            if (!payload || payload === "[DONE]")
+                continue;
+            try {
+                const data = JSON.parse(payload);
+                maybeCaptureResponseEvent(state, data, onResponseId);
+                if (state.encounteredError)
+                    break;
+            }
+            catch {
+                // Ignore malformed SSE lines and keep forwarding the raw stream.
+            }
+        }
+    };
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            bufferedText += decoder.decode(chunk, { stream: true });
+            processBufferedLines();
+            controller.enqueue(chunk);
+        },
+        flush() {
+            bufferedText += decoder.decode();
+            processBufferedLines(true);
+        },
+    }));
+}
 /**
  * Ensure response has content-type header
  * @param headers - Response headers
@@ -115,7 +657,7 @@ async function readWithTimeout(reader, timeoutMs) {
             reader.read(),
             new Promise((_, reject) => {
                 timeoutId = setTimeout(() => {
-                    reject(new Error(`SSE stream stalled for ${timeoutMs}ms while waiting for response.done`));
+                    reject(new Error(`SSE stream stalled for ${timeoutMs}ms while waiting for a terminal response event`));
                 }, timeoutMs);
             }),
         ]);
@@ -152,4 +694,18 @@ export function isEmptyResponse(body) {
     }
     return false;
 }
+export function attachResponseIdCapture(response, headers, onResponseId) {
+    if (!response.body || !onResponseId) {
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    return new Response(createResponseIdCapturingStream(response.body, onResponseId), {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
 //# sourceMappingURL=response-handler.js.map