dsh-compact-saviour 0.2.7 → 0.2.9

package/src/controller.ts

@@ -12,11 +12,12 @@ import type {} from '@deepseek-ai/dsh-session-projection';
 import { compactSurfaceRegion, selectCompactableRange } from './vendor/region.js';
 import { compress } from './compress.js';
 import { PressureMeter } from './pressure.js';
+import type { CompactionRouteLease, CompactionRouteRegistry } from './routes.js';
 import type { Config, Target, State, JobView } from './shared.js';
 
 type Engine = BasicCompactionEngine;
 interface Binding { engine: Engine; ctx: Context; fiber: Fiber; restore(): void }
-interface Job { view: JobView; pending?: Target; abort?: AbortController; blocked: boolean; work?: Promise<unknown> }
+interface Job { view: JobView; pending?: Target; pendingRoute?: CompactionRouteLease; abort?: AbortController; blocked: boolean; work?: Promise<unknown> }
 const inactive = (): Job => ({ view: { phase: 'idle', message: '', failures: 0 }, blocked: false });
 
 export class Controller {
@@ -24,7 +25,7 @@ export class Controller {
   private jobs = new Map<string, Job>();
   private disposed = false;
   private pressure: PressureMeter;
-  constructor(readonly ctx: Context, readonly settings: SettingsScope<Config>) {
+  constructor(readonly ctx: Context, readonly settings: SettingsScope<Config>, private readonly routes?: CompactionRouteRegistry) {
     this.pressure = new PressureMeter(ctx);
     const scan = () => { if (!this.disposed) this.scan(); };
     ctx.on('internal/status', () => queueMicrotask(scan), { global: true });
@@ -69,7 +70,8 @@ export class Controller {
       const region: Engine['compactRegion'] = async function(this: Engine, start, end, agent, signal) {
         const job = self.job(agent);
         if (job.blocked && self.settings.get().enabled) throw new Error('压缩救援等待用户选择重试或取消。');
-        if (self.direct()) return self.rescue(agent, { engine, ctx: fiber.ctx, fiber, restore() {} }, self.configured(), signal ?? new AbortController().signal, false, { start, end });
+        const route = self.settings.get().enabled ? self.routes?.resolve(agent) : undefined;
+        if (self.direct() || route) return self.rescue(agent, { engine, ctx: fiber.ctx, fiber, restore() {} }, route?.target ?? self.configured(), signal ?? new AbortController().signal, false, { start, end }, undefined, route);
         const generation = agent.session.surface.replaceGeneration;
         const firstEvent = agent.session.seq;
         try {
@@ -91,7 +93,7 @@ export class Controller {
         if (self.job(agent).blocked && self.settings.get().enabled) return null;
         // Prime metadata before the official synchronous pressure check. Failure
         // to resolve it leaves the original check and context-overflow recovery intact.
-        try { await self.pressure.refresh(agent.session, undefined, signal); } catch { if (signal?.aborted) throw signal.reason; }
+        try { await self.pressure.refresh(agent.session, self.current(agent), signal); } catch { if (signal?.aborted) throw signal.reason; }
         return originalIfNeeded.call(this, agent, trigger, signal);
       };
       const now: Engine['compactNow'] = function(this: Engine, agent, signal, sourceCommandId) {
@@ -131,6 +133,8 @@ export class Controller {
   }
   private direct(): boolean { const config = this.settings.get(); return config.enabled && config.mode === 'direct'; }
   current(agent: Agent): Target | undefined {
+    const routed = this.routes?.resolve(agent);
+    if (routed) return routed.context;
     const projection = this.ctx.sessionProjections.stateOf(agent.session, 'modelSelection');
     const target = projection?.pending ?? projection?.lastUsed ?? agent.session.requestHeader()?.config ?? agent.options;
     return target.provider && target.model ? { provider: target.provider, model: target.model, ...(target.reasoningEffort ? { reasoningEffort: String(target.reasoningEffort) } : {}) } : undefined;
@@ -156,15 +160,16 @@ export class Controller {
     const job = this.job(agent);
     if (mode === 'cancel') {
       job.blocked = false;
-      job.pending = undefined; job.abort?.abort(new Error('用户取消压缩。'));
+      job.pending = undefined; job.pendingRoute = undefined; job.abort?.abort(new Error('用户取消压缩。'));
       if (!job.abort) job.view = { phase: 'idle', message: '已取消压缩。', failures: job.view.failures };
       return this.state(id);
     }
     if (job.pending || job.abort) throw new Error('该会话已有压缩任务。');
     this.binding(agent);
-    const target = mode === 'current' ? this.current(agent) : this.configured();
+    const route = this.routes?.resolve(agent);
+    const target = route?.target ?? (mode === 'current' ? this.current(agent) : this.configured());
     if (!target?.provider || !target.model) throw new Error('请先在设置中选择压缩模型。');
-    job.pending = target; job.blocked = false;
+    job.pending = target; job.pendingRoute = route; job.blocked = false;
     job.view = { phase: 'queued', message: agent.status === 'idle' ? '正在准备压缩…' : '已排队，当前模型或工具步骤结束后压缩。', failures: job.view.failures };
     if (agent.status === 'idle') queueMicrotask(() => { void this.runIdle(agent); });
     return this.state(id);
@@ -176,31 +181,35 @@ export class Controller {
     catch (error) {
       // A turn may win admission between the click and maintenance. Keep it queued for pre-step.
       if (agent.status !== 'idle') return;
-      job.pending = undefined; this.fail(job, error);
+      job.pending = undefined; job.pendingRoute = undefined; this.fail(job, error);
     }
   }
   private async runPending(agent: Agent, signal: AbortSignal, idle: boolean): Promise<void> {
-    const job = this.job(agent), target = job.pending;
+    const job = this.job(agent), target = job.pending, route = job.pendingRoute;
     if (!target || this.disposed) return;
-    job.pending = undefined;
-    try { await this.rescue(agent, this.binding(agent), target, signal, idle); }
+    job.pending = undefined; job.pendingRoute = undefined;
+    try { await this.rescue(agent, this.binding(agent), target, signal, idle, undefined, undefined, route); }
     catch (error) { if (!signal.aborted && job.view.phase === 'queued') this.fail(job, error); }
   }
   private fail(job: Job, error: unknown): void {
     job.blocked = true;
     job.view = { ...job.view, phase: 'failed', message: errorChain(error) };
   }
-  private async rescue(agent: Agent, binding: Binding, target: Target, outerSignal: AbortSignal, idle: boolean, selected?: { start: SessionSeq; end: SessionSeq }, sourceCommandId?: CommandId) {
+  private async rescue(agent: Agent, binding: Binding, target: Target, outerSignal: AbortSignal, idle: boolean, selected?: { start: SessionSeq; end: SessionSeq }, sourceCommandId?: CommandId, lease?: CompactionRouteLease) {
     const job = this.job(agent);
     if (job.abort) throw new Error('该会话已有压缩任务。');
     const abort = new AbortController(); job.abort = abort;
-    const signal = AbortSignal.any([outerSignal, abort.signal]);
+    let signal = AbortSignal.any([outerSignal, abort.signal]);
     const work = (async () => {
       try {
         signal.throwIfAborted();
+        const route = lease ?? this.routes?.resolve(agent);
+        if (route) signal = AbortSignal.any([signal, route.signal]);
+        route?.assertCurrent();
+        target = route?.target ?? target;
         if (!target.provider || !target.model) throw new Error('请先在设置 → Compact Saviour 中选择压缩模型。');
         const meter = binding.ctx.tokenMeter;
-        const current = this.current(agent);
+        const current = route?.context ?? this.current(agent);
         const header = agent.session.requestHeader();
         // Reprice retained images for the model selected for the next request.
         const effectiveHeader = header && current ? { ...header, config: { ...header.config, provider: current.provider, model: current.model } } : header;
@@ -215,6 +224,8 @@ export class Controller {
         const beforeTokens = fixed + before.surfaceTokens;
         job.view = { phase: 'running', message: '正在压缩上下文…', failures: job.view.failures, beforeTokens };
         const info = current ? await binding.ctx.llm.resolveModelInfo(current.provider, current.model, signal) : undefined;
+        signal.throwIfAborted(); route?.assertCurrent();
+        if (info && (info.provider !== current?.provider || info.id !== current.model)) throw new Error('上下文模型元数据与实际路由不一致。');
         const contextWindow = info?.context?.contextWindow;
         if (!contextWindow) throw new Error('当前对话模型没有可确认的上下文容量。');
         const room = Math.floor(contextWindow * .75) - fixed - (effectiveHeader?.config.maxTokens ?? info?.defaultMaxTokens ?? 8192);
@@ -229,7 +240,7 @@ export class Controller {
         const summaryBudget = Math.min(6000, maxSummaryTokens);
         const result = await compactSurfaceRegion({
           meter,
-          summarize: (input, owner, abortSignal) => compress(binding.ctx, input, owner, { target, signal: abortSignal ?? signal, summaryBudget, maxSummaryTokens,
+          summarize: (input, owner, abortSignal) => compress(binding.ctx, input, owner, { target, signal: abortSignal ?? signal, summaryBudget, maxSummaryTokens, routeLease: route,
             progress: (completed, total, message) => { job.view = { ...job.view, completed, total, message: message ?? (total === 1 ? '正在生成摘要…' : `正在分块压缩 ${completed}/${total}…`) }; },
           }),
         }, agent.session, range.start, range.end, agent, { owner: idle ? null : 'current-turn', stability: idle ? 'selected-span' : 'whole-surface', ...(sourceCommandId ? { sourceCommandId } : {}), ...(idle ? { flush: async () => { await binding.ctx.sessions.flush(agent.session); } } : {}) }, signal);

package/src/dsh-compact-saviour.ts

@@ -6,6 +6,9 @@ import type {} from '@deepseek-ai/dsh-settings';
 import type {} from '@deepseek-ai/dsh-llm';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { Controller } from './controller.js';
+import { CompactionRouteRegistry } from './routes.js';
+export { CompactionRouteRegistry } from './routes.js';
+export type { CompactionRouteSnapshot, CompactionRouteLease } from './routes.js';
 import type { Config as Settings } from './shared.js';
 
 export const name = 'dsh-compact-saviour';
@@ -41,7 +44,10 @@ export function apply(ctx: Context, config: { [K in keyof Settings]-?: Volatile<
     replace: (value: Settings) => ctx.settings.update('dsh-compact-saviour', value),
   };
   ctx.effect(() => ctx.settings.configure({ auto: false }));
-  const controller = new Controller(ctx, settings);
+  const routes = new CompactionRouteRegistry();
+  ctx.provide('compactionRoutes', routes);
+  ctx.effect(() => () => routes.close());
+  const controller = new Controller(ctx, settings, routes);
   // Versioned route also recovers a running 0.1.0 Host whose unowned legacy
   // route cannot be released through the public WebServer API. All new route
   // registrations are fiber-owned and disappear before replacement on HMR.

package/src/routes.ts

@@ -0,0 +1,76 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { GenerateOptions } from '@deepseek-ai/dsh-llm';
+import type { Target } from './shared.js';
+
+/** Optional plugin contract. Capacity is resolved separately for these exact routes. */
+export interface CompactionRouteSnapshot {
+  revision: string;
+  context: Target;
+  target: Target;
+  maxOutputTokens?: number;
+}
+export interface CompactionRouteLease extends CompactionRouteSnapshot {
+  readonly signal: AbortSignal;
+  assertCurrent(): void;
+  prepare(request: GenerateOptions): GenerateOptions;
+}
+type Resolver = (agent: Agent) => CompactionRouteSnapshot | undefined;
+
+function snapshot(value: CompactionRouteSnapshot): CompactionRouteSnapshot {
+  if (!value.revision || ![value.context, value.target].every(route =>
+    typeof route?.provider === 'string' && route.provider && typeof route.model === 'string' && route.model
+      && (route.reasoningEffort === undefined || typeof route.reasoningEffort === 'string' && route.reasoningEffort)))
+    throw new Error('Invalid session compaction route');
+  if (value.maxOutputTokens !== undefined && (!Number.isSafeInteger(value.maxOutputTokens) || value.maxOutputTokens <= 0))
+    throw new Error('Invalid session compaction output reservation');
+  return Object.freeze({ revision: value.revision,
+    context: Object.freeze({ ...value.context }), target: Object.freeze({ ...value.target }),
+    ...(value.maxOutputTokens === undefined ? {} : { maxOutputTokens: value.maxOutputTokens }) });
+}
+const key = (value: CompactionRouteSnapshot) => JSON.stringify([value.revision,
+  value.context.provider, value.context.model, value.context.reasoningEffort,
+  value.target.provider, value.target.model, value.target.reasoningEffort, value.maxOutputTokens]);
+
+/** Fiber-owned registrations; a lease expires on route change or owner unload. */
+export class CompactionRouteRegistry {
+  readonly apiVersion = 1;
+  private resolvers = new Set<{ owner: string; resolve: Resolver; lifecycle: AbortController }>();
+  register(owner: string, resolve: Resolver): () => void {
+    if (!owner) throw new Error('Compaction route owner is required');
+    const entry = { owner, resolve, lifecycle: new AbortController() }; this.resolvers.add(entry);
+    return () => { this.resolvers.delete(entry); entry.lifecycle.abort(new Error('Session compaction route owner unloaded')); };
+  }
+  resolve(agent: Agent): CompactionRouteLease | undefined {
+    const matches = [...this.resolvers].flatMap(entry => {
+      const value = entry.resolve(agent); return value ? [{ entry, value: snapshot(value) }] : [];
+    });
+    if (!matches.length) return undefined;
+    if (matches.length !== 1) throw new Error('Multiple plugins own this session compaction route');
+    const { entry, value } = matches[0]!;
+    const signature = key(value);
+    const assertCurrent = () => {
+      if ([...this.resolvers].some(other => other !== entry && other.resolve(agent)))
+        throw new Error('Multiple plugins own this session compaction route');
+      const current = this.resolvers.has(entry) && entry.resolve(agent);
+      if (!current || key(snapshot(current)) !== signature) throw new Error('Session compaction route changed; retry with the current model');
+    };
+    return Object.freeze({ ...value, signal: entry.lifecycle.signal, assertCurrent,
+      prepare: (request: GenerateOptions) => {
+        request.signal?.throwIfAborted(); assertCurrent();
+        if (request.purpose !== 'compaction' || request.sessionId !== agent.session.id
+          || request.provider !== value.target.provider || request.model !== value.target.model
+          || request.reasoningEffort !== value.target.reasoningEffort
+          || !Number.isSafeInteger(request.maxTokens) || Number(request.maxTokens) <= 0
+          || value.maxOutputTokens !== undefined && request.maxTokens! > value.maxOutputTokens)
+          throw new Error('Compaction request does not match its planned physical route');
+        // Host llm.stream supports frozen one-shot envelopes. Later middleware
+        // may validate this route, but cannot replace its model or reservation.
+        return Object.freeze(request);
+      },
+    });
+  }
+  close(): void {
+    for (const entry of this.resolvers) entry.lifecycle.abort(new Error('Session compaction route registry unloaded'));
+    this.resolvers.clear();
+  }
+}

package/tests/compression.test.ts

@@ -14,7 +14,7 @@ test('chunks preserve multilingual source exactly, including a single huge line'
 function fixture(text: string, finish = 'stop') {
   const requests: any[] = [];
   const ctx = { llm: {
-    resolveModelInfo: async () => ({ context: { contextWindow: 64000 }, reasoning: { efforts: [{ id: 'low' }] } }),
+    resolveModelInfo: async (provider: string, model: string) => ({ provider, id: model, name: model, context: { contextWindow: 64000 }, reasoning: { efforts: [{ id: 'low' }] } }),
     async *stream(request: any) {
       requests.push(request);
       yield { type: 'block-start', index: 0, blockType: 'text' };

package/tests/peer-range.test.ts

@@ -3,19 +3,19 @@ import { readFileSync } from 'node:fs';
 import test from 'node:test';
 import semver from 'semver';
 
-const RANGE = '>=0.2.0-rc.1 <0.2.1';
-const ACCEPT = ['0.2.0-rc.2', '0.2.0', '0.2.0-rc.2'];
-const REJECT = ['0.2.0-alpha', '0.2.0-alpha.1', '0.2.0-alpha.2', '0.1.7-rc.2', '0.1.7-rc.1', '0.2.1'];
+const RANGE = '>=0.2.1-rc.1 <0.2.2';
+const ACCEPT = ['0.2.1-rc.5', '0.2.1-rc.1', '0.2.1'];
+const REJECT = ['0.2.0-rc.2', '0.2.0', '0.2.0-alpha', '0.2.0-alpha.1', '0.2.1-alpha.1', '0.1.7-rc.2', '0.1.7-rc.1', '0.2.2'];
 
-test('Harness peers use >=0.2.0-rc.1 <0.2.1', () => {
+test('Harness peers use >=0.2.1-rc.1 <0.2.2', () => {
   const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-  assert.equal(pkg.version, '0.2.7');
-  assert.equal(semver.satisfies('0.2.0-rc.2', RANGE), true);
+  assert.equal(pkg.version, '0.2.9');
+  assert.equal(semver.satisfies('0.2.1-rc.5', RANGE), true);
   const peers = Object.entries(pkg.peerDependencies).filter(([name]) => name.startsWith('@deepseek-ai/dsh'));
   assert.ok(peers.length >= 17);
   for (const [name, range] of peers) assert.equal(range, RANGE, name);
-  assert.equal(pkg.devDependencies['@deepseek-ai/dsh-agent-loop'], '0.2.0-rc.2');
-  assert.equal(pkg.devDependencies['@deepseek-ai/dsh-agent-loop-testkit'], '0.2.0-rc.2');
+  assert.equal(pkg.devDependencies['@deepseek-ai/dsh-agent-loop'], RANGE);
+  assert.equal(pkg.devDependencies['@deepseek-ai/dsh-agent-loop-testkit'], RANGE);
   assert.equal(pkg.peerDependencies['@deepseek-ai/cordis'], '^4.0.4');
   assert.equal(pkg.peerDependencies['@deepseek-ai/schemastery'], '^3.18.4');
   for (const version of ACCEPT) assert.equal(semver.satisfies(version, RANGE), true, version);

package/tests/routes.test.ts

@@ -0,0 +1,67 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { CompactionRouteRegistry } from '../src/routes.js';
+import { compress } from '../src/compress.js';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+
+const agent = (id = 'a') => ({ id, session: { id } }) as never;
+const value = (revision = '1') => ({ revision, context: { provider: 'p', model: 'lead' },
+  target: { provider: 'p', model: 'summary' }, maxOutputTokens: 2048 });
+
+test('session leases isolate routes and expire on revision change or owner unload', () => {
+  const registry = new CompactionRouteRegistry(); let revision = '1';
+  const remove = registry.register('fixture', a => a.session.id === 'a' ? value(revision) : undefined);
+  const first = registry.resolve(agent())!;
+  assert.equal(registry.resolve(agent('ordinary')), undefined);
+  first.assertCurrent(); revision = '2';
+  assert.throws(() => first.assertCurrent(), /route changed/);
+  const second = registry.resolve(agent())!; remove();
+  assert.throws(() => second.assertCurrent(), /route changed/);
+  assert.equal(second.signal.aborted, true);
+});
+test('ambiguous owners fail instead of choosing whichever plugin registered first', () => {
+  const registry = new CompactionRouteRegistry();
+  registry.register('one', () => value());
+  const lease = registry.resolve(agent())!;
+  registry.register('two', () => value());
+  assert.throws(() => registry.resolve(agent()), /Multiple plugins/);
+  assert.throws(() => lease.assertCurrent(), /Multiple plugins/);
+});
+test('a planned request retains its bounded cap and cannot be rerouted', () => {
+  const registry = new CompactionRouteRegistry(); registry.register('fixture', () => value());
+  const lease = registry.resolve(agent())!;
+  const request = { provider: 'p', model: 'summary', sessionId: 'a', purpose: 'compaction', maxTokens: 1024, messages: [] };
+  const planned = lease.prepare(request as never);
+  assert.equal(planned.maxTokens, 1024); assert.equal(Object.isFrozen(planned), true);
+  assert.throws(() => { planned.model = 'other'; });
+  assert.throws(() => lease.prepare({ ...request, maxTokens: 4096 } as never), /planned physical route/);
+  assert.throws(() => lease.prepare({ ...request, model: 'other' } as never), /planned physical route/);
+});
+test('physical planning uses the lease model and cap before dispatch, then rejects stale metadata', async () => {
+  const registry = new CompactionRouteRegistry(); let revision = '1';
+  registry.register('fixture', () => value(revision));
+  const input = { messages: [createUserMessage({ content: [{ type: 'text', text: 'Preserve synthetic task facts. '.repeat(500) }] })] };
+  const requests: any[] = [], metadata: string[] = [];
+  const ctx = { llm: {
+    async resolveModelInfo(provider: string, model: string) {
+      metadata.push(model); return { provider, id: model, name: model, context: { contextWindow: 32000 }, defaultMaxTokens: 8192 };
+    },
+    async *stream(request: any) {
+      requests.push(request); assert.equal(Object.isFrozen(request), true);
+      yield { type: 'block-start', index: 0, blockType: 'text' };
+      yield { type: 'block-end', index: 0, block: { type: 'text', text: 'Preserve task facts. Next: verify.' } };
+      yield { type: 'finish', reason: { kind: 'stop' } };
+    },
+  } };
+  const lease = registry.resolve(agent())!;
+  await compress(ctx as never, input, agent(), { target: lease.target, routeLease: lease,
+    signal: new AbortController().signal, progress() {} });
+  assert.deepEqual(metadata, ['summary']); assert.equal(requests[0].maxTokens, 2048);
+  assert.equal(requests[0].model, 'summary');
+  ctx.llm.resolveModelInfo = async (provider, model) => {
+    revision = '2'; return { provider, id: model, name: model, context: { contextWindow: 32000 }, defaultMaxTokens: 8192 };
+  };
+  await assert.rejects(compress(ctx as never, input, agent(), { target: lease.target, routeLease: lease,
+    signal: new AbortController().signal, progress() {} }), /route changed/);
+  assert.equal(requests.length, 1);
+});