ai-zero-token 2.0.3 → 2.0.5

package/dist/server/app.js

@@ -2,15 +2,18 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import { z } from "zod";
 import { createGatewayContext } from "../core/context.js";
 import { requestText } from "../core/providers/http-client.js";
+import { streamOpenAICodex } from "../core/providers/openai-codex/chat.js";
 const packageRoot = path.dirname(fileURLToPath(new URL("../../package.json", import.meta.url)));
 const adminUiDistDir = path.join(packageRoot, "admin-ui", "dist");
 const adminUiIndexPath = path.join(adminUiDistDir, "index.html");
+const MAX_GATEWAY_REQUEST_LOGS = 100;
 const assetContentTypes = {
   ".css": "text/css; charset=utf-8",
   ".gif": "image/gif",
@@ -44,17 +47,9 @@ async function readAdminUiAsset(assetPath) {
     return null;
   }
 }
-const inputPartSchema = z.object({
-  type: z.string().optional(),
-  text: z.string().optional()
-}).passthrough();
-const inputMessageSchema = z.object({
-  role: z.string().optional(),
-  content: z.array(inputPartSchema).optional()
-}).passthrough();
 const responsesBodySchema = z.object({
   model: z.string().optional(),
-  input: z.union([z.string(), z.array(inputMessageSchema)]).optional(),
+  input: z.unknown().optional(),
   instructions: z.string().optional(),
   stream: z.boolean().optional(),
   tools: z.array(z.unknown()).optional(),
@@ -68,7 +63,7 @@ const responsesBodySchema = z.object({
     allow_unknown_model: z.boolean().optional(),
     include_raw: z.boolean().optional()
   }).passthrough().optional()
-});
+}).passthrough();
 const chatCompletionContentPartSchema = z.object({
   type: z.string().optional(),
   text: z.string().optional(),
@@ -113,7 +108,8 @@ const settingsUpdateSchema = z.object({
     noProxy: z.string().optional()
   }).optional(),
   autoSwitch: z.object({
-    enabled: z.boolean()
+    enabled: z.boolean().optional(),
+    excludedProfileIds: z.array(z.string()).optional()
   }).optional(),
   runtime: z.object({
     quotaSyncConcurrency: z.number().int().min(1).max(32).optional()
@@ -149,6 +145,10 @@ const profileExportSchema = z.object({
 const codexApplySchema = z.object({
   profileId: z.string().min(1)
 });
+const codexProviderConfigSchema = z.object({
+  baseUrl: z.string().min(1).optional(),
+  providerId: z.string().min(1).optional()
+});
 const githubImageBedConfigSchema = z.object({
   token: z.string().min(1)
 });
@@ -198,13 +198,21 @@ const imageEditsBodySchema = z.object({
   response_format: z.enum(["b64_json", "url"]).optional(),
   user: z.string().optional()
 }).passthrough();
-const chatCompletionExcludedKeys = /* @__PURE__ */ new Set([
-  "messages",
-  "n",
-  "stream",
-  "max_tokens",
-  "max_completion_tokens"
-]);
+function extractTextFromInputContent(content) {
+  if (typeof content === "string" && content.trim()) {
+    return [content.trim()];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.flatMap((part) => {
+    if (!part || typeof part !== "object") {
+      return [];
+    }
+    const record = part;
+    return typeof record.text === "string" && record.text.trim() ? [record.text.trim()] : [];
+  });
+}
 function extractTextInput(input) {
   if (typeof input === "undefined") {
     return "";
@@ -213,12 +221,14 @@ function extractTextInput(input) {
     return input;
   }
   const chunks = [];
+  if (!Array.isArray(input)) {
+    return "";
+  }
   for (const item of input) {
-    for (const part of item.content ?? []) {
-      if (typeof part.text === "string" && part.text.trim()) {
-        chunks.push(part.text.trim());
-      }
+    if (!item || typeof item !== "object") {
+      continue;
     }
+    chunks.push(...extractTextFromInputContent(item.content));
   }
   return chunks.join("\n").trim();
 }
@@ -242,7 +252,20 @@ function normalizeChatRole(role) {
   }
   return role ?? "user";
 }
-function normalizeChatContentPart(part) {
+function safeJsonStringify(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "undefined" || value === null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function normalizeChatContentPart(part, textType) {
   if (part.type === "image_url") {
     const url = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
     if (!url) {
@@ -258,37 +281,270 @@ function normalizeChatContentPart(part) {
   }
   const text = typeof part.text === "string" ? part.text : "";
   return {
-    type: "input_text",
+    type: textType,
     text
   };
 }
-function normalizeChatContent(content) {
+function normalizeChatContent(content, role) {
+  const textType = role === "assistant" ? "output_text" : "input_text";
   if (typeof content === "string") {
-    return [{ type: "input_text", text: content }];
+    return [{ type: textType, text: content }];
   }
   if (!Array.isArray(content) || content.length === 0) {
-    return [{ type: "input_text", text: "" }];
+    return [{ type: textType, text: "" }];
   }
-  return content.map((part) => normalizeChatContentPart(part));
+  return content.map((part) => normalizeChatContentPart(part, textType));
 }
 function normalizeChatMessages(messages) {
-  return messages.map((message) => ({
-    role: normalizeChatRole(message.role),
-    content: normalizeChatContent(message.content),
-    ...message.name ? { name: message.name } : {},
-    ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}
+  const normalized = [];
+  for (const message of messages) {
+    const record = message;
+    if (message.role === "tool") {
+      normalized.push({
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: typeof message.content === "string" ? message.content : safeJsonStringify(message.content)
+      });
+      continue;
+    }
+    normalized.push({
+      role: normalizeChatRole(message.role),
+      content: normalizeChatContent(message.content, message.role),
+      ...message.name ? { name: message.name } : {},
+      ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}
+    });
+    const toolCalls = Array.isArray(record.tool_calls) ? record.tool_calls : [];
+    for (const toolCall of toolCalls) {
+      const call = toolCall && typeof toolCall === "object" ? toolCall : {};
+      const fn = call.function && typeof call.function === "object" ? call.function : {};
+      const name = typeof fn.name === "string" ? fn.name : void 0;
+      if (!name) {
+        continue;
+      }
+      normalized.push({
+        type: "function_call",
+        call_id: typeof call.id === "string" ? call.id : `call_${normalized.length}`,
+        name,
+        arguments: safeJsonStringify(fn.arguments)
+      });
+    }
+  }
+  return normalized;
+}
+function normalizeChatTools(tools) {
+  if (!tools) {
+    return void 0;
+  }
+  return tools.map((tool) => {
+    if (!tool || typeof tool !== "object") {
+      return tool;
+    }
+    const record = tool;
+    const fn = record.function && typeof record.function === "object" ? record.function : null;
+    if (record.type !== "function" || !fn) {
+      return tool;
+    }
+    return {
+      type: "function",
+      name: fn.name,
+      description: fn.description,
+      parameters: fn.parameters
+    };
+  });
+}
+function normalizeChatToolChoice(toolChoice) {
+  if (!toolChoice || typeof toolChoice !== "object") {
+    return toolChoice;
+  }
+  const record = toolChoice;
+  const fn = record.function && typeof record.function === "object" ? record.function : null;
+  if (record.type === "function" && fn && typeof fn.name === "string") {
+    return {
+      type: "function",
+      name: fn.name
+    };
+  }
+  return toolChoice;
+}
+function normalizeReasoningEffort(value) {
+  if (value === "low" || value === "medium" || value === "high") {
+    return value;
+  }
+  if (value === "minimal") {
+    return "low";
+  }
+  if (value === "xhigh") {
+    return "high";
+  }
+  return void 0;
+}
+function normalizeChatReasoning(data) {
+  const record = data;
+  const existing = record.reasoning;
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
+  }
+  const effort = normalizeReasoningEffort(record.reasoning_effort);
+  return effort ? { effort } : void 0;
+}
+function truncateForLog(value, maxLength = 300) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength)}...`;
+}
+function extractChatMessageText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (!Array.isArray(message.content)) {
+    return "";
+  }
+  return message.content.map((part) => typeof part.text === "string" ? part.text : part.image_url ? "[image]" : "").filter(Boolean).join("\n");
+}
+function countRoles(messages) {
+  const counts = {};
+  for (const message of messages) {
+    const role = message.role ?? "user";
+    counts[role] = (counts[role] ?? 0) + 1;
+  }
+  return counts;
+}
+function summarizeRecentMessages(messages) {
+  return messages.slice(-8).map((message) => ({
+    role: message.role ?? "user",
+    textPreview: truncateForLog(extractChatMessageText(message), 180),
+    toolCallId: message.tool_call_id
   }));
 }
+function summarizeToolNames(tools) {
+  if (!tools) {
+    return [];
+  }
+  return tools.map((tool) => {
+    if (!tool || typeof tool !== "object") {
+      return "";
+    }
+    const record = tool;
+    const fn = record.function && typeof record.function === "object" ? record.function : null;
+    return typeof fn?.name === "string" ? fn.name : typeof record.name === "string" ? record.name : "";
+  }).filter(Boolean);
+}
+function summarizeResponsesRequest(data) {
+  const input = data.input;
+  const toolNames = summarizeToolNames(Array.isArray(data.tools) ? data.tools : void 0);
+  return {
+    endpoint: "/v1/responses",
+    model: data.model ?? "default",
+    stream: data.stream ?? false,
+    inputKind: typeof input === "string" ? "string" : Array.isArray(input) ? "array" : "override",
+    inputItems: Array.isArray(input) ? input.length : void 0,
+    inputTextPreview: typeof input === "string" ? truncateForLog(input) : "",
+    instructionsLength: typeof data.instructions === "string" ? data.instructions.length : void 0,
+    toolCount: Array.isArray(data.tools) ? data.tools.length : 0,
+    toolNames: toolNames.slice(0, 50),
+    toolNamesTruncated: toolNames.length > 50,
+    toolChoice: typeof data.tool_choice === "undefined" ? "default" : typeof data.tool_choice,
+    parallelToolCalls: data.parallel_tool_calls,
+    hasReasoning: Boolean(data.reasoning)
+  };
+}
+function createResponsesCodexBody(data) {
+  const experimentalBody = data.experimental_codex?.body ?? {};
+  const body = {
+    ...experimentalBody,
+    ...data
+  };
+  delete body.experimental_codex;
+  const normalizedInput = normalizeResponseInput(data.input);
+  if (typeof normalizedInput !== "undefined") {
+    body.input = normalizedInput;
+  }
+  return body;
+}
+function createCodexPassthroughBody(data, model) {
+  const body = {
+    ...data,
+    model
+  };
+  delete body.experimental_codex;
+  return body;
+}
+function summarizeChatCompletionsRequest(data) {
+  const lastUserMessage = [...data.messages].reverse().find((message) => (message.role ?? "user") === "user");
+  const toolNames = summarizeToolNames(data.tools);
+  return {
+    endpoint: "/v1/chat/completions",
+    model: data.model ?? "default",
+    stream: data.stream ?? false,
+    messageCount: data.messages.length,
+    roleCounts: countRoles(data.messages),
+    recentMessages: summarizeRecentMessages(data.messages),
+    lastUserTextPreview: lastUserMessage ? truncateForLog(extractChatMessageText(lastUserMessage)) : "",
+    toolCount: data.tools?.length ?? 0,
+    toolNames: toolNames.slice(0, 50),
+    toolNamesTruncated: toolNames.length > 50,
+    toolChoice: typeof data.tool_choice === "undefined" ? "default" : typeof data.tool_choice,
+    parallelToolCalls: data.parallel_tool_calls,
+    hasReasoning: Boolean(data.reasoning || data.reasoning_effort),
+    maxTokens: data.max_completion_tokens ?? data.max_tokens
+  };
+}
+function summarizeCodexChatBody(body) {
+  const toolNames = summarizeToolNames(Array.isArray(body.tools) ? body.tools : void 0);
+  return {
+    keys: Object.keys(body).sort(),
+    model: body.model ?? "default",
+    stream: body.stream,
+    store: body.store,
+    inputItems: Array.isArray(body.input) ? body.input.length : void 0,
+    tools: Array.isArray(body.tools) ? body.tools.length : void 0,
+    toolNames: toolNames.slice(0, 50),
+    toolNamesTruncated: toolNames.length > 50,
+    toolChoice: typeof body.tool_choice === "undefined" ? "default" : typeof body.tool_choice,
+    parallelToolCalls: body.parallel_tool_calls,
+    hasReasoning: Boolean(body.reasoning)
+  };
+}
+function profileLogLabel(profile) {
+  return profile?.email || profile?.accountId || profile?.profileId || "-";
+}
+function requestSourceFromUserAgent(userAgent) {
+  if (typeof userAgent !== "string") {
+    return "API";
+  }
+  const normalized = userAgent.toLowerCase();
+  if (normalized.includes("codex")) {
+    return "Codex";
+  }
+  if (normalized.includes("openclaw")) {
+    return "OpenClaw";
+  }
+  return "API";
+}
 function createChatCompletionsCodexBody(data) {
-  const body = Object.fromEntries(
-    Object.entries(data).filter(([key]) => !chatCompletionExcludedKeys.has(key))
-  );
-  if (typeof data.max_completion_tokens === "number") {
-    body.max_output_tokens = data.max_completion_tokens;
-  } else if (typeof data.max_tokens === "number") {
-    body.max_output_tokens = data.max_tokens;
-  }
-  body.input = normalizeChatMessages(data.messages);
+  const body = {
+    store: false,
+    stream: true,
+    input: normalizeChatMessages(data.messages)
+  };
+  if (data.model) {
+    body.model = data.model;
+  }
+  if (typeof data.parallel_tool_calls === "boolean") {
+    body.parallel_tool_calls = data.parallel_tool_calls;
+  }
+  if (data.tools) {
+    body.tools = normalizeChatTools(data.tools);
+  }
+  if (typeof data.tool_choice !== "undefined") {
+    body.tool_choice = normalizeChatToolChoice(data.tool_choice);
+  }
+  const reasoning = normalizeChatReasoning(data);
+  if (reasoning) {
+    body.reasoning = reasoning;
+  }
   return body;
 }
 function summarizeImageRequestForLog(body) {
@@ -373,6 +629,7 @@ function buildResponseApiBody(result, includeRaw) {
   return responseBody;
 }
 function buildChatCompletionsBody(result) {
+  const hasToolCalls = result.toolCalls.length > 0;
   const body = {
     id: `chatcmpl_${randomUUID().replace(/-/g, "")}`,
     object: "chat.completion",
@@ -381,10 +638,11 @@ function buildChatCompletionsBody(result) {
     choices: [
       {
         index: 0,
-        finish_reason: "stop",
+        finish_reason: hasToolCalls ? "tool_calls" : "stop",
         message: {
           role: "assistant",
-          content: result.text
+          content: hasToolCalls ? result.text || null : result.text,
+          ...hasToolCalls ? { tool_calls: result.toolCalls } : {}
         }
       }
     ]
@@ -394,6 +652,79 @@ function buildChatCompletionsBody(result) {
   }
   return body;
 }
+function writeChatCompletionsSseEvent(reply, data) {
+  reply.raw.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+function buildChatCompletionChunk(params) {
+  return {
+    id: params.id,
+    object: "chat.completion.chunk",
+    created: params.created,
+    model: params.model,
+    choices: [
+      {
+        index: 0,
+        delta: params.delta,
+        finish_reason: params.finishReason ?? null
+      }
+    ]
+  };
+}
+function sendChatCompletionsStream(reply, result) {
+  const id = `chatcmpl_${randomUUID().replace(/-/g, "")}`;
+  const created = Math.floor(Date.now() / 1e3);
+  reply.raw.writeHead(200, {
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  writeChatCompletionsSseEvent(reply, buildChatCompletionChunk({
+    id,
+    created,
+    model: result.model,
+    delta: { role: "assistant" }
+  }));
+  if (result.text) {
+    writeChatCompletionsSseEvent(reply, buildChatCompletionChunk({
+      id,
+      created,
+      model: result.model,
+      delta: { content: result.text }
+    }));
+  }
+  result.toolCalls.forEach((toolCall, index) => {
+    writeChatCompletionsSseEvent(reply, buildChatCompletionChunk({
+      id,
+      created,
+      model: result.model,
+      delta: {
+        tool_calls: [
+          {
+            index,
+            id: toolCall.id,
+            type: toolCall.type,
+            function: {
+              name: toolCall.function.name,
+              arguments: toolCall.function.arguments
+            }
+          }
+        ]
+      }
+    }));
+  });
+  writeChatCompletionsSseEvent(reply, buildChatCompletionChunk({
+    id,
+    created,
+    model: result.model,
+    delta: {},
+    finishReason: result.toolCalls.length > 0 ? "tool_calls" : "stop"
+  }));
+  reply.raw.write("data: [DONE]\n\n");
+  reply.raw.end();
+}
 function validateImageRequest(data) {
   if (data.response_format === "url") {
     return "\u5F53\u524D\u7F51\u5173\u4EC5\u652F\u6301 response_format=b64_json\uFF0C\u6682\u4E0D\u652F\u6301\u8FD4\u56DE\u6258\u7BA1\u56FE\u7247 URL\u3002";
@@ -484,7 +815,7 @@ function getErrorStatusCode(error) {
     return normalized.statusCode;
   }
   const upstreamStatus = normalized.upstreamStatus;
-  if (upstreamStatus === 401 || upstreamStatus === 403) {
+  if (typeof upstreamStatus === "number" && upstreamStatus >= 400 && upstreamStatus < 600) {
     return upstreamStatus;
   }
   const message = normalized.message;
@@ -496,12 +827,74 @@ function getErrorStatusCode(error) {
   }
   return 500;
 }
+function isQuotaLimitError(error) {
+  const normalized = normalizeError(error);
+  const marker = `${normalized.upstreamErrorCode ?? ""} ${normalized.upstreamErrorType ?? ""} ${normalized.message}`.toLowerCase();
+  return normalized.upstreamStatus === 429 || marker.includes("usage_limit_reached");
+}
+function createSseStreamStats() {
+  return {
+    buffer: "",
+    bytes: 0,
+    completed: false
+  };
+}
+function trackSseChunk(stats, chunk) {
+  const text = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString("utf8") : String(chunk);
+  stats.bytes += Buffer.byteLength(text);
+  stats.buffer += text.replace(/\r\n/g, "\n");
+  let separatorIndex = stats.buffer.indexOf("\n\n");
+  while (separatorIndex !== -1) {
+    const block = stats.buffer.slice(0, separatorIndex);
+    stats.buffer = stats.buffer.slice(separatorIndex + 2);
+    const eventName = block.split("\n").find((line) => line.startsWith("event:"))?.slice("event:".length).trim();
+    const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trim()).join("\n");
+    let eventType = eventName;
+    if (data && data !== "[DONE]") {
+      try {
+        const parsed = JSON.parse(data);
+        if (typeof parsed.type === "string") {
+          eventType = parsed.type;
+        }
+      } catch {
+      }
+    }
+    if (eventType === "response.completed") {
+      stats.completed = true;
+      stats.terminalEvent = eventType;
+    } else if (eventType === "response.failed" || eventType === "response.incomplete") {
+      stats.terminalEvent = eventType;
+    }
+    separatorIndex = stats.buffer.indexOf("\n\n");
+  }
+  if (stats.buffer.length > 65536) {
+    stats.buffer = stats.buffer.slice(-65536);
+  }
+}
 function createApp(params) {
   const app = Fastify({
     logger: false,
     bodyLimit: params?.bodyLimit
   });
   const ctx = createGatewayContext();
+  const gatewayRequestLogs = [];
+  function pushGatewayRequestLog(log) {
+    gatewayRequestLogs.unshift({
+      id: log.id ?? randomUUID(),
+      time: log.time ?? Date.now(),
+      method: log.method,
+      endpoint: log.endpoint,
+      account: log.account,
+      model: log.model,
+      statusCode: log.statusCode,
+      durationMs: log.durationMs,
+      source: log.source,
+      details: log.details
+    });
+    if (gatewayRequestLogs.length > MAX_GATEWAY_REQUEST_LOGS) {
+      gatewayRequestLogs.length = MAX_GATEWAY_REQUEST_LOGS;
+    }
+  }
   void app.register(cors, {
     origin: params?.corsOrigin ?? true,
     methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"]
@@ -524,6 +917,9 @@ function createApp(params) {
       }
     };
   });
+  app.get("/_gateway/admin/request-logs", async () => ({
+    data: gatewayRequestLogs
+  }));
   async function buildAdminConfig(request) {
     const [status, models, modelCatalog, versionStatus, settings, profile, profiles, codexStatus] = await Promise.all([
       ctx.authService.getStatus(),
@@ -547,7 +943,9 @@ function createApp(params) {
       codex: codexStatus,
       adminUrl: `${origin}/`,
       baseUrl: `${origin}/v1`,
+      codexBaseUrl: `${origin}/codex/v1`,
       restartSupported: Boolean(params?.onRestart),
+      codexRestartSupported: Boolean(params?.onRestartCodex),
       supportedEndpoints: [
         {
           method: "GET",
@@ -559,6 +957,11 @@ function createApp(params) {
           path: "/v1/responses",
           description: "OpenAI responses \u517C\u5BB9\u63A5\u53E3\u3002"
         },
+        {
+          method: "POST",
+          path: "/codex/v1/responses",
+          description: "Codex custom provider \u4E13\u7528 Responses SSE \u900F\u4F20\u63A5\u53E3\u3002"
+        },
         {
           method: "POST",
           path: "/v1/chat/completions",
@@ -805,6 +1208,45 @@ function createApp(params) {
       config: await buildAdminConfig(request)
     };
   });
+  app.post("/_gateway/admin/codex/configure-provider", async (request, reply) => {
+    const parsed = codexProviderConfigSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    const origin = resolveOrigin(request);
+    const baseUrl = parsed.data.baseUrl ?? `${origin}/codex/v1`;
+    return {
+      codexProvider: await ctx.authService.applyGatewayToCodexProvider({
+        baseUrl,
+        providerId: parsed.data.providerId
+      }),
+      config: await buildAdminConfig(request)
+    };
+  });
+  app.post("/_gateway/admin/codex/remove-provider", async (request, reply) => {
+    const parsed = codexProviderConfigSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      reply.code(400);
+      return {
+        error: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    return {
+      codexProvider: await ctx.authService.removeGatewayFromCodexProvider({
+        providerId: parsed.data.providerId
+      }),
+      config: await buildAdminConfig(request)
+    };
+  });
   app.put("/_gateway/admin/settings", async (request, reply) => {
     const parsed = settingsUpdateSchema.safeParse(request.body);
     if (!parsed.success) {
@@ -839,6 +1281,22 @@ function createApp(params) {
       restarting: true
     };
   });
+  app.post("/_gateway/admin/desktop/restart-codex", async (_request, reply) => {
+    if (!params?.onRestartCodex) {
+      reply.code(501);
+      return {
+        error: {
+          type: "not_supported",
+          message: "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301\u91CD\u542F Codex\u3002"
+        }
+      };
+    }
+    await params.onRestartCodex();
+    return {
+      ok: true,
+      restarted: true
+    };
+  });
   app.post("/_gateway/admin/settings/proxy-test", async (request, reply) => {
     const parsed = proxyTestSchema.safeParse(request.body);
     if (!parsed.success) {
@@ -959,9 +1417,171 @@ function createApp(params) {
       owned_by: model.provider
     }))
   }));
-  app.post("/v1/responses", async (request, reply) => {
+  async function handleCodexResponsesPassthrough(request, reply, data, startedAt) {
+    const abortController = new AbortController();
+    let streamFinished = false;
+    let headersCommitted = false;
+    let profile = null;
+    let retryCount = 0;
+    let failureRecorded = false;
+    reply.raw.on("close", () => {
+      if (!streamFinished) {
+        abortController.abort();
+      }
+    });
+    try {
+      const model = await ctx.modelService.resolveModel("openai-codex", data.model, {
+        allowUnknown: data.experimental_codex?.allow_unknown_model
+      });
+      const codexBody = createCodexPassthroughBody(data, model);
+      let upstream = null;
+      const maxProfileAttempts = 5;
+      for (let attempt = 0; attempt < maxProfileAttempts; attempt += 1) {
+        profile = await ctx.authService.requireUsableProfile("openai-codex");
+        try {
+          upstream = await streamOpenAICodex({
+            profile,
+            model,
+            bodyOverride: codexBody,
+            passthroughBody: true,
+            signal: abortController.signal
+          });
+          break;
+        } catch (error) {
+          const quota = error.quota;
+          const switchedProfile = await ctx.authService.recordProfileRequestFailure(profile.profileId, error, quota, "openai-codex");
+          failureRecorded = true;
+          if (attempt < maxProfileAttempts - 1 && isQuotaLimitError(error) && switchedProfile && switchedProfile.profileId !== profile.profileId && !abortController.signal.aborted) {
+            retryCount += 1;
+            failureRecorded = false;
+            continue;
+          }
+          throw error;
+        }
+      }
+      if (!upstream || !profile) {
+        throw new Error("Codex stream \u672A\u80FD\u5EFA\u7ACB\u3002");
+      }
+      await ctx.authService.recordProfileRequestSuccess(profile.profileId, upstream.quota, "openai-codex");
+      const headers = {
+        "Content-Type": upstream.headers["content-type"] ?? "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no"
+      };
+      for (const [key, value] of Object.entries(upstream.headers)) {
+        if (key.startsWith("x-codex-") || key === "x-request-id") {
+          headers[key] = value;
+        }
+      }
+      reply.raw.writeHead(upstream.status, headers);
+      headersCommitted = true;
+      reply.raw.flushHeaders?.();
+      const streamStats = createSseStreamStats();
+      for await (const chunk of Readable.fromWeb(upstream.body)) {
+        trackSseChunk(streamStats, chunk);
+        if (!reply.raw.write(chunk)) {
+          await new Promise((resolve) => reply.raw.once("drain", resolve));
+        }
+      }
+      streamFinished = true;
+      reply.raw.end();
+      if (!streamStats.completed) {
+        console.warn("[gateway:codex:stream] upstream stream ended without response.completed", {
+          requestId: request.id,
+          upstreamRequestId: upstream.requestId,
+          account: profileLogLabel(profile),
+          model,
+          bytes: streamStats.bytes,
+          terminalEvent: streamStats.terminalEvent
+        });
+      }
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: profileLogLabel(profile),
+        model,
+        statusCode: upstream.status,
+        durationMs: performance.now() - startedAt,
+        source: "Codex",
+        details: {
+          requestId: request.id,
+          upstreamRequestId: upstream.requestId,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: summarizeResponsesRequest(data),
+          response: {
+            stream: true,
+            passthrough: true,
+            retryCount,
+            completed: streamStats.completed,
+            terminalEvent: streamStats.terminalEvent,
+            bytes: streamStats.bytes
+          }
+        }
+      });
+      return reply;
+    } catch (error) {
+      const quota = error.quota;
+      if (profile && !failureRecorded) {
+        await ctx.authService.recordProfileRequestFailure(profile.profileId, error, quota, "openai-codex");
+      }
+      const normalized = normalizeError(error);
+      const statusCode = getErrorStatusCode(normalized);
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: profileLogLabel(profile),
+        model: data.model ?? "default",
+        statusCode,
+        durationMs: performance.now() - startedAt,
+        source: "Codex",
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: summarizeResponsesRequest(data),
+          response: {
+            retryCount
+          },
+          error: {
+            message: normalized.message,
+            upstreamStatus: normalized.upstreamStatus,
+            upstreamErrorCode: normalized.upstreamErrorCode,
+            upstreamErrorMessage: normalized.upstreamErrorMessage
+          }
+        }
+      });
+      if (headersCommitted) {
+        streamFinished = true;
+        reply.raw.end();
+        return reply;
+      }
+      throw error;
+    }
+  }
+  app.post("/codex/v1/responses", async (request, reply) => {
+    const startedAt = performance.now();
     const parsed = responsesBodySchema.safeParse(request.body);
     if (!parsed.success) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: "-",
+        statusCode: 400,
+        durationMs: performance.now() - startedAt,
+        source: "Codex",
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          error: {
+            type: "validation_error",
+            message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+          }
+        }
+      });
       reply.code(400);
       return {
         error: {
@@ -970,18 +1590,61 @@ function createApp(params) {
         }
       };
     }
-    if (parsed.data.stream) {
-      reply.code(501);
+    return handleCodexResponsesPassthrough(request, reply, parsed.data, startedAt);
+  });
+  app.post("/v1/responses", async (request, reply) => {
+    const startedAt = performance.now();
+    const parsed = responsesBodySchema.safeParse(request.body);
+    if (!parsed.success) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: "-",
+        statusCode: 400,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          error: {
+            type: "validation_error",
+            message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+          }
+        }
+      });
+      reply.code(400);
       return {
         error: {
-          type: "not_supported",
-          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 stream=true"
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
         }
       };
     }
+    const wantsEventStream = typeof request.headers.accept === "string" && request.headers.accept.toLowerCase().includes("text/event-stream");
     const input = extractTextInput(parsed.data.input);
     const hasInput = typeof parsed.data.input !== "undefined" || typeof parsed.data.experimental_codex?.body?.input !== "undefined";
     if (!hasInput) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "default",
+        statusCode: 400,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: summarizeResponsesRequest(parsed.data),
+          error: {
+            type: "validation_error",
+            message: "\u6CA1\u6709\u63D0\u4F9B input\uFF0C\u4E5F\u6CA1\u6709\u5728 experimental_codex.body \u91CC\u900F\u4F20 input"
+          }
+        }
+      });
       reply.code(400);
       return {
         error: {
@@ -990,34 +1653,35 @@ function createApp(params) {
         }
       };
     }
-    const codexBody = {
-      ...parsed.data.experimental_codex?.body ?? {}
-    };
-    const normalizedInput = normalizeResponseInput(parsed.data.input);
-    if (typeof normalizedInput !== "undefined") {
-      codexBody.input = normalizedInput;
-    }
-    if (typeof parsed.data.instructions === "string") {
-      codexBody.instructions = parsed.data.instructions;
-    }
-    if (parsed.data.tools) {
-      codexBody.tools = parsed.data.tools;
-    }
-    if (typeof parsed.data.tool_choice !== "undefined") {
-      codexBody.tool_choice = parsed.data.tool_choice;
-    }
-    if (parsed.data.include) {
-      codexBody.include = parsed.data.include;
-    }
-    if (parsed.data.text) {
-      codexBody.text = parsed.data.text;
-    }
-    if (typeof parsed.data.store === "boolean") {
-      codexBody.store = parsed.data.store;
-    }
-    if (typeof parsed.data.parallel_tool_calls === "boolean") {
-      codexBody.parallel_tool_calls = parsed.data.parallel_tool_calls;
+    if (parsed.data.stream || wantsEventStream) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "default",
+        statusCode: 501,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: summarizeResponsesRequest(parsed.data),
+          error: {
+            type: "not_supported",
+            message: "\u666E\u901A Responses stream \u5C1A\u672A\u5B9E\u73B0\uFF1BCodex custom provider \u8BF7\u6C42\u4F1A\u8D70\u4E13\u7528\u900F\u4F20\u8DEF\u5F84\u3002"
+          }
+        }
+      });
+      reply.code(501);
+      return {
+        error: {
+          type: "not_supported",
+          message: "\u666E\u901A Responses stream \u5C1A\u672A\u5B9E\u73B0\uFF1BCodex custom provider \u8BF7\u6C42\u4F1A\u8D70\u4E13\u7528\u900F\u4F20\u8DEF\u5F84\u3002"
+        }
+      };
     }
+    const codexBody = createResponsesCodexBody(parsed.data);
     const result = await ctx.chatService.chat({
       model: parsed.data.model,
       input: input || void 0,
@@ -1030,8 +1694,27 @@ function createApp(params) {
     return buildResponseApiBody(result, parsed.data.experimental_codex?.include_raw);
   });
   app.post("/v1/chat/completions", async (request, reply) => {
+    const startedAt = performance.now();
     const parsed = chatCompletionsBodySchema.safeParse(request.body);
     if (!parsed.success) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: "-",
+        statusCode: 400,
+        durationMs: performance.now() - startedAt,
+        source: "API",
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          error: {
+            type: "validation_error",
+            message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+          }
+        }
+      });
       reply.code(400);
       return {
         error: {
@@ -1040,16 +1723,24 @@ function createApp(params) {
         }
       };
     }
-    if (parsed.data.stream) {
-      reply.code(501);
-      return {
-        error: {
-          type: "not_supported",
-          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 chat.completions \u7684 stream=true"
-        }
-      };
-    }
     if (typeof parsed.data.n === "number" && parsed.data.n > 1) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "default",
+        statusCode: 501,
+        durationMs: performance.now() - startedAt,
+        source: "API",
+        details: {
+          requestId: request.id,
+          request: summarizeChatCompletionsRequest(parsed.data),
+          error: {
+            type: "not_supported",
+            message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301\u4E00\u6B21\u8FD4\u56DE\u591A\u4E2A choices\uFF08n > 1\uFF09"
+          }
+        }
+      });
       reply.code(501);
       return {
         error: {
@@ -1059,16 +1750,93 @@ function createApp(params) {
       };
     }
     const codexBody = createChatCompletionsCodexBody(parsed.data);
+    console.info("[gateway:chat:request]", {
+      requestId: request.id,
+      remoteAddress: request.ip,
+      userAgent: request.headers["user-agent"],
+      ...summarizeChatCompletionsRequest(parsed.data),
+      codex: summarizeCodexChatBody(codexBody)
+    });
     const fallbackInput = parsed.data.messages.map(
       (message) => typeof message.content === "string" ? message.content : (message.content ?? []).map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n")
     ).filter(Boolean).join("\n").trim();
-    const result = await ctx.chatService.chat({
-      model: parsed.data.model,
-      input: fallbackInput || void 0,
-      experimental: {
-        codexBody
+    let result;
+    try {
+      result = await ctx.chatService.chat({
+        model: parsed.data.model,
+        input: fallbackInput || void 0,
+        experimental: {
+          codexBody
+        }
+      });
+    } catch (error) {
+      const normalized = normalizeError(error);
+      const statusCode = getErrorStatusCode(normalized);
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: profileLogLabel(await ctx.authService.getActiveProfile()),
+        model: parsed.data.model ?? "default",
+        statusCode,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: summarizeChatCompletionsRequest(parsed.data),
+          codex: summarizeCodexChatBody(codexBody),
+          error: {
+            message: normalized.message,
+            upstreamStatus: normalized.upstreamStatus,
+            upstreamErrorCode: normalized.upstreamErrorCode,
+            upstreamErrorMessage: normalized.upstreamErrorMessage
+          }
+        }
+      });
+      throw error;
+    }
+    pushGatewayRequestLog({
+      method: request.method,
+      endpoint: request.url,
+      account: profileLogLabel(await ctx.authService.getActiveProfile()),
+      model: result.model,
+      statusCode: 200,
+      durationMs: performance.now() - startedAt,
+      source: requestSourceFromUserAgent(request.headers["user-agent"]),
+      details: {
+        requestId: request.id,
+        remoteAddress: request.ip,
+        userAgent: request.headers["user-agent"],
+        request: summarizeChatCompletionsRequest(parsed.data),
+        codex: summarizeCodexChatBody(codexBody),
+        response: {
+          textPreview: truncateForLog(result.text),
+          textLength: result.text.length,
+          toolCallCount: result.toolCalls.length,
+          toolCalls: result.toolCalls.map((toolCall) => ({
+            id: toolCall.id,
+            name: toolCall.function.name,
+            argumentsPreview: truncateForLog(toolCall.function.arguments)
+          })),
+          artifactCount: result.artifacts.length,
+          stream: parsed.data.stream ?? false
+        }
       }
     });
+    console.info("[gateway:chat:response]", {
+      requestId: request.id,
+      model: result.model,
+      stream: parsed.data.stream ?? false,
+      durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
+      textLength: result.text.length,
+      toolCallCount: result.toolCalls.length,
+      artifactCount: result.artifacts.length
+    });
+    if (parsed.data.stream) {
+      sendChatCompletionsStream(reply, result);
+      return reply;
+    }
     return buildChatCompletionsBody(result);
   });
   app.post("/v1/images/generations", async (request, reply) => {