pi-tsgw 0.0.1 → 0.0.2

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "pi-tsgw",
3
- "version": "0.0.1",
3
+ "version": "0.0.2",
4
4
  "description": "Pi extension for the TOSSP AIH gateway: per-vendor model catalog and thinking operations for openai-completions, openai-responses, anthropic-messages, and google-generative-ai wire protocols.",
5
5
  "type": "module",
6
6
  "keywords": [
@@ -15,16 +15,13 @@
15
15
  "type": "git",
16
16
  "url": "git+https://github.com/tossp/pi-tsgw.git"
17
17
  },
18
- "files": [
19
- "extensions"
20
- ],
21
18
  "pi": {
22
19
  "extensions": [
23
20
  "./extensions/index.ts"
24
21
  ]
25
22
  },
26
23
  "scripts": {
27
- "test": "tsc && node dist/extensions/index.test.js && node dist/extensions/models/operations.test.js && node dist/extensions/models/catalog.test.js && node dist/extensions/web-search/web-search.test.js"
24
+ "test": "tsc -p tsconfig.test.json && node dist/extensions/index.test.js && node dist/extensions/models/operations.test.js && node dist/extensions/models/catalog.test.js && node dist/extensions/web-search/web-search.test.js"
28
25
  },
29
26
  "peerDependencies": {
30
27
  "@earendil-works/pi-coding-agent": ">=0.82.0"
@@ -1,509 +0,0 @@
1
- import { deepStrictEqual, equal, match, strictEqual } from "node:assert";
2
- import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
3
- import { tmpdir } from "node:os";
4
- import { join } from "node:path";
5
- import type {
6
- ExtensionAPI,
7
- ProviderConfig,
8
- } from "@earendil-works/pi-coding-agent";
9
- import registerTsgw from "./index.ts";
10
-
11
- type HookName =
12
- | "session_start"
13
- | "agent_start"
14
- | "model_select"
15
- | "thinking_level_select"
16
- | "before_provider_request"
17
- | "before_provider_headers";
18
-
19
- const STALE_ERROR = "Extension context is stale after runtime replacement";
20
- const TEST_ROOT = "https://aih.example.com";
21
- const TSGW_TERRA = {
22
- provider: "tsgw",
23
- id: "gpt-5.6-terra",
24
- api: "openai-responses",
25
- baseUrl: `${TEST_ROOT}/v1`,
26
- };
27
- const TSGW_DEEPSEEK = {
28
- provider: "tsgw",
29
- id: "deepseek-v4-flash",
30
- api: "openai-completions",
31
- baseUrl: `${TEST_ROOT}/v1`,
32
- };
33
- const TSGW_GLM = {
34
- provider: "tsgw",
35
- id: "glm-5.2",
36
- api: "openai-completions",
37
- baseUrl: `${TEST_ROOT}/v1`,
38
- };
39
-
40
- class FakeContext {
41
- private stale = false;
42
-
43
- constructor(
44
- private readonly currentModel:
45
- | typeof TSGW_TERRA
46
- | typeof TSGW_DEEPSEEK
47
- | typeof TSGW_GLM
48
- | { provider: string; id: string; api: string; baseUrl: string }
49
- | undefined,
50
- private readonly currentThinkingLevel: "off" | "high" | "low",
51
- ) {}
52
-
53
- get model(): typeof this.currentModel {
54
- this.assertFresh();
55
- return this.currentModel;
56
- }
57
-
58
- get thinkingLevel(): typeof this.currentThinkingLevel {
59
- this.assertFresh();
60
- return this.currentThinkingLevel;
61
- }
62
-
63
- makeStale(): void {
64
- this.stale = true;
65
- }
66
-
67
- private assertFresh(): void {
68
- if (this.stale) throw new Error(STALE_ERROR);
69
- }
70
- }
71
-
72
- class FakePi {
73
- readonly providers: Array<{ name: string; config: unknown }> = [];
74
- private readonly handlers = new Map<HookName, unknown[]>();
75
-
76
- on: ExtensionAPI["on"] = (event, handler) => {
77
- if (!this.isHookName(event)) return;
78
- const handlers = this.handlers.get(event) ?? [];
79
- handlers.push(handler);
80
- this.handlers.set(event, handlers);
81
- };
82
- registerTool: ExtensionAPI["registerTool"] = () => {};
83
- registerCommand: ExtensionAPI["registerCommand"] = () => {};
84
- registerShortcut: ExtensionAPI["registerShortcut"] = () => {};
85
- registerFlag: ExtensionAPI["registerFlag"] = () => {};
86
- getFlag: ExtensionAPI["getFlag"] = () => undefined;
87
- registerMessageRenderer: ExtensionAPI["registerMessageRenderer"] = () => {};
88
- registerEntryRenderer: ExtensionAPI["registerEntryRenderer"] = () => {};
89
- sendMessage: ExtensionAPI["sendMessage"] = () => {};
90
- sendUserMessage: ExtensionAPI["sendUserMessage"] = () => {};
91
- appendEntry: ExtensionAPI["appendEntry"] = () => {};
92
- setSessionName: ExtensionAPI["setSessionName"] = () => {};
93
- getSessionName: ExtensionAPI["getSessionName"] = () => undefined;
94
- setLabel: ExtensionAPI["setLabel"] = () => {};
95
- exec: ExtensionAPI["exec"] = async () => {
96
- throw new Error("FakePi.exec is not used by this test");
97
- };
98
- getActiveTools: ExtensionAPI["getActiveTools"] = () => [];
99
- getAllTools: ExtensionAPI["getAllTools"] = () => [];
100
- setActiveTools: ExtensionAPI["setActiveTools"] = () => {};
101
- getCommands: ExtensionAPI["getCommands"] = () => [];
102
- setModel: ExtensionAPI["setModel"] = async () => false;
103
- getThinkingLevel: ExtensionAPI["getThinkingLevel"] = () => {
104
- throw new Error("legacy getThinkingLevel must not be called");
105
- };
106
- setThinkingLevel: ExtensionAPI["setThinkingLevel"] = () => {};
107
- unregisterProvider: ExtensionAPI["unregisterProvider"] = () => {};
108
-
109
- get events(): ExtensionAPI["events"] {
110
- throw new Error("FakePi.events is not used by this test");
111
- }
112
-
113
- registerProvider(_provider: unknown): void;
114
- registerProvider(name: string, config: ProviderConfig): void;
115
- registerProvider(nameOrProvider: unknown, config?: ProviderConfig): void {
116
- if (typeof nameOrProvider === "string")
117
- this.providers.push({ name: nameOrProvider, config });
118
- }
119
-
120
- has(event: HookName): boolean {
121
- return (this.handlers.get(event)?.length ?? 0) > 0;
122
- }
123
-
124
- invoke(event: HookName, payload: unknown, ctx?: unknown): unknown {
125
- const handlers = this.handlers.get(event);
126
- if (!handlers?.length) throw new Error(`missing ${event} handler`);
127
- let result: unknown;
128
- for (const handler of handlers) {
129
- if (typeof handler !== "function")
130
- throw new Error(`invalid ${event} handler`);
131
- result = handler(payload, ctx);
132
- }
133
- return result;
134
- }
135
-
136
- private isHookName(event: string): event is HookName {
137
- return (
138
- event === "session_start" ||
139
- event === "agent_start" ||
140
- event === "model_select" ||
141
- event === "thinking_level_select" ||
142
- event === "before_provider_request" ||
143
- event === "before_provider_headers"
144
- );
145
- }
146
- }
147
-
148
- async function createPi(settings?: unknown): Promise<FakePi> {
149
- const pi = new FakePi();
150
- await withAgentDir(settings, async () => {
151
- await registerTsgw(pi);
152
- });
153
- return pi;
154
- }
155
-
156
- function sessionStart(
157
- pi: FakePi,
158
- ctx: FakeContext,
159
- reason: "startup" | "reload" | "new" | "resume" | "fork" = "startup",
160
- ): void {
161
- pi.invoke("session_start", { type: "session_start", reason }, ctx);
162
- }
163
-
164
- function agentStart(pi: FakePi, ctx: FakeContext): void {
165
- pi.invoke("agent_start", { type: "agent_start" }, ctx);
166
- }
167
-
168
- function providerRequest(pi: FakePi, payload: unknown): unknown {
169
- return pi.invoke("before_provider_request", {
170
- type: "before_provider_request",
171
- payload,
172
- });
173
- }
174
-
175
- function providerHeaders(
176
- pi: FakePi,
177
- headers: Record<string, string | null>,
178
- ): void {
179
- pi.invoke("before_provider_headers", {
180
- type: "before_provider_headers",
181
- headers,
182
- });
183
- }
184
-
185
- /**
186
- * Isolate the extension from the real Pi config directory: point
187
- * PI_CODING_AGENT_DIR at a throwaway directory that may contain a
188
- * settings.json with a `tsgw` namespace.
189
- */
190
- function withAgentDir(
191
- settings: unknown,
192
- run: () => Promise<void>,
193
- ): Promise<void> {
194
- const dir = mkdtempSync(join(tmpdir(), "pi-tsgw-test-"));
195
- if (settings !== undefined) {
196
- writeFileSync(join(dir, "settings.json"), JSON.stringify(settings));
197
- }
198
- const previous = process.env.PI_CODING_AGENT_DIR;
199
- process.env.PI_CODING_AGENT_DIR = dir;
200
- return run().finally(() => {
201
- if (previous === undefined) delete process.env.PI_CODING_AGENT_DIR;
202
- else process.env.PI_CODING_AGENT_DIR = previous;
203
- rmSync(dir, { recursive: true, force: true });
204
- });
205
- }
206
-
207
- function assertUuid(value: string | null | undefined): void {
208
- match(
209
- value ?? "",
210
- /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
211
- );
212
- }
213
-
214
- async function testChatCompletionsCompatibility(): Promise<void> {
215
- const pi = await createPi();
216
- const provider = pi.providers.find(({ name }) => name === "tsgw");
217
- const models =
218
- (
219
- provider?.config as
220
- | {
221
- models?: Array<{
222
- id: string;
223
- api?: string;
224
- compat?: { supportsDeveloperRole?: boolean };
225
- }>;
226
- }
227
- | undefined
228
- )?.models ?? [];
229
- const completionModels = models.filter(
230
- ({ api }) => api === "openai-completions",
231
- );
232
-
233
- equal(completionModels.length > 0, true);
234
- for (const model of completionModels) {
235
- strictEqual(
236
- model.compat?.supportsDeveloperRole,
237
- false,
238
- `${model.id} must send its instruction prompt as system, not developer`,
239
- );
240
- }
241
- }
242
-
243
- async function testSafeProviderHooksAfterContextStales(): Promise<void> {
244
- const pi = await createPi({
245
- tsgw: { traceHeaders: true, webSearch: "cached" },
246
- });
247
- const sessionContext = new FakeContext(TSGW_TERRA, "high");
248
- sessionStart(pi, sessionContext);
249
-
250
- const firstHeaders: Record<string, string | null> = {};
251
- providerHeaders(pi, firstHeaders);
252
- const agentContext = new FakeContext(TSGW_TERRA, "high");
253
- agentStart(pi, agentContext);
254
- sessionContext.makeStale();
255
- agentContext.makeStale();
256
- pi.getThinkingLevel = () => {
257
- throw new Error(STALE_ERROR);
258
- };
259
-
260
- deepStrictEqual(providerRequest(pi, { tools: [] }), {
261
- tools: [
262
- {
263
- type: "web_search",
264
- search_context_size: "medium",
265
- external_web_access: false,
266
- },
267
- ],
268
- service_tier: "flex",
269
- text: { verbosity: "medium" },
270
- });
271
- const headers: Record<string, string | null> = {};
272
- providerHeaders(pi, headers);
273
- assertUuid(headers["AH-Thread-Id"]);
274
- assertUuid(headers["AH-Trace-Id"]);
275
- strictEqual(headers["AH-Thread-Id"], firstHeaders["AH-Thread-Id"]);
276
- if (headers["AH-Trace-Id"] === firstHeaders["AH-Trace-Id"])
277
- throw new Error("agent_start must refresh AH-Trace-Id");
278
-
279
- const preserved = {
280
- "ah-thread-id": "keep-thread",
281
- "AH-Trace-Id": "keep-trace",
282
- };
283
- providerHeaders(pi, preserved);
284
- deepStrictEqual(preserved, {
285
- "ah-thread-id": "keep-thread",
286
- "AH-Trace-Id": "keep-trace",
287
- });
288
- }
289
-
290
- async function testLifecycleStateUpdates(): Promise<void> {
291
- const pi = await createPi();
292
- sessionStart(pi, new FakeContext(TSGW_DEEPSEEK, "high"));
293
- deepStrictEqual(providerRequest(pi, {}), {
294
- reasoning_effort: "high",
295
- thinking: { type: "enabled" },
296
- });
297
-
298
- pi.invoke("thinking_level_select", {
299
- type: "thinking_level_select",
300
- level: "off",
301
- previousLevel: "high",
302
- });
303
- deepStrictEqual(providerRequest(pi, {}), {
304
- thinking: { type: "disabled" },
305
- });
306
-
307
- pi.invoke("model_select", {
308
- type: "model_select",
309
- model: TSGW_GLM,
310
- previousModel: TSGW_DEEPSEEK,
311
- source: "set",
312
- });
313
- deepStrictEqual(providerRequest(pi, { stream: true }), {
314
- stream: true,
315
- tool_stream: true,
316
- reasoning_effort: "none",
317
- thinking: { type: "disabled" },
318
- });
319
-
320
- pi.invoke("thinking_level_select", {
321
- type: "thinking_level_select",
322
- level: "high",
323
- previousLevel: "off",
324
- });
325
- deepStrictEqual(providerRequest(pi, { stream: true }), {
326
- stream: true,
327
- tool_stream: true,
328
- reasoning_effort: "high",
329
- thinking: { type: "enabled", clear_thinking: false },
330
- });
331
-
332
- const agentContext = new FakeContext(TSGW_DEEPSEEK, "off");
333
- agentStart(pi, agentContext);
334
- agentContext.makeStale();
335
- deepStrictEqual(providerRequest(pi, {}), {
336
- thinking: { type: "disabled" },
337
- });
338
- }
339
-
340
- async function testNoStateAndTraceLimits(): Promise<void> {
341
- const pi = await createPi();
342
- const payload = { untouched: true };
343
- strictEqual(providerRequest(pi, payload), undefined);
344
- // 未启用 trace 时,不注册 before_provider_headers 钩子。
345
- equal(pi.has("before_provider_headers"), false);
346
- }
347
-
348
- async function testTraceHeaderSettings(): Promise<void> {
349
- const pi = await createPi({ tsgw: { traceHeaders: true } });
350
- equal(pi.has("before_provider_headers"), true);
351
-
352
- // 无 session 状态:不产生追踪头。
353
- const empty: Record<string, string | null> = {};
354
- providerHeaders(pi, empty);
355
- deepStrictEqual(empty, {});
356
-
357
- // 非 tsgw provider 不追踪。
358
- sessionStart(
359
- pi,
360
- new FakeContext({ ...TSGW_TERRA, provider: "other" }, "high"),
361
- );
362
- const foreign: Record<string, string | null> = {};
363
- providerHeaders(pi, foreign);
364
- deepStrictEqual(foreign, {});
365
-
366
- // 模型 baseUrl 与配置 root 不同 host 时不追踪。
367
- sessionStart(
368
- pi,
369
- new FakeContext(
370
- { ...TSGW_TERRA, baseUrl: "https://example.test/v1" },
371
- "high",
372
- ),
373
- );
374
- const otherHost: Record<string, string | null> = {};
375
- providerHeaders(pi, otherHost);
376
- deepStrictEqual(otherHost, {});
377
-
378
- // 匹配 host:产生追踪头。
379
- sessionStart(pi, new FakeContext(TSGW_TERRA, "high"));
380
- const headers: Record<string, string | null> = {};
381
- providerHeaders(pi, headers);
382
- assertUuid(headers["AH-Thread-Id"]);
383
- assertUuid(headers["AH-Trace-Id"]);
384
- }
385
-
386
- async function testOldInstanceCallbacksKeepOwnSnapshot(): Promise<void> {
387
- const replacements = [
388
- { label: "reload", reason: "reload" },
389
- { label: "new", reason: "new" },
390
- { label: "fork", reason: "fork" },
391
- { label: "switch", reason: "resume" },
392
- ] as const;
393
-
394
- for (const replacement of replacements) {
395
- const oldPi = await createPi({
396
- tsgw: { traceHeaders: true, webSearch: "cached" },
397
- });
398
- const oldContext = new FakeContext(TSGW_TERRA, "high");
399
- sessionStart(oldPi, oldContext);
400
- agentStart(oldPi, oldContext);
401
- oldContext.makeStale();
402
- oldPi.getThinkingLevel = () => {
403
- throw new Error(STALE_ERROR);
404
- };
405
-
406
- const newPi = await createPi();
407
- sessionStart(
408
- newPi,
409
- new FakeContext(TSGW_DEEPSEEK, "off"),
410
- replacement.reason,
411
- );
412
-
413
- deepStrictEqual(
414
- providerRequest(oldPi, { tools: [] }),
415
- {
416
- tools: [
417
- {
418
- type: "web_search",
419
- search_context_size: "medium",
420
- external_web_access: false,
421
- },
422
- ],
423
- service_tier: "flex",
424
- text: { verbosity: "medium" },
425
- },
426
- `${replacement.label}: late old callback must retain its own state`,
427
- );
428
- deepStrictEqual(
429
- providerRequest(newPi, {}),
430
- { thinking: { type: "disabled" } },
431
- `${replacement.label}: new instance must use its own state`,
432
- );
433
-
434
- const headers: Record<string, string | null> = {};
435
- providerHeaders(oldPi, headers);
436
- assertUuid(headers["AH-Thread-Id"]);
437
- assertUuid(headers["AH-Trace-Id"]);
438
- }
439
- }
440
-
441
- async function testSettingsConfig(): Promise<void> {
442
- // settings.json `tsgw.baseUrl` drives the registered provider root.
443
- const piBase = await createPi({
444
- tsgw: { baseUrl: "https://gateway.example.net" },
445
- });
446
- const provider = piBase.providers.find(({ name }) => name === "tsgw");
447
- const baseUrl = (provider?.config as { baseUrl?: string } | undefined)
448
- ?.baseUrl;
449
- strictEqual(baseUrl, "https://gateway.example.net/v1");
450
-
451
- // `tsgw.webSearch: "live"` enables the built-in search injection.
452
- const piSearch = await createPi({ tsgw: { webSearch: "live" } });
453
- sessionStart(piSearch, new FakeContext(TSGW_TERRA, "high"));
454
- deepStrictEqual(providerRequest(piSearch, { tools: [] }), {
455
- tools: [
456
- {
457
- type: "web_search",
458
- search_context_size: "medium",
459
- external_web_access: true,
460
- },
461
- ],
462
- service_tier: "flex",
463
- text: { verbosity: "medium" },
464
- });
465
-
466
- // `tsgw.includeModels` / `tsgw.excludeModels` filter the model catalog.
467
- const piFiltered = await createPi({
468
- tsgw: {
469
- includeModels: ["glm-*"],
470
- excludeModels: ["glm-5.1"],
471
- },
472
- });
473
- const filtered = piFiltered.providers.find(({ name }) => name === "tsgw");
474
- const modelIds = (
475
- (filtered?.config as { models?: Array<{ id: string }> } | undefined)
476
- ?.models ?? []
477
- ).map(({ id }) => id);
478
- equal(modelIds.length > 1, true);
479
- equal(
480
- modelIds.every((id) => id.startsWith("glm-")),
481
- true,
482
- );
483
- equal(modelIds.includes("glm-5.2"), true);
484
- equal(modelIds.includes("glm-5.1"), false);
485
-
486
- // Malformed or missing `tsgw` namespaces are ignored.
487
- const piBroken = await createPi({ tsgw: "not-an-object" });
488
- const brokenProvider = piBroken.providers.find(({ name }) => name === "tsgw");
489
- const brokenBase = (
490
- brokenProvider?.config as { baseUrl?: string } | undefined
491
- )?.baseUrl;
492
- strictEqual(brokenBase, `${TEST_ROOT}/v1`);
493
- }
494
-
495
- async function main(): Promise<void> {
496
- await testChatCompletionsCompatibility();
497
- await testSafeProviderHooksAfterContextStales();
498
- await testLifecycleStateUpdates();
499
- await testNoStateAndTraceLimits();
500
- await testTraceHeaderSettings();
501
- await testOldInstanceCallbacksKeepOwnSnapshot();
502
- await testSettingsConfig();
503
- console.log("index.test.ts: all assertions passed");
504
- }
505
-
506
- void main().catch((error: unknown) => {
507
- console.error(error);
508
- process.exitCode = 1;
509
- });
@@ -1,137 +0,0 @@
1
- import { deepStrictEqual, equal, strictEqual, throws } from "node:assert";
2
- import {
3
- DEFAULT_ROOT,
4
- filterModels,
5
- modelsForRoot,
6
- normalizeRoot,
7
- PROVIDER_ID,
8
- } from "./catalog.ts";
9
-
10
- const ROOT = "https://aih.example.com";
11
-
12
- function testCatalogConcatenation(): void {
13
- const models = modelsForRoot(ROOT);
14
- const ids = models.map(({ id }) => id);
15
-
16
- // 10 家供应商分片拼接,共 59 个模型(22 原有 + 37 新增)。
17
- equal(ids.length, 59);
18
- // id 全局唯一。
19
- equal(new Set(ids).size, ids.length);
20
-
21
- // 供应商覆盖:每家至少一个模型。
22
- for (const prefix of [
23
- "deepseek-",
24
- "glm-",
25
- "mimo-",
26
- "minimax-",
27
- "kimi-",
28
- "longcat-",
29
- "qwen",
30
- "gpt-",
31
- "gemini-",
32
- "claude-",
33
- ]) {
34
- equal(
35
- ids.some((id) => id.startsWith(prefix)),
36
- true,
37
- `expected a model with prefix ${prefix}`,
38
- );
39
- }
40
-
41
- // 拼接顺序保持目录顺序(deepseek → … → claude)。
42
- equal(ids[0], "deepseek-v4-flash");
43
- equal(ids[ids.length - 1], "claude-sonnet-5");
44
-
45
- // 模型 baseUrl 按协议端点派生。
46
- const deepseek = models.find(({ id }) => id === "deepseek-v4-flash");
47
- strictEqual(deepseek?.baseUrl, `${ROOT}/v1`);
48
- const gemini = models.find(({ id }) => id === "gemini-flash");
49
- strictEqual(gemini?.baseUrl, `${ROOT}/gemini`);
50
- const claude = models.find(({ id }) => id === "claude-fable-5");
51
- strictEqual(claude?.baseUrl, `${ROOT}/anthropic`);
52
- }
53
-
54
- function testFilterModels(): void {
55
- const all = modelsForRoot(ROOT);
56
-
57
- // 无过滤条件:原样返回(新数组,元素不变)。
58
- const untouched = filterModels(all);
59
- equal(untouched.length, all.length);
60
- strictEqual(untouched[0], all[0]);
61
-
62
- // 白名单精确匹配。
63
- deepStrictEqual(
64
- filterModels(all, { include: ["glm-5.2"] }).map(({ id }) => id),
65
- ["glm-5.2"],
66
- );
67
-
68
- // 白名单前缀通配。
69
- deepStrictEqual(
70
- filterModels(all, { include: ["gpt-5.6-*"] }).map(({ id }) => id),
71
- ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"],
72
- );
73
- // 黑名单精确匹配。
74
- const excluded = filterModels(all, { exclude: ["claude-sonnet"] });
75
- equal(
76
- excluded.some(({ id }) => id === "claude-sonnet"),
77
- false,
78
- );
79
- equal(excluded.length, all.length - 1);
80
-
81
- // 黑名单前缀通配。
82
- const noGemini = filterModels(all, { exclude: ["gemini-*"] });
83
- equal(
84
- noGemini.some(({ id }) => id.startsWith("gemini-")),
85
- false,
86
- );
87
-
88
- // 黑白名单并存:黑名单优先于白名单。
89
- const both = filterModels(all, {
90
- include: ["glm-*", "claude-*"],
91
- exclude: ["glm-5.1", "claude-sonnet"],
92
- });
93
- equal(
94
- both.some(({ id }) => id.startsWith("glm-")),
95
- true,
96
- );
97
- equal(
98
- both.some(({ id }) => id.startsWith("claude-")),
99
- true,
100
- );
101
- equal(
102
- both.some(({ id }) => id === "glm-5.1"),
103
- false,
104
- );
105
- equal(
106
- both.some(({ id }) => id === "claude-sonnet"),
107
- false,
108
- );
109
- }
110
-
111
- function testNormalizeRoot(): void {
112
- strictEqual(normalizeRoot(), DEFAULT_ROOT);
113
- strictEqual(
114
- normalizeRoot("https://gw.example.com/v1"),
115
- "https://gw.example.com",
116
- );
117
- strictEqual(
118
- normalizeRoot("https://gw.example.com/v1/"),
119
- "https://gw.example.com",
120
- );
121
- strictEqual(
122
- normalizeRoot("https://gw.example.com/"),
123
- "https://gw.example.com",
124
- );
125
- strictEqual(
126
- normalizeRoot("https://gw.example.com/base/v1"),
127
- "https://gw.example.com/base",
128
- );
129
- throws(() => normalizeRoot("ftp://gw.example.com"), /http or https/);
130
- throws(() => normalizeRoot("not-a-url"), /not a valid URL/);
131
- equal(PROVIDER_ID, "tsgw");
132
- }
133
-
134
- testCatalogConcatenation();
135
- testFilterModels();
136
- testNormalizeRoot();
137
- console.log("catalog.test.ts: all assertions passed");
@@ -1,428 +0,0 @@
1
- import { deepStrictEqual, equal, strictEqual } from "node:assert";
2
- import { applyModelOperations } from "./operations.ts";
3
- import {
4
- isPlainObject,
5
- type ModelOperationContext,
6
- type ThinkingLevel,
7
- } from "./_tools.ts";
8
-
9
- type Payload = Record<string, unknown>;
10
-
11
- const levels = [
12
- "off",
13
- "high",
14
- "xhigh",
15
- "max",
16
- ] as const satisfies readonly ThinkingLevel[];
17
-
18
- function deepFreeze(value: unknown): void {
19
- if (Array.isArray(value)) {
20
- for (const item of value) deepFreeze(item);
21
- Object.freeze(value);
22
- return;
23
- }
24
- if (isPlainObject(value)) {
25
- for (const item of Object.values(value)) deepFreeze(item);
26
- Object.freeze(value);
27
- }
28
- }
29
-
30
- function context(
31
- modelId: string,
32
- api = "openai-completions",
33
- thinkingLevel: ThinkingLevel = "high",
34
- ): ModelOperationContext {
35
- return { provider: "tsgw", modelId, api, thinkingLevel };
36
- }
37
-
38
- function apply(
39
- payload: Payload,
40
- modelId: string,
41
- api: string,
42
- thinkingLevel: ThinkingLevel,
43
- ): Payload {
44
- deepFreeze(payload);
45
- const result = applyModelOperations(
46
- payload,
47
- context(modelId, api, thinkingLevel),
48
- );
49
- if (!isPlainObject(result)) throw new Error("expected a plain object result");
50
- return result;
51
- }
52
-
53
- function completionBase(): Payload {
54
- return {
55
- stream: true,
56
- reasoning_effort: "medium",
57
- thinking: { type: "legacy", retained: true },
58
- };
59
- }
60
-
61
- function testCompletionProfiles(): void {
62
- for (const modelId of ["deepseek-v4-flash", "deepseek-v4-pro"]) {
63
- for (const level of levels) {
64
- const result = apply(
65
- completionBase(),
66
- modelId,
67
- "openai-completions",
68
- level,
69
- );
70
- const effort =
71
- level === "off"
72
- ? undefined
73
- : level === "xhigh" || level === "max"
74
- ? "max"
75
- : "high";
76
- deepStrictEqual(
77
- result,
78
- effort === undefined
79
- ? { stream: true, thinking: { type: "disabled", retained: true } }
80
- : {
81
- stream: true,
82
- reasoning_effort: effort,
83
- thinking: { type: "enabled", retained: true },
84
- },
85
- );
86
- }
87
- }
88
- deepStrictEqual(
89
- apply(
90
- completionBase(),
91
- "deepseek-v4-flash",
92
- "openai-completions",
93
- "minimal",
94
- ),
95
- {
96
- stream: true,
97
- reasoning_effort: "high",
98
- thinking: { type: "enabled", retained: true },
99
- },
100
- );
101
-
102
- for (const modelId of ["glm-5.2", "glm-5.1"]) {
103
- for (const level of levels) {
104
- const result = apply(
105
- completionBase(),
106
- modelId,
107
- "openai-completions",
108
- level,
109
- );
110
- const effort =
111
- level === "off"
112
- ? "none"
113
- : level === "xhigh" || level === "max"
114
- ? "max"
115
- : "high";
116
- deepStrictEqual(result, {
117
- stream: true,
118
- tool_stream: true,
119
- reasoning_effort: effort,
120
- thinking:
121
- level === "off"
122
- ? { type: "disabled", retained: true }
123
- : { type: "enabled", retained: true, clear_thinking: false },
124
- });
125
- }
126
- }
127
- const glmNotStreaming = apply(
128
- { stream: false, reasoning_effort: "medium", thinking: { type: "legacy" } },
129
- "glm-5.2",
130
- "openai-completions",
131
- "high",
132
- );
133
- equal(Object.hasOwn(glmNotStreaming, "tool_stream"), false);
134
-
135
- for (const modelId of [
136
- "mimo-v2.5",
137
- "mimo-v2.5-pro",
138
- "kimi-for-coding",
139
- "longcat-2.0",
140
- ]) {
141
- for (const level of levels) {
142
- const result = apply(
143
- completionBase(),
144
- modelId,
145
- "openai-completions",
146
- level,
147
- );
148
- deepStrictEqual(result, {
149
- stream: true,
150
- thinking: {
151
- type: level === "off" ? "disabled" : "enabled",
152
- retained: true,
153
- },
154
- });
155
- }
156
- }
157
-
158
- for (const level of levels) {
159
- const result = apply(
160
- completionBase(),
161
- "minimax-m3",
162
- "openai-completions",
163
- level,
164
- );
165
- deepStrictEqual(result, {
166
- stream: true,
167
- reasoning_split: true,
168
- thinking: {
169
- type: level === "off" ? "disabled" : "adaptive",
170
- retained: true,
171
- },
172
- });
173
- }
174
-
175
- for (const level of [
176
- "off",
177
- "minimal",
178
- "low",
179
- "medium",
180
- "high",
181
- "xhigh",
182
- "max",
183
- ] as const satisfies readonly ThinkingLevel[]) {
184
- const result = apply(
185
- completionBase(),
186
- "kimi-k3",
187
- "openai-completions",
188
- level,
189
- );
190
- const effort =
191
- level === "off"
192
- ? undefined
193
- : level === "minimal" || level === "low"
194
- ? "low"
195
- : level === "max"
196
- ? "max"
197
- : "high";
198
- deepStrictEqual(
199
- result,
200
- effort === undefined
201
- ? { stream: true }
202
- : { stream: true, reasoning_effort: effort },
203
- );
204
- }
205
-
206
- for (const modelId of ["qwen3.7-plus", "qwen3.7-max"]) {
207
- for (const level of levels) {
208
- const result = apply(
209
- {
210
- ...completionBase(),
211
- thinking_budget: 1,
212
- search_options: { old: true },
213
- enable_code_interpreter: false,
214
- },
215
- modelId,
216
- "openai-completions",
217
- level,
218
- );
219
- const expected: Payload = {
220
- stream: true,
221
- enable_search: true,
222
- parallel_tool_calls: true,
223
- enable_thinking: level !== "off",
224
- preserve_thinking: level !== "off",
225
- thinking: { type: "legacy", retained: true },
226
- };
227
- if (level !== "off") {
228
- expected.thinking_budget = 6000;
229
- expected.search_options = { search_strategy: "agent_max" };
230
- expected.enable_code_interpreter = true;
231
- }
232
- deepStrictEqual(result, expected);
233
- }
234
- }
235
- const qwenLow = apply(
236
- {
237
- ...completionBase(),
238
- thinking_budget: 1,
239
- search_options: { old: true },
240
- enable_code_interpreter: false,
241
- },
242
- "qwen3.7-plus",
243
- "openai-completions",
244
- "low",
245
- );
246
- deepStrictEqual(qwenLow, {
247
- stream: true,
248
- thinking: { type: "legacy", retained: true },
249
- enable_search: true,
250
- parallel_tool_calls: true,
251
- enable_thinking: true,
252
- preserve_thinking: true,
253
- });
254
- }
255
-
256
- function testGeminiProfiles(): void {
257
- for (const level of levels) {
258
- const tools = [{ functionDeclarations: [{ name: "keep" }] }];
259
- const signal = new AbortController().signal;
260
- const input = {
261
- reasoning_effort: "medium",
262
- config: {
263
- tools,
264
- abortSignal: signal,
265
- thinkingConfig: { retained: true, thinkingLevel: "HIGH" },
266
- },
267
- };
268
- const result = apply(input, "gemini-flash", "google-generative-ai", level);
269
- const budget = level === "max" ? 24576 : level === "off" ? 0 : 16000;
270
- deepStrictEqual(result, {
271
- config: {
272
- tools,
273
- abortSignal: signal,
274
- thinkingConfig: {
275
- retained: true,
276
- includeThoughts: level !== "off",
277
- thinkingBudget: budget,
278
- },
279
- },
280
- });
281
- strictEqual((result.config as Payload).tools, tools);
282
- strictEqual((result.config as Payload).abortSignal, signal);
283
- }
284
-
285
- const proLevels: readonly ThinkingLevel[] = [
286
- "off",
287
- "minimal",
288
- "low",
289
- "medium",
290
- "high",
291
- "xhigh",
292
- "max",
293
- ];
294
- for (const level of proLevels) {
295
- const tools = [{ functionDeclarations: [{ name: "keep" }] }];
296
- const signal = new AbortController().signal;
297
- const input = {
298
- reasoning_effort: "medium",
299
- config: {
300
- tools,
301
- abortSignal: signal,
302
- thinkingConfig: { retained: true, thinkingBudget: 42 },
303
- },
304
- };
305
- const result = apply(input, "gemini-pro", "google-generative-ai", level);
306
- const thinkingLevel =
307
- level === "off" || level === "minimal" || level === "low"
308
- ? "LOW"
309
- : level === "medium"
310
- ? "MEDIUM"
311
- : "HIGH";
312
- deepStrictEqual(result, {
313
- config: {
314
- tools,
315
- abortSignal: signal,
316
- thinkingConfig: {
317
- retained: true,
318
- includeThoughts: level !== "off",
319
- thinkingLevel,
320
- },
321
- },
322
- });
323
- strictEqual((result.config as Payload).tools, tools);
324
- strictEqual((result.config as Payload).abortSignal, signal);
325
- }
326
- }
327
-
328
- function testOpenAIResponsesProfiles(): void {
329
- const verbosityByModel: Record<string, "low" | "medium"> = {
330
- "gpt-5.6-sol": "low",
331
- "gpt-5.6-terra": "medium",
332
- "gpt-5.6-luna": "low",
333
- "gpt-5.5": "low",
334
- "gpt-5.3-codex-spark": "low",
335
- };
336
- for (const [modelId, verbosity] of Object.entries(verbosityByModel)) {
337
- for (const level of levels) {
338
- const reasoning = { effort: "high", summary: "auto", retained: true };
339
- const input = {
340
- reasoning,
341
- text: { format: "text" },
342
- include: ["reasoning.encrypted_content"],
343
- store: false,
344
- parallel_tool_calls: false,
345
- };
346
- const result = apply(input, modelId, "openai-responses", level);
347
- deepStrictEqual(result, {
348
- reasoning,
349
- text: { format: "text", verbosity },
350
- include: ["reasoning.encrypted_content"],
351
- store: false,
352
- parallel_tool_calls: false,
353
- service_tier: "flex",
354
- });
355
- strictEqual(result.reasoning, reasoning);
356
- }
357
- }
358
- }
359
-
360
- function testNoOpsAndProtectedFields(): void {
361
- const nonPlain = [null, [], new Date()] as const;
362
- for (const payload of nonPlain)
363
- strictEqual(
364
- applyModelOperations(payload, context("deepseek-v4-flash")),
365
- payload,
366
- );
367
- const claude = { model: "keep" };
368
- strictEqual(
369
- applyModelOperations(
370
- claude,
371
- context("claude-fable-5", "anthropic-messages"),
372
- ),
373
- claude,
374
- );
375
- strictEqual(
376
- applyModelOperations(claude, {
377
- ...context("gpt-5.6-sol", "openai-responses"),
378
- provider: "other",
379
- }),
380
- claude,
381
- );
382
-
383
- const input: Payload = {
384
- model: "keep",
385
- messages: [{ role: "user", content: "keep" }],
386
- input: ["keep"],
387
- contents: ["keep"],
388
- system: "keep",
389
- tools: [{ type: "function", name: "keep" }],
390
- tool_choice: "auto",
391
- headers: { keep: "yes" },
392
- stream: true,
393
- include: ["keep"],
394
- store: false,
395
- prompt_cache_key: "keep",
396
- max_output_tokens: 9,
397
- reasoning_effort: "keep",
398
- reasoning: { effort: "high", summary: "auto" },
399
- parallel_tool_calls: false,
400
- };
401
- const result = apply(input, "gpt-5.6-terra", "openai-responses", "high");
402
- for (const key of [
403
- "model",
404
- "messages",
405
- "input",
406
- "contents",
407
- "system",
408
- "tools",
409
- "tool_choice",
410
- "headers",
411
- "stream",
412
- "include",
413
- "store",
414
- "prompt_cache_key",
415
- "max_output_tokens",
416
- "reasoning_effort",
417
- "reasoning",
418
- "parallel_tool_calls",
419
- ]) {
420
- deepStrictEqual(result[key], input[key]);
421
- }
422
- }
423
-
424
- testCompletionProfiles();
425
- testGeminiProfiles();
426
- testOpenAIResponsesProfiles();
427
- testNoOpsAndProtectedFields();
428
- console.log("operations.test.ts: all assertions passed");
@@ -1,111 +0,0 @@
1
- import { deepStrictEqual, equal, strictEqual } from "node:assert";
2
- import { applyWebSearchTool } from "./web-search.ts";
3
- import {
4
- isPlainObject,
5
- type Payload,
6
- type WebSearchMode,
7
- } from "../models/_tools.ts";
8
-
9
- const OPENAI_RESPONSES = "openai-responses";
10
-
11
- function apply(
12
- payload: unknown,
13
- modelId: string,
14
- mode: WebSearchMode,
15
- ): Payload {
16
- const result = applyWebSearchTool(payload, {
17
- modelId,
18
- api: OPENAI_RESPONSES,
19
- mode,
20
- });
21
- if (!isPlainObject(result)) throw new Error("expected a plain object result");
22
- return result;
23
- }
24
-
25
- function testBuiltinSearchInjection(): void {
26
- const functionTool = { type: "function", name: "keep" };
27
- for (const mode of ["off", "cached", "live"] as const) {
28
- const input = {
29
- tools: [functionTool],
30
- tool_choice: "auto",
31
- include: ["reasoning.encrypted_content"],
32
- store: false,
33
- };
34
- const result = apply(input, "gpt-5.6-sol", mode);
35
- const tools = result.tools as unknown[];
36
- equal(tools.length, mode === "off" ? 1 : 2);
37
- strictEqual(tools[0], functionTool);
38
- if (mode !== "off")
39
- deepStrictEqual(tools[1], {
40
- type: "web_search",
41
- search_context_size: "medium",
42
- external_web_access: mode === "live",
43
- });
44
- deepStrictEqual(result.tool_choice, "auto");
45
- deepStrictEqual(result.include, ["reasoning.encrypted_content"]);
46
- strictEqual(result.store, false);
47
- }
48
-
49
- for (const type of [
50
- "web_search",
51
- "web_search_preview",
52
- "web_search_custom",
53
- ]) {
54
- const existing = { type };
55
- const result = apply({ tools: [existing] }, "gpt-5.6-terra", "live");
56
- strictEqual((result.tools as unknown[])[0], existing);
57
- equal((result.tools as unknown[]).length, 1);
58
- }
59
-
60
- const undefinedTools = apply({}, "gpt-5.6-luna", "cached");
61
- deepStrictEqual(undefinedTools.tools, [
62
- {
63
- type: "web_search",
64
- search_context_size: "medium",
65
- external_web_access: false,
66
- },
67
- ]);
68
- const invalidTools = apply({ tools: null }, "gpt-5.5", "live");
69
- strictEqual(invalidTools.tools, null);
70
- }
71
-
72
- function testNoOpsAndScope(): void {
73
- // 非内置查询名单内的模型不注入。
74
- const nonSearch = { tools: [functionTool] };
75
- strictEqual(
76
- applyWebSearchTool(nonSearch, {
77
- modelId: "gpt-5.3-codex-spark",
78
- api: OPENAI_RESPONSES,
79
- mode: "live",
80
- }),
81
- nonSearch,
82
- );
83
-
84
- // 非 Responses 协议不注入。
85
- strictEqual(
86
- applyWebSearchTool(nonSearch, {
87
- modelId: "gpt-5.6-sol",
88
- api: "openai-completions",
89
- mode: "live",
90
- }),
91
- nonSearch,
92
- );
93
-
94
- // 非 plain 对象原样返回。
95
- const nonPlain = [null, [], new Date()] as const;
96
- for (const payload of nonPlain)
97
- strictEqual(
98
- applyWebSearchTool(payload, {
99
- modelId: "gpt-5.6-sol",
100
- api: OPENAI_RESPONSES,
101
- mode: "live",
102
- }),
103
- payload,
104
- );
105
- }
106
-
107
- const functionTool = { type: "function", name: "keep" };
108
-
109
- testBuiltinSearchInjection();
110
- testNoOpsAndScope();
111
- console.log("web-search.test.ts: all assertions passed");