@galaxy-yearn/codex-deepseek-gateway 0.2.0 → 0.2.2

package/src/server.js

@@ -21,7 +21,7 @@ import {
   toProviderChatCompletionsRequest,
   unavailableWebSearchToolShims,
 } from './protocol.js';
-import { SessionStore } from './session-store.js';
+import { ReasoningCache } from './reasoning-cache.js';
 import { callChatCompletions, callModels, readJsonResponse, relayChatCompletionsResponse } from './upstream.js';
 import {
   annotateMessagePartWithWebCitations,
@@ -32,7 +32,6 @@ import {
   hasAnyToolCalls,
   hasKnownExternalToolCalls,
   hasUnknownExternalToolCalls,
-  INTERNAL_WEB_SEARCH_TOOL,
   maxWebSearchRounds,
   prepareWebSearchRequest,
   removeWebSearchInstructions,
@@ -62,6 +61,14 @@ function getRequestPath(req) {
   return url.pathname;
 }
 
+function codexRequestKind(req) {
+  const value = req.headers['x-codex-turn-metadata'];
+  if (typeof value !== 'string') return '';
+  const parsed = safeJsonParse(value);
+  if (!parsed.ok || !parsed.value || typeof parsed.value !== 'object') return '';
+  return String(parsed.value.request_kind || '');
+}
+
 function isAuthorized(req, config) {
   if (!config.proxyApiKey) return true;
   const authorization = req.headers.authorization || '';
@@ -69,29 +76,7 @@ function isAuthorized(req, config) {
   return bearerToken === config.proxyApiKey || req.headers['x-api-key'] === config.proxyApiKey;
 }
 
-function conversationIdFromRequest(request, normalized) {
-  const conversation = normalized.conversation ?? request.conversation;
-  if (typeof conversation === 'string') return conversation;
-  if (conversation && typeof conversation === 'object') return conversation.id || conversation.conversation_id || null;
-  return request.conversation_id || null;
-}
-
-function historyMessagesFromSession(session) {
-  return Array.isArray(session?.messages) ? session.messages : [];
-}
-
-function sessionMessages(chatMessages, assistantMessage) {
-  const messages = Array.isArray(chatMessages) ? chatMessages.slice() : [];
-  if (assistantMessage) messages.push(assistantMessage);
-  return messages;
-}
-
-function shouldPersistSession(normalized, request, conversationId) {
-  if (conversationId) return true;
-  return (normalized.store ?? request.store) !== false;
-}
-
-function prependMissingAssistantToolMessages(messages, sessions) {
+function prependMissingAssistantToolMessages(messages, reasoningCache) {
   const existingToolCallIds = new Set();
   const missingToolOutputIds = [];
   for (const message of messages) {
@@ -111,7 +96,7 @@ function prependMissingAssistantToolMessages(messages, sessions) {
   const inserted = new Set(existingToolCallIds);
   for (const callId of missingToolOutputIds) {
     if (inserted.has(callId)) continue;
-    const assistantMessage = sessions.getAssistantMessageForToolCall(callId);
+    const assistantMessage = reasoningCache.getAssistantMessageForToolCall(callId);
     if (!assistantMessage) continue;
     prefix.push(assistantMessage);
     for (const id of extractToolCallIdsFromMessages([assistantMessage])) inserted.add(id);
@@ -119,14 +104,14 @@ function prependMissingAssistantToolMessages(messages, sessions) {
   return prefix.length ? prefix.concat(messages) : messages;
 }
 
-function restoreAssistantReasoningContent(messages, sessions) {
+function restoreAssistantReasoningContent(messages, reasoningCache) {
   return messages.map((message) => {
     if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls) || !message.tool_calls.length) {
       return message;
     }
     if (typeof message.reasoning_content === 'string' && message.reasoning_content) return message;
     for (const toolCall of message.tool_calls) {
-      const stored = sessions.getAssistantMessageForToolCall(toolCall?.id);
+      const stored = reasoningCache.getAssistantMessageForToolCall(toolCall?.id);
       if (typeof stored?.reasoning_content === 'string' && stored.reasoning_content) {
         return { ...message, reasoning_content: stored.reasoning_content };
       }
@@ -242,16 +227,15 @@ function webToolTimeoutMs(config = {}) {
 function combineUsage(completions) {
   const usages = completions.map((completion) => completion?.usage).filter(Boolean);
   if (!usages.length) return null;
-  const last = usages[usages.length - 1];
   const sum = (pick) => usages.reduce((total, usage) => total + (Number(pick(usage)) || 0), 0);
-  const promptTokens = Number(last.prompt_tokens) || 0;
+  const promptTokens = sum((usage) => usage.prompt_tokens);
   const completionTokens = sum((usage) => usage.completion_tokens);
   return {
     prompt_tokens: promptTokens,
     completion_tokens: completionTokens,
     total_tokens: promptTokens + completionTokens,
     prompt_tokens_details: {
-      cached_tokens: last.prompt_tokens_details?.cached_tokens ?? last.prompt_cache_hit_tokens ?? 0,
+      cached_tokens: sum((usage) => usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens),
     },
     completion_tokens_details: {
       reasoning_tokens: sum((usage) => usage.completion_tokens_details?.reasoning_tokens ?? usage.reasoning_tokens),
@@ -259,27 +243,53 @@ function combineUsage(completions) {
   };
 }
 
-function cloneCompletionWithUsage(completion, usage) {
-  if (!usage) return completion;
-  return {
-    ...completion,
-    usage,
-  };
+function lastUsage(usages) {
+  for (let index = usages.length - 1; index >= 0; index -= 1) {
+    if (usages[index]) return usages[index];
+  }
+  return null;
+}
+
+function withUsageFallback(completion, usage) {
+  if (!completion || completion.usage || !usage) return completion;
+  return { ...completion, usage };
+}
+
+function toWebSearchUpstreamRequest(chatRequest, config, webTools) {
+  const request = toProviderChatCompletionsRequest(chatRequest, config);
+  if (
+    request.thinking?.type === 'enabled' &&
+    request.tool_choice?.type === 'function' &&
+    request.tool_choice.function?.name === webTools?.search
+  ) {
+    return { ...request, thinking: { type: 'disabled' }, reasoning_effort: undefined };
+  }
+  return request;
+}
+
+function logWebSearchUsage(config, stage, usages, finalUsage) {
+  if (!config.debugPayload) return;
+  const aggregateUsage = combineUsage(usages.map((usage) => ({ usage })));
+  if (!aggregateUsage && !finalUsage) return;
+  writeDebugPayloadLine(config, `[codex-deepseek-gateway] web search usage ${JSON.stringify({
+    stage,
+    rounds: usages.length,
+    aggregate: aggregateUsage,
+    final: finalUsage || null,
+  })}\n`);
 }
 
-function toolCallsToFinalAnswerRequest(request) {
+function toolCallsToFinalAnswerRequest(request, webTools) {
   return {
     ...request,
     tool_choice: undefined,
     tools: undefined,
-    messages: removeWebSearchInstructions(request.messages).concat({
+    messages: removeWebSearchInstructions(request.messages, webTools).concat({
       role: 'user',
       content: [
-        'Web tools are not available now.',
-        'Use the completed tool results already provided in this conversation.',
-        'Give the final answer now as visible assistant message content.',
-        'Do not write tool calls, DSML, XML, or JSON tool-call blocks in the answer.',
-        'If the available tool results are incomplete, say what is missing and answer only what the provided context supports.',
+        'Web tools are now unavailable.',
+        'Answer now using only completed tool results as visible assistant text, without tool calls or tool-call markup.',
+        'If results are incomplete, state what is missing and do not infer beyond them.',
       ].join(' '),
     }),
   };
@@ -407,6 +417,8 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
   const effectiveChatRequest = { ...chatRequest, normalized };
   const state = prepareWebSearchRequest({ normalized, chatRequest: effectiveChatRequest, config });
   const searchConfig = state.config || config;
+  const webTools = state.webTools;
+  const webCache = state.webCache;
   let currentChatRequest = state.enabled ? state.chatRequest : effectiveChatRequest;
   const completions = [];
   const searches = [];
@@ -417,8 +429,8 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
   const maxRounds = maxWebSearchRounds(searchConfig);
 
   async function requestFinalAnswer(baseRequest) {
-    currentChatRequest = toolCallsToFinalAnswerRequest(baseRequest);
-    const upstreamRequest = toProviderChatCompletionsRequest(currentChatRequest, config);
+    currentChatRequest = toolCallsToFinalAnswerRequest(baseRequest, webTools);
+    const upstreamRequest = toWebSearchUpstreamRequest(currentChatRequest, config, webTools);
     if (!upstreamRequest.model) upstreamRequest.model = config.upstreamModel || currentChatRequest.model;
     logDebugPayload(config, upstreamRequest, {
       stage: 'web_search_final_answer',
@@ -444,7 +456,7 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
   }
 
   for (let round = 0; round <= maxRounds + 1; round += 1) {
-    const upstreamRequest = toProviderChatCompletionsRequest(currentChatRequest, config);
+    const upstreamRequest = toWebSearchUpstreamRequest(currentChatRequest, config, webTools);
     if (!upstreamRequest.model) upstreamRequest.model = config.upstreamModel || currentChatRequest.model;
     logDebugPayload(config, upstreamRequest, {
       stage: `web_search_round_${round}`,
@@ -465,9 +477,9 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
     const commentaryCalls = bridgedCommentaryToolCallsFromMessage(roundChatMessage, currentChatRequest.tools);
     const routingData = stripBridgedCommentaryFromCompletion(data, currentChatRequest.tools);
 
-    if (state.enabled && hasKnownExternalToolCalls(routingData, currentChatRequest.tools)) {
+    if (state.enabled && hasKnownExternalToolCalls(routingData, currentChatRequest.tools, webTools)) {
       finalCompletion = restoreCommentaryToolCalls(
-        knownExternalToolCallsCompletion(routingData, currentChatRequest.tools),
+        knownExternalToolCallsCompletion(routingData, currentChatRequest.tools, webTools),
         commentaryCalls,
       );
       completions[completions.length - 1] = finalCompletion;
@@ -478,15 +490,16 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
       break;
     }
 
-    const wantsInternalWeb = shouldContinueWebSearchLoop(routingData);
+    const wantsInternalWeb = shouldContinueWebSearchLoop(routingData, webTools);
     const wantsInternalRound = wantsInternalWeb || commentaryCalls.length > 0;
     const hasToolCalls = hasAnyToolCalls(routingData);
 
     if (!wantsInternalRound || round >= maxRounds) {
-      if (hasToolCalls && hasUnknownExternalToolCalls(routingData, currentChatRequest.tools)) {
+      if (hasToolCalls && hasUnknownExternalToolCalls(routingData, currentChatRequest.tools, webTools)) {
         const unsupportedMessages = unhandledToolMessagesFromCompletion(routingData, undefined, {
           onlyUnknownExternal: true,
           tools: currentChatRequest.tools,
+          webTools,
         });
         const finalAnswerError = await requestFinalAnswer({
           ...currentChatRequest,
@@ -511,6 +524,8 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
       toolResult = await executeWebSearchCalls({
         completion: data,
         config: searchConfig,
+        webTools,
+        webCache,
         signal: mergeAbortSignals([controller.signal, clientSignal]),
         onSearchStart,
         onSearchDone,
@@ -524,18 +539,22 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
       ...currentChatRequest,
       messages: currentChatRequest.messages.concat(toolResult.messages, commentaryToolMessages(commentaryCalls)),
       tool_choice:
-        currentChatRequest.tool_choice?.function?.name === INTERNAL_WEB_SEARCH_TOOL
+        currentChatRequest.tool_choice?.function?.name === webTools.search && toolResult.searches.length
           ? 'auto'
           : currentChatRequest.tool_choice,
     };
   }
 
+  const usages = completions.map((completion) => completion?.usage).filter(Boolean);
+  const reportedUsage = finalCompletion?.usage || lastUsage(usages);
+  logWebSearchUsage(config, 'web_search', usages, finalCompletion?.usage);
   return {
     ok: true,
     response: finalResponse,
-    completion: cloneCompletionWithUsage(finalCompletion, combineUsage(completions)),
+    completion: withUsageFallback(finalCompletion, reportedUsage),
     searches,
     openedPages,
+    webTools,
     chatRequest: currentChatRequest,
     incompleteReason,
   };
@@ -543,23 +562,48 @@ async function runWebSearchChatLoop({ rawRequest, normalized, chatRequest, confi
 
 const STREAM_HEARTBEAT_MS = 10000;
 
+function streamHeartbeatMs(config) {
+  const value = Number(config?.streamHeartbeatMs);
+  if (Number.isFinite(value) && value > 0) return value;
+  return STREAM_HEARTBEAT_MS;
+}
+
+function startStreamHeartbeat({ config, res, write }) {
+  const heartbeatMs = streamHeartbeatMs(config);
+  let lastActivityAt = Date.now();
+  let timer = null;
+  const stop = () => {
+    if (timer) clearInterval(timer);
+    timer = null;
+    res.off('close', stop);
+  };
+  timer = setInterval(() => {
+    if (res.writableEnded || res.destroyed || Date.now() - lastActivityAt < heartbeatMs) return;
+    write();
+    lastActivityAt = Date.now();
+  }, heartbeatMs);
+  res.once('close', stop);
+  return {
+    activity() {
+      lastActivityAt = Date.now();
+    },
+    stop,
+  };
+}
+
 function writeSseEvent(res, event) {
   if (res.writableEnded || res.destroyed) return;
   res.write(serializeResponsesSseEvent(event));
 }
 
-function writeSseDone(res) {
-  writeSseEvent(res, { done: true });
-}
-
-function webSearchSseWriter({ res, mapper, outputIndexBySearch, includeSources = false }) {
+function webSearchSseWriter({ writeEvent, mapper, outputIndexBySearch, includeSources = false }) {
   return {
     start(search) {
       const outputIndex = mapper.output.length;
       outputIndexBySearch.set(search.id, outputIndex);
       const item = buildWebSearchCallItem(search, { status: 'in_progress', includeSources });
       mapper.output.push(item);
-      writeSseEvent(res, {
+      writeEvent({
         type: 'response.output_item.added',
         sequence_number: mapper.nextSequence(),
         output_index: outputIndex,
@@ -570,7 +614,7 @@ function webSearchSseWriter({ res, mapper, outputIndexBySearch, includeSources =
       const outputIndex = outputIndexBySearch.get(search.id);
       const item = buildWebSearchCallItem(search, { includeSources });
       if (Number.isInteger(outputIndex)) mapper.output[outputIndex] = item;
-      writeSseEvent(res, {
+      writeEvent({
         type: 'response.output_item.done',
         sequence_number: mapper.nextSequence(),
         output_index: Number.isInteger(outputIndex) ? outputIndex : mapper.output.indexOf(item),
@@ -580,17 +624,19 @@ function webSearchSseWriter({ res, mapper, outputIndexBySearch, includeSources =
   };
 }
 
-async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest, config, res, responseId, previousResponseId, clientSignal }) {
+async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest, config, res, responseId, clientSignal }) {
   const effectiveChatRequest = { ...chatRequest, normalized };
   const state = prepareWebSearchRequest({ normalized, chatRequest: effectiveChatRequest, config });
   if (!state.enabled) return { handled: false };
 
   const searchConfig = state.config || config;
+  const webTools = state.webTools;
+  const webCache = state.webCache;
   const maxRounds = maxWebSearchRounds(searchConfig);
   let currentChatRequest = state.chatRequest;
 
   const buildUpstreamRequest = (stage) => {
-    const upstreamRequest = toProviderChatCompletionsRequest(currentChatRequest, config);
+    const upstreamRequest = toWebSearchUpstreamRequest(currentChatRequest, config, webTools);
     if (!upstreamRequest.model) upstreamRequest.model = config.upstreamModel || currentChatRequest.model;
     logDebugPayload(config, upstreamRequest, { stage, rawRequest, normalized, chatRequest: currentChatRequest });
     return upstreamRequest;
@@ -613,15 +659,19 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
     responseId,
     model: firstUpstreamRequest.model,
     createdAt: Math.floor(Date.now() / 1000),
-    previousResponseId,
     normalized,
     config,
     ...resolveReasoningStreamMode(config, firstUpstreamRequest),
     holdToolItemEvents: true,
     knownToolNames: chatToolNamesFromTools(firstUpstreamRequest.tools),
   });
+  let heartbeat = null;
+  const writeEvent = (event) => {
+    writeSseEvent(res, event);
+    heartbeat?.activity();
+  };
   const searchWriter = webSearchSseWriter({
-    res,
+    writeEvent,
     mapper,
     outputIndexBySearch: new Map(),
     includeSources: shouldIncludeSearchSources(normalized),
@@ -639,18 +689,20 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
     connection: 'keep-alive',
     'x-accel-buffering': 'no',
   });
-  writeSseEvent(res, mapper.createdEvent());
-  writeSseEvent(res, mapper.inProgressEvent());
-  const heartbeat = setInterval(() => {
-    writeSseEvent(res, mapper.inProgressEvent());
-  }, STREAM_HEARTBEAT_MS);
+  writeEvent(mapper.createdEvent());
+  writeEvent(mapper.inProgressEvent());
+  heartbeat = startStreamHeartbeat({
+    config,
+    res,
+    write: () => writeEvent(mapper.inProgressEvent()),
+  });
 
   const endStream = () => {
-    writeSseDone(res);
+    writeEvent({ done: true });
     res.end();
   };
   const failStream = (message) => {
-    for (const event of mapper.streamFailed(message)) writeSseEvent(res, event);
+    for (const event of mapper.streamFailed(message)) writeEvent(event);
     endStream();
     return { handled: true };
   };
@@ -658,12 +710,18 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
     if (mapper.messageItem?.content?.length) {
       annotateMessagePartWithWebCitations(mapper.messageItem.content[0], searches, openedPages);
     }
-    const combinedUsage = combineUsage(roundUsages.concat([{ usage: mapper.pendingUsage }]));
-    for (const event of mapper.finalize(mapper.pendingFinishReason || 'stop', combinedUsage)) {
-      writeSseEvent(res, event);
+    const usages = roundUsages.map((completion) => completion.usage).filter(Boolean).concat(mapper.pendingUsage ? [mapper.pendingUsage] : []);
+    const reportedUsage = mapper.pendingUsage || lastUsage(usages);
+    logWebSearchUsage(config, 'web_search_stream', usages, mapper.pendingUsage);
+    for (const event of mapper.finalize(mapper.pendingFinishReason || 'stop', reportedUsage)) {
+      writeEvent(event);
     }
     endStream();
-    return { handled: true, chatRequest: currentChatRequest, assistantMessage: mapper.roundAssistantMessage() };
+    return {
+      handled: true,
+      chatRequest: currentChatRequest,
+      assistantMessage: mapper.terminalStatus === 'completed' ? mapper.roundAssistantMessage() : null,
+    };
   };
   const relayRound = async () => {
     roundEnd = null;
@@ -680,7 +738,7 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
           return;
         }
         for (const responseEvent of mapper.mapChatEvent(event)) {
-          writeSseEvent(res, responseEvent);
+          writeEvent(responseEvent);
         }
       },
     });
@@ -698,7 +756,7 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
       mapper.expandParallelToolItems();
       const roundMessage = mapper.roundAssistantMessage();
       const commentaryCalls = bridgedCommentaryToolCallsFromMessage(roundMessage, currentChatRequest.tools);
-      for (const event of mapper.convertBridgedCommentaryItems()) writeSseEvent(res, event);
+      for (const event of mapper.convertBridgedCommentaryItems()) writeEvent(event);
       const completionLike = {
         choices: [{ index: 0, message: roundMessage, finish_reason: mapper.pendingFinishReason || 'stop' }],
       };
@@ -709,13 +767,13 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
         const reason = finalAnswerIncompleteReason(routingCompletion);
         if (reason) {
           const events = mapper.replaceBufferedAssistantText(gatewayIncompleteMessageContent(reason));
-          for (const event of events || []) writeSseEvent(res, event);
+          for (const event of events || []) writeEvent(event);
         }
         return finishTurn();
       }
 
-      if (hasKnownExternalToolCalls(routingCompletion, currentChatRequest.tools)) {
-        const kept = knownExternalToolCallsCompletion(routingCompletion, currentChatRequest.tools);
+      if (hasKnownExternalToolCalls(routingCompletion, currentChatRequest.tools, webTools)) {
+        const kept = knownExternalToolCallsCompletion(routingCompletion, currentChatRequest.tools, webTools);
         const keptIds = new Set(
           (kept.choices?.[0]?.message?.tool_calls || []).map((toolCall) => toolCall.id).filter(Boolean),
         );
@@ -723,33 +781,34 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
         return finishTurn();
       }
 
-      const wantsInternalWeb = shouldContinueWebSearchLoop(routingCompletion);
+      const wantsInternalWeb = shouldContinueWebSearchLoop(routingCompletion, webTools);
       const wantsInternalRound = wantsInternalWeb || commentaryCalls.length > 0;
       const hasToolCallsRound = hasAnyToolCalls(routingCompletion);
 
       if (!wantsInternalRound || round >= maxRounds) {
-        if (hasToolCallsRound && hasUnknownExternalToolCalls(routingCompletion, currentChatRequest.tools)) {
+        if (hasToolCallsRound && hasUnknownExternalToolCalls(routingCompletion, currentChatRequest.tools, webTools)) {
           const unsupportedMessages = unhandledToolMessagesFromCompletion(routingCompletion, undefined, {
             onlyUnknownExternal: true,
             tools: currentChatRequest.tools,
+            webTools,
           });
           currentChatRequest = toolCallsToFinalAnswerRequest({
             ...currentChatRequest,
             messages: currentChatRequest.messages.concat(unsupportedMessages),
-          });
+          }, webTools);
         } else if (wantsInternalRound || (!hasToolCallsRound && hasWebSearchContext(searches, openedPages) && !hasVisibleAssistantContent(routingCompletion))) {
-          currentChatRequest = toolCallsToFinalAnswerRequest(currentChatRequest);
+          currentChatRequest = toolCallsToFinalAnswerRequest(currentChatRequest, webTools);
         } else {
           return finishTurn();
         }
         finalAnswerForced = true;
         roundUsages.push({ usage: mapper.pendingUsage });
         mapper.removeToolItems();
-        for (const event of mapper.beginNextRound()) writeSseEvent(res, event);
+        for (const event of mapper.beginNextRound()) writeEvent(event);
         mapper.holdVisibleTextUntilDone();
       } else {
         roundUsages.push({ usage: mapper.pendingUsage });
-        for (const event of mapper.beginNextRound()) writeSseEvent(res, event);
+        for (const event of mapper.beginNextRound()) writeEvent(event);
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), webToolTimeoutMs(searchConfig));
         let toolResult;
@@ -757,6 +816,8 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
           toolResult = await executeWebSearchCalls({
             completion: completionLike,
             config: searchConfig,
+            webTools,
+            webCache,
             signal: mergeAbortSignals([controller.signal, clientSignal]),
             onSearchStart(search) {
               if (search.action && search.auto) return;
@@ -777,7 +838,7 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
           ...currentChatRequest,
           messages: currentChatRequest.messages.concat(toolResult.messages, commentaryToolMessages(commentaryCalls)),
           tool_choice:
-            currentChatRequest.tool_choice?.function?.name === INTERNAL_WEB_SEARCH_TOOL
+            currentChatRequest.tool_choice?.function?.name === webTools.search && toolResult.searches.length
               ? 'auto'
               : currentChatRequest.tool_choice,
         };
@@ -806,15 +867,16 @@ async function runStreamingWebSearchTurn({ rawRequest, normalized, chatRequest,
     }
     throw error;
   } finally {
-    clearInterval(heartbeat);
+    heartbeat?.stop();
   }
 }
 
-export function createProxyServer({ config = loadConfig(), sessions } = {}) {
-  sessions ||= new SessionStore({
-    persistPath: config.sessionStoreEnabled === false ? '' : config.sessionStorePath,
-    maxSessions: config.sessionStoreMaxSessions,
-    maxBytes: config.sessionStoreMaxBytes,
+export function createProxyServer({ config = loadConfig(), reasoningCache } = {}) {
+  reasoningCache ||= new ReasoningCache({
+    persistPath: config.reasoningCacheEnabled === false ? '' : config.reasoningCachePath,
+    legacyPath: config.legacyReasoningCachePath,
+    maxMessages: config.reasoningCacheMaxMessages,
+    maxBytes: config.reasoningCacheMaxBytes,
   });
   let modelCache = null;
 
@@ -852,16 +914,11 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
     }
 
     const request = parsed.value;
-    const normalized = normalizeResponsesRequest(request);
-    const previousResponseId = normalized.previous_response_id || request.previous_response_id || null;
-    const conversationId = conversationIdFromRequest(request, normalized);
-    const priorSession = previousResponseId ? sessions.get(previousResponseId) : conversationId ? sessions.getConversation(conversationId) : null;
-    const priorMessages = historyMessagesFromSession(priorSession);
-    if (priorMessages.length) {
-      normalized.messages = priorMessages.concat(normalized.messages);
-    }
-    normalized.messages = prependMissingAssistantToolMessages(normalized.messages, sessions);
-    normalized.messages = restoreAssistantReasoningContent(normalized.messages, sessions);
+    const normalized = normalizeResponsesRequest(request, {
+      restoreDiscoveredTools: codexRequestKind(req) !== 'compaction',
+    });
+    normalized.messages = prependMissingAssistantToolMessages(normalized.messages, reasoningCache);
+    normalized.messages = restoreAssistantReasoningContent(normalized.messages, reasoningCache);
 
     const chatRequest = toChatCompletionsRequest(normalized);
     const useWebSearchEmulator = hasTavilyWebSearch(config, normalized);
@@ -886,17 +943,7 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
     }
 
     const responseId = generateId('resp');
-    const nextSession = { id: responseId, messages: [] };
-    const persistSession = shouldPersistSession(normalized, request, conversationId);
-    const persistTurn = (chatMessages, assistantMessage) => {
-      if (persistSession) {
-        nextSession.messages = sessionMessages(chatMessages, assistantMessage);
-        sessions.set(responseId, nextSession);
-        sessions.setConversation(conversationId, responseId);
-      } else {
-        sessions.rememberAssistantMessage(assistantMessage);
-      }
-    };
+    const persistReasoning = (assistantMessage) => reasoningCache.rememberAssistantMessage(assistantMessage);
 
     if (useWebSearchEmulator && request.stream) {
       const result = await runStreamingWebSearchTurn({
@@ -906,11 +953,10 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
         config,
         res,
         responseId,
-        previousResponseId,
         clientSignal,
       });
       if (result.handled) {
-        if (result.assistantMessage) persistTurn(result.chatRequest.messages, result.assistantMessage);
+        if (result.assistantMessage) persistReasoning(result.assistantMessage);
         return;
       }
     } else if (useWebSearchEmulator) {
@@ -936,12 +982,13 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
       const payload = applyWebSearchOutputCompatibility(convertChatCompletionToResponses({
         completion: loop.completion,
         model: upstreamRequest.model,
-        previousResponseId,
         normalized,
         responseId,
         config,
-      }), loop.searches, normalized, loop.openedPages);
-      persistTurn(loop.chatRequest.messages, assistantMessageFromResponseOutput(payload.output));
+      }), loop.searches, normalized, loop.openedPages, loop.webTools);
+      if (payload.status === 'completed') {
+        persistReasoning(assistantMessageFromResponseOutput(payload.output));
+      }
       sendJson(res, 200, payload);
       return;
     }
@@ -969,12 +1016,13 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
       const payload = convertChatCompletionToResponses({
         completion: data,
         model,
-        previousResponseId,
         normalized,
         responseId,
         config,
       });
-      persistTurn(chatRequest.messages, assistantMessageFromResponseOutput(payload.output));
+      if (payload.status === 'completed') {
+        persistReasoning(assistantMessageFromResponseOutput(payload.output));
+      }
       sendJson(res, 200, payload);
       return;
     }
@@ -990,7 +1038,6 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
       responseId,
       model,
       createdAt: Math.floor(Date.now() / 1000),
-      previousResponseId,
       normalized,
       config,
       ...resolveReasoningStreamMode(config, upstreamRequest),
@@ -1005,7 +1052,13 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
 
     writeSseEvent(res, mapper.createdEvent());
     writeSseEvent(res, mapper.inProgressEvent());
-    let lastEventWriteAt = Date.now();
+    const heartbeat = startStreamHeartbeat({
+      config,
+      res,
+      write: () => {
+        if (!doneSent) writeSseEvent(res, mapper.inProgressEvent());
+      },
+    });
 
     try {
       await relayChatCompletionsResponse({
@@ -1019,10 +1072,7 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
             writeSseEvent(res, responseEvent);
           }
           if (events.length) {
-            lastEventWriteAt = Date.now();
-          } else if (!event?.done && Date.now() - lastEventWriteAt >= STREAM_HEARTBEAT_MS) {
-            writeSseEvent(res, mapper.inProgressEvent());
-            lastEventWriteAt = Date.now();
+            heartbeat.activity();
           }
           if (event?.done) writeResponsesDone();
         },
@@ -1030,9 +1080,13 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
     } catch (error) {
       if (clientSignal.aborted) return;
       throw error;
+    } finally {
+      heartbeat.stop();
     }
 
-    persistTurn(chatRequest.messages, mapper.assistantMessage());
+    if (mapper.terminalStatus === 'completed') {
+      persistReasoning(mapper.assistantMessage());
+    }
   }
 
   return http.createServer(async (req, res) => {
@@ -1098,7 +1152,8 @@ export function createProxyServer({ config = loadConfig(), sessions } = {}) {
         }
         return;
       }
-      sendJson(res, 500, { error: { message: error.message || 'Internal server error' } });
+      const statusCode = Number.isInteger(error.statusCode) ? error.statusCode : 500;
+      sendJson(res, statusCode, { error: { code: error.code, message: error.message || 'Internal server error' } });
     }
   });
 }