pi-tsgw 3.4.1 → 3.5.1
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 +3 -0
- package/extensions/magpie/controller.ts +164 -0
- package/extensions/magpie/data.ts +385 -0
- package/extensions/magpie/service.ts +181 -0
- package/extensions/magpie/summary.ts +43 -0
- package/extensions/magpie/ui.ts +79 -0
- package/extensions/magpie/view.ts +273 -0
- package/extensions/models/gateway-catalog-recovery.ts +13 -9
- package/extensions/models/gateway-catalog-service.ts +65 -62
- package/extensions/models/gateway-catalog-shared.ts +56 -0
- package/extensions/models/gateway-catalog.ts +43 -62
- package/extensions/models/gateway-model-list.ts +20 -0
- package/extensions/provider/catalog-state.ts +7 -1
- package/extensions/provider/index.ts +9 -4
- package/package.json +2 -2
- package/skills/tsgw-mk-docs/SKILL.md +5 -5
- package/skills/tsgw-mk-docs/SOURCE.md +4 -5
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 秒复用窗口;切换会话或模型保留已有读数,空闲不轮询,不自动刷新供应商。底部仅显示 OpenAI 的最高已知剩余比例:先取每个账户共同限制窗口中的最低值,再取可用 OpenAI 账户的最高值;无有效读数时隐藏额度项,有效旧读数标记为旧。其他厂商及余额在详情中查看,不跨账户相加。完整窗口、读数时间和会话状态仍可在 `/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,164 @@
|
|
|
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;
|
|
122
|
+
const summary = quotaSummary(snapshot.data);
|
|
123
|
+
if (!summary) return;
|
|
124
|
+
return snapshot.error ? `${summary}(旧)` : summary;
|
|
125
|
+
},
|
|
126
|
+
async handle(choice: string, ctx: ExtensionCommandContext): Promise<void> {
|
|
127
|
+
if (![STATUS, CARDS, RELOAD, REFRESH].includes(choice) || !ctx.hasUI) return;
|
|
128
|
+
const ui = ctx.ui;
|
|
129
|
+
const id = ctx.sessionManager.getSessionId();
|
|
130
|
+
const registry = ctx.modelRegistry;
|
|
131
|
+
const signal = lifetime.signal;
|
|
132
|
+
try {
|
|
133
|
+
const connection = await connect(registry, signal);
|
|
134
|
+
if (!connection) return;
|
|
135
|
+
const { service, request } = connection;
|
|
136
|
+
if (choice === STATUS) {
|
|
137
|
+
const snapshot = await service.readStatus(id, request, { force: true, signal });
|
|
138
|
+
if (signal.aborted || !service.valid()) return;
|
|
139
|
+
options.onChange();
|
|
140
|
+
await showStatus(ui, snapshot, signal);
|
|
141
|
+
return;
|
|
142
|
+
}
|
|
143
|
+
let snapshot = await service.readCards(request, { force: choice === RELOAD, signal });
|
|
144
|
+
if (signal.aborted || !service.valid()) return;
|
|
145
|
+
if (choice === REFRESH) {
|
|
146
|
+
if (snapshot.status === 401 || snapshot.status === 403) {
|
|
147
|
+
ui.notify(snapshot.error!, "error");
|
|
148
|
+
return;
|
|
149
|
+
}
|
|
150
|
+
const selection = await chooseRefresh(ui, snapshot.data ?? [], signal);
|
|
151
|
+
if (!selection || signal.aborted || !service.valid()) return;
|
|
152
|
+
const before = snapshot.data;
|
|
153
|
+
snapshot = await service.refreshCards(request, selection.target, signal);
|
|
154
|
+
if (signal.aborted || !service.valid()) return;
|
|
155
|
+
if (!snapshot.error) ui.notify(unchangedReadTimes(before, snapshot.data)
|
|
156
|
+
? "刷新请求已返回,读数时间未变化或未提供。" : "刷新请求已返回,请核对各卡片读数时间。", "info");
|
|
157
|
+
}
|
|
158
|
+
await showCards(ui, snapshot, signal);
|
|
159
|
+
} catch (error) {
|
|
160
|
+
if (!signal.aborted) ui.notify(error instanceof Error ? error.message : "Magpie 操作失败。", "error");
|
|
161
|
+
}
|
|
162
|
+
},
|
|
163
|
+
};
|
|
164
|
+
}
|
|
@@ -0,0 +1,385 @@
|
|
|
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
|
+
* 额度是参考快照:厂商身份和可解释读数是核心,附加展示/辅助字段允许陈旧、
|
|
12
|
+
* 缺失或类型漂移。入口只做一次校验,已知字段异常时局部剔除或把读数降为未知,
|
|
13
|
+
* 无法识别 provider 的卡片跳过;顶层列表缺失或不可识别仍明确失败,避免无效
|
|
14
|
+
* 响应冒充空成功。合法对象保持原引用,需要修改时最小 copy-on-write,未知字段
|
|
15
|
+
* 随浅拷贝保留引用;不补窗口、不补读数,也不把缺失值当成 0 或 100%。
|
|
16
|
+
*/
|
|
17
|
+
|
|
18
|
+
/** 卡片已知字段均可缺失;未知字段通过索引签名原样保留。 */
|
|
19
|
+
export interface MagpieWindow extends Record<string, unknown> {
|
|
20
|
+
name?: string;
|
|
21
|
+
/** 普通窗口的已用百分比;文本行、无总量余额的占位值不是读数。 */
|
|
22
|
+
used?: number;
|
|
23
|
+
/** 厂商给出的展示文本,例如 “1.2k / 3k”;有值时优先展示。 */
|
|
24
|
+
display?: string;
|
|
25
|
+
text?: boolean;
|
|
26
|
+
unlimited?: boolean;
|
|
27
|
+
resetsAt?: string;
|
|
28
|
+
/** 额度报告(statusline 账户)窗口的计算剩余百分比;卡片窗口没有此字段。 */
|
|
29
|
+
remaining?: number;
|
|
30
|
+
amount?: number;
|
|
31
|
+
limit?: number;
|
|
32
|
+
unit?: string;
|
|
33
|
+
/** 窗口级钱包/积分余额;有值时 `used` 未必是占比。 */
|
|
34
|
+
balance?: number;
|
|
35
|
+
spent?: number;
|
|
36
|
+
spentSince?: string;
|
|
37
|
+
runsOutAt?: string;
|
|
38
|
+
runsOut?: number;
|
|
39
|
+
resetSecs?: number;
|
|
40
|
+
pool?: string;
|
|
41
|
+
lane?: string;
|
|
42
|
+
family?: string;
|
|
43
|
+
holdsWhy?: string;
|
|
44
|
+
credits?: boolean;
|
|
45
|
+
extra?: boolean;
|
|
46
|
+
capped?: boolean;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
export interface MagpieBalancePart extends Record<string, unknown> {
|
|
50
|
+
text: string;
|
|
51
|
+
label?: string;
|
|
52
|
+
percent?: number;
|
|
53
|
+
error?: string;
|
|
54
|
+
expires?: string;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/** 用户自填余额减去网关已计费的估算值,不是厂商读数。 */
|
|
58
|
+
export interface MagpieEstimate extends Record<string, unknown> {
|
|
59
|
+
set: number;
|
|
60
|
+
at?: string;
|
|
61
|
+
spent: number;
|
|
62
|
+
currency?: string;
|
|
63
|
+
rate?: number;
|
|
64
|
+
left?: number | null;
|
|
65
|
+
from?: string;
|
|
66
|
+
next?: string;
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
export interface MagpieResetCard extends Record<string, unknown> {
|
|
70
|
+
until?: string;
|
|
71
|
+
window?: string;
|
|
72
|
+
id?: string;
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
/** 尚持有的重置权益;列出不代表可以消费,消费入口不属于本扩展。 */
|
|
76
|
+
export interface MagpieResetCredits extends Record<string, unknown> {
|
|
77
|
+
count: number;
|
|
78
|
+
until?: string;
|
|
79
|
+
byWindow?: boolean;
|
|
80
|
+
fiveHour?: number;
|
|
81
|
+
weekly?: number;
|
|
82
|
+
team?: boolean;
|
|
83
|
+
each?: MagpieResetCard[];
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
/**
|
|
87
|
+
* 一张额度卡片。`provider` 是 Magpie 的渠道标识(订阅常是 Agent ID),
|
|
88
|
+
* 不必等于厂商名;`from` 是远程 Magpie 名称。同一 `provider/user`
|
|
89
|
+
* 仍可能对应多张独立卡片,调用方不得据此覆盖或相加。
|
|
90
|
+
* `provider` 缺失或不可识别的卡片在入口跳过;其余已知字段异常只做局部降级。
|
|
91
|
+
*/
|
|
92
|
+
export interface MagpieCard extends Record<string, unknown> {
|
|
93
|
+
provider: string;
|
|
94
|
+
name?: string;
|
|
95
|
+
user?: string;
|
|
96
|
+
plan?: string;
|
|
97
|
+
from?: string;
|
|
98
|
+
kind?: string;
|
|
99
|
+
readAt?: string;
|
|
100
|
+
asOf?: string;
|
|
101
|
+
error?: string;
|
|
102
|
+
balance?: string;
|
|
103
|
+
/** 协议未加 omitempty,窗口未提供时可能为 null;null 与缺失同为“未提供”,不是格式错误。 */
|
|
104
|
+
windows?: MagpieWindow[] | null;
|
|
105
|
+
alias?: string;
|
|
106
|
+
seat?: string;
|
|
107
|
+
sharedBalance?: string;
|
|
108
|
+
balanceSplit?: MagpieBalancePart[];
|
|
109
|
+
/** 与 balanceSplit 同结构的另一组分项(用户书写的多段余额),不得重复相加。 */
|
|
110
|
+
balanceParts?: MagpieBalancePart[];
|
|
111
|
+
estimate?: MagpieEstimate;
|
|
112
|
+
resets?: MagpieResetCredits;
|
|
113
|
+
readDeferred?: boolean;
|
|
114
|
+
until?: string;
|
|
115
|
+
renew?: string;
|
|
116
|
+
lastServedAt?: string;
|
|
117
|
+
held?: boolean;
|
|
118
|
+
last?: boolean;
|
|
119
|
+
pluginError?: boolean;
|
|
120
|
+
needsAccessKey?: boolean;
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
/**
|
|
124
|
+
* statusline 响应。`text`/`model` 只是展示信息,缺失或类型异常按未提供处理;
|
|
125
|
+
* `accounts` 是额度报告口径的卡片列表,缺失或非数组仍视为顶层形状错误。
|
|
126
|
+
* `model` 可能回退为请求名,不证明实际成员。
|
|
127
|
+
*/
|
|
128
|
+
export interface MagpieStatusline extends Record<string, unknown> {
|
|
129
|
+
text?: string;
|
|
130
|
+
model?: string;
|
|
131
|
+
accounts: MagpieCard[];
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
/** 形状错误;消息只说明位置与字段,不回显原始值。 */
|
|
135
|
+
export class MagpieDataError extends Error {
|
|
136
|
+
constructor(message: string) {
|
|
137
|
+
super(message);
|
|
138
|
+
this.name = "MagpieDataError";
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
function invalid(where: string, detail: string): never {
|
|
143
|
+
throw new MagpieDataError(`Magpie 数据无效:${where}${detail}`);
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
function asRecord(value: unknown, where: string): Record<string, unknown> {
|
|
147
|
+
if (!isRecord(value)) invalid(where, "必须是 JSON 对象。");
|
|
148
|
+
return value;
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
152
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
function isFiniteNumber(value: unknown): value is number {
|
|
156
|
+
return typeof value === "number" && Number.isFinite(value);
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
/**
|
|
160
|
+
* 惰性 copy-on-write:只有确实需要剔除或替换字段时才复制对象。
|
|
161
|
+
* 浅拷贝保留未知字段及其引用;没有改动时调用方继续返回原对象。
|
|
162
|
+
*/
|
|
163
|
+
function editor(record: Record<string, unknown>) {
|
|
164
|
+
let copy: Record<string, unknown> | undefined;
|
|
165
|
+
const current = (): Record<string, unknown> => copy ?? record;
|
|
166
|
+
return {
|
|
167
|
+
value: current,
|
|
168
|
+
changed: (): boolean => copy !== undefined,
|
|
169
|
+
drop(key: string): void {
|
|
170
|
+
if (!Object.hasOwn(current(), key)) return;
|
|
171
|
+
copy ??= { ...record };
|
|
172
|
+
delete copy[key];
|
|
173
|
+
},
|
|
174
|
+
set(key: string, value: unknown): void {
|
|
175
|
+
if (Object.hasOwn(current(), key) && current()[key] === value) return;
|
|
176
|
+
copy ??= { ...record };
|
|
177
|
+
copy[key] = value;
|
|
178
|
+
},
|
|
179
|
+
};
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
function dropWrongStrings(target: ReturnType<typeof editor>, keys: readonly string[]): void {
|
|
183
|
+
for (const key of keys) {
|
|
184
|
+
const value = target.value()[key];
|
|
185
|
+
if (value !== undefined && typeof value !== "string") target.drop(key);
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
function dropWrongNumbers(target: ReturnType<typeof editor>, keys: readonly string[]): void {
|
|
190
|
+
for (const key of keys) {
|
|
191
|
+
const value = target.value()[key];
|
|
192
|
+
if (value !== undefined && !isFiniteNumber(value)) target.drop(key);
|
|
193
|
+
}
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
function dropWrongBooleans(target: ReturnType<typeof editor>, keys: readonly string[]): void {
|
|
197
|
+
for (const key of keys) {
|
|
198
|
+
const value = target.value()[key];
|
|
199
|
+
if (value !== undefined && typeof value !== "boolean") target.drop(key);
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
const WINDOW_STRINGS = ["name", "display", "resetsAt", "unit", "pool", "lane", "family", "holdsWhy", "spentSince", "runsOutAt"] as const;
|
|
204
|
+
const WINDOW_NUMBERS = ["used", "remaining", "amount", "limit", "balance", "spent", "runsOut", "resetSecs"] as const;
|
|
205
|
+
const WINDOW_BOOLEANS = ["text", "unlimited", "credits", "extra", "capped"] as const;
|
|
206
|
+
|
|
207
|
+
function sanitizeWindow(value: unknown): MagpieWindow {
|
|
208
|
+
// 窗口本身无法识别时保留一个未知窗口占位,避免汇总把剩余窗口当成完整额度。
|
|
209
|
+
if (!isRecord(value)) return {};
|
|
210
|
+
const target = editor(value);
|
|
211
|
+
const original = target.value();
|
|
212
|
+
// 文本行、无限额、独立通道、额外消费和钱包都会改变 used 的语义。标记存在但
|
|
213
|
+
// 类型异常时不能只删标记,否则 used=0 可能被误算成剩余 100%;清空读数降为未知。
|
|
214
|
+
const readingsUnknown =
|
|
215
|
+
(original.text !== undefined && typeof original.text !== "boolean") ||
|
|
216
|
+
(original.unlimited !== undefined && typeof original.unlimited !== "boolean") ||
|
|
217
|
+
(original.extra !== undefined && typeof original.extra !== "boolean") ||
|
|
218
|
+
(original.lane !== undefined && typeof original.lane !== "string") ||
|
|
219
|
+
(original.balance !== undefined && !isFiniteNumber(original.balance));
|
|
220
|
+
dropWrongStrings(target, WINDOW_STRINGS);
|
|
221
|
+
dropWrongNumbers(target, WINDOW_NUMBERS);
|
|
222
|
+
dropWrongBooleans(target, WINDOW_BOOLEANS);
|
|
223
|
+
if (readingsUnknown) {
|
|
224
|
+
target.drop("used");
|
|
225
|
+
target.drop("remaining");
|
|
226
|
+
}
|
|
227
|
+
return target.value() as MagpieWindow;
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
function sanitizeWindows(value: unknown): { value: MagpieWindow[] | null | undefined; changed: boolean } {
|
|
231
|
+
// null 是协议可能输出的“未提供窗口”,保留原值,不改成 []、也不当作满额。
|
|
232
|
+
if (value === undefined || value === null) return { value, changed: false };
|
|
233
|
+
if (!Array.isArray(value)) return { value: undefined, changed: true };
|
|
234
|
+
let changed = false;
|
|
235
|
+
const windows = value.map(item => {
|
|
236
|
+
const window = sanitizeWindow(item);
|
|
237
|
+
if (window !== item) changed = true;
|
|
238
|
+
return window;
|
|
239
|
+
});
|
|
240
|
+
return { value: changed ? windows : value as MagpieWindow[], changed };
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
function sanitizeBalanceParts(value: unknown): MagpieBalancePart[] | undefined {
|
|
244
|
+
if (value === undefined) return;
|
|
245
|
+
if (!Array.isArray(value)) return;
|
|
246
|
+
let changed = false;
|
|
247
|
+
const parts: MagpieBalancePart[] = [];
|
|
248
|
+
for (const item of value) {
|
|
249
|
+
if (!isRecord(item) || typeof item.text !== "string") {
|
|
250
|
+
changed = true;
|
|
251
|
+
continue;
|
|
252
|
+
}
|
|
253
|
+
const target = editor(item);
|
|
254
|
+
dropWrongStrings(target, ["label", "error", "expires"]);
|
|
255
|
+
dropWrongNumbers(target, ["percent"]);
|
|
256
|
+
if (target.changed()) changed = true;
|
|
257
|
+
parts.push(target.value() as MagpieBalancePart);
|
|
258
|
+
}
|
|
259
|
+
return changed ? parts : value as MagpieBalancePart[];
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
function sanitizeEstimate(value: unknown): MagpieEstimate | undefined {
|
|
263
|
+
// set/spent 是估算可解释的最小前提;缺失或异常时整项降级,不编造读数。
|
|
264
|
+
if (!isRecord(value) || !isFiniteNumber(value.set) || !isFiniteNumber(value.spent)) return;
|
|
265
|
+
const target = editor(value);
|
|
266
|
+
dropWrongNumbers(target, ["rate"]);
|
|
267
|
+
dropWrongStrings(target, ["at", "currency", "from", "next"]);
|
|
268
|
+
const left = target.value().left;
|
|
269
|
+
if (left !== undefined && left !== null && !isFiniteNumber(left)) target.drop("left");
|
|
270
|
+
return target.value() as MagpieEstimate;
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
function sanitizeResets(value: unknown): MagpieResetCredits | undefined {
|
|
274
|
+
// count 是重置权益条目的核心;不可解释时整项降级,不凭 each 长度补 count。
|
|
275
|
+
if (!isRecord(value) || !isFiniteNumber(value.count)) return;
|
|
276
|
+
const target = editor(value);
|
|
277
|
+
dropWrongStrings(target, ["until"]);
|
|
278
|
+
dropWrongNumbers(target, ["fiveHour", "weekly"]);
|
|
279
|
+
dropWrongBooleans(target, ["byWindow", "team"]);
|
|
280
|
+
const each = target.value().each;
|
|
281
|
+
if (each !== undefined) {
|
|
282
|
+
if (!Array.isArray(each)) target.drop("each");
|
|
283
|
+
else {
|
|
284
|
+
let changed = false;
|
|
285
|
+
const cards: MagpieResetCard[] = [];
|
|
286
|
+
for (const item of each) {
|
|
287
|
+
if (!isRecord(item)) {
|
|
288
|
+
changed = true;
|
|
289
|
+
continue;
|
|
290
|
+
}
|
|
291
|
+
const card = editor(item);
|
|
292
|
+
dropWrongStrings(card, ["until", "window", "id"]);
|
|
293
|
+
if (card.changed()) changed = true;
|
|
294
|
+
cards.push(card.value() as MagpieResetCard);
|
|
295
|
+
}
|
|
296
|
+
if (changed) target.set("each", cards);
|
|
297
|
+
}
|
|
298
|
+
}
|
|
299
|
+
return target.value() as MagpieResetCredits;
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
const CARD_STRINGS = ["name", "user", "plan", "from", "kind", "readAt", "asOf", "error", "balance", "alias", "seat", "sharedBalance", "until", "renew", "lastServedAt"] as const;
|
|
303
|
+
const CARD_BOOLEANS = ["readDeferred", "held", "last", "pluginError", "needsAccessKey"] as const;
|
|
304
|
+
const MALFORMED_READING = "记录字段异常,读数按旧读数处理。";
|
|
305
|
+
|
|
306
|
+
function replaceNested(target: ReturnType<typeof editor>, key: string, original: unknown, next: unknown): void {
|
|
307
|
+
if (original === undefined) return;
|
|
308
|
+
if (next === undefined) target.drop(key);
|
|
309
|
+
else if (next !== original) target.set(key, next);
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
function sanitizeCard(value: unknown): MagpieCard | undefined {
|
|
313
|
+
// provider 是卡片身份;无法识别时无法分组、刷新或解释读数,只跳过这一条。
|
|
314
|
+
if (!isRecord(value) || typeof value.provider !== "string" || !value.provider.trim()) return;
|
|
315
|
+
const target = editor(value);
|
|
316
|
+
const original = target.value();
|
|
317
|
+
const errorMalformed = original.error !== undefined && typeof original.error !== "string";
|
|
318
|
+
const asOfMalformed = original.asOf !== undefined && typeof original.asOf !== "string";
|
|
319
|
+
const heldMalformed = original.held !== undefined && typeof original.held !== "boolean";
|
|
320
|
+
const accessKeyMalformed = original.needsAccessKey !== undefined && typeof original.needsAccessKey !== "boolean";
|
|
321
|
+
dropWrongStrings(target, CARD_STRINGS);
|
|
322
|
+
dropWrongBooleans(target, CARD_BOOLEANS);
|
|
323
|
+
// error/asOf 是“读数可能陈旧”的语义标记;类型异常时保留一个通用错误标记,
|
|
324
|
+
// 避免删掉后旧读数被当成新鲜读数展示。
|
|
325
|
+
if (errorMalformed || (asOfMalformed && original.error === undefined)) target.set("error", MALFORMED_READING);
|
|
326
|
+
// 派发/密钥状态无法解释时保留参考读数并标记不确定,不能编造停派或缺密钥事实。
|
|
327
|
+
if (heldMalformed || accessKeyMalformed)
|
|
328
|
+
target.set("error", "账户状态字段异常,额度仅供参考。");
|
|
329
|
+
|
|
330
|
+
if (original.windows !== undefined) {
|
|
331
|
+
const windows = sanitizeWindows(original.windows);
|
|
332
|
+
if (windows.value === undefined) target.drop("windows");
|
|
333
|
+
else if (windows.changed) target.set("windows", windows.value);
|
|
334
|
+
}
|
|
335
|
+
replaceNested(target, "balanceSplit", original.balanceSplit, sanitizeBalanceParts(original.balanceSplit));
|
|
336
|
+
replaceNested(target, "balanceParts", original.balanceParts, sanitizeBalanceParts(original.balanceParts));
|
|
337
|
+
replaceNested(target, "estimate", original.estimate, sanitizeEstimate(original.estimate));
|
|
338
|
+
replaceNested(target, "resets", original.resets, sanitizeResets(original.resets));
|
|
339
|
+
return target.value() as MagpieCard;
|
|
340
|
+
}
|
|
341
|
+
|
|
342
|
+
/**
|
|
343
|
+
* 解析 `/v1/magpie/quotas/cards` 响应。无法识别 provider 的卡片跳过;其余卡片
|
|
344
|
+
* 局部降级。全部合法时返回原始数组及卡片引用,否则返回保留原引用的新数组。
|
|
345
|
+
*/
|
|
346
|
+
export function parseCards(value: unknown): MagpieCard[] {
|
|
347
|
+
const payload = asRecord(value, "cards 响应");
|
|
348
|
+
if (!Array.isArray(payload.data)) invalid("cards 响应", "data 必须是数组。");
|
|
349
|
+
let changed = false;
|
|
350
|
+
const cards: MagpieCard[] = [];
|
|
351
|
+
for (const item of payload.data) {
|
|
352
|
+
const card = sanitizeCard(item);
|
|
353
|
+
if (!card) {
|
|
354
|
+
changed = true;
|
|
355
|
+
continue;
|
|
356
|
+
}
|
|
357
|
+
if (card !== item) changed = true;
|
|
358
|
+
cards.push(card);
|
|
359
|
+
}
|
|
360
|
+
return changed ? cards : payload.data as MagpieCard[];
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
/** 解析 `/v1/magpie/statusline?format=json` 响应;展示字段降级,账户按保真卡片处理。 */
|
|
364
|
+
export function parseStatusline(value: unknown): MagpieStatusline {
|
|
365
|
+
const payload = asRecord(value, "statusline 响应");
|
|
366
|
+
if (!Array.isArray(payload.accounts)) invalid("statusline 响应", "accounts 必须是数组。");
|
|
367
|
+
const target = editor(payload);
|
|
368
|
+
for (const key of ["text", "model"] as const) {
|
|
369
|
+
const current = target.value()[key];
|
|
370
|
+
if (current !== undefined && typeof current !== "string") target.drop(key);
|
|
371
|
+
}
|
|
372
|
+
let accountsChanged = false;
|
|
373
|
+
const accounts: MagpieCard[] = [];
|
|
374
|
+
for (const item of payload.accounts) {
|
|
375
|
+
const card = sanitizeCard(item);
|
|
376
|
+
if (!card) {
|
|
377
|
+
accountsChanged = true;
|
|
378
|
+
continue;
|
|
379
|
+
}
|
|
380
|
+
if (card !== item) accountsChanged = true;
|
|
381
|
+
accounts.push(card);
|
|
382
|
+
}
|
|
383
|
+
if (accountsChanged) target.set("accounts", accounts);
|
|
384
|
+
return target.value() as MagpieStatusline;
|
|
385
|
+
}
|