ai-zero-token 2.0.5 → 2.0.6

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

@@ -27,7 +27,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,12 +151,59 @@ class AuthService {
     const percents = this.getQuotaPercents(profile);
     return percents.length > 0 && percents.some((value) => value >= 100);
   }
-  hasKnownAvailableQuota(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 false;
+    }
+    return percents.every((value) => value < 100) || this.hasResetElapsedForExhaustedQuota(profile);
   }
   hasInvalidAuthStatus(profile) {
     return profile.authStatus?.state === "token_invalidated" || profile.authStatus?.state === "auth_error";
@@ -225,7 +272,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;

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/usage-service.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  ensureStateMigrated,
+  getUsageDailyPath,
+  getUsageDir,
+  getUsageEventsDir,
+  getUsageLifetimePath
+} from "../store/state-paths.js";
+const durationBucketLimits = [100, 300, 500, 1e3, 2e3, 5e3, 1e4, 3e4, 6e4, 12e4, Number.POSITIVE_INFINITY];
+function createAggregate() {
+  return {
+    requestCount: 0,
+    successCount: 0,
+    failureCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    unknownTokenCount: 0,
+    imageCount: 0,
+    totalDurationMs: 0,
+    averageDurationMs: 0,
+    p95DurationMs: 0,
+    durationBuckets: {}
+  };
+}
+function cloneAggregate(value) {
+  return {
+    ...value,
+    durationBuckets: { ...value.durationBuckets }
+  };
+}
+function normalizeNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function normalizeAggregate(value) {
+  if (!value || typeof value !== "object") {
+    return createAggregate();
+  }
+  const record = value;
+  const aggregate = {
+    requestCount: Math.max(0, Math.trunc(normalizeNumber(record.requestCount))),
+    successCount: Math.max(0, Math.trunc(normalizeNumber(record.successCount))),
+    failureCount: Math.max(0, Math.trunc(normalizeNumber(record.failureCount))),
+    inputTokens: Math.max(0, Math.trunc(normalizeNumber(record.inputTokens))),
+    outputTokens: Math.max(0, Math.trunc(normalizeNumber(record.outputTokens))),
+    totalTokens: Math.max(0, Math.trunc(normalizeNumber(record.totalTokens))),
+    unknownTokenCount: Math.max(0, Math.trunc(normalizeNumber(record.unknownTokenCount))),
+    imageCount: Math.max(0, Math.trunc(normalizeNumber(record.imageCount))),
+    totalDurationMs: Math.max(0, normalizeNumber(record.totalDurationMs)),
+    averageDurationMs: 0,
+    p95DurationMs: 0,
+    durationBuckets: {}
+  };
+  if (record.durationBuckets && typeof record.durationBuckets === "object") {
+    for (const [key, item] of Object.entries(record.durationBuckets)) {
+      aggregate.durationBuckets[key] = Math.max(0, Math.trunc(normalizeNumber(item)));
+    }
+  }
+  refreshDerivedMetrics(aggregate);
+  return aggregate;
+}
+function normalizeDimensionStore(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => {
+      const row = item && typeof item === "object" ? item : {};
+      return [
+        key,
+        {
+          key,
+          label: typeof row.label === "string" && row.label.trim() ? row.label : key,
+          aggregate: normalizeAggregate(row.aggregate)
+        }
+      ];
+    })
+  );
+}
+function createDailyStore() {
+  return {
+    version: 1,
+    updatedAt: Date.now(),
+    days: {}
+  };
+}
+function createLifetimeStore() {
+  return {
+    version: 1,
+    updatedAt: Date.now(),
+    aggregate: createAggregate(),
+    byAccount: {},
+    byModel: {},
+    byEndpoint: {},
+    byError: {},
+    byImageRoute: {},
+    bySource: {}
+  };
+}
+function normalizeDailyStore(value) {
+  if (!value || typeof value !== "object") {
+    return createDailyStore();
+  }
+  const record = value;
+  return {
+    version: 1,
+    updatedAt: normalizeNumber(record.updatedAt, Date.now()),
+    days: Object.fromEntries(
+      Object.entries(record.days ?? {}).map(([date, aggregate]) => [date, normalizeAggregate(aggregate)])
+    )
+  };
+}
+function normalizeLifetimeStore(value) {
+  if (!value || typeof value !== "object") {
+    return createLifetimeStore();
+  }
+  const record = value;
+  return {
+    version: 1,
+    updatedAt: normalizeNumber(record.updatedAt, Date.now()),
+    aggregate: normalizeAggregate(record.aggregate),
+    byAccount: normalizeDimensionStore(record.byAccount),
+    byModel: normalizeDimensionStore(record.byModel),
+    byEndpoint: normalizeDimensionStore(record.byEndpoint),
+    byError: normalizeDimensionStore(record.byError),
+    byImageRoute: normalizeDimensionStore(record.byImageRoute),
+    bySource: normalizeDimensionStore(record.bySource)
+  };
+}
+function formatLocalDate(timestamp) {
+  const date = new Date(timestamp);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function durationBucketKey(durationMs) {
+  const normalized = Math.max(0, durationMs);
+  for (const limit of durationBucketLimits) {
+    if (normalized <= limit) {
+      return Number.isFinite(limit) ? String(limit) : "inf";
+    }
+  }
+  return "inf";
+}
+function bucketKeyToDuration(key) {
+  if (key === "inf") {
+    return 12e4;
+  }
+  const parsed = Number.parseInt(key, 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function estimateP95Duration(buckets, total) {
+  if (total <= 0) {
+    return 0;
+  }
+  const target = Math.ceil(total * 0.95);
+  let seen = 0;
+  for (const limit of durationBucketLimits) {
+    const key = Number.isFinite(limit) ? String(limit) : "inf";
+    seen += buckets[key] ?? 0;
+    if (seen >= target) {
+      return bucketKeyToDuration(key);
+    }
+  }
+  return 0;
+}
+function refreshDerivedMetrics(aggregate) {
+  aggregate.averageDurationMs = aggregate.requestCount > 0 ? aggregate.totalDurationMs / aggregate.requestCount : 0;
+  aggregate.p95DurationMs = estimateP95Duration(aggregate.durationBuckets, aggregate.requestCount);
+}
+function tokenNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
+}
+function addToAggregate(aggregate, event) {
+  const success = event.success ?? (event.statusCode >= 200 && event.statusCode < 400);
+  const inputTokens = tokenNumber(event.tokenUsage?.inputTokens);
+  const outputTokens = tokenNumber(event.tokenUsage?.outputTokens);
+  const totalTokens = tokenNumber(event.tokenUsage?.totalTokens) ?? (inputTokens !== null || outputTokens !== null ? (inputTokens ?? 0) + (outputTokens ?? 0) : null);
+  aggregate.requestCount += 1;
+  aggregate.successCount += success ? 1 : 0;
+  aggregate.failureCount += success ? 0 : 1;
+  aggregate.inputTokens += inputTokens ?? 0;
+  aggregate.outputTokens += outputTokens ?? 0;
+  aggregate.totalTokens += totalTokens ?? 0;
+  aggregate.unknownTokenCount += totalTokens === null ? 1 : 0;
+  aggregate.imageCount += Math.max(0, Math.trunc(event.imageCount ?? 0));
+  aggregate.totalDurationMs += Math.max(0, event.durationMs);
+  const bucket = durationBucketKey(event.durationMs);
+  aggregate.durationBuckets[bucket] = (aggregate.durationBuckets[bucket] ?? 0) + 1;
+  refreshDerivedMetrics(aggregate);
+}
+function imageRouteLabel(route) {
+  if (route === "codex-tool") {
+    return "Codex \u56FE\u7247\u5DE5\u5177";
+  }
+  if (route === "chatgpt-web") {
+    return "ChatGPT \u7F51\u9875\u751F\u56FE";
+  }
+  return "\u975E\u751F\u56FE";
+}
+function bumpDimension(store, key, label, event) {
+  const normalizedKey = key.trim() || "-";
+  const existing = store[normalizedKey] ?? {
+    key: normalizedKey,
+    label: label.trim() || normalizedKey,
+    aggregate: createAggregate()
+  };
+  existing.label = label.trim() || existing.label;
+  addToAggregate(existing.aggregate, event);
+  store[normalizedKey] = existing;
+}
+function topRows(store, limit = 12) {
+  return Object.values(store).sort((a, b) => b.aggregate.requestCount - a.aggregate.requestCount || b.aggregate.totalTokens - a.aggregate.totalTokens || a.label.localeCompare(b.label, "zh-CN")).slice(0, limit).map((row) => ({
+    key: row.key,
+    label: row.label,
+    aggregate: cloneAggregate(row.aggregate)
+  }));
+}
+async function readJsonFile(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeJsonAtomic(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await fs.rename(tempPath, filePath);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+class UsageService {
+  startedAt = Date.now();
+  startupAggregate = createAggregate();
+  dailyStore = null;
+  lifetimeStore = null;
+  loadPromise = null;
+  saveQueue = Promise.resolve();
+  async record(event) {
+    await this.ensureLoaded();
+    const timestamp = event.timestamp ?? Date.now();
+    const date = formatLocalDate(timestamp);
+    const normalized = {
+      ...event,
+      id: event.id ?? randomUUID(),
+      timestamp,
+      statusCode: event.statusCode,
+      durationMs: Math.max(0, event.durationMs),
+      endpoint: event.endpoint || "-",
+      method: event.method || "-",
+      model: event.model || "-",
+      source: event.source || "-",
+      imageRoute: event.imageRoute ?? "none",
+      imageCount: Math.max(0, Math.trunc(event.imageCount ?? 0)),
+      success: event.success ?? (event.statusCode >= 200 && event.statusCode < 400)
+    };
+    const daily = this.dailyStore ?? createDailyStore();
+    const lifetime = this.lifetimeStore ?? createLifetimeStore();
+    daily.days[date] = daily.days[date] ? normalizeAggregate(daily.days[date]) : createAggregate();
+    addToAggregate(this.startupAggregate, normalized);
+    addToAggregate(daily.days[date], normalized);
+    addToAggregate(lifetime.aggregate, normalized);
+    bumpDimension(lifetime.byAccount, normalized.profileId || normalized.accountId || normalized.accountLabel || "-", normalized.accountLabel || normalized.accountId || normalized.profileId || "-", normalized);
+    bumpDimension(lifetime.byModel, normalized.model || "-", normalized.model || "-", normalized);
+    bumpDimension(lifetime.byEndpoint, `${normalized.method} ${normalized.endpoint}`, `${normalized.method} ${normalized.endpoint}`, normalized);
+    bumpDimension(lifetime.bySource, normalized.source || "-", normalized.source || "-", normalized);
+    bumpDimension(lifetime.byImageRoute, normalized.imageRoute ?? "none", imageRouteLabel(normalized.imageRoute ?? "none"), normalized);
+    if (!normalized.success) {
+      const errorType = normalized.errorType?.trim() || `HTTP ${normalized.statusCode}`;
+      bumpDimension(lifetime.byError, errorType, errorType, normalized);
+    }
+    daily.updatedAt = timestamp;
+    lifetime.updatedAt = timestamp;
+    this.dailyStore = daily;
+    this.lifetimeStore = lifetime;
+    const eventPath = path.join(getUsageEventsDir(), `${date}.jsonl`);
+    const dailyPath = getUsageDailyPath();
+    const lifetimePath = getUsageLifetimePath();
+    this.saveQueue = this.saveQueue.then(async () => {
+      await fs.mkdir(getUsageEventsDir(), { recursive: true });
+      await fs.appendFile(eventPath, `${JSON.stringify(normalized)}
+`, "utf8");
+      await Promise.all([
+        writeJsonAtomic(dailyPath, daily),
+        writeJsonAtomic(lifetimePath, lifetime)
+      ]);
+    }, async () => {
+      await fs.mkdir(getUsageEventsDir(), { recursive: true });
+      await fs.appendFile(eventPath, `${JSON.stringify(normalized)}
+`, "utf8");
+      await Promise.all([
+        writeJsonAtomic(dailyPath, daily),
+        writeJsonAtomic(lifetimePath, lifetime)
+      ]);
+    });
+    await this.saveQueue;
+  }
+  async getSummary() {
+    await this.ensureLoaded();
+    const daily = this.dailyStore ?? createDailyStore();
+    const lifetime = this.lifetimeStore ?? createLifetimeStore();
+    const todayDate = formatLocalDate(Date.now());
+    return {
+      generatedAt: Date.now(),
+      startedAt: this.startedAt,
+      todayDate,
+      storageDir: getUsageDir(),
+      startup: cloneAggregate(this.startupAggregate),
+      today: cloneAggregate(daily.days[todayDate] ?? createAggregate()),
+      lifetime: cloneAggregate(lifetime.aggregate),
+      daily: Object.entries(daily.days).sort(([left], [right]) => right.localeCompare(left)).slice(0, 30).map(([date, aggregate]) => ({ date, aggregate: cloneAggregate(aggregate) })),
+      byAccount: topRows(lifetime.byAccount, 16),
+      byModel: topRows(lifetime.byModel, 16),
+      byEndpoint: topRows(lifetime.byEndpoint, 16),
+      byError: topRows(lifetime.byError, 16),
+      byImageRoute: topRows(lifetime.byImageRoute, 8),
+      bySource: topRows(lifetime.bySource, 8)
+    };
+  }
+  async ensureLoaded() {
+    if (!this.loadPromise) {
+      this.loadPromise = (async () => {
+        await ensureStateMigrated();
+        await fs.mkdir(getUsageDir(), { recursive: true });
+        await fs.mkdir(getUsageEventsDir(), { recursive: true });
+        const [dailyRaw, lifetimeRaw] = await Promise.all([
+          readJsonFile(getUsageDailyPath()),
+          readJsonFile(getUsageLifetimePath())
+        ]);
+        this.dailyStore = normalizeDailyStore(dailyRaw);
+        this.lifetimeStore = normalizeLifetimeStore(lifetimeRaw);
+      })();
+    }
+    await this.loadPromise;
+  }
+}
+export {
+  UsageService
+};