ai-zero-token 1.0.1 → 1.0.3

package/dist/core/providers/openai-codex/chat.js

@@ -2,6 +2,101 @@
 import { DEFAULT_CODEX_MODEL } from "../../models/openai-codex-models.js";
 import { requestText } from "../http-client.js";
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const URL_KEY_RE = /(url|uri|href|download|preview|thumbnail|image|asset|file)/i;
+const REFERENCE_KEY_RE = /(image|asset|file|media|blob|artifact|download|preview|thumbnail)/i;
+const REFERENCE_VALUE_RE = /^(file|asset|image|img|media|blob)-[\w-]+$/i;
+function parseOptionalNumber(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseOptionalBoolean(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  return void 0;
+}
+function parseOptionalText(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function extractCodexQuotaSnapshot(headers, requestId) {
+  const activeLimit = parseOptionalText(headers["x-codex-active-limit"]);
+  const planType = parseOptionalText(headers["x-codex-plan-type"]);
+  const primaryUsedPercent = parseOptionalNumber(headers["x-codex-primary-used-percent"]);
+  const secondaryUsedPercent = parseOptionalNumber(headers["x-codex-secondary-used-percent"]);
+  const primaryWindowMinutes = parseOptionalNumber(headers["x-codex-primary-window-minutes"]);
+  const secondaryWindowMinutes = parseOptionalNumber(headers["x-codex-secondary-window-minutes"]);
+  const primaryResetAfterSeconds = parseOptionalNumber(headers["x-codex-primary-reset-after-seconds"]);
+  const secondaryResetAfterSeconds = parseOptionalNumber(headers["x-codex-secondary-reset-after-seconds"]);
+  const primaryResetAt = parseOptionalNumber(headers["x-codex-primary-reset-at"]);
+  const secondaryResetAt = parseOptionalNumber(headers["x-codex-secondary-reset-at"]);
+  const primaryOverSecondaryLimitPercent = parseOptionalNumber(
+    headers["x-codex-primary-over-secondary-limit-percent"]
+  );
+  const creditsHasCredits = parseOptionalBoolean(headers["x-codex-credits-has-credits"]);
+  const creditsUnlimited = parseOptionalBoolean(headers["x-codex-credits-unlimited"]);
+  const creditsBalance = parseOptionalText(headers["x-codex-credits-balance"]);
+  const promoCampaignId = parseOptionalText(headers["x-codex-promo-campaign-id"]);
+  const promoMessage = parseOptionalText(headers["x-codex-promo-message"]);
+  const hasQuotaData = [
+    activeLimit,
+    planType,
+    primaryUsedPercent,
+    secondaryUsedPercent,
+    primaryWindowMinutes,
+    secondaryWindowMinutes,
+    primaryResetAfterSeconds,
+    secondaryResetAfterSeconds,
+    primaryResetAt,
+    secondaryResetAt,
+    primaryOverSecondaryLimitPercent,
+    creditsHasCredits,
+    creditsUnlimited,
+    creditsBalance,
+    promoCampaignId,
+    promoMessage
+  ].some((value) => typeof value !== "undefined");
+  if (!hasQuotaData) {
+    return void 0;
+  }
+  return {
+    capturedAt: Date.now(),
+    sourceRequestId: requestId,
+    activeLimit,
+    planType,
+    primaryUsedPercent,
+    secondaryUsedPercent,
+    primaryWindowMinutes,
+    secondaryWindowMinutes,
+    primaryResetAfterSeconds,
+    secondaryResetAfterSeconds,
+    primaryResetAt,
+    secondaryResetAt,
+    primaryOverSecondaryLimitPercent,
+    creditsHasCredits,
+    creditsUnlimited,
+    creditsBalance,
+    promoCampaignId,
+    promoMessage
+  };
+}
 function extractOutputText(payload) {
   if (!payload || typeof payload !== "object") {
     return "";
@@ -43,12 +138,92 @@ function parseSseEvents(body) {
   }
   return events;
 }
-function extractCodexText(body) {
+function pushArtifactCandidate(items, dedupe, candidate) {
+  const signature = `${candidate.source}:${candidate.path}:${candidate.key}:${candidate.kind}:${candidate.value}`;
+  if (dedupe.has(signature)) {
+    return;
+  }
+  dedupe.add(signature);
+  items.push(candidate);
+}
+function collectArtifactCandidates(value, source, path = [], items = [], dedupe = /* @__PURE__ */ new Set()) {
+  if (typeof value === "string") {
+    const key = path[path.length - 1] ?? "";
+    const joinedPath = path.join(".");
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return items;
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+      pushArtifactCandidate(items, dedupe, {
+        source,
+        path: joinedPath,
+        key,
+        kind: "url",
+        value: trimmed
+      });
+      return items;
+    }
+    if (REFERENCE_KEY_RE.test(key) || REFERENCE_VALUE_RE.test(trimmed)) {
+      pushArtifactCandidate(items, dedupe, {
+        source,
+        path: joinedPath,
+        key,
+        kind: "reference",
+        value: trimmed
+      });
+    }
+    return items;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      collectArtifactCandidates(item, source, [...path, String(index)], items, dedupe);
+    });
+    return items;
+  }
+  if (!value || typeof value !== "object") {
+    return items;
+  }
+  for (const [key, nested] of Object.entries(value)) {
+    const nextPath = [...path, key];
+    if (typeof nested === "string" && (URL_KEY_RE.test(key) || /^https?:\/\//i.test(nested))) {
+      collectArtifactCandidates(nested, source, nextPath, items, dedupe);
+      continue;
+    }
+    collectArtifactCandidates(nested, source, nextPath, items, dedupe);
+  }
+  return items;
+}
+function buildDefaultRequestBody(params) {
+  const body = {
+    model: params.model ?? DEFAULT_CODEX_MODEL,
+    store: false,
+    stream: true,
+    instructions: params.system ?? "",
+    text: { verbosity: "medium" },
+    include: ["reasoning.encrypted_content"],
+    tool_choice: "auto",
+    parallel_tool_calls: true
+  };
+  if (typeof params.prompt === "string" && params.prompt.trim()) {
+    body.input = [
+      {
+        role: "user",
+        content: [{ type: "input_text", text: params.prompt }]
+      }
+    ];
+  }
+  return body;
+}
+function extractCodexText(body, requestBody) {
   const events = parseSseEvents(body);
   let responsePayload;
   let accumulated = "";
   for (const event of events) {
-    if (event.type === "response.completed" || event.type === "response.done" || event.type === "response.incomplete") {
+    if (typeof event.response !== "undefined") {
+      responsePayload = event.response;
+    }
+    if (event.type === "response.completed" || event.type === "response.done" || event.type === "response.incomplete" || event.type === "response.failed") {
       responsePayload = event.response;
     }
     if (typeof event.delta === "string" && event.delta) {
@@ -56,12 +231,39 @@ function extractCodexText(body) {
     }
   }
   const completedText = extractOutputText(responsePayload);
+  const artifacts = [
+    ...collectArtifactCandidates(responsePayload, "response"),
+    ...collectArtifactCandidates(events, "event")
+  ];
   if (completedText) {
-    return { text: completedText, raw: responsePayload ?? events };
+    return {
+      text: completedText,
+      raw: {
+        request: requestBody,
+        response: responsePayload ?? null,
+        events
+      },
+      artifacts
+    };
   }
-  return { text: accumulated.trim(), raw: responsePayload ?? events };
+  return {
+    text: accumulated.trim(),
+    raw: {
+      request: requestBody,
+      response: responsePayload ?? null,
+      events
+    },
+    artifacts
+  };
 }
 async function askOpenAICodex(params) {
+  const requestBody = {
+    ...buildDefaultRequestBody(params),
+    ...params.bodyOverride ?? {}
+  };
+  if (typeof requestBody.input === "undefined") {
+    throw new Error("Codex \u8BF7\u6C42\u7F3A\u5C11 input\u3002\u8BF7\u63D0\u4F9B prompt \u6216\u5728\u5B9E\u9A8C\u8BF7\u6C42\u4F53\u91CC\u663E\u5F0F\u4F20\u5165 input\u3002");
+  }
   const response = await requestText({
     method: "POST",
     url: CODEX_RESPONSES_URL,
@@ -74,29 +276,20 @@ async function askOpenAICodex(params) {
       Originator: "pi",
       "User-Agent": "pi (bun demo)"
     },
-    body: JSON.stringify({
-      model: params.model ?? DEFAULT_CODEX_MODEL,
-      store: false,
-      stream: true,
-      instructions: params.system ?? "",
-      input: [
-        {
-          role: "user",
-          content: [{ type: "input_text", text: params.prompt }]
-        }
-      ],
-      text: { verbosity: "medium" },
-      include: ["reasoning.encrypted_content"],
-      tool_choice: "auto",
-      parallel_tool_calls: true
-    })
+    body: JSON.stringify(requestBody)
   });
+  const quota = extractCodexQuotaSnapshot(response.headers, response.requestId);
   if (response.status < 200 || response.status >= 300) {
-    throw new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${response.status} via ${response.transport} ${response.body}`);
+    const error = new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${response.status} via ${response.transport} ${response.body}`);
+    error.quota = quota;
+    throw error;
   }
-  return extractCodexText(response.body);
+  return {
+    ...extractCodexText(response.body, requestBody),
+    quota
+  };
 }
 export {
-  askOpenAICodex
+  askOpenAICodex,
+  extractCodexQuotaSnapshot
 };
-//# sourceMappingURL=chat.js.map

package/dist/core/providers/openai-codex/oauth.js

@@ -12,6 +12,7 @@ const TOKEN_URL = "https://auth.openai.com/oauth/token";
 const REDIRECT_URI = "http://localhost:1455/auth/callback";
 const SCOPE = "openid profile email offline_access";
 const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const PROFILE_CLAIM_PATH = "https://api.openai.com/profile";
 const SUCCESS_HTML = `<!doctype html>
 <html lang="zh-CN">
 <head>
@@ -41,6 +42,18 @@ function decodeJwtPayload(token) {
     return null;
   }
 }
+function extractEmailFromPayload(payload) {
+  const profileClaim = payload?.[PROFILE_CLAIM_PATH];
+  const nestedEmail = profileClaim?.email;
+  if (typeof nestedEmail === "string" && nestedEmail.trim()) {
+    return nestedEmail.trim();
+  }
+  const topLevelEmail = payload?.email;
+  if (typeof topLevelEmail === "string" && topLevelEmail.trim()) {
+    return topLevelEmail.trim();
+  }
+  return void 0;
+}
 function parseAuthorizationInput(value) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -74,11 +87,10 @@ function extractProfile(accessToken, refreshToken, expires) {
   if (typeof accountId !== "string" || !accountId.trim()) {
     throw new Error("\u65E0\u6CD5\u4ECE access token \u4E2D\u63D0\u53D6 accountId\u3002");
   }
-  const email = typeof payload?.email === "string" && payload.email.trim() ? payload.email.trim() : void 0;
-  const profileKey = email ?? accountId;
+  const email = extractEmailFromPayload(payload);
   return {
     provider: "openai-codex",
-    profileId: `openai-codex:${profileKey}`,
+    profileId: `openai-codex:${accountId}`,
     mode: "oauth_account",
     access: accessToken,
     refresh: refreshToken,
@@ -281,4 +293,3 @@ export {
   loginOpenAICodex,
   refreshOpenAICodexToken
 };
-//# sourceMappingURL=oauth.js.map

package/dist/core/providers/openai-codex/pkce.js

@@ -18,4 +18,3 @@ async function generatePKCE() {
 export {
   generatePKCE
 };
-//# sourceMappingURL=pkce.js.map

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

@@ -2,57 +2,166 @@
 import {
   clearStore,
   getActiveProfile,
-  saveProfile
+  listProfiles,
+  removeProfile,
+  saveProfile,
+  setActiveProfile,
+  updateProfile
 } from "../store/profile-store.js";
 import {
   loginOpenAICodex,
   refreshOpenAICodexToken
 } from "../providers/openai-codex/oauth.js";
+import { askOpenAICodex } from "../providers/openai-codex/chat.js";
 class AuthService {
   constructor(configService) {
     this.configService = configService;
   }
+  maskSecret(value) {
+    if (value.length <= 12) {
+      return value;
+    }
+    return `${value.slice(0, 8)}...${value.slice(-6)}`;
+  }
+  toManagedProfile(profile) {
+    return {
+      ...profile,
+      mode: "oauth_account"
+    };
+  }
+  toProfileSummary(profile, activeProfileId) {
+    return {
+      provider: profile.provider,
+      profileId: profile.profileId,
+      accountId: profile.accountId,
+      email: profile.email,
+      quota: profile.quota,
+      expiresAt: profile.expires,
+      accessTokenPreview: this.maskSecret(profile.access),
+      refreshTokenPreview: this.maskSecret(profile.refresh),
+      isActive: profile.profileId === activeProfileId
+    };
+  }
   async login(provider) {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
     }
     const profile = await loginOpenAICodex();
     await saveProfile(profile);
-    return {
-      ...profile,
-      mode: "oauth_account"
-    };
+    return this.toManagedProfile(profile);
   }
   async getActiveProfile(provider = "openai-codex") {
     const profile = await getActiveProfile();
     if (!profile || profile.provider !== provider) {
       return null;
     }
-    return {
-      ...profile,
-      mode: "oauth_account"
-    };
+    return this.toManagedProfile(profile);
+  }
+  async listProfiles(provider = "openai-codex") {
+    const [profiles, activeProfile] = await Promise.all([
+      listProfiles(),
+      this.getActiveProfile(provider)
+    ]);
+    const activeProfileId = activeProfile?.profileId;
+    return profiles.filter((profile) => profile.provider === provider).sort((left, right) => {
+      if (left.profileId === activeProfileId) {
+        return -1;
+      }
+      if (right.profileId === activeProfileId) {
+        return 1;
+      }
+      return right.expires - left.expires;
+    }).map((profile) => this.toProfileSummary(profile, activeProfileId));
+  }
+  async activateProfile(profileId, provider = "openai-codex") {
+    const profiles = await listProfiles();
+    const target = profiles.find((profile) => profile.profileId === profileId && profile.provider === provider);
+    if (!target) {
+      throw new Error(`\u6CA1\u6709\u627E\u5230\u53EF\u5207\u6362\u7684\u8D26\u53F7: ${profileId}`);
+    }
+    const activated = await setActiveProfile(profileId);
+    if (!activated) {
+      throw new Error(`\u5207\u6362\u8D26\u53F7\u5931\u8D25: ${profileId}`);
+    }
+    return this.toManagedProfile(activated);
+  }
+  async removeProfile(profileId, provider = "openai-codex") {
+    const profiles = await listProfiles();
+    const target = profiles.find((profile) => profile.profileId === profileId && profile.provider === provider);
+    if (!target) {
+      throw new Error(`\u6CA1\u6709\u627E\u5230\u8981\u5220\u9664\u7684\u8D26\u53F7: ${profileId}`);
+    }
+    await removeProfile(profileId);
   }
   async requireUsableProfile(provider = "openai-codex") {
     const profile = await this.getActiveProfile(provider);
     if (!profile) {
-      throw new Error(`\u8FD8\u6CA1\u6709\u767B\u5F55 ${provider}\u3002\u5148\u8FD0\u884C bun src/cli.js login`);
+      throw new Error(`\u8FD8\u6CA1\u6709\u767B\u5F55 ${provider}\u3002\u5148\u8FD0\u884C azt login`);
     }
     if (Date.now() < profile.expires) {
       return profile;
     }
     const refreshed = await refreshOpenAICodexToken(profile);
     await saveProfile(refreshed);
-    return {
-      ...refreshed,
-      mode: "oauth_account"
-    };
+    return this.toManagedProfile(refreshed);
   }
   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;
+    }
+    await updateProfile(profileId, (profile) => {
+      if (profile.provider !== provider) {
+        return profile;
+      }
+      return {
+        ...profile,
+        quota
+      };
+    });
+  }
   async getStatus() {
-    const profile = await this.getActiveProfile();
+    const [profile, profiles] = await Promise.all([
+      this.getActiveProfile(),
+      this.listProfiles()
+    ]);
     const defaultModel = await this.configService.getDefaultModel();
     const server = await this.configService.getServerConfig();
     return {
@@ -62,6 +171,7 @@ class AuthService {
       defaultModel,
       loggedIn: Boolean(profile),
       expiresAt: profile?.expires,
+      profileCount: profiles.length,
       serverHost: server.host,
       serverPort: server.port
     };
@@ -70,4 +180,3 @@ class AuthService {
 export {
   AuthService
 };
-//# sourceMappingURL=auth-service.js.map

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

@@ -6,23 +6,33 @@ class ChatService {
   }
   async chat(request) {
     const provider = request.provider ?? "openai-codex";
-    const model = await this.deps.modelService.resolveModel(provider, request.model);
-    const profile = await this.deps.authService.requireUsableProfile(provider);
-    const result = await askOpenAICodex({
-      profile,
-      prompt: request.input,
-      model,
-      system: request.system
+    const model = await this.deps.modelService.resolveModel(provider, request.model, {
+      allowUnknown: request.experimental?.allowUnknownModel
     });
-    return {
-      provider,
-      model,
-      text: result.text,
-      raw: result.raw
-    };
+    const profile = await this.deps.authService.requireUsableProfile(provider);
+    try {
+      const result = await askOpenAICodex({
+        profile,
+        prompt: request.input,
+        model,
+        system: request.system,
+        bodyOverride: request.experimental?.codexBody
+      });
+      await this.deps.authService.updateProfileQuota(profile.profileId, result.quota, provider);
+      return {
+        provider,
+        model,
+        text: result.text,
+        raw: result.raw,
+        artifacts: result.artifacts
+      };
+    } catch (error) {
+      const quota = error.quota;
+      await this.deps.authService.updateProfileQuota(profile.profileId, quota, provider);
+      throw error;
+    }
   }
 }
 export {
   ChatService
 };
-//# sourceMappingURL=chat-service.js.map

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 = {
@@ -66,4 +66,3 @@ class ConfigService {
 export {
   ConfigService
 };
-//# sourceMappingURL=config-service.js.map