feat(compact): compaction capability seam — abstract CompactService interface

Adds the @deepseek-ai/dsh-compact interface package: the abstract CompactService (ctx.compact) with compactIfNeeded / compactRegion, the compact/* session-event types via SessionEventMap declaration merging, and the capability-seam RFC. Wires the package into the three root tsconfigs and the cordis catalog. A backend implementation lands separately.
2026-06-22 14:52:30 +08:00
parent 0298f5c6f0
commit e45053f0f5
14 changed files with 430 additions and 1 deletions
@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest'
+import { Context } from 'cordis'
+import { CompactService } from '@deepseek-ai/dsh-compact'
+import type { CompactionResult } from '@deepseek-ai/dsh-compact'
+import { Session, SessionId } from '@deepseek-ai/dsh-session'
+
+/**
+ * A trivial concrete CompactService implementing the abstract contract. The
+ * interface package owns no algorithm — these tests exercise the seam itself:
+ * service registration, the abstract method shape, and the `compact/*` event
+ * declaration merge.
+ */
+class StubCompactService extends CompactService {
+  override async compactIfNeeded(_session: Session, _systemPrompt?: string, _model?: string): Promise<CompactionResult | null> {
+    return null
+  }
+
+  override async compactRegion(session: Session, start: number, end: number, _model: string): Promise<CompactionResult> {
+    // Minimal stub honoring the lock + log-only event contract.
+    const startEvent = session.append('compact/start', { turn: 0 })
+    const summaryEvent = session.append('compact/summary', {
+      summary: [{ type: 'text', text: 'stub' }],
+      compactedRange: { startSeq: start, endSeq: end },
+      compactedEventSeqs: [],
+      tokenCount: 0,
+    })
+    const endEvent = session.append('compact/end', { turn: 0 })
+    return {
+      startSeq: startEvent.seq,
+      summarySeq: summaryEvent.seq,
+      endSeq: endEvent.seq,
+      summary: [{ type: 'text', text: 'stub' }],
+      shadowedRange: { start, end },
+      shadowedSeqs: [],
+      compactedTokenCount: 0,
+    }
+  }
+}
+
+describe('CompactService seam', () => {
+  it('registers as ctx.compact', () => {
+    const ctx = new Context()
+    void new StubCompactService(ctx)
+    expect(ctx.compact).toBeDefined()
+    expect(ctx.compact).toBeInstanceOf(StubCompactService)
+  })
+
+  it('disposing the fiber unregisters ctx.compact (HMR safety)', async () => {
+    const ctx = new Context()
+    const fiber = await ctx.plugin(StubCompactService)
+    expect(ctx.compact).toBeInstanceOf(StubCompactService)
+    await fiber.dispose()
+    expect(ctx.compact).toBeUndefined()
+  })
+
+  it('exposes the abstract contract methods', async () => {
+    const ctx = new Context()
+    const svc = new StubCompactService(ctx)
+    expect(await svc.compactIfNeeded(new Session(SessionId('s')))).toBeNull()
+  })
+
+  it('compact/* events merge into SessionEventMap and are log-only', async () => {
+    const ctx = new Context()
+    const svc = new StubCompactService(ctx)
+    const session = new Session(SessionId('s'))
+
+    const result = await svc.compactRegion(session, 0, 0, 'm')
+
+    const startEvent = session.events.find(e => e.type === 'compact/start')
+    expect(startEvent).toBeDefined()
+    // Log-only: the compiler rejects surfaceOp on compact/* (not a SurfaceEventType);
+    // verify the runtime value is absent.
+    const raw = startEvent as unknown as { surfaceOp?: unknown }
+    expect(raw.surfaceOp).toBeUndefined()
+    expect(result.summarySeq).toBeGreaterThan(result.startSeq)
+    expect(result.endSeq).toBeGreaterThan(result.summarySeq)
+  })
+})