ai-zero-token 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 1.0.4 - 2026-04-24
+
+- Moved persistent account and settings state to the user home directory at `~/.ai-zero-token/.state`.
+- Added automatic one-time migration from the old package-local `.state` directory when available.
+- Added `AI_ZERO_TOKEN_HOME` support for overriding the persistent state location.
+- Fixed repeated login prompts after npm upgrades or global package reinstalls.
+
+## 1.0.3 - 2026-04-24
+
+- Added dynamic Codex model discovery from the local `~/.codex/models_cache.json` cache, with static model fallback when the cache is unavailable.
+- Added `azt models --refresh` and a management-page action to re-read the local Codex model list without rebuilding the package.
+- Added runtime version checks against npm, including a prominent update panel in the management UI when a newer version is available.
+- Added 10-minute automatic refresh for quota snapshots and version status in the management UI.
+- Improved quota display so account cards show used and remaining quota percentages clearly.
+- Improved quota syncing so inactive or missing login state does not break runtime refresh.
+- Improved image generation error handling with transient retries and clearer failure details.
+- Preserved response headers when using the curl HTTP fallback so quota metadata can still be captured.
+- Added Vibe Coding / OpenAI-compatible client integration documentation.

package/README.md

@@ -18,6 +18,8 @@ AI Zero Token 是一个本地优先的单用户 AI CLI 和本地网关。
 - 直接代理 `gpt-image-2`，把图片生成能力暴露成 OpenAI 风格 `images.generations` 接口
 - 启动 `azt start` 后即可获得本地管理页和本地网关，适合脚本、前端和自动化流程接入
 - 支持多账号保存、切换当前账号、查看账号套餐 plan，以及当前账号是否支持生图
+- 模型列表会优先同步本机 `~/.codex/models_cache.json`，不需要每次为新模型重新 build
+- 管理页会每 10 分钟自动同步额度快照和版本状态，并提示当前版本是否可更新
 - `free` 账号会在管理页直接预警，并在网关层明确拦截生图请求
 
 如果你只关心一句话，可以把这个项目理解为：
@@ -78,6 +80,7 @@ AI Zero Token 就是围绕这些问题设计的。
 - 在 token 过期时自动刷新
 - 通过 `azt start` 一键启动本地 HTTP 网关和管理页面
 - 在管理页面里完成多账号登录、查看账号状态、切换当前账号、切换默认模型、测试接口
+- 模型列表优先读取本机 Codex 最新缓存，并支持在 CLI / 管理页手动同步
 - 暴露 OpenAI 风格接口：
   - `GET /v1/models`
   - `POST /v1/responses`
@@ -131,6 +134,7 @@ npm install -g ai-zero-token
 
 ```bash
 azt start
+azt models --refresh
 ```
 
 如果你是为了开发、构建、`npm link`、`npm pack` 或准备发布，单独看：
@@ -174,6 +178,10 @@ http://127.0.0.1:8787
 http://127.0.0.1:8787/v1
 ```
 
+Vibe Coding、OpenAI-compatible SDK 和脚本接入可以参考：
+
+- [API 使用说明](docs/API_USAGE.md)
+
 如果你要让本地网页直接从浏览器请求这个网关，现在已经默认开启 CORS。
 
 如需限制来源，可以在启动前指定：
@@ -320,6 +328,7 @@ curl http://127.0.0.1:8787/v1/images/generations \
 - `GET /_gateway/health`
 - `GET /_gateway/status`
 - `GET /_gateway/models`
+- `POST /_gateway/models/refresh`
 - `GET /_gateway/admin/config`
 - `POST /_gateway/admin/login`
 - `POST /_gateway/admin/logout`

package/dist/cli/commands/help.js

@@ -4,6 +4,7 @@ function printHelp() {
 
   azt login
   azt models
+  azt models --refresh
   azt status
   azt ask "\u4F60\u597D\uFF0C\u8BF7\u7B80\u5355\u4ECB\u7ECD\u4E00\u4E0B\u81EA\u5DF1"
   azt ask --model gpt-5.3-codex "\u4F60\u597D"
@@ -16,7 +17,7 @@ function printHelp() {
 \u8BF4\u660E:
 
   login   \u8D70\u771F\u5B9E OpenAI Codex OAuth\uFF0C\u65B0\u589E\u5E76\u4FDD\u5B58\u4E00\u4E2A\u8D26\u53F7 profile
-  models  \u67E5\u770B\u8FD9\u4E2A demo \u5F53\u524D\u5185\u7F6E\u652F\u6301\u7684\u6A21\u578B\u5217\u8868
+  models  \u67E5\u770B\u5F53\u524D\u53EF\u7528\u6A21\u578B\u5217\u8868\uFF1B\u4F18\u5148\u8BFB\u53D6 ~/.codex/models_cache.json\uFF0C--refresh \u53EF\u624B\u52A8\u91CD\u8BFB
   status  \u67E5\u770B\u5F53\u524D demo \u5F53\u524D\u6FC0\u6D3B\u8D26\u53F7\u3001\u8D26\u53F7\u6570\u91CF\u548C\u8FC7\u671F\u65F6\u95F4
   ask     \u7528\u4FDD\u5B58\u7684 token \u8C03\u771F\u5B9E Codex Responses API
           \u5B9E\u9A8C\u6A21\u5F0F\u53EF\u7528 --payload-file \u900F\u4F20\u989D\u5916\u8BF7\u6C42\u4F53\uFF0C\u914D\u5408 --dump-raw / --print-raw \u89C2\u5BDF SSE \u539F\u59CB\u4E8B\u4EF6

package/dist/cli/commands/models.js

@@ -1,9 +1,20 @@
 #!/usr/bin/env node
 import { createGatewayContext } from "../../core/context.js";
-async function runModelsCommand() {
+async function runModelsCommand(args = []) {
   const ctx = createGatewayContext();
-  console.log("\u5F53\u524D demo \u5185\u7F6E\u652F\u6301\u7684\u6A21\u578B:");
-  for (const model of await ctx.modelService.listModels()) {
+  const refresh = args.includes("--refresh");
+  const result = refresh ? await ctx.modelService.refreshModels() : {
+    models: await ctx.modelService.listModels(),
+    catalog: await ctx.modelService.getCatalog()
+  };
+  console.log(refresh ? "\u5DF2\u91CD\u65B0\u8BFB\u53D6 Codex \u6A21\u578B\u5217\u8868:" : "\u5F53\u524D demo \u53EF\u7528\u6A21\u578B\u5217\u8868:");
+  console.log(`- \u6765\u6E90: ${result.catalog.source === "codex-cache" ? "Codex \u672C\u5730\u7F13\u5B58" : "\u9879\u76EE\u5185\u7F6E\u56DE\u9000\u5217\u8868"}`);
+  console.log(`- \u8DEF\u5F84: ${result.catalog.cachePath}`);
+  if (result.catalog.fetchedAt) {
+    console.log(`- Codex \u66F4\u65B0\u65F6\u95F4: ${result.catalog.fetchedAt}`);
+  }
+  console.log(`- \u6570\u91CF: ${result.catalog.modelCount}`);
+  for (const model of result.models) {
     const suffix = model.isDefault ? " (\u9ED8\u8BA4)" : "";
     console.log(`- ${model.id}${suffix}`);
   }

package/dist/cli/index.js

@@ -17,7 +17,7 @@ async function runCli(argv = process.argv.slice(2)) {
       await runStatusCommand();
       return;
     case "models":
-      await runModelsCommand();
+      await runModelsCommand(rest);
       return;
     case "ask":
       await runAskCommand(rest);

package/dist/core/context.js

@@ -4,10 +4,12 @@ import { AuthService } from "./services/auth-service.js";
 import { ChatService } from "./services/chat-service.js";
 import { ImageService } from "./services/image-service.js";
 import { ModelService } from "./services/model-service.js";
+import { VersionService } from "./services/version-service.js";
 function createGatewayContext() {
   const configService = new ConfigService();
   const authService = new AuthService(configService);
   const modelService = new ModelService(configService);
+  const versionService = new VersionService();
   const chatService = new ChatService({
     authService,
     modelService
@@ -20,6 +22,7 @@ function createGatewayContext() {
     configService,
     authService,
     modelService,
+    versionService,
     chatService,
     imageService
   };

package/dist/core/models/openai-codex-models.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 const DEFAULT_CODEX_MODEL = "gpt-5.4";
 const CODEX_MODEL_INFOS = [
   { provider: "openai-codex", id: "gpt-5.4", name: "GPT-5.4", input: ["text", "image"], source: "static" },
@@ -22,6 +25,88 @@ const SUPPORTED_CODEX_MODELS = [
   "gpt-5.1-codex-mini",
   "gpt-5.1-codex-max"
 ];
+function getCodexModelsCachePath() {
+  return process.env.CODEX_MODELS_CACHE_PATH || path.join(os.homedir(), ".codex", "models_cache.json");
+}
+function normalizeInputModalities(input) {
+  const rawValues = Array.isArray(input) ? input : [];
+  const values = /* @__PURE__ */ new Set();
+  for (const item of rawValues) {
+    if (item === "text" || item === "image") {
+      values.add(item);
+    }
+  }
+  if (values.size === 0) {
+    values.add("text");
+  }
+  return Array.from(values);
+}
+function normalizeCodexCacheEntry(entry) {
+  if (!entry || typeof entry.slug !== "string" || !entry.slug) {
+    return null;
+  }
+  if (typeof entry.visibility === "string" && entry.visibility !== "list") {
+    return null;
+  }
+  return {
+    provider: "openai-codex",
+    id: entry.slug,
+    name: typeof entry.display_name === "string" && entry.display_name ? entry.display_name : entry.slug,
+    input: normalizeInputModalities(entry.input_modalities),
+    source: "codex-cache"
+  };
+}
+function dedupeModels(models) {
+  const seen = /* @__PURE__ */ new Set();
+  const next = [];
+  for (const model of models) {
+    if (seen.has(model.id)) {
+      continue;
+    }
+    seen.add(model.id);
+    next.push(model);
+  }
+  return next;
+}
+async function getCodexModelCatalog() {
+  const cachePath = getCodexModelsCachePath();
+  try {
+    const raw = await fs.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const models = dedupeModels((parsed.models ?? []).map(normalizeCodexCacheEntry).filter(Boolean));
+    if (models.length > 0) {
+      return {
+        models,
+        catalog: {
+          source: "codex-cache",
+          cachePath,
+          fetchedAt: parsed.fetched_at,
+          modelCount: models.length
+        }
+      };
+    }
+  } catch {
+  }
+  return {
+    models: CODEX_MODEL_INFOS,
+    catalog: {
+      source: "static-fallback",
+      cachePath,
+      modelCount: CODEX_MODEL_INFOS.length
+    }
+  };
+}
+async function hasCodexModel(model) {
+  const { models } = await getCodexModelCatalog();
+  return models.some((item) => item.id === model);
+}
+async function getPreferredCodexModel() {
+  const { models } = await getCodexModelCatalog();
+  if (models.some((item) => item.id === DEFAULT_CODEX_MODEL)) {
+    return DEFAULT_CODEX_MODEL;
+  }
+  return models[0]?.id ?? DEFAULT_CODEX_MODEL;
+}
 function isSupportedCodexModel(model) {
   return SUPPORTED_CODEX_MODELS.includes(model);
 }
@@ -29,5 +114,9 @@ export {
   CODEX_MODEL_INFOS,
   DEFAULT_CODEX_MODEL,
   SUPPORTED_CODEX_MODELS,
+  getCodexModelCatalog,
+  getCodexModelsCachePath,
+  getPreferredCodexModel,
+  hasCodexModel,
   isSupportedCodexModel
 };

package/dist/core/providers/http-client.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 const CURL_STATUS_MARKER = "\n__CURL_STATUS__:";
+const CURL_HEADERS_MARKER = "\n__CURL_HEADERS__:";
 let requestSequence = 0;
 function nextRequestId() {
   requestSequence += 1;
@@ -37,6 +38,23 @@ function normalizeHeaders(headers) {
   });
   return normalized;
 }
+function normalizeCurlHeaders(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).flatMap(([key, rawValue]) => {
+      if (typeof rawValue === "string" && rawValue.trim()) {
+        return [[key.toLowerCase(), rawValue.trim()]];
+      }
+      if (Array.isArray(rawValue)) {
+        const joined = rawValue.filter((item) => typeof item === "string" && item.trim()).join(", ");
+        return joined ? [[key.toLowerCase(), joined]] : [];
+      }
+      return [];
+    })
+  );
+}
 async function runCurlRequest(init, params) {
   const requestId = params?.requestId ?? nextRequestId();
   const startedAt = performance.now();
@@ -48,7 +66,7 @@ async function runCurlRequest(init, params) {
     init.method,
     init.url,
     "--write-out",
-    `${CURL_STATUS_MARKER}%{http_code}`
+    `${CURL_STATUS_MARKER}%{http_code}${CURL_HEADERS_MARKER}%{header_json}`
   ];
   for (const [key, value] of Object.entries(init.headers ?? {})) {
     args.push("--header", `${key}: ${value}`);
@@ -82,16 +100,33 @@ async function runCurlRequest(init, params) {
     throw new Error(stderr.trim() || `curl \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`);
   }
   const parseStartedAt = performance.now();
-  const markerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
-  if (markerIndex === -1) {
+  const statusMarkerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
+  const headersMarkerIndex = stdout.lastIndexOf(CURL_HEADERS_MARKER);
+  if (statusMarkerIndex === -1) {
     throw new Error("curl \u54CD\u5E94\u7F3A\u5C11\u72B6\u6001\u7801\u6807\u8BB0\u3002");
   }
-  const body = stdout.slice(0, markerIndex);
-  const statusText = stdout.slice(markerIndex + CURL_STATUS_MARKER.length).trim();
+  if (headersMarkerIndex === -1 || headersMarkerIndex < statusMarkerIndex) {
+    throw new Error("curl \u54CD\u5E94\u7F3A\u5C11\u54CD\u5E94\u5934\u6807\u8BB0\u3002");
+  }
+  const body = stdout.slice(0, statusMarkerIndex);
+  const statusText = stdout.slice(statusMarkerIndex + CURL_STATUS_MARKER.length, headersMarkerIndex).trim();
   const status = Number.parseInt(statusText, 10);
   if (!Number.isFinite(status)) {
     throw new Error(`\u65E0\u6CD5\u89E3\u6790 curl \u72B6\u6001\u7801: ${statusText}`);
   }
+  const headersText = stdout.slice(headersMarkerIndex + CURL_HEADERS_MARKER.length).trim();
+  let headers = {};
+  if (headersText) {
+    try {
+      headers = normalizeCurlHeaders(JSON.parse(headersText));
+    } catch (error) {
+      console.warn("[http] failed to parse curl response headers", {
+        requestId,
+        url: init.url,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   phases.parseResponseMs = performance.now() - parseStartedAt;
   const timing = finalizeTiming(startedAt, phases);
   logHttpTiming({
@@ -110,7 +145,7 @@ async function runCurlRequest(init, params) {
     transport: "curl",
     timing,
     requestId,
-    headers: {}
+    headers
   };
 }
 async function requestText(init) {

package/dist/core/services/auth-service.js

@@ -12,6 +12,7 @@ import {
   loginOpenAICodex,
   refreshOpenAICodexToken
 } from "../providers/openai-codex/oauth.js";
+import { askOpenAICodex } from "../providers/openai-codex/chat.js";
 class AuthService {
   constructor(configService) {
     this.configService = configService;
@@ -107,6 +108,41 @@ class AuthService {
   async logoutAll() {
     await clearStore();
   }
+  async syncActiveProfileQuota(provider = "openai-codex", options) {
+    let profile;
+    try {
+      profile = await this.requireUsableProfile(provider);
+    } catch (error) {
+      if (options?.suppressErrors) {
+        return;
+      }
+      throw error;
+    }
+    const model = await this.configService.getDefaultModel(provider);
+    try {
+      const result = await askOpenAICodex({
+        profile,
+        model,
+        system: "Reply with OK only.",
+        prompt: "ping",
+        bodyOverride: {
+          text: { verbosity: "low" }
+        }
+      });
+      await this.updateProfileQuota(profile.profileId, result.quota, provider);
+    } catch (error) {
+      const quota = error.quota;
+      await this.updateProfileQuota(profile.profileId, quota, provider);
+      if (!options?.suppressErrors) {
+        throw error;
+      }
+      console.warn("[auth] sync active profile quota failed", {
+        provider,
+        profileId: profile.profileId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   async updateProfileQuota(profileId, quota, provider = "openai-codex") {
     if (!quota) {
       return;

package/dist/core/services/config-service.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { DEFAULT_CODEX_MODEL, isSupportedCodexModel } from "../models/openai-codex-models.js";
+import { getPreferredCodexModel, hasCodexModel } from "../models/openai-codex-models.js";
 import {
   createDefaultSettings,
   loadSettings,
@@ -23,14 +23,14 @@ class ConfigService {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
     }
-    return isSupportedCodexModel(settings.defaultModel) ? settings.defaultModel : DEFAULT_CODEX_MODEL;
+    return await hasCodexModel(settings.defaultModel) ? settings.defaultModel : getPreferredCodexModel();
   }
   async setDefaultModel(model, provider = "openai-codex") {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
     }
-    if (!isSupportedCodexModel(model)) {
-      throw new Error(`\u5F53\u524D demo \u672A\u5185\u7F6E\u6A21\u578B: ${model}`);
+    if (!await hasCodexModel(model)) {
+      throw new Error(`\u5F53\u524D\u7F51\u5173\u672A\u627E\u5230\u53EF\u7528\u6A21\u578B: ${model}`);
     }
     const settings = await this.getSettings();
     const next = {

package/dist/core/services/image-service.js

@@ -25,6 +25,8 @@ const SUPPORTED_IMAGE_BACKGROUNDS = /* @__PURE__ */ new Set([
   "transparent",
   "opaque"
 ]);
+const IMAGE_GENERATION_MAX_ATTEMPTS = 3;
+const IMAGE_GENERATION_RETRY_DELAYS_MS = [1500, 4e3];
 function truncateForLog(value, max = 160) {
   if (value.length <= max) {
     return value;
@@ -167,7 +169,24 @@ function summarizeImageDebug(raw) {
     image_events: imageEvents
   };
 }
-function extractImageFailureMessage(raw) {
+function extractRequestIdFromMessage(message) {
+  const match = message.match(/request ID ([a-z0-9-]+)/i);
+  return match?.[1];
+}
+function createImageFailureDetails(code, message) {
+  const normalizedMessage = typeof message === "string" && message.trim() ? message.trim() : typeof code === "string" && code.trim() ? code.trim() : null;
+  if (!normalizedMessage) {
+    return null;
+  }
+  const normalizedCode = typeof code === "string" && code.trim() ? code.trim() : void 0;
+  return {
+    code: normalizedCode,
+    message: normalizedMessage,
+    requestId: extractRequestIdFromMessage(normalizedMessage),
+    transient: normalizedCode === "server_error" || /retry your request/i.test(normalizedMessage) || /temporar/i.test(normalizedMessage)
+  };
+}
+function extractImageFailureDetails(raw) {
   if (!isRecord(raw)) {
     return null;
   }
@@ -175,9 +194,9 @@ function extractImageFailureMessage(raw) {
   if (response) {
     const responseError = isRecord(response.error) ? response.error : null;
     const responseStatus = typeof response.status === "string" ? response.status : void 0;
-    const responseMessage = typeof responseError?.message === "string" ? responseError.message : typeof responseError?.code === "string" ? responseError.code : null;
-    if (responseStatus === "failed" && responseMessage) {
-      return responseMessage;
+    const details = createImageFailureDetails(responseError?.code, responseError?.message);
+    if (responseStatus === "failed" && details) {
+      return details;
     }
   }
   const events = Array.isArray(raw.events) ? raw.events : [];
@@ -187,21 +206,29 @@ function extractImageFailureMessage(raw) {
     }
     if (event.type === "error") {
       const eventError = isRecord(event.error) ? event.error : event;
-      const message = typeof eventError.message === "string" ? eventError.message : typeof eventError.code === "string" ? eventError.code : null;
-      if (message) {
-        return message;
+      const details = createImageFailureDetails(eventError.code, eventError.message);
+      if (details) {
+        return details;
       }
     }
     if (event.type === "response.failed" && isRecord(event.response)) {
       const responseError = isRecord(event.response.error) ? event.response.error : null;
-      const message = typeof responseError?.message === "string" ? responseError.message : typeof responseError?.code === "string" ? responseError.code : null;
-      if (message) {
-        return message;
+      const details = createImageFailureDetails(responseError?.code, responseError?.message);
+      if (details) {
+        return details;
       }
     }
   }
   return null;
 }
+function createError(message, statusCode) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function extractImageUsage(raw) {
   if (!isRecord(raw) || !isRecord(raw.response)) {
     return void 0;
@@ -283,76 +310,94 @@ class ImageService {
     if (request.moderation) {
       tool.moderation = request.moderation;
     }
-    let result;
-    try {
-      result = await askOpenAICodex({
-        profile,
-        model: orchestratorModel,
-        bodyOverride: {
+    for (let attempt = 1; attempt <= IMAGE_GENERATION_MAX_ATTEMPTS; attempt += 1) {
+      let result;
+      try {
+        result = await askOpenAICodex({
+          profile,
           model: orchestratorModel,
-          input: [
-            {
-              role: "user",
-              content: [
-                {
-                  type: "input_text",
-                  text: request.prompt
-                }
-              ]
-            }
-          ],
-          tools: [tool],
-          tool_choice: {
-            type: "image_generation"
-          },
-          include: ["reasoning.encrypted_content"]
+          bodyOverride: {
+            model: orchestratorModel,
+            input: [
+              {
+                role: "user",
+                content: [
+                  {
+                    type: "input_text",
+                    text: request.prompt
+                  }
+                ]
+              }
+            ],
+            tools: [tool],
+            tool_choice: {
+              type: "image_generation"
+            },
+            include: ["reasoning.encrypted_content"]
+          }
+        });
+        await this.deps.authService.updateProfileQuota(profile.profileId, result.quota, "openai-codex");
+      } catch (error) {
+        const quota = error.quota;
+        await this.deps.authService.updateProfileQuota(profile.profileId, quota, "openai-codex");
+        throw error;
+      }
+      const raw = isRecord(result.raw) ? result.raw : {};
+      const response = isRecord(raw.response) ? raw.response : null;
+      const images = collectImageGenerationOutputs(raw);
+      const debugSummary = summarizeImageDebug(raw);
+      if (images.length === 0) {
+        const upstreamFailure = extractImageFailureDetails(raw);
+        console.error("[gateway:image] parse failure", {
+          ...requestSummary,
+          attempt,
+          upstreamFailure,
+          debug: debugSummary
+        });
+        if (upstreamFailure?.transient && attempt < IMAGE_GENERATION_MAX_ATTEMPTS) {
+          const retryDelayMs = IMAGE_GENERATION_RETRY_DELAYS_MS[attempt - 1] ?? 4e3;
+          console.warn("[gateway:image] transient upstream failure, retrying", {
+            ...requestSummary,
+            attempt,
+            retryDelayMs,
+            code: upstreamFailure.code,
+            requestId: upstreamFailure.requestId
+          });
+          await sleep(retryDelayMs);
+          continue;
         }
-      });
-      await this.deps.authService.updateProfileQuota(profile.profileId, result.quota, "openai-codex");
-    } catch (error) {
-      const quota = error.quota;
-      await this.deps.authService.updateProfileQuota(profile.profileId, quota, "openai-codex");
-      throw error;
-    }
-    const raw = isRecord(result.raw) ? result.raw : {};
-    const response = isRecord(raw.response) ? raw.response : null;
-    const images = collectImageGenerationOutputs(raw);
-    const debugSummary = summarizeImageDebug(raw);
-    if (images.length === 0) {
-      const upstreamFailure = extractImageFailureMessage(raw);
-      console.error("[gateway:image] parse failure", {
+        if (upstreamFailure) {
+          const reason = upstreamFailure.code ? `${upstreamFailure.code}: ${upstreamFailure.message}` : upstreamFailure.message;
+          throw createError(`\u4E0A\u6E38\u56FE\u7247\u751F\u6210\u5931\u8D25: ${reason}`, upstreamFailure.transient ? 503 : 502);
+        }
+        throw createError("\u56FE\u7247\u751F\u6210\u8BF7\u6C42\u5DF2\u5B8C\u6210\uFF0C\u4F46\u6CA1\u6709\u89E3\u6790\u51FA image_generation_call \u7ED3\u679C\u3002", 502);
+      }
+      const first = images[0];
+      const imageResult = {
+        created: typeof response?.created_at === "number" ? response.created_at : Math.floor(Date.now() / 1e3),
+        data: images.map((image) => ({
+          b64_json: image.result ?? "",
+          ...image.revised_prompt ? { revised_prompt: image.revised_prompt } : {}
+        })),
+        background: normalizeReturnedBackground(first.background),
+        output_format: normalizeReturnedFormat(first.output_format),
+        quality: normalizeReturnedQuality(first.quality),
+        size: normalizeReturnedSize(first.size, request.size),
+        usage: extractImageUsage(raw)
+      };
+      console.info("[gateway:image] upstream response", {
         ...requestSummary,
-        upstreamFailure,
+        attempt,
+        imageCount: imageResult.data.length,
+        firstImageBase64Length: imageResult.data[0]?.b64_json.length ?? 0,
+        outputFormat: imageResult.output_format ?? request.outputFormat ?? "unknown",
+        quality: imageResult.quality ?? request.quality ?? "unknown",
+        size: imageResult.size ?? request.size ?? "unknown",
         debug: debugSummary
       });
-      if (upstreamFailure) {
-        throw new Error(`\u4E0A\u6E38\u56FE\u7247\u751F\u6210\u5931\u8D25: ${upstreamFailure}`);
-      }
-      throw new Error("\u56FE\u7247\u751F\u6210\u8BF7\u6C42\u5DF2\u5B8C\u6210\uFF0C\u4F46\u6CA1\u6709\u89E3\u6790\u51FA image_generation_call \u7ED3\u679C\u3002");
+      return imageResult;
     }
-    const first = images[0];
-    const imageResult = {
-      created: typeof response?.created_at === "number" ? response.created_at : Math.floor(Date.now() / 1e3),
-      data: images.map((image) => ({
-        b64_json: image.result ?? "",
-        ...image.revised_prompt ? { revised_prompt: image.revised_prompt } : {}
-      })),
-      background: normalizeReturnedBackground(first.background),
-      output_format: normalizeReturnedFormat(first.output_format),
-      quality: normalizeReturnedQuality(first.quality),
-      size: normalizeReturnedSize(first.size, request.size),
-      usage: extractImageUsage(raw)
-    };
-    console.info("[gateway:image] upstream response", {
-      ...requestSummary,
-      imageCount: imageResult.data.length,
-      firstImageBase64Length: imageResult.data[0]?.b64_json.length ?? 0,
-      outputFormat: imageResult.output_format ?? request.outputFormat ?? "unknown",
-      quality: imageResult.quality ?? request.quality ?? "unknown",
-      size: imageResult.size ?? request.size ?? "unknown",
-      debug: debugSummary
-    });
-    return imageResult;
+    throw createError("\u56FE\u7247\u751F\u6210\u5931\u8D25\uFF1A\u8D85\u8FC7\u6700\u5927\u91CD\u8BD5\u6B21\u6570\u3002", 503);
   }
 }
 export {