feat: add Structured Outputs support (response_format → text.format)

OpenAI response_format (json_object/json_schema) and Gemini
responseMimeType/responseSchema now translate to Codex text.format.
/v1/responses endpoint passes through text field as-is.

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

CHANGELOG.md

@@ -10,6 +10,7 @@
 
 - 更新弹窗 + 自动重启：点击"有可用更新"弹出 Modal 显示 changelog，一键更新后服务器自动重启、前端自动刷新，零人工干预（git 模式 spawn 新进程、Docker/Electron 显示对应操作指引）
 - Model-aware 多计划账号路由：不同 plan（free/plus/business）的账号自动路由到各自支持的模型，business 账号可继续使用 gpt-5.4 等高端模型 (#57)
+- Structured Outputs 支持：`/v1/chat/completions` 支持 `response_format`（`json_object` / `json_schema`），Gemini 端点支持 `responseMimeType` + `responseSchema`，自动翻译为 Codex Responses API 的 `text.format`；`/v1/responses` 直通 `text` 字段
 
 ### Changed
 

README.md

@@ -107,6 +107,7 @@ curl http://localhost:8080/v1/chat/completions \
 - 完全兼容 `/v1/chat/completions`（OpenAI）、`/v1/messages`（Anthropic）和 Gemini 格式
 - 支持 SSE 流式输出，可直接对接所有 OpenAI SDK 和客户端
 - 自动完成 Chat Completions ↔ Codex Responses API 双向协议转换
+- **Structured Outputs** — 支持 `response_format`（OpenAI `json_object` / `json_schema`）和 Gemini `responseMimeType`，强制 JSON 结构化输出无需提示词
 
 ### 2. 🔐 账号管理与智能轮换 (Auth & Multi-Account)
 - **OAuth PKCE 登录** — 浏览器一键授权，无需手动复制 Token

README_EN.md

@@ -103,6 +103,7 @@ curl http://localhost:8080/v1/chat/completions \
 - Compatible with `/v1/chat/completions` (OpenAI), `/v1/messages` (Anthropic), and Gemini formats
 - SSE streaming output, works with all OpenAI SDKs and clients
 - Automatic bidirectional translation between Chat Completions and Codex Responses API
+- **Structured Outputs** — supports `response_format` (OpenAI `json_object` / `json_schema`) and Gemini `responseMimeType` for enforcing JSON output without prompt engineering
 
 ### 2. 🔐 Account Management & Smart Rotation
 - **OAuth PKCE login** — one-click browser auth, no manual token copying

src/proxy/codex-api.ts

@@ -34,6 +34,15 @@ export interface CodexResponsesRequest {
   tools?: unknown[];
   /** Optional: tool choice strategy */
   tool_choice?: string | { type: string; name: string };
+  /** Optional: text output format (JSON mode / structured outputs) */
+  text?: {
+    format: {
+      type: "text" | "json_object" | "json_schema";
+      name?: string;
+      schema?: Record<string, unknown>;
+      strict?: boolean;
+    };
+  };
 }
 
 /** Structured content part for multimodal Codex input. */

src/routes/responses.ts

@@ -261,6 +261,28 @@ export function createResponsesRoutes(
       codexRequest.tool_choice = body.tool_choice as CodexResponsesRequest["tool_choice"];
     }
 
+    // Pass through text format (JSON mode / structured outputs) as-is
+    if (
+      isRecord(body.text) &&
+      isRecord(body.text.format) &&
+      typeof body.text.format.type === "string"
+    ) {
+      codexRequest.text = {
+        format: {
+          type: body.text.format.type as "text" | "json_object" | "json_schema",
+          ...(typeof body.text.format.name === "string"
+            ? { name: body.text.format.name }
+            : {}),
+          ...(isRecord(body.text.format.schema)
+            ? { schema: body.text.format.schema as Record<string, unknown> }
+            : {}),
+          ...(typeof body.text.format.strict === "boolean"
+            ? { strict: body.text.format.strict }
+            : {}),
+        },
+      };
+    }
+
     // Client can request non-streaming (collect mode), but upstream is always stream
     const clientWantsStream = body.stream !== false;
 

src/translation/gemini-to-codex.ts

@@ -232,5 +232,25 @@ export function translateGeminiToCodexRequest(
     request.service_tier = serviceTier;
   }
 
+  // Response format: translate responseMimeType + responseSchema → text.format
+  const mimeType = req.generationConfig?.responseMimeType;
+  if (mimeType === "application/json") {
+    const schema = req.generationConfig?.responseSchema;
+    if (schema && Object.keys(schema).length > 0) {
+      // Codex strict mode requires additionalProperties: false at root level
+      const strictSchema = { additionalProperties: false, ...schema };
+      request.text = {
+        format: {
+          type: "json_schema",
+          name: "gemini_schema",
+          schema: strictSchema,
+          strict: true,
+        },
+      };
+    } else {
+      request.text = { format: { type: "json_object" } };
+    }
+  }
+
   return request;
 }

src/translation/openai-to-codex.ts

@@ -192,5 +192,26 @@ export function translateToCodexRequest(
     request.service_tier = serviceTier;
   }
 
+  // Response format: translate response_format → text.format
+  if (req.response_format && req.response_format.type !== "text") {
+    if (req.response_format.type === "json_object") {
+      request.text = { format: { type: "json_object" } };
+    } else if (
+      req.response_format.type === "json_schema" &&
+      req.response_format.json_schema
+    ) {
+      request.text = {
+        format: {
+          type: "json_schema",
+          name: req.response_format.json_schema.name,
+          schema: req.response_format.json_schema.schema,
+          ...(req.response_format.json_schema.strict !== undefined
+            ? { strict: req.response_format.json_schema.strict }
+            : {}),
+        },
+      };
+    }
+  }
+
   return request;
 }

src/types/gemini.ts

@@ -40,6 +40,8 @@ const GeminiGenerationConfigSchema = z.object({
   maxOutputTokens: z.number().optional(),
   stopSequences: z.array(z.string()).optional(),
   thinkingConfig: GeminiThinkingConfigSchema.optional(),
+  responseMimeType: z.string().optional(),
+  responseSchema: z.record(z.unknown()).optional(),
 });
 
 export const GeminiGenerateContentRequestSchema = z.object({

src/types/openai.ts

@@ -60,6 +60,15 @@ export const ChatCompletionRequestSchema = z.object({
     z.object({ type: z.literal("function"), function: z.object({ name: z.string() }) }),
   ]).optional(),
   parallel_tool_calls: z.boolean().optional(),
+  // Structured output format (JSON mode / JSON Schema)
+  response_format: z.object({
+    type: z.enum(["text", "json_object", "json_schema"]),
+    json_schema: z.object({
+      name: z.string(),
+      schema: z.record(z.unknown()),
+      strict: z.boolean().optional(),
+    }).optional(),
+  }).optional(),
   // Legacy function format (accepted for compatibility, not forwarded to Codex)
   functions: z.array(z.object({
     name: z.string(),