@bitkyc08/opencodex 2.44.0 → 2.45.0

package/src/chat/outbound.ts

@@ -8,7 +8,11 @@
 type Rec = Record<string, unknown>;
 
 import { decodeServerSentEvents, sseFieldValue } from "../lib/sse-decoder";
-import { isTranslatorBudgetExceededError, type TranslatorBudget } from "../lib/translator-budget";
+import {
+  isTranslatorBudgetExceededError,
+  type TranslatorBudget,
+  type TranslatorTransientReservation,
+} from "../lib/translator-budget";
 import {
   classifyError,
   cyberPolicyErrorType,
@@ -156,6 +160,14 @@ function appendedUtf8Bytes(previous: string, previousBytes: number, fragment: st
   return nextBytes;
 }
 
+function refusalTranslationError(): ChatCompletionsStreamError {
+  // Never include provider-controlled refusal text or correlation IDs in diagnostics.
+  return new ChatCompletionsStreamError("upstream refusal representations are inconsistent", {
+    type: "upstream_error",
+    code: "invalid_refusal",
+  });
+}
+
 /**
  * Streaming: Responses SSE bytes -> Chat Completions SSE bytes.
  */
@@ -188,6 +200,125 @@ export function responsesSseToChatCompletionsSse(
   let emittedFrames = 0;
   let stepping = false;
   let decoderStarted = false;
+  // Raw output/content positions are the ordering authority; IDs only constrain identity.
+  // Charge a fixed entry allowance as well as keys/IDs so empty parts remain bounded.
+  const refusalEntryBytes = 64;
+  const refusalItems = new Map<number, {
+    id?: string;
+    parts: Map<number, { text: string; bytes: number; present: boolean }>;
+  }>();
+  const refusalIndexById = new Map<string, number>();
+  let refusalMetadataBytes = 0;
+  let refusalTextBytes = 0;
+  const releaseRefusals = () => {
+    refusalItems.clear();
+    refusalIndexById.clear();
+    translatorBudget.releaseRetained(refusalMetadataBytes, { kind: "item_ids" });
+    translatorBudget.releaseRetained(refusalTextBytes, { kind: "retained_collectors" });
+    refusalMetadataBytes = 0;
+    refusalTextBytes = 0;
+  };
+  const position = (value: unknown): number => {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+      throw refusalTranslationError();
+    }
+    return value;
+  };
+  const chargeRefusalMetadata = (bytes: number) => {
+    translatorBudget.chargeRetained(bytes, { kind: "item_ids" });
+    refusalMetadataBytes += bytes;
+  };
+  const refusalItem = (outputIndex: unknown, source: Rec, idField: string) => {
+    const index = position(outputIndex);
+    const hasId = Object.hasOwn(source, idField);
+    const candidate = source[idField];
+    if (hasId && typeof candidate !== "string") throw refusalTranslationError();
+    let item = refusalItems.get(index);
+    if (!item) {
+      chargeRefusalMetadata(refusalEntryBytes + Buffer.byteLength(String(index)));
+      item = { parts: new Map() };
+      refusalItems.set(index, item);
+    }
+    if (hasId && typeof candidate === "string") {
+      const knownIndex = refusalIndexById.get(candidate);
+      if (knownIndex !== undefined && knownIndex !== index) throw refusalTranslationError();
+      if (item.id !== undefined && item.id !== candidate) throw refusalTranslationError();
+      if (item.id === undefined) {
+        chargeRefusalMetadata(refusalEntryBytes + Buffer.byteLength(candidate));
+        item.id = candidate;
+        refusalIndexById.set(candidate, index);
+      }
+    }
+    return item;
+  };
+  const retainRefusal = (outputIndex: unknown, contentIndex: unknown, source: Rec,
+    idField: string, evidence: Rec, field: string, delta = false) => {
+    const item = refusalItem(outputIndex, source, idField);
+    const index = position(contentIndex);
+    let part = item.parts.get(index);
+    if (!part) {
+      chargeRefusalMetadata(refusalEntryBytes + Buffer.byteLength(String(index)));
+      part = { text: "", bytes: 0, present: false };
+      item.parts.set(index, part);
+    }
+    if (!Object.hasOwn(evidence, field)) {
+      if (delta) throw refusalTranslationError();
+      return;
+    }
+    const candidate = evidence[field];
+    if (typeof candidate !== "string") throw refusalTranslationError();
+    part.present = true;
+    if (!delta) {
+      // Equal, empty, and stale-prefix snapshots add no evidence; never erase deltas.
+      if (part.text.startsWith(candidate)) return;
+      if (!candidate.startsWith(part.text)) throw refusalTranslationError();
+    }
+    const nextBytes = delta ? appendedUtf8Bytes(part.text, part.bytes, candidate) : Buffer.byteLength(candidate);
+    const reservation = translatorBudget.reserveTransient(nextBytes, { kind: "retained_collectors" });
+    try {
+      const next = delta ? part.text + candidate : candidate;
+      reservation.commitRetained();
+      translatorBudget.releaseRetained(part.bytes, { kind: "retained_collectors" });
+      refusalTextBytes += nextBytes - part.bytes;
+      part.text = next;
+      part.bytes = nextBytes;
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+  };
+  const snapshotRefusalItem = (outputIndex: unknown, item: Rec) => {
+    const existing = typeof outputIndex === "number" ? refusalItems.get(outputIndex) : undefined;
+    // Sparse final snapshots may omit type/content but cannot change a known ID.
+    if (Object.hasOwn(item, "id")
+      && (existing || (typeof item.id === "string" && refusalIndexById.has(item.id)))) {
+      refusalItem(outputIndex, item, "id");
+    }
+    if (item.type !== "message") {
+      if (existing && existing.parts.size > 0 && item.type !== undefined) throw refusalTranslationError();
+      return;
+    }
+    // Unrelated sparse text messages historically need no position metadata.
+    if (outputIndex === undefined && (!Array.isArray(item.content)
+      || !item.content.some(part => isRec(part) && part.type === "refusal"))) return;
+    const known = refusalItem(outputIndex, item, "id");
+    if (!Array.isArray(item.content)) return;
+    item.content.forEach((part: unknown, contentIndex: number) => {
+      if (!isRec(part)) return;
+      if (part.type === "refusal") {
+        retainRefusal(outputIndex, contentIndex, item, "id", part, "refusal");
+      } else if (part.type !== undefined && known.parts.has(contentIndex)) {
+        throw refusalTranslationError();
+      }
+    });
+  };
+  const snapshotRefusals = (response: Rec) => {
+    if (!Array.isArray(response.output)) return;
+    response.output.forEach((item: unknown, outputIndex: number) => {
+      if (isRec(item)) snapshotRefusalItem(outputIndex, item);
+    });
+  };
+  let terminalBatch: Array<{ frame: Uint8Array; reservation: TranslatorTransientReservation }> | undefined;
   const queuedLiveFrameBytes: number[] = [];
   const enqueueLiveFrame = (frame: Uint8Array) => {
     const reservation = translatorBudget.reserveTransient(frame.byteLength, { kind: "live_transient" });
@@ -235,8 +366,20 @@ export function responsesSseToChatCompletionsSse(
   };
       const emit = (payload: Rec | "[DONE]") => {
         if (failed) return;
-        enqueueLiveFrame(encoder.encode(dataFrame(payload)));
-        emittedFrames++;
+        if (terminalBatch) {
+          const serialized = dataFrame(payload);
+          const stringReservation = translatorBudget.reserveTransient(Buffer.byteLength(serialized), { kind: "live_transient" });
+          try {
+            const frame = encoder.encode(serialized);
+            const reservation = translatorBudget.reserveTransient(frame.byteLength, { kind: "live_transient" });
+            terminalBatch.push({ frame, reservation });
+          } finally {
+            stringReservation.release();
+          }
+        } else {
+          enqueueLiveFrame(encoder.encode(dataFrame(payload)));
+          emittedFrames++;
+        }
       };
       const ensureRole = () => {
         if (started) return;
@@ -298,38 +441,68 @@ export function responsesSseToChatCompletionsSse(
       };
       const finish = (finishReason: string, usage: unknown) => {
         if (terminated) return;
-        // A valid completed/incomplete terminal frame may arrive without output_item.done.
-        // Preserve any known tool call before emitting its finish reason.
-        flushPendingToolCalls();
+        // Admit every pending role/tool/refusal/finish/DONE frame before exposing any
+        // of this terminal batch. Serialization and encoded bytes coexist and both count.
+        const batch: NonNullable<typeof terminalBatch> = [];
+        terminalBatch = batch;
+        try {
+          flushPendingToolCalls();
+          ensureRole();
+          for (const [, item] of [...refusalItems.entries()].sort(([a], [b]) => a - b)) {
+            for (const [, part] of [...item.parts.entries()].sort(([a], [b]) => a - b)) {
+              if (!part.present) continue;
+              const refusal = chunkBase(id, model, created);
+              refusal.choices = [{ index: 0, delta: { refusal: part.text }, finish_reason: null }];
+              emit(refusal);
+            }
+          }
+          const frame = chunkBase(id, model, created);
+          frame.choices = [{ index: 0, delta: {}, finish_reason: finishReason }];
+          if (usage) frame.usage = chatCompletionsUsage(usage);
+          emit(frame);
+          emit("[DONE]");
+        } catch (error) {
+          for (const staged of batch) staged.reservation.release();
+          throw error;
+        } finally {
+          terminalBatch = undefined;
+        }
+        for (const staged of batch) {
+          controller.enqueue(staged.frame);
+          staged.reservation.commitRetained();
+          queuedLiveFrameBytes.push(staged.frame.byteLength);
+          emittedFrames++;
+        }
         terminated = true;
-        ensureRole();
-        const frame = chunkBase(id, model, created);
-        frame.choices = [{ index: 0, delta: {}, finish_reason: finishReason }];
-        if (usage) frame.usage = chatCompletionsUsage(usage);
-        emit(frame);
-        emit("[DONE]");
+        releaseRefusals();
       };
       const fail = (message: string, details?: { code?: string | null; type?: string; status?: number }) => {
         if (terminated) return;
         terminated = true;
         failed = true;
+        releaseRefusals();
+        closeToolCalls();
+        upstreamAbort.abort(new Error("upstream chat translation failed"));
+        try { void sseIterator?.return(undefined).catch(() => {}); } catch { /* already closed */ }
         // OpenAI-compatible clients need a real error event, not a success completion
         // that embeds `[error] ...` text followed by a clean [DONE].
         // Deliver the error frame then close the stream abnormally (no [DONE]).
         // Do not controller.error() — that can drop already-enqueued bytes from consumers
         // like response.text().
-        const safeMessage = redactSecretString(message);
+        const translatorOverflow = details?.code === "translation_buffer_limit";
+        const safeMessage = translatorOverflow ? "upstream translation buffer exceeded the safe limit"
+          : details?.code === "invalid_refusal" ? "upstream refusal representations are inconsistent"
+          : redactSecretString(message);
         const statusHint = details?.status ?? streamErrorStatus(safeMessage);
         const classified = classifyError(statusHint, details?.type ?? "upstream_error", safeMessage);
-        const translatorOverflow = details?.code === "translation_buffer_limit";
         if (translatorOverflow) {
-          upstreamAbort.abort(new Error("upstream translation buffer exceeded the safe limit"));
-          closeToolCalls();
-          try { void sseIterator?.return(undefined).catch(() => {}); } catch { /* already closed */ }
           classified.code = "translation_buffer_limit";
           // Provider-controlled overflow is an upstream failure on every path:
           // streaming frame, collector, and defensive JSON agree on 502.
           classified.type = "upstream_error";
+        } else if (details?.code === "invalid_refusal") {
+          classified.code = details.code;
+          classified.type = "upstream_error";
         } else if (isCyberPolicyCode(details?.code) || classified.code === CYBER_POLICY_ERROR_CODE) {
           classified.code = CYBER_POLICY_ERROR_CODE;
           classified.type = cyberPolicyErrorType(details?.type);
@@ -345,9 +518,9 @@ export function responsesSseToChatCompletionsSse(
               code: classified.code,
             },
           }));
-          // The budget is already exhausted. This bounded emergency frame is the sole
-          // typed overflow closure and therefore cannot reserve from that budget again.
-          if (translatorOverflow) controller.enqueue(frame);
+          // These fixed, bounded failures must survive even when decoder-owned input
+          // still fills the budget. They contain no provider text or IDs.
+          if (translatorOverflow || details?.code === "invalid_refusal") controller.enqueue(frame);
           else enqueueLiveFrame(frame);
           emittedFrames++;
         } catch {
@@ -371,8 +544,29 @@ export function responsesSseToChatCompletionsSse(
             if (typeof data.delta === "string") emitReasoning(data.delta);
             break;
           }
+          case "response.refusal.delta":
+          case "response.refusal.done": {
+            const delta = eventName === "response.refusal.delta";
+            retainRefusal(data.output_index, data.content_index, data, "item_id", data, delta ? "delta" : "refusal", delta);
+            break;
+          }
+          case "response.content_part.added":
+          case "response.content_part.done": {
+            const part = isRec(data.part) ? data.part : null;
+            if (part?.type === "refusal") {
+              retainRefusal(data.output_index, data.content_index, data, "item_id", part, "refusal");
+            } else if (typeof data.output_index === "number" && refusalItems.has(data.output_index)) {
+              const item = refusalItem(data.output_index, data, "item_id");
+              if (part?.type !== undefined && item.parts.has(position(data.content_index))) throw refusalTranslationError();
+            }
+            break;
+          }
           case "response.output_item.added": {
             const item = isRec(data.item) ? data.item : null;
+            if (item?.type === "message") {
+              snapshotRefusalItem(data.output_index, item);
+              if (Object.hasOwn(data, "item_id")) refusalItem(data.output_index, data, "item_id");
+            }
             if (!item || item.type !== "function_call") break;
             ensureRole();
             sawToolUse = true;
@@ -416,6 +610,8 @@ export function responsesSseToChatCompletionsSse(
           case "response.output_item.done": {
             const item = isRec(data.item) ? data.item : null;
             if (!item) break;
+            snapshotRefusalItem(data.output_index, item);
+            if (item.type === "message" && Object.hasOwn(data, "item_id")) refusalItem(data.output_index, data, "item_id");
             if (item.type === "function_call") {
               sawToolUse = true;
               const callId = typeof item.call_id === "string" ? item.call_id : "";
@@ -445,6 +641,7 @@ export function responsesSseToChatCompletionsSse(
           }
           case "response.completed": {
             const response = isRec(data.response) ? data.response : {};
+            snapshotRefusals(response);
             finish(sawToolUse ? "tool_calls" : "stop", response.usage);
             break;
           }
@@ -456,6 +653,7 @@ export function responsesSseToChatCompletionsSse(
               : undefined;
             if (reason !== undefined) {
               // Truthful OpenAI-compatible finish reasons: the turn ended, just early.
+              snapshotRefusals(response);
               finish(reason, response.usage);
             } else {
               // upstream_stall_timeout / adapter_eof / proxy-synthesized incompletes are
@@ -500,6 +698,7 @@ export function responsesSseToChatCompletionsSse(
           while (!cancelled && emittedFrames === emittedAtStart) {
             decoderStarted = true;
             const next = await sseIterator!.next();
+            if (cancelled) break;
             if (next.done) {
               if (!cancelled && !terminated) {
                 fail("upstream stream ended before a terminal frame (truncated response)");
@@ -525,6 +724,8 @@ export function responsesSseToChatCompletionsSse(
             upstreamAbort.abort(err);
             closeToolCalls();
             fail(err.message, { status: 502, type: "upstream_error", code: err.code });
+          } else if (isChatCompletionsStreamError(err)) {
+            fail(err.message, { status: err.status, type: err.type, code: err.code });
           } else {
             fail(err instanceof Error ? err.message : String(err));
           }
@@ -545,6 +746,7 @@ export function responsesSseToChatCompletionsSse(
     },
     cancel(reason) {
       cancelled = true;
+      releaseRefusals();
       while (queuedLiveFrameBytes.length > 0) releaseDeliveredFrame();
       closeToolCalls();
       // Abort first: it cancels the decoder's underlying reader, settling any in-flight
@@ -560,55 +762,99 @@ export function responsesSseToChatCompletionsSse(
 }
 
 /** Non-streaming: /v1/responses JSON -> Chat Completions message JSON. */
-export function responsesJsonToChatCompletion(json: unknown, model: string): Rec {
+export function responsesJsonToChatCompletion(json: unknown, model: string, translatorBudget?: TranslatorBudget): Rec {
   const body = isRec(json) ? json : {};
+  const incomplete = isRec(body.incomplete_details) ? body.incomplete_details : {};
+  let incompleteFinish: "length" | "content_filter" | undefined;
+  if (body.status === "incomplete") {
+    if (incomplete.reason === "max_output_tokens") incompleteFinish = "length";
+    else if (incomplete.reason === "content_filter") incompleteFinish = "content_filter";
+    else throw new ChatCompletionsStreamError("upstream response ended without a supported completion boundary", {
+      code: "upstream_incomplete", type: "upstream_error",
+    });
+  }
   const output = Array.isArray(body.output) ? body.output : [];
   let content = "";
+  let refusal: string | null = null;
+  let refusalBytes = 0;
   let reasoning = "";
+  let contentBytes = 0;
+  let reasoningBytes = 0;
   const toolCalls: Rec[] = [];
+  const append = (previous: string, previousBytes: number, fragment: string): { text: string; bytes: number } => {
+    if (!fragment) return { text: previous, bytes: previousBytes };
+    const scope = { kind: "retained_collectors" as const };
+    const nextBytes = appendedUtf8Bytes(previous, previousBytes, fragment);
+    const reservation = translatorBudget?.reserveTransient(nextBytes, scope);
+    try {
+      const next = previous + fragment;
+      reservation?.commitRetained();
+      translatorBudget?.releaseRetained(previousBytes, scope);
+      return { text: next, bytes: nextBytes };
+    } catch (error) {
+      reservation?.release();
+      throw error;
+    }
+  };
 
   for (const raw of output) {
     if (!isRec(raw)) continue;
     if (raw.type === "message" && Array.isArray(raw.content)) {
       for (const part of raw.content) {
         if (isRec(part) && part.type === "output_text" && typeof part.text === "string") {
-          content += part.text;
+          ({ text: content, bytes: contentBytes } = append(content, contentBytes, part.text));
+        } else if (isRec(part) && part.type === "refusal" && Object.hasOwn(part, "refusal")) {
+          if (typeof part.refusal !== "string") throw refusalTranslationError();
+          const next = append(refusal ?? "", refusalBytes, part.refusal);
+          refusal = next.text;
+          refusalBytes = next.bytes;
         }
       }
     } else if (raw.type === "reasoning") {
       if (Array.isArray(raw.summary)) {
         for (const part of raw.summary) {
           if (isRec(part) && part.type === "summary_text" && typeof part.text === "string") {
-            reasoning += part.text;
+            ({ text: reasoning, bytes: reasoningBytes } = append(reasoning, reasoningBytes, part.text));
           }
         }
       }
       if (Array.isArray(raw.content)) {
         for (const part of raw.content) {
           if (isRec(part) && part.type === "reasoning_text" && typeof part.text === "string") {
-            reasoning += part.text;
+            ({ text: reasoning, bytes: reasoningBytes } = append(reasoning, reasoningBytes, part.text));
           }
         }
       }
     } else if (raw.type === "function_call") {
-      toolCalls.push({
+      const call = {
         id: typeof raw.call_id === "string" ? raw.call_id : `call_${uuid().slice(0, 16)}`,
         type: "function",
         function: {
           name: typeof raw.name === "string" ? raw.name : "",
           arguments: typeof raw.arguments === "string" ? raw.arguments : "{}",
         },
+      };
+      // A complete buffered call still obeys the same per-call cap as live deltas.
+      // Reserve before serializing, then transfer ownership to the complete call.
+      // The internal scope stays nonempty even when an upstream call_id is empty.
+      const argumentsReservation = translatorBudget?.reserveTransient(Buffer.byteLength(call.function.arguments), {
+        kind: "tool_args", callId: `chat_json_${toolCalls.length}`,
       });
+      try {
+        translatorBudget?.chargeRetained(Buffer.byteLength(JSON.stringify(call)), { kind: "retained_collectors" });
+        toolCalls.push(call);
+      } finally {
+        argumentsReservation?.release();
+      }
     }
   }
 
-  const finishReason = toolCalls.length > 0 ? "tool_calls"
-    : body.status === "incomplete" ? "length"
-    : "stop";
+  const finishReason = incompleteFinish ?? (toolCalls.length > 0 ? "tool_calls" : "stop");
 
   const message: Rec = {
     role: "assistant",
     content: content || null,
+    refusal,
   };
   if (reasoning) message.reasoning_content = reasoning;
   if (toolCalls.length > 0) message.tool_calls = toolCalls;
@@ -637,6 +883,7 @@ export async function collectChatCompletion(
   const decoder = new TextDecoder();
   let buffer = "";
   let content = "";
+  let refusal: string | null = null;
   let reasoning = "";
   const toolCalls = new Map<number, { id: string; name: string; arguments: string; argumentBytes: number }>();
   // Per-call budget scopes (2 MiB/call enforced by the budget): the map key is the
@@ -644,7 +891,6 @@ export async function collectChatCompletion(
   const callScope = (index: number) => `chat_collect_${index}`;
   let finishReason = "stop";
   let usage: unknown;
-  let streamError: ChatCompletionsStreamError | null = null;
   const replaceRetained = (previous: string, next: string, kind: "live_transient" | "retained_collectors") => {
     const reservation = translatorBudget.reserveTransient(Buffer.byteLength(next), { kind });
     reservation.commitRetained();
@@ -697,12 +943,12 @@ export async function collectChatCompletion(
               : code === CYBER_POLICY_ERROR_CODE || isCyberPolicyMessage(message)
                 ? 400
                 : streamErrorStatus(message);
-            streamError = new ChatCompletionsStreamError(message, {
+            const streamError = new ChatCompletionsStreamError(message, {
               status,
               type: code === "translation_buffer_limit" ? "upstream_error" : type,
               code,
             });
-            continue;
+            throw streamError;
           }
           if (parsed.usage) usage = parsed.usage;
           const choices = Array.isArray(parsed.choices) ? parsed.choices : [];
@@ -712,6 +958,10 @@ export async function collectChatCompletion(
           const delta = isRec(choice.delta) ? choice.delta : null;
           if (!delta) continue;
           if (typeof delta.content === "string") content = replaceRetained(content, content + delta.content, "retained_collectors");
+          if (delta.refusal !== undefined && delta.refusal !== null) {
+            if (typeof delta.refusal !== "string") throw refusalTranslationError();
+            refusal = replaceRetained(refusal ?? "", (refusal ?? "") + delta.refusal, "retained_collectors");
+          }
           if (typeof delta.reasoning_content === "string") reasoning = replaceRetained(reasoning, reasoning + delta.reasoning_content, "retained_collectors");
           if (Array.isArray(delta.tool_calls)) {
             for (const tc of delta.tool_calls) {
@@ -749,6 +999,10 @@ export async function collectChatCompletion(
       }
     }
   } catch (error) {
+    // Processing may fail between reads; cancel while we still own the lock so the
+    // upstream translator releases its maps and stops any pending provider read.
+    try { await reader.cancel(error); } catch { /* preserve the original failure */ }
+    translatorBudget.releaseRetained(Buffer.byteLength(refusal ?? ""), { kind: "retained_collectors" });
     // Never leak an open call scope on the error path; the turn budget's
     // dispose is a backstop, not the owner of this transfer.
     for (const index of toolCalls.keys()) translatorBudget.closeCall(callScope(index));
@@ -765,14 +1019,11 @@ export async function collectChatCompletion(
   } finally {
     reader.releaseLock();
   }
-  if (streamError) {
-    for (const index of toolCalls.keys()) translatorBudget.closeCall(callScope(index));
-    throw streamError;
-  }
 
   const message: Rec = {
     role: "assistant",
     content: content || null,
+    refusal,
   };
   if (reasoning) message.reasoning_content = reasoning;
   if (toolCalls.size > 0) {