@armadra/agent 0.5.1 → 0.6.0

package/dist/ai/apis/chatgpt-backend.d.ts

@@ -0,0 +1,52 @@
+/**
+ * openai-responses 的 ChatGPT 订阅后端（compat `chatgptBackend`；docs/wave6-plan.md §4.1、§4.6、D14、D17）。[W6-O]
+ *
+ * - 请求体：强制 `store:false`、`stream:true`、`input` 数组；按后端删禁用字段（SIWC 15 个；codex 5 个，保留
+ *   `prompt_cache_key`）；SIWC 不发 `role:"system"` item（改 developer）；`instructionsMode: "developer-message"`
+ *   时系统提示改放 input 开头的 developer 消息；`toolsInNamespace` 时工具改放 `additional_tools` 输入项（形状待
+ *   真账户实测）；`unsupported_capability` 报过的字段本进程内不再发；
+ * - 请求头：两者 `Authorization: Bearer`；codex 另加 `ChatGPT-Account-ID`（来自活 token 登记）、`originator`（渠道
+ *   headers，缺省 `codex_cli_rs`）、`session-id` / `x-client-request-id`；
+ * - 出错恢复（每种至多一次）：401 → 强制刷新重试；SIWC 400 `subscription_sharing_unsupported_capability` → 删去
+ *   `error.param` 重试；codex 400 `Instructions are not valid` → 本会话切 developer-message 重试；
+ * - 错误映射（文案带码前缀，宿主按码判断）：429 配额 → `quota_exceeded`（不重试）；失效 → `auth_expired`；
+ *   SIWC 403 `subscription_sharing_user_not_eligible` → `not_eligible`；503 留给会话层现有重试；
+ * - 用量：`cost = 0`、`billing: "subscription"`。
+ */
+import { type LiveToken } from "../../auth/oauth/live.js";
+import type { HttpError } from "../http.js";
+import type { Model, OpenAIResponsesCompat, StreamOptions, Usage } from "../types.js";
+type Json = Record<string, unknown>;
+export type ChatGptBackend = "siwc" | "codex";
+export declare const SIWC_FORBIDDEN_FIELDS: readonly ["background", "conversation", "max_output_tokens", "max_tool_calls", "metadata", "moderation", "multi_agent", "prompt", "prompt_cache_retention", "safety_identifier", "temperature", "top_logprobs", "top_p", "truncation", "user"];
+export declare const CODEX_FORBIDDEN_FIELDS: readonly ["max_output_tokens", "temperature", "top_p", "prompt_cache_retention", "prompt_cache_options"];
+export declare function sessionKeyOf(model: Model, options: StreamOptions): string;
+/** 测试用。 */
+export declare function resetChatGptState(): void;
+export declare function instructionsModeOf(model: Model, compat: OpenAIResponsesCompat, options: StreamOptions): "native" | "developer-message";
+export declare function transformChatGptBody(body: Json, model: Model, compat: OpenAIResponsesCompat, options: StreamOptions): Json;
+/** 发请求前：needsLogin 直接报 auth_expired；登录 flavor 与渠道不符报错。 */
+export declare function chatgptPrecheck(model: Model, compat: OpenAIResponsesCompat, apiKey?: string): void;
+export declare function chatgptHeaders(compat: OpenAIResponsesCompat, options: StreamOptions, apiKey: string | undefined): Record<string, string>;
+/** 包一层 onResponse：解析响应头里的配额。 */
+export declare function quotaOnResponse(compat: OpenAIResponsesCompat, options: StreamOptions): ((status: number, headers: Headers) => void) | undefined;
+/** SSE 里的 `codex.rate_limits`：处理了返回 true。 */
+export declare function handleChatGptEvent(data: Json, options: StreamOptions): boolean;
+/** 订阅计费：按零价计成本（cost 全 0），用量标 `billing: "subscription"`。 */
+export declare function subscriptionModel(model: Model, usage: Usage): Model;
+export type Recovery = {
+    kind: "refresh";
+    live: LiveToken;
+} | {
+    kind: "retry";
+} | {
+    kind: "fail";
+    error: Error;
+} | {
+    kind: "none";
+};
+/**
+ * HTTP 错误 → 恢复动作或映射后的错误。`tried`：本次请求已用过的恢复（每种至多一次）。
+ */
+export declare function recoverChatGptError(error: HttpError, model: Model, compat: OpenAIResponsesCompat, options: StreamOptions, apiKey: string | undefined, tried: Set<string>): Recovery;
+export {};

package/dist/ai/apis/chatgpt-backend.js

@@ -0,0 +1,224 @@
+/**
+ * openai-responses 的 ChatGPT 订阅后端（compat `chatgptBackend`；docs/wave6-plan.md §4.1、§4.6、D14、D17）。[W6-O]
+ *
+ * - 请求体：强制 `store:false`、`stream:true`、`input` 数组；按后端删禁用字段（SIWC 15 个；codex 5 个，保留
+ *   `prompt_cache_key`）；SIWC 不发 `role:"system"` item（改 developer）；`instructionsMode: "developer-message"`
+ *   时系统提示改放 input 开头的 developer 消息；`toolsInNamespace` 时工具改放 `additional_tools` 输入项（形状待
+ *   真账户实测）；`unsupported_capability` 报过的字段本进程内不再发；
+ * - 请求头：两者 `Authorization: Bearer`；codex 另加 `ChatGPT-Account-ID`（来自活 token 登记）、`originator`（渠道
+ *   headers，缺省 `codex_cli_rs`）、`session-id` / `x-client-request-id`；
+ * - 出错恢复（每种至多一次）：401 → 强制刷新重试；SIWC 400 `subscription_sharing_unsupported_capability` → 删去
+ *   `error.param` 重试；codex 400 `Instructions are not valid` → 本会话切 developer-message 重试；
+ * - 错误映射（文案带码前缀，宿主按码判断）：429 配额 → `quota_exceeded`（不重试）；失效 → `auth_expired`；
+ *   SIWC 403 `subscription_sharing_user_not_eligible` → `not_eligible`；503 留给会话层现有重试；
+ * - 用量：`cost = 0`、`billing: "subscription"`。
+ */
+import { liveToken } from "../../auth/oauth/live.js";
+import { authExpiredError } from "../../auth/oauth/refresh.js";
+import { parseQuotaHeaders, parseRateLimitEvent, quotaFromLimitError, } from "./chatgpt-rate-limits.js";
+export const SIWC_FORBIDDEN_FIELDS = [
+    "background",
+    "conversation",
+    "max_output_tokens",
+    "max_tool_calls",
+    "metadata",
+    "moderation",
+    "multi_agent",
+    "prompt",
+    "prompt_cache_retention",
+    "safety_identifier",
+    "temperature",
+    "top_logprobs",
+    "top_p",
+    "truncation",
+    "user",
+];
+export const CODEX_FORBIDDEN_FIELDS = [
+    "max_output_tokens",
+    "temperature",
+    "top_p",
+    "prompt_cache_retention",
+    "prompt_cache_options",
+];
+/** 本会话已切 developer-message 的会话键；`unsupported_capability` 报过的 `provider/model` → 字段。 */
+const developerMode = new Set();
+const strippedFields = new Map();
+export function sessionKeyOf(model, options) {
+    return options.sessionId ?? `${model.provider}/${model.id}`;
+}
+/** 测试用。 */
+export function resetChatGptState() {
+    developerMode.clear();
+    strippedFields.clear();
+}
+export function instructionsModeOf(model, compat, options) {
+    return developerMode.has(sessionKeyOf(model, options))
+        ? "developer-message"
+        : (compat.instructionsMode ?? "native");
+}
+export function transformChatGptBody(body, model, compat, options) {
+    const backend = compat.chatgptBackend;
+    const out = { ...body };
+    const forbidden = backend === "siwc" ? SIWC_FORBIDDEN_FIELDS : CODEX_FORBIDDEN_FIELDS;
+    for (const field of forbidden)
+        delete out[field];
+    for (const field of strippedFields.get(`${model.provider}/${model.id}`) ?? [])
+        delete out[field];
+    out["store"] = false;
+    out["stream"] = true;
+    let input = Array.isArray(out["input"]) ? [...out["input"]] : [];
+    if (backend === "siwc")
+        input = input.map((item) => item["role"] === "system" ? { ...item, role: "developer" } : item);
+    if (instructionsModeOf(model, compat, options) === "developer-message" &&
+        typeof out["instructions"] === "string") {
+        input.unshift({ role: "developer", content: out["instructions"] });
+        delete out["instructions"];
+    }
+    if (compat.toolsInNamespace === true && Array.isArray(out["tools"])) {
+        input.unshift({ type: "additional_tools", tools: out["tools"] });
+        delete out["tools"];
+    }
+    out["input"] = input;
+    return out;
+}
+/** 发请求前：needsLogin 直接报 auth_expired；登录 flavor 与渠道不符报错。 */
+export function chatgptPrecheck(model, compat, apiKey) {
+    const live = liveToken(apiKey);
+    if (live === undefined)
+        return;
+    if (live.needsLogin === true)
+        throw authExpiredError(live.provider);
+    if (live.flavor !== compat.chatgptBackend) {
+        throw new Error(`chatgpt_flavor_mismatch: logged in with ${live.flavor} but ${model.provider}/${model.id} uses the ${String(compat.chatgptBackend)} channel; run \`ama auth login ${live.provider} --flavor ${String(compat.chatgptBackend)}\` or switch channel`);
+    }
+}
+export function chatgptHeaders(compat, options, apiKey) {
+    if (compat.chatgptBackend !== "codex")
+        return {};
+    const headers = {};
+    const accountId = liveToken(apiKey)?.accountId;
+    if (accountId !== undefined)
+        headers["ChatGPT-Account-ID"] = accountId;
+    if (options.sessionId !== undefined) {
+        headers["session-id"] = options.sessionId;
+        headers["x-client-request-id"] = options.sessionId;
+    }
+    return headers;
+}
+/** 包一层 onResponse：解析响应头里的配额。 */
+export function quotaOnResponse(compat, options) {
+    if (compat.chatgptBackend !== "codex" || options.onQuota === undefined)
+        return options.onResponse;
+    return (status, headers) => {
+        options.onResponse?.(status, headers);
+        const quota = parseQuotaHeaders(headers);
+        if (quota !== undefined)
+            emitQuota(options, quota);
+    };
+}
+function emitQuota(options, quota) {
+    try {
+        options.onQuota?.(quota);
+    }
+    catch {
+        // 观察者出错不影响请求
+    }
+}
+/** SSE 里的 `codex.rate_limits`：处理了返回 true。 */
+export function handleChatGptEvent(data, options) {
+    const quota = parseRateLimitEvent(data);
+    if (quota === undefined)
+        return data["type"] === "codex.rate_limits";
+    emitQuota(options, quota);
+    return true;
+}
+/** 订阅计费：按零价计成本（cost 全 0），用量标 `billing: "subscription"`。 */
+export function subscriptionModel(model, usage) {
+    usage.billing = "subscription";
+    return { ...model, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } };
+}
+function errorBody(body) {
+    try {
+        const value = JSON.parse(body);
+        const error = value["error"];
+        if (typeof error === "object" && error !== null)
+            return error;
+        return value;
+    }
+    catch {
+        return {};
+    }
+}
+function codeOf(error) {
+    const code = error["code"] ?? error["type"];
+    return typeof code === "string" ? code : "";
+}
+/** 订阅配额耗尽（不重试）；其余 429（普通限流）留给会话层的退避重试。 */
+const QUOTA_CODES = new Set([
+    "subscription_sharing_usage_limit_exceeded",
+    "usage_limit_reached",
+    "usage_not_included",
+    "insufficient_quota",
+]);
+function resetText(quota) {
+    const at = quota?.primary?.resetsAt;
+    return at === undefined ? "" : ` (resets at ${new Date(at).toISOString()})`;
+}
+/**
+ * HTTP 错误 → 恢复动作或映射后的错误。`tried`：本次请求已用过的恢复（每种至多一次）。
+ */
+export function recoverChatGptError(error, model, compat, options, apiKey, tried) {
+    const backend = compat.chatgptBackend;
+    const body = errorBody(error.body);
+    const code = codeOf(body);
+    const provider = model.provider;
+    if (error.status === 429 && QUOTA_CODES.has(code)) {
+        const quota = quotaFromLimitError(body);
+        emitQuota(options, quota);
+        const what = code === "usage_not_included"
+            ? "your ChatGPT plan does not include this usage"
+            : "ChatGPT plan usage limit reached";
+        return {
+            kind: "fail",
+            error: new Error(`quota_exceeded: ${what}; quota exceeded${resetText(quota)}; see https://chatgpt.com/settings/usage`),
+        };
+    }
+    if (error.status === 401) {
+        const live = liveToken(apiKey);
+        if (live !== undefined && !tried.has("refresh")) {
+            tried.add("refresh");
+            return { kind: "refresh", live };
+        }
+        return { kind: "fail", error: authExpiredError(provider) };
+    }
+    if (backend === "siwc" &&
+        error.status === 403 &&
+        code === "subscription_sharing_user_not_eligible")
+        return {
+            kind: "fail",
+            error: new Error("not_eligible: this ChatGPT account cannot share plan usage with ama (403 subscription_sharing_user_not_eligible)"),
+        };
+    if (backend === "siwc" &&
+        error.status === 400 &&
+        code === "subscription_sharing_unsupported_capability" &&
+        !tried.has("strip")) {
+        const param = typeof body["param"] === "string" ? body["param"].split(/[.[]/)[0] : undefined;
+        if (param !== undefined && param !== "" && param !== "input" && param !== "model") {
+            tried.add("strip");
+            const key = `${model.provider}/${model.id}`;
+            const set = strippedFields.get(key) ?? new Set();
+            set.add(param);
+            strippedFields.set(key, set);
+            return { kind: "retry" };
+        }
+    }
+    if (backend === "codex" &&
+        error.status === 400 &&
+        /instructions are not valid/i.test(error.body) &&
+        !tried.has("instructions")) {
+        tried.add("instructions");
+        developerMode.add(sessionKeyOf(model, options));
+        return { kind: "retry" };
+    }
+    return { kind: "none" };
+}

package/dist/ai/apis/chatgpt-rate-limits.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ChatGPT 订阅配额解析（docs/wave6-plan.md §4.1 配额行、D17；R6 §1.2 配额三行）。[W6-O]
+ *
+ * - 响应头（codex flavor）：`x-codex-primary-used-percent` / `-window-minutes` / `-reset-at`（epoch 秒），
+ *   `secondary` 同形；
+ * - SSE（codex flavor）：`{"type":"codex.rate_limits","plan_type",…,"rate_limits":{"primary":{used_percent,
+ *   window_minutes,reset_at},"secondary":…}}`；
+ * - `GET /wham/usage`（codex flavor，`ama auth status` 用）：`{plan_type, rate_limit:{primary_window:{used_percent,
+ *   limit_window_seconds, reset_at}, secondary_window}}`——私有格式，解析失败静默；
+ * - 429（两种 flavor）：`resets_at`（秒）→ primary 用满。
+ *
+ * 输出统一为 `QuotaSnapshot`，时间换成 epoch 毫秒；会话层转成 `quota_update` 事件。
+ */
+import type { QuotaWindow } from "../../agent/types-w6.js";
+export interface QuotaSnapshot {
+    planType?: string;
+    primary?: QuotaWindow;
+    secondary?: QuotaWindow;
+}
+type Json = Record<string, unknown>;
+export declare function parseQuotaHeaders(headers: Pick<Headers, "get">, family?: string): QuotaSnapshot | undefined;
+export declare function parseRateLimitEvent(data: Json): QuotaSnapshot | undefined;
+export declare function parseUsagePayload(value: unknown): QuotaSnapshot | undefined;
+/** 429 体里的 `resets_at`（秒）→ primary 用满。 */
+export declare function quotaFromLimitError(error: Json): QuotaSnapshot;
+export {};

package/dist/ai/apis/chatgpt-rate-limits.js

@@ -0,0 +1,91 @@
+/**
+ * ChatGPT 订阅配额解析（docs/wave6-plan.md §4.1 配额行、D17；R6 §1.2 配额三行）。[W6-O]
+ *
+ * - 响应头（codex flavor）：`x-codex-primary-used-percent` / `-window-minutes` / `-reset-at`（epoch 秒），
+ *   `secondary` 同形；
+ * - SSE（codex flavor）：`{"type":"codex.rate_limits","plan_type",…,"rate_limits":{"primary":{used_percent,
+ *   window_minutes,reset_at},"secondary":…}}`；
+ * - `GET /wham/usage`（codex flavor，`ama auth status` 用）：`{plan_type, rate_limit:{primary_window:{used_percent,
+ *   limit_window_seconds, reset_at}, secondary_window}}`——私有格式，解析失败静默；
+ * - 429（两种 flavor）：`resets_at`（秒）→ primary 用满。
+ *
+ * 输出统一为 `QuotaSnapshot`，时间换成 epoch 毫秒；会话层转成 `quota_update` 事件。
+ */
+function num(value) {
+    const n = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+    return typeof n === "number" && Number.isFinite(n) ? n : undefined;
+}
+function obj(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function window(used, minutes, resetSeconds) {
+    const usedPercent = num(used);
+    if (usedPercent === undefined)
+        return undefined;
+    const out = { usedPercent: Math.max(0, Math.min(100, usedPercent)) };
+    const m = num(minutes);
+    if (m !== undefined)
+        out.windowMinutes = m;
+    const reset = num(resetSeconds);
+    if (reset !== undefined && reset > 0)
+        out.resetsAt = reset * 1000;
+    return out;
+}
+function snapshot(primary, secondary, plan) {
+    const out = {};
+    if (typeof plan === "string" && plan !== "")
+        out.planType = plan;
+    if (primary !== undefined)
+        out.primary = primary;
+    if (secondary !== undefined)
+        out.secondary = secondary;
+    return primary === undefined && secondary === undefined ? undefined : out;
+}
+export function parseQuotaHeaders(headers, family = "codex") {
+    const p = `x-${family}`;
+    const get = (name) => headers.get(`${p}-${name}`);
+    return snapshot(window(get("primary-used-percent"), get("primary-window-minutes"), get("primary-reset-at")), window(get("secondary-used-percent"), get("secondary-window-minutes"), get("secondary-reset-at")), undefined);
+}
+export function parseRateLimitEvent(data) {
+    if (data["type"] !== "codex.rate_limits")
+        return undefined;
+    const limits = obj(data["rate_limits"]);
+    const w = (value) => {
+        const o = obj(value);
+        return o === undefined
+            ? undefined
+            : window(o["used_percent"], o["window_minutes"], o["reset_at"]);
+    };
+    return snapshot(w(limits?.["primary"]), w(limits?.["secondary"]), data["plan_type"]);
+}
+export function parseUsagePayload(value) {
+    const body = obj(value);
+    const limit = obj(body?.["rate_limit"]);
+    const w = (raw) => {
+        const o = obj(raw);
+        if (o === undefined)
+            return undefined;
+        const seconds = num(o["limit_window_seconds"]);
+        return window(o["used_percent"], seconds === undefined ? undefined : seconds / 60, o["reset_at"]);
+    };
+    const out = snapshot(w(limit?.["primary_window"]), w(limit?.["secondary_window"]), body?.["plan_type"]);
+    if (out === undefined && typeof body?.["plan_type"] === "string")
+        return { planType: body["plan_type"] };
+    return out;
+}
+/** 429 体里的 `resets_at`（秒）→ primary 用满。 */
+export function quotaFromLimitError(error) {
+    const reset = num(error["resets_at"]);
+    const minutes = num(error["limit_window_minutes"]);
+    const primary = { usedPercent: 100 };
+    if (reset !== undefined)
+        primary.resetsAt = reset * 1000;
+    if (minutes !== undefined)
+        primary.windowMinutes = minutes;
+    const out = { primary };
+    if (typeof error["plan_type"] === "string")
+        out.planType = error["plan_type"];
+    return out;
+}

package/dist/ai/apis/openai-responses-request.d.ts

@@ -17,7 +17,8 @@
  *   时发，`cacheRetention: "none"` 不发；`long` 在 `supportsExplicitPromptCacheMode` 时发
  *   `prompt_cache_options: {ttl:"30m"}`，否则在 `supportsLongCacheRetention` 时发
  *   `prompt_cache_retention: "24h"`，两者都不支持按 short；
- * - `toolChoice: "none"`（有工具时）→ `tool_choice: "none"`。
+ * - `toolChoice: "none"`（有工具时）→ `tool_choice: "none"`；
+ * - [W6-O] compat `chatgptBackend`（ChatGPT 订阅后端）：最后经 chatgpt-backend.ts 按后端白名单改写。
  */
 import type { AssistantMessage, Model, ModelThinkingLevel, OpenAIResponsesCompat, ProviderData, StreamOptions, ToolResultMessage, TranscriptContext, UserMessage } from "../types.js";
 type Json = Record<string, unknown>;

package/dist/ai/apis/openai-responses-request.js

@@ -17,16 +17,21 @@
  *   时发，`cacheRetention: "none"` 不发；`long` 在 `supportsExplicitPromptCacheMode` 时发
  *   `prompt_cache_options: {ttl:"30m"}`，否则在 `supportsLongCacheRetention` 时发
  *   `prompt_cache_retention: "24h"`，两者都不支持按 short；
- * - `toolChoice: "none"`（有工具时）→ `tool_choice: "none"`。
+ * - `toolChoice: "none"`（有工具时）→ `tool_choice: "none"`；
+ * - [W6-O] compat `chatgptBackend`（ChatGPT 订阅后端）：最后经 chatgpt-backend.ts 按后端白名单改写。
  */
 import { contentText, normalizeContext, sanitizeText } from "../context.js";
 import { clampThinkingLevel, mappedThinkingValue } from "../thinking.js";
 import { resolveCacheRetention, resolvePromptCacheCompat } from "./cache-params.js";
+import { transformChatGptBody } from "./chatgpt-backend.js";
 import { isStrictCompatible } from "./openai-request.js";
 export const RESPONSES_API = "openai-responses";
 const RESPONSES_COMPAT_KEYS = [
     "supportsReasoningSummary",
     "supportsStore",
+    "chatgptBackend",
+    "instructionsMode",
+    "toolsInNamespace",
 ];
 /** 缺省（未知的 Responses 兼容服务）：不要 summary、不发 store。 */
 export const CONSERVATIVE_RESPONSES_COMPAT = {
@@ -262,5 +267,6 @@ export function buildResponsesRequest(model, context, options) {
     const providerLevel = applyReasoning(body, model, compat, level);
     if (model.samplingParams)
         Object.assign(body, model.samplingParams);
-    return { body, compat, thinkingLevel: level, providerThinkingLevel: providerLevel };
+    const final = compat.chatgptBackend === undefined ? body : transformChatGptBody(body, model, compat, options);
+    return { body: final, compat, thinkingLevel: level, providerThinkingLevel: providerLevel };
 }

package/dist/ai/apis/openai-responses.d.ts

@@ -13,6 +13,8 @@
  * - usage：input = input_tokens − input_tokens_details.cached_tokens，reasoning =
  *   output_tokens_details.reasoning_tokens（已含在 output_tokens 里）；cached_tokens 出现（含 0）即
  *   `cacheReported: true`。
+ * - [W6-O] compat `chatgptBackend`：请求头、配额、出错恢复（401 刷新 / 删不支持字段 / instructions 回退，各一次）、
+ *   错误映射与订阅用量见 chatgpt-backend.ts。
  */
 import type { ApiImplementation, OpenAIResponsesCompat, Usage } from "../types.js";
 type Json = Record<string, unknown>;

package/dist/ai/apis/openai-responses.js

@@ -13,11 +13,14 @@
  * - usage：input = input_tokens − input_tokens_details.cached_tokens，reasoning =
  *   output_tokens_details.reasoning_tokens（已含在 output_tokens 里）；cached_tokens 出现（含 0）即
  *   `cacheReported: true`。
+ * - [W6-O] compat `chatgptBackend`：请求头、配额、出错恢复（401 刷新 / 删不支持字段 / instructions 回退，各一次）、
+ *   错误映射与订阅用量见 chatgpt-backend.ts。
  */
 import { AssistantEventStreamImpl } from "../event-stream.js";
-import { authHeaders, describeErrorJson, idleTimeoutOf, joinUrl, mergeHeaders, USER_AGENT, } from "../http.js";
+import { HttpError, authHeaders, describeErrorJson, idleTimeoutOf, joinUrl, mergeHeaders, USER_AGENT, } from "../http.js";
 import { readSseEvents } from "../sse.js";
 import { affinityHeaders, postWithCacheFallback, resolveCacheRetention } from "./cache-params.js";
+import { chatgptHeaders, chatgptPrecheck, handleChatGptEvent, subscriptionModel, quotaOnResponse, recoverChatGptError, } from "./chatgpt-backend.js";
 import { buildResponsesRequest, detectResponsesCompat, encodeMessageSignature, } from "./openai-responses-request.js";
 import { BlockTracker, ProviderStopError, STREAM_ENDED_MESSAGE, createOutput, finishDone, finishError, requireApiKey, } from "./shared.js";
 function num(value) {
@@ -231,27 +234,55 @@ function handleEvent(data, state, tracker) {
             return false;
     }
 }
-function buildHeaders(model, options) {
-    return mergeHeaders({ "content-type": "application/json", accept: "text/event-stream", "user-agent": USER_AGENT }, authHeaders(options.apiKey, model.authHeader, "authorization-bearer"), affinityHeaders(model, "openai-responses", options.sessionId, resolveCacheRetention(options.cacheRetention)), model.headers, options.headers);
+function buildHeaders(model, options, compat) {
+    return mergeHeaders({ "content-type": "application/json", accept: "text/event-stream", "user-agent": USER_AGENT }, authHeaders(options.apiKey, model.authHeader, "authorization-bearer"), affinityHeaders(model, "openai-responses", options.sessionId, resolveCacheRetention(options.cacheRetention)), chatgptHeaders(compat, options, options.apiKey), model.headers, options.headers);
 }
-async function run(stream, model, context, options) {
-    const tracker = new BlockTracker(stream, createOutput(model));
-    try {
+/** 发请求；ChatGPT 后端按 chatgpt-backend.ts 做至多各一次的恢复（刷新 token / 删字段 / instructions 回退）。 */
+async function post(model, context, initial, tracker) {
+    let options = initial;
+    const tried = new Set();
+    for (;;) {
         const request = buildResponsesRequest(model, context, options);
         tracker.output.thinkingLevel = request.thinkingLevel;
         if (request.providerThinkingLevel !== undefined) {
             tracker.output.providerThinkingLevel = request.providerThinkingLevel;
         }
+        const compat = request.compat;
+        const chatgpt = compat.chatgptBackend !== undefined;
+        if (chatgpt)
+            chatgptPrecheck(model, compat, options.apiKey);
         const replaced = options.onPayload?.(request.body);
         const baseUrl = model.baseUrl ?? "https://api.openai.com/v1";
-        const response = await postWithCacheFallback(model, joinUrl(baseUrl, "/responses"), {
-            headers: buildHeaders(model, options),
-            body: replaced === undefined ? request.body : replaced,
-            signal: options.signal,
-            timeoutMs: options.timeoutMs,
-            idleTimeoutMs: idleTimeoutOf(options),
-            onResponse: options.onResponse,
-        });
+        try {
+            const response = await postWithCacheFallback(model, joinUrl(baseUrl, "/responses"), {
+                headers: buildHeaders(model, options, compat),
+                body: replaced === undefined ? request.body : replaced,
+                signal: options.signal,
+                timeoutMs: options.timeoutMs,
+                idleTimeoutMs: idleTimeoutOf(options),
+                onResponse: chatgpt ? quotaOnResponse(compat, options) : options.onResponse,
+            });
+            return { response, options, compat };
+        }
+        catch (error) {
+            if (!chatgpt || !(error instanceof HttpError))
+                throw error;
+            const recovery = recoverChatGptError(error, model, compat, options, options.apiKey, tried);
+            if (recovery.kind === "fail")
+                throw recovery.error;
+            if (recovery.kind === "none")
+                throw error;
+            if (recovery.kind === "refresh")
+                options = { ...options, apiKey: await recovery.live.refresh() };
+        }
+    }
+}
+async function run(stream, model, context, options) {
+    const tracker = new BlockTracker(stream, createOutput(model));
+    let subscription = false;
+    try {
+        const { response, compat } = await post(model, context, options, tracker);
+        subscription = compat.chatgptBackend !== undefined;
         stream.push({ type: "start", partial: tracker.output });
         const state = {
             byOutput: new Map(),
@@ -274,6 +305,8 @@ async function run(stream, model, context, options) {
             }
             if (data["type"] === undefined && sse.event)
                 data["type"] = sse.event;
+            if (subscription && handleChatGptEvent(data, options))
+                continue;
             if (handleEvent(data, state, tracker)) {
                 finished = true;
                 break;
@@ -286,10 +319,12 @@ async function run(stream, model, context, options) {
         if (state.stop.reason === "error")
             throw new ProviderStopError(state.stop.message);
         const reason = state.stop.reason === "stop" && tracker.hasToolCalls ? "toolUse" : state.stop.reason;
-        finishDone(stream, tracker, model, reason);
+        const billed = subscription ? subscriptionModel(model, tracker.output.usage) : model;
+        finishDone(stream, tracker, billed, reason);
     }
     catch (error) {
-        finishError(stream, tracker, model, error, options.signal);
+        const billed = subscription ? subscriptionModel(model, tracker.output.usage) : model;
+        finishError(stream, tracker, billed, error, options.signal);
     }
 }
 function stream(model, context, options) {

package/dist/ai/overflow.d.ts

@@ -10,7 +10,7 @@
  * 文案表只记录各家文档或实测中出现过的句式；新增供应商时用真实溢出请求取样后补一条。
  */
 import type { AssistantMessage } from "./types.js";
-/** [正则, 来源说明]。 */
+/** [正则, 来源说明]。来源说明只是给维护者看的出处记录（不显示、不发给模型），统一写英文。 */
 export declare const OVERFLOW_PATTERNS: readonly (readonly [RegExp, string])[];
 /** 错误文本是否表示上下文溢出。 */
 export declare function isOverflowErrorText(text: string): boolean;

package/dist/ai/overflow.js

@@ -9,29 +9,32 @@
  *
  * 文案表只记录各家文档或实测中出现过的句式；新增供应商时用真实溢出请求取样后补一条。
  */
-/** [正则, 来源说明]。 */
+/** [正则, 来源说明]。来源说明只是给维护者看的出处记录（不显示、不发给模型），统一写英文。 */
 export const OVERFLOW_PATTERNS = [
     [/prompt is too long/i, "Anthropic: prompt is too long: N tokens > M maximum"],
     [/request_too_large/i, "Anthropic: 413 request_too_large"],
     [/exceeds the context window/i, "OpenAI: Your input exceeds the context window of this model"],
     [/maximum context length is \d+ tokens/i, "OpenAI / OpenRouter / DeepSeek"],
-    [/exceeds (?:the )?(?:model'?s )?maximum context length/i, "OpenAI 兼容网关（vLLM / LiteLLM）"],
+    [
+        /exceeds (?:the )?(?:model'?s )?maximum context length/i,
+        "OpenAI-compatible gateways (vLLM / LiteLLM)",
+    ],
     [/input token count.*exceeds the maximum/i, "Google Gemini"],
     [
         /exceeds the maximum number of tokens allowed/i,
-        "Google Gemini（无 input token count 前缀的变体）",
+        "Google Gemini (variant without the input token count prefix)",
     ],
     [/maximum prompt length is \d+/i, "xAI"],
     [/reduce the length of the messages/i, "Groq"],
     [/too large for model with \d+ maximum context length/i, "Mistral"],
     [/exceeded model token limit/i, "Moonshot / Kimi"],
-    [/prompt (?:too long|exceeds max length)/i, "智谱 GLM（code 1261）/ Ollama"],
+    [/prompt (?:too long|exceeds max length)/i, "Zhipu GLM (code 1261) / Ollama"],
     [/range of input length should be/i, "DashScope / Qwen"],
     [/greater than the context length/i, "LM Studio"],
     [/exceeds the available context size/i, "llama.cpp server"],
-    [/context[_ ]length[_ ]exceeded/i, "通用：context_length_exceeded"],
-    [/model_context_window_exceeded/i, "通用：finish_reason 文本化"],
-    [/token limit exceeded/i, "通用"],
+    [/context[_ ]length[_ ]exceeded/i, "generic: context_length_exceeded"],
+    [/model_context_window_exceeded/i, "generic: finish_reason as text"],
+    [/token limit exceeded/i, "generic"],
 ];
 /** 命中这些的不算溢出（限流 / 配额）。 */
 const NOT_OVERFLOW = [/rate[ _-]?limit/i, /too many requests/i, /\b429\b/];

package/dist/ai/providers/auth.d.ts

@@ -10,8 +10,14 @@
  * auth.json 的 `apiKey` 以 `!` 开头 = 执行命令取值（stdout 去首尾空白；超时 10 s；空输出或
  * 非零退出视为未配置，继续找下一来源）；同一命令进程内只执行一次。
  * 密钥只出现在 `resolve()` 的返回值里：warning 文案不含密钥与命令输出。
+ *
+ * [W6-O] auth.json 的 OAuth 条目（`type: "oauth"`，ChatGPT 登录）在 ②③ 的位置解析：每次从磁盘重读（绕过
+ * `fileCache`），临近过期经 `auth/oauth/refresh.ts` 刷新（跨进程锁），返回 `{ source: "oauth" }`，并把 token 的
+ * 上下文登记进 `auth/oauth/live.ts` 供协议层取账户 id、401 时强制刷新。永久失效（needsLogin）时仍返回旧 token
+ * 并在登记里标 needsLogin，协议层据此直接报 `auth_expired`（不发请求）。
  */
-import type { AuthFile } from "../../config/types.js";
+import { type RefreshDeps } from "../../auth/oauth/refresh.js";
+import type { ApiKeyAuthEntry, AuthFile } from "../../config/types.js";
 import type { ApiKeyResolution, ProviderData } from "../types.js";
 export type KeyProvider = Pick<ProviderData, "id" | "envKeys" | "requiresApiKey">;
 export interface KeyResolverOptions {
@@ -32,10 +38,13 @@ export interface KeyResolverOptions {
     onWarning?: ((message: string) => void) | undefined;
     /** `!command` 超时，缺省 10 000。 */
     commandTimeoutMs?: number | undefined;
+    /** [W6-O] OAuth 刷新的依赖（fetch、配置 `auth.chatgpt`、测试注入）。 */
+    oauth?: RefreshDeps | undefined;
 }
 /** 用户级配置目录：AMA_CONFIG_DIR > %APPDATA%\ama > $XDG_CONFIG_HOME/ama > ~/.config/ama。 */
 export declare function defaultConfigDir(env?: NodeJS.ProcessEnv): string;
-type AuthEntry = AuthFile["providers"][string];
+/** API key 条目；OAuth 条目（`type: "oauth"`）走 `oauthPath()` + token 存储。 */
+type AuthEntry = ApiKeyAuthEntry;
 /** 读 auth.json；不存在返回 undefined；格式错误 / 权限过宽记 warning。 */
 export declare function readAuthFile(path: string, onWarning?: (message: string) => void): AuthFile | undefined;
 /**
@@ -57,6 +66,10 @@ export declare class ApiKeyResolver {
         entry: AuthEntry;
         path: string;
     } | undefined;
+    /** [W6-O] 第一个给该供应商写了条目的 auth.json 若是 OAuth 条目，返回其路径。 */
+    oauthPath(providerId: string): string | undefined;
+    private register;
+    private fromOAuth;
     private runCommand;
     private fromAuthFiles;
     private fromConfig;