@snylonue/dsh-context-policy 0.0.0-stage → 0.1.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.
Files changed (63) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +223 -2
  3. package/assets/deepseek-v4/LICENSE +21 -0
  4. package/assets/deepseek-v4/README.md +19 -0
  5. package/assets/deepseek-v4/tokenizer.json.gz +0 -0
  6. package/assets/o200k-base/LICENSE +21 -0
  7. package/assets/o200k-base/README.md +20 -0
  8. package/assets/o200k-base/tokenizer.json.gz +0 -0
  9. package/cordis.patch.yml +19 -0
  10. package/dist/builtin-tokenizers.d.ts +2 -0
  11. package/dist/builtin-tokenizers.d.ts.map +1 -0
  12. package/dist/builtin-tokenizers.js +15 -0
  13. package/dist/builtin-tokenizers.js.map +1 -0
  14. package/dist/compaction.d.ts +43 -0
  15. package/dist/compaction.d.ts.map +1 -0
  16. package/dist/compaction.js +198 -0
  17. package/dist/compaction.js.map +1 -0
  18. package/dist/core.d.ts +49 -0
  19. package/dist/core.d.ts.map +1 -0
  20. package/dist/core.js +213 -0
  21. package/dist/core.js.map +1 -0
  22. package/dist/projection.d.ts +103 -0
  23. package/dist/projection.d.ts.map +1 -0
  24. package/dist/projection.js +137 -0
  25. package/dist/projection.js.map +1 -0
  26. package/dist/token-meter.d.ts +46 -0
  27. package/dist/token-meter.d.ts.map +1 -0
  28. package/dist/token-meter.js +55 -0
  29. package/dist/token-meter.js.map +1 -0
  30. package/dist/tokenizers.d.ts +6 -0
  31. package/dist/tokenizers.d.ts.map +1 -0
  32. package/dist/tokenizers.js +64 -0
  33. package/dist/tokenizers.js.map +1 -0
  34. package/dist/types.d.ts +62 -0
  35. package/dist/types.d.ts.map +1 -0
  36. package/dist/types.js +2 -0
  37. package/dist/types.js.map +1 -0
  38. package/dist/usage.d.ts +67 -0
  39. package/dist/usage.d.ts.map +1 -0
  40. package/dist/usage.js +81 -0
  41. package/dist/usage.js.map +1 -0
  42. package/examples/preset-compaction.yml +13 -0
  43. package/locale/en.json +6 -0
  44. package/locale/zh.json +6 -0
  45. package/package.json +92 -5
  46. package/scripts/audit.ts +105 -0
  47. package/scripts/check.ts +19 -0
  48. package/scripts/prepare-o200k.ts +40 -0
  49. package/src/builtin-tokenizers.ts +24 -0
  50. package/src/compaction.ts +293 -0
  51. package/src/core.ts +277 -0
  52. package/src/projection.ts +173 -0
  53. package/src/token-meter.ts +81 -0
  54. package/src/tokenizers.ts +78 -0
  55. package/src/types.ts +63 -0
  56. package/src/usage.ts +96 -0
  57. package/tests/bundle.test.ts +43 -0
  58. package/tests/deepseek-v4-fixtures.json +125 -0
  59. package/tests/o200k-base-fixtures.json +184 -0
  60. package/tests/policy.test.ts +773 -0
  61. package/tests/tokenizers.test.ts +51 -0
  62. package/tsconfig.check.json +15 -0
  63. package/tsconfig.json +17 -0
@@ -0,0 +1,773 @@
1
+ import test from "node:test";
2
+ import assert from "node:assert/strict";
3
+ import { Context } from "@deepseek-ai/cordis";
4
+ import Registry from "@deepseek-ai/dsh-session-projection";
5
+ import { createUserMessage } from "@deepseek-ai/dsh-llm";
6
+ import { SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
7
+ import type {
8
+ Session,
9
+ SessionEvent,
10
+ EpochHeader,
11
+ } from "@deepseek-ai/dsh-session";
12
+ import type {
13
+ BasicCompactionConfig,
14
+ ResolvedTargetPolicy,
15
+ } from "@deepseek-ai/dsh-compaction-basic";
16
+ import Meter from "../dist/token-meter.js";
17
+ import Compaction, {
18
+ resolveCompactSpec,
19
+ selectCompactableRange,
20
+ } from "../dist/compaction.js";
21
+ import {
22
+ countText,
23
+ resolvePolicy,
24
+ registerTokenizer,
25
+ } from "../dist/tokenizers.js";
26
+ import { initialState, fold, measureState } from "../dist/core.js";
27
+
28
+ const meterConfig = { defaultTokenizer: "o200k_base", modelPolicies: [] };
29
+ const header = (provider = "p", model = "gpt-new", maxTokens = 128000) =>
30
+ ({ config: { provider, model, maxTokens }, tools: [] }) as EpochHeader;
31
+ function event(
32
+ seq: number,
33
+ type: string,
34
+ data: unknown,
35
+ surfaceOp?: unknown,
36
+ ): SessionEvent {
37
+ return {
38
+ seq: SessionSeq(seq),
39
+ type,
40
+ data,
41
+ ...(surfaceOp === undefined ? {} : { surfaceOp }),
42
+ } as SessionEvent;
43
+ }
44
+ function user(seq: number, text: string, op: unknown = "append") {
45
+ return event(
46
+ seq,
47
+ "user/message",
48
+ createUserMessage({
49
+ source: { kind: "user" },
50
+ content: [{ type: "text", text }],
51
+ }),
52
+ op,
53
+ );
54
+ }
55
+ function assistant(seq: number, usage: unknown, text = "ok", step = 0) {
56
+ return event(
57
+ seq,
58
+ "assistant/message",
59
+ {
60
+ turn: 0,
61
+ step,
62
+ message: {
63
+ id: `a${seq}`,
64
+ role: "assistant",
65
+ content: [{ type: "text", text }],
66
+ },
67
+ stream: [],
68
+ usage,
69
+ },
70
+ "append",
71
+ );
72
+ }
73
+ function session(events: SessionEvent[]) {
74
+ const state = events.reduce(fold, initialState());
75
+ return {
76
+ seq: events.length,
77
+ header: {},
78
+ inheritedEventCount: 0,
79
+ snapshotEvents: () => events.slice(),
80
+ eventAt: (seq: number) => events[seq],
81
+ requestHeader: () => state.header ?? undefined,
82
+ surface: { nodes: state.nodes.map((n) => n.seq), replaceGeneration: 0 },
83
+ } as unknown as Session;
84
+ }
85
+ const policy: ResolvedTargetPolicy = {
86
+ target: { provider: "p", model: "m" },
87
+ thresholdRatio: 0.9,
88
+ headroomTokens: 65536,
89
+ retainRatio: 0.16,
90
+ summarizationProvider: "",
91
+ summarizationModel: "",
92
+ maxTokens: 8192,
93
+ compactionRetries: 1,
94
+ maxOverflowRetries: 1,
95
+ };
96
+
97
+ test("percentage trigger ignores output/headroom and scales retention against full window", () => {
98
+ for (const maxTokens of [1, 8192, 128000]) {
99
+ const spec = resolveCompactSpec(
100
+ { ...policy, maxTokens, headroomTokens: 999999 },
101
+ 272000,
102
+ );
103
+ assert.equal(spec.thresholdTokens, 244800);
104
+ assert.equal(spec.retainTokens, 43520);
105
+ }
106
+ assert.throws(() =>
107
+ resolveCompactSpec({ ...policy, retainRatio: 0.95 }, 272000),
108
+ );
109
+ assert.throws(() => resolveCompactSpec(policy, 0));
110
+ });
111
+
112
+ test("o200k_base counts ordinary text; exact provider mapping wins", () => {
113
+ assert.equal(countText("hello world", "o200k_base"), 2);
114
+ assert.equal(countText("你好世界", "o200k_base"), 2);
115
+ assert.equal(countText("<|endoftext|>", "o200k_base"), 7);
116
+ assert.throws(() => countText("x", "cl100k_base"));
117
+ const unregister = registerTokenizer("custom-test", (text) => text.length);
118
+ const cfg = {
119
+ defaultTokenizer: "o200k_base",
120
+ modelPolicies: [
121
+ { model: "m", tokenizer: "o200k_base", tokensPerMessage: 9 },
122
+ {
123
+ provider: "p",
124
+ model: "m",
125
+ tokenizer: "custom-test",
126
+ tokensPerMessage: 7,
127
+ },
128
+ ],
129
+ };
130
+ assert.equal(resolvePolicy(cfg, header("p", "m")).tokenizer, "custom-test");
131
+ assert.equal(resolvePolicy(cfg, header("q", "m")).tokensPerMessage, 9);
132
+ assert.equal(countText("hello", "custom-test"), 5);
133
+ unregister();
134
+ assert.throws(() => countText("hello", "custom-test"));
135
+ });
136
+
137
+ test("DeepSeek V4 model policies reprice measurement and preserve the default route", () => {
138
+ const cfg = Meter.Config({
139
+ modelPolicies: [
140
+ { model: "deepseek-v4-pro", tokenizer: "deepseek_v4" },
141
+ { model: "deepseek-v4-flash", tokenizer: "deepseek_v4" },
142
+ ],
143
+ });
144
+ for (const model of ["deepseek-v4-pro", "deepseek-v4-flash"]) {
145
+ const state = [
146
+ event(0, "request/header", { header: header("deepseek", model) }),
147
+ user(1, "你好世界"),
148
+ ].reduce(fold, initialState());
149
+ const measurement = measureState(state, cfg);
150
+ assert.equal(measurement.tokenizer, "deepseek_v4");
151
+ assert.equal(measurement.surfaceTokens, 5); // 2 text + 3 message
152
+ assert.equal(measurement.totalTokens, 8); // + 3 reply
153
+ }
154
+ assert.equal(resolvePolicy(cfg, header()).tokenizer, "deepseek_v4");
155
+ });
156
+
157
+ test("DeepSeek V4 is the global default; provider defaults price every model on that provider", () => {
158
+ const defaults = Meter.Config({});
159
+ assert.equal(defaults.defaultTokenizer, "deepseek_v4");
160
+ assert.deepEqual(defaults.providerTokenizers, {});
161
+ assert.equal(resolvePolicy(defaults, null).tokenizer, "deepseek_v4");
162
+ const cfg = Meter.Config({ providerTokenizers: { openai: "o200k_base" } });
163
+ for (const [provider, model, tokenizer, tokens] of [
164
+ ["openai", "new-model", "o200k_base", 13],
165
+ ["openai", "other-model", "o200k_base", 13],
166
+ ["other", "new-model", "deepseek_v4", 14],
167
+ ] as const) {
168
+ const state = [
169
+ event(0, "request/header", { header: header(provider, model) }),
170
+ user(1, "DeepSeek V4 Pro / Flash"),
171
+ ].reduce(fold, initialState());
172
+ const measurement = measureState(state, cfg);
173
+ assert.equal(measurement.tokenizer, tokenizer);
174
+ assert.equal(measurement.totalTokens, tokens);
175
+ }
176
+ const customDefault = Meter.Config({ defaultTokenizer: "o200k_base" });
177
+ assert.equal(resolvePolicy(customDefault, null).tokenizer, "o200k_base");
178
+ });
179
+
180
+ test("matched model policy overrides the provider tokenizer, or inherits it when omitted", () => {
181
+ const cfg = Meter.Config({
182
+ providerTokenizers: { openai: "o200k_base", another: "o200k_base" },
183
+ modelPolicies: [
184
+ { model: "shared", tokenizer: "deepseek_v4" },
185
+ {
186
+ provider: "openai",
187
+ model: "shared",
188
+ tokenizer: "o200k_base",
189
+ tokensPerMessage: 7,
190
+ },
191
+ { model: "framing", tokensPerMessage: 9 },
192
+ { provider: "openai", model: "exact-inherit", tokensPerMessage: 11 },
193
+ ],
194
+ });
195
+ const exact = resolvePolicy(cfg, header("openai", "shared"));
196
+ assert.equal(exact.tokenizer, "o200k_base");
197
+ assert.equal(exact.tokensPerMessage, 7);
198
+ assert.equal(
199
+ resolvePolicy(cfg, header("another", "shared")).tokenizer,
200
+ "deepseek_v4",
201
+ );
202
+ const inherited = resolvePolicy(cfg, header("openai", "framing"));
203
+ assert.equal(inherited.tokenizer, "o200k_base");
204
+ assert.equal(inherited.tokensPerMessage, 9);
205
+ assert.equal(
206
+ resolvePolicy(cfg, header("other", "framing")).tokenizer,
207
+ "deepseek_v4",
208
+ );
209
+ const exactInherited = resolvePolicy(cfg, header("openai", "exact-inherit"));
210
+ assert.equal(exactInherited.tokenizer, "o200k_base");
211
+ assert.equal(exactInherited.tokensPerMessage, 11);
212
+ });
213
+
214
+ test("calibrate prompt plus cache traffic; never add hidden reasoning output blindly", () => {
215
+ const events = [
216
+ event(0, "request/header", { header: header() }),
217
+ event(1, "request/context", { contextWindow: 272000 }),
218
+ user(2, "question"),
219
+ assistant(3, {
220
+ inputTokens: 80,
221
+ cacheReadTokens: 15,
222
+ cacheWriteTokens: 5,
223
+ outputTokens: 9000,
224
+ }),
225
+ ];
226
+ const state = events.reduce(fold, initialState());
227
+ const m = measureState(state, meterConfig);
228
+ assert.equal(m.baseline.tokens, 100);
229
+ const last = m.nodes.at(-1);
230
+ assert(last);
231
+ assert.equal(m.totalTokens, 100 + last.tokens);
232
+ assert(m.totalTokens < 9000);
233
+ assert.equal(m.logRevision, events.length);
234
+ assert(Object.isFrozen(m));
235
+ assert(Object.isFrozen(m.nodes));
236
+ });
237
+
238
+ test("failure with zero usage preserves occupancy; retries still accumulate billed usage", async () => {
239
+ let state = [
240
+ event(0, "request/header", { header: header() }),
241
+ user(1, "question"),
242
+ assistant(2, { inputTokens: 120, outputTokens: 10 }),
243
+ ].reduce(fold, initialState());
244
+ const before = measureState(state, meterConfig);
245
+ const attempt = event(3, "assistant/attempt", {
246
+ turn: 0,
247
+ step: 1,
248
+ stream: [
249
+ {
250
+ type: "chunk",
251
+ chunk: { type: "usage", usage: { inputTokens: 0, outputTokens: 0 } },
252
+ },
253
+ ],
254
+ });
255
+ state = fold(state, attempt);
256
+ assert.equal(
257
+ measureState(state, meterConfig).totalTokens,
258
+ before.totalTokens,
259
+ );
260
+ assert.equal(measureState(state, meterConfig).baseline.tokens, 120);
261
+ const failed = event(0, "assistant/attempt", {
262
+ turn: 0,
263
+ step: 0,
264
+ stream: [
265
+ {
266
+ type: "chunk",
267
+ chunk: { type: "usage", usage: { inputTokens: 10, outputTokens: 2 } },
268
+ },
269
+ ],
270
+ });
271
+ const ctx = new Context();
272
+ await ctx.plugin(Registry).await();
273
+ await ctx.plugin(Meter, {}).await();
274
+ try {
275
+ const events = [
276
+ failed,
277
+ event(1, "llm/retry-started", { turn: 0, step: 0 }),
278
+ assistant(2, { inputTokens: 20, outputTokens: 3 }),
279
+ ];
280
+ const s = session(events);
281
+ const billing = ctx.sessionProjections.snapshot(s).values.tokenUsage;
282
+ assert(billing);
283
+ assert.equal(billing.uncachedInputTokens, 30);
284
+ assert.equal(billing.outputTokens, 5);
285
+ events.push(assistant(3, { inputTokens: 20, outputTokens: 3 }));
286
+ Object.assign(s, { seq: events.length });
287
+ assert.deepEqual(
288
+ ctx.sessionProjections.snapshot(s).values.tokenUsage,
289
+ billing,
290
+ );
291
+ } finally {
292
+ await ctx.fiber.dispose();
293
+ }
294
+ });
295
+
296
+ test("replacement reprices removed content while keeping the fixed durable shadow heuristic", () => {
297
+ let state = [
298
+ event(0, "request/header", { header: header() }),
299
+ user(1, "long ".repeat(600)),
300
+ assistant(2, { inputTokens: 2000, outputTokens: 2 }),
301
+ ].reduce(fold, initialState());
302
+ const before = measureState(state, meterConfig);
303
+ const originalShadow = state.nodes[0].heuristicTokens;
304
+ state = fold(
305
+ state,
306
+ user(3, "summary", { startSeq: SessionSeq(1), endSeq: SessionSeq(1) }),
307
+ );
308
+ const after = measureState(state, meterConfig);
309
+ assert(after.totalTokens < before.totalTokens);
310
+ assert(after.surfaceDeltaTokens < 0);
311
+ assert.deepEqual(
312
+ after.nodes.map((n) => n.seq),
313
+ [3, 2],
314
+ );
315
+ assert(state.anchor);
316
+ assert.equal(state.anchor.nodes[0].heuristicTokens, originalShadow);
317
+ assert.equal(after.nodes[0].heuristicTokens, state.nodes[0].heuristicTokens);
318
+ });
319
+
320
+ test("header/model changes reject old usage anchor and reprice using mapped tokenizer", () => {
321
+ const unregister = registerTokenizer("characters", (text) => text.length);
322
+ let state = [
323
+ event(0, "request/header", { header: header() }),
324
+ user(1, "hello world"),
325
+ assistant(2, { inputTokens: 800, outputTokens: 2 }),
326
+ ].reduce(fold, initialState());
327
+ state = fold(
328
+ state,
329
+ event(3, "request/header", { header: header("other", "char-model") }),
330
+ );
331
+ const m = measureState(state, {
332
+ defaultTokenizer: "o200k_base",
333
+ modelPolicies: [
334
+ { provider: "other", model: "char-model", tokenizer: "characters" },
335
+ ],
336
+ });
337
+ assert.equal(m.baseline.kind, "estimated");
338
+ assert.equal(m.tokenizer, "characters");
339
+ assert(m.totalTokens < 800);
340
+ unregister();
341
+ });
342
+
343
+ test("batch image pricing and adapter file projection; image offload retains anchor accounting", () => {
344
+ const base = createUserMessage({
345
+ source: { kind: "user" },
346
+ content: [{ type: "text", text: "question" }],
347
+ });
348
+ const message = { ...base, content: [...base.content] };
349
+ message.content.push(
350
+ { type: "image", image: "one" } as never,
351
+ { type: "image", image: "two" } as never,
352
+ { type: "file", attachment: { id: "f" } } as never,
353
+ );
354
+ let state = [
355
+ event(0, "request/header", { header: header() }),
356
+ event(1, "user/message", message, "append"),
357
+ ].reduce(fold, initialState());
358
+ const batches: number[] = [];
359
+ const services = {
360
+ llm: {
361
+ imageRequestPricing: () => ({
362
+ priceImages: (images: readonly { offloaded?: boolean }[]) => {
363
+ batches.push(images.length);
364
+ return images.map((i, index) => ({
365
+ visualTokens: i.offloaded ? 0 : 100 + index,
366
+ text: "image",
367
+ }));
368
+ },
369
+ }),
370
+ fileRequestText: () => "file text",
371
+ },
372
+ };
373
+ const before = measureState(state, meterConfig, services);
374
+ assert.deepEqual(batches, [2]);
375
+ assert.equal(before.unpricedImages, false);
376
+ assert.equal(before.unpricedFiles, false);
377
+ state = fold(state, {
378
+ type: "image/offload",
379
+ seq: SessionSeq(2),
380
+ data: { targets: [{ seq: SessionSeq(1), imageIndexes: [0] }] },
381
+ });
382
+ assert.equal(
383
+ before.totalTokens - measureState(state, meterConfig, services).totalTokens,
384
+ 100,
385
+ );
386
+ assert.equal(measureState(state, meterConfig).unpricedImages, true);
387
+ assert.equal(measureState(state, meterConfig).unpricedFiles, true);
388
+ assert.throws(() =>
389
+ measureState(state, meterConfig, {
390
+ llm: {
391
+ ...services.llm,
392
+ imageRequestPricing: () => ({ priceImages: () => [] }),
393
+ },
394
+ }),
395
+ );
396
+ });
397
+
398
+ test("actual Cordis registry replays nonempty logs, validates all UI views and unloads cleanly", async () => {
399
+ const ctx = new Context();
400
+ await ctx.plugin(Registry).await();
401
+ const fiber = ctx.plugin(Meter, {});
402
+ await fiber.await();
403
+ try {
404
+ const events = [
405
+ event(0, "request/header", { header: header() }),
406
+ event(1, "request/context", { contextWindow: 272000 }),
407
+ user(2, "hello world"),
408
+ assistant(3, { inputTokens: 100, outputTokens: 2 }),
409
+ ];
410
+ const s = session(events);
411
+ const actual = ctx.tokenMeter.measure(s);
412
+ assert.equal(actual.baseline.kind, "usage");
413
+ const values = ctx.sessionProjections.snapshot(s).values;
414
+ assert.deepEqual(Object.keys(values).sort(), [
415
+ "contextBreakdown",
416
+ "contextPressure",
417
+ "tokenUsage",
418
+ ]);
419
+ assert.equal(values.contextPressure?.projectedTokens, actual.totalTokens);
420
+ assert.equal(values.contextPressure?.pressureTokens, 100);
421
+ assert(ctx.sessionProjections.stateOf(s, "contextPolicyMeter"));
422
+ assert.equal(
423
+ ctx.sessionProjections.stateOf(s, "contextPressure")?.surfaceTokens,
424
+ actual.nodes.reduce((total, node) => total + node.heuristicTokens, 0),
425
+ );
426
+ assert.equal(values.tokenUsage?.uncachedInputTokens, 100);
427
+ const checkpoint = ctx.sessionProjections.checkpoint(s);
428
+ assert.deepEqual(ctx.sessionProjections.viewCheckpoint(checkpoint), values);
429
+ await fiber.dispose();
430
+ assert.deepEqual(ctx.sessionProjections.snapshot(s).values, {});
431
+ const reloaded = ctx.plugin(
432
+ Meter,
433
+ Meter.Config({
434
+ modelPolicies: [
435
+ { provider: "p", model: "gpt-new", tokensPerMessage: 1000 },
436
+ ],
437
+ }),
438
+ );
439
+ await reloaded.await();
440
+ const updated = ctx.sessionProjections.snapshot(s).values;
441
+ assert.deepEqual(updated.tokenUsage, values.tokenUsage);
442
+ assert.equal(
443
+ updated.contextPressure?.contextWindow,
444
+ values.contextPressure?.contextWindow,
445
+ );
446
+ assert.equal(
447
+ updated.contextPressure?.projectedTokens,
448
+ ctx.tokenMeter.measure(s).totalTokens,
449
+ );
450
+ assert(ctx.tokenMeter.measure(s).totalTokens > actual.totalTokens);
451
+ assert(updated.contextBreakdown && values.contextBreakdown);
452
+ assert(
453
+ updated.contextBreakdown.messageTokens >
454
+ values.contextBreakdown.messageTokens,
455
+ );
456
+ assert.deepEqual(
457
+ ctx.sessionProjections.viewCheckpoint(checkpoint),
458
+ updated,
459
+ );
460
+ const restored = ctx.sessionProjections.restore(
461
+ checkpoint,
462
+ events.slice(-1),
463
+ SessionLogOffset(events.length - 1),
464
+ s.header,
465
+ SessionLogOffset(0),
466
+ );
467
+ assert.deepEqual(restored.snapshot.values, updated);
468
+ } finally {
469
+ await ctx.fiber.dispose();
470
+ }
471
+ });
472
+
473
+ test("default 80% boundary triggers, independent of request output limits; pruner can avert compaction", async () => {
474
+ const ctx = new Context();
475
+ await ctx.plugin(Registry).await();
476
+ let tokens = 217599,
477
+ calls = 0;
478
+ const s = session([
479
+ event(0, "request/header", { header: header() }),
480
+ user(1, "past"),
481
+ user(2, "tail"),
482
+ ]);
483
+ ctx.provide("llm");
484
+ ctx.provide("tokenMeter");
485
+ ctx.provide("toolResultPruner");
486
+ ctx.set("llm", {
487
+ resolveModelInfo: async () => ({
488
+ context: { contextWindow: 272000 },
489
+ defaultMaxTokens: 128000,
490
+ }),
491
+ } as never);
492
+ ctx.set("tokenMeter", {
493
+ measure: () => ({
494
+ logRevision: 3,
495
+ totalTokens: tokens,
496
+ nodes: [
497
+ { seq: 1, tokens: 200000, heuristicTokens: 2 },
498
+ { seq: 2, tokens: 100000, heuristicTokens: 2 },
499
+ ],
500
+ }),
501
+ } as never);
502
+ class TestCompaction extends Compaction {
503
+ override async compactRegion() {
504
+ calls++;
505
+ tokens = 10000;
506
+ return { test: true } as never;
507
+ }
508
+ }
509
+ const engine = new TestCompaction(
510
+ ctx,
511
+ Compaction.Config({ auto: false }),
512
+ );
513
+ const agent = { session: s } as Parameters<Compaction["compactIfNeeded"]>[0];
514
+ try {
515
+ assert.equal(engine.config.thresholdRatio, 0.8);
516
+ assert.equal(engine.config.retainRatio, 0.16);
517
+ assert.equal(engine.config.maxTokens, 65536);
518
+ assert.equal(await engine.compactIfNeeded(agent, "pressure"), null);
519
+ assert.equal(calls, 0);
520
+ tokens = 217600;
521
+ await engine.compactIfNeeded(agent, "pressure");
522
+ assert.equal(calls, 1);
523
+ ctx.set("toolResultPruner", {
524
+ pruneSession: () => {
525
+ tokens = 100;
526
+ },
527
+ } as never);
528
+ tokens = 250000;
529
+ assert.equal(await engine.compactIfNeeded(agent, "pressure"), null);
530
+ assert.equal(calls, 1);
531
+ } finally {
532
+ await ctx.fiber.dispose();
533
+ }
534
+ });
535
+
536
+ test("model overrides inherit absent fields, support exact routes and ignore legacy headroom", async () => {
537
+ for (const config of [
538
+ {
539
+ modelPolicies: [
540
+ {
541
+ provider: "p",
542
+ model: "gpt-new",
543
+ retainTokens: 20000,
544
+ thresholdRatio: undefined,
545
+ headroomTokens: 999999,
546
+ },
547
+ ],
548
+ },
549
+ {
550
+ thresholdRatio: 0.5,
551
+ modelPolicies: [
552
+ { provider: "other", model: "gpt-new", thresholdRatio: 0.9 },
553
+ ],
554
+ },
555
+ {
556
+ modelPolicies: [
557
+ {
558
+ provider: "p",
559
+ model: "gpt-new",
560
+ thresholdRatio: 0.5,
561
+ retainTokens: 20000,
562
+ },
563
+ ],
564
+ },
565
+ ] satisfies BasicCompactionConfig[]) {
566
+ const ctx = new Context();
567
+ await ctx.plugin(Registry).await();
568
+ ctx.provide("llm");
569
+ ctx.provide("tokenMeter");
570
+ const s = session([
571
+ event(0, "request/header", { header: header() }),
572
+ user(1, "past"),
573
+ user(2, "tail"),
574
+ ]);
575
+ let tokens =
576
+ config.modelPolicies[0]?.thresholdRatio === undefined &&
577
+ config.thresholdRatio === undefined
578
+ ? 217600
579
+ : 136000;
580
+ let calls = 0;
581
+ ctx.set("llm", {
582
+ resolveModelInfo: async () => ({ context: { contextWindow: 272000 } }),
583
+ } as never);
584
+ ctx.set("tokenMeter", {
585
+ measure: () => ({
586
+ totalTokens: tokens,
587
+ nodes: [
588
+ { seq: 1, tokens: 200000 },
589
+ { seq: 2, tokens: 100000 },
590
+ ],
591
+ }),
592
+ } as never);
593
+ class Engine extends Compaction {
594
+ override async compactRegion() {
595
+ calls++;
596
+ tokens = 1;
597
+ return {} as never;
598
+ }
599
+ }
600
+ try {
601
+ const engine = new Engine(
602
+ ctx,
603
+ Compaction.Config({
604
+ auto: false,
605
+ maxTokens: 8192,
606
+ ...config,
607
+ }),
608
+ );
609
+ assert.equal(engine.config.modelPolicies[0]?.maxTokens, 8192);
610
+ await engine.compactIfNeeded({ session: s } as never, "pressure");
611
+ assert.equal(calls, 1);
612
+ } finally {
613
+ await ctx.fiber.dispose();
614
+ }
615
+ }
616
+ });
617
+
618
+ test("exhausted pressure retries throw, overflow still compacts below threshold, active lock refuses pressure", async () => {
619
+ const ctx = new Context();
620
+ await ctx.plugin(Registry).await();
621
+ ctx.provide("llm");
622
+ ctx.provide("tokenMeter");
623
+ let calls = 0,
624
+ tokens = 250000;
625
+ const events = [
626
+ event(0, "request/header", { header: header() }),
627
+ user(1, "past"),
628
+ user(2, "tail"),
629
+ ];
630
+ let s = session(events);
631
+ ctx.set("llm", {
632
+ resolveModelInfo: async () => ({ context: { contextWindow: 272000 } }),
633
+ } as never);
634
+ ctx.set("tokenMeter", {
635
+ measure: () => ({
636
+ totalTokens: tokens,
637
+ nodes: [
638
+ { seq: 1, tokens: 200000 },
639
+ { seq: 2, tokens: 100000 },
640
+ ],
641
+ }),
642
+ } as never);
643
+ class Engine extends Compaction {
644
+ override async compactRegion() {
645
+ calls++;
646
+ return {} as never;
647
+ }
648
+ }
649
+ try {
650
+ const engine = new Engine(
651
+ ctx,
652
+ Compaction.Config({ auto: false, compactionRetries: 1 }),
653
+ );
654
+ await assert.rejects(
655
+ engine.compactIfNeeded({ session: s } as never, "pressure"),
656
+ /still above/,
657
+ );
658
+ assert.equal(calls, 2);
659
+ tokens = 100;
660
+ await engine.compactIfNeeded({ session: s } as never, "context-overflow");
661
+ assert.equal(calls, 3);
662
+ s = session([...events, event(3, "compaction/start", {})]);
663
+ await assert.rejects(
664
+ engine.compactIfNeeded({ session: s } as never, "pressure"),
665
+ /already in progress/,
666
+ );
667
+ } finally {
668
+ await ctx.fiber.dispose();
669
+ }
670
+ });
671
+
672
+ test("compaction projection tracks empty system heads, replacements and lock lifecycle", async () => {
673
+ const ctx = new Context();
674
+ await ctx.plugin(Registry).await();
675
+ ctx.provide("llm");
676
+ ctx.provide("tokenMeter");
677
+ new Compaction(ctx, Compaction.Config({ auto: false }));
678
+ const events = [
679
+ event(
680
+ 0,
681
+ "system/message",
682
+ {
683
+ message: { id: "system", role: "system", content: [] },
684
+ },
685
+ "append",
686
+ ),
687
+ user(1, "tail"),
688
+ ];
689
+ const s = session(events);
690
+ const state = () =>
691
+ ctx.sessionProjections.stateOf(s, "contextPolicyCompaction");
692
+ const append = (next: SessionEvent) => {
693
+ events.push(next);
694
+ Object.assign(s, { seq: events.length });
695
+ };
696
+ try {
697
+ assert.equal(state()?.systemHead, true);
698
+ assert.equal(state()?.active, false);
699
+ append(
700
+ user(2, "replacement", {
701
+ startSeq: SessionSeq(0),
702
+ endSeq: SessionSeq(0),
703
+ }),
704
+ );
705
+ assert.equal(state()?.headSeq, 2);
706
+ assert.equal(state()?.systemHead, false);
707
+ append(event(3, "compaction/start", {}));
708
+ assert.equal(state()?.active, true);
709
+ append(event(4, "session/end-seed", {}));
710
+ assert.equal(state()?.active, false);
711
+ append(event(5, "compaction/start", {}));
712
+ assert.equal(state()?.active, true);
713
+ append(event(6, "compaction/end", {}));
714
+ assert.equal(state()?.active, false);
715
+ } finally {
716
+ await ctx.fiber.dispose();
717
+ }
718
+ });
719
+
720
+ test("range selection preserves system head and does not split tool call/result pairs", () => {
721
+ const events = [
722
+ event(
723
+ 0,
724
+ "system/message",
725
+ {
726
+ message: {
727
+ id: "s",
728
+ role: "system",
729
+ content: [{ type: "text", text: "system" }],
730
+ },
731
+ },
732
+ "append",
733
+ ),
734
+ user(1, "past"),
735
+ event(
736
+ 2,
737
+ "assistant/message",
738
+ {
739
+ stream: [],
740
+ message: {
741
+ id: "a",
742
+ role: "assistant",
743
+ content: [
744
+ { type: "tool-call", id: "call", name: "tool", arguments: "{}" },
745
+ ],
746
+ },
747
+ },
748
+ "append",
749
+ ),
750
+ event(
751
+ 3,
752
+ "tool/result",
753
+ {
754
+ message: {
755
+ id: "t",
756
+ role: "tool",
757
+ content: [{ type: "text", text: "result" }],
758
+ },
759
+ },
760
+ "append",
761
+ ),
762
+ user(4, "tail"),
763
+ ];
764
+ const s = session(events);
765
+ const m = {
766
+ nodes: events.map((e) => ({ seq: e.seq, tokens: 10, heuristicTokens: 2 })),
767
+ } as ReturnType<typeof measureState>;
768
+ assert.deepEqual(selectCompactableRange(s, m, 20, true), {
769
+ start: 1,
770
+ end: 1,
771
+ });
772
+ assert.equal(selectCompactableRange(s, m, 50, true), null);
773
+ });