feat: add reasoning/thinking output support for OpenAI and Anthropic routes

- Always send `summary: "auto"` to Codex API so reasoning summaries are available
- Parse `response.reasoning_summary_text.delta/done` SSE events
- OpenAI route: emit `reasoning_content` in chunks when client sends `reasoning_effort`
- Anthropic route: emit thinking blocks when client sends `thinking.type: enabled/adaptive`
- Extract block lifecycle helpers in Anthropic translator to eliminate duplication
- Log unknown SSE events via console.debug for discovering new event types

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Added
 
+- Reasoning/Thinking 输出支持：始终向 Codex API 发送 `summary: "auto"` 以获取推理摘要事件；OpenAI 路由在客户端发送 `reasoning_effort` 时以 `reasoning_content` 输出；Anthropic 路由在客户端发送 `thinking.type: enabled/adaptive` 时以 thinking block 输出；未知 SSE 事件记录到 debug 日志以便发现新事件类型
 - 图片输入支持：OpenAI、Anthropic、Gemini 三种格式的图片内容现在可以正确透传到 Codex 后端（`input_image` + data URI），此前图片被静默丢弃
 - 每窗口使用量计数器：Dashboard 主显示当前窗口内的请求数和 Token 用量，累计总量降为次要灰色小字；窗口过期时自动归零（时间驱动，零 API 开销），后端同步作为双保险校正
 - 窗口时长显示：从后端同步 `limit_window_seconds`，AccountCard header 显示窗口时长 badge（如 `3h`），重置时间行追加窗口时长文字

src/proxy/codex-api.ts

@@ -26,8 +26,8 @@ export interface CodexResponsesRequest {
   input: CodexInputItem[];
   stream: true;
   store: false;
-  /** Optional: reasoning effort level */
-  reasoning?: { effort: string };
+  /** Optional: reasoning effort + summary mode */
+  reasoning?: { effort?: string; summary?: string };
   /** Optional: tools available to the model */
   tools?: unknown[];
   /** Optional: tool choice strategy */

src/routes/chat.ts

@@ -14,37 +14,41 @@ import {
   type FormatAdapter,
 } from "./shared/proxy-handler.js";
 
-const OPENAI_FORMAT: FormatAdapter = {
-  tag: "Chat",
-  noAccountStatus: 503,
-  formatNoAccount: () => ({
-    error: {
-      message:
-        "No available accounts. All accounts are expired or rate-limited.",
-      type: "server_error",
-      param: null,
-      code: "no_available_accounts",
-    },
-  }),
-  format429: (msg) => ({
-    error: {
-      message: msg,
-      type: "rate_limit_error",
-      param: null,
-      code: "rate_limit_exceeded",
-    },
-  }),
-  formatError: (_status, msg) => ({
-    error: {
-      message: msg,
-      type: "server_error",
-      param: null,
-      code: "codex_api_error",
-    },
-  }),
-  streamTranslator: streamCodexToOpenAI,
-  collectTranslator: collectCodexResponse,
-};
+function makeOpenAIFormat(wantReasoning: boolean): FormatAdapter {
+  return {
+    tag: "Chat",
+    noAccountStatus: 503,
+    formatNoAccount: () => ({
+      error: {
+        message:
+          "No available accounts. All accounts are expired or rate-limited.",
+        type: "server_error",
+        param: null,
+        code: "no_available_accounts",
+      },
+    }),
+    format429: (msg) => ({
+      error: {
+        message: msg,
+        type: "rate_limit_error",
+        param: null,
+        code: "rate_limit_exceeded",
+      },
+    }),
+    formatError: (_status, msg) => ({
+      error: {
+        message: msg,
+        type: "server_error",
+        param: null,
+        code: "codex_api_error",
+      },
+    }),
+    streamTranslator: (api, response, model, onUsage, onResponseId) =>
+      streamCodexToOpenAI(api, response, model, onUsage, onResponseId, wantReasoning),
+    collectTranslator: (api, response, model) =>
+      collectCodexResponse(api, response, model, wantReasoning),
+  };
+}
 
 export function createChatRoutes(
   accountPool: AccountPool,
@@ -118,6 +122,7 @@ export function createChatRoutes(
     const req = parsed.data;
 
     const codexRequest = translateToCodexRequest(req);
+    const wantReasoning = !!req.reasoning_effort;
 
     return handleProxyRequest(
       c,
@@ -137,7 +142,7 @@ export function createChatRoutes(
         model: codexRequest.model,
         isStreaming: req.stream,
       },
-      OPENAI_FORMAT,
+      makeOpenAIFormat(wantReasoning),
     );
   });
 

src/routes/messages.ts

@@ -41,19 +41,23 @@ function contentToString(
     .join("\n");
 }
 
-const ANTHROPIC_FORMAT: FormatAdapter = {
-  tag: "Messages",
-  noAccountStatus: 529 as StatusCode,
-  formatNoAccount: () =>
-    makeError(
-      "overloaded_error",
-      "No available accounts. All accounts are expired or rate-limited.",
-    ),
-  format429: (msg) => makeError("rate_limit_error", msg),
-  formatError: (_status, msg) => makeError("api_error", msg),
-  streamTranslator: streamCodexToAnthropic,
-  collectTranslator: collectCodexToAnthropicResponse,
-};
+function makeAnthropicFormat(wantThinking: boolean): FormatAdapter {
+  return {
+    tag: "Messages",
+    noAccountStatus: 529 as StatusCode,
+    formatNoAccount: () =>
+      makeError(
+        "overloaded_error",
+        "No available accounts. All accounts are expired or rate-limited.",
+      ),
+    format429: (msg) => makeError("rate_limit_error", msg),
+    formatError: (_status, msg) => makeError("api_error", msg),
+    streamTranslator: (api, response, model, onUsage, onResponseId) =>
+      streamCodexToAnthropic(api, response, model, onUsage, onResponseId, wantThinking),
+    collectTranslator: (api, response, model) =>
+      collectCodexToAnthropicResponse(api, response, model, wantThinking),
+  };
+}
 
 export function createMessagesRoutes(
   accountPool: AccountPool,
@@ -121,6 +125,7 @@ export function createMessagesRoutes(
     }
 
     const codexRequest = translateAnthropicToCodexRequest(req);
+    const wantThinking = req.thinking?.type === "enabled" || req.thinking?.type === "adaptive";
 
     return handleProxyRequest(
       c,
@@ -133,7 +138,7 @@ export function createMessagesRoutes(
         model: req.model,
         isStreaming: req.stream,
       },
-      ANTHROPIC_FORMAT,
+      makeAnthropicFormat(wantThinking),
     );
   });
 

src/translation/anthropic-to-codex.ts

@@ -210,15 +210,13 @@ export function translateAnthropicToCodexRequest(
     request.previous_response_id = previousResponseId;
   }
 
-  // Add reasoning effort: thinking param → model default → config default
+  // Always request reasoning summary (translation layer filters output on demand)
   const thinkingEffort = mapThinkingToEffort(req.thinking);
   const effort =
     thinkingEffort ??
     modelInfo?.defaultReasoningEffort ??
     config.model.default_reasoning_effort;
-  if (effort) {
-    request.reasoning = { effort };
-  }
+  request.reasoning = { summary: "auto", ...(effort ? { effort } : {}) };
 
   return request;
 }

src/translation/codex-event-extractor.ts

@@ -47,6 +47,7 @@ export interface ExtractedEvent {
   typed: TypedCodexEvent;
   responseId?: string;
   textDelta?: string;
+  reasoningDelta?: string;
   usage?: UsageInfo;
   error?: { code: string; message: string };
   functionCallStart?: FunctionCallStart;
@@ -69,6 +70,11 @@ export async function* iterateCodexEvents(
     const typed = parseCodexEvent(raw);
     const extracted: ExtractedEvent = { typed };
 
+    // Log unrecognized events to discover new Codex event types
+    if (typed.type === "unknown") {
+      console.debug(`[CodexEvents] Unknown event: ${raw.event}`, JSON.stringify(raw.data).slice(0, 300));
+    }
+
     switch (typed.type) {
       case "response.created":
       case "response.in_progress":
@@ -79,6 +85,10 @@ export async function* iterateCodexEvents(
         extracted.textDelta = typed.delta;
         break;
 
+      case "response.reasoning_summary_text.delta":
+        extracted.reasoningDelta = typed.delta;
+        break;
+
       case "response.output_item.added":
         if (typed.item.type === "function_call") {
           // Register item_id → call_id mapping

src/translation/codex-to-anthropic.ts

@@ -3,6 +3,7 @@
  *
  * Codex SSE events:
  *   response.created → extract response ID
+ *   response.reasoning_summary_text.delta → thinking block (if wantThinking)
  *   response.output_text.delta → content_block_delta (text_delta)
  *   response.completed → content_block_stop + message_delta + message_stop
  *
@@ -31,6 +32,9 @@ function formatSSE(eventType: string, data: unknown): string {
 /**
  * Stream Codex Responses API events as Anthropic Messages SSE.
  * Yields string chunks ready to write to the HTTP response.
+ *
+ * When wantThinking is true, reasoning summary deltas are emitted as
+ * thinking content blocks before the text block.
  */
 export async function* streamCodexToAnthropic(
   codexApi: CodexApi,
@@ -38,6 +42,7 @@ export async function* streamCodexToAnthropic(
   model: string,
   onUsage?: (usage: AnthropicUsageInfo) => void,
   onResponseId?: (id: string) => void,
+  wantThinking?: boolean,
 ): AsyncGenerator<string> {
   const msgId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   let outputTokens = 0;
@@ -46,8 +51,42 @@ export async function* streamCodexToAnthropic(
   let hasContent = false;
   let contentIndex = 0;
   let textBlockStarted = false;
+  let thinkingBlockStarted = false;
   const callIdsWithDeltas = new Set<string>();
 
+  // Helper: close an open block and advance the index
+  function* closeBlock(blockType: "thinking" | "text"): Generator<string> {
+    yield formatSSE("content_block_stop", {
+      type: "content_block_stop",
+      index: contentIndex,
+    });
+    contentIndex++;
+    if (blockType === "thinking") thinkingBlockStarted = false;
+    else textBlockStarted = false;
+  }
+
+  // Helper: ensure thinking block is closed before a non-thinking block
+  function* closeThinkingIfOpen(): Generator<string> {
+    if (thinkingBlockStarted) yield* closeBlock("thinking");
+  }
+
+  // Helper: ensure text block is closed
+  function* closeTextIfOpen(): Generator<string> {
+    if (textBlockStarted) yield* closeBlock("text");
+  }
+
+  // Helper: ensure a text block is open
+  function* ensureTextBlock(): Generator<string> {
+    if (!textBlockStarted) {
+      yield formatSSE("content_block_start", {
+        type: "content_block_start",
+        index: contentIndex,
+        content_block: { type: "text", text: "" },
+      });
+      textBlockStarted = true;
+    }
+  }
+
   // 1. message_start
   yield formatSSE("message_start", {
     type: "message_start",
@@ -63,33 +102,22 @@ export async function* streamCodexToAnthropic(
     },
   });
 
-  // 2. content_block_start for text block at index 0
-  yield formatSSE("content_block_start", {
-    type: "content_block_start",
-    index: contentIndex,
-    content_block: { type: "text", text: "" },
-  });
-  textBlockStarted = true;
+  // Don't eagerly open a text block — wait for actual content so thinking can come first
 
-  // 3. Process Codex stream events
+  // 2. Process Codex stream events
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
     // Handle upstream error events
     if (evt.error) {
-      // Close current text block if open
-      if (textBlockStarted) {
-        yield formatSSE("content_block_delta", {
-          type: "content_block_delta",
-          index: contentIndex,
-          delta: { type: "text_delta", text: `[Error] ${evt.error.code}: ${evt.error.message}` },
-        });
-        yield formatSSE("content_block_stop", {
-          type: "content_block_stop",
-          index: contentIndex,
-        });
-        textBlockStarted = false;
-      }
+      yield* closeThinkingIfOpen();
+      yield* ensureTextBlock();
+      yield formatSSE("content_block_delta", {
+        type: "content_block_delta",
+        index: contentIndex,
+        delta: { type: "text_delta", text: `[Error] ${evt.error.code}: ${evt.error.message}` },
+      });
+      yield* closeBlock("text");
       yield formatSSE("error", {
         type: "error",
         error: { type: "api_error", message: `${evt.error.code}: ${evt.error.message}` },
@@ -98,20 +126,34 @@ export async function* streamCodexToAnthropic(
       return;
     }
 
-    // Handle function call start → close text block, open tool_use block
-    if (evt.functionCallStart) {
-      hasToolCalls = true;
+    // Handle reasoning delta → thinking block (only if client wants thinking)
+    if (evt.reasoningDelta && wantThinking) {
       hasContent = true;
-
-      // Close text block if still open
-      if (textBlockStarted) {
-        yield formatSSE("content_block_stop", {
-          type: "content_block_stop",
+      yield* closeTextIfOpen();
+      // Open thinking block if not already open
+      if (!thinkingBlockStarted) {
+        yield formatSSE("content_block_start", {
+          type: "content_block_start",
           index: contentIndex,
+          content_block: { type: "thinking", thinking: "" },
         });
-        contentIndex++;
-        textBlockStarted = false;
+        thinkingBlockStarted = true;
       }
+      yield formatSSE("content_block_delta", {
+        type: "content_block_delta",
+        index: contentIndex,
+        delta: { type: "thinking_delta", thinking: evt.reasoningDelta },
+      });
+      continue;
+    }
+
+    // Handle function call start → close open blocks, open tool_use block
+    if (evt.functionCallStart) {
+      hasToolCalls = true;
+      hasContent = true;
+
+      yield* closeThinkingIfOpen();
+      yield* closeTextIfOpen();
 
       // Start tool_use block
       yield formatSSE("content_block_start", {
@@ -159,15 +201,10 @@ export async function* streamCodexToAnthropic(
       case "response.output_text.delta": {
         if (evt.textDelta) {
           hasContent = true;
-          // Reopen a text block if the previous one was closed (e.g. after tool calls)
-          if (!textBlockStarted) {
-            yield formatSSE("content_block_start", {
-              type: "content_block_start",
-              index: contentIndex,
-              content_block: { type: "text", text: "" },
-            });
-            textBlockStarted = true;
-          }
+          // Close thinking block if open (transition from thinking → text)
+          yield* closeThinkingIfOpen();
+          // Open a text block if not already open
+          yield* ensureTextBlock();
           yield formatSSE("content_block_delta", {
             type: "content_block_delta",
             index: contentIndex,
@@ -184,7 +221,8 @@ export async function* streamCodexToAnthropic(
           onUsage?.({ input_tokens: inputTokens, output_tokens: outputTokens });
         }
         // Inject error text if stream completed with no content
-        if (!hasContent && textBlockStarted) {
+        if (!hasContent) {
+          yield* ensureTextBlock();
           yield formatSSE("content_block_delta", {
             type: "content_block_delta",
             index: contentIndex,
@@ -196,22 +234,18 @@ export async function* streamCodexToAnthropic(
     }
   }
 
-  // 4. Close text block if still open (no tool calls, or text came before tools)
-  if (textBlockStarted) {
-    yield formatSSE("content_block_stop", {
-      type: "content_block_stop",
-      index: contentIndex,
-    });
-  }
+  // 3. Close any open blocks
+  yield* closeThinkingIfOpen();
+  yield* closeTextIfOpen();
 
-  // 5. message_delta with stop_reason and usage
+  // 4. message_delta with stop_reason and usage
   yield formatSSE("message_delta", {
     type: "message_delta",
     delta: { stop_reason: hasToolCalls ? "tool_use" : "end_turn" },
     usage: { input_tokens: inputTokens, output_tokens: outputTokens },
   });
 
-  // 6. message_stop
+  // 5. message_stop
   yield formatSSE("message_stop", {
     type: "message_stop",
   });
@@ -225,6 +259,7 @@ export async function collectCodexToAnthropicResponse(
   codexApi: CodexApi,
   rawResponse: Response,
   model: string,
+  wantThinking?: boolean,
 ): Promise<{
   response: AnthropicMessagesResponse;
   usage: AnthropicUsageInfo;
@@ -232,6 +267,7 @@ export async function collectCodexToAnthropicResponse(
 }> {
   const id = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   let fullText = "";
+  let fullReasoning = "";
   let inputTokens = 0;
   let outputTokens = 0;
   let responseId: string | null = null;
@@ -245,6 +281,7 @@ export async function collectCodexToAnthropicResponse(
       throw new Error(`Codex API error: ${evt.error.code}: ${evt.error.message}`);
     }
     if (evt.textDelta) fullText += evt.textDelta;
+    if (evt.reasoningDelta) fullReasoning += evt.reasoningDelta;
     if (evt.usage) {
       inputTokens = evt.usage.input_tokens;
       outputTokens = evt.usage.output_tokens;
@@ -270,6 +307,10 @@ export async function collectCodexToAnthropicResponse(
 
   const hasToolCalls = toolUseBlocks.length > 0;
   const content: AnthropicContentBlock[] = [];
+  // Thinking block comes first if requested and available
+  if (wantThinking && fullReasoning) {
+    content.push({ type: "thinking", thinking: fullReasoning });
+  }
   if (fullText) {
     content.push({ type: "text", text: fullText });
   }

src/translation/codex-to-openai.ts

@@ -38,6 +38,7 @@ export async function* streamCodexToOpenAI(
   model: string,
   onUsage?: (usage: UsageInfo) => void,
   onResponseId?: (id: string) => void,
+  wantReasoning?: boolean,
 ): AsyncGenerator<string> {
   const chunkId = `chatcmpl-${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   const created = Math.floor(Date.now() / 1000);
@@ -182,6 +183,24 @@ export async function* streamCodexToOpenAI(
       continue;
     }
 
+    // Emit reasoning delta if client requested it
+    if (evt.reasoningDelta && wantReasoning) {
+      hasContent = true;
+      yield formatSSE({
+        id: chunkId,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [
+          {
+            index: 0,
+            delta: { reasoning_content: evt.reasoningDelta },
+            finish_reason: null,
+          },
+        ],
+      });
+    }
+
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
@@ -251,10 +270,12 @@ export async function collectCodexResponse(
   codexApi: CodexApi,
   rawResponse: Response,
   model: string,
+  wantReasoning?: boolean,
 ): Promise<{ response: ChatCompletionResponse; usage: UsageInfo; responseId: string | null }> {
   const id = `chatcmpl-${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   const created = Math.floor(Date.now() / 1000);
   let fullText = "";
+  let fullReasoning = "";
   let promptTokens = 0;
   let completionTokens = 0;
   let responseId: string | null = null;
@@ -268,6 +289,7 @@ export async function collectCodexResponse(
       throw new Error(`Codex API error: ${evt.error.code}: ${evt.error.message}`);
     }
     if (evt.textDelta) fullText += evt.textDelta;
+    if (evt.reasoningDelta) fullReasoning += evt.reasoningDelta;
     if (evt.usage) {
       promptTokens = evt.usage.input_tokens;
       completionTokens = evt.usage.output_tokens;
@@ -294,6 +316,9 @@ export async function collectCodexResponse(
     role: "assistant",
     content: fullText || null,
   };
+  if (wantReasoning && fullReasoning) {
+    message.reasoning_content = fullReasoning;
+  }
   if (hasToolCalls) {
     message.tool_calls = toolCalls;
   }

src/translation/gemini-to-codex.ts

@@ -217,7 +217,7 @@ export function translateGeminiToCodexRequest(
     request.previous_response_id = previousResponseId;
   }
 
-  // Add reasoning effort: thinkingBudget → model default → config default
+  // Always request reasoning summary (translation layer filters output on demand)
   const thinkingEffort = budgetToEffort(
     req.generationConfig?.thinkingConfig?.thinkingBudget,
   );
@@ -225,9 +225,7 @@ export function translateGeminiToCodexRequest(
     thinkingEffort ??
     modelInfo?.defaultReasoningEffort ??
     config.model.default_reasoning_effort;
-  if (effort) {
-    request.reasoning = { effort };
-  }
+  request.reasoning = { summary: "auto", ...(effort ? { effort } : {}) };
 
   return request;
 }

src/translation/openai-to-codex.ts

@@ -179,14 +179,12 @@ export function translateToCodexRequest(
     request.previous_response_id = previousResponseId;
   }
 
-  // Add reasoning effort if applicable
+  // Always request reasoning summary (translation layer filters output on demand)
   const effort =
     req.reasoning_effort ??
     modelInfo?.defaultReasoningEffort ??
     config.model.default_reasoning_effort;
-  if (effort) {
-    request.reasoning = { effort };
-  }
+  request.reasoning = { summary: "auto", ...(effort ? { effort } : {}) };
 
   return request;
 }

src/types/codex-events.ts

@@ -43,6 +43,18 @@ export interface CodexCompletedEvent {
   response: CodexResponseData;
 }
 
+// ── Reasoning summary event data shapes ─────────────────────────
+
+export interface CodexReasoningSummaryDeltaEvent {
+  type: "response.reasoning_summary_text.delta";
+  delta: string;
+}
+
+export interface CodexReasoningSummaryDoneEvent {
+  type: "response.reasoning_summary_text.done";
+  text: string;
+}
+
 // ── Function call event data shapes ─────────────────────────────
 
 export interface CodexOutputItemAddedEvent {
@@ -91,6 +103,8 @@ export type TypedCodexEvent =
   | CodexInProgressEvent
   | CodexTextDeltaEvent
   | CodexTextDoneEvent
+  | CodexReasoningSummaryDeltaEvent
+  | CodexReasoningSummaryDoneEvent
   | CodexCompletedEvent
   | CodexOutputItemAddedEvent
   | CodexFunctionCallArgsDeltaEvent
@@ -152,6 +166,18 @@ export function parseCodexEvent(evt: CodexSSEEvent): TypedCodexEvent {
       }
       return { type: "unknown", raw: data };
     }
+    case "response.reasoning_summary_text.delta": {
+      if (isRecord(data) && typeof data.delta === "string") {
+        return { type: "response.reasoning_summary_text.delta", delta: data.delta };
+      }
+      return { type: "unknown", raw: data };
+    }
+    case "response.reasoning_summary_text.done": {
+      if (isRecord(data) && typeof data.text === "string") {
+        return { type: "response.reasoning_summary_text.done", text: data.text };
+      }
+      return { type: "unknown", raw: data };
+    }
     case "response.completed": {
       const resp = parseResponseData(data);
       return resp

src/types/openai.ts

@@ -90,6 +90,7 @@ export interface ChatCompletionChoice {
   message: {
     role: "assistant";
     content: string | null;
+    reasoning_content?: string | null;
     tool_calls?: ChatCompletionToolCall[];
   };
   finish_reason: "stop" | "length" | "tool_calls" | "function_call" | null;
@@ -125,6 +126,7 @@ export interface ChatCompletionChunkToolCall {
 export interface ChatCompletionChunkDelta {
   role?: "assistant";
   content?: string | null;
+  reasoning_content?: string | null;
   tool_calls?: ChatCompletionChunkToolCall[];
 }