ai-zero-token 2.0.4 → 2.0.6

package/dist/server/app.js

@@ -2,16 +2,30 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { Readable } from "node:stream";
+import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
+import {
+  brotliDecompress,
+  gunzip,
+  inflate,
+  zstdDecompress
+} from "node:zlib";
 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";
+import { generateChatGPTWebImage } from "../core/providers/openai-codex/chatgpt-web-image.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 gunzipAsync = promisify(gunzip);
+const inflateAsync = promisify(inflate);
+const brotliDecompressAsync = promisify(brotliDecompress);
+const zstdDecompressAsync = typeof zstdDecompress === "function" ? promisify(zstdDecompress) : null;
 const assetContentTypes = {
   ".css": "text/css; charset=utf-8",
   ".gif": "image/gif",
@@ -29,6 +43,35 @@ const assetContentTypes = {
 function getContentType(filePath) {
   return assetContentTypes[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
+async function decodeJsonRequestBody(body, contentEncoding) {
+  const encodings = (Array.isArray(contentEncoding) ? contentEncoding.join(",") : contentEncoding ?? "").split(",").map((item) => item.trim().toLowerCase()).filter((item) => item && item !== "identity");
+  let decoded = body;
+  for (const encoding of encodings.reverse()) {
+    if (encoding === "gzip" || encoding === "x-gzip") {
+      decoded = await gunzipAsync(decoded);
+    } else if (encoding === "deflate") {
+      decoded = await inflateAsync(decoded);
+    } else if (encoding === "br") {
+      decoded = await brotliDecompressAsync(decoded);
+    } else if (encoding === "zstd") {
+      if (!zstdDecompressAsync) {
+        throw new Error("\u5F53\u524D Node.js \u8FD0\u884C\u65F6\u4E0D\u652F\u6301 zstd \u8BF7\u6C42\u4F53\u89E3\u538B\uFF0C\u8BF7\u5347\u7EA7\u8FD0\u884C\u65F6\u540E\u91CD\u8BD5\u3002");
+      }
+      decoded = await zstdDecompressAsync(decoded);
+    } else {
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u8BF7\u6C42\u4F53\u538B\u7F29\u683C\u5F0F: ${encoding}`);
+    }
+  }
+  return decoded;
+}
+async function parseJsonRequestBody(request, body) {
+  const rawBody = typeof body === "string" ? Buffer.from(body) : body;
+  if (rawBody.length === 0) {
+    return {};
+  }
+  const decoded = await decodeJsonRequestBody(rawBody, request.headers["content-encoding"]);
+  return JSON.parse(decoded.toString("utf8"));
+}
 async function readAdminUiAsset(assetPath) {
   const normalized = path.normalize(assetPath).replace(/^(\.\.(\/|\\|$))+/, "");
   const filePath = path.resolve(adminUiDistDir, normalized);
@@ -45,17 +88,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(),
@@ -69,7 +104,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(),
@@ -114,11 +149,15 @@ 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()
   }).optional(),
+  image: z.object({
+    freeAccountWebGenerationEnabled: z.boolean().optional()
+  }).optional(),
   server: z.object({
     port: z.number().int().min(1).max(65535)
   }).optional()
@@ -150,6 +189,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)
 });
@@ -199,6 +242,97 @@ const imageEditsBodySchema = z.object({
   response_format: z.enum(["b64_json", "url"]).optional(),
   user: z.string().optional()
 }).passthrough();
+function isObjectRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function tokenNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
+}
+function normalizeTokenUsage(value) {
+  if (!isObjectRecord(value)) {
+    return null;
+  }
+  const inputTokens = tokenNumber(value.input_tokens ?? value.prompt_tokens);
+  const outputTokens = tokenNumber(value.output_tokens ?? value.completion_tokens);
+  const totalTokens = tokenNumber(value.total_tokens) ?? (inputTokens !== null || outputTokens !== null ? (inputTokens ?? 0) + (outputTokens ?? 0) : null);
+  if (inputTokens === null && outputTokens === null && totalTokens === null) {
+    return null;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens
+  };
+}
+function extractTokenUsage(value, depth = 0) {
+  if (depth > 5 || !value) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const usage = extractTokenUsage(item, depth + 1);
+      if (usage) {
+        return usage;
+      }
+    }
+    return null;
+  }
+  if (!isObjectRecord(value)) {
+    return null;
+  }
+  const direct = normalizeTokenUsage(value);
+  if (direct) {
+    return direct;
+  }
+  for (const key of ["usage", "response", "events"]) {
+    const usage = extractTokenUsage(value[key], depth + 1);
+    if (usage) {
+      return usage;
+    }
+  }
+  return null;
+}
+function imageUsageToTokenUsage(usage) {
+  if (!usage) {
+    return null;
+  }
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    totalTokens: usage.total_tokens
+  };
+}
+function extractUsageErrorType(details, statusCode) {
+  const error = isObjectRecord(details?.error) ? details.error : null;
+  const upstreamErrorCode = error?.upstreamErrorCode;
+  const upstreamStatus = error?.upstreamStatus;
+  const type = error?.type;
+  if (typeof upstreamErrorCode === "string" && upstreamErrorCode.trim()) {
+    return upstreamErrorCode.trim();
+  }
+  if (typeof type === "string" && type.trim()) {
+    return type.trim();
+  }
+  if (typeof upstreamStatus === "number") {
+    return `HTTP ${upstreamStatus}`;
+  }
+  return statusCode >= 400 ? `HTTP ${statusCode}` : void 0;
+}
+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 "";
@@ -207,15 +341,60 @@ 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();
 }
+function extractImageUrlFromInputPart(part) {
+  if (!isObjectRecord(part)) {
+    return null;
+  }
+  const imageUrl = part.image_url ?? part.imageUrl;
+  if (typeof imageUrl === "string" && imageUrl.trim()) {
+    return imageUrl.trim();
+  }
+  if (isObjectRecord(imageUrl) && typeof imageUrl.url === "string" && imageUrl.url.trim()) {
+    return imageUrl.url.trim();
+  }
+  return null;
+}
+function extractImageInputs(input) {
+  const images = [];
+  const addImage = (imageUrl) => {
+    if (imageUrl && !images.some((item) => item.imageUrl === imageUrl)) {
+      images.push({ imageUrl });
+    }
+  };
+  if (!Array.isArray(input)) {
+    addImage(extractImageUrlFromInputPart(input));
+    return images;
+  }
+  for (const item of input) {
+    addImage(extractImageUrlFromInputPart(item));
+    if (!isObjectRecord(item)) {
+      continue;
+    }
+    const content = item.content;
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        addImage(extractImageUrlFromInputPart(part));
+      }
+    } else {
+      addImage(extractImageUrlFromInputPart(content));
+    }
+  }
+  return images;
+}
+function isFreePlan(profile) {
+  return profile.quota?.planType?.toLowerCase() === "free";
+}
 function normalizeResponseInput(input) {
   if (typeof input === "undefined") {
     return void 0;
@@ -412,9 +591,162 @@ function summarizeToolNames(tools) {
     }
     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 : "";
+    return typeof fn?.name === "string" ? fn.name : typeof record.name === "string" ? record.name : typeof record.type === "string" ? record.type : "";
   }).filter(Boolean);
 }
+function summarizeResponsesRequest(data, endpoint = "/v1/responses") {
+  const input = data.input;
+  const toolNames = summarizeToolNames(Array.isArray(data.tools) ? data.tools : void 0);
+  return {
+    endpoint,
+    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 getImageGenerationTool(body) {
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  for (const tool of tools) {
+    if (isObjectRecord(tool) && tool.type === "image_generation") {
+      return tool;
+    }
+  }
+  return null;
+}
+function hasImageGenerationToolChoice(body) {
+  const choice = body.tool_choice;
+  if (typeof choice === "string") {
+    return choice === "image_generation";
+  }
+  return isObjectRecord(choice) && choice.type === "image_generation";
+}
+function normalizeImageOutputFormat(value) {
+  return value === "png" || value === "webp" || value === "jpeg" ? value : void 0;
+}
+function extractCodexImageGenerationRequest(body) {
+  const imageTool = getImageGenerationTool(body);
+  if (!hasImageGenerationToolChoice(body)) {
+    return null;
+  }
+  return {
+    prompt: extractTextInput(body.input),
+    inputImages: extractImageInputs(body.input),
+    imageModel: typeof imageTool?.model === "string" && imageTool.model.trim() ? imageTool.model.trim() : "gpt-image-2",
+    size: typeof imageTool?.size === "string" && imageTool.size.trim() ? imageTool.size.trim() : void 0,
+    outputFormat: normalizeImageOutputFormat(imageTool?.output_format)
+  };
+}
+async function writeResponsesSseBlock(reply, block) {
+  if (!reply.raw.write(block)) {
+    await new Promise((resolve) => reply.raw.once("drain", resolve));
+  }
+  return Buffer.byteLength(block);
+}
+async function writeResponsesSseEvent(reply, eventName, payload) {
+  return writeResponsesSseBlock(reply, `event: ${eventName}
+data: ${JSON.stringify(payload)}
+
+`);
+}
+async function sendSyntheticCodexImageSse(params) {
+  const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
+  const created = Math.floor(Date.now() / 1e3);
+  const outputFormat = params.result.output_format ?? params.requestedOutputFormat ?? "png";
+  const size = params.result.size ?? params.requestedSize;
+  const output = params.result.data.map((image, index) => ({
+    id: `ig_${randomUUID().replace(/-/g, "")}`,
+    type: "image_generation_call",
+    status: "completed",
+    result: image.b64_json,
+    revised_prompt: image.revised_prompt ?? params.prompt,
+    output_format: outputFormat,
+    ...size ? { size } : {}
+  }));
+  let bytes = 0;
+  params.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"
+  });
+  params.reply.raw.flushHeaders?.();
+  bytes += await writeResponsesSseEvent(params.reply, "response.created", {
+    type: "response.created",
+    response: {
+      id: responseId,
+      object: "response",
+      created_at: created,
+      model: params.model,
+      status: "in_progress",
+      output: []
+    }
+  });
+  for (let index = 0; index < output.length; index += 1) {
+    const item = output[index];
+    bytes += await writeResponsesSseEvent(params.reply, "response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: index,
+      item: {
+        id: item.id,
+        type: item.type,
+        status: "in_progress"
+      }
+    });
+    bytes += await writeResponsesSseEvent(params.reply, "response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: index,
+      item
+    });
+  }
+  bytes += await writeResponsesSseEvent(params.reply, "response.completed", {
+    type: "response.completed",
+    response: {
+      id: responseId,
+      object: "response",
+      created_at: created,
+      model: params.model,
+      status: "completed",
+      output,
+      usage: null
+    }
+  });
+  bytes += await writeResponsesSseBlock(params.reply, "data: [DONE]\n\n");
+  params.reply.raw.end();
+  return {
+    bytes,
+    imageCount: output.length
+  };
+}
 function summarizeChatCompletionsRequest(data) {
   const lastUserMessage = [...data.messages].reverse().find((message) => (message.role ?? "user") === "user");
   const toolNames = summarizeToolNames(data.tools);
@@ -451,11 +783,57 @@ function summarizeCodexChatBody(body) {
     hasReasoning: Boolean(body.reasoning)
   };
 }
+async function buildOpenAIModelsResponse(ctx) {
+  return {
+    object: "list",
+    data: (await ctx.modelService.listModels()).map((model) => ({
+      id: model.id,
+      object: "model",
+      owned_by: model.provider
+    }))
+  };
+}
+async function buildCodexModelsResponse(ctx) {
+  const [models, catalog] = await Promise.all([
+    ctx.modelService.listModels(),
+    ctx.modelService.getCatalog()
+  ]);
+  return {
+    fetched_at: catalog.fetchedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    models: models.map((model, index) => ({
+      slug: model.id,
+      display_name: model.name,
+      description: model.name,
+      default_reasoning_level: "medium",
+      supported_reasoning_levels: [
+        { effort: "low", description: "Fast responses with lighter reasoning" },
+        { effort: "medium", description: "Balanced speed and reasoning" },
+        { effort: "high", description: "Deeper reasoning" },
+        { effort: "xhigh", description: "Extra deep reasoning" }
+      ],
+      shell_type: "shell_command",
+      visibility: "list",
+      supported_in_api: true,
+      priority: index,
+      input_modalities: model.input
+    }))
+  };
+}
 function profileLogLabel(profile) {
   return profile?.email || profile?.accountId || profile?.profileId || "-";
 }
 function requestSourceFromUserAgent(userAgent) {
-  return typeof userAgent === "string" && userAgent.toLowerCase().includes("openclaw") ? "OpenClaw" : "API";
+  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 = {
@@ -749,7 +1127,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;
@@ -761,15 +1139,67 @@ 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
   });
+  app.removeContentTypeParser("application/json");
+  app.addContentTypeParser(
+    /^application\/(?:[\w!#$&^.+-]+\+)?json(?:\s*;.*)?$/i,
+    { parseAs: "buffer" },
+    (request, body, done) => {
+      parseJsonRequestBody(request, Buffer.isBuffer(body) ? body : Buffer.from(body)).then((parsed) => done(null, parsed)).catch((error) => done(error));
+    }
+  );
   const ctx = createGatewayContext();
   const gatewayRequestLogs = [];
   function pushGatewayRequestLog(log) {
-    gatewayRequestLogs.unshift({
+    const entry = {
       id: log.id ?? randomUUID(),
       time: log.time ?? Date.now(),
       method: log.method,
@@ -780,10 +1210,34 @@ function createApp(params) {
       durationMs: log.durationMs,
       source: log.source,
       details: log.details
-    });
+    };
+    gatewayRequestLogs.unshift(entry);
     if (gatewayRequestLogs.length > MAX_GATEWAY_REQUEST_LOGS) {
       gatewayRequestLogs.length = MAX_GATEWAY_REQUEST_LOGS;
     }
+    const profile = log.usage?.profile ?? void 0;
+    const usageEvent = {
+      id: entry.id,
+      timestamp: entry.time,
+      method: entry.method,
+      endpoint: entry.endpoint,
+      model: entry.model,
+      source: entry.source,
+      statusCode: entry.statusCode,
+      durationMs: entry.durationMs,
+      success: entry.statusCode >= 200 && entry.statusCode < 400,
+      profileId: profile?.profileId,
+      accountId: profile?.accountId,
+      accountLabel: entry.account,
+      planType: profile?.quota?.planType,
+      tokenUsage: log.usage?.tokenUsage,
+      imageCount: log.usage?.imageCount,
+      imageRoute: log.usage?.imageRoute ?? "none",
+      errorType: log.usage?.errorType ?? extractUsageErrorType(log.details, entry.statusCode)
+    };
+    ctx.usageService.record(usageEvent).catch((error) => {
+      console.warn("[gateway:usage] \u7EDF\u8BA1\u5199\u5165\u5931\u8D25", error);
+    });
   }
   void app.register(cors, {
     origin: params?.corsOrigin ?? true,
@@ -810,8 +1264,9 @@ function createApp(params) {
   app.get("/_gateway/admin/request-logs", async () => ({
     data: gatewayRequestLogs
   }));
+  app.get("/_gateway/admin/usage", async () => ctx.usageService.getSummary());
   async function buildAdminConfig(request) {
-    const [status, models, modelCatalog, versionStatus, settings, profile, profiles, codexStatus] = await Promise.all([
+    const [status, models, modelCatalog, versionStatus, settings, profile, profiles, codexStatus, usage] = await Promise.all([
       ctx.authService.getStatus(),
       ctx.modelService.listModels(),
       ctx.modelService.getCatalog(),
@@ -819,7 +1274,8 @@ function createApp(params) {
       ctx.configService.getSettings(),
       ctx.authService.getActiveProfile(),
       ctx.authService.listProfiles(),
-      ctx.authService.getCodexStatus()
+      ctx.authService.getCodexStatus(),
+      ctx.usageService.getSummary()
     ]);
     const origin = resolveOrigin(request);
     return {
@@ -831,8 +1287,10 @@ function createApp(params) {
       profile: serializeProfile(profile),
       profiles: profiles.map((item) => serializeManagedProfile(item)),
       codex: codexStatus,
+      usage,
       adminUrl: `${origin}/`,
       baseUrl: `${origin}/v1`,
+      codexBaseUrl: `${origin}/codex/v1`,
       restartSupported: Boolean(params?.onRestart),
       codexRestartSupported: Boolean(params?.onRestartCodex),
       supportedEndpoints: [
@@ -846,6 +1304,16 @@ 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: "/codex/v1/responses/compact",
+          description: "Codex custom provider \u4E13\u7528 Responses compact SSE \u900F\u4F20\u63A5\u53E3\u3002"
+        },
         {
           method: "POST",
           path: "/v1/chat/completions",
@@ -1092,6 +1560,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) {
@@ -1254,83 +1761,470 @@ function createApp(params) {
     return ctx.githubImageBedService.deleteHistoryItem(parsed.data.id);
   });
   app.delete("/_gateway/image-bed/history", async () => ctx.githubImageBedService.clearHistory());
-  app.get("/v1/models", async () => ({
-    object: "list",
-    data: (await ctx.modelService.listModels()).map((model) => ({
-      id: model.id,
-      object: "model",
-      owned_by: model.provider
-    }))
-  }));
-  app.post("/v1/responses", async (request, reply) => {
-    const parsed = responsesBodySchema.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"
+  app.get("/v1/models", async () => buildOpenAIModelsResponse(ctx));
+  app.get("/codex/v1/models", async () => buildCodexModelsResponse(ctx));
+  app.get("/codex/v1/responses", async (_request, reply) => {
+    reply.code(426);
+    return {
+      error: {
+        type: "websocket_unsupported",
+        message: "AI Zero Token \u5F53\u524D\u901A\u8FC7 HTTP SSE \u8F6C\u53D1 Codex Responses \u8BF7\u6C42\u3002"
+      }
+    };
+  });
+  async function handleCodexResponsesPassthrough(request, reply, data, startedAt, upstreamEndpoint = "responses") {
+    const abortController = new AbortController();
+    let streamFinished = false;
+    let headersCommitted = false;
+    let profile = null;
+    let retryCount = 0;
+    let failureRecorded = false;
+    let codexImageRoute = "none";
+    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);
+      const imageRequest = upstreamEndpoint === "responses" ? extractCodexImageGenerationRequest(codexBody) : null;
+      if (imageRequest) {
+        codexImageRoute = "codex-tool";
+        const settings = await ctx.configService.getSettings();
+        if (settings.image.freeAccountWebGenerationEnabled) {
+          profile = await ctx.authService.requireUsableProfile("openai-codex", {
+            skipAutoSwitch: true
+          });
         }
-      };
-    }
-    if (parsed.data.stream) {
-      reply.code(501);
-      return {
-        error: {
-          type: "not_supported",
-          message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 stream=true"
+        if (profile && isFreePlan(profile)) {
+          if (!imageRequest.prompt) {
+            throw new Error("Codex \u751F\u56FE\u8BF7\u6C42\u7F3A\u5C11\u6587\u672C prompt\u3002");
+          }
+          console.info("[gateway:codex:image] using ChatGPT web image route for Free profile", {
+            requestId: request.id,
+            account: profileLogLabel(profile),
+            model,
+            imageModel: imageRequest.imageModel,
+            promptLength: imageRequest.prompt.length,
+            inputImageCount: imageRequest.inputImages.length,
+            size: imageRequest.size ?? "default"
+          });
+          const imageResult = await generateChatGPTWebImage({
+            profile,
+            prompt: imageRequest.prompt,
+            model: imageRequest.imageModel,
+            inputImages: imageRequest.inputImages,
+            size: imageRequest.size,
+            responseFormat: "b64_json"
+          });
+          await ctx.authService.recordProfileRequestSuccess(profile.profileId, void 0, "openai-codex", {
+            skipAutoSwitch: true
+          });
+          headersCommitted = true;
+          const syntheticStats = await sendSyntheticCodexImageSse({
+            reply,
+            result: imageResult,
+            model,
+            prompt: imageRequest.prompt,
+            requestedSize: imageRequest.size,
+            requestedOutputFormat: imageRequest.outputFormat
+          });
+          streamFinished = true;
+          pushGatewayRequestLog({
+            method: request.method,
+            endpoint: request.url,
+            account: profileLogLabel(profile),
+            model,
+            statusCode: 200,
+            durationMs: performance.now() - startedAt,
+            source: "Codex",
+            details: {
+              requestId: request.id,
+              remoteAddress: request.ip,
+              userAgent: request.headers["user-agent"],
+              request: summarizeResponsesRequest(data, request.url),
+              response: {
+                stream: true,
+                passthrough: false,
+                upstreamEndpoint,
+                route: "chatgpt-web-image",
+                imageModel: imageRequest.imageModel,
+                imageCount: syntheticStats.imageCount,
+                bytes: syntheticStats.bytes
+              }
+            },
+            usage: {
+              profile,
+              imageCount: syntheticStats.imageCount,
+              imageRoute: "chatgpt-web"
+            }
+          });
+          return reply;
         }
-      };
-    }
-    const input = extractTextInput(parsed.data.input);
-    const hasInput = typeof parsed.data.input !== "undefined" || typeof parsed.data.experimental_codex?.body?.input !== "undefined";
-    if (!hasInput) {
-      reply.code(400);
-      return {
-        error: {
-          type: "validation_error",
-          message: "\u6CA1\u6709\u63D0\u4F9B input\uFF0C\u4E5F\u6CA1\u6709\u5728 experimental_codex.body \u91CC\u900F\u4F20 input"
+      }
+      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,
+            endpoint: upstreamEndpoint,
+            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"
       };
-    }
-    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;
-    }
-    const result = await ctx.chatService.chat({
-      model: parsed.data.model,
-      input: input || void 0,
-      system: parsed.data.instructions,
-      experimental: {
-        codexBody,
-        allowUnknownModel: parsed.data.experimental_codex?.allow_unknown_model
+      for (const [key, value] of Object.entries(upstream.headers)) {
+        if (key.startsWith("x-codex-") || key === "x-request-id") {
+          headers[key] = value;
+        }
       }
-    });
-    return buildResponseApiBody(result, parsed.data.experimental_codex?.include_raw);
+      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, request.url),
+          response: {
+            stream: true,
+            passthrough: true,
+            upstreamEndpoint,
+            retryCount,
+            completed: streamStats.completed,
+            terminalEvent: streamStats.terminalEvent,
+            bytes: streamStats.bytes
+          }
+        },
+        usage: {
+          profile,
+          imageRoute: codexImageRoute
+        }
+      });
+      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, request.url),
+          response: {
+            upstreamEndpoint,
+            retryCount
+          },
+          error: {
+            message: normalized.message,
+            upstreamStatus: normalized.upstreamStatus,
+            upstreamErrorCode: normalized.upstreamErrorCode,
+            upstreamErrorMessage: normalized.upstreamErrorMessage
+          }
+        },
+        usage: {
+          profile,
+          imageRoute: codexImageRoute
+        }
+      });
+      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: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    return handleCodexResponsesPassthrough(request, reply, parsed.data, startedAt);
+  });
+  app.post("/codex/v1/responses/compact", 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: {
+          type: "validation_error",
+          message: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
+        }
+      };
+    }
+    return handleCodexResponsesPassthrough(request, reply, parsed.data, startedAt, "responses/compact");
+  });
+  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: "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: {
+          type: "validation_error",
+          message: "\u6CA1\u6709\u63D0\u4F9B input\uFF0C\u4E5F\u6CA1\u6709\u5728 experimental_codex.body \u91CC\u900F\u4F20 input"
+        }
+      };
+    }
+    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);
+    let result;
+    try {
+      result = await ctx.chatService.chat({
+        model: parsed.data.model,
+        input: input || void 0,
+        system: parsed.data.instructions,
+        experimental: {
+          codexBody,
+          allowUnknownModel: parsed.data.experimental_codex?.allow_unknown_model
+        }
+      });
+    } catch (error) {
+      const normalized = normalizeError(error);
+      const statusCode = getErrorStatusCode(normalized);
+      const activeProfile2 = await ctx.authService.getActiveProfile();
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: profileLogLabel(activeProfile2),
+        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: summarizeResponsesRequest(parsed.data),
+          codex: summarizeCodexChatBody(codexBody),
+          error: {
+            message: normalized.message,
+            upstreamStatus: normalized.upstreamStatus,
+            upstreamErrorCode: normalized.upstreamErrorCode,
+            upstreamErrorMessage: normalized.upstreamErrorMessage
+          }
+        },
+        usage: {
+          profile: activeProfile2
+        }
+      });
+      throw error;
+    }
+    const activeProfile = await ctx.authService.getActiveProfile();
+    pushGatewayRequestLog({
+      method: request.method,
+      endpoint: request.url,
+      account: profileLogLabel(activeProfile),
+      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: summarizeResponsesRequest(parsed.data),
+        codex: summarizeCodexChatBody(codexBody),
+        response: {
+          textPreview: truncateForLog(result.text),
+          textLength: result.text.length,
+          artifactCount: result.artifacts.length
+        }
+      },
+      usage: {
+        profile: activeProfile,
+        tokenUsage: extractTokenUsage(result.raw)
+      }
+    });
+    return buildResponseApiBody(result, parsed.data.experimental_codex?.include_raw);
   });
   app.post("/v1/chat/completions", async (request, reply) => {
     const startedAt = performance.now();
@@ -1411,10 +2305,11 @@ function createApp(params) {
     } catch (error) {
       const normalized = normalizeError(error);
       const statusCode = getErrorStatusCode(normalized);
+      const activeProfile2 = await ctx.authService.getActiveProfile();
       pushGatewayRequestLog({
         method: request.method,
         endpoint: request.url,
-        account: profileLogLabel(await ctx.authService.getActiveProfile()),
+        account: profileLogLabel(activeProfile2),
         model: parsed.data.model ?? "default",
         statusCode,
         durationMs: performance.now() - startedAt,
@@ -1431,14 +2326,18 @@ function createApp(params) {
             upstreamErrorCode: normalized.upstreamErrorCode,
             upstreamErrorMessage: normalized.upstreamErrorMessage
           }
+        },
+        usage: {
+          profile: activeProfile2
         }
       });
       throw error;
     }
+    const activeProfile = await ctx.authService.getActiveProfile();
     pushGatewayRequestLog({
       method: request.method,
       endpoint: request.url,
-      account: profileLogLabel(await ctx.authService.getActiveProfile()),
+      account: profileLogLabel(activeProfile),
       model: result.model,
       statusCode: 200,
       durationMs: performance.now() - startedAt,
@@ -1461,6 +2360,10 @@ function createApp(params) {
           artifactCount: result.artifacts.length,
           stream: parsed.data.stream ?? false
         }
+      },
+      usage: {
+        profile: activeProfile,
+        tokenUsage: extractTokenUsage(result.raw)
       }
     });
     console.info("[gateway:chat:response]", {
@@ -1479,6 +2382,7 @@ function createApp(params) {
     return buildChatCompletionsBody(result);
   });
   app.post("/v1/images/generations", async (request, reply) => {
+    const startedAt = performance.now();
     const parsed = imageGenerationsBodySchema.safeParse(request.body);
     if (!parsed.success) {
       console.error("[gateway:image] validation failure", {
@@ -1486,6 +2390,24 @@ function createApp(params) {
         url: request.url,
         issue: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
       });
+      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: {
@@ -1502,6 +2424,25 @@ function createApp(params) {
         summary: summarizeImageRequestForLog(parsed.data),
         issue: validationError
       });
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "gpt-image-2",
+        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: summarizeImageRequestForLog(parsed.data),
+          error: {
+            type: "validation_error",
+            message: validationError
+          }
+        }
+      });
       reply.code(400);
       return {
         error: {
@@ -1517,6 +2458,25 @@ function createApp(params) {
         summary: summarizeImageRequestForLog(parsed.data),
         issue: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 images.generations \u4E00\u6B21\u8FD4\u56DE\u591A\u5F20\u56FE\uFF08n > 1\uFF09"
       });
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "gpt-image-2",
+        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: summarizeImageRequestForLog(parsed.data),
+          error: {
+            type: "not_supported",
+            message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 images.generations \u4E00\u6B21\u8FD4\u56DE\u591A\u5F20\u56FE\uFF08n > 1\uFF09"
+          }
+        }
+      });
       reply.code(501);
       return {
         error: {
@@ -1531,17 +2491,52 @@ function createApp(params) {
       url: request.url,
       summary: requestSummary
     });
-    const response = await ctx.imageService.generate({
-      prompt: parsed.data.prompt,
-      model: parsed.data.model,
-      n: parsed.data.n,
-      size: parsed.data.size,
-      quality: parsed.data.quality,
-      background: parsed.data.background,
-      outputFormat: parsed.data.output_format,
-      outputCompression: parsed.data.output_compression,
-      moderation: parsed.data.moderation
-    });
+    const activeProfile = await ctx.authService.getActiveProfile();
+    const settings = await ctx.configService.getSettings();
+    const imageRoute = activeProfile && isFreePlan(activeProfile) && settings.image.freeAccountWebGenerationEnabled ? "chatgpt-web" : "codex-tool";
+    let response;
+    try {
+      response = await ctx.imageService.generate({
+        prompt: parsed.data.prompt,
+        model: parsed.data.model,
+        n: parsed.data.n,
+        size: parsed.data.size,
+        quality: parsed.data.quality,
+        background: parsed.data.background,
+        outputFormat: parsed.data.output_format,
+        outputCompression: parsed.data.output_compression,
+        moderation: parsed.data.moderation
+      });
+    } catch (error) {
+      const normalized = normalizeError(error);
+      const statusCode = getErrorStatusCode(normalized);
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: profileLogLabel(activeProfile),
+        model: parsed.data.model ?? "gpt-image-2",
+        statusCode,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: requestSummary,
+          error: {
+            message: normalized.message,
+            upstreamStatus: normalized.upstreamStatus,
+            upstreamErrorCode: normalized.upstreamErrorCode,
+            upstreamErrorMessage: normalized.upstreamErrorMessage
+          }
+        },
+        usage: {
+          profile: activeProfile,
+          imageRoute
+        }
+      });
+      throw error;
+    }
     console.info("[gateway:image] response ready", {
       method: request.method,
       url: request.url,
@@ -1552,11 +2547,57 @@ function createApp(params) {
       quality: response.quality,
       size: response.size
     });
+    pushGatewayRequestLog({
+      method: request.method,
+      endpoint: request.url,
+      account: profileLogLabel(activeProfile),
+      model: parsed.data.model ?? "gpt-image-2",
+      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: requestSummary,
+        response: {
+          imageCount: response.data.length,
+          outputFormat: response.output_format,
+          quality: response.quality,
+          size: response.size
+        }
+      },
+      usage: {
+        profile: activeProfile,
+        tokenUsage: imageUsageToTokenUsage(response.usage),
+        imageCount: response.data.length,
+        imageRoute
+      }
+    });
     return response;
   });
   app.post("/v1/images/edits", async (request, reply) => {
+    const startedAt = performance.now();
     const contentType = request.headers["content-type"] ?? "";
     if (!String(contentType).toLowerCase().includes("application/json")) {
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: "-",
+        statusCode: 415,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          error: {
+            type: "unsupported_media_type",
+            message: "\u5F53\u524D\u7F51\u5173\u4EC5\u652F\u6301 JSON \u7248 images.edits\uFF1B\u8BF7\u4F7F\u7528 application/json\uFF0C\u5E76\u901A\u8FC7 images[].image_url \u4F20 URL \u6216 base64 data URL\u3002"
+          }
+        }
+      });
       reply.code(415);
       return {
         error: {
@@ -1572,6 +2613,24 @@ function createApp(params) {
         url: request.url,
         issue: parsed.error.issues[0]?.message ?? "\u8BF7\u6C42\u4F53\u683C\u5F0F\u9519\u8BEF"
       });
+      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: {
@@ -1588,6 +2647,25 @@ function createApp(params) {
         summary: summarizeImageEditRequestForLog(parsed.data),
         issue: validationError
       });
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "gpt-image-2",
+        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: summarizeImageEditRequestForLog(parsed.data),
+          error: {
+            type: "validation_error",
+            message: validationError
+          }
+        }
+      });
       reply.code(400);
       return {
         error: {
@@ -1603,6 +2681,25 @@ function createApp(params) {
         summary: summarizeImageEditRequestForLog(parsed.data),
         issue: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 images.edits \u4E00\u6B21\u8FD4\u56DE\u591A\u5F20\u56FE\uFF08n > 1\uFF09"
       });
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: "-",
+        model: parsed.data.model ?? "gpt-image-2",
+        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: summarizeImageEditRequestForLog(parsed.data),
+          error: {
+            type: "not_supported",
+            message: "\u5F53\u524D\u7F51\u5173\u6682\u4E0D\u652F\u6301 images.edits \u4E00\u6B21\u8FD4\u56DE\u591A\u5F20\u56FE\uFF08n > 1\uFF09"
+          }
+        }
+      });
       reply.code(501);
       return {
         error: {
@@ -1620,18 +2717,53 @@ function createApp(params) {
       url: request.url,
       summary: requestSummary
     });
-    const response = await ctx.imageService.generate({
-      prompt: parsed.data.prompt,
-      inputImages: imageReferences,
-      model: parsed.data.model,
-      n: parsed.data.n,
-      size: parsed.data.size,
-      quality: parsed.data.quality,
-      background: parsed.data.background,
-      outputFormat: parsed.data.output_format,
-      outputCompression: parsed.data.output_compression,
-      moderation: parsed.data.moderation
-    });
+    const activeProfile = await ctx.authService.getActiveProfile();
+    const settings = await ctx.configService.getSettings();
+    const imageRoute = activeProfile && isFreePlan(activeProfile) && settings.image.freeAccountWebGenerationEnabled ? "chatgpt-web" : "codex-tool";
+    let response;
+    try {
+      response = await ctx.imageService.generate({
+        prompt: parsed.data.prompt,
+        inputImages: imageReferences,
+        model: parsed.data.model,
+        n: parsed.data.n,
+        size: parsed.data.size,
+        quality: parsed.data.quality,
+        background: parsed.data.background,
+        outputFormat: parsed.data.output_format,
+        outputCompression: parsed.data.output_compression,
+        moderation: parsed.data.moderation
+      });
+    } catch (error) {
+      const normalized = normalizeError(error);
+      const statusCode = getErrorStatusCode(normalized);
+      pushGatewayRequestLog({
+        method: request.method,
+        endpoint: request.url,
+        account: profileLogLabel(activeProfile),
+        model: parsed.data.model ?? "gpt-image-2",
+        statusCode,
+        durationMs: performance.now() - startedAt,
+        source: requestSourceFromUserAgent(request.headers["user-agent"]),
+        details: {
+          requestId: request.id,
+          remoteAddress: request.ip,
+          userAgent: request.headers["user-agent"],
+          request: requestSummary,
+          error: {
+            message: normalized.message,
+            upstreamStatus: normalized.upstreamStatus,
+            upstreamErrorCode: normalized.upstreamErrorCode,
+            upstreamErrorMessage: normalized.upstreamErrorMessage
+          }
+        },
+        usage: {
+          profile: activeProfile,
+          imageRoute
+        }
+      });
+      throw error;
+    }
     console.info("[gateway:image:edit] response ready", {
       method: request.method,
       url: request.url,
@@ -1642,6 +2774,33 @@ function createApp(params) {
       quality: response.quality,
       size: response.size
     });
+    pushGatewayRequestLog({
+      method: request.method,
+      endpoint: request.url,
+      account: profileLogLabel(activeProfile),
+      model: parsed.data.model ?? "gpt-image-2",
+      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: requestSummary,
+        response: {
+          imageCount: response.data.length,
+          outputFormat: response.output_format,
+          quality: response.quality,
+          size: response.size
+        }
+      },
+      usage: {
+        profile: activeProfile,
+        tokenUsage: imageUsageToTokenUsage(response.usage),
+        imageCount: response.data.length,
+        imageRoute
+      }
+    });
     return response;
   });
   return app;