pi-tsgw 3.4.0 → 3.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -26,6 +26,9 @@ pi install npm:pi-tsgw
26
26
 
27
27
  将占位地址替换为实际网关地址,通过 `/login` 选择 `tsgw` 配置密钥,然后执行 `/reload`。
28
28
  使用 `/tsgw` 查看目录状态,`/tsgw-refresh` 强制刷新。
29
+ 网关目录含 `magpie_label` 时自动识别为 Magpie,识别结果随目录缓存并在当前宿主进程内共享。识别后可在 `/tsgw` 查看状态与按厂商/来源展开的额度、重新读取卡片或明确确认刷新上游;普通查看只读网关缓存,刷新按 provider/账户匹配范围执行,同名卡片可能共同刷新。
30
+
31
+ 使用该网关的正常用户任务完成后,异步读取一次全局额度卡片,同一网关和凭据在当前宿主进程内共享读数与 60 秒复用窗口;切换会话或模型保留已有读数,空闲不轮询,不自动刷新供应商。底部按厂商显示最高已知剩余比例:先取每个账户共同限制窗口中的最低值,再取同厂商账户的最高值;厂商组无百分比时按原单位展示余额,未知与旧读数单独标记,不跨账户相加。完整窗口、读数时间和会话状态仍可在 `/tsgw` 查看;状态报告的模型名可能是请求别名,不代表实际路由成员。
29
32
 
30
33
  网关追踪头默认开启:`AH-Thread-Id` 和 `X-Magpie-Session` 使用真实会话 ID,`AH-Trace-Id` 关联真实用户消息;压缩、摘要等请求不冒充用户消息追踪。仅补充指向已配置网关的 `tsgw` 聊天请求,保留调用方已有同名头。可在 `settings.json` 的 `tsgw` 中设置 `"traceHeaders": false` 关闭插件补头,但不禁用宿主原生会话头或网关侧记录;网关已开启对话记录时,会话标识可能使其归集并保存对话。
31
34
 
@@ -0,0 +1,162 @@
1
+ import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
2
+ import { normalizeRoot, PROVIDER_ID } from "#tsgw/models/catalog";
3
+ import { gatewayModelCacheScope } from "#tsgw/models/gateway-catalog";
4
+ import type { GatewayCatalogService } from "#tsgw/models/gateway-catalog-service";
5
+ import { getMagpieService, type MagpieRequest, type MagpieService } from "./service.ts";
6
+ import { chooseRefresh, showStatus, showCards, unchangedReadTimes } from "./ui.ts";
7
+ import { quotaSummary } from "./summary.ts";
8
+
9
+ const STATUS = "查看 Magpie 状态";
10
+ const CARDS = "查看 Magpie 额度";
11
+ const RELOAD = "重新读取卡片";
12
+ const REFRESH = "刷新上游额度";
13
+
14
+ export function registerMagpie(pi: ExtensionAPI, options: {
15
+ root: string;
16
+ gateway: () => GatewayCatalogService | undefined;
17
+ onChange: () => void;
18
+ }) {
19
+ let lifetime = new AbortController();
20
+ let subscribed: MagpieService | undefined;
21
+ let unsubscribe: (() => void) | undefined;
22
+ let watched: GatewayCatalogService | undefined;
23
+ let stopCatalog: (() => void) | undefined;
24
+ let hidden: GatewayCatalogService | undefined;
25
+ let userRun = false;
26
+ let availableUI = false;
27
+ const clear = (catalog: GatewayCatalogService) => { hidden = catalog; options.onChange(); };
28
+ const release = () => {
29
+ unsubscribe?.(); unsubscribe = undefined; subscribed = undefined;
30
+ stopCatalog?.(); stopCatalog = undefined; watched = undefined;
31
+ };
32
+ function currentService(): MagpieService | undefined {
33
+ const catalog = options.gateway();
34
+ if (!availableUI || lifetime.signal.aborted || !catalog?.valid() || hidden === catalog) {
35
+ release();
36
+ return;
37
+ }
38
+ if (watched !== catalog) {
39
+ release();
40
+ watched = catalog;
41
+ stopCatalog = catalog.subscribe(options.onChange);
42
+ }
43
+ if (!catalog.isMagpie()) {
44
+ unsubscribe?.(); unsubscribe = undefined; subscribed = undefined;
45
+ return;
46
+ }
47
+ const service = getMagpieService(catalog);
48
+ if (subscribed !== service) {
49
+ unsubscribe?.();
50
+ subscribed = service;
51
+ unsubscribe = service.subscribe(options.onChange);
52
+ }
53
+ return service;
54
+ }
55
+
56
+ async function connect(registry: ExtensionContext["modelRegistry"], signal: AbortSignal):
57
+ Promise<{ service: MagpieService; request: MagpieRequest } | undefined> {
58
+ const catalog = options.gateway();
59
+ if (!catalog?.isMagpie() || !catalog.valid() || signal.aborted) return;
60
+ if (typeof registry.getProviderAuth !== "function") {
61
+ clear(catalog);
62
+ throw new Error("当前宿主未提供 Magpie 查询所需的认证接口。请使用支持 getProviderAuth 的 Pi 版本。");
63
+ }
64
+ let auth;
65
+ try { auth = (await registry.getProviderAuth(PROVIDER_ID))?.auth; }
66
+ catch { clear(catalog); throw new Error("Magpie 认证解析失败,请检查宿主登录状态。"); }
67
+ if (signal.aborted || !catalog.valid() || !catalog.isMagpie()) return;
68
+ if (!auth?.apiKey) { clear(catalog); throw new Error("Magpie 查询需要已配置的 TSGW 密钥,请先通过 /login 配置。"); }
69
+ let root: string;
70
+ try { root = normalizeRoot(auth.baseUrl ?? options.root); }
71
+ catch { clear(catalog); throw new Error("宿主提供的 Magpie 地址不可用。"); }
72
+ if (root !== options.root || gatewayModelCacheScope(root, auth.apiKey) !== catalog.scope) {
73
+ clear(catalog);
74
+ throw new Error("TSGW 地址或凭据已变化,请先刷新模型目录确认当前网关身份。");
75
+ }
76
+ const headers = new Headers({ Authorization: `Bearer ${auth.apiKey}`, Accept: "application/json" });
77
+ for (const [name, value] of Object.entries(auth.headers ?? {})) {
78
+ if (value === null) headers.delete(name);
79
+ else if (value !== undefined) headers.set(name, value);
80
+ }
81
+ hidden = undefined;
82
+ const service = currentService();
83
+ if (!service) return;
84
+ return { service, request: { root, headers } };
85
+ }
86
+
87
+ pi.on("session_start", (_event, ctx) => {
88
+ lifetime.abort();
89
+ lifetime = new AbortController();
90
+ userRun = false;
91
+ availableUI = ctx.hasUI;
92
+ });
93
+ pi.on("session_shutdown", () => { lifetime.abort(); userRun = false; availableUI = false; release(); });
94
+ pi.on("before_agent_start", (event) => { userRun = event.messageType === "user"; });
95
+ pi.on("model_select", () => {
96
+ lifetime.abort();
97
+ lifetime = new AbortController();
98
+ options.onChange();
99
+ });
100
+ // agent_end 之后宿主可能继续重试;settled 才表示本次任务不会自动续跑。
101
+ pi.on("agent_settled", (event, ctx) => {
102
+ const normal = userRun;
103
+ userRun = false;
104
+ if (!normal || event.aborted || !availableUI || ctx.model?.provider !== PROVIDER_ID || !options.gateway()?.isMagpie()) return;
105
+ try { if (normalizeRoot(ctx.model.baseUrl) !== options.root) return; } catch { return; }
106
+ const registry = ctx.modelRegistry;
107
+ const signal = lifetime.signal;
108
+ void connect(registry, signal).then(async connection => {
109
+ if (!connection) return;
110
+ await connection.service.readCards(connection.request, { automatic: true, signal });
111
+ if (!signal.aborted) options.onChange();
112
+ }).catch(() => { if (!signal.aborted) options.onChange(); });
113
+ });
114
+
115
+ return {
116
+ choices: () => options.gateway()?.isMagpie() ? [STATUS, CARDS, RELOAD, REFRESH] : [],
117
+ label(): string | undefined {
118
+ const service = currentService();
119
+ if (!service) return;
120
+ const snapshot = service.cards();
121
+ if (!snapshot.data) return snapshot.error ? "额度读取失败" : "剩余:?";
122
+ return `${quotaSummary(snapshot.data)}${snapshot.error ? "(旧)" : ""}`;
123
+ },
124
+ async handle(choice: string, ctx: ExtensionCommandContext): Promise<void> {
125
+ if (![STATUS, CARDS, RELOAD, REFRESH].includes(choice) || !ctx.hasUI) return;
126
+ const ui = ctx.ui;
127
+ const id = ctx.sessionManager.getSessionId();
128
+ const registry = ctx.modelRegistry;
129
+ const signal = lifetime.signal;
130
+ try {
131
+ const connection = await connect(registry, signal);
132
+ if (!connection) return;
133
+ const { service, request } = connection;
134
+ if (choice === STATUS) {
135
+ const snapshot = await service.readStatus(id, request, { force: true, signal });
136
+ if (signal.aborted || !service.valid()) return;
137
+ options.onChange();
138
+ await showStatus(ui, snapshot, signal);
139
+ return;
140
+ }
141
+ let snapshot = await service.readCards(request, { force: choice === RELOAD, signal });
142
+ if (signal.aborted || !service.valid()) return;
143
+ if (choice === REFRESH) {
144
+ if (snapshot.status === 401 || snapshot.status === 403) {
145
+ ui.notify(snapshot.error!, "error");
146
+ return;
147
+ }
148
+ const selection = await chooseRefresh(ui, snapshot.data ?? [], signal);
149
+ if (!selection || signal.aborted || !service.valid()) return;
150
+ const before = snapshot.data;
151
+ snapshot = await service.refreshCards(request, selection.target, signal);
152
+ if (signal.aborted || !service.valid()) return;
153
+ if (!snapshot.error) ui.notify(unchangedReadTimes(before, snapshot.data)
154
+ ? "刷新请求已返回,读数时间未变化或未提供。" : "刷新请求已返回,请核对各卡片读数时间。", "info");
155
+ }
156
+ await showCards(ui, snapshot, signal);
157
+ } catch (error) {
158
+ if (!signal.aborted) ui.notify(error instanceof Error ? error.message : "Magpie 操作失败。", "error");
159
+ }
160
+ },
161
+ };
162
+ }
@@ -0,0 +1,263 @@
1
+ /**
2
+ * Magpie 额度数据的入口解析与保真类型。
3
+ *
4
+ * 两个固定接口的响应外壳不同,但共用卡片外壳:
5
+ * - `GET /v1/magpie/quotas/cards`:`{ object: "list", data: SubscriptionQuota[] }`。
6
+ * - `GET /v1/magpie/statusline?format=json`:`{ text, model, accounts: Quota[] }`。
7
+ *
8
+ * 卡片窗口是 `QuotaWindow`(没有 `remaining`);状态行账户是额度报告 `Quota`
9
+ * (窗口另有 `remaining`),因此同一个保真卡片类型同时容纳两套窗口字段。
10
+ * 解析只校验已知字段的类型与必需字段,未知字段原样保留并共享同一引用,
11
+ * 不补窗口、不补读数,也不把缺失值当成 0 或 100%。
12
+ */
13
+
14
+ /** 卡片已知字段均可缺失;未知字段通过索引签名原样保留。 */
15
+ export interface MagpieWindow extends Record<string, unknown> {
16
+ name?: string;
17
+ /** 普通窗口的已用百分比;文本行、无总量余额的占位值不是读数。 */
18
+ used?: number;
19
+ /** 厂商给出的展示文本,例如 “1.2k / 3k”;有值时优先展示。 */
20
+ display?: string;
21
+ text?: boolean;
22
+ unlimited?: boolean;
23
+ resetsAt?: string;
24
+ /** 额度报告(statusline 账户)窗口的计算剩余百分比;卡片窗口没有此字段。 */
25
+ remaining?: number;
26
+ amount?: number;
27
+ limit?: number;
28
+ unit?: string;
29
+ /** 窗口级钱包/积分余额;有值时 `used` 未必是占比。 */
30
+ balance?: number;
31
+ spent?: number;
32
+ spentSince?: string;
33
+ runsOutAt?: string;
34
+ runsOut?: number;
35
+ resetSecs?: number;
36
+ pool?: string;
37
+ lane?: string;
38
+ family?: string;
39
+ holdsWhy?: string;
40
+ credits?: boolean;
41
+ extra?: boolean;
42
+ capped?: boolean;
43
+ }
44
+
45
+ export interface MagpieBalancePart extends Record<string, unknown> {
46
+ text: string;
47
+ label?: string;
48
+ percent?: number;
49
+ error?: string;
50
+ expires?: string;
51
+ }
52
+
53
+ /** 用户自填余额减去网关已计费的估算值,不是厂商读数。 */
54
+ export interface MagpieEstimate extends Record<string, unknown> {
55
+ set: number;
56
+ at?: string;
57
+ spent: number;
58
+ currency?: string;
59
+ rate?: number;
60
+ left?: number | null;
61
+ from?: string;
62
+ next?: string;
63
+ }
64
+
65
+ export interface MagpieResetCard extends Record<string, unknown> {
66
+ until?: string;
67
+ window?: string;
68
+ id?: string;
69
+ }
70
+
71
+ /** 尚持有的重置权益;列出不代表可以消费,消费入口不属于本扩展。 */
72
+ export interface MagpieResetCredits extends Record<string, unknown> {
73
+ count: number;
74
+ until?: string;
75
+ byWindow?: boolean;
76
+ fiveHour?: number;
77
+ weekly?: number;
78
+ team?: boolean;
79
+ each?: MagpieResetCard[];
80
+ }
81
+
82
+ /**
83
+ * 一张额度卡片。`provider` 是 Magpie 的渠道标识(订阅常是 Agent ID),
84
+ * 不必等于厂商名;`from` 是远程 Magpie 名称。同一 `provider/user`
85
+ * 仍可能对应多张独立卡片,调用方不得据此覆盖或相加。
86
+ */
87
+ export interface MagpieCard extends Record<string, unknown> {
88
+ provider: string;
89
+ name?: string;
90
+ user?: string;
91
+ plan?: string;
92
+ from?: string;
93
+ kind?: string;
94
+ readAt?: string;
95
+ asOf?: string;
96
+ error?: string;
97
+ balance?: string;
98
+ /** 协议未加 omitempty,窗口未提供时可能为 null;null 与缺失同为“未提供”,不是格式错误。 */
99
+ windows?: MagpieWindow[] | null;
100
+ alias?: string;
101
+ seat?: string;
102
+ sharedBalance?: string;
103
+ balanceSplit?: MagpieBalancePart[];
104
+ /** 与 balanceSplit 同结构的另一组分项(用户书写的多段余额),不得重复相加。 */
105
+ balanceParts?: MagpieBalancePart[];
106
+ estimate?: MagpieEstimate;
107
+ resets?: MagpieResetCredits;
108
+ readDeferred?: boolean;
109
+ until?: string;
110
+ renew?: string;
111
+ lastServedAt?: string;
112
+ held?: boolean;
113
+ last?: boolean;
114
+ pluginError?: boolean;
115
+ needsAccessKey?: boolean;
116
+ }
117
+
118
+ /**
119
+ * statusline 响应。`model` 可能回退为请求名,不证明实际成员;
120
+ * `accounts` 是额度报告口径的卡片,窗口另含 `remaining`。
121
+ */
122
+ export interface MagpieStatusline extends Record<string, unknown> {
123
+ text: string;
124
+ model: string;
125
+ accounts: MagpieCard[];
126
+ }
127
+
128
+ /** 形状错误;消息只说明位置与字段,不回显原始值。 */
129
+ export class MagpieDataError extends Error {
130
+ constructor(message: string) {
131
+ super(message);
132
+ this.name = "MagpieDataError";
133
+ }
134
+ }
135
+
136
+ function invalid(where: string, detail: string): never {
137
+ throw new MagpieDataError(`Magpie 数据无效:${where}${detail}`);
138
+ }
139
+
140
+ function asRecord(value: unknown, where: string): Record<string, unknown> {
141
+ if (typeof value !== "object" || value === null || Array.isArray(value)) invalid(where, "必须是 JSON 对象。");
142
+ return value as Record<string, unknown>;
143
+ }
144
+
145
+ function checkString(item: Record<string, unknown>, key: string, where: string): void {
146
+ const value = item[key];
147
+ if (value !== undefined && typeof value !== "string") invalid(where, `的 ${key} 必须是字符串。`);
148
+ }
149
+
150
+ function checkNumber(item: Record<string, unknown>, key: string, where: string): void {
151
+ const value = item[key];
152
+ if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) invalid(where, `的 ${key} 必须是有限数值。`);
153
+ }
154
+
155
+ function checkRequiredNumber(item: Record<string, unknown>, key: string, where: string): void {
156
+ if (typeof item[key] !== "number" || !Number.isFinite(item[key] as number)) invalid(where, `缺少 ${key} 数值。`);
157
+ }
158
+
159
+ function checkBoolean(item: Record<string, unknown>, key: string, where: string): void {
160
+ const value = item[key];
161
+ if (value !== undefined && typeof value !== "boolean") invalid(where, `的 ${key} 必须是布尔值。`);
162
+ }
163
+
164
+ const WINDOW_STRINGS = ["name", "display", "resetsAt", "unit", "pool", "lane", "family", "holdsWhy", "spentSince", "runsOutAt"] as const;
165
+ const WINDOW_NUMBERS = ["used", "remaining", "amount", "limit", "balance", "spent", "runsOut", "resetSecs"] as const;
166
+ const WINDOW_BOOLEANS = ["text", "unlimited", "credits", "extra", "capped"] as const;
167
+
168
+ function checkWindow(value: unknown, where: string): MagpieWindow {
169
+ const window = asRecord(value, where);
170
+ for (const key of WINDOW_STRINGS) checkString(window, key, where);
171
+ for (const key of WINDOW_NUMBERS) checkNumber(window, key, where);
172
+ for (const key of WINDOW_BOOLEANS) checkBoolean(window, key, where);
173
+ return window as MagpieWindow;
174
+ }
175
+
176
+ function checkWindows(item: Record<string, unknown>, where: string): void {
177
+ const value = item.windows;
178
+ // null 是协议可能输出的“未提供窗口”,保留原值,不改成 []、也不当作满额。
179
+ if (value === undefined || value === null) return;
180
+ if (!Array.isArray(value)) invalid(where, "的 windows 必须是数组或 null。");
181
+ value.forEach((window, index) => checkWindow(window, `${where}第 ${index + 1} 个窗口`));
182
+ }
183
+
184
+ function checkBalanceParts(item: Record<string, unknown>, key: string, where: string): void {
185
+ const value = item[key];
186
+ if (value === undefined) return;
187
+ if (!Array.isArray(value)) invalid(where, `的 ${key} 必须是数组。`);
188
+ value.forEach((part, index) => {
189
+ const at = `${where}的 ${key} 第 ${index + 1} 项`;
190
+ const record = asRecord(part, at);
191
+ if (typeof record.text !== "string") invalid(at, "缺少 text 字符串。");
192
+ for (const field of ["label", "error", "expires"]) checkString(record, field, at);
193
+ checkNumber(record, "percent", at);
194
+ });
195
+ }
196
+
197
+ function checkEstimate(item: Record<string, unknown>, where: string): void {
198
+ const value = item.estimate;
199
+ if (value === undefined) return;
200
+ const at = `${where}的 estimate`;
201
+ const estimate = asRecord(value, at);
202
+ checkRequiredNumber(estimate, "set", at);
203
+ checkRequiredNumber(estimate, "spent", at);
204
+ for (const key of ["rate"]) checkNumber(estimate, key, at);
205
+ for (const key of ["at", "currency", "from", "next"]) checkString(estimate, key, at);
206
+ const left = estimate.left;
207
+ if (left !== undefined && left !== null && (typeof left !== "number" || !Number.isFinite(left))) invalid(at, "的 left 必须是有限数值或 null。");
208
+ }
209
+
210
+ function checkResets(item: Record<string, unknown>, where: string): void {
211
+ const value = item.resets;
212
+ if (value === undefined) return;
213
+ const at = `${where}的 resets`;
214
+ const resets = asRecord(value, at);
215
+ checkRequiredNumber(resets, "count", at);
216
+ checkString(resets, "until", at);
217
+ for (const key of ["fiveHour", "weekly"]) checkNumber(resets, key, at);
218
+ for (const key of ["byWindow", "team"]) checkBoolean(resets, key, at);
219
+ const each = resets.each;
220
+ if (each === undefined) return;
221
+ if (!Array.isArray(each)) invalid(at, "的 each 必须是数组。");
222
+ each.forEach((card, index) => {
223
+ const whereCard = `${at} 第 ${index + 1} 项`;
224
+ const record = asRecord(card, whereCard);
225
+ for (const key of ["until", "window", "id"]) checkString(record, key, whereCard);
226
+ });
227
+ }
228
+
229
+ const CARD_STRINGS = ["name", "user", "plan", "from", "kind", "readAt", "asOf", "error", "balance", "alias", "seat", "sharedBalance", "until", "renew", "lastServedAt"] as const;
230
+ const CARD_BOOLEANS = ["readDeferred", "held", "last", "pluginError", "needsAccessKey"] as const;
231
+
232
+ function checkCard(value: unknown, where: string): MagpieCard {
233
+ const card = asRecord(value, where);
234
+ if (typeof card.provider !== "string" || !card.provider.trim()) invalid(where, "缺少非空的 provider 字符串。");
235
+ for (const key of CARD_STRINGS) checkString(card, key, where);
236
+ for (const key of CARD_BOOLEANS) checkBoolean(card, key, where);
237
+ checkWindows(card, where);
238
+ checkBalanceParts(card, "balanceSplit", where);
239
+ checkBalanceParts(card, "balanceParts", where);
240
+ checkEstimate(card, where);
241
+ checkResets(card, where);
242
+ return card as MagpieCard;
243
+ }
244
+
245
+ /** 解析 `/v1/magpie/quotas/cards` 响应;返回的卡片与原始对象共享引用。 */
246
+ export function parseCards(value: unknown): MagpieCard[] {
247
+ const payload = asRecord(value, "cards 响应");
248
+ if (payload.object !== "list") invalid("cards 响应", "缺少 object:\"list\"。");
249
+ if (!Array.isArray(payload.data)) invalid("cards 响应", "data 必须是数组。");
250
+ payload.data.forEach((card, index) => checkCard(card, `cards 响应第 ${index + 1} 条卡片`));
251
+ return payload.data as MagpieCard[];
252
+ }
253
+
254
+ /** 解析 `/v1/magpie/statusline?format=json` 响应;账户按保真卡片校验。 */
255
+ export function parseStatusline(value: unknown): MagpieStatusline {
256
+ const payload = asRecord(value, "statusline 响应");
257
+ for (const key of ["text", "model"]) {
258
+ if (typeof payload[key] !== "string") invalid("statusline 响应", `缺少 ${key} 字符串。`);
259
+ }
260
+ if (!Array.isArray(payload.accounts)) invalid("statusline 响应", "accounts 必须是数组。");
261
+ payload.accounts.forEach((account, index) => checkCard(account, `statusline 响应 accounts 第 ${index + 1} 条卡片`));
262
+ return payload as MagpieStatusline;
263
+ }
@@ -0,0 +1,171 @@
1
+ import type { GatewayCatalogService } from "#tsgw/models/gateway-catalog-service";
2
+ import { parseCards, parseStatusline, type MagpieCard, type MagpieStatusline } from "./data.ts";
3
+
4
+ export interface MagpieRequest {
5
+ root: string;
6
+ headers: Headers;
7
+ }
8
+ export interface MagpieSnapshot<T> {
9
+ data?: T;
10
+ fetchedAt?: number;
11
+ error?: string;
12
+ status?: number;
13
+ }
14
+ export interface RefreshTarget { provider: string; user?: string }
15
+ interface Task<T> {
16
+ controller: AbortController;
17
+ waiters: number;
18
+ promise: Promise<MagpieSnapshot<T>>;
19
+ }
20
+ interface Resource<T> {
21
+ snapshot: MagpieSnapshot<T>;
22
+ attemptedAt?: number;
23
+ blocked?: boolean;
24
+ task?: Task<T>;
25
+ }
26
+ const TTL = 60_000;
27
+ const resource = <T>(): Resource<T> => ({ snapshot: {} });
28
+
29
+ /** 只共享同一目录作用域的内存读数,不保存宿主上下文或常驻明文凭据。 */
30
+ export function createMagpieService(catalog: Pick<GatewayCatalogService, "valid" | "isMagpie">,
31
+ fetcher: typeof fetch = (...args) => globalThis.fetch(...args), now = Date.now) {
32
+ const cards = resource<MagpieCard[]>();
33
+ const listeners = new Set<() => void>();
34
+ const sessions = new Map<string, Resource<MagpieStatusline>>();
35
+ let statusBlocked = false;
36
+ let refresh: { target?: RefreshTarget; task: Task<MagpieCard[]> } | undefined;
37
+ let cardsRevision = 0;
38
+ const valid = () => catalog.valid() && catalog.isMagpie();
39
+ const session = (id: string) => {
40
+ let state = sessions.get(id);
41
+ if (!state) sessions.set(id, state = resource());
42
+ return state;
43
+ };
44
+
45
+ function start<T>(state: Resource<T>, request: MagpieRequest, path: string,
46
+ parse: (value: unknown) => T, method: "GET" | "POST", canCommit = () => true): Task<T> {
47
+ const controller = new AbortController();
48
+ const task: Task<T> = { controller, waiters: 0, promise: Promise.resolve(state.snapshot) };
49
+ state.attemptedAt = now();
50
+ task.promise = (async () => {
51
+ let timedOut = false;
52
+ const timer = setTimeout(() => { timedOut = true; controller.abort(); }, method === "POST" ? 35_000 : 5_000);
53
+ let status: number | undefined;
54
+ let result: MagpieSnapshot<T>;
55
+ try {
56
+ const response = await fetcher(`${request.root}/v1/magpie/${path}`, {
57
+ method, headers: request.headers, signal: controller.signal, redirect: "error",
58
+ });
59
+ status = response.status;
60
+ if (!response.ok) throw new Error();
61
+ const data = parse(await response.json());
62
+ result = { data, fetchedAt: now() };
63
+ } catch {
64
+ const hidden = status === 401 || status === 403;
65
+ result = { ...(hidden ? {} : state.snapshot), status,
66
+ error: status && status >= 200 && status < 300 ? "Magpie 返回的数据无法解析,保留已有读数。"
67
+ : status ? `Magpie 查询失败(HTTP ${status})。` : "Magpie 查询失败或超时,保留已有读数。" };
68
+ } finally { clearTimeout(timer); }
69
+ if (!valid()) return {};
70
+ if ((controller.signal.aborted && !timedOut) || !canCommit()) return state.snapshot;
71
+ state.snapshot = result;
72
+ state.blocked = status === 401 || status === 403 || status === 404 || status === 405;
73
+ if (state === cards) for (const listener of listeners) listener();
74
+ return result;
75
+ })().finally(() => { if (state.task === task) state.task = undefined; });
76
+ state.task = task;
77
+ return task;
78
+ }
79
+
80
+ return {
81
+ valid,
82
+ subscribe(listener: () => void): () => void {
83
+ listeners.add(listener);
84
+ return () => { listeners.delete(listener); };
85
+ },
86
+ status: (id: string): MagpieSnapshot<MagpieStatusline> => valid() ? session(id).snapshot : {},
87
+ cards: (): MagpieSnapshot<MagpieCard[]> => valid() ? cards.snapshot : {},
88
+ async readStatus(id: string, request: MagpieRequest,
89
+ options: { force?: boolean; automatic?: boolean; signal?: AbortSignal } = {}): Promise<MagpieSnapshot<MagpieStatusline>> {
90
+ if (!valid() || options.signal?.aborted) return {};
91
+ const state = session(id);
92
+ if (state.task?.controller.signal.aborted) state.task = undefined;
93
+ if (state.task) return wait(state.task, options.signal);
94
+ if (options.automatic && (statusBlocked ||
95
+ (state.attemptedAt !== undefined && now() - state.attemptedAt < TTL))) return state.snapshot;
96
+ if (!options.force && state.snapshot.fetchedAt !== undefined && now() - state.snapshot.fetchedAt < TTL)
97
+ return state.snapshot;
98
+ const task = start(state, request, `statusline?format=json&session=${encodeURIComponent(id)}`, parseStatusline, "GET");
99
+ const result = await wait(task, options.signal);
100
+ statusBlocked = state.blocked === true;
101
+ if (result.status === 401 || result.status === 403)
102
+ for (const other of sessions.values()) other.snapshot = { error: result.error, status: result.status };
103
+ return result;
104
+ },
105
+ readCards(request: MagpieRequest, options: { force?: boolean; automatic?: boolean; signal?: AbortSignal } = {}): Promise<MagpieSnapshot<MagpieCard[]>> {
106
+ if (!valid() || options.signal?.aborted) return Promise.resolve({});
107
+ if (refresh?.task.controller.signal.aborted) refresh = undefined;
108
+ if (cards.task?.controller.signal.aborted) cards.task = undefined;
109
+ if (refresh) return wait(refresh.task, options.signal);
110
+ if (cards.task) return wait(cards.task, options.signal);
111
+ if (options.automatic && (cards.blocked ||
112
+ (cards.attemptedAt !== undefined && now() - cards.attemptedAt < TTL))) return Promise.resolve(cards.snapshot);
113
+ if (!options.force && cards.snapshot.fetchedAt !== undefined && now() - cards.snapshot.fetchedAt < TTL)
114
+ return Promise.resolve(cards.snapshot);
115
+ const revision = cardsRevision;
116
+ return wait(start(cards, request, "quotas/cards", parseCards, "GET", () => revision === cardsRevision), options.signal);
117
+ },
118
+ refreshCards(request: MagpieRequest, target?: RefreshTarget, signal?: AbortSignal): Promise<MagpieSnapshot<MagpieCard[]>> {
119
+ if (!valid() || signal?.aborted) return Promise.resolve({});
120
+ if (refresh?.task.controller.signal.aborted) refresh = undefined;
121
+ if (refresh) {
122
+ const current = refresh.target;
123
+ if (!current || (target && current.provider === target.provider &&
124
+ (!current.user || current.user.toLowerCase() === target.user?.toLowerCase()))) return wait(refresh.task, signal);
125
+ return Promise.resolve({ ...cards.snapshot, error: "另一范围的额度刷新正在进行,请完成后再操作。" });
126
+ }
127
+ cardsRevision++;
128
+ const query = new URLSearchParams();
129
+ if (target) {
130
+ query.set("provider", target.provider);
131
+ if (target.user) query.set("user", target.user);
132
+ }
133
+ const task = start(cards, request, `quotas/refresh${query.size ? `?${query}` : ""}`, parseCards, "POST");
134
+ refresh = { target, task };
135
+ void task.promise.finally(() => { if (refresh?.task === task) refresh = undefined; });
136
+ return wait(task, signal);
137
+ },
138
+ };
139
+ }
140
+
141
+ function wait<T>(task: Task<T>, signal?: AbortSignal): Promise<MagpieSnapshot<T>> {
142
+ task.waiters++;
143
+ return new Promise((resolve) => {
144
+ let done = false;
145
+ const finish = (result: MagpieSnapshot<T>) => {
146
+ if (done) return;
147
+ done = true;
148
+ signal?.removeEventListener("abort", abort);
149
+ task.waiters--;
150
+ resolve(result);
151
+ };
152
+ const abort = () => {
153
+ finish({});
154
+ if (task.waiters === 0) task.controller.abort();
155
+ };
156
+ task.promise.then(finish, () => finish({ error: "Magpie 查询失败。" }));
157
+ if (signal?.aborted) abort();
158
+ else signal?.addEventListener("abort", abort, { once: true });
159
+ });
160
+ }
161
+
162
+ export type MagpieService = ReturnType<typeof createMagpieService>;
163
+ const SHARED = Symbol.for("pi-tsgw:magpie-state");
164
+ /** 用目录服务对象本身作为作用域,沿用其跨工厂和凭据切换失效语义。 */
165
+ export function getMagpieService(catalog: GatewayCatalogService): MagpieService {
166
+ const globals = globalThis as typeof globalThis & { [SHARED]?: WeakMap<GatewayCatalogService, MagpieService> };
167
+ const services = globals[SHARED] ??= new WeakMap();
168
+ let service = services.get(catalog);
169
+ if (!service) services.set(catalog, service = createMagpieService(catalog));
170
+ return service;
171
+ }
@@ -0,0 +1,68 @@
1
+ import type { MagpieCard, MagpieWindow } from "./data.ts";
2
+ import { groupCards } from "./view.ts";
3
+
4
+ const SHORT_NAMES: Readonly<Record<string, string>> = {
5
+ "OpenAI / Codex": "OpenAI",
6
+ "Anthropic / Claude": "Claude",
7
+ "Moonshot / Kimi": "Kimi",
8
+ };
9
+
10
+ interface Reading {
11
+ percent?: number;
12
+ balances: string[];
13
+ stale: boolean;
14
+ }
15
+
16
+ /** 同账户取瓶颈窗口,同厂商取已知账户最大值;金额只展示,不相加或折算。 */
17
+ export function quotaSummary(cards: readonly MagpieCard[]): string {
18
+ const groups = groupCards(cards);
19
+ if (!groups.length) return "剩余:?";
20
+ return `剩余:${groups.map(group => {
21
+ const readings = group.cards.filter(card => !card.held && !card.needsAccessKey).map(cardReading);
22
+ const known = readings.filter(reading => reading.percent !== undefined || reading.balances.length);
23
+ // 当前读数优先,避免一个失败账户的旧高值盖过正常账户的新低值。
24
+ const fresh = known.filter(reading => !reading.stale);
25
+ const usable = fresh.length ? fresh : known;
26
+ const percentages = usable.flatMap(reading => reading.percent === undefined ? [] : [reading.percent]);
27
+ const parts: string[] = [];
28
+ if (percentages.length) {
29
+ const best = Math.max(...percentages);
30
+ parts.push(best === Infinity ? "∞" : `${Math.round(best * 100) / 100}%`);
31
+ } else parts.push(...new Set(usable.flatMap(reading => reading.balances)));
32
+ if (!parts.length) parts.push("?");
33
+ else if (readings.some(reading => reading.percent === undefined && !reading.balances.length)) parts.push("?");
34
+ const stale = usable.length && !fresh.length ? "(旧)" : "";
35
+ return `${SHORT_NAMES[group.name] ?? group.name} ${parts.join("/")}${stale}`;
36
+ }).join(" · ")}`.replace(/[\r\n]+/g, " ");
37
+ }
38
+
39
+ function cardReading(card: MagpieCard): Reading {
40
+ const balances: string[] = [];
41
+ if (card.balance?.trim()) balances.push(card.balance.trim());
42
+ // 独立图片通道与额外消费行不是账户的共同额度限制。
43
+ const windows = (card.windows ?? []).filter(window => !window.lane && !window.extra && !window.text);
44
+ const percentages: number[] = [];
45
+ let unknown = false;
46
+ for (const window of windows) {
47
+ if (window.balance !== undefined) balances.push(`${window.balance}${window.unit ? ` ${window.unit}` : ""}`);
48
+ const percent = windowRemaining(window);
49
+ if (percent !== undefined) percentages.push(percent);
50
+ else if (window.balance === undefined) unknown = true;
51
+ }
52
+ return {
53
+ percent: !unknown && percentages.length ? Math.min(...percentages) : undefined,
54
+ balances,
55
+ stale: Boolean(card.error?.trim() || card.asOf?.trim()),
56
+ };
57
+ }
58
+
59
+ function windowRemaining(window: MagpieWindow): number | undefined {
60
+ if (window.unlimited) return Infinity;
61
+ // 没有总量的钱包 used/remaining 不是百分比。
62
+ if (window.balance !== undefined && !(window.limit !== undefined && window.limit > 0)) return;
63
+ const used = window.used;
64
+ if (used !== undefined && (used < 0 || used > 100)) return;
65
+ const remaining = window.remaining ?? (used === undefined ? undefined : 100 - used);
66
+ if (remaining === undefined || remaining < 0 || remaining > 100) return;
67
+ return remaining;
68
+ }