@sixzjd/dsh-workbuddy-connect 0.0.0-stage → 0.3.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/LICENSE +21 -0
- package/README.en.md +162 -0
- package/README.md +202 -2
- package/assets/icon.svg +12 -0
- package/client.js +770 -0
- package/cordis.patch.yml +13 -0
- package/lib/adapter.js +340 -0
- package/lib/atrest.js +382 -0
- package/lib/auth.js +540 -0
- package/lib/catalog.js +226 -0
- package/lib/identity.js +309 -0
- package/lib/index.js +879 -0
- package/lib/paths.js +156 -0
- package/lib/shim.js +531 -0
- package/lib/updates.js +325 -0
- package/lib/upstream.js +1918 -0
- package/lib/variants.js +91 -0
- package/locale/en.json +6 -0
- package/locale/zh.json +6 -0
- package/package.json +59 -4
package/lib/upstream.js
ADDED
|
@@ -0,0 +1,1918 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* WorkBuddy upstream client: chat streaming, token refresh, model catalog and
|
|
3
|
+
* credit balance.
|
|
4
|
+
*
|
|
5
|
+
* Two deployments live behind one set of function names:
|
|
6
|
+
*
|
|
7
|
+
* | | CN | International |
|
|
8
|
+
* |---|---|---|
|
|
9
|
+
* | chat base | `https://copilot.tencent.com` | `https://www.workbuddy.ai` |
|
|
10
|
+
* | billing base | `https://www.codebuddy.cn` | `https://www.workbuddy.ai` |
|
|
11
|
+
* | catalog | `/console/enterprises/personal/models` | `/v3/config` |
|
|
12
|
+
* | chat path | `/v2/chat/completions` | `/console/chat/completions` → `/v2/chat/completions` |
|
|
13
|
+
*
|
|
14
|
+
* Everything that varies between them is a function of the credential's
|
|
15
|
+
* *realm*, never a branch on a flag passed down from the UI — so a third
|
|
16
|
+
* deployment would be a data change rather than a refactor.
|
|
17
|
+
*
|
|
18
|
+
* @module dsh-workbuddy-connect/upstream
|
|
19
|
+
*/
|
|
20
|
+
import { createHash, randomBytes } from 'node:crypto'
|
|
21
|
+
import { appUserAgent, chatUserAgent, fallbackChatIdentity, resolveAppVersion, resolveChatIdentity } from './identity.js'
|
|
22
|
+
|
|
23
|
+
/** WorkBuddy region selected by the credential's login domain. */
|
|
24
|
+
export const REGIONS = ['cn', 'global']
|
|
25
|
+
|
|
26
|
+
/** Upstream failure classes the shim maps onto distinct HTTP answers. */
|
|
27
|
+
export const UPSTREAM_ERROR_KINDS = ['hard_credit', 'soft_rate', 'session_dead', 'account_restricted', 'not_found', 'server', 'client']
|
|
28
|
+
|
|
29
|
+
const CN_CHAT_BASE = 'https://copilot.tencent.com'
|
|
30
|
+
const CN_BILLING_BASE = 'https://www.codebuddy.cn'
|
|
31
|
+
const GLOBAL_BASE = 'https://www.workbuddy.ai'
|
|
32
|
+
|
|
33
|
+
/**
|
|
34
|
+
* The domain the international gateway expects in `X-Domain`.
|
|
35
|
+
*
|
|
36
|
+
* A fixed value rather than the signed-in account's own domain: the
|
|
37
|
+
* international client declares it is talking to `www.workbuddy.ai` whichever
|
|
38
|
+
* host issued its session, and the gateway rejects the request as illegal when
|
|
39
|
+
* the declared domain disagrees.
|
|
40
|
+
*/
|
|
41
|
+
const GLOBAL_DOMAIN = 'www.workbuddy.ai'
|
|
42
|
+
|
|
43
|
+
/** The chat path both realms serve. */
|
|
44
|
+
const CHAT_PATH = '/v2/chat/completions'
|
|
45
|
+
|
|
46
|
+
/**
|
|
47
|
+
* The international gateway's first-choice chat path.
|
|
48
|
+
*
|
|
49
|
+
* Tried before {@link CHAT_PATH} and abandoned on 404/405: the two deployments
|
|
50
|
+
* route chat differently, so a single hard-coded path fails one of them.
|
|
51
|
+
*/
|
|
52
|
+
const GLOBAL_CONSOLE_CHAT_PATH = '/console/chat/completions'
|
|
53
|
+
|
|
54
|
+
/** Shared CLI-form User-Agent for refresh and the CN catalog. */
|
|
55
|
+
const CLIENT_UA = 'CLI/2.63.2 CodeBuddy/2.63.2'
|
|
56
|
+
|
|
57
|
+
/** Client version carried by the attribution and billing headers. */
|
|
58
|
+
const CLIENT_VERSION = '2.63.2'
|
|
59
|
+
|
|
60
|
+
/** Client name the upstream attributes usage to; the desktop product, not a gateway. */
|
|
61
|
+
const WORKBUDDY_CLIENT_NAME = 'WorkBuddy'
|
|
62
|
+
|
|
63
|
+
const JSON_TIMEOUT_MS = 30_000
|
|
64
|
+
const ERROR_BODY_LIMIT = 4096
|
|
65
|
+
|
|
66
|
+
/**
|
|
67
|
+
* Insufficient-credit markers, ASCII lowercase plus the original Chinese.
|
|
68
|
+
*
|
|
69
|
+
* Kept apart from the generic quota phrases on purpose: throttling bodies say
|
|
70
|
+
* "quota exceeded" too, and a terminal refusal must not be parked as a
|
|
71
|
+
* retryable rate limit.
|
|
72
|
+
*/
|
|
73
|
+
const HARD_CREDIT_MARKERS = [
|
|
74
|
+
'insufficient credit', 'no credit', 'credit exhausted', 'credits exhausted', 'out of credit',
|
|
75
|
+
'quota exceeded', 'quota exhaust', 'payment required', 'credit not enough',
|
|
76
|
+
'not enough credit',
|
|
77
|
+
'积分不足', '额度不足', '余额不足', '积分用完', '额度用尽', '没有积分',
|
|
78
|
+
]
|
|
79
|
+
|
|
80
|
+
/**
|
|
81
|
+
* Insufficient-credit markers precise enough to honour under a 429.
|
|
82
|
+
*
|
|
83
|
+
* The international deployment answers an exhausted balance with `429` carrying
|
|
84
|
+
* `{"code":14018,"msg":"Credits exhausted."}` — measured 2026-10-13 — so
|
|
85
|
+
* reading 429 as throttling alone parks a terminal refusal as retryable.
|
|
86
|
+
*/
|
|
87
|
+
const HARD_CREDIT_MARKERS_ON_429 = [
|
|
88
|
+
'14018',
|
|
89
|
+
'credit exhausted', 'credits exhausted', 'insufficient credit', 'no credit',
|
|
90
|
+
'out of credit', 'credit not enough', 'not enough credit', 'payment required',
|
|
91
|
+
'积分不足', '额度不足', '余额不足', '积分用完', '额度用尽', '没有积分',
|
|
92
|
+
]
|
|
93
|
+
|
|
94
|
+
/**
|
|
95
|
+
* Rate-limit markers that arrive without a 429 status.
|
|
96
|
+
*
|
|
97
|
+
* The upstream reports throttling in the body on 200/400/403 as well, so a
|
|
98
|
+
* status-only test misses it and the account is neither cooled down nor moved
|
|
99
|
+
* aside — it simply keeps failing.
|
|
100
|
+
*/
|
|
101
|
+
const SOFT_RATE_MARKERS = [
|
|
102
|
+
'rate limit', 'rate-limiting', 'rate-limited', 'too many requests', 'too many',
|
|
103
|
+
'usage limit', '请求过于频繁', '限流',
|
|
104
|
+
]
|
|
105
|
+
|
|
106
|
+
/**
|
|
107
|
+
* Business code for an account the upstream has restricted.
|
|
108
|
+
*
|
|
109
|
+
* Measured 2026-11-08: the international deployment answered HTTP 403 with
|
|
110
|
+
* this body for *every* model, using a token minted seconds earlier by the
|
|
111
|
+
* refresh endpoint — and the same account was refused inside the official
|
|
112
|
+
* WorkBuddy desktop app. The credential was valid and the request shape
|
|
113
|
+
* accepted; the account itself was restricted. Only an appeal clears it, so it
|
|
114
|
+
* must never be reported as a dead session: that advice ("import the desktop
|
|
115
|
+
* session again") sends the user to re-authenticate a credential that was
|
|
116
|
+
* never the problem.
|
|
117
|
+
*/
|
|
118
|
+
const ACCOUNT_RESTRICTED_CODES = new Set([11140])
|
|
119
|
+
|
|
120
|
+
/**
|
|
121
|
+
* Text markers of the same restriction, for answers without the envelope code.
|
|
122
|
+
*
|
|
123
|
+
* The gateway sometimes drops `code` and leaves prose. Matched lowercase
|
|
124
|
+
* against the whole body, so both spellings of the message and the appeal tip
|
|
125
|
+
* count.
|
|
126
|
+
*/
|
|
127
|
+
const ACCOUNT_RESTRICTED_MARKERS = [
|
|
128
|
+
'account has been restricted',
|
|
129
|
+
'restricted due to unusual activity',
|
|
130
|
+
'账号存在异常行为',
|
|
131
|
+
'账号存在异常使用行为',
|
|
132
|
+
'帐號存在異常行為',
|
|
133
|
+
'帳號存在異常行為',
|
|
134
|
+
]
|
|
135
|
+
|
|
136
|
+
/** The concrete effort spellings WorkBuddy exposes on the wire. */
|
|
137
|
+
export const EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'max']
|
|
138
|
+
|
|
139
|
+
/** Promotional badge keys the upstream tags carry, minus their color suffix. */
|
|
140
|
+
const BADGE_PREFIX = 'badge:'
|
|
141
|
+
|
|
142
|
+
/**
|
|
143
|
+
* Reduce an upstream credits string to its language-neutral display form.
|
|
144
|
+
*
|
|
145
|
+
* The host LLM seam carries this text to the browser, and the host has no
|
|
146
|
+
* locale service — whatever string is produced here is shown verbatim in every
|
|
147
|
+
* UI language. The upstream is inconsistent in a way that matters: some catalog
|
|
148
|
+
* rows report a bare multiplier (`x0.79`) and others append a unit word
|
|
149
|
+
* (`x0.79 credits`), and the unit word would pin the display to English.
|
|
150
|
+
*/
|
|
151
|
+
export function normalizeCredits(credits) {
|
|
152
|
+
if (typeof credits !== 'string') return undefined
|
|
153
|
+
const match = /x\s*(\d+(?:\.\d+)?)/i.exec(credits)
|
|
154
|
+
if (match === null) return undefined
|
|
155
|
+
return `x${Number(match[1]).toFixed(2)}`
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
/** Parse the upstream `reasoning` object into a normalized reasoning record. */
|
|
159
|
+
/**
|
|
160
|
+
* Models whose upstream refuses `reasoning_effort: "off"`.
|
|
161
|
+
*
|
|
162
|
+
* Measured across both gateways: nine ids answer HTTP 400 / code 11133 when
|
|
163
|
+
* the field says `off`, even though their catalog row declares
|
|
164
|
+
* `canDisableThinking: true`. Every other effort value — and omitting the
|
|
165
|
+
* field entirely — is accepted. The plugin therefore never *sends* `off`: the
|
|
166
|
+
* "Default" level carries the model's own declared default instead.
|
|
167
|
+
*/
|
|
168
|
+
export const REFUSES_OFF_MODEL_IDS = new Set([
|
|
169
|
+
'deepseek-v4.1-flash',
|
|
170
|
+
'deepseek-v4.1-flash-sg',
|
|
171
|
+
'deepseek-v4-pro',
|
|
172
|
+
'primary-model',
|
|
173
|
+
'gpt-6-astra',
|
|
174
|
+
'gpt-5.6-sol',
|
|
175
|
+
'gpt-5.6-terra',
|
|
176
|
+
'gpt-5.6-luna',
|
|
177
|
+
'gemini-3.5-flash',
|
|
178
|
+
])
|
|
179
|
+
|
|
180
|
+
/**
|
|
181
|
+
* The effort ladder a *singular* reasoning declaration implies.
|
|
182
|
+
*
|
|
183
|
+
* The upstream ships two shapes: the plural `{supportedEfforts[], …}` and the
|
|
184
|
+
* singular `{effort:"medium", summary:"auto"}`. The singular shape carries one
|
|
185
|
+
* effort value but the model answers with distinct reasoning across the whole
|
|
186
|
+
* ladder, so the row is folded onto the full ladder rather than left
|
|
187
|
+
* undeclared — an undeclared row gets no effort control at all, which is
|
|
188
|
+
* exactly the capability the singular shape was trying to declare.
|
|
189
|
+
*/
|
|
190
|
+
const SINGULAR_EFFORT_LADDER = ['low', 'medium', 'high', 'xhigh', 'max']
|
|
191
|
+
|
|
192
|
+
/** Parse the upstream `reasoning` object into a normalized reasoning record. */
|
|
193
|
+
function resolveUpstreamReasoning(wrapped) {
|
|
194
|
+
const supports = wrapped['supportsReasoning'] === true
|
|
195
|
+
const onlyReasoning = wrapped['onlyReasoning'] === true
|
|
196
|
+
const rawReasoning = wrapped['reasoning']
|
|
197
|
+
let supportedEfforts
|
|
198
|
+
let defaultEffort
|
|
199
|
+
let canDisableThinking = false
|
|
200
|
+
if (typeof rawReasoning === 'object' && rawReasoning !== null && !Array.isArray(rawReasoning)) {
|
|
201
|
+
const rawEfforts = rawReasoning['supportedEfforts']
|
|
202
|
+
if (Array.isArray(rawEfforts)) {
|
|
203
|
+
const efforts = rawEfforts.filter(value => typeof value === 'string' && EFFORT_VALUES.includes(value))
|
|
204
|
+
if (efforts.length > 0) supportedEfforts = efforts
|
|
205
|
+
}
|
|
206
|
+
const singularEffort = rawReasoning['effort']
|
|
207
|
+
if (supportedEfforts === undefined
|
|
208
|
+
&& typeof singularEffort === 'string'
|
|
209
|
+
&& EFFORT_VALUES.includes(singularEffort)) {
|
|
210
|
+
// The singular shape declares one effort but the model honours the
|
|
211
|
+
// ladder; folding it keeps the effort control available.
|
|
212
|
+
supportedEfforts = [...SINGULAR_EFFORT_LADDER]
|
|
213
|
+
canDisableThinking = true
|
|
214
|
+
}
|
|
215
|
+
const declaredDefault = rawReasoning['defaultEffort'] ?? rawReasoning['effort']
|
|
216
|
+
if (typeof declaredDefault === 'string' && EFFORT_VALUES.includes(declaredDefault)) defaultEffort = declaredDefault
|
|
217
|
+
// Only an explicit `canDisableThinking: true` offers "thinking off"; older
|
|
218
|
+
// rows omit the field and several of them reject `off` on the wire, so the
|
|
219
|
+
// conservative default is "cannot be disabled".
|
|
220
|
+
if (rawReasoning['canDisableThinking'] === true) canDisableThinking = true
|
|
221
|
+
}
|
|
222
|
+
return {
|
|
223
|
+
reasoning: {
|
|
224
|
+
// A row that declares its effort set is a reasoning model even when it
|
|
225
|
+
// carries no `supportsReasoning` flag: the upstream's flag is absent
|
|
226
|
+
// from some documents, and a declared ladder is the stronger statement.
|
|
227
|
+
supports: supports || supportedEfforts !== undefined,
|
|
228
|
+
onlyReasoning,
|
|
229
|
+
...supportedEfforts === undefined ? {} : { supportedEfforts },
|
|
230
|
+
...defaultEffort === undefined ? {} : { defaultEffort },
|
|
231
|
+
canDisableThinking,
|
|
232
|
+
},
|
|
233
|
+
}
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
/** Parse the upstream's promotional badge list into plain labels. */
|
|
237
|
+
function resolveUpstreamBadges(wrapped) {
|
|
238
|
+
const raw = wrapped['promotions'] ?? wrapped['promotionTags']
|
|
239
|
+
const list = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : []
|
|
240
|
+
const badges = []
|
|
241
|
+
for (const entry of list) {
|
|
242
|
+
if (typeof entry !== 'string') continue
|
|
243
|
+
const label = entry.startsWith(BADGE_PREFIX) ? entry.slice(BADGE_PREFIX.length).split(':')[0] : entry
|
|
244
|
+
if (label !== '' && !badges.includes(label)) badges.push(label)
|
|
245
|
+
}
|
|
246
|
+
return badges
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
/** Parse the upstream's billing block into a normalized billing record. */
|
|
250
|
+
function resolveUpstreamBilling(wrapped) {
|
|
251
|
+
const rawCredits = typeof wrapped['credits'] === 'string' ? wrapped['credits'] : undefined
|
|
252
|
+
const rate = normalizeCredits(rawCredits)
|
|
253
|
+
const badges = resolveUpstreamBadges(wrapped)
|
|
254
|
+
return {
|
|
255
|
+
billing: {
|
|
256
|
+
...rate === undefined ? {} : { credits: rate },
|
|
257
|
+
...badges.length === 0 ? {} : { badges },
|
|
258
|
+
free: rate !== undefined && Number(rate.slice(1)) === 0,
|
|
259
|
+
},
|
|
260
|
+
}
|
|
261
|
+
}
|
|
262
|
+
|
|
263
|
+
/**
|
|
264
|
+
* Classify an upstream failure into one of {@link UPSTREAM_ERROR_KINDS}.
|
|
265
|
+
*
|
|
266
|
+
* The classes matter because they map onto different HTTP answers at the shim:
|
|
267
|
+
* a hard credit refusal is terminal (402), a soft rate limit is retryable
|
|
268
|
+
* (429), and a dead session needs a new sign-in (401).
|
|
269
|
+
*
|
|
270
|
+
* The upstream's *business codes* are matched first, because they are exact
|
|
271
|
+
* and the prose around them is not: `14018` is an exhausted balance (which
|
|
272
|
+
* arrives as a 429 and would otherwise be read as throttling), `14003` is a
|
|
273
|
+
* model-scoped throttle, `6004` is an account volume limit, `12153` is a
|
|
274
|
+
* dead session, and `11140` is an account the upstream has restricted.
|
|
275
|
+
*
|
|
276
|
+
* `account_restricted` is deliberately separate from `session_dead` even
|
|
277
|
+
* though both arrive as 401/403: a dead session is fixed by signing in again,
|
|
278
|
+
* a restriction only by appealing. See {@link describeAccountRestriction}.
|
|
279
|
+
*/
|
|
280
|
+
export function classifyUpstreamError(status, body) {
|
|
281
|
+
const text = String(body ?? '').toLowerCase()
|
|
282
|
+
const code = businessCodeOf(body)
|
|
283
|
+
if (code === 14018) return 'hard_credit'
|
|
284
|
+
if (code === 14003 || code === 6004) return 'soft_rate'
|
|
285
|
+
if (code === 12153) return 'session_dead'
|
|
286
|
+
// Before the status branches: the restriction today arrives as 403 but its
|
|
287
|
+
// meaning does not depend on the status, and a 403 that means "restricted"
|
|
288
|
+
// must never be re-read as "sign in again".
|
|
289
|
+
if (code !== undefined && ACCOUNT_RESTRICTED_CODES.has(code)) return 'account_restricted'
|
|
290
|
+
if (ACCOUNT_RESTRICTED_MARKERS.some(marker => text.includes(marker))) return 'account_restricted'
|
|
291
|
+
if (status === 429) {
|
|
292
|
+
return HARD_CREDIT_MARKERS_ON_429.some(marker => text.includes(marker)) ? 'hard_credit' : 'soft_rate'
|
|
293
|
+
}
|
|
294
|
+
if (status === 401 || status === 403) {
|
|
295
|
+
if (HARD_CREDIT_MARKERS.some(marker => text.includes(marker))) return 'hard_credit'
|
|
296
|
+
if (SOFT_RATE_MARKERS.some(marker => text.includes(marker))) return 'soft_rate'
|
|
297
|
+
return 'session_dead'
|
|
298
|
+
}
|
|
299
|
+
if (status === 402) return 'hard_credit'
|
|
300
|
+
if (status === 404) return 'not_found'
|
|
301
|
+
if (status >= 500) return 'server'
|
|
302
|
+
if (status >= 400) {
|
|
303
|
+
if (HARD_CREDIT_MARKERS.some(marker => text.includes(marker))) return 'hard_credit'
|
|
304
|
+
if (SOFT_RATE_MARKERS.some(marker => text.includes(marker))) return 'soft_rate'
|
|
305
|
+
return 'client'
|
|
306
|
+
}
|
|
307
|
+
return 'server'
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
/**
|
|
311
|
+
* Models that are text-only, however the catalog row describes them.
|
|
312
|
+
*
|
|
313
|
+
* The upstream's `supportsImages` is a *platform* flag, not a capability: it
|
|
314
|
+
* reads `true` for nearly every row in the catalog, including the ones that
|
|
315
|
+
* cannot take an image at all. Offering an image to a text-only model is a
|
|
316
|
+
* request the provider rejects *after* the message is already durable, and
|
|
317
|
+
* refusing an image to a model that can take one is a capability the user
|
|
318
|
+
* loses. So the row flag is corrected by this table, which was reviewed id by
|
|
319
|
+
* id against what each model actually accepts.
|
|
320
|
+
*/
|
|
321
|
+
export const TEXT_ONLY_MODEL_IDS = new Set([
|
|
322
|
+
'deepseek-v4-pro',
|
|
323
|
+
'glm-5.1',
|
|
324
|
+
'glm-5.2',
|
|
325
|
+
'glm-5.3',
|
|
326
|
+
'hy3',
|
|
327
|
+
'hy4-preview',
|
|
328
|
+
])
|
|
329
|
+
|
|
330
|
+
/**
|
|
331
|
+
* The default context window a model's own product document declares, for ids
|
|
332
|
+
* whose CN document reports only the maximum.
|
|
333
|
+
*
|
|
334
|
+
* The two deployments describe capacity differently: the international
|
|
335
|
+
* `/v3/config` product document carries a `contextWindow` object with the
|
|
336
|
+
* *default* length the official client requests at (`deepseek-v4.1-flash`:
|
|
337
|
+
* 300000 default, 1000000 maximum), while the CN CLI document carries only
|
|
338
|
+
* `maxInputTokens` — and for the deepseek row that is the *maximum* (1000000),
|
|
339
|
+
* not what a real request can span. A harness told "1M" packs five days of
|
|
340
|
+
* un-compacted history into one send; measured 2026-10-25, requests past
|
|
341
|
+
* roughly the official default hang the connection outright or are refused
|
|
342
|
+
* (400 / code 11115) before a byte of model output, and the harness's
|
|
343
|
+
* compaction engine — threshold at 0.8 of the *declared* window — never fires
|
|
344
|
+
* because the declared window is 3-5x the deliverable size.
|
|
345
|
+
*
|
|
346
|
+
* Values are the international document's `defaultContextWindow` per id
|
|
347
|
+
* (measured 2026-10-25). Ids absent here keep `maxInputTokens`, which for them
|
|
348
|
+
* equals the declared default (`hy3` reads 192000 on both deployments). The
|
|
349
|
+
* international branch does not consult this table: its rows carry the default
|
|
350
|
+
* on the row itself.
|
|
351
|
+
*/
|
|
352
|
+
const DEFAULT_CONTEXT_WINDOWS = new Map([
|
|
353
|
+
['deepseek-v4.1-flash', 300000],
|
|
354
|
+
['deepseek-v4.1-flash-sg', 300000],
|
|
355
|
+
['gemini-3.8-flash', 300000],
|
|
356
|
+
['glm-5.3-flash', 300000],
|
|
357
|
+
['grok-4.7', 200000],
|
|
358
|
+
['gpt-6-astra', 400000],
|
|
359
|
+
['gpt-6.1-sol', 272000],
|
|
360
|
+
['hy4-preview', 200000],
|
|
361
|
+
['kimi-k3.1-pro', 300000],
|
|
362
|
+
['kimi-k3.1-pro-highspeed', 300000],
|
|
363
|
+
['minimax-m3.1-flash', 300000],
|
|
364
|
+
['step-5-preview', 300000],
|
|
365
|
+
])
|
|
366
|
+
|
|
367
|
+
/**
|
|
368
|
+
* The upstream's business code, read out of a `{code,msg,data}` envelope.
|
|
369
|
+
*
|
|
370
|
+
* Returns undefined when the body is not such an envelope — a gateway HTML
|
|
371
|
+
* page, for instance, which the 401 branch already classifies as a dead
|
|
372
|
+
* session.
|
|
373
|
+
*/
|
|
374
|
+
export function businessCodeOf(body) {
|
|
375
|
+
return envelopeOf(body)?.code
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
/** One upstream `{code,msg,data}` reply, decoded tolerantly. */
|
|
379
|
+
function envelopeOf(body) {
|
|
380
|
+
if (typeof body !== 'string') return undefined
|
|
381
|
+
let parsed
|
|
382
|
+
try {
|
|
383
|
+
parsed = JSON.parse(body)
|
|
384
|
+
} catch {
|
|
385
|
+
return undefined
|
|
386
|
+
}
|
|
387
|
+
if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return undefined
|
|
388
|
+
const code = typeof parsed['code'] === 'number' ? parsed['code'] : undefined
|
|
389
|
+
const extError = typeof parsed['extError'] === 'object' && parsed['extError'] !== null ? parsed['extError'] : undefined
|
|
390
|
+
const param = typeof extError?.['param'] === 'string' ? extError['param'] : undefined
|
|
391
|
+
const value = extError?.['value'] !== undefined ? String(extError['value']) : undefined
|
|
392
|
+
return {
|
|
393
|
+
...code === undefined ? {} : { code },
|
|
394
|
+
...param === undefined ? {} : { param },
|
|
395
|
+
...value === undefined ? {} : { value },
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
|
|
399
|
+
/**
|
|
400
|
+
* A one-line description of what the upstream refused and why.
|
|
401
|
+
*
|
|
402
|
+
* The envelope's `extError` names the offending field (`param`) and its value
|
|
403
|
+
* — without it a 11133 reads as "model unavailable", and the fix (a reasoning
|
|
404
|
+
* effort the model refuses, a tool schema shape it cannot parse) lives
|
|
405
|
+
* nowhere in the message.
|
|
406
|
+
*/
|
|
407
|
+
export function describeUpstreamFailure(body) {
|
|
408
|
+
const envelope = envelopeOf(body)
|
|
409
|
+
if (envelope === undefined) return String(body ?? '').slice(0, 400)
|
|
410
|
+
const parts = []
|
|
411
|
+
if (envelope.code !== undefined) parts.push(`code ${envelope.code}`)
|
|
412
|
+
if (envelope.param !== undefined) parts.push(`param ${envelope.param}`)
|
|
413
|
+
if (envelope.value !== undefined) parts.push(`value ${envelope.value}`)
|
|
414
|
+
return parts.join(', ')
|
|
415
|
+
}
|
|
416
|
+
|
|
417
|
+
/**
|
|
418
|
+
* The upstream's own explanation of an account restriction, or undefined.
|
|
419
|
+
*
|
|
420
|
+
* Returned verbatim: the message and the appeal tip are the only things that
|
|
421
|
+
* tell the user this is not a broken credential. English and Chinese are both
|
|
422
|
+
* carried by the body, and the Chinese one is what the official app shows, so
|
|
423
|
+
* the reader recognises it.
|
|
424
|
+
*
|
|
425
|
+
* @param {string} body The refusal body.
|
|
426
|
+
* @returns {string|undefined}
|
|
427
|
+
*/
|
|
428
|
+
export function describeAccountRestriction(body) {
|
|
429
|
+
const text = String(body ?? '')
|
|
430
|
+
const code = businessCodeOf(text)
|
|
431
|
+
const restricted = (code !== undefined && ACCOUNT_RESTRICTED_CODES.has(code))
|
|
432
|
+
|| ACCOUNT_RESTRICTED_MARKERS.some(marker => text.toLowerCase().includes(marker))
|
|
433
|
+
if (!restricted) return undefined
|
|
434
|
+
let parsed
|
|
435
|
+
try {
|
|
436
|
+
parsed = JSON.parse(text)
|
|
437
|
+
} catch {
|
|
438
|
+
return undefined
|
|
439
|
+
}
|
|
440
|
+
if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return undefined
|
|
441
|
+
const displayMsg = typeof parsed['displayMsg'] === 'object' && parsed['displayMsg'] !== null ? parsed['displayMsg'] : {}
|
|
442
|
+
const displayTips = typeof parsed['displayTips'] === 'object' && parsed['displayTips'] !== null ? parsed['displayTips'] : {}
|
|
443
|
+
const message = firstNonEmpty([displayMsg['zh'], displayMsg['en'], parsed['msg']])
|
|
444
|
+
const tip = firstNonEmpty([displayTips['zh'], displayTips['en']])
|
|
445
|
+
const parts = [message, tip].filter(part => part !== undefined)
|
|
446
|
+
return parts.length === 0 ? undefined : parts.join(' — ')
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
/** The first of `values` that is a non-empty string. */
|
|
450
|
+
function firstNonEmpty(values) {
|
|
451
|
+
for (const value of values) {
|
|
452
|
+
if (typeof value === 'string' && value.trim() !== '') return value.trim()
|
|
453
|
+
}
|
|
454
|
+
return undefined
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
/** Region for a login domain; an empty domain means CN. */
|
|
458
|
+
export function regionOf(domain) {
|
|
459
|
+
const lowered = String(domain ?? '').trim().toLowerCase()
|
|
460
|
+
if (lowered === 'workbuddy.ai' || lowered.endsWith('.workbuddy.ai')) return 'global'
|
|
461
|
+
// The international product also answers on the `codebuddy.ai` brand domain.
|
|
462
|
+
// The two brand domains are *not* interchangeable — a `codebuddy.ai` token
|
|
463
|
+
// is refused by the `workbuddy.ai` gateway — but both are international.
|
|
464
|
+
if (lowered === 'codebuddy.ai' || lowered.endsWith('.codebuddy.ai')) return 'global'
|
|
465
|
+
return 'cn'
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
/**
|
|
469
|
+
* The realm a credential belongs to.
|
|
470
|
+
*
|
|
471
|
+
* An explicit realm wins when it names the international deployment; a domain
|
|
472
|
+
* naming `workbuddy.ai` is international whatever the explicit realm says.
|
|
473
|
+
* Anything else is CN, which keeps a credential that states nothing behaving
|
|
474
|
+
* exactly as it did before the field existed.
|
|
475
|
+
*/
|
|
476
|
+
export function realmOf(credential) {
|
|
477
|
+
if (credential?.region === 'global') return 'global'
|
|
478
|
+
return regionOf(credential?.domain ?? '')
|
|
479
|
+
}
|
|
480
|
+
|
|
481
|
+
/**
|
|
482
|
+
* The international deployment's two brand domains.
|
|
483
|
+
*
|
|
484
|
+
* A token issued at one is refused by the other, so the base has to follow
|
|
485
|
+
* the credential's own domain rather than a fixed guess. `www.codebuddy.ai`
|
|
486
|
+
* does resolve (measured 2026-10-20), so the fallback chain is real rather
|
|
487
|
+
* than theoretical.
|
|
488
|
+
*/
|
|
489
|
+
const GLOBAL_BASES = {
|
|
490
|
+
'codebuddy.ai': 'https://www.codebuddy.ai',
|
|
491
|
+
'workbuddy.ai': 'https://www.workbuddy.ai',
|
|
492
|
+
}
|
|
493
|
+
|
|
494
|
+
/** The international base that serves the credential's own domain. */
|
|
495
|
+
function globalBase(credential) {
|
|
496
|
+
const domain = String(credential?.domain ?? '').trim().toLowerCase()
|
|
497
|
+
for (const [suffix, base] of Object.entries(GLOBAL_BASES)) {
|
|
498
|
+
if (domain === suffix || domain.endsWith(`.${suffix}`)) return base
|
|
499
|
+
}
|
|
500
|
+
return GLOBAL_BASE
|
|
501
|
+
}
|
|
502
|
+
|
|
503
|
+
function chatBase(credential) {
|
|
504
|
+
return realmOf(credential) === 'global' ? globalBase(credential) : CN_CHAT_BASE
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
function billingBase(credential) {
|
|
508
|
+
return realmOf(credential) === 'global' ? globalBase(credential) : CN_BILLING_BASE
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
function originReferer(credential) {
|
|
512
|
+
return realmOf(credential) === 'global' ? globalBase(credential) : CN_BILLING_BASE
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
/**
|
|
516
|
+
* The `X-Domain` a realm's request declares.
|
|
517
|
+
*
|
|
518
|
+
* The international gateway expects the domain the session belongs to — the
|
|
519
|
+
* international product serves two brand domains and a request that declares
|
|
520
|
+
* the other one is refused as illegal.
|
|
521
|
+
*/
|
|
522
|
+
function domainHeaderFor(credential) {
|
|
523
|
+
const domain = String(credential?.domain ?? '').trim()
|
|
524
|
+
if (domain !== '') return domain
|
|
525
|
+
return realmOf(credential) === 'global' ? GLOBAL_DOMAIN : ''
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
/**
|
|
529
|
+
* Per-account device identifiers, derived from the uid.
|
|
530
|
+
*
|
|
531
|
+
* Stable across restarts and distinct per account, which is what the upstream
|
|
532
|
+
* treats a device fingerprint as: a missing or drifting one lets it associate
|
|
533
|
+
* several accounts as a single client. The shape is the upstream's own: a
|
|
534
|
+
* hyphenated UUID.
|
|
535
|
+
*/
|
|
536
|
+
function accountStableHeaders(credential) {
|
|
537
|
+
if (!credential?.uid) return {}
|
|
538
|
+
return {
|
|
539
|
+
'X-Machine-ID': deriveAccountStableId(credential.uid, 'machine'),
|
|
540
|
+
'X-Session-ID': deriveAccountStableId(credential.uid, 'session'),
|
|
541
|
+
}
|
|
542
|
+
}
|
|
543
|
+
|
|
544
|
+
/** One stable hyphenated UUID for an account and purpose. */
|
|
545
|
+
function deriveAccountStableId(uid, purpose) {
|
|
546
|
+
const hex = createHash('sha256').update(`wb2a:${purpose}:${uid}`).digest('hex')
|
|
547
|
+
return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`
|
|
548
|
+
}
|
|
549
|
+
|
|
550
|
+
/** The locale the upstream expects for a realm's requests. */
|
|
551
|
+
function acceptLanguageFor(credential) {
|
|
552
|
+
return realmOf(credential) === 'global' ? 'en-US' : 'zh-CN'
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
/**
|
|
556
|
+
* The enterprise headers, present only when the account has an enterprise.
|
|
557
|
+
*
|
|
558
|
+
* The upstream carries the same id twice, under two names: `X-Enterprise-Id`
|
|
559
|
+
* for the enterprise itself and `X-Tenant-Id` for the tenant inside it. A
|
|
560
|
+
* request that sends one but not the other is answered as an unidentified
|
|
561
|
+
* client, which the upstream records as an anonymous call.
|
|
562
|
+
*/
|
|
563
|
+
function enterpriseHeaders(credential) {
|
|
564
|
+
if (credential?.enterpriseId === undefined || credential.enterpriseId === '') return {}
|
|
565
|
+
return { 'X-Enterprise-Id': credential.enterpriseId, 'X-Tenant-Id': credential.enterpriseId }
|
|
566
|
+
}
|
|
567
|
+
|
|
568
|
+
/** Headers every upstream request shares. */
|
|
569
|
+
function commonHeaders(credential) {
|
|
570
|
+
return {
|
|
571
|
+
'Content-Type': 'application/json',
|
|
572
|
+
'Accept': 'application/json',
|
|
573
|
+
'X-Requested-With': 'XMLHttpRequest',
|
|
574
|
+
'Origin': originReferer(credential),
|
|
575
|
+
'Referer': `${originReferer(credential)}/`,
|
|
576
|
+
'User-Agent': CLIENT_UA,
|
|
577
|
+
// The gateway reads this as the official client's gate header, and every
|
|
578
|
+
// API request is expected to carry it.
|
|
579
|
+
'X-CodeBuddy-Request': '1',
|
|
580
|
+
'Accept-Language': acceptLanguageFor(credential),
|
|
581
|
+
...enterpriseHeaders(credential),
|
|
582
|
+
...accountStableHeaders(credential),
|
|
583
|
+
}
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
/**
|
|
587
|
+
* Chat request headers, including the X-No-* conventions the official CLI uses.
|
|
588
|
+
*
|
|
589
|
+
* `userAgent` carries the desktop identity for chat requests; when it is absent
|
|
590
|
+
* the shared CLI-form UA applies. Refresh shares `commonHeaders` but never this
|
|
591
|
+
* override, so the two paths cannot drift into each other.
|
|
592
|
+
*/
|
|
593
|
+
function chatHeaders(credential, userAgent, clientVersion) {
|
|
594
|
+
const international = realmOf(credential) === 'global'
|
|
595
|
+
const domain = domainHeaderFor(credential)
|
|
596
|
+
return {
|
|
597
|
+
...commonHeaders(credential),
|
|
598
|
+
...userAgent === undefined ? {} : { 'User-Agent': userAgent },
|
|
599
|
+
// Chat streams, so it declares the event-stream type the shared
|
|
600
|
+
// non-streaming default does not.
|
|
601
|
+
'Accept': 'application/json, text/event-stream',
|
|
602
|
+
...credential.accessToken === ''
|
|
603
|
+
? { 'X-No-Authorization': '1' }
|
|
604
|
+
: { 'Authorization': `Bearer ${credential.accessToken}` },
|
|
605
|
+
// 安全红线:chat 请求绝不携带 refresh token。
|
|
606
|
+
...credential.uid === '' ? { 'X-No-User-Id': '1' } : { 'X-User-Id': credential.uid },
|
|
607
|
+
...international
|
|
608
|
+
// The international gateway is told, unconditionally, that this is a
|
|
609
|
+
// personal international client: no enterprise, and the international
|
|
610
|
+
// domain rather than whichever host issued the login. Declaring the
|
|
611
|
+
// account's own enterprise id here is refused as an illegal request.
|
|
612
|
+
? { 'X-No-Enterprise-Id': '1', 'X-Domain': domain }
|
|
613
|
+
: {
|
|
614
|
+
...credential.enterpriseId === undefined || credential.enterpriseId === ''
|
|
615
|
+
? { 'X-No-Enterprise-Id': '1' }
|
|
616
|
+
: { 'X-Enterprise-Id': credential.enterpriseId },
|
|
617
|
+
...domain === '' ? { 'X-No-Department-Info': '1' } : { 'X-Domain': domain },
|
|
618
|
+
},
|
|
619
|
+
// Usage attribution: the upstream reports usage per client, and a request
|
|
620
|
+
// carrying no client identity is recorded as an anonymous gateway call.
|
|
621
|
+
'X-Agent-Intent': 'craft',
|
|
622
|
+
'X-Agent-Purpose': 'conversation',
|
|
623
|
+
...international ? { 'X-Agent-Type': 'main' } : {},
|
|
624
|
+
'X-IDE-Name': WORKBUDDY_CLIENT_NAME,
|
|
625
|
+
'X-IDE-Type': WORKBUDDY_CLIENT_NAME,
|
|
626
|
+
'X-IDE-Version': clientVersion ?? CLIENT_VERSION,
|
|
627
|
+
// The product the request is attributed to. Measured across three
|
|
628
|
+
// independent implementations: the gateway attributes usage to the SaaS
|
|
629
|
+
// product, not to the desktop app's own name.
|
|
630
|
+
'X-Product': 'SaaS',
|
|
631
|
+
}
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
/** Refresh-endpoint headers; X-Refresh-Token appears here and nowhere else. */
|
|
635
|
+
function refreshHeaders(credential) {
|
|
636
|
+
const headers = {
|
|
637
|
+
...commonHeaders(credential),
|
|
638
|
+
'X-Refresh-Token': credential.refreshToken,
|
|
639
|
+
// Names the channel the refresh came through; the official client's own
|
|
640
|
+
// spelling is `workbuddy`.
|
|
641
|
+
'X-Auth-Refresh-Source': 'workbuddy',
|
|
642
|
+
}
|
|
643
|
+
if (credential.enterpriseId !== undefined && credential.enterpriseId !== '') {
|
|
644
|
+
headers['X-Enterprise-Id'] = credential.enterpriseId
|
|
645
|
+
headers['X-Tenant-Id'] = credential.enterpriseId
|
|
646
|
+
}
|
|
647
|
+
return headers
|
|
648
|
+
}
|
|
649
|
+
|
|
650
|
+
/** Billing request headers; the gate header and identity apply here too. */
|
|
651
|
+
function billingHeaders(credential) {
|
|
652
|
+
const domain = domainHeaderFor(credential)
|
|
653
|
+
return {
|
|
654
|
+
...commonHeaders(credential),
|
|
655
|
+
'Accept': 'application/json',
|
|
656
|
+
...credential.accessToken === ''
|
|
657
|
+
? { 'X-No-Authorization': '1' }
|
|
658
|
+
: { 'Authorization': `Bearer ${credential.accessToken}` },
|
|
659
|
+
...credential.uid === '' ? { 'X-No-User-Id': '1' } : { 'X-User-Id': credential.uid },
|
|
660
|
+
...domain === '' ? {} : { 'X-Domain': domain },
|
|
661
|
+
'X-IDE-Name': WORKBUDDY_CLIENT_NAME,
|
|
662
|
+
'X-IDE-Type': WORKBUDDY_CLIENT_NAME,
|
|
663
|
+
'X-IDE-Version': CLIENT_VERSION,
|
|
664
|
+
'X-Product': 'SaaS',
|
|
665
|
+
}
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
/**
|
|
669
|
+
* Salt for the conversation/turn id derivation, fresh in each process.
|
|
670
|
+
*
|
|
671
|
+
* A derived id must not be readable as the text it came from, so it is hashed
|
|
672
|
+
* with a per-process salt: the same conversation names the same id for this
|
|
673
|
+
* run, and a restart starts a new namespace — which is what a fresh client
|
|
674
|
+
* would do too.
|
|
675
|
+
*/
|
|
676
|
+
const CONVERSATION_ID_SALT = randomBytes(16).toString('hex')
|
|
677
|
+
|
|
678
|
+
/** A 32-hex-digit id in the shape WorkBuddy's own client emits. */
|
|
679
|
+
function conversationIdHex() {
|
|
680
|
+
return randomBytes(16).toString('hex')
|
|
681
|
+
}
|
|
682
|
+
|
|
683
|
+
/**
|
|
684
|
+
* A hyphenated UUID, the shape the upstream's `X-Conversation-ID` carries.
|
|
685
|
+
*
|
|
686
|
+
* The conversation id is the one id the upstream reads as a *grouping* key
|
|
687
|
+
* rather than as a digest: it names the conversation itself, and it is the
|
|
688
|
+
* only one of the family the upstream expects in UUID form. The other three
|
|
689
|
+
* (`X-Request-ID`, `X-Conversation-Message-ID`, `X-Conversation-Request-ID`)
|
|
690
|
+
* are 32 hex digits without hyphens.
|
|
691
|
+
*/
|
|
692
|
+
function conversationUuid() {
|
|
693
|
+
const hex = randomBytes(16).toString('hex')
|
|
694
|
+
return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
|
|
695
|
+
}
|
|
696
|
+
|
|
697
|
+
/** Derive a 32-hex id from what names the thing it identifies. */
|
|
698
|
+
function derivedConversationId(kind, key) {
|
|
699
|
+
return createHash('sha256').update(`${CONVERSATION_ID_SALT}|${kind}|${key}`).digest('hex').slice(0, 32)
|
|
700
|
+
}
|
|
701
|
+
|
|
702
|
+
/**
|
|
703
|
+
* A message content's signature: its text, plus a digest of every part that is
|
|
704
|
+
* not text (an image, a file), so a turn made of images alone is still a turn
|
|
705
|
+
* of its own.
|
|
706
|
+
*/
|
|
707
|
+
function messageSignature(content) {
|
|
708
|
+
if (typeof content === 'string') return content
|
|
709
|
+
if (!Array.isArray(content)) return ''
|
|
710
|
+
let out = ''
|
|
711
|
+
for (const part of content) {
|
|
712
|
+
if (typeof part !== 'object' || part === null) continue
|
|
713
|
+
const type = typeof part['type'] === 'string' ? part['type'] : ''
|
|
714
|
+
if (type === '' || type === 'text') {
|
|
715
|
+
out += typeof part['text'] === 'string' ? part['text'] : ''
|
|
716
|
+
} else {
|
|
717
|
+
out += `[${type}:${createHash('sha256').update(JSON.stringify(part)).digest('hex').slice(0, 8)}]`
|
|
718
|
+
}
|
|
719
|
+
}
|
|
720
|
+
return out
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
/**
|
|
724
|
+
* Whether `messages[i]` answers the message before it — a tool's result, or an
|
|
725
|
+
* assistant's calls — rather than carrying the user's own words.
|
|
726
|
+
*/
|
|
727
|
+
function answeredBefore(messages, i) {
|
|
728
|
+
const prev = messages[i - 1]
|
|
729
|
+
if (typeof prev !== 'object' || prev === null) return false
|
|
730
|
+
if (prev['role'] === 'tool') return true
|
|
731
|
+
return prev['role'] === 'assistant' && Array.isArray(prev['tool_calls']) && prev['tool_calls'].length > 0
|
|
732
|
+
}
|
|
733
|
+
|
|
734
|
+
/**
|
|
735
|
+
* Whether a message's content is nothing but tool results.
|
|
736
|
+
*
|
|
737
|
+
* Anthropic-shaped clients carry a tool result inside a *user* message, so a
|
|
738
|
+
* body can end with several such messages in a row while the send is still
|
|
739
|
+
* one. Keying the turn on one of those would change the id with every step of
|
|
740
|
+
* a tool loop, which is the opposite of what a turn id is for.
|
|
741
|
+
*/
|
|
742
|
+
function isToolResultOnly(content) {
|
|
743
|
+
if (!Array.isArray(content) || content.length === 0) return false
|
|
744
|
+
for (const part of content) {
|
|
745
|
+
if (typeof part !== 'object' || part === null) return false
|
|
746
|
+
const type = part['type']
|
|
747
|
+
if (type !== 'tool_result' && type !== 'tool-result') return false
|
|
748
|
+
}
|
|
749
|
+
return true
|
|
750
|
+
}
|
|
751
|
+
|
|
752
|
+
/**
|
|
753
|
+
* Name the user send a chat answers: the body's last user message that is the
|
|
754
|
+
* user's own, by its place and its signature.
|
|
755
|
+
*
|
|
756
|
+
* Every step of one send repeats it, while the user's next message changes it.
|
|
757
|
+
* That is what `X-Conversation-Request-ID` means upstream: the backend counts
|
|
758
|
+
* one user send as one request by this id, so a chat that carried a fresh id
|
|
759
|
+
* per step would show up in the usage detail as many requests.
|
|
760
|
+
*/
|
|
761
|
+
function turnKeyOf(body) {
|
|
762
|
+
const messages = Array.isArray(body?.['messages']) ? body['messages'] : []
|
|
763
|
+
for (let i = messages.length - 1; i >= 0; i--) {
|
|
764
|
+
const message = messages[i]
|
|
765
|
+
if (typeof message !== 'object' || message === null) continue
|
|
766
|
+
if (message['role'] !== 'user' || answeredBefore(messages, i)) continue
|
|
767
|
+
if (isToolResultOnly(message['content'])) continue
|
|
768
|
+
const signature = messageSignature(message['content'])
|
|
769
|
+
return signature === '' ? '' : `u${i}:${signature}`
|
|
770
|
+
}
|
|
771
|
+
return ''
|
|
772
|
+
}
|
|
773
|
+
|
|
774
|
+
/**
|
|
775
|
+
* Name the conversation a chat belongs to, from its first user message.
|
|
776
|
+
*
|
|
777
|
+
* The opening user message is the only session-scoped fact available, and it is
|
|
778
|
+
* stable for the whole conversation, which is what the id is for.
|
|
779
|
+
*/
|
|
780
|
+
function conversationKeyOf(body) {
|
|
781
|
+
const messages = Array.isArray(body?.['messages']) ? body['messages'] : []
|
|
782
|
+
for (const message of messages) {
|
|
783
|
+
if (typeof message !== 'object' || message === null) continue
|
|
784
|
+
if (message['role'] !== 'user') continue
|
|
785
|
+
const signature = messageSignature(message['content'])
|
|
786
|
+
if (signature !== '') return `first:${signature}`
|
|
787
|
+
}
|
|
788
|
+
return ''
|
|
789
|
+
}
|
|
790
|
+
|
|
791
|
+
/**
|
|
792
|
+
* Attach the conversation-tracking header family to a chat request.
|
|
793
|
+
*
|
|
794
|
+
* The gateway's channel verification is an **independent, separately switched**
|
|
795
|
+
* check: some deployments refuse chats that lack this family with
|
|
796
|
+
* `400 / code 11128 / "request illegal"`, and it is reported to spread by
|
|
797
|
+
* deployment and by time of day rather than by request shape. The body is the
|
|
798
|
+
* **prepared** text actually sent, so the ids name what went out on the wire.
|
|
799
|
+
* An id the caller already carried is kept for all four: its own attribution is
|
|
800
|
+
* better information than a derivation made here.
|
|
801
|
+
*/
|
|
802
|
+
export function withGatewayChatHeaders(headers, preparedBody) {
|
|
803
|
+
let body
|
|
804
|
+
try {
|
|
805
|
+
const parsed = JSON.parse(preparedBody)
|
|
806
|
+
body = typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : undefined
|
|
807
|
+
} catch {
|
|
808
|
+
body = undefined
|
|
809
|
+
}
|
|
810
|
+
const messageId = conversationIdHex()
|
|
811
|
+
if (headers['X-Conversation-Message-ID'] === undefined) headers['X-Conversation-Message-ID'] = messageId
|
|
812
|
+
// The official client has these two be one value.
|
|
813
|
+
if (headers['X-Request-ID'] === undefined) headers['X-Request-ID'] = headers['X-Conversation-Message-ID']
|
|
814
|
+
const turn = turnKeyOf(body)
|
|
815
|
+
if (headers['X-Conversation-Request-ID'] === undefined) {
|
|
816
|
+
headers['X-Conversation-Request-ID'] = turn === '' ? conversationIdHex() : derivedConversationId('turn', turn)
|
|
817
|
+
}
|
|
818
|
+
// The root request id is the same value as the conversation request id: one
|
|
819
|
+
// user send is one request, and the upstream counts it by that id.
|
|
820
|
+
if (headers['X-Root-Request-ID'] === undefined) headers['X-Root-Request-ID'] = headers['X-Conversation-Request-ID']
|
|
821
|
+
const conversation = conversationKeyOf(body)
|
|
822
|
+
if (conversation !== '' && headers['X-Conversation-ID'] === undefined) {
|
|
823
|
+
// The conversation id is a UUID upstream, not a digest: it names the
|
|
824
|
+
// conversation rather than a hash of it.
|
|
825
|
+
//
|
|
826
|
+
// It must be STABLE for the whole conversation, because the upstream keys
|
|
827
|
+
// its prefix cache by it. Measured 2026-11-14 against the CN gateway: with
|
|
828
|
+
// a fresh UUID per request, `hy4free` reported 0 cached tokens on three
|
|
829
|
+
// identical ~20k-token sends; holding this one id fixed reported 20672.
|
|
830
|
+
// (`deepseek-v4.1-flash` caches either way, which is why the regression
|
|
831
|
+
// looked model-specific.) Deriving it from the conversation key gives the
|
|
832
|
+
// same "one conversation, one id" identity the caller already has.
|
|
833
|
+
headers['X-Conversation-ID'] = conversationUuidOf(conversation)
|
|
834
|
+
}
|
|
835
|
+
return headers
|
|
836
|
+
}
|
|
837
|
+
|
|
838
|
+
/** A stable UUID-shaped id naming one conversation key. */
|
|
839
|
+
function conversationUuidOf(conversation) {
|
|
840
|
+
const hex = createHash('sha256')
|
|
841
|
+
.update(`${CONVERSATION_ID_SALT}|conversation-id|${conversation}`)
|
|
842
|
+
.digest('hex')
|
|
843
|
+
.slice(0, 32)
|
|
844
|
+
return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
|
|
845
|
+
}
|
|
846
|
+
|
|
847
|
+
/**
|
|
848
|
+
* Normalize the reasoning effort a body carries.
|
|
849
|
+
*
|
|
850
|
+
* "Default" goes on the wire as the level the upstream itself declares as its
|
|
851
|
+
* default. Only when the catalog carries no `defaultEffort` is the field
|
|
852
|
+
* dropped, which leaves the choice to the upstream.
|
|
853
|
+
*/
|
|
854
|
+
/**
|
|
855
|
+
* Rewrite the reasoning effort a body carries into a spelling the upstream
|
|
856
|
+
* accepts.
|
|
857
|
+
*
|
|
858
|
+
* The upstream has no `off` spelling at all: `reasoning_effort: "off"` is
|
|
859
|
+
* refused with HTTP 400 / code 11133 by every model, and by nine of them
|
|
860
|
+
* specifically even when it is spelled as a *declared* default. So:
|
|
861
|
+
*
|
|
862
|
+
* - "Default"/"auto"/"off"/"disabled" all become the model's own declared
|
|
863
|
+
* default effort, and the field is dropped when the model declares none.
|
|
864
|
+
* - A model on the refusal list never carries `off` on the wire, whatever the
|
|
865
|
+
* caller asked for.
|
|
866
|
+
*/
|
|
867
|
+
function normalizeReasoningEffort(obj, defaultEffort, modelId) {
|
|
868
|
+
const effort = obj['reasoning_effort']
|
|
869
|
+
if (typeof modelId === 'string' && REFUSES_OFF_MODEL_IDS.has(modelId) && effort === 'off') {
|
|
870
|
+
delete obj['reasoning_effort']
|
|
871
|
+
return
|
|
872
|
+
}
|
|
873
|
+
if (effort !== 'default' && effort !== 'auto' && effort !== 'off' && effort !== 'disabled') return
|
|
874
|
+
if (typeof defaultEffort === 'string' && defaultEffort.length > 0) obj['reasoning_effort'] = defaultEffort
|
|
875
|
+
else delete obj['reasoning_effort']
|
|
876
|
+
}
|
|
877
|
+
|
|
878
|
+
/**
|
|
879
|
+
* Translate the `max_completion_tokens` alias into the `max_tokens` field the
|
|
880
|
+
* upstream actually reads.
|
|
881
|
+
*
|
|
882
|
+
* OpenAI deprecated `max_tokens` in favour of the alias, so a newer client sends
|
|
883
|
+
* only the alias; the upstream ignores it and falls back to its own default
|
|
884
|
+
* output cap, which truncates long answers. An explicit `max_tokens` wins and
|
|
885
|
+
* the alias is then dropped rather than translated, and a value that is not a
|
|
886
|
+
* positive integer is dropped without translating — `0` and `null` mean "not
|
|
887
|
+
* set", and a negative or non-numeric value is malformed input that must not be
|
|
888
|
+
* laundered into a valid one.
|
|
889
|
+
*/
|
|
890
|
+
function translateMaxCompletionTokens(obj) {
|
|
891
|
+
const present = 'max_completion_tokens' in obj
|
|
892
|
+
const alias = obj['max_completion_tokens']
|
|
893
|
+
delete obj['max_completion_tokens']
|
|
894
|
+
if (!present || 'max_tokens' in obj) return
|
|
895
|
+
if (typeof alias === 'number' && Number.isInteger(alias) && alias > 0) obj['max_tokens'] = alias
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
/** Rewrite `role: "developer"` messages to `role: "system"`. */
|
|
899
|
+
function normalizeDeveloperRole(obj) {
|
|
900
|
+
const messages = obj['messages']
|
|
901
|
+
if (!Array.isArray(messages)) return
|
|
902
|
+
for (const message of messages) {
|
|
903
|
+
if (typeof message !== 'object' || message === null || Array.isArray(message)) continue
|
|
904
|
+
if (message['role'] === 'developer') message['role'] = 'system'
|
|
905
|
+
}
|
|
906
|
+
}
|
|
907
|
+
|
|
908
|
+
/** Rewrite OpenAI `tool_choice` spellings into the upstream's string form. */
|
|
909
|
+
function normalizeToolChoice(obj) {
|
|
910
|
+
const suppress = () => {
|
|
911
|
+
delete obj['tools']
|
|
912
|
+
delete obj['functions']
|
|
913
|
+
}
|
|
914
|
+
if (!('tool_choice' in obj)) return
|
|
915
|
+
const choice = obj['tool_choice']
|
|
916
|
+
if (typeof choice === 'string') {
|
|
917
|
+
if (choice.trim().toLowerCase() === 'none') {
|
|
918
|
+
delete obj['tool_choice']
|
|
919
|
+
suppress()
|
|
920
|
+
}
|
|
921
|
+
return
|
|
922
|
+
}
|
|
923
|
+
if (typeof choice === 'object' && choice !== null && !Array.isArray(choice)) {
|
|
924
|
+
const type = typeof choice['type'] === 'string' ? choice['type'].trim().toLowerCase() : ''
|
|
925
|
+
if (type === 'none') {
|
|
926
|
+
delete obj['tool_choice']
|
|
927
|
+
suppress()
|
|
928
|
+
} else if (type === 'auto' || type === 'required') {
|
|
929
|
+
obj['tool_choice'] = type
|
|
930
|
+
} else if (type === 'function') {
|
|
931
|
+
const fn = typeof choice['function'] === 'object' && choice['function'] !== null ? choice['function'] : undefined
|
|
932
|
+
let name = typeof fn?.['name'] === 'string' ? fn['name'] : ''
|
|
933
|
+
if (name === '' && typeof choice['name'] === 'string') name = choice['name']
|
|
934
|
+
name = name.trim()
|
|
935
|
+
obj['tool_choice'] = name !== '' ? name : 'auto'
|
|
936
|
+
} else {
|
|
937
|
+
delete obj['tool_choice']
|
|
938
|
+
}
|
|
939
|
+
return
|
|
940
|
+
}
|
|
941
|
+
delete obj['tool_choice']
|
|
942
|
+
}
|
|
943
|
+
|
|
944
|
+
/**
|
|
945
|
+
* Normalize the `stop` field into the shape the upstream reads.
|
|
946
|
+
*
|
|
947
|
+
* The upstream's field is a list of strings; a bare string is refused with
|
|
948
|
+
* HTTP 400 / code 11101 ("cannot unmarshal into field of type []string").
|
|
949
|
+
*/
|
|
950
|
+
function normalizeStop(obj) {
|
|
951
|
+
if (typeof obj['stop'] === 'string') obj['stop'] = [obj['stop']]
|
|
952
|
+
}
|
|
953
|
+
|
|
954
|
+
/**
|
|
955
|
+
* Normalize the `arguments` of every tool call in the request history.
|
|
956
|
+
*
|
|
957
|
+
* The upstream reads `tool_calls[].function.arguments` as a *string*; an
|
|
958
|
+
* object, a list, a number or a boolean is refused with the same 11101. A
|
|
959
|
+
* caller that modelled the arguments as structured JSON is serialised rather
|
|
960
|
+
* than dropped, because the tool's result is matched against what the model
|
|
961
|
+
* saw.
|
|
962
|
+
*/
|
|
963
|
+
function normalizeToolCallArguments(obj) {
|
|
964
|
+
const messages = obj['messages']
|
|
965
|
+
if (!Array.isArray(messages)) return
|
|
966
|
+
for (const message of messages) {
|
|
967
|
+
if (typeof message !== 'object' || message === null) continue
|
|
968
|
+
const calls = message['tool_calls']
|
|
969
|
+
if (!Array.isArray(calls)) continue
|
|
970
|
+
for (const call of calls) {
|
|
971
|
+
if (typeof call !== 'object' || call === null) continue
|
|
972
|
+
const fn = call['function']
|
|
973
|
+
if (typeof fn !== 'object' || fn === null) continue
|
|
974
|
+
const args = fn['arguments']
|
|
975
|
+
if (typeof args === 'string') continue
|
|
976
|
+
if (args === undefined || args === null) {
|
|
977
|
+
fn['arguments'] = ''
|
|
978
|
+
continue
|
|
979
|
+
}
|
|
980
|
+
try {
|
|
981
|
+
fn['arguments'] = JSON.stringify(args)
|
|
982
|
+
} catch {
|
|
983
|
+
fn['arguments'] = ''
|
|
984
|
+
}
|
|
985
|
+
}
|
|
986
|
+
}
|
|
987
|
+
}
|
|
988
|
+
|
|
989
|
+
/**
|
|
990
|
+
* Substrings the upstream's channel check treats as a competing client.
|
|
991
|
+
*
|
|
992
|
+
* The gateway refuses a request with HTTP 400 / code 11128 ("Illegal API
|
|
993
|
+
* invocation from an unapproved channel") when one of these appears in the
|
|
994
|
+
* prompt — the check is on the *content* of the messages, not on the request's
|
|
995
|
+
* shape, and it fires whether the string is a whole phrase or a contiguous
|
|
996
|
+
* substring of one.
|
|
997
|
+
*
|
|
998
|
+
* Two of them are ordinary things a coding harness puts in its system prompt:
|
|
999
|
+
* a line naming the current git branch ("Main branch (…") and a reference to
|
|
1000
|
+
* a GitHub organisation. So the sanitization is narrow and mechanical: it
|
|
1001
|
+
* rewrites the marker, not the meaning.
|
|
1002
|
+
*/
|
|
1003
|
+
const WAF_MARKERS = [
|
|
1004
|
+
['x-anthropic-billing-header', 'x-anthropic-billing-entry'],
|
|
1005
|
+
['You are Claude Code', 'You are an AI coding assistant'],
|
|
1006
|
+
['You are a coding agent running in the Codex CLI', 'You are an AI coding agent'],
|
|
1007
|
+
// The CN gateway refuses a message whose FIRST LINE opens with a client
|
|
1008
|
+
// identity that is not theirs — and this harness's own opening line is on
|
|
1009
|
+
// that list. The check is a literal prefix (a leading space, or the same
|
|
1010
|
+
// sentence further down, slips past), so the opening line has to be
|
|
1011
|
+
// rewritten rather than the phrase merely removed.
|
|
1012
|
+
//
|
|
1013
|
+
// It reads that line out of a system message *and* out of an assistant
|
|
1014
|
+
// message: a reply that quotes its own instructions back poisons the history
|
|
1015
|
+
// for every later turn of that conversation, which is how a session that
|
|
1016
|
+
// worked yesterday fails today with the very same code.
|
|
1017
|
+
['You are an AI agent powered by DeepSeek Harness', 'You are an AI coding assistant'],
|
|
1018
|
+
// 2026-10-24: the CN check grew past first lines. It now fingerprint-matches
|
|
1019
|
+
// the *assembled* harness system prompt, and the prompt itself grew two more
|
|
1020
|
+
// sentences that name the product — the runtime-context section ("…names the
|
|
1021
|
+
// DeepSeek Harness implementation checkout…") and the Web GUI section
|
|
1022
|
+
// ("…through the DeepSeek Harness Web GUI…"). A prompt carrying both passes
|
|
1023
|
+
// neither the old first-line rule nor any single-phrase probe (each sentence
|
|
1024
|
+
// alone is answered 200), yet is refused deterministically — the refusal
|
|
1025
|
+
// needs the prompt's own wording to survive. Rewriting the product name
|
|
1026
|
+
// wherever it outlives the specific first-line marker breaks the match
|
|
1027
|
+
// (measured: the same request deterministically fails with the name intact
|
|
1028
|
+
// and streams with it rewritten).
|
|
1029
|
+
//
|
|
1030
|
+
// 2026-10-25: the system-only rewrite proved necessary but not sufficient.
|
|
1031
|
+
// A five-day conversation whose every turn still failed carried the product
|
|
1032
|
+
// name 91 times in assistant messages and 75 times in tool results — a
|
|
1033
|
+
// session where the model had read and quoted this plugin's own source —
|
|
1034
|
+
// with the system prompt already sanitized. The scan therefore reaches the
|
|
1035
|
+
// rest of the transcript too, so this row is marked `"deep"`: it is also
|
|
1036
|
+
// rewritten anywhere in an assistant message and inside tool results. User
|
|
1037
|
+
// messages stay untouched (measured 2026-10-24: several user-side mentions
|
|
1038
|
+
// alongside a clean system message pass), which keeps the human's own words
|
|
1039
|
+
// verbatim even when they quote this file.
|
|
1040
|
+
//
|
|
1041
|
+
// This row is ordered after the one above, so the opening line still gets
|
|
1042
|
+
// its friendlier replacement and only the later sentences are shortened.
|
|
1043
|
+
['DeepSeek Harness', 'DSH', 'deep'],
|
|
1044
|
+
['cc_entrypoint=', 'cc_entry='],
|
|
1045
|
+
['Main branch (', 'Default branch ('],
|
|
1046
|
+
['github.com/anthropics/', 'github.com/anthropic-clients/'],
|
|
1047
|
+
['Sisyphus-Junior - Focused executor from OhMyOpenCode', 'An AI coding executor'],
|
|
1048
|
+
// 2026-10-28: the CN check also fingerprints the harness's *path-resolution*
|
|
1049
|
+
// paragraph, which carries no product name at all — so the `deep` row above
|
|
1050
|
+
// never touched it and a session stayed refused no matter how the name was
|
|
1051
|
+
// rewritten. Bisected sentence by sentence: each of the two sentences alone is
|
|
1052
|
+
// answered 200, and only their adjacency is refused, so the match spans the
|
|
1053
|
+
// pair rather than living in either one. Splitting the pair with a newline,
|
|
1054
|
+
// reordering it, or rewording either sentence all clear it; rewording is used
|
|
1055
|
+
// here because it leaves the prompt's meaning and length intact while leaving
|
|
1056
|
+
// no contiguous span for the scan to fingerprint.
|
|
1057
|
+
//
|
|
1058
|
+
// 2026-10-31: this row has to be `"deep"`. Measured on the live CN gateway:
|
|
1059
|
+
// the pair is refused in an assistant message **mid-sentence** as well as at a
|
|
1060
|
+
// line start (both 11128), and a tool result carrying it is answered 200. The
|
|
1061
|
+
// non-deep scope only rewrites an assistant *line start*, so a model that
|
|
1062
|
+
// quotes the paragraph inside a sentence kept the session refused — which is
|
|
1063
|
+
// exactly how a working conversation poisons its own later turns.
|
|
1064
|
+
//
|
|
1065
|
+
// There is no scope narrower than `deep` that reaches an assistant
|
|
1066
|
+
// mid-sentence, so accepting this row also rewrites the pair inside tool
|
|
1067
|
+
// results, where the gateway does not currently check it. That over-reach is
|
|
1068
|
+
// deliberate: the scan has already widened twice (first-line → assembled
|
|
1069
|
+
// system prompt → whole transcript), and a name-for-name substitution costs
|
|
1070
|
+
// nothing in a tool result, while missing the next widening strands the whole
|
|
1071
|
+
// CN route again.
|
|
1072
|
+
[
|
|
1073
|
+
'Tokens prefixed with @ are paths the user explicitly referenced. Relative paths resolve from the workspace root;',
|
|
1074
|
+
'Tokens beginning with @ are paths the user explicitly referenced. Relative paths are resolved from the workspace root;',
|
|
1075
|
+
'deep',
|
|
1076
|
+
],
|
|
1077
|
+
]
|
|
1078
|
+
|
|
1079
|
+
/**
|
|
1080
|
+
* Rewrite the channel markers inside the request's messages.
|
|
1081
|
+
*
|
|
1082
|
+
* The CN gateway reads the markers out of **two** roles, not one:
|
|
1083
|
+
*
|
|
1084
|
+
* - the **system** message, anywhere in it (a substring rewrite is enough);
|
|
1085
|
+
* - an **assistant** message, but only when the marker opens a line — this is
|
|
1086
|
+
* the one that bites a working session: the model paraphrases or quotes its
|
|
1087
|
+
* own instructions back into the reply, and the next turn's history then
|
|
1088
|
+
* carries the phrase. A single successful turn is therefore enough to poison
|
|
1089
|
+
* every later turn of that conversation.
|
|
1090
|
+
*
|
|
1091
|
+
* User and tool messages are left alone: the same phrase there is the human's
|
|
1092
|
+
* own text (or a file's), and rewriting it would corrupt the conversation. The
|
|
1093
|
+
* check does not fire on those roles either — measured, only system and
|
|
1094
|
+
* assistant.
|
|
1095
|
+
*
|
|
1096
|
+
* The one exception is a marker marked `"deep"`: the product name this harness
|
|
1097
|
+
* itself is fingerprinted by. Once the gateway's scan grew to the whole
|
|
1098
|
+
* transcript (2026-10-25, see {@link WAF_MARKERS}), such a marker is rewritten
|
|
1099
|
+
* **anywhere in an assistant message and inside tool results** too — a tool
|
|
1100
|
+
* result quoting this plugin's own source is exactly how a long session stays
|
|
1101
|
+
* refused forever. User messages remain untouched even for a deep marker.
|
|
1102
|
+
*
|
|
1103
|
+
* Content arrives in two shapes and **both** have to be handled: a plain string,
|
|
1104
|
+
* or an array of content parts (`{type:'text',text}` and friends). A body whose
|
|
1105
|
+
* content is an array is refused by the gateway exactly like a string body that
|
|
1106
|
+
* carries the marker, so skipping arrays would leave the whole rewrite inert on
|
|
1107
|
+
* any client that sends parts — which is what every OpenAI-compatible SDK does
|
|
1108
|
+
* for a multimodal or block-shaped transcript.
|
|
1109
|
+
*/
|
|
1110
|
+
function sanitizeSystemMessages(obj) {
|
|
1111
|
+
const messages = obj['messages']
|
|
1112
|
+
if (!Array.isArray(messages)) return
|
|
1113
|
+
for (const message of messages) {
|
|
1114
|
+
if (typeof message !== 'object' || message === null) continue
|
|
1115
|
+
const role = message['role']
|
|
1116
|
+
const isSystem = role === 'system'
|
|
1117
|
+
const isAssistant = role === 'assistant'
|
|
1118
|
+
if (!isSystem && !isAssistant && role !== 'tool') continue
|
|
1119
|
+
const deepOnly = role === 'tool'
|
|
1120
|
+
// A deep marker also travels inside an assistant's recorded tool calls: the
|
|
1121
|
+
// arguments are what the model once sent to write a file, and a file it
|
|
1122
|
+
// wrote from this plugin's source quotes the name the same way a reply
|
|
1123
|
+
// does. Plain identifier replacement inside the serialised JSON is safe.
|
|
1124
|
+
if (isAssistant && Array.isArray(message['tool_calls'])) {
|
|
1125
|
+
for (const call of message['tool_calls']) {
|
|
1126
|
+
const fn = typeof call === 'object' && call !== null ? call['function'] : undefined
|
|
1127
|
+
const args = typeof fn === 'object' && fn !== null ? fn['arguments'] : undefined
|
|
1128
|
+
if (typeof args !== 'string' || !args.includes('DeepSeek Harness')) continue
|
|
1129
|
+
fn['arguments'] = args.split('DeepSeek Harness').join('DSH')
|
|
1130
|
+
}
|
|
1131
|
+
}
|
|
1132
|
+
const content = message['content']
|
|
1133
|
+
if (Array.isArray(content)) {
|
|
1134
|
+
// Parts shape: rewrite the text of each text part in place, so the
|
|
1135
|
+
// surrounding structure (images, cache hints) is preserved.
|
|
1136
|
+
for (const part of content) {
|
|
1137
|
+
if (typeof part !== 'object' || part === null) continue
|
|
1138
|
+
const text = part['text']
|
|
1139
|
+
if (typeof text !== 'string') continue
|
|
1140
|
+
const next = rewriteMarkers(text, isSystem, deepOnly)
|
|
1141
|
+
if (next !== text) part['text'] = next
|
|
1142
|
+
}
|
|
1143
|
+
continue
|
|
1144
|
+
}
|
|
1145
|
+
if (typeof content !== 'string') continue
|
|
1146
|
+
const next = rewriteMarkers(content, isSystem, deepOnly)
|
|
1147
|
+
if (next !== content) message['content'] = next
|
|
1148
|
+
}
|
|
1149
|
+
}
|
|
1150
|
+
|
|
1151
|
+
/**
|
|
1152
|
+
* Rewrite every marker in one piece of text.
|
|
1153
|
+
*
|
|
1154
|
+
* A system message is matched anywhere; an assistant message only where the
|
|
1155
|
+
* marker opens a line, which is the shape the gateway actually refuses — except
|
|
1156
|
+
* for a `deep` marker, which is matched anywhere there too. `deepOnly` (a tool
|
|
1157
|
+
* message) applies the deep markers, anywhere in the text: a tool result is the
|
|
1158
|
+
* machine's own output, so rewriting it is fair game, but only the fingerprint
|
|
1159
|
+
* it would otherwise keep reproducing.
|
|
1160
|
+
*/
|
|
1161
|
+
function rewriteMarkers(text, isSystem, deepOnly = false) {
|
|
1162
|
+
let next = text
|
|
1163
|
+
for (const marker of WAF_MARKERS) {
|
|
1164
|
+
const [needle, replacement, scope] = marker
|
|
1165
|
+
const deep = scope === 'deep'
|
|
1166
|
+
if (deepOnly && !deep) continue
|
|
1167
|
+
if (!next.includes(needle)) continue
|
|
1168
|
+
if (isSystem || deep) {
|
|
1169
|
+
next = next.split(needle).join(replacement)
|
|
1170
|
+
continue
|
|
1171
|
+
}
|
|
1172
|
+
next = next.split('\n').map(line => {
|
|
1173
|
+
if (!line.startsWith(needle)) return line
|
|
1174
|
+
return replacement + line.slice(needle.length)
|
|
1175
|
+
}).join('\n')
|
|
1176
|
+
}
|
|
1177
|
+
return next
|
|
1178
|
+
}
|
|
1179
|
+
|
|
1180
|
+
/**
|
|
1181
|
+
* Normalize an OpenAI chat-completions body for the WorkBuddy upstream: force
|
|
1182
|
+
* `stream: true` (the upstream rejects non-streaming with code 11101),
|
|
1183
|
+
* translate the `max_completion_tokens` alias, default `stream_options`,
|
|
1184
|
+
* flatten `tool_choice` (the upstream's field is a string; object forms return
|
|
1185
|
+
* 400), rewrite `developer` messages as `system`, and drop the provider-default
|
|
1186
|
+
* reasoning levels.
|
|
1187
|
+
*
|
|
1188
|
+
* The `developer` rewrite is load-bearing: pi-ai emits the system prompt as
|
|
1189
|
+
* `role: "developer"` (the OpenAI convention it adopted), but the WorkBuddy
|
|
1190
|
+
* upstream rejects that role with HTTP 400 code 11128.
|
|
1191
|
+
*/
|
|
1192
|
+
export function prepareChatBody(source, options) {
|
|
1193
|
+
let body
|
|
1194
|
+
try {
|
|
1195
|
+
body = JSON.parse(source)
|
|
1196
|
+
} catch {
|
|
1197
|
+
return source
|
|
1198
|
+
}
|
|
1199
|
+
if (typeof body !== 'object' || body === null || Array.isArray(body)) return source
|
|
1200
|
+
const obj = body
|
|
1201
|
+
obj['stream'] = true
|
|
1202
|
+
translateMaxCompletionTokens(obj)
|
|
1203
|
+
// The official client always asks for usage on a streaming call, and the
|
|
1204
|
+
// upstream only reports it in the final frame when asked.
|
|
1205
|
+
if (!('stream_options' in obj)) obj['stream_options'] = { include_usage: true }
|
|
1206
|
+
normalizeDeveloperRole(obj)
|
|
1207
|
+
normalizeToolChoice(obj)
|
|
1208
|
+
normalizeStop(obj)
|
|
1209
|
+
normalizeToolCallArguments(obj)
|
|
1210
|
+
sanitizeSystemMessages(obj)
|
|
1211
|
+
normalizeReasoningEffort(obj, options?.defaultEffort, options?.modelId)
|
|
1212
|
+
// pi-ai sets `store: false` on every OpenAI chat call. That is an OpenAI-only
|
|
1213
|
+
// field: the WorkBuddy upstream rejects the whole request with HTTP 400 /
|
|
1214
|
+
// code 11133. Neither the official client nor this plugin's own probe calls
|
|
1215
|
+
// ever send it, so drop it before forwarding.
|
|
1216
|
+
delete obj['store']
|
|
1217
|
+
return JSON.stringify(obj)
|
|
1218
|
+
}
|
|
1219
|
+
|
|
1220
|
+
/**
|
|
1221
|
+
* The system prompt injected when the international endpoint receives a body
|
|
1222
|
+
* with none.
|
|
1223
|
+
*
|
|
1224
|
+
* Minimal on purpose: it exists to satisfy a gateway precondition, not to
|
|
1225
|
+
* steer the model. The plugin is not the place to invent a persona, and the
|
|
1226
|
+
* normal path never reaches this — pi-ai already sends the harness's system
|
|
1227
|
+
* prompt, so this only covers a caller that omitted one.
|
|
1228
|
+
*/
|
|
1229
|
+
export const INTERNATIONAL_SYSTEM_PROMPT = 'You are a helpful assistant.'
|
|
1230
|
+
|
|
1231
|
+
/**
|
|
1232
|
+
* Apply the international endpoint's extra chat requirement: the first message
|
|
1233
|
+
* must be a system prompt.
|
|
1234
|
+
*
|
|
1235
|
+
* The international gateway rejects a body whose first message is not `system`
|
|
1236
|
+
* with HTTP 400 code 11128 ("first message is not system prompt"). Note that
|
|
1237
|
+
* the *same* code means something else on the CN endpoint — there it reports a
|
|
1238
|
+
* rejected `developer` role — so the two are never branched on by code alone.
|
|
1239
|
+
*
|
|
1240
|
+
* The added prompt is deliberately empty of user content and prepended, never
|
|
1241
|
+
* merged: existing messages keep their order and wording.
|
|
1242
|
+
*/
|
|
1243
|
+
export function prepareInternationalChatBody(source, options) {
|
|
1244
|
+
const prepared = prepareChatBody(source, options)
|
|
1245
|
+
let body
|
|
1246
|
+
try {
|
|
1247
|
+
body = JSON.parse(prepared)
|
|
1248
|
+
} catch {
|
|
1249
|
+
return prepared
|
|
1250
|
+
}
|
|
1251
|
+
if (typeof body !== 'object' || body === null || Array.isArray(body)) return prepared
|
|
1252
|
+
const messages = body['messages']
|
|
1253
|
+
if (!Array.isArray(messages)) return prepared
|
|
1254
|
+
const first = messages[0]
|
|
1255
|
+
if (typeof first === 'object' && first !== null && first['role'] === 'system') return prepared
|
|
1256
|
+
messages.unshift({ role: 'system', content: INTERNATIONAL_SYSTEM_PROMPT })
|
|
1257
|
+
return JSON.stringify(body)
|
|
1258
|
+
}
|
|
1259
|
+
|
|
1260
|
+
/**
|
|
1261
|
+
* Add a `prompt_cache_key` to an outbound chat body.
|
|
1262
|
+
*
|
|
1263
|
+
* The key is derived from the account's uid and its conversation, so the same
|
|
1264
|
+
* conversation on the same account reuses the upstream's prefix cache while two
|
|
1265
|
+
* accounts can never collide on one key — a collision would let one account hit
|
|
1266
|
+
* a cached prefix belonging to another.
|
|
1267
|
+
*/
|
|
1268
|
+
export function withPromptCacheKey(source, uid) {
|
|
1269
|
+
let body
|
|
1270
|
+
try {
|
|
1271
|
+
body = JSON.parse(source)
|
|
1272
|
+
} catch {
|
|
1273
|
+
return source
|
|
1274
|
+
}
|
|
1275
|
+
if (typeof body !== 'object' || body === null || Array.isArray(body)) return source
|
|
1276
|
+
const obj = body
|
|
1277
|
+
if (typeof obj['prompt_cache_key'] === 'string' && obj['prompt_cache_key'] !== '') return source
|
|
1278
|
+
const conversation = typeof obj['conversation_id'] === 'string' && obj['conversation_id'] !== ''
|
|
1279
|
+
? obj['conversation_id']
|
|
1280
|
+
: typeof obj['conversationId'] === 'string' && obj['conversationId'] !== '' ? obj['conversationId'] : ''
|
|
1281
|
+
obj['prompt_cache_key'] = buildPromptCacheKey(uid, conversation)
|
|
1282
|
+
return JSON.stringify(obj)
|
|
1283
|
+
}
|
|
1284
|
+
|
|
1285
|
+
/** The stable `wb2a-<uid8>-<conversationHash>` cache key for one account. */
|
|
1286
|
+
function buildPromptCacheKey(uid, conversation) {
|
|
1287
|
+
const accountSegment = uid === '' ? '-' : uid.slice(0, 8)
|
|
1288
|
+
const conversationHash = createHash('sha256').update(`${uid}|${conversation}`).digest('hex').slice(0, 32)
|
|
1289
|
+
return `wb2a-${accountSegment}-${conversationHash}`
|
|
1290
|
+
}
|
|
1291
|
+
|
|
1292
|
+
/** One JSON-envelope response from the upstream, already unwrapped. */
|
|
1293
|
+
async function readEnvelope(response) {
|
|
1294
|
+
const text = await response.text()
|
|
1295
|
+
let parsed
|
|
1296
|
+
try {
|
|
1297
|
+
parsed = JSON.parse(text)
|
|
1298
|
+
} catch {
|
|
1299
|
+
throw new Error(`workbuddy upstream returned non-JSON (http ${response.status}): ${text.slice(0, 160)}`)
|
|
1300
|
+
}
|
|
1301
|
+
if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
|
|
1302
|
+
throw new Error(`workbuddy upstream returned an unexpected document (http ${response.status})`)
|
|
1303
|
+
}
|
|
1304
|
+
const document = parsed
|
|
1305
|
+
return {
|
|
1306
|
+
code: typeof document['code'] === 'number' ? document['code'] : 0,
|
|
1307
|
+
msg: typeof document['msg'] === 'string' ? document['msg'] : '',
|
|
1308
|
+
data: 'data' in document ? document['data'] : undefined,
|
|
1309
|
+
// Carried alongside `data` because the two catalog shapes differ: the CN
|
|
1310
|
+
// endpoint always wraps (`{code,msg,data}`), while the international
|
|
1311
|
+
// `/v3/config` has also been observed answering with the product document
|
|
1312
|
+
// bare at the top level.
|
|
1313
|
+
document,
|
|
1314
|
+
}
|
|
1315
|
+
}
|
|
1316
|
+
|
|
1317
|
+
/** Turn an upstream envelope refusal into a message worth showing a human. */
|
|
1318
|
+
function envelopeError(status, envelope) {
|
|
1319
|
+
const code = envelope.code === 0 ? '' : ` (code ${envelope.code})`
|
|
1320
|
+
const message = envelope.msg === '' ? '' : `: ${envelope.msg}`
|
|
1321
|
+
return new Error(`workbuddy upstream refused the request (http ${status})${code}${message}`)
|
|
1322
|
+
}
|
|
1323
|
+
|
|
1324
|
+
/**
|
|
1325
|
+
* The chat paths to try, in order, for a realm.
|
|
1326
|
+
*
|
|
1327
|
+
* `/v2/chat/completions` is the path both deployments serve (measured 2026-10-20:
|
|
1328
|
+
* the international gateway answers it with a token refusal rather than a
|
|
1329
|
+
* routing miss, so the route is there). The console path is kept as a
|
|
1330
|
+
* fallback for a deployment that routes chat elsewhere — it costs a round trip
|
|
1331
|
+
* only when the first path 404s or 405s, never on the happy path.
|
|
1332
|
+
*/
|
|
1333
|
+
export function chatPaths(region) {
|
|
1334
|
+
return region === 'global' ? [CHAT_PATH, GLOBAL_CONSOLE_CHAT_PATH] : [CHAT_PATH]
|
|
1335
|
+
}
|
|
1336
|
+
|
|
1337
|
+
/**
|
|
1338
|
+
* Whether a 403 body is an interception page rather than an API refusal.
|
|
1339
|
+
*
|
|
1340
|
+
* A WAF block page is HTML, while this API's own refusals are JSON envelopes.
|
|
1341
|
+
* Retrying every 403 would double a permission failure that answers the same
|
|
1342
|
+
* way on both spellings.
|
|
1343
|
+
*/
|
|
1344
|
+
function isInterceptionPage(body) {
|
|
1345
|
+
const head = body.slice(0, 2048).toLowerCase()
|
|
1346
|
+
return head.includes('<html') || head.includes('<!doctype html')
|
|
1347
|
+
}
|
|
1348
|
+
|
|
1349
|
+
/**
|
|
1350
|
+
* Whether a failed request should be retried on the next candidate path.
|
|
1351
|
+
*
|
|
1352
|
+
* Deliberately narrow: a fall-through doubles the upstream request count for
|
|
1353
|
+
* that message, so it is reserved for failures that mean "this spelling is
|
|
1354
|
+
* unusable", never "this account or gateway is unhappy".
|
|
1355
|
+
*/
|
|
1356
|
+
export function pathFallbackStatus(status, body) {
|
|
1357
|
+
if (status === 404 || status === 405) return true
|
|
1358
|
+
if (status === 403 && body !== undefined) return isInterceptionPage(body)
|
|
1359
|
+
return false
|
|
1360
|
+
}
|
|
1361
|
+
|
|
1362
|
+
/**
|
|
1363
|
+
* The personal billing paths to try, in order, for a realm.
|
|
1364
|
+
*
|
|
1365
|
+
* The international deployment serves the meter without the `/v2` prefix; the
|
|
1366
|
+
* CN deployment serves it with one.
|
|
1367
|
+
*/
|
|
1368
|
+
export function billingMeterPaths(region) {
|
|
1369
|
+
const withVersion = '/v2/billing/meter/get-user-resource'
|
|
1370
|
+
const withoutVersion = '/billing/meter/get-user-resource'
|
|
1371
|
+
return region === 'global' ? [withoutVersion, withVersion] : [withVersion]
|
|
1372
|
+
}
|
|
1373
|
+
|
|
1374
|
+
function isObject(value) {
|
|
1375
|
+
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
|
1376
|
+
}
|
|
1377
|
+
|
|
1378
|
+
function positive(value) {
|
|
1379
|
+
return typeof value === 'number' && Number.isFinite(value) && value > 0
|
|
1380
|
+
}
|
|
1381
|
+
|
|
1382
|
+
/**
|
|
1383
|
+
* The agent list inside a catalog document.
|
|
1384
|
+
*
|
|
1385
|
+
* The upstream nests it two different ways, and both are live: the CN CLI
|
|
1386
|
+
* document answers with `data.agents`, while the international `/v3/config`
|
|
1387
|
+
* product document answers with `data.agent.agents` (measured 2026-10-20
|
|
1388
|
+
* against the live deployment). A parser that only looks at one of them sees
|
|
1389
|
+
* "no cli agent models" on the other.
|
|
1390
|
+
*/
|
|
1391
|
+
function catalogAgents(data) {
|
|
1392
|
+
if (Array.isArray(data['agents'])) return data['agents']
|
|
1393
|
+
const nested = data['agent']
|
|
1394
|
+
if (typeof nested === 'object' && nested !== null && Array.isArray(nested['agents'])) return nested['agents']
|
|
1395
|
+
return []
|
|
1396
|
+
}
|
|
1397
|
+
|
|
1398
|
+
/**
|
|
1399
|
+
* Parse either catalog shape after its envelope has been checked.
|
|
1400
|
+
*
|
|
1401
|
+
* The catalog names two lists: `models` (the full roster with its budgets) and
|
|
1402
|
+
* `agents` (the surfaces that may use them). The `cli` agent's model list is
|
|
1403
|
+
* the one this plugin serves — it is the roster the official CLI offers, and
|
|
1404
|
+
* the only one the chat endpoint accepts.
|
|
1405
|
+
*/
|
|
1406
|
+
export function parseModelCatalog(data, international = false) {
|
|
1407
|
+
const rawModels = Array.isArray(data['models']) ? data['models'] : []
|
|
1408
|
+
const agents = catalogAgents(data)
|
|
1409
|
+
let cliIds
|
|
1410
|
+
for (const agent of agents) {
|
|
1411
|
+
if (typeof agent === 'object' && agent !== null) {
|
|
1412
|
+
if (agent['name'] === 'cli' && Array.isArray(agent['models'])) {
|
|
1413
|
+
cliIds = agent['models'].filter(id => typeof id === 'string')
|
|
1414
|
+
break
|
|
1415
|
+
}
|
|
1416
|
+
}
|
|
1417
|
+
}
|
|
1418
|
+
if (cliIds === undefined || cliIds.length === 0) {
|
|
1419
|
+
throw new Error('workbuddy model catalog lists no cli agent models')
|
|
1420
|
+
}
|
|
1421
|
+
const byId = new Map()
|
|
1422
|
+
for (const model of rawModels) {
|
|
1423
|
+
if (typeof model !== 'object' || model === null) continue
|
|
1424
|
+
const id = typeof model['id'] === 'string' ? model['id'] : ''
|
|
1425
|
+
if (id === '' || model['disabled'] === true) continue
|
|
1426
|
+
const input = typeof model['maxInputTokens'] === 'number' ? model['maxInputTokens'] : 0
|
|
1427
|
+
const output = typeof model['maxOutputTokens'] === 'number' ? model['maxOutputTokens'] : 0
|
|
1428
|
+
if (input <= 0 || output <= 0) continue
|
|
1429
|
+
const declaredWindow = isObject(model['contextWindow']) && positive(model['contextWindow']['defaultLength'])
|
|
1430
|
+
? model['contextWindow']['defaultLength']
|
|
1431
|
+
: undefined
|
|
1432
|
+
byId.set(id, {
|
|
1433
|
+
id,
|
|
1434
|
+
name: typeof model['name'] === 'string' && model['name'] !== '' ? model['name'] : id,
|
|
1435
|
+
contextWindow: international && declaredWindow !== undefined
|
|
1436
|
+
? declaredWindow
|
|
1437
|
+
// A CN row reports only the maximum; where the product document names a
|
|
1438
|
+
// smaller default, that default is what a deliverable request spans.
|
|
1439
|
+
: Math.min(input, DEFAULT_CONTEXT_WINDOWS.get(id) ?? input),
|
|
1440
|
+
...(international
|
|
1441
|
+
? {
|
|
1442
|
+
...declaredWindow === undefined ? {} : { defaultContextWindow: declaredWindow },
|
|
1443
|
+
maxInputTokens: input,
|
|
1444
|
+
supportedContextWindows: isObject(model['contextWindow']) && Array.isArray(model['contextWindow']['supportedLengths'])
|
|
1445
|
+
? model['contextWindow']['supportedLengths'].filter(positive)
|
|
1446
|
+
: [],
|
|
1447
|
+
promotions: parsePromotions(data['modelPromotions'], id),
|
|
1448
|
+
}
|
|
1449
|
+
: {}),
|
|
1450
|
+
maxTokens: output,
|
|
1451
|
+
supportsImages: model['supportsImages'] === true
|
|
1452
|
+
&& model['disabledMultimodal'] !== true
|
|
1453
|
+
&& !TEXT_ONLY_MODEL_IDS.has(id),
|
|
1454
|
+
...resolveUpstreamReasoning(model),
|
|
1455
|
+
...resolveUpstreamBilling(model),
|
|
1456
|
+
})
|
|
1457
|
+
}
|
|
1458
|
+
const models = cliIds.map(id => byId.get(id)).filter(model => model !== undefined)
|
|
1459
|
+
if (models.length === 0) throw new Error('workbuddy model catalog resolved to an empty list')
|
|
1460
|
+
return models
|
|
1461
|
+
}
|
|
1462
|
+
|
|
1463
|
+
/** One verified promotion entry. */
|
|
1464
|
+
export function parsePromotions(value, model) {
|
|
1465
|
+
if (!Array.isArray(value)) return []
|
|
1466
|
+
return value.flatMap(item => {
|
|
1467
|
+
if (!isObject(item) || item['enabled'] !== true) return []
|
|
1468
|
+
const modelIds = item['modelIds']
|
|
1469
|
+
if (!Array.isArray(modelIds) || !modelIds.includes(model)) return []
|
|
1470
|
+
const schedule = item['schedule']
|
|
1471
|
+
const discount = item['discount']
|
|
1472
|
+
const badge = item['badge']
|
|
1473
|
+
if (!isObject(schedule) || !isObject(discount) || !isObject(badge)) return []
|
|
1474
|
+
// Only a replacement discount has an unambiguous display rule; any other
|
|
1475
|
+
// display mode is left to the upstream's own client.
|
|
1476
|
+
if (discount['displayMode'] !== 'replace') return []
|
|
1477
|
+
const start = typeof schedule['validFrom'] === 'string' ? Date.parse(schedule['validFrom']) : Number.NaN
|
|
1478
|
+
const end = typeof schedule['validUntil'] === 'string' ? Date.parse(schedule['validUntil']) : Number.NaN
|
|
1479
|
+
const factor = discount['factor']
|
|
1480
|
+
if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return []
|
|
1481
|
+
if (typeof factor !== 'number' || !Number.isFinite(factor) || factor < 0) return []
|
|
1482
|
+
return [{
|
|
1483
|
+
start,
|
|
1484
|
+
end,
|
|
1485
|
+
factor,
|
|
1486
|
+
label: typeof badge['label'] === 'string' ? badge['label'] : '',
|
|
1487
|
+
priority: typeof item['priority'] === 'number' && Number.isFinite(item['priority']) ? item['priority'] : 0,
|
|
1488
|
+
}]
|
|
1489
|
+
})
|
|
1490
|
+
}
|
|
1491
|
+
|
|
1492
|
+
/**
|
|
1493
|
+
* Re-evaluate a model's promotion against the current time.
|
|
1494
|
+
*
|
|
1495
|
+
* Promotions are time-boxed, and the catalog they arrive in is cached for the
|
|
1496
|
+
* life of the process. Frozen at parse time, a cached "Free now" would keep
|
|
1497
|
+
* claiming a discount after `validUntil` had passed — and `free: true` is the
|
|
1498
|
+
* worst case of it: the user would be told a model costs nothing when it does
|
|
1499
|
+
* not.
|
|
1500
|
+
*
|
|
1501
|
+
* Non-destructive: the model's own `credits` and `badges` are the base, and the
|
|
1502
|
+
* promotion is layered onto a copy.
|
|
1503
|
+
*/
|
|
1504
|
+
export function modelWithCurrentPromotion(model, now = Date.now()) {
|
|
1505
|
+
if (model.promotions === undefined || model.promotions.length === 0) return model
|
|
1506
|
+
const promotion = [...model.promotions]
|
|
1507
|
+
.sort((a, b) => b.priority - a.priority)
|
|
1508
|
+
.find(candidate => now >= candidate.start && now < candidate.end)
|
|
1509
|
+
if (promotion === undefined) {
|
|
1510
|
+
// This row arrives with promotions attached, but none is in force now. The
|
|
1511
|
+
// upstream bakes the discounted value into `credits` itself, so keeping
|
|
1512
|
+
// that value would advertise a discount that has ended.
|
|
1513
|
+
const derivedFromPromotion = model.billing?.free === true
|
|
1514
|
+
|| (model.billing?.badges?.length ?? 0) > 0
|
|
1515
|
+
|| model.promotions.some(candidate => candidate.factor !== 1)
|
|
1516
|
+
if (!derivedFromPromotion) return model
|
|
1517
|
+
// The lapsed rate is KEPT in `credits` so the settings card can show it
|
|
1518
|
+
// with an "expired" note, while `rateUnknown` keeps every other surface
|
|
1519
|
+
// from quoting it as current.
|
|
1520
|
+
const staleRate = normalizeCredits(model.billing?.credits)
|
|
1521
|
+
const expiredLabels = [...new Set(model.promotions.map(candidate => candidate.label).filter(label => typeof label === 'string' && label !== ''))]
|
|
1522
|
+
return {
|
|
1523
|
+
...model,
|
|
1524
|
+
billing: {
|
|
1525
|
+
free: false,
|
|
1526
|
+
rateUnknown: true,
|
|
1527
|
+
...staleRate === undefined ? {} : { credits: staleRate },
|
|
1528
|
+
...expiredLabels.length === 0 ? {} : { expiredPromotions: expiredLabels },
|
|
1529
|
+
},
|
|
1530
|
+
}
|
|
1531
|
+
}
|
|
1532
|
+
const rate = normalizeCredits(model.billing?.credits)
|
|
1533
|
+
const original = rate !== undefined && rate.startsWith('x') ? Number(rate.slice(1)) : Number.NaN
|
|
1534
|
+
// A replacement to zero is meaningful even when the base rate is unknown; any
|
|
1535
|
+
// other multiplier needs a number to scale, so it is skipped rather than
|
|
1536
|
+
// invented.
|
|
1537
|
+
if (promotion.factor !== 0 && !Number.isFinite(original)) return model
|
|
1538
|
+
const value = promotion.factor === 0 ? 0 : original * promotion.factor
|
|
1539
|
+
return {
|
|
1540
|
+
...model,
|
|
1541
|
+
billing: {
|
|
1542
|
+
...model.billing,
|
|
1543
|
+
credits: `x${value.toFixed(2)}`,
|
|
1544
|
+
free: value === 0,
|
|
1545
|
+
// De-duplicated, so applying the promotion to an already-promoted row is
|
|
1546
|
+
// a no-op: the catalog re-derives the promotion on every read, and a
|
|
1547
|
+
// label that accumulated would read `Free now · Free now` in the picker.
|
|
1548
|
+
badges: [...new Set([
|
|
1549
|
+
...(model.billing?.badges ?? []),
|
|
1550
|
+
...(promotion.label === '' ? [] : [promotion.label]),
|
|
1551
|
+
])],
|
|
1552
|
+
},
|
|
1553
|
+
}
|
|
1554
|
+
}
|
|
1555
|
+
|
|
1556
|
+
/**
|
|
1557
|
+
* The catalog endpoints to try, in order, for a region.
|
|
1558
|
+
*
|
|
1559
|
+
* Each candidate names a path, the User-Agent to present, and a short source
|
|
1560
|
+
* label for the status card.
|
|
1561
|
+
*
|
|
1562
|
+
* `/v3/config` comes first for BOTH regions, and the order matters: the
|
|
1563
|
+
* legacy per-enterprise document answers with the *CLI channel's* roster, whose
|
|
1564
|
+
* second slot is the paid `hy4-preview` (x0.29) while the product document
|
|
1565
|
+
* lists the free `hy4-preview-f` (x0.00) under the same display name. Serving
|
|
1566
|
+
* the legacy document first would therefore show a price that disagrees with
|
|
1567
|
+
* the desktop app and hide the free tier.
|
|
1568
|
+
*
|
|
1569
|
+
* The User-Agent matters too: the gateway splits the catalog by channel, and
|
|
1570
|
+
* the CLI channel's roster is a *smaller* one (it omits rows the App channel
|
|
1571
|
+
* serves). The international deployment is therefore asked with the App
|
|
1572
|
+
* channel first — the terse `WorkBuddyAI/<v>` spelling, because the spaced
|
|
1573
|
+
* `WorkBuddy AI/<v>` form is refused with 400/12403 — and the CN deployment
|
|
1574
|
+
* with the CLI channel, which is the channel its own client uses.
|
|
1575
|
+
*/
|
|
1576
|
+
export function catalogCandidates(international, appVersion) {
|
|
1577
|
+
if (international) {
|
|
1578
|
+
const version = appVersion?.version
|
|
1579
|
+
const app = []
|
|
1580
|
+
if (typeof version === 'string') {
|
|
1581
|
+
try {
|
|
1582
|
+
app.push({ path: '/v3/config', userAgent: appUserAgent(version), source: 'app' })
|
|
1583
|
+
} catch {
|
|
1584
|
+
// An invalid version is not worth a header: fall through to the
|
|
1585
|
+
// version-less spellings.
|
|
1586
|
+
}
|
|
1587
|
+
app.push({ path: '/v3/config', userAgent: `WorkBuddy/${version}`, source: 'app' })
|
|
1588
|
+
}
|
|
1589
|
+
app.push({ path: '/v3/config', userAgent: CLIENT_UA, source: 'cli' })
|
|
1590
|
+
app.push({ path: '/v2/enterprises/personal/models', userAgent: CLIENT_UA, source: 'cli' })
|
|
1591
|
+
app.push({ path: '/console/enterprises/personal/models', userAgent: CLIENT_UA, source: 'cli' })
|
|
1592
|
+
return app
|
|
1593
|
+
}
|
|
1594
|
+
return [
|
|
1595
|
+
{ path: '/v3/config', userAgent: CLIENT_UA, source: 'cli' },
|
|
1596
|
+
{ path: '/v2/enterprises/personal/models', userAgent: CLIENT_UA, source: 'cli' },
|
|
1597
|
+
{ path: '/console/enterprises/personal/models', userAgent: CLIENT_UA, source: 'cli' },
|
|
1598
|
+
]
|
|
1599
|
+
}
|
|
1600
|
+
|
|
1601
|
+
/**
|
|
1602
|
+
* Provenance of one successful catalog fetch, surfaced by the status card.
|
|
1603
|
+
*/
|
|
1604
|
+
export class WorkBuddyUpstreamClient {
|
|
1605
|
+
/**
|
|
1606
|
+
* @param {object} [options]
|
|
1607
|
+
* @param {() => Promise<object>} [options.resolveAppVersion] App-shaped UA version resolver.
|
|
1608
|
+
* @param {(region: string) => Promise<object>} [options.resolveChatIdentity] Chat-identity resolver.
|
|
1609
|
+
*/
|
|
1610
|
+
constructor(options = {}) {
|
|
1611
|
+
this.resolveAppVersion = options.resolveAppVersion ?? (() => resolveAppVersion())
|
|
1612
|
+
this.resolveChatIdentity = options.resolveChatIdentity ?? (region => resolveChatIdentity(region))
|
|
1613
|
+
/** Provenance of the most recent successful catalog fetch, for the card. */
|
|
1614
|
+
this.lastCatalog = undefined
|
|
1615
|
+
}
|
|
1616
|
+
|
|
1617
|
+
/**
|
|
1618
|
+
* POST the chat endpoint; a successful answer is the raw SSE response.
|
|
1619
|
+
*/
|
|
1620
|
+
async chatStream(credential, bodyJson, signal) {
|
|
1621
|
+
const region = realmOf(credential)
|
|
1622
|
+
// Identity resolution must never block a message: any failure — a thrown
|
|
1623
|
+
// resolver included — degrades to the desktop fallback form.
|
|
1624
|
+
let userAgent
|
|
1625
|
+
let clientVersion
|
|
1626
|
+
try {
|
|
1627
|
+
const identity = await this.resolveChatIdentity(region)
|
|
1628
|
+
userAgent = chatUserAgent(identity, region)
|
|
1629
|
+
clientVersion = identity.clientVersion
|
|
1630
|
+
} catch {
|
|
1631
|
+
const fallback = fallbackChatIdentity(region)
|
|
1632
|
+
userAgent = chatUserAgent(fallback, region)
|
|
1633
|
+
clientVersion = fallback.clientVersion
|
|
1634
|
+
}
|
|
1635
|
+
const body = withPromptCacheKey(
|
|
1636
|
+
region === 'global' ? prepareInternationalChatBody(bodyJson) : bodyJson,
|
|
1637
|
+
credential.uid,
|
|
1638
|
+
)
|
|
1639
|
+
// Built once from the prepared body and reused across the path fallback: a
|
|
1640
|
+
// sibling path retrying the same send is the same request, so its message
|
|
1641
|
+
// and turn ids must not rotate.
|
|
1642
|
+
const headers = withGatewayChatHeaders(chatHeaders(credential, userAgent, clientVersion), body)
|
|
1643
|
+
let response
|
|
1644
|
+
let lastFailure
|
|
1645
|
+
for (const path of chatPaths(region)) {
|
|
1646
|
+
let attempt
|
|
1647
|
+
try {
|
|
1648
|
+
attempt = await fetch(`${chatBase(credential)}${path}`, {
|
|
1649
|
+
method: 'POST',
|
|
1650
|
+
headers,
|
|
1651
|
+
body,
|
|
1652
|
+
...signal === undefined ? {} : { signal },
|
|
1653
|
+
})
|
|
1654
|
+
} catch (error) {
|
|
1655
|
+
// A transport failure on one spelling says nothing about the other. A
|
|
1656
|
+
// caller-initiated abort is the exception: that is the message being
|
|
1657
|
+
// cancelled and must not be retried against the next path.
|
|
1658
|
+
if (signal?.aborted === true) {
|
|
1659
|
+
return { ok: false, status: 0, kind: 'server', message: `transport error: ${String(error)}` }
|
|
1660
|
+
}
|
|
1661
|
+
lastFailure = { status: 0, text: `transport error: ${String(error)}` }
|
|
1662
|
+
continue
|
|
1663
|
+
}
|
|
1664
|
+
if (attempt.ok) {
|
|
1665
|
+
response = attempt
|
|
1666
|
+
break
|
|
1667
|
+
}
|
|
1668
|
+
// A body can only be read once, so capture it here: the failure keeps its
|
|
1669
|
+
// reason after a fallback attempt.
|
|
1670
|
+
const failureText = (await attempt.text()).slice(0, ERROR_BODY_LIMIT)
|
|
1671
|
+
lastFailure = { status: attempt.status, text: failureText }
|
|
1672
|
+
if (!pathFallbackStatus(attempt.status, failureText)) break
|
|
1673
|
+
}
|
|
1674
|
+
if (response !== undefined) return { ok: true, response }
|
|
1675
|
+
const failure = lastFailure ?? { status: 0, text: 'no chat endpoint answered' }
|
|
1676
|
+
return {
|
|
1677
|
+
ok: false,
|
|
1678
|
+
status: failure.status,
|
|
1679
|
+
// Status 0 is a transport failure, not a client-side rejection.
|
|
1680
|
+
kind: failure.status === 0 ? 'server' : classifyUpstreamError(failure.status, failure.text),
|
|
1681
|
+
message: failure.text,
|
|
1682
|
+
}
|
|
1683
|
+
}
|
|
1684
|
+
|
|
1685
|
+
/** POST the token-refresh endpoint; the caller merges the outcome. */
|
|
1686
|
+
async refreshToken(credential) {
|
|
1687
|
+
const response = await fetch(`${chatBase(credential)}/v2/plugin/auth/token/refresh`, {
|
|
1688
|
+
method: 'POST',
|
|
1689
|
+
headers: refreshHeaders(credential),
|
|
1690
|
+
signal: AbortSignal.timeout(JSON_TIMEOUT_MS),
|
|
1691
|
+
})
|
|
1692
|
+
const envelope = await readEnvelope(response)
|
|
1693
|
+
if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope)
|
|
1694
|
+
const data = typeof envelope.data === 'object' && envelope.data !== null ? envelope.data : {}
|
|
1695
|
+
const accessToken = typeof data['accessToken'] === 'string' ? data['accessToken'] : ''
|
|
1696
|
+
if (accessToken === '') throw new Error('workbuddy token refresh returned no accessToken; sign in again in the WorkBuddy app')
|
|
1697
|
+
const outcome = { accessToken }
|
|
1698
|
+
if (typeof data['refreshToken'] === 'string' && data['refreshToken'] !== '') outcome.refreshToken = data['refreshToken']
|
|
1699
|
+
if (typeof data['expiresIn'] === 'number' && data['expiresIn'] > 0) outcome.expiresInSec = data['expiresIn']
|
|
1700
|
+
if (typeof data['domain'] === 'string' && data['domain'] !== '') outcome.domain = data['domain']
|
|
1701
|
+
return outcome
|
|
1702
|
+
}
|
|
1703
|
+
|
|
1704
|
+
/**
|
|
1705
|
+
* GET the personal model catalog.
|
|
1706
|
+
*
|
|
1707
|
+
* The upstream serves the roster from more than one place, and which one
|
|
1708
|
+
* answers depends on the deployment *and* on the client channel the
|
|
1709
|
+
* User-Agent names — the international `/v3/config` document, the CN CLI
|
|
1710
|
+
* document, and their legacy spellings. The candidates are therefore tried
|
|
1711
|
+
* in order of measurement confidence and the first one that yields a
|
|
1712
|
+
* parsable catalog wins; a candidate that answers 200 with an empty roster
|
|
1713
|
+
* does not end the walk.
|
|
1714
|
+
*
|
|
1715
|
+
* The User-Agent matters here in a way it does not elsewhere: the gateway
|
|
1716
|
+
* splits the catalog by channel, and the CLI channel's roster is a *smaller*
|
|
1717
|
+
* one (it omits rows the App channel serves). The App-channel spelling is
|
|
1718
|
+
* therefore tried first.
|
|
1719
|
+
*/
|
|
1720
|
+
async fetchModels(credential, signal) {
|
|
1721
|
+
const international = realmOf(credential) === 'global'
|
|
1722
|
+
const appVersion = international ? await this.resolveAppVersion() : undefined
|
|
1723
|
+
const candidates = catalogCandidates(international, appVersion)
|
|
1724
|
+
let lastError
|
|
1725
|
+
for (const candidate of candidates) {
|
|
1726
|
+
try {
|
|
1727
|
+
const response = await fetch(`${chatBase(credential)}${candidate.path}`, {
|
|
1728
|
+
headers: {
|
|
1729
|
+
Authorization: `Bearer ${credential.accessToken}`,
|
|
1730
|
+
Accept: 'application/json',
|
|
1731
|
+
Origin: originReferer(credential),
|
|
1732
|
+
Referer: `${originReferer(credential)}/`,
|
|
1733
|
+
...international
|
|
1734
|
+
? {
|
|
1735
|
+
'X-Requested-With': 'XMLHttpRequest',
|
|
1736
|
+
'X-Product': 'SaaS',
|
|
1737
|
+
...credential.uid === '' ? {} : { 'X-User-Id': credential.uid },
|
|
1738
|
+
'X-Domain': domainHeaderFor(credential),
|
|
1739
|
+
}
|
|
1740
|
+
: {},
|
|
1741
|
+
'User-Agent': candidate.userAgent,
|
|
1742
|
+
},
|
|
1743
|
+
signal: signal === undefined
|
|
1744
|
+
? AbortSignal.timeout(JSON_TIMEOUT_MS)
|
|
1745
|
+
: AbortSignal.any([signal, AbortSignal.timeout(JSON_TIMEOUT_MS)]),
|
|
1746
|
+
})
|
|
1747
|
+
const envelope = await readEnvelope(response)
|
|
1748
|
+
if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope)
|
|
1749
|
+
// Two catalog shapes share this path. The endpoint always answers with
|
|
1750
|
+
// the `{code,msg,data}` wrapper; `/v3/config` has also been observed
|
|
1751
|
+
// answering with the product document bare at the top level.
|
|
1752
|
+
const data = isObject(envelope.data) ? envelope.data
|
|
1753
|
+
: 'models' in envelope.document || 'agent' in envelope.document || 'agents' in envelope.document ? envelope.document
|
|
1754
|
+
: {}
|
|
1755
|
+
const models = parseModelCatalog(data, international)
|
|
1756
|
+
this.lastCatalog = {
|
|
1757
|
+
fetchedAtMs: Date.now(),
|
|
1758
|
+
source: `${international ? 'workbuddy-ai' : 'workbuddy'}:${candidate.source}`,
|
|
1759
|
+
...appVersion === undefined ? {} : { appVersion },
|
|
1760
|
+
}
|
|
1761
|
+
return models
|
|
1762
|
+
} catch (error) {
|
|
1763
|
+
lastError = error
|
|
1764
|
+
}
|
|
1765
|
+
}
|
|
1766
|
+
throw lastError ?? new Error('workbuddy model catalog: no candidate endpoint answered')
|
|
1767
|
+
}
|
|
1768
|
+
|
|
1769
|
+
/**
|
|
1770
|
+
* POST the billing endpoint for the aggregated remaining credit.
|
|
1771
|
+
*
|
|
1772
|
+
* The personal endpoint serves a list of named packages; the card renders one
|
|
1773
|
+
* row per package. The international deployment serves the meter under a path
|
|
1774
|
+
* without the `/v2` prefix, so the candidates are tried in order and only a
|
|
1775
|
+
* routing miss falls through.
|
|
1776
|
+
*/
|
|
1777
|
+
async fetchCredits(credential) {
|
|
1778
|
+
const now = new Date()
|
|
1779
|
+
const format = date => [
|
|
1780
|
+
date.getFullYear().toString().padStart(4, '0'),
|
|
1781
|
+
(date.getMonth() + 1).toString().padStart(2, '0'),
|
|
1782
|
+
date.getDate().toString().padStart(2, '0'),
|
|
1783
|
+
].join('-') + ' ' + [
|
|
1784
|
+
date.getHours().toString().padStart(2, '0'),
|
|
1785
|
+
date.getMinutes().toString().padStart(2, '0'),
|
|
1786
|
+
date.getSeconds().toString().padStart(2, '0'),
|
|
1787
|
+
].join(':')
|
|
1788
|
+
const body = JSON.stringify({
|
|
1789
|
+
PageNumber: 1,
|
|
1790
|
+
PageSize: 100,
|
|
1791
|
+
ProductCode: 'p_tcaca',
|
|
1792
|
+
Status: [0, 3],
|
|
1793
|
+
PackageEndTimeRangeBegin: format(now),
|
|
1794
|
+
PackageEndTimeRangeEnd: format(new Date(now.getTime() + 365 * 24 * 3600 * 1000)),
|
|
1795
|
+
})
|
|
1796
|
+
let response
|
|
1797
|
+
let lastStatus = 0
|
|
1798
|
+
for (const path of billingMeterPaths(realmOf(credential))) {
|
|
1799
|
+
const attempt = await fetch(`${billingBase(credential)}${path}`, {
|
|
1800
|
+
method: 'POST',
|
|
1801
|
+
headers: billingHeaders(credential),
|
|
1802
|
+
body,
|
|
1803
|
+
signal: AbortSignal.timeout(JSON_TIMEOUT_MS),
|
|
1804
|
+
})
|
|
1805
|
+
lastStatus = attempt.status
|
|
1806
|
+
if (attempt.ok || !pathFallbackStatus(attempt.status)) {
|
|
1807
|
+
response = attempt
|
|
1808
|
+
break
|
|
1809
|
+
}
|
|
1810
|
+
}
|
|
1811
|
+
if (response === undefined) throw new Error(`workbuddy billing endpoint failed (http ${lastStatus})`)
|
|
1812
|
+
const envelope = await readEnvelope(response)
|
|
1813
|
+
if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope)
|
|
1814
|
+
return normalizeCreditsDocument(envelope.data)
|
|
1815
|
+
}
|
|
1816
|
+
}
|
|
1817
|
+
|
|
1818
|
+
/**
|
|
1819
|
+
* Reduce the billing document to the shape the card renders.
|
|
1820
|
+
*
|
|
1821
|
+
* The upstream nests its account list two ways in the field — the documented
|
|
1822
|
+
* `data.Response.Data.Accounts[]` and a flat `data.Accounts[]` — and names
|
|
1823
|
+
* the capacities either `Size`/`Remain` or `CapacitySize`/`CapacityRemain`.
|
|
1824
|
+
* Every capacity also arrives as a `*Precise` *string*; that fraction is
|
|
1825
|
+
* preferred, because the integer fields lose it and a credit balance shown
|
|
1826
|
+
* without its fraction is a balance that does not add up.
|
|
1827
|
+
*
|
|
1828
|
+
* The **cycle** family is the one that counts. The pool family
|
|
1829
|
+
* (`CapacitySize`/`CapacityRemain`) reports what the package *granted*, and a
|
|
1830
|
+
* spent monthly resource still reports the whole pool as remaining — "nothing
|
|
1831
|
+
* used, everything left" — while the cycle family reports what is left of
|
|
1832
|
+
* this cycle's allowance. The upstream's own client sums the cycle family, and
|
|
1833
|
+
* so does this: the pool is only a fallback for a row that carries no cycle
|
|
1834
|
+
* capacity at all.
|
|
1835
|
+
*/
|
|
1836
|
+
export function normalizeCreditsDocument(data) {
|
|
1837
|
+
const list = accountsOf(data)
|
|
1838
|
+
const accounts = []
|
|
1839
|
+
for (const entry of list) {
|
|
1840
|
+
if (typeof entry !== 'object' || entry === null) continue
|
|
1841
|
+
const cycleSize = preciseNumber(entry, 'CycleCapacitySize')
|
|
1842
|
+
const cycleRemain = preciseNumber(entry, 'CycleCapacityRemain')
|
|
1843
|
+
const poolSize = preciseNumber(entry, 'CapacitySize', 'Size')
|
|
1844
|
+
const poolRemain = preciseNumber(entry, 'CapacityRemain', 'Remain')
|
|
1845
|
+
// The cycle family wins; the pool family is the fallback for a row that
|
|
1846
|
+
// carries no cycle capacity.
|
|
1847
|
+
const size = cycleSize ?? poolSize
|
|
1848
|
+
const remain = cycleRemain ?? poolRemain
|
|
1849
|
+
if (size === undefined && remain === undefined) continue
|
|
1850
|
+
// `CapacityType` distinguishes the two kinds of resource: 4 is the
|
|
1851
|
+
// monthly cycle quota (it refreshes and never expires) and 1 is a
|
|
1852
|
+
// deduction gift (it drains to zero and does expire). `CycleEndTime`
|
|
1853
|
+
// exists on both, so it alone cannot tell them apart.
|
|
1854
|
+
const capacityType = typeof entry['CapacityType'] === 'number' ? entry['CapacityType'] : undefined
|
|
1855
|
+
const packageEndTime = typeof entry['ExpiredTime'] === 'string' && entry['ExpiredTime'] !== ''
|
|
1856
|
+
? entry['ExpiredTime']
|
|
1857
|
+
: typeof entry['PackageEndTime'] === 'string' && entry['PackageEndTime'] !== ''
|
|
1858
|
+
? entry['PackageEndTime']
|
|
1859
|
+
: undefined
|
|
1860
|
+
const cycleEndTime = typeof entry['CycleEndTime'] === 'string' && entry['CycleEndTime'] !== ''
|
|
1861
|
+
? entry['CycleEndTime']
|
|
1862
|
+
: undefined
|
|
1863
|
+
accounts.push({
|
|
1864
|
+
packageName: typeof entry['PackageName'] === 'string' && entry['PackageName'] !== '' ? entry['PackageName'] : 'package',
|
|
1865
|
+
remain: remain ?? 0,
|
|
1866
|
+
size: size ?? 0,
|
|
1867
|
+
...capacityType === undefined ? {} : { capacityType },
|
|
1868
|
+
...packageEndTime === undefined ? {} : { packageEndTime },
|
|
1869
|
+
...cycleEndTime === undefined ? {} : { cycleEndTime },
|
|
1870
|
+
})
|
|
1871
|
+
}
|
|
1872
|
+
const totalSize = accounts.reduce((sum, account) => sum + account.size, 0)
|
|
1873
|
+
const remainTotal = accounts.reduce((sum, account) => sum + account.remain, 0)
|
|
1874
|
+
const reported = Number(data?.['TotalDosage'] ?? data?.['totalDosage'] ?? 0)
|
|
1875
|
+
const grandTotal = Number.isFinite(reported) && reported > totalSize ? reported : totalSize
|
|
1876
|
+
const cycleResetTime = typeof data?.['CycleResetTime'] === 'string' ? data['CycleResetTime'] : undefined
|
|
1877
|
+
return {
|
|
1878
|
+
total: remainTotal,
|
|
1879
|
+
...grandTotal === 0 ? {} : { totalSize: grandTotal },
|
|
1880
|
+
accounts,
|
|
1881
|
+
...cycleResetTime === undefined ? {} : { cycleResetTime },
|
|
1882
|
+
}
|
|
1883
|
+
}
|
|
1884
|
+
|
|
1885
|
+
/** The account list inside a billing document, wherever the upstream nested it. */
|
|
1886
|
+
function accountsOf(data) {
|
|
1887
|
+
if (typeof data !== 'object' || data === null) return []
|
|
1888
|
+
if (Array.isArray(data['Accounts'])) return data['Accounts']
|
|
1889
|
+
if (Array.isArray(data['accounts'])) return data['accounts']
|
|
1890
|
+
const response = data['Response']
|
|
1891
|
+
if (typeof response === 'object' && response !== null) {
|
|
1892
|
+
const inner = response['Data']
|
|
1893
|
+
if (typeof inner === 'object' && inner !== null) {
|
|
1894
|
+
if (Array.isArray(inner['Accounts'])) return inner['Accounts']
|
|
1895
|
+
if (Array.isArray(inner['accounts'])) return inner['accounts']
|
|
1896
|
+
}
|
|
1897
|
+
}
|
|
1898
|
+
return []
|
|
1899
|
+
}
|
|
1900
|
+
|
|
1901
|
+
/**
|
|
1902
|
+
* One capacity, preferring the `*Precise` string fraction over the integer
|
|
1903
|
+
* field of the same name.
|
|
1904
|
+
*
|
|
1905
|
+
* `plainKey` names the integer field when it differs from the precise one
|
|
1906
|
+
* (`CapacitySize` vs `Size`); when it is omitted the same name is read
|
|
1907
|
+
* without the `Precise` suffix (`CycleCapacitySize`).
|
|
1908
|
+
*/
|
|
1909
|
+
function preciseNumber(entry, preciseKey, plainKey) {
|
|
1910
|
+
const precise = entry[`${preciseKey}Precise`]
|
|
1911
|
+
if (typeof precise === 'string' && precise.trim() !== '') {
|
|
1912
|
+
const parsed = Number(precise)
|
|
1913
|
+
if (Number.isFinite(parsed)) return parsed
|
|
1914
|
+
}
|
|
1915
|
+
const plain = entry[plainKey ?? preciseKey]
|
|
1916
|
+
const parsed = Number(plain)
|
|
1917
|
+
return Number.isFinite(parsed) ? parsed : undefined
|
|
1918
|
+
}
|