ai-zero-token 2.0.5 → 2.0.7

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

@@ -14,6 +14,7 @@ import {
   refreshOpenAICodexToken
 } from "../providers/openai-codex/oauth.js";
 import { askOpenAICodex } from "../providers/openai-codex/chat.js";
+import { isTransientHttpError } from "../providers/http-client.js";
 import {
   applyGatewayToCodexProviderConfig,
   applyProfileToCodexAuth,
@@ -27,7 +28,7 @@ import {
   importProfileFromJson,
   importProfilesFromJson
 } from "../store/profile-transfer.js";
-const DEFAULT_QUOTA_SYNC_CONCURRENCY = 16;
+const DEFAULT_QUOTA_SYNC_CONCURRENCY = 3;
 function getQuotaSyncConcurrency(configured) {
   const raw = process.env.AZT_QUOTA_SYNC_CONCURRENCY;
   const parsed = raw ? Number.parseInt(raw, 10) : configured ?? DEFAULT_QUOTA_SYNC_CONCURRENCY;
@@ -151,20 +152,99 @@ class AuthService {
     const percents = this.getQuotaPercents(profile);
     return percents.length > 0 && percents.some((value) => value >= 100);
   }
-  hasKnownAvailableQuota(profile) {
+  isQuotaSnapshotExhausted(quota) {
+    if (!quota) {
+      return false;
+    }
+    return [quota.primaryUsedPercent, quota.secondaryUsedPercent].some(
+      (value) => typeof value === "number" && Number.isFinite(value) && value >= 100
+    );
+  }
+  isQuotaBlocked(profile) {
+    return this.isQuotaExhausted(profile) && !this.hasResetElapsedForExhaustedQuota(profile);
+  }
+  timestampToMillis(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+      return void 0;
+    }
+    return value < 1e12 ? value * 1e3 : value;
+  }
+  getQuotaResetAt(profile, slot) {
+    const quota = profile.quota;
+    if (!quota) {
+      return void 0;
+    }
+    const direct = slot === "primary" ? quota.primaryResetAt : quota.secondaryResetAt;
+    const directMillis = this.timestampToMillis(direct);
+    if (directMillis) {
+      return directMillis;
+    }
+    const after = slot === "primary" ? quota.primaryResetAfterSeconds : quota.secondaryResetAfterSeconds;
+    if (typeof after === "number" && Number.isFinite(after) && after > 0) {
+      const capturedAt = this.timestampToMillis(quota.capturedAt) ?? Date.now();
+      return capturedAt + after * 1e3;
+    }
+    return void 0;
+  }
+  hasResetElapsedForExhaustedQuota(profile) {
+    const quota = profile.quota;
+    if (!quota) {
+      return false;
+    }
+    const exhaustedSlots = [];
+    if (typeof quota.primaryUsedPercent === "number" && quota.primaryUsedPercent >= 100) {
+      exhaustedSlots.push("primary");
+    }
+    if (typeof quota.secondaryUsedPercent === "number" && quota.secondaryUsedPercent >= 100) {
+      exhaustedSlots.push("secondary");
+    }
+    if (exhaustedSlots.length === 0) {
+      return false;
+    }
+    const now = Date.now();
+    return exhaustedSlots.every((slot) => {
+      const resetAt = this.getQuotaResetAt(profile, slot);
+      return typeof resetAt === "number" && resetAt <= now;
+    });
+  }
+  canEnterAutoSwitchPool(profile) {
     if (profile.authStatus?.state === "token_invalidated" || profile.authStatus?.state === "auth_error") {
       return false;
     }
     const percents = this.getQuotaPercents(profile);
-    return percents.length > 0 && percents.every((value) => value < 100);
+    if (percents.length === 0) {
+      return true;
+    }
+    return percents.every((value) => value < 100) || this.hasResetElapsedForExhaustedQuota(profile);
   }
   hasInvalidAuthStatus(profile) {
     return profile.authStatus?.state === "token_invalidated" || profile.authStatus?.state === "auth_error";
   }
+  shouldLeaveActiveProfile(profile) {
+    return this.hasInvalidAuthStatus(profile) || this.isQuotaBlocked(profile);
+  }
+  isRotationTrigger(error, quota) {
+    if (this.isQuotaSnapshotExhausted(quota)) {
+      return true;
+    }
+    if (isTransientHttpError(error)) {
+      return true;
+    }
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    const details = normalized;
+    const status = typeof details.upstreamStatus === "number" ? details.upstreamStatus : void 0;
+    const marker = [
+      normalized.message,
+      details.upstreamErrorCode,
+      details.upstreamErrorType,
+      details.upstreamErrorMessage
+    ].filter((value) => typeof value === "string").join(" ").toLowerCase();
+    return status === 429 || status === 401 || status === 403 || marker.includes("usage_limit_reached") || marker.includes("token_invalidated") || marker.includes("authentication token has been invalidated") || marker.includes("\u5237\u65B0 token \u5931\u8D25");
+  }
   getQuotaUsageScore(profile) {
     const percents = this.getQuotaPercents(profile);
     if (percents.length === 0) {
-      return 100;
+      return 50;
     }
     return Math.max(...percents);
   }
@@ -175,12 +255,12 @@ class AuthService {
       }
       return updater(profile);
     });
-    if (!options?.checkAutoSwitch || options.skipAutoSwitch || !updated || updated.provider !== provider || !this.isQuotaExhausted(updated)) {
+    if (!options?.checkAutoSwitch || options.skipAutoSwitch || !updated || updated.provider !== provider || !this.shouldLeaveActiveProfile(updated)) {
       return updated;
     }
     const activeProfile = await this.getActiveProfile(provider);
     if (activeProfile?.profileId === updated.profileId) {
-      await this.maybeAutoSwitchProfile(updated, provider);
+      return this.maybeAutoSwitchProfile(updated, provider);
     }
     return updated;
   }
@@ -212,7 +292,7 @@ class AuthService {
   async maybeAutoSwitchProfile(profile, provider) {
     const settings = await this.configService.getSettings();
     const excludedProfileIds = new Set(settings.autoSwitch.excludedProfileIds);
-    if (!settings.autoSwitch.enabled || excludedProfileIds.has(profile.profileId) || !this.isQuotaExhausted(profile)) {
+    if (!settings.autoSwitch.enabled || excludedProfileIds.has(profile.profileId) || !this.shouldLeaveActiveProfile(profile)) {
       return profile;
     }
     const [profiles, codexStatus] = await Promise.all([
@@ -225,7 +305,7 @@ class AuthService {
       profile: item,
       index,
       distance: currentIndex >= 0 ? (index - currentIndex + profiles.length) % profiles.length : index + 1
-    })).filter((item) => item.profile.provider === provider && item.profile.profileId !== profile.profileId).filter((item) => !excludedProfileIds.has(item.profile.profileId)).filter((item) => this.hasKnownAvailableQuota(item.profile)).sort((left, right) => {
+    })).filter((item) => item.profile.provider === provider && item.profile.profileId !== profile.profileId).filter((item) => !excludedProfileIds.has(item.profile.profileId)).filter((item) => this.canEnterAutoSwitchPool(item.profile)).sort((left, right) => {
       const leftCodexConflict = codexAccountId && left.profile.accountId === codexAccountId ? 1 : 0;
       const rightCodexConflict = codexAccountId && right.profile.accountId === codexAccountId ? 1 : 0;
       const codexDiff = leftCodexConflict - rightCodexConflict;
@@ -255,8 +335,9 @@ class AuthService {
     if (!activated) {
       return profile;
     }
-    console.info("[auth] auto switched active profile after quota exhaustion", {
+    console.info("[auth] auto switched active profile", {
       provider,
+      reason: this.hasInvalidAuthStatus(profile) ? "auth_error" : "quota_exhausted",
       fromProfileId: profile.profileId,
       toProfileId: activated.profileId,
       avoidedCodexAccount: Boolean(codexAccountId && activated.accountId !== codexAccountId)
@@ -401,6 +482,69 @@ class AuthService {
     }
     return this.refreshStoredProfile(profile, provider);
   }
+  async requireUsableProfileById(profileId, provider = "openai-codex") {
+    const profiles = await listProfiles();
+    const profile = profiles.find((item) => item.provider === provider && item.profileId === profileId);
+    if (!profile) {
+      throw new Error(`\u6CA1\u6709\u627E\u5230\u8D26\u53F7: ${profileId}`);
+    }
+    if (Date.now() < profile.expires) {
+      return this.toManagedProfile(profile);
+    }
+    return this.refreshStoredProfile(profile, provider);
+  }
+  async withProfileRotation(provider, runner, options) {
+    const maxAttempts = Math.max(1, Math.min(8, options?.maxAttempts ?? 2));
+    const attemptedProfileIds = /* @__PURE__ */ new Set();
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      let profile;
+      try {
+        profile = await this.requireUsableProfile(provider, {
+          skipAutoSwitch: options?.skipAutoSwitch
+        });
+      } catch (error) {
+        lastError = error;
+        if (options?.skipAutoSwitch || attempt >= maxAttempts - 1 || !this.isRotationTrigger(error)) {
+          throw error;
+        }
+        const activeProfile = await this.getActiveProfile(provider);
+        if (!activeProfile) {
+          throw error;
+        }
+        const switchedProfile = await this.recordProfileRequestFailure(activeProfile.profileId, error, void 0, provider);
+        if (!switchedProfile || switchedProfile.profileId === activeProfile.profileId) {
+          throw error;
+        }
+        continue;
+      }
+      if (attemptedProfileIds.has(profile.profileId)) {
+        break;
+      }
+      attemptedProfileIds.add(profile.profileId);
+      try {
+        const result = await runner(profile, attempt);
+        await this.recordProfileRequestSuccess(profile.profileId, result.quota, provider, {
+          skipAutoSwitch: options?.skipAutoSwitch
+        });
+        return {
+          profile,
+          result,
+          retryCount: attempt
+        };
+      } catch (error) {
+        lastError = error;
+        const quota = error.quota;
+        const switchedProfile = await this.recordProfileRequestFailure(profile.profileId, error, quota, provider, {
+          skipAutoSwitch: options?.skipAutoSwitch
+        });
+        if (options?.skipAutoSwitch || attempt >= maxAttempts - 1 || !this.isRotationTrigger(error, quota) || !switchedProfile || switchedProfile.profileId === profile.profileId || attemptedProfileIds.has(switchedProfile.profileId)) {
+          throw error;
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "\u6CA1\u6709\u53EF\u7528\u8D26\u53F7\u53EF\u8F6E\u6362\u3002"));
+  }
   async requireFreshProfileWithIdToken(profileId, provider = "openai-codex") {
     const profiles = await listProfiles();
     const profile = profiles.find((item) => item.provider === provider && item.profileId === profileId);
@@ -538,7 +682,7 @@ class AuthService {
       }),
       {
         skipAutoSwitch: options?.skipAutoSwitch,
-        checkAutoSwitch: Boolean(quota)
+        checkAutoSwitch: Boolean(quota || authStatus)
       }
     );
   }

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

@@ -9,29 +9,27 @@ class ChatService {
     const model = await this.deps.modelService.resolveModel(provider, request.model, {
       allowUnknown: request.experimental?.allowUnknownModel
     });
-    const profile = await this.deps.authService.requireUsableProfile(provider);
-    try {
-      const result = await askOpenAICodex({
+    const rotation = await this.deps.authService.withProfileRotation(
+      provider,
+      (profile) => askOpenAICodex({
         profile,
         prompt: request.input,
         model,
         system: request.system,
         bodyOverride: request.experimental?.codexBody
-      });
-      await this.deps.authService.recordProfileRequestSuccess(profile.profileId, result.quota, provider);
-      return {
-        provider,
-        model,
-        text: result.text,
-        toolCalls: result.toolCalls,
-        raw: result.raw,
-        artifacts: result.artifacts
-      };
-    } catch (error) {
-      const quota = error.quota;
-      await this.deps.authService.recordProfileRequestFailure(profile.profileId, error, quota, provider);
-      throw error;
-    }
+      })
+    );
+    const result = rotation.result;
+    return {
+      provider,
+      model,
+      profile: rotation.profile,
+      retryCount: rotation.retryCount,
+      text: result.text,
+      toolCalls: result.toolCalls,
+      raw: result.raw,
+      artifacts: result.artifacts
+    };
   }
 }
 export {

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

@@ -161,6 +161,15 @@ class ConfigService {
         }
       };
     }
+    if (params.image) {
+      next = {
+        ...next,
+        image: {
+          ...next.image,
+          freeAccountWebGenerationEnabled: params.image.freeAccountWebGenerationEnabled ?? next.image.freeAccountWebGenerationEnabled
+        }
+      };
+    }
     if (params.server) {
       next = {
         ...next,

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { askOpenAICodex } from "../providers/openai-codex/chat.js";
+import { generateChatGPTWebImage } from "../providers/openai-codex/chatgpt-web-image.js";
 const SUPPORTED_IMAGE_MODELS = /* @__PURE__ */ new Set([
   "gpt-image-1",
   "gpt-image-1-mini",
@@ -248,6 +249,9 @@ function extractImageUsage(raw) {
     total_tokens: imageGen.total_tokens
   };
 }
+function isFreePlan(profile) {
+  return profile.quota?.planType?.toLowerCase() === "free";
+}
 class ImageService {
   constructor(deps) {
     this.deps = deps;
@@ -262,9 +266,12 @@ class ImageService {
     return model;
   }
   async generate(request) {
-    const profile = await this.deps.authService.requireUsableProfile("openai-codex");
+    const profile = await this.deps.authService.requireUsableProfile("openai-codex", {
+      skipAutoSwitch: true
+    });
     const orchestratorModel = IMAGE_ORCHESTRATOR_MODEL;
     const requestedImageModel = this.resolveRequestedImageModel(request.model);
+    const settings = await this.deps.configService.getSettings();
     const requestSummary = {
       requestedImageModel,
       orchestratorModel,
@@ -279,6 +286,29 @@ class ImageService {
       inputImageCount: request.inputImages?.length ?? 0
     };
     console.info("[gateway:image] upstream request", requestSummary);
+    if (isFreePlan(profile) && settings.image.freeAccountWebGenerationEnabled) {
+      try {
+        console.info("[gateway:image] using ChatGPT web image route for Free profile", requestSummary);
+        const response = await generateChatGPTWebImage({
+          profile,
+          prompt: request.prompt,
+          model: requestedImageModel,
+          inputImages: request.inputImages,
+          size: request.size,
+          responseFormat: "b64_json"
+        });
+        await this.deps.authService.recordProfileRequestSuccess(profile.profileId, void 0, "openai-codex");
+        console.info("[gateway:image] ChatGPT web image response", {
+          ...requestSummary,
+          imageCount: response.data.length,
+          firstImageBase64Length: response.data[0]?.b64_json.length ?? 0
+        });
+        return response;
+      } catch (error) {
+        await this.deps.authService.recordProfileRequestFailure(profile.profileId, error, void 0, "openai-codex");
+        throw error;
+      }
+    }
     const tool = {
       type: "image_generation",
       model: requestedImageModel

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

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 import {
   getCodexModelCatalog,
-  hasCodexModel
+  hasCodexModel,
+  refreshCodexModelCatalogFromNetwork
 } from "../models/openai-codex-models.js";
 class ModelService {
-  constructor(configService) {
+  constructor(configService, authService) {
     this.configService = configService;
+    this.authService = authService;
   }
   async listModels(provider = "openai-codex") {
     if (provider !== "openai-codex") {
@@ -30,16 +32,28 @@ class ModelService {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
     }
-    const [{ models, catalog }, defaultModel] = await Promise.all([
-      getCodexModelCatalog(),
-      this.configService.getDefaultModel(provider)
-    ]);
+    const profile = await this.authService.requireUsableProfile(provider, {
+      skipAutoSwitch: true
+    });
+    let result;
+    try {
+      result = await refreshCodexModelCatalogFromNetwork(profile);
+      await this.authService.recordProfileRequestSuccess(profile.profileId, void 0, provider, {
+        skipAutoSwitch: true
+      });
+    } catch (error) {
+      await this.authService.recordProfileRequestFailure(profile.profileId, error, void 0, provider, {
+        skipAutoSwitch: true
+      });
+      throw error;
+    }
+    const defaultModel = await this.configService.getDefaultModel(provider);
     return {
-      models: models.map((model) => ({
+      models: result.models.map((model) => ({
         ...model,
         isDefault: model.id === defaultModel
       })),
-      catalog
+      catalog: result.catalog
     };
   }
   async getDefaultModel(provider = "openai-codex") {