codex-overleaf-link 2.1.5 → 2.2.1

package/native-host/src/anthropicBridgeResponse.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const crypto = require('node:crypto');
+const MAX_STREAM_BUFFER_BYTES = 8 * 1024 * 1024;
 const { encodeAnthropicThinkingBlock } = require('./anthropicBridgeRequest');
 
 function convertAnthropicResponse(message = {}, context = {}) {
@@ -44,30 +45,58 @@ function convertAnthropicResponse(message = {}, context = {}) {
   };
 }
 
-async function streamAnthropicResponse({ upstream, res, context = {}, onComplete = () => {} } = {}) {
+async function streamAnthropicResponse({
+  upstream,
+  res,
+  context = {},
+  onComplete = () => {},
+  onActivity = () => {},
+  recoverInterrupted = () => ''
+} = {}) {
   const state = createState(context);
   beginSse(res);
   emit(state, res, 'response.created', { response: streamEnvelope(state, 'in_progress') });
   emit(state, res, 'response.in_progress', { response: streamEnvelope(state, 'in_progress') });
   const decoder = new TextDecoder();
   let buffer = '';
-  for await (const chunk of upstream.body || []) {
-    buffer += typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
-    let boundary = findBoundary(buffer);
-    while (boundary) {
-      const block = buffer.slice(0, boundary.index);
-      buffer = buffer.slice(boundary.index + boundary.length);
-      const event = parseEvent(block);
-      if (event.data) processEvent(state, res, event.type, parseJson(event.data));
-      boundary = findBoundary(buffer);
+  let done = false;
+  let interruptedReason = '';
+  try {
+    for await (const chunk of upstream.body || []) {
+      onActivity();
+      buffer += typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+      if (Buffer.byteLength(buffer, 'utf8') > MAX_STREAM_BUFFER_BYTES) {
+        throw responseError('Provider stream frame exceeded the local bridge limit.', 'provider_stream_frame_too_large');
+      }
+      let boundary = findBoundary(buffer);
+      while (boundary) {
+        const block = buffer.slice(0, boundary.index);
+        buffer = buffer.slice(boundary.index + boundary.length);
+        const event = parseEvent(block);
+        if (event.data) processEvent(state, res, event.type, parseJson(event.data));
+        if (state.sawMessageStop || state.stopReason) {
+          done = true;
+          break;
+        }
+        boundary = findBoundary(buffer);
+      }
+      if (done) break;
     }
+  } catch (error) {
+    interruptedReason = String(recoverInterrupted(error) || '');
+    if (!interruptedReason || !hasRecoverablePartialOutput(state)) throw error;
   }
+  if (!done && !interruptedReason && hasRecoverablePartialOutput(state)) {
+    interruptedReason = 'stream_ended';
+  }
+  if (!done && !interruptedReason) {
     buffer += decoder.decode();
-  if (buffer.trim()) {
-    const event = parseEvent(buffer);
-    if (event.data) processEvent(state, res, event.type, parseJson(event.data));
+    if (buffer.trim()) {
+      const event = parseEvent(buffer);
+      if (event.data) processEvent(state, res, event.type, parseJson(event.data));
+    }
   }
-  const converted = completeStream(state, res);
+  const converted = completeStream(state, res, interruptedReason);
   onComplete(converted);
   res.end();
   return converted;
@@ -221,10 +250,12 @@ function closeBlock(state, res, index) {
   state.items[entry.outputIndex] = entry.item;
 }
 
-function completeStream(state, res) {
+function completeStream(state, res, interruptedReason = '') {
   for (const index of Array.from(state.blocks.keys()).sort((a, b) => a - b)) closeBlock(state, res, index);
   if (!state.items.filter(Boolean).length) throw responseError('Anthropic stream ended without usable output.');
-  const terminal = mapStopReason(state.stopReason);
+  const terminal = interruptedReason
+    ? { status: 'incomplete', incompleteReason: interruptedReason }
+    : mapStopReason(state.stopReason);
   const response = responseEnvelope({
     id: state.id,
     model: state.model,
@@ -237,6 +268,15 @@ function completeStream(state, res) {
   return { response, assistantBlocks: state.assistantBlocks.filter(Boolean) };
 }
 
+function hasRecoverablePartialOutput(state) {
+  const entries = Array.from(state.blocks.values());
+  if (entries.some(entry => entry?.type === 'tool_use')) return false;
+  return entries.some(entry => (
+    (entry?.type === 'text' && entry.text)
+    || ((entry?.type === 'thinking' || entry?.type === 'redacted_thinking') && (entry.thinking || entry.data))
+  ));
+}
+
 function toolItem(block, toolContext) {
   const spec = resolveToolSpec(toolContext, block.name);
   const kind = spec?.kind === 'custom' ? 'custom' : 'function';
@@ -289,7 +329,8 @@ function responseEnvelope({ id, model, output, usage, requestBody = {}, status,
 }
 
 function mapStopReason(value) {
-  if (value === 'max_tokens' || value === 'model_context_window_exceeded') return { status: 'incomplete', incompleteReason: 'max_output_tokens' };
+  if (value === 'max_tokens') return { status: 'incomplete', incompleteReason: 'max_output_tokens' };
+  if (value === 'model_context_window_exceeded') return { status: 'incomplete', incompleteReason: 'context_window_exceeded' };
   if (value === 'refusal') return { status: 'incomplete', incompleteReason: 'content_filter' };
   return { status: 'completed', incompleteReason: null };
 }

package/native-host/src/anthropicMessagesBridge.js

@@ -14,18 +14,28 @@ const { writeConvertedResponseAsSse } = require('./chatBridgeResponse');
 const { classifyResponsesRoute } = require('./providerBridgeRoutes');
 const { providerError } = require('./providerProfile');
 const { sanitizeProviderMessage } = require('./providerRedaction');
+const { logDebug } = require('./debugLog');
+const {
+  createProviderStreamLifecycle,
+  resolveProviderIdleTimeoutMs,
+  resolveProviderTotalTimeoutMs
+} = require('./providerStreamLifecycle');
 
 const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 const MAX_ERROR_BYTES = 64 * 1024;
 const MAX_HISTORY_ENTRIES = 64;
+const MAX_CONTINUATION_CHARS = 512 * 1024;
+const MAX_REASONING_CONTINUATIONS = 2;
+const REASONING_CONTINUATION_MARKER = '[codex-overleaf-provider-reasoning-continuation]';
 
 async function startAnthropicMessagesBridge({ launch, signal } = {}) {
   if (!launch?.baseUrl) throw providerError('provider_base_url_invalid', 'Anthropic routing requires a provider Base URL.');
   const clientToken = crypto.randomBytes(32).toString('base64url');
   const activeRequests = new Set();
   const history = new Map();
+  const continuationState = { anchorMessages: [], attempts: 0, responseId: '' };
   const server = http.createServer((req, res) => {
-    handleRequest({ req, res, launch, clientToken, activeRequests, history }).catch(error => {
+    handleRequest({ req, res, launch, clientToken, activeRequests, history, continuationState }).catch(error => {
       if (res.writableEnded) return;
       const code = normalizeBridgeErrorCode(error?.code);
       const message = sanitizeProviderMessage(error?.message, [launch.apiKey]) || 'The Anthropic provider bridge failed.';
@@ -40,9 +50,10 @@ async function startAnthropicMessagesBridge({ launch, signal } = {}) {
       }
     });
   });
-  const timeoutMs = resolveTimeout(launch);
+  const idleTimeoutMs = resolveProviderIdleTimeoutMs(launch);
+  const totalTimeoutMs = resolveProviderTotalTimeoutMs(launch, idleTimeoutMs);
   server.keepAliveTimeout = 5000;
-  server.requestTimeout = timeoutMs + 5000;
+  server.requestTimeout = totalTimeoutMs + 5000;
   await listen(server);
   const address = server.address();
   let closed = false;
@@ -53,6 +64,9 @@ async function startAnthropicMessagesBridge({ launch, signal } = {}) {
     for (const controller of activeRequests) controller.abort();
     activeRequests.clear();
     history.clear();
+    continuationState.anchorMessages = [];
+    continuationState.attempts = 0;
+    continuationState.responseId = '';
     await closeServer(server);
   };
   signal?.addEventListener('abort', close, { once: true });
@@ -60,7 +74,7 @@ async function startAnthropicMessagesBridge({ launch, signal } = {}) {
   return { baseUrl: `http://127.0.0.1:${address.port}/v1`, clientToken, close };
 }
 
-async function handleRequest({ req, res, launch, clientToken, activeRequests, history }) {
+async function handleRequest({ req, res, launch, clientToken, activeRequests, history, continuationState }) {
   if (!isAuthorized(req, clientToken)) {
     sendJsonError(res, 401, 'unauthorized', 'Local bridge authorization failed.');
     return;
@@ -76,22 +90,48 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
     return;
   }
   const requestBody = await readJsonBody(req);
-  const previous = history.get(String(requestBody.previous_response_id || ''));
+  const previousResponseId = String(requestBody.previous_response_id || '');
+  const previous = history.get(previousResponseId);
+  const fallbackAnchor = previous ? [] : continuationState.anchorMessages;
+  const continuing = Boolean(previous?.continuation || fallbackAnchor.length);
+  if (continuing && continuationState.attempts >= MAX_REASONING_CONTINUATIONS) {
+    throw providerError(
+      'provider_reasoning_continuation_exhausted',
+      'The provider repeatedly interrupted the same reasoning stream. Retry the task or use a different model endpoint.'
+    );
+  }
   const translated = buildAnthropicRequest({
     requestBody,
     launch,
-    historyMessages: previous?.messages || []
+    historyMessages: previous?.messages || fallbackAnchor
+  });
+  logDebug('provider.anthropic.request', {
+    model: translated.body.model,
+    stream: requestBody.stream !== false,
+    maxTokens: translated.body.max_tokens,
+    thinkingType: translated.body.thinking?.type || 'disabled',
+    hasPreviousResponse: Boolean(previousResponseId),
+    continuing,
+    continuationAttempt: continuationState.attempts
   });
   const controller = new AbortController();
   activeRequests.add(controller);
+  let abortReason = '';
+  const lifecycle = createProviderStreamLifecycle({
+    controller,
+    idleTimeoutMs: resolveProviderIdleTimeoutMs(launch),
+    totalTimeoutMs: resolveProviderTotalTimeoutMs(launch),
+    onAbort: reason => { abortReason = reason; }
+  });
   const onClientClose = () => {
-    if (!res.writableEnded) controller.abort();
+    if (!res.writableEnded) lifecycle.abort('client_close');
   };
   req.on('aborted', onClientClose);
   res.on('close', onClientClose);
-  const timeout = setTimeout(() => controller.abort(), resolveTimeout(launch));
+  lifecycle.start();
   try {
     const upstream = await fetchWithRectification(launch, translated.body, controller.signal);
+    lifecycle.touch();
     if (!upstream.response.ok) {
       forwardUpstreamError(upstream.response, upstream.errorText, res, launch.apiKey);
       return;
@@ -102,14 +142,48 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
       model: translated.body.model,
       toolContext: translated.toolContext
     };
-    const remember = converted => rememberHistory(history, converted.response.id, [
-      ...(upstream.requestBody.messages || translated.messages),
-      { role: 'assistant', content: converted.assistantBlocks }
-    ]);
+    const remember = converted => {
+      const baseMessages = upstream.requestBody.messages || translated.messages;
+      const continuation = buildAnthropicHistoryContinuation(converted);
+      const anchored = continuation.length > 0;
+      const assistantMessages = anchored
+        ? continuation
+        : [{ role: 'assistant', content: converted.assistantBlocks }];
+      const messages = [...baseMessages, ...assistantMessages];
+      if (anchored) {
+        continuationState.anchorMessages = messages;
+        continuationState.attempts += 1;
+        continuationState.responseId = converted.response.id;
+      } else {
+        continuationState.anchorMessages = [];
+        continuationState.attempts = 0;
+        continuationState.responseId = '';
+      }
+      rememberHistory(history, converted.response.id, messages, { continuation: anchored });
+      const blocks = Array.isArray(converted.assistantBlocks) ? converted.assistantBlocks : [];
+      logDebug('provider.anthropic.response', {
+        responseId: converted.response.id,
+        status: converted.response.status,
+        incompleteReason: converted.response.incomplete_details?.reason || '',
+        blockTypes: blocks.map(block => String(block?.type || 'unknown')),
+        textChars: blocks.reduce((total, block) => total + (block?.type === 'text' ? String(block.text || '').length : 0), 0),
+        thinkingChars: blocks.reduce((total, block) => total + (block?.type === 'thinking' ? String(block.thinking || '').length : 0), 0),
+        signedThinkingBlocks: blocks.filter(block => block?.type === 'thinking' && block.signature).length,
+        continuationAnchored: anchored,
+        continuationAttempt: continuationState.attempts
+      });
+    };
     const contentType = String(upstream.response.headers.get('content-type') || '').toLowerCase();
     if (requestBody.stream !== false) {
       if (contentType.includes('text/event-stream')) {
-        await streamAnthropicResponse({ upstream: upstream.response, res, context, onComplete: remember });
+        await streamAnthropicResponse({
+          upstream: upstream.response,
+          res,
+          context,
+          onComplete: remember,
+          onActivity: lifecycle.touch,
+          recoverInterrupted: lifecycle.recoverInterrupted
+        });
       } else {
         const converted = convertAnthropicResponse(await upstream.response.json(), context);
         writeConvertedResponseAsSse(res, converted, context, remember);
@@ -117,7 +191,14 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
     } else if (contentType.includes('text/event-stream')) {
       let converted;
       const sink = { writeHead() {}, write() {}, end() {} };
-      await streamAnthropicResponse({ upstream: upstream.response, res: sink, context, onComplete: value => { converted = value; } });
+      await streamAnthropicResponse({
+        upstream: upstream.response,
+        res: sink,
+        context,
+        onComplete: value => { converted = value; },
+        onActivity: lifecycle.touch,
+        recoverInterrupted: lifecycle.recoverInterrupted
+      });
       remember(converted);
       sendJson(res, 200, converted.response);
     } else {
@@ -126,10 +207,17 @@ async function handleRequest({ req, res, launch, clientToken, activeRequests, hi
       sendJson(res, 200, converted.response);
     }
   } catch (error) {
-    if (controller.signal.aborted) throw providerError('provider_connection_timeout', 'The provider request was cancelled or timed out.');
+    if (controller.signal.aborted) {
+      throw providerError(
+        'provider_connection_timeout',
+        abortReason === 'total_timeout'
+          ? 'The provider exceeded the maximum total request duration.'
+          : 'The provider stopped producing data before the request completed.'
+      );
+    }
     throw error;
   } finally {
-    clearTimeout(timeout);
+    lifecycle.dispose();
     activeRequests.delete(controller);
     req.removeListener('aborted', onClientClose);
     res.removeListener('close', onClientClose);
@@ -202,20 +290,64 @@ function forwardUpstreamError(response, errorText, res, apiKey) {
   sendJsonError(res, response.status, 'provider_upstream_error', sanitizeProviderMessage(message, [apiKey]));
 }
 
-function rememberHistory(history, responseId, messages) {
+function rememberHistory(history, responseId, messages, metadata = {}) {
   history.delete(responseId);
-  history.set(responseId, { messages });
+  history.set(responseId, { messages, ...metadata });
   while (history.size > MAX_HISTORY_ENTRIES) history.delete(history.keys().next().value);
 }
 
-function resolveTimeout(launch = {}) {
-  const configured = Math.min(300000, Math.max(5000, Number(launch.requestTimeoutMs) || 30000));
-  const thinking = !['', 'none', 'off', 'disabled'].includes(String(launch.reasoningEffort || '').toLowerCase());
-  return thinking ? Math.max(120000, configured) : configured;
+function buildAnthropicHistoryContinuation(converted = {}) {
+  if (converted.response?.status !== 'incomplete') return [];
+  if (converted.response?.incomplete_details?.reason !== 'max_output_tokens') return [];
+  const blocks = Array.isArray(converted.assistantBlocks) ? converted.assistantBlocks : [];
+  if (blocks.some(block => block?.type === 'tool_use')) return [];
+  const assistantContent = [];
+  const unsignedThinking = [];
+  for (const block of blocks) {
+    if (block?.type === 'thinking') {
+      const thinking = String(block.thinking || '');
+      const signature = String(block.signature || '');
+      if (signature) assistantContent.push({ type: 'thinking', thinking, signature });
+      else if (thinking) unsignedThinking.push(thinking);
+      continue;
+    }
+    if (block?.type === 'redacted_thinking' && block.data) {
+      assistantContent.push({ type: 'redacted_thinking', data: block.data });
+      continue;
+    }
+    if (block?.type === 'text' && block.text) {
+      assistantContent.push({ type: 'text', text: String(block.text) });
+    }
+  }
+  if (!assistantContent.length && !unsignedThinking.length) return [];
+
+  const messages = [];
+  if (assistantContent.length) messages.push({ role: 'assistant', content: assistantContent });
+  const partial = unsignedThinking.join('\n\n').trim();
+  const retained = partial.length > MAX_CONTINUATION_CHARS
+    ? partial.slice(-MAX_CONTINUATION_CHARS)
+    : partial;
+  const preservedTail = retained
+    ? `\n\nPreserved unfinished reasoning tail:\n${retained}`
+    : '';
+  messages.push({
+    role: 'user',
+    content: [{
+      type: 'text',
+      text: `${REASONING_CONTINUATION_MARKER}\nThe previous provider response reached its output limit. Continue from the exact unfinished point. Do not reread files already analyzed, repeat prior analysis, restate the plan, or restart the task. Complete the remaining work and produce the final answer.${preservedTail}`
+    }]
+  });
+  return messages;
 }
 
 function normalizeBridgeErrorCode(value) {
-  return ['provider_connection_timeout', 'provider_response_invalid', 'provider_request_invalid', 'provider_upstream_error'].includes(value)
+  return [
+    'provider_connection_timeout',
+    'provider_reasoning_continuation_exhausted',
+    'provider_response_invalid',
+    'provider_request_invalid',
+    'provider_upstream_error'
+  ].includes(value)
     ? value
     : 'provider_bridge_failed';
 }
@@ -275,6 +407,7 @@ function closeServer(server) {
 }
 
 module.exports = {
+  buildAnthropicHistoryContinuation,
   buildAnthropicHeaders,
   buildAnthropicMessagesUrl,
   startAnthropicMessagesBridge

package/native-host/src/chatBridgeRequest.js

@@ -36,7 +36,7 @@ function buildChatRequest({ requestBody = {}, launch = {}, historyMessages = []
   copyNumber(requestBody, body, 'temperature');
   copyNumber(requestBody, body, 'top_p');
   const maxOutputTokens = resolveReasoningMaxOutputTokens(
-    requestBody.max_output_tokens ?? launch.maxOutputTokens,
+    launch.maxOutputTokens ?? requestBody.max_output_tokens,
     requestBody,
     launch,
     model

package/native-host/src/chatBridgeResponse.js

@@ -2,6 +2,7 @@
 
 const crypto = require('node:crypto');
 const { requiresReasoningContentReplay } = require('./providerReasoning');
+const MAX_STREAM_BUFFER_BYTES = 8 * 1024 * 1024;
 
 function convertChatResponse(chat = {}, context = {}) {
   const choice = Array.isArray(chat.choices) ? chat.choices[0] || {} : {};
@@ -56,6 +57,9 @@ async function streamChatResponse({
     for await (const chunk of upstream.body || []) {
       onActivity();
       buffer += decoder.decode(chunk, { stream: true });
+      if (Buffer.byteLength(buffer, 'utf8') > MAX_STREAM_BUFFER_BYTES) {
+        throw responseError('Provider stream frame exceeded the local bridge limit.', 'provider_stream_frame_too_large');
+      }
       let boundary = findSseBoundary(buffer);
       while (boundary) {
         const block = buffer.slice(0, boundary.index);
@@ -240,7 +244,7 @@ function completeStream(state, res, interruptedReason = '') {
   const tools = Array.from(state.tools.values()).sort((a, b) => a.index - b.index);
   for (const tool of tools) completeTool(state, res, tool);
   const terminal = interruptedReason
-    ? { status: 'incomplete', incompleteReason: 'max_output_tokens' }
+    ? { status: 'incomplete', incompleteReason: interruptedReason }
     : mapChatFinishReason(state.finishReason);
   const response = streamEnvelope(state, terminal.status, terminal.incompleteReason);
   emit(
@@ -470,24 +474,24 @@ function extractReasoning(message = {}) {
 
 function mapChatFinishReason(value) {
   const reason = normalizeText(value).trim().toLowerCase();
-  if (['length', 'max_tokens', 'max_output_tokens', 'model_context_window_exceeded'].includes(reason)) {
+  if (['length', 'max_tokens', 'max_output_tokens'].includes(reason)) {
     return { status: 'incomplete', incompleteReason: 'max_output_tokens' };
   }
+  if (reason === 'model_context_window_exceeded') {
+    return { status: 'incomplete', incompleteReason: 'context_window_exceeded' };
+  }
   if (['content_filter', 'content-filter', 'refusal', 'safety'].includes(reason)) {
     return { status: 'incomplete', incompleteReason: 'content_filter' };
   }
   if (['insufficient_system_resource', 'insufficient-system-resource', 'resource_exhausted'].includes(reason)) {
-    // The Responses API has no portable provider-resource incomplete reason.
-    // Treat the partial generation like an output truncation so Codex can
-    // continue it through the bounded history-anchor path.
-    return { status: 'incomplete', incompleteReason: 'max_output_tokens' };
+    return { status: 'incomplete', incompleteReason: 'provider_resource_exhausted' };
   }
   return { status: 'completed', incompleteReason: null };
 }
 
-function responseError(message) {
+function responseError(message, code = 'provider_response_invalid') {
   const error = new Error(message);
-  error.code = 'provider_response_invalid';
+  error.code = code;
   return error;
 }
 

package/native-host/src/chatCompletionsBridge.js

@@ -13,6 +13,11 @@ const { classifyResponsesRoute } = require('./providerBridgeRoutes');
 const { providerError } = require('./providerProfile');
 const { sanitizeProviderMessage } = require('./providerRedaction');
 const { logDebug } = require('./debugLog');
+const {
+  createProviderStreamLifecycle,
+  resolveProviderIdleTimeoutMs,
+  resolveProviderTotalTimeoutMs
+} = require('./providerStreamLifecycle');
 
 const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 const MAX_ERROR_BYTES = 64 * 1024;
@@ -57,9 +62,10 @@ async function startChatCompletionsBridge({ launch, signal } = {}) {
       }
     });
   });
-  const requestTimeoutMs = resolveRequestTimeoutMs(launch);
+  const requestTimeoutMs = resolveProviderIdleTimeoutMs(launch);
+  const totalTimeoutMs = resolveProviderTotalTimeoutMs(launch, requestTimeoutMs);
   server.keepAliveTimeout = 5000;
-  server.requestTimeout = requestTimeoutMs + 5000;
+  server.requestTimeout = totalTimeoutMs + 5000;
   await listen(server);
   const address = server.address();
   const baseUrl = `http://127.0.0.1:${address.port}/v1`;
@@ -121,8 +127,8 @@ async function handleRequest({
     historyMessages: previous?.messages || fallbackAnchor
   });
   assertReasoningContinuationBudget(translated.messages, continuationState.attempts);
-  const idleTimeoutMs = resolveRequestTimeoutMs(launch);
-  const totalTimeoutMs = resolveTotalRequestTimeoutMs(launch, idleTimeoutMs);
+  const idleTimeoutMs = resolveProviderIdleTimeoutMs(launch);
+  const totalTimeoutMs = resolveProviderTotalTimeoutMs(launch, idleTimeoutMs);
   logDebug('provider.bridge.request', {
     traceId,
     providerName: launch.providerName,
@@ -142,23 +148,18 @@ async function handleRequest({
   const controller = new AbortController();
   activeRequests.add(controller);
   let abortReason = '';
-  let idleTimeout;
-  const abortRequest = reason => {
-    if (controller.signal.aborted) return;
-    abortReason = reason;
-    controller.abort();
-  };
-  const refreshIdleTimeout = () => {
-    clearTimeout(idleTimeout);
-    idleTimeout = setTimeout(() => abortRequest('idle_timeout'), idleTimeoutMs);
-  };
+  const lifecycle = createProviderStreamLifecycle({
+    controller,
+    idleTimeoutMs,
+    totalTimeoutMs,
+    onAbort: reason => { abortReason = reason; }
+  });
   const onClientClose = () => {
-    if (!res.writableEnded) abortRequest('client_close');
+    if (!res.writableEnded) lifecycle.abort('client_close');
   };
   req.on('aborted', onClientClose);
   res.on('close', onClientClose);
-  refreshIdleTimeout();
-  const totalTimeout = setTimeout(() => abortRequest('total_timeout'), totalTimeoutMs);
+  lifecycle.start();
   try {
     const upstream = await fetch(buildChatCompletionsUrl(launch.baseUrl, launch), {
       method: 'POST',
@@ -166,7 +167,7 @@ async function handleRequest({
       body: JSON.stringify(translated.body),
       signal: controller.signal
     });
-    refreshIdleTimeout();
+    lifecycle.touch();
     if (!upstream.ok) {
       await forwardUpstreamError(upstream, res, launch.apiKey);
       return;
@@ -226,12 +227,8 @@ async function handleRequest({
           res,
           context,
           onComplete: remember,
-          onActivity: refreshIdleTimeout,
-          recoverInterrupted: () => (
-            ['idle_timeout', 'total_timeout'].includes(abortReason)
-              ? abortReason
-              : ''
-          )
+          onActivity: lifecycle.touch,
+          recoverInterrupted: lifecycle.recoverInterrupted
         });
       } else {
         const converted = convertChatResponse(await upstream.json(), context);
@@ -255,8 +252,7 @@ async function handleRequest({
     }
     throw error;
   } finally {
-    clearTimeout(idleTimeout);
-    clearTimeout(totalTimeout);
+    lifecycle.dispose();
     activeRequests.delete(controller);
     req.removeListener('aborted', onClientClose);
     res.removeListener('close', onClientClose);
@@ -309,20 +305,6 @@ function buildUpstreamHeaders(launch = {}) {
   return headers;
 }
 
-function resolveRequestTimeoutMs(launch = {}) {
-  const configured = Math.min(300000, Math.max(5000, Number(launch.requestTimeoutMs) || 30000));
-  const deepSeekThinking = requiresReasoningContentReplay(launch, launch.modelId)
-    && String(launch.reasoningEffort || '').toLowerCase() !== 'none';
-  return deepSeekThinking ? Math.max(120000, configured) : configured;
-}
-
-function resolveTotalRequestTimeoutMs(launch = {}, idleTimeoutMs = resolveRequestTimeoutMs(launch)) {
-  const deepSeekThinking = requiresReasoningContentReplay(launch, launch.modelId)
-    && String(launch.reasoningEffort || '').toLowerCase() !== 'none';
-  const floor = deepSeekThinking ? 30 * 60 * 1000 : 5 * 60 * 1000;
-  return Math.max(floor, idleTimeoutMs * 2);
-}
-
 function buildHistoryContinuation(converted = {}) {
   const assistant = converted.assistantMessage || {};
   const reasoning = typeof assistant.reasoning_content === 'string'

package/native-host/src/codexPromptAssembly.js

@@ -268,7 +268,9 @@ function formatMathOutputRules() {
   return [
     '- In user-visible prose, format inline mathematics as $...$ and display mathematics as $$...$$ on separate lines.',
     '- Never wrap mathematical expressions in backticks or fenced code blocks unless you are showing literal source code.',
-    '- Do not emit bare TeX commands as prose when explicit math delimiters can express the same formula.'
+    '- Do not emit bare TeX commands as prose when explicit math delimiters can express the same formula.',
+    '- Keep prose outside math delimiters. Inside mathematics, wrap necessary words with \\text{...} and use \\mid for conditional bars.',
+    '- For long display equations, use \\begin{aligned}...\\end{aligned} and place explicit row breaks near relation operators.'
   ].join('\n');
 }
 

package/native-host/src/codexProviderLaunch.js

@@ -2,6 +2,7 @@
 
 const { startChatCompletionsBridge } = require('./chatCompletionsBridge');
 const { startAnthropicMessagesBridge } = require('./anthropicMessagesBridge');
+const { startResponsesPassthroughBridge } = require('./responsesPassthroughBridge');
 const { prepareProviderModelCatalog } = require('./providerModelCatalog');
 
 const PROVIDER_CONFIG_ID = 'codex_overleaf_custom';
@@ -49,21 +50,23 @@ function createProviderLaunch({ profile, secret = '', modelId, wireApi, reasonin
     anthropicThinkingMode: profile.anthropicThinkingMode || 'budget',
     anthropicPromptCaching: profile.anthropicPromptCaching === true,
     impersonateClaudeCode: profile.impersonateClaudeCode === true,
-    maxOutputTokens: profile.maxOutputTokens || 32768,
+    maxOutputTokens: profile.maxOutputTokens || 65536,
     apiKey: secret
   });
 }
 
 async function prepareProviderLaunch(launch, { signal } = {}) {
   const catalog = prepareProviderModelCatalog(launch);
-  if (!catalog.launch || !['chat', 'anthropic'].includes(catalog.launch.wireApi)) {
+  if (!catalog.launch || !['responses', 'chat', 'anthropic'].includes(catalog.launch.wireApi)) {
     return { launch: catalog.launch, close: async () => catalog.close() };
   }
   try {
     const routedWireApi = catalog.launch.wireApi;
     const bridge = routedWireApi === 'anthropic'
       ? await startAnthropicMessagesBridge({ launch: catalog.launch, signal })
-      : await startChatCompletionsBridge({ launch: catalog.launch, signal });
+      : routedWireApi === 'chat'
+        ? await startChatCompletionsBridge({ launch: catalog.launch, signal })
+        : await startResponsesPassthroughBridge({ launch: catalog.launch, signal });
     return {
       launch: Object.freeze({
         ...catalog.launch,