codex-overleaf-link 2.4.1 → 2.5.1

package/native-host/src/providerStore.js

@@ -4,6 +4,7 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { isDeepStrictEqual } = require('node:util');
 const {
   computeConnectionFingerprint,
   computeDraftFingerprint,
@@ -16,6 +17,9 @@ const {
 } = require('./providerProfile');
 
 const SCHEMA_VERSION = 1;
+const STORE_FILE_MAX_BYTES = 1024 * 1024;
+// A compact journal contains two bounded Store files plus revision/schema keys.
+const STORE_TRANSACTION_MAX_BYTES = 2 * STORE_FILE_MAX_BYTES + 1024;
 const STORE_LOCK_TIMEOUT_MS = 2500;
 const STORE_LOCK_STALE_MS = 30000;
 const STORE_LOCK_RETRY_MS = 25;
@@ -261,6 +265,10 @@ function recordProviderDiagnosticUnlocked(params = {}, env = process.env) {
     return { recorded: false };
   }
   const modelId = String(params.modelId || '').trim();
+  // Draft tests may cover models that are not saved yet; only saved models carry diagnostics.
+  if (!profile.models.some(model => model.id === modelId)) {
+    return { recorded: false };
+  }
   const secret = state.secrets.secrets[providerId] || '';
   const connectionFingerprint = computeConnectionFingerprint(profile, secret, modelId);
   if (connectionFingerprint !== String(params.connectionFingerprint || '') || !isResolvedWireApi(params.wireApi)) {
@@ -353,6 +361,7 @@ function loadProviderStateUnlocked(env = process.env) {
     : [];
   return {
     paths,
+    stored: { public: publicStore, secrets: secretStore },
     public: {
       schemaVersion: SCHEMA_VERSION,
       storeRevision: normalizeRevision(publicStore.storeRevision),
@@ -369,23 +378,35 @@ function loadProviderStateUnlocked(env = process.env) {
 
 function commitProviderState(previous, next) {
   const revision = previous.public.storeRevision + 1;
-  const nextPublic = { ...next.public, schemaVersion: SCHEMA_VERSION, storeRevision: revision };
-  const nextSecrets = { ...next.secrets, schemaVersion: SCHEMA_VERSION, storeRevision: revision };
+  const previousPublic = previous.stored.public;
+  const previousSecrets = previous.stored.secrets;
+  const nextPublic = { ...mergeStoredChanges(previousPublic, previous.public, next.public), schemaVersion: SCHEMA_VERSION, storeRevision: revision };
+  const nextSecrets = { ...mergeStoredChanges(previousSecrets, previous.secrets, next.secrets), schemaVersion: SCHEMA_VERSION, storeRevision: revision };
+  const compactPublic = Buffer.byteLength(`${JSON.stringify(previousPublic, null, 2)}\n`) > STORE_FILE_MAX_BYTES;
+  const compactSecrets = Buffer.byteLength(`${JSON.stringify(previousSecrets, null, 2)}\n`) > STORE_FILE_MAX_BYTES;
   const journal = {
     schemaVersion: SCHEMA_VERSION,
     nextRevision: revision,
-    previousPublic: previous.public,
-    previousSecrets: previous.secrets
+    previousPublic,
+    previousSecrets,
+    compactPublic,
+    compactSecrets
   };
+  // Validate every write, including rollback copies, before replacing any file.
+  serializeStoreJson(previous.paths.publicFile, nextPublic, compactPublic);
+  serializeStoreJson(previous.paths.secretFile, nextSecrets, compactSecrets);
+  serializeStoreJson(previous.paths.publicFile, previousPublic, compactPublic);
+  serializeStoreJson(previous.paths.secretFile, previousSecrets, compactSecrets);
+  serializeStoreJson(previous.paths.transactionFile, journal);
   atomicWriteJson(previous.paths.transactionFile, journal);
   try {
-    atomicWriteJson(previous.paths.secretFile, nextSecrets);
-    atomicWriteJson(previous.paths.publicFile, nextPublic);
+    atomicWriteJson(previous.paths.secretFile, nextSecrets, compactSecrets);
+    atomicWriteJson(previous.paths.publicFile, nextPublic, compactPublic);
     fs.rmSync(previous.paths.transactionFile, { force: true });
   } catch (error) {
     try {
-      atomicWriteJson(previous.paths.secretFile, previous.secrets);
-      atomicWriteJson(previous.paths.publicFile, previous.public);
+      atomicWriteJson(previous.paths.secretFile, previousSecrets, compactSecrets);
+      atomicWriteJson(previous.paths.publicFile, previousPublic, compactPublic);
       fs.rmSync(previous.paths.transactionFile, { force: true });
     } catch (_restoreError) {
       // The journal remains the recovery source on the next Native Host start.
@@ -394,6 +415,26 @@ function commitProviderState(previous, next) {
   }
 }
 
+function mergeStoredChanges(stored, before, after) {
+  if (isDeepStrictEqual(before, after)) return stored;
+  if (!stored || !before || !after || typeof stored !== 'object' || typeof before !== 'object' || typeof after !== 'object') return after;
+  if (Array.isArray(before) || Array.isArray(after)) {
+    // Profiles and models carry stable IDs; changed membership must not persist
+    // normalization defaults into unrelated records at the storage boundary.
+    if (!Array.isArray(stored) || !Array.isArray(before) || !Array.isArray(after)
+      || [...before, ...after].some(item => !item?.id)) return after;
+    const oldById = new Map(before.map(item => [item.id, item]));
+    const storedById = new Map(stored.map(item => [typeof item === 'string' ? item : item?.id, item]));
+    return after.map(item => mergeStoredChanges(storedById.get(item.id), oldById.get(item.id), item));
+  }
+  const result = { ...stored };
+  for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+    if (!Object.prototype.hasOwnProperty.call(after, key)) delete result[key];
+    else if (!isDeepStrictEqual(before[key], after[key])) result[key] = mergeStoredChanges(stored[key], before[key], after[key]);
+  }
+  return result;
+}
+
 function recoverInterruptedTransaction(paths) {
   if (!fs.existsSync(paths.transactionFile)) {
     return;
@@ -408,8 +449,10 @@ function recoverInterruptedTransaction(paths) {
     fs.rmSync(paths.transactionFile, { force: true });
     return;
   }
-  atomicWriteJson(paths.secretFile, journal.previousSecrets);
-  atomicWriteJson(paths.publicFile, journal.previousPublic);
+  serializeStoreJson(paths.secretFile, journal.previousSecrets, journal.compactSecrets === true);
+  serializeStoreJson(paths.publicFile, journal.previousPublic, journal.compactPublic === true);
+  atomicWriteJson(paths.secretFile, journal.previousSecrets, journal.compactSecrets === true);
+  atomicWriteJson(paths.publicFile, journal.previousPublic, journal.compactPublic === true);
   fs.rmSync(paths.transactionFile, { force: true });
 }
 
@@ -498,11 +541,16 @@ function normalizeStoredProfile(value) {
   if (!value || typeof value !== 'object' || !normalizeId(value.id)) {
     throw providerError('provider_store_corrupt', 'Provider store contains an invalid profile.');
   }
-  const normalized = normalizeProviderDraft(value);
+  const legacyOutputBudget = value.outputBudgetVersion !== 1
+    && [8192, 32768].includes(Number(value.maxOutputTokens));
+  const normalized = normalizeProviderDraft(legacyOutputBudget ? { ...value, maxOutputTokens: 65536 } : value);
   return {
     id: normalizeId(value.id),
     revision: Math.max(1, normalizeRevision(value.revision)),
     ...normalized,
+    // Keep the old provenance until an explicit upsert persists the new value.
+    // Unrelated mutations must not mark an unmigrated raw record as current.
+    outputBudgetVersion: value.outputBudgetVersion === 1 ? 1 : 0,
     resolvedWireApi: isResolvedWireApi(value.resolvedWireApi) ? value.resolvedWireApi : '',
     endpointDisclosureHost: String(value.endpointDisclosureHost || ''),
     endpointDisclosureBaseUrl: String(value.endpointDisclosureBaseUrl || ''),
@@ -630,11 +678,12 @@ function ensurePrivateDirectory(directory) {
   }
 }
 
-function atomicWriteJson(target, value) {
+function atomicWriteJson(target, value, compact = false) {
+  const serialized = serializeStoreJson(target, value, compact);
   const temp = `${target}.tmp-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
   const fd = fs.openSync(temp, 'w', 0o600);
   try {
-    fs.writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(fd, serialized, 'utf8');
     fs.fsyncSync(fd);
   } finally {
     fs.closeSync(fd);
@@ -645,13 +694,26 @@ function atomicWriteJson(target, value) {
   fs.renameSync(temp, target);
 }
 
+function getStoreFileMaxBytes(target) {
+  return path.basename(target) === 'provider-transaction.json' ? STORE_TRANSACTION_MAX_BYTES : STORE_FILE_MAX_BYTES;
+}
+
+function serializeStoreJson(target, value, compact = false) {
+  const serialized = `${JSON.stringify(value, null, compact || path.basename(target) === 'provider-transaction.json' ? undefined : 2)}\n`;
+  const maxBytes = getStoreFileMaxBytes(target);
+  if (Buffer.byteLength(serialized, 'utf8') > maxBytes) {
+    throw providerError('provider_store_too_large', `Provider settings exceed the ${maxBytes}-byte limit for ${path.basename(target)}. Reduce the configuration and retry.`);
+  }
+  return serialized;
+}
+
 function readJson(target, fallback) {
   if (!fs.existsSync(target)) {
     return fallback;
   }
   try {
     const stat = fs.statSync(target);
-    if (!stat.isFile() || stat.size > 1024 * 1024) {
+    if (!stat.isFile() || stat.size > getStoreFileMaxBytes(target)) {
       throw new Error('invalid provider store file');
     }
     return JSON.parse(fs.readFileSync(target, 'utf8'));

package/native-host/src/releaseTransport.js

@@ -22,7 +22,7 @@ function terminalError(code, message) {
   return Object.assign(updateError(code, message), { retryable: false });
 }
 
-async function readBoundedBody(response, limit, signal) {
+async function readBoundedBody(response, limit, signal, onProgress = () => {}) {
   const declared = Number(response.headers?.get?.('content-length') || 0);
   if (declared > limit) throw terminalError('update_download_limit', 'Update response exceeds its size limit.');
   const reader = response.body?.getReader?.();
@@ -39,6 +39,7 @@ async function readBoundedBody(response, limit, signal) {
       if (chunk.done) break;
       const bytes = Buffer.from(chunk.value);
       length += bytes.length;
+      if (bytes.length) onProgress();
       if (length > limit) throw terminalError('update_download_limit', 'Update response exceeds its size limit.');
       chunks.push(bytes);
     }
@@ -95,8 +96,14 @@ async function requestRelease(url, options = {}) {
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(new DOMException('Update request timed out.', 'TimeoutError')),
-      Math.min(remaining, options.timeoutMs ?? 12000));
+    const timeout = () => controller.abort(new DOMException('Update request timed out.', 'TimeoutError'));
+    const totalTimer = setTimeout(timeout, remaining);
+    let phaseTimer = setTimeout(timeout, Math.min(remaining, options.timeoutMs ?? 12000));
+    const receivedBytes = () => {
+      clearTimeout(phaseTimer);
+      phaseTimer = setTimeout(timeout, Math.min(Math.max(1, deadline - Date.now()),
+        options.idleTimeoutMs ?? options.timeoutMs ?? 12000));
+    };
     const cancel = () => controller.abort(options.signal.reason);
     if (options.signal?.aborted) cancel();
     else options.signal?.addEventListener('abort', cancel, { once: true });
@@ -108,6 +115,7 @@ async function requestRelease(url, options = {}) {
         method: options.method || 'GET', headers: options.headers,
         redirect: 'follow', signal: controller.signal
       }), controller.signal);
+      receivedBytes();
       const finalUrl = new URL(response.url || url);
       if (options.allowedHosts && (finalUrl.protocol !== 'https:' || !options.allowedHosts.has(finalUrl.hostname))) {
         throw terminalError('update_asset_redirect_forbidden', 'Release request redirected to an untrusted host.');
@@ -117,7 +125,7 @@ async function requestRelease(url, options = {}) {
           'Update request failed with HTTP ' + response.status + '.'), { retryable: RETRYABLE_HTTP.has(response.status) });
       }
       const bytes = options.method === 'HEAD' || response.status === 304
-        ? null : await readBoundedBody(response, options.limit ?? 32 * 1024 * 1024, controller.signal);
+        ? null : await readBoundedBody(response, options.limit ?? 32 * 1024 * 1024, controller.signal, receivedBytes);
       return { ok: response.ok, status: response.status, url: finalUrl.href, headers: response.headers,
         bytes, attempts: attempt, elapsedMs: Date.now() - started };
     } catch (error) {
@@ -140,7 +148,8 @@ async function requestRelease(url, options = {}) {
       if (!classified.retryable || attempt === maxAttempts) throw failure;
       retryAfter = retryDelay(response, (options.delayMs ?? 500) * attempt);
     } finally {
-      clearTimeout(timer);
+      clearTimeout(totalTimer);
+      clearTimeout(phaseTimer);
       options.signal?.removeEventListener('abort', cancel);
       controller.abort();
       if (response?.body && !response.body.locked) void response.body.cancel().catch(() => {});

package/native-host/src/responsesPassthroughBridge.js

@@ -4,6 +4,7 @@ const crypto = require('node:crypto');
 const http = require('node:http');
 const { classifyResponsesRoute } = require('./providerBridgeRoutes');
 const { providerError } = require('./providerProfile');
+const { fetchProvider, readProviderText } = require('./providerHttp');
 const { sanitizeProviderMessage } = require('./providerRedaction');
 const { logDebug } = require('./debugLog');
 const {
@@ -19,6 +20,7 @@ const MAX_HISTORY_ITEMS = 4096;
 const MAX_HISTORY_BYTES = 32 * 1024 * 1024;
 const MAX_DUPLICATE_CONTINUATIONS = 2;
 const MAX_STREAM_BUFFER_BYTES = 8 * 1024 * 1024;
+const MAX_COMPACT_RESPONSE_BYTES = 32 * 1024 * 1024;
 const DEFAULT_MAX_OUTPUT_TOKENS = 65536;
 const CONTINUATION_MARKER = '[codex-overleaf-provider-reasoning-continuation]';
 
@@ -102,7 +104,7 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
   const prepared = route === 'responses'
     ? prepareResponsesRequest({ requestBody, launch, history, previous, originalPreviousResponseId })
     : {
-        body: { ...requestBody },
+        body: { ...(launch.bodyOverrides || {}), ...requestBody, previous_response_id: requestBody.previous_response_id },
         currentInput: normalizeInputItems(requestBody.input),
         replayed: false
       };
@@ -140,19 +142,19 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
   res.on('close', onClientClose);
   lifecycle.start();
   try {
-    const upstream = await fetch(buildResponsesUrl(launch.baseUrl, launch, route), {
+    const upstream = await fetchProvider(buildResponsesUrl(launch.baseUrl, launch, route), {
       method: 'POST',
       headers: buildUpstreamHeaders(launch),
       body: JSON.stringify(prepared.body),
       signal: controller.signal
-    });
+    }, launch);
     lifecycle.touch();
     if (!upstream.ok) {
-      await forwardUpstreamError(upstream, res, launch.apiKey);
+      await forwardUpstreamError(upstream, res, launch.apiKey, lifecycle.touch);
       return;
     }
     if (route === 'compact') {
-      await forwardOpaqueResponse(upstream, res, lifecycle.touch);
+      await forwardCompactResponse(upstream, res, lifecycle.touch, launch.apiKey);
       return;
     }
 
@@ -165,11 +167,18 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
           'The provider returned a non-streaming payload for a streaming Responses request.'
         );
       }
-      response = await forwardResponsesSse(upstream, res, lifecycle.touch);
+      response = await forwardResponsesSse(upstream, res, lifecycle.touch, launch.apiKey);
     } else {
-      response = await upstream.json();
+      const text = await readProviderText(upstream, lifecycle.touch);
+      try {
+        response = JSON.parse(text);
+      } catch (_error) {
+        throw providerError('provider_response_invalid', 'The provider returned an invalid Responses JSON response.');
+      }
       lifecycle.touch();
-      sendJson(res, 200, response);
+      sanitizeProtocolErrors(response, launch.apiKey, hasDuplicateJsonKeys(text));
+      if (requestBody.stream !== false) writeBufferedResponseAsSse(res, response);
+      else sendJson(res, 200, response);
     }
     if (response?.id) {
       rememberResponse(history, {
@@ -228,7 +237,10 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
 function prepareResponsesRequest({ requestBody, launch, history, previous, originalPreviousResponseId }) {
   const currentInput = normalizeInputItems(requestBody.input);
   const body = {
+    ...(launch.bodyOverrides || {}),
     ...requestBody,
+    previous_response_id: requestBody.previous_response_id,
+    stream: requestBody.stream !== false && launch.upstreamResponseMode !== 'buffered',
     max_output_tokens: resolveMaxOutputTokens(launch.maxOutputTokens, requestBody.max_output_tokens)
   };
   if (!previous?.continuationRequired) {
@@ -405,7 +417,75 @@ function resolveMaxOutputTokens(configured, requested) {
   return Math.max(1, Math.floor(value));
 }
 
-async function forwardResponsesSse(upstream, res, onActivity) {
+function writeBufferedResponseAsSse(res, response) {
+  if (!response || typeof response !== 'object' || Array.isArray(response)) {
+    throw providerError('provider_response_invalid', 'The provider returned an invalid Responses JSON response.');
+  }
+  if (!response.error && !['completed', 'incomplete', 'failed'].includes(response.status)) {
+    throw providerError('provider_response_invalid', 'The buffered Responses request did not return a terminal response.');
+  }
+  res.writeHead(200, { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache, no-store' });
+  let sequence = 0;
+  const emit = (type, detail) => {
+    const frame = `event: ${type}\ndata: ${JSON.stringify({ type, sequence_number: sequence++, ...detail })}\n\n`;
+    if (Buffer.byteLength(frame, 'utf8') > MAX_STREAM_BUFFER_BYTES) {
+      throw providerError('provider_stream_frame_too_large', 'Provider stream frame exceeded the local bridge limit.');
+    }
+    res.write(frame);
+  };
+  if (response.error && !Array.isArray(response.output)) {
+    emit('error', { ...response, type: 'error' });
+    res.end();
+    return;
+  }
+  const pending = { ...response, status: 'in_progress', output: [], usage: null, error: null, incomplete_details: null };
+  emit('response.created', { response: pending });
+  emit('response.in_progress', { response: pending });
+  for (const [output_index, item] of (response.output || []).entries()) {
+    const identity = { item_id: item.id, output_index };
+    const added = { ...item, status: 'in_progress' };
+    if (item.type === 'message') added.content = [];
+    if (item.type === 'reasoning') added.summary = [];
+    if (item.type === 'function_call') added.arguments = '';
+    if (item.type === 'custom_tool_call') added.input = '';
+    emit('response.output_item.added', { output_index, item: added });
+    for (const [content_index, part] of (item.content || []).entries()) {
+      const detail = { ...identity, content_index };
+      const emptyPart = part.type === 'refusal' ? { ...part, refusal: '' }
+        : { ...part, ...(typeof part.text === 'string' ? { text: '' } : {}) };
+      emit('response.content_part.added', { ...detail, part: emptyPart });
+      if (part.type === 'output_text') {
+        if (part.text) emit('response.output_text.delta', { ...detail, delta: part.text, logprobs: [] });
+        emit('response.output_text.done', { ...detail, text: part.text || '', logprobs: [] });
+      } else if (part.type === 'refusal') {
+        if (part.refusal) emit('response.refusal.delta', { ...detail, delta: part.refusal });
+        emit('response.refusal.done', { ...detail, refusal: part.refusal || '' });
+      }
+      emit('response.content_part.done', { ...detail, part });
+    }
+    for (const [summary_index, part] of (item.summary || []).entries()) {
+      const detail = { ...identity, summary_index };
+      emit('response.reasoning_summary_part.added', { ...detail, part: { ...part, text: '' } });
+      if (part.text) emit('response.reasoning_summary_text.delta', { ...detail, delta: part.text });
+      emit('response.reasoning_summary_text.done', { ...detail, text: part.text || '' });
+      emit('response.reasoning_summary_part.done', { ...detail, part });
+    }
+    if (item.type === 'function_call' || item.type === 'custom_tool_call') {
+      const custom = item.type === 'custom_tool_call';
+      const value = custom ? item.input : item.arguments;
+      const event = custom ? 'response.custom_tool_call_input' : 'response.function_call_arguments';
+      if (value) emit(event + '.delta', { ...identity, delta: value });
+      emit(event + '.done', { ...identity, [custom ? 'input' : 'arguments']: value || (custom ? '' : '{}') });
+    }
+    emit('response.output_item.done', { output_index, item });
+  }
+  const status = response.error || response.status === 'failed' ? 'failed'
+    : response.status === 'incomplete' ? 'incomplete' : 'completed';
+  emit('response.' + status, { response });
+  res.end();
+}
+
+async function forwardResponsesSse(upstream, res, onActivity, apiKey) {
   res.writeHead(200, {
     'content-type': 'text/event-stream; charset=utf-8',
     'cache-control': 'no-cache, no-store',
@@ -415,67 +495,199 @@ async function forwardResponsesSse(upstream, res, onActivity) {
     throw providerError('provider_response_invalid', 'The provider returned an empty Responses stream.');
   }
   const reader = upstream.body.getReader();
-  const decoder = new TextDecoder();
-  const observer = { buffer: '', terminalResponse: null };
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    onActivity();
-    observeSseText(observer, decoder.decode(value, { stream: true }));
-    if (!res.writableEnded) res.write(Buffer.from(value));
-  }
-  observeSseText(observer, decoder.decode(), true);
+  const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+  const observer = { buffer: '', position: 0, lineStart: 0, terminalResponse: null };
+  const forward = frame => {
+    const safeFrame = inspectSseFrame(observer, frame, apiKey);
+    if (!res.writableEnded) res.write(safeFrame);
+  };
+  let complete = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      onActivity();
+      forwardSseText(observer, decoder.decode(value, { stream: true }), forward);
+    }
+    forwardSseText(observer, decoder.decode(), forward, true);
+    complete = true;
+  } finally {
+    if (!complete) await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
   if (!res.writableEnded) res.end();
   return observer.terminalResponse;
 }
 
-function observeSseText(observer, text, flush = false) {
+function forwardSseText(observer, text, forward, flush = false) {
   observer.buffer += text;
+  // Hold each event until its diagnostics can be inspected. Line endings and
+  // successful frames remain intact, including CRLF split across HTTP chunks.
+  while (observer.position < observer.buffer.length) {
+    const position = observer.position;
+    const char = observer.buffer[position];
+    if (char !== '\r' && char !== '\n') { observer.position += 1; continue; }
+    if (char === '\r' && position + 1 === observer.buffer.length && !flush) break;
+    const end = position + (char === '\r' && observer.buffer[position + 1] === '\n' ? 2 : 1);
+    if (position === observer.lineStart) {
+      forward(observer.buffer.slice(0, end));
+      observer.buffer = observer.buffer.slice(end);
+      observer.position = observer.lineStart = 0;
+    } else {
+      observer.position = observer.lineStart = end;
+    }
+  }
   if (Buffer.byteLength(observer.buffer, 'utf8') > MAX_STREAM_BUFFER_BYTES) {
     throw providerError('provider_stream_frame_too_large', 'Provider stream frame exceeded the local bridge limit.');
   }
-  let match;
-  while ((match = /\r?\n\r?\n/.exec(observer.buffer))) {
-    const block = observer.buffer.slice(0, match.index);
-    observer.buffer = observer.buffer.slice(match.index + match[0].length);
-    observeSseBlock(observer, block);
-  }
   if (flush && observer.buffer.trim()) {
-    observeSseBlock(observer, observer.buffer);
+    forward(observer.buffer);
     observer.buffer = '';
   }
 }
 
-function observeSseBlock(observer, block) {
-  const data = String(block || '')
-    .split(/\r?\n/)
-    .filter(line => line.startsWith('data:'))
-    .map(line => line.slice(5).trimStart())
-    .join('\n');
-  if (!data || data === '[DONE]') return;
+function inspectSseFrame(observer, frame, apiKey) {
+  if (Buffer.byteLength(frame, 'utf8') > MAX_STREAM_BUFFER_BYTES) {
+    throw providerError('provider_stream_frame_too_large', 'Provider stream frame exceeded the local bridge limit.');
+  }
+  const parts = frame.split(/(\r\n|\r|\n)/);
+  const dataIndexes = [];
+  let event = '';
+  for (let index = 0; index < parts.length; index += 2) {
+    const line = parts[index].replace(/^\uFEFF/, '');
+    if (/^data(?::|$)/.test(line)) dataIndexes.push(index);
+    if (line.startsWith('event:')) event = line.slice(6).replace(/^ /, '');
+  }
+  const failedEvent = ['error', 'response.failed', 'response.error'].includes(event);
+  if (!dataIndexes.length && !failedEvent) return frame;
+  const data = dataIndexes.map(index => parts[index].replace(/^\uFEFF/, '').replace(/^data:? ?/, '')).join('\n');
+  if ((!data || data === '[DONE]') && !failedEvent) return frame;
+  let payload;
   try {
-    const payload = JSON.parse(data);
-    if (['response.completed', 'response.incomplete', 'response.failed'].includes(payload?.type) && payload.response) {
-      observer.terminalResponse = payload.response;
+    payload = JSON.parse(data);
+  } catch (_error) {
+    throw providerError('provider_response_invalid', 'The provider returned an invalid Responses stream event.');
+  }
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw providerError('provider_response_invalid', 'The provider returned an invalid Responses stream event.');
+  }
+  const changed = sanitizeProtocolErrors(payload, apiKey, failedEvent || hasDuplicateJsonKeys(data));
+  if (['response.completed', 'response.incomplete', 'response.failed'].includes(payload.type || event) && payload.response) {
+    observer.terminalResponse = payload.response;
+  }
+  if (!changed) return frame;
+  parts[dataIndexes[0]] = `data: ${JSON.stringify(payload)}`;
+  for (const index of dataIndexes.slice(1)) parts[index] = parts[index + 1] = '';
+  return parts.join('');
+}
+
+function sanitizeProtocolErrors(payload, apiKey, failedEvent = false) {
+  let changed = false;
+  const clean = value => {
+    if (typeof value === 'string' && value) {
+      const safe = sanitizeProviderMessage(value, [apiKey], MAX_ERROR_BYTES);
+      changed ||= safe !== value;
+      return safe;
     }
-  } catch (_error) {}
+    if (value && typeof value === 'object') {
+      for (const key of Object.keys(value)) value[key] = clean(value[key]);
+    }
+    return value;
+  };
+  const visit = (value, inheritedFailure) => {
+    if (!value || typeof value !== 'object') return;
+    if (value.error != null) { changed = true; value.error = clean(value.error); }
+    const failed = inheritedFailure || ['error', 'response.failed', 'response.error'].includes(value.type)
+      || ['failed', 'error'].includes(value.status);
+    if (failed) {
+      // Re-encode failures even when the surviving values need no replacement:
+      // duplicate JSON keys must not retain an earlier raw diagnostic value.
+      changed = true;
+      for (const key of ['message', 'code', 'param', 'detail', 'details', 'reason', 'description']) {
+        if (value[key] != null) value[key] = clean(value[key]);
+      }
+    }
+    // Response envelopes carry diagnostics; model output and tool arguments
+    // retain their original protocol semantics, even if they resemble secrets.
+    visit(value.response, failed);
+  };
+  visit(payload, failedEvent);
+  return changed;
 }
 
-async function forwardOpaqueResponse(upstream, res, onActivity) {
-  const contentType = upstream.headers.get('content-type') || 'application/json; charset=utf-8';
-  res.writeHead(upstream.status, { 'content-type': contentType, 'cache-control': 'no-store' });
+function hasDuplicateJsonKeys(text) {
+  // Called only after JSON.parse succeeds. Track keys per object and skip
+  // entire string values, including JSON-looking tool arguments. A duplicate
+  // can hide both an error value and an earlier failed status, so its protocol
+  // diagnostics require cleaning even when the surviving status is completed.
+  const stack = [];
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '{') stack.push({ keys: new Set(), expectsKey: true });
+    else if (char === '[') stack.push(null);
+    else if (char === '}' || char === ']') stack.pop();
+    else if (char === ',' && stack.at(-1)) stack.at(-1).expectsKey = true;
+    else if (char === '"') {
+      let end = index;
+      while (true) {
+        end = text.indexOf('"', end + 1);
+        let backslashes = 0;
+        for (let at = end - 1; text[at] === '\\'; at -= 1) backslashes += 1;
+        if (backslashes % 2 === 0) break;
+      }
+      const object = stack.at(-1);
+      if (object?.expectsKey) {
+        const key = JSON.parse(text.slice(index, end + 1));
+        if (object.keys.has(key)) return true;
+        object.keys.add(key);
+        object.expectsKey = false;
+      }
+      index = end;
+    }
+  }
+  return false;
+}
+
+async function forwardCompactResponse(upstream, res, onActivity, apiKey) {
   if (!upstream.body) {
-    res.end();
-    return;
+    throw providerError('provider_response_invalid', 'The provider returned an empty compact response.');
   }
   const reader = upstream.body.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    onActivity();
-    if (!res.writableEnded) res.write(Buffer.from(value));
+  const chunks = [];
+  let bytes = 0;
+  let complete = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      onActivity();
+      bytes += value.byteLength;
+      if (bytes > MAX_COMPACT_RESPONSE_BYTES) {
+        throw providerError('provider_response_too_large', 'The compact response exceeded the 32 MiB local bridge limit.');
+      }
+      chunks.push(Buffer.from(value));
+    }
+    complete = true;
+  } finally {
+    if (!complete) await reader.cancel().catch(() => {});
+    reader.releaseLock();
   }
-  if (!res.writableEnded) res.end();
+  const body = Buffer.concat(chunks, bytes);
+  let text;
+  let payload;
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(body);
+    payload = JSON.parse(text);
+  } catch (_error) {
+    throw providerError('provider_response_invalid', 'The provider returned an invalid compact JSON response.');
+  }
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw providerError('provider_response_invalid', 'The provider returned an invalid compact JSON response.');
+  }
+  const changed = sanitizeProtocolErrors(payload, apiKey, hasDuplicateJsonKeys(text));
+  const contentType = upstream.headers.get('content-type') || 'application/json; charset=utf-8';
+  res.writeHead(upstream.status, { 'content-type': contentType, 'cache-control': 'no-store' });
+  if (!res.writableEnded) res.end(changed ? JSON.stringify(payload) : body);
 }
 
 function buildResponsesUrl(baseUrl, launch = {}, route = 'responses') {
@@ -521,8 +733,8 @@ function buildUpstreamHeaders(launch = {}) {
   return headers;
 }
 
-async function forwardUpstreamError(upstream, res, apiKey) {
-  const text = (await upstream.text()).slice(0, MAX_ERROR_BYTES);
+async function forwardUpstreamError(upstream, res, apiKey, onActivity) {
+  const text = (await readProviderText(upstream, onActivity)).slice(0, MAX_ERROR_BYTES);
   let message = `Provider returned HTTP ${upstream.status}.`;
   try {
     const parsed = JSON.parse(text);
@@ -555,12 +767,14 @@ function normalizeBridgeErrorCode(value) {
   return [
     'provider_connection_timeout',
     'provider_response_invalid',
+    'provider_response_too_large',
     'provider_protocol_incompatible',
     'provider_request_invalid',
     'provider_request_too_large',
     'provider_responses_continuation_repeated',
     'provider_responses_continuation_unrecoverable',
-    'provider_continuation_history_limit'
+    'provider_continuation_history_limit',
+    'provider_upstream_error'
   ].includes(value) ? value : 'provider_bridge_failed';
 }