dsh-context-compression-improved 0.1.1 → 0.2.0

package/packages/selector/tests/cache-prefix-audit.spec.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest'
+import {
+  assessReusablePrefix,
+  buildSafeCacheAuditRecord,
+  fingerprintStablePrefix,
+  validateCacheUsage,
+  type StablePrefixEnvelope,
+} from './support/cache-prefix-audit.js'
+
+const parentEnvelope = (): StablePrefixEnvelope => ({
+  provider: 'deepseek',
+  model: 'deepseek-v4-flash',
+  system: ['stable-system'],
+  tools: [
+    { name: 'alpha', description: 'first', parameters: { type: 'object' } },
+    { name: 'beta', description: 'second', parameters: { type: 'object' } },
+  ],
+  messages: [
+    { role: 'user', content: 'completed parent turn' },
+    { role: 'assistant', content: 'completed response' },
+  ],
+})
+
+describe('parent/child cache-prefix characterization', () => {
+  it('accepts an identical fork prefix and computes the same fingerprint', () => {
+    const parent = parentEnvelope()
+    const child = structuredClone(parent)
+    const result = assessReusablePrefix({ mode: 'fork', inheritsParentContext: true, parent, child })
+
+    expect(result).toEqual({ eligible: true, reason: 'identical-fork-prefix' })
+    expect(fingerprintStablePrefix(parent)).toBe(fingerprintStablePrefix(child))
+    expect(fingerprintStablePrefix(parent)).toMatch(/^[a-f0-9]{64}$/u)
+  })
+
+  it('rejects spawn because it does not inherit parent messages', () => {
+    const parent = parentEnvelope()
+    const result = assessReusablePrefix({
+      mode: 'spawn',
+      inheritsParentContext: false,
+      parent,
+      child: { ...structuredClone(parent), messages: [] },
+    })
+
+    expect(result).toEqual({ eligible: false, reason: 'spawn-does-not-inherit' })
+  })
+
+  it.each([
+    ['system', (child: StablePrefixEnvelope) => { child.system = ['different-persona'] }],
+    ['tools', (child: StablePrefixEnvelope) => { child.tools.reverse() }],
+    ['provider', (child: StablePrefixEnvelope) => { child.provider = 'another-provider' }],
+    ['model', (child: StablePrefixEnvelope) => { child.model = 'another-model' }],
+    ['messages', (child: StablePrefixEnvelope) => { child.messages[0] = { role: 'user', content: 'different-history' } }],
+  ])('rejects a %s mismatch', (_field, mutate) => {
+    const parent = parentEnvelope()
+    const child = structuredClone(parent)
+    mutate(child)
+
+    expect(assessReusablePrefix({ mode: 'fork', inheritsParentContext: true, parent, child })).toEqual({
+      eligible: false,
+      reason: 'stable-prefix-mismatch',
+    })
+  })
+
+  it('emits only allowlisted evidence fields', () => {
+    const secret = 'sk-do-not-record-this'
+    const toolResult = 'private tool result'
+    const record = buildSafeCacheAuditRecord({
+      fingerprint: fingerprintStablePrefix(parentEnvelope()),
+      estimatedSharedPrefixTokens: 128,
+      parentSessionId: 'parent-id',
+      childSessionId: 'child-id',
+      mode: 'fork',
+      eligible: true,
+      reason: 'identical-fork-prefix',
+      cacheReadTokens: 96,
+      cacheMissTokens: 32,
+      observedPromptTokens: 128,
+    })
+    const serialized = JSON.stringify(record)
+
+    expect(Object.keys(record).sort()).toEqual([
+      'auditVersion',
+      'cacheMissTokens',
+      'cacheReadTokens',
+      'childSessionId',
+      'confirmationStatus',
+      'eligible',
+      'estimatedSharedPrefixTokens',
+      'fingerprint',
+      'mode',
+      'observedPromptTokens',
+      'parentSessionId',
+      'reason',
+    ])
+    expect(serialized).not.toContain(secret)
+    expect(serialized).not.toContain(toolResult)
+    expect(record.confirmationStatus).toBe('confirmed')
+  })
+
+  it('validates official cache usage arithmetic', () => {
+    expect(validateCacheUsage({ cacheReadTokens: 96, cacheMissTokens: 32, observedPromptTokens: 128 })).toBe(true)
+    expect(validateCacheUsage({ cacheReadTokens: 95, cacheMissTokens: 32, observedPromptTokens: 128 })).toBe(false)
+  })
+
+  it('marks missing official cache fields as unconfirmed without inventing zeros', () => {
+    const record = buildSafeCacheAuditRecord({
+      fingerprint: fingerprintStablePrefix(parentEnvelope()),
+      estimatedSharedPrefixTokens: 128,
+      parentSessionId: 'parent-id',
+      childSessionId: 'child-id',
+      mode: 'fork',
+      eligible: true,
+      reason: 'identical-fork-prefix',
+    })
+
+    expect(record).toMatchObject({
+      cacheReadTokens: null,
+      cacheMissTokens: null,
+      observedPromptTokens: null,
+      confirmationStatus: 'unconfirmed',
+    })
+  })
+})

package/packages/selector/tests/code-skeleton.client.spec.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { ClientContext, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-runtime/client'
+import { DEFAULT_CUSTOM_COMPRESSION_POLICY } from '../src/profiles.ts'
+import { apply } from '../src/client/index.ts'
+import type {
+  CompressionSelectorInjected,
+  ContextCompressionSettings,
+} from '../src/client/CompressionProfileSelector.tsx'
+
+vi.mock('@deepseek-ai/dsh-client-ui-primitives', () => ({
+  IconChevronDownOutline14: () => null,
+  Menu: () => null,
+}))
+
+describe('codeSkeleton confirm-on-write client contract', () => {
+  it('resolves only when the host confirms the toggled value and rejects silent drops', async () => {
+    let revision = 3
+    let commit = false
+    let flipEnabled = false
+    let value: ContextCompressionSettings = {
+      profile: 'balanced',
+      custom: structuredClone(DEFAULT_CUSTOM_COMPRESSION_POLICY),
+      autoCompact: { thresholdPercent: 80 },
+      codeSkeleton: { enabled: false },
+    }
+    const snapshot = (): SettingsScopeSnapshot<ContextCompressionSettings> => ({
+      status: 'ready',
+      value,
+      base: undefined,
+      user: undefined,
+      revision,
+      writable: true,
+      mode: 'host',
+    })
+    const scope = {
+      getSnapshot: snapshot,
+      subscribe: vi.fn(() => () => {}),
+      set: vi.fn(async (field: string, next: unknown) => {
+        if (!commit) return
+        revision += 1
+        if (field === 'codeSkeleton' && flipEnabled) {
+          const accepted = structuredClone(next as ContextCompressionSettings['codeSkeleton'])
+          accepted.enabled = !accepted.enabled
+          value = { ...value, codeSkeleton: accepted }
+          return
+        }
+        value = { ...value, [field]: next }
+      }),
+      unset: vi.fn(async () => {}),
+    }
+    let injected: (() => CompressionSelectorInjected) | undefined
+    const ctx = {
+      effect: (install: () => unknown) => { install() },
+      locale: { register: vi.fn(() => () => {}) },
+      settingsScope: { bind: vi.fn(() => scope) },
+      slots: {
+        inject: (_slot: string, install: () => unknown) => { install() },
+        register: (registration: { inject: () => CompressionSelectorInjected }) => {
+          injected = registration.inject
+          return () => {}
+        },
+      },
+    } as unknown as ClientContext
+
+    apply(ctx)
+    const actions = injected?.()
+    expect(actions).toBeDefined()
+    if (actions === undefined) throw new Error('selector injection was not registered')
+
+    // A silent host drop leaves the revision untouched: the write must reject.
+    await expect(actions.saveCodeSkeleton(true)).rejects.toThrow('were not saved')
+
+    // A committed write resolves and persists the exact section payload.
+    commit = true
+    await expect(actions.saveCodeSkeleton(true)).resolves.toBeUndefined()
+    expect(scope.set).toHaveBeenLastCalledWith('codeSkeleton', { enabled: true })
+    expect(value.codeSkeleton).toEqual({ enabled: true })
+
+    // A host that flips the toggled bit fails the acceptance check.
+    flipEnabled = true
+    await expect(actions.saveCodeSkeleton(false)).rejects.toThrow('were not saved')
+
+    flipEnabled = false
+    await expect(actions.saveCodeSkeleton(false)).resolves.toBeUndefined()
+    expect(scope.set).toHaveBeenLastCalledWith('codeSkeleton', { enabled: false })
+    expect(value.codeSkeleton).toEqual({ enabled: false })
+  })
+})

package/packages/selector/tests/custom-contract.client.spec.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { ClientContext, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-runtime/client'
+import {
+  DEFAULT_CUSTOM_COMPRESSION_POLICY,
+  isCustomCompressionPolicy,
+} from '../src/profiles.ts'
+import { apply } from '../src/client/index.ts'
+import { decodeSettings } from '../src/client/decode.ts'
+import type {
+  CompressionSelectorInjected,
+  ContextCompressionSettings,
+} from '../src/client/CompressionProfileSelector.tsx'
+
+vi.mock('@deepseek-ai/dsh-client-ui-primitives', () => ({
+  IconChevronDownOutline14: () => null,
+  Menu: () => null,
+}))
+
+const CUSTOM = {
+  version: 1,
+  unit: 'tokens',
+  fresh: { enabled: true, trigger: 4_096, target: 2_048 },
+  aggregate: { enabled: true, trigger: 16_384, target: 8_192 },
+  history: {
+    enabled: true,
+    trigger: 32_768,
+    keepRecentTurns: 2,
+    keepRecent: 16_384,
+    minReclaim: 8_192,
+  },
+  prefixPolicy: 'pressure-break',
+} as const satisfies ContextCompressionSettings['custom']
+
+describe('context compression browser contract', () => {
+  it('accepts legacy v1 and defaults new edits to v3 with TailTrim disabled', () => {
+    expect(isCustomCompressionPolicy(CUSTOM)).toBe(true)
+    expect(DEFAULT_CUSTOM_COMPRESSION_POLICY).toMatchObject({
+      version: 3,
+      tailTrim: { enabled: false, trigger: 700_000 },
+    })
+    expect(isCustomCompressionPolicy(DEFAULT_CUSTOM_COMPRESSION_POLICY)).toBe(true)
+  })
+
+  it('fails the browser narrowing for unknown or invalid Custom fields', () => {
+    expect(isCustomCompressionPolicy({
+      ...structuredClone(CUSTOM),
+      tailTrim: { enabled: true },
+    })).toBe(false)
+    expect(isCustomCompressionPolicy({
+      ...structuredClone(CUSTOM),
+      fresh: { enabled: true, trigger: 100, target: 100 },
+    })).toBe(false)
+    for (const trigger of [0, -1]) {
+      expect(isCustomCompressionPolicy({
+        ...structuredClone(DEFAULT_CUSTOM_COMPRESSION_POLICY),
+        tailTrim: { enabled: true, trigger },
+      })).toBe(false)
+    }
+    expect(isCustomCompressionPolicy({
+      ...structuredClone(DEFAULT_CUSTOM_COMPRESSION_POLICY),
+      unit: 'context-percent',
+      tailTrim: { enabled: true, trigger: 101 },
+    })).toBe(false)
+  })
+
+  it('decodes legacy settings to the default threshold and rejects malformed sections', async () => {
+    // Legacy documents stored before autoCompact existed inherit 80%.
+    const legacy = decodeSettings({ profile: 'balanced', custom: structuredClone(CUSTOM) })
+    expect(legacy).toMatchObject({ autoCompact: { thresholdPercent: 80 } })
+    // A present-but-invalid threshold fails the whole decode.
+    expect(decodeSettings({
+      profile: 'balanced',
+      custom: structuredClone(CUSTOM),
+      autoCompact: { thresholdPercent: 91 },
+    })).toBeUndefined()
+  })
+
+  it('reports a recovered no-op write only on the selector boundary', async () => {
+    let revision = 7
+    let commit = false
+    let rewriteCustom = false
+    let rewriteReset = false
+    let dropTailTrim = false
+    let downgradeVersion = false
+    let value: ContextCompressionSettings = {
+      profile: 'balanced',
+      custom: structuredClone(CUSTOM),
+      autoCompact: { thresholdPercent: 80 },
+      codeSkeleton: { enabled: false },
+    }
+    const snapshot = (): SettingsScopeSnapshot<ContextCompressionSettings> => ({
+      status: 'ready',
+      value,
+      base: undefined,
+      user: undefined,
+      revision,
+      writable: true,
+      mode: 'host',
+    })
+    const scope = {
+      getSnapshot: snapshot,
+      subscribe: vi.fn(() => () => {}),
+      set: vi.fn(async (field: string, next: unknown) => {
+        if (!commit) return
+        revision += 1
+        if (field === 'custom' && rewriteCustom) {
+          const accepted = structuredClone(next as ContextCompressionSettings['custom'])
+          accepted.fresh.trigger += 1
+          value = { ...value, custom: accepted }
+          return
+        }
+        if (field === 'custom' && rewriteReset) {
+          const accepted = structuredClone(next as ContextCompressionSettings['custom'])
+          accepted.fresh.trigger += 1
+          value = { ...value, custom: accepted }
+          return
+        }
+        if (field === 'custom' && dropTailTrim) {
+          const accepted = structuredClone(next as ContextCompressionSettings['custom'])
+          if (accepted.version === 3) {
+            accepted.tailTrim = { enabled: false, trigger: 700_000 }
+          }
+          value = { ...value, custom: accepted }
+          return
+        }
+        if (field === 'custom' && downgradeVersion) {
+          value = { ...value, custom: structuredClone(CUSTOM) }
+          return
+        }
+        value = { ...value, [field]: next }
+      }),
+      unset: vi.fn(async () => {
+        if (!commit) return
+        revision += 1
+        const custom: ContextCompressionSettings['custom'] = structuredClone(CUSTOM)
+        if (rewriteReset) {
+          custom.fresh.trigger = 8_192
+          custom.fresh.target = 4_096
+        }
+        value = { ...value, custom }
+      }),
+    }
+    let injected: (() => CompressionSelectorInjected) | undefined
+    const ctx = {
+      effect: (install: () => unknown) => { install() },
+      locale: { register: vi.fn(() => () => {}) },
+      settingsScope: { bind: vi.fn(() => scope) },
+      slots: {
+        inject: (_slot: string, install: () => unknown) => { install() },
+        register: (registration: { inject: () => CompressionSelectorInjected }) => {
+          injected = registration.inject
+          return () => {}
+        },
+      },
+    } as unknown as ClientContext
+
+    apply(ctx)
+    const actions = injected?.()
+    expect(actions).toBeDefined()
+    if (actions === undefined) throw new Error('selector injection was not registered')
+    await expect(actions.select('native')).rejects.toThrow('were not saved')
+
+    commit = true
+    await expect(actions.select('native')).resolves.toBeUndefined()
+    expect(value.profile).toBe('native')
+
+    const requested: ContextCompressionSettings['custom'] = structuredClone(CUSTOM)
+    requested.fresh.trigger = 8_192
+    requested.fresh.target = 4_096
+    rewriteCustom = true
+    await expect(actions.saveCustom(requested)).rejects.toThrow('were not saved')
+
+    rewriteCustom = false
+    const requestedV3 = structuredClone(DEFAULT_CUSTOM_COMPRESSION_POLICY)
+    if (requestedV3.version !== 3) throw new Error('Custom TailTrim persistence fixture requires policy v3')
+    requestedV3.tailTrim = { enabled: true, trigger: 49_152 }
+    dropTailTrim = true
+    await expect(actions.saveCustom(requestedV3)).rejects.toThrow('were not saved')
+
+    dropTailTrim = false
+    downgradeVersion = true
+    await expect(actions.saveCustom(requestedV3)).rejects.toThrow('were not saved')
+
+    downgradeVersion = false
+    rewriteReset = true
+    await expect(actions.resetCustom()).rejects.toThrow('were not saved')
+
+    rewriteReset = false
+    await expect(actions.resetCustom()).resolves.toBeUndefined()
+    expect(scope.set).toHaveBeenLastCalledWith('custom', DEFAULT_CUSTOM_COMPRESSION_POLICY)
+    expect(scope.unset).not.toHaveBeenCalled()
+
+    // The Auto Compact threshold shares the same confirm-on-write boundary:
+    // committed writes resolve, and a silent host drop rejects.
+    commit = false
+    await expect(actions.saveAutoCompact(73)).rejects.toThrow('were not saved')
+    commit = true
+    await expect(actions.saveAutoCompact(73)).resolves.toBeUndefined()
+    expect(scope.set).toHaveBeenLastCalledWith('autoCompact', { thresholdPercent: 73 })
+    expect(value.autoCompact).toEqual({ thresholdPercent: 73 })
+  })
+})

package/packages/selector/tests/estimator-catalog.spec.ts

@@ -0,0 +1,70 @@
+/** Estimator catalog projection: never throws, selection precedence, inline errors. */
+
+import { describe, expect, it } from 'vitest'
+import {
+  buildEstimatorCatalog, resolveHostRoute,
+  type EstimatorCatalogDeps,
+} from '../src/estimator-catalog.ts'
+
+describe('resolveHostRoute', () => {
+  it('prefers explicit overrides over the host default selection', () => {
+    expect(resolveHostRoute({
+      overrideProvider: 'p1',
+      overrideModel: 'm1',
+      currentSelection: () => ({ provider: 'p2', model: 'm2' }),
+    })).toEqual({ provider: 'p1', model: 'm1' })
+  })
+
+  it('falls back to the host default selection when overrides are empty', () => {
+    expect(resolveHostRoute({
+      overrideProvider: '',
+      overrideModel: '',
+      currentSelection: () => ({ provider: 'p2', model: 'm2' }),
+    })).toEqual({ provider: 'p2', model: 'm2' })
+  })
+
+  it('fills missing override fields from the selection, per field', () => {
+    expect(resolveHostRoute({ overrideProvider: 'p1', currentSelection: () => ({ model: 'm2' }) }))
+      .toEqual({ provider: 'p1', model: 'm2' })
+  })
+
+  it('reports undefined when neither source yields a complete route', () => {
+    expect(resolveHostRoute({ currentSelection: () => ({ provider: 'p' }) })).toBeUndefined()
+    expect(resolveHostRoute({})).toBeUndefined()
+  })
+})
+
+describe('buildEstimatorCatalog', () => {
+  it('lists every provider with its models and never throws on one broken group', async () => {
+    const llm = {
+      listProviders: () => [{ id: 'deepseek', name: 'DeepSeek' }, { id: 'broken', name: 'Broken' }],
+      listModels: async (providerId: string) => {
+        if (providerId === 'broken') throw new Error('adapter offline')
+        return [{ id: 'm1', name: 'Model 1' }]
+      },
+    }
+    const catalog = await buildEstimatorCatalog({ llm })
+    expect(catalog.providers).toHaveLength(2)
+    expect(catalog.providers[0]).toEqual({ id: 'deepseek', name: 'DeepSeek', models: [{ id: 'm1', name: 'Model 1' }] })
+    expect(catalog.providers[1]?.error).toBe('adapter offline')
+  })
+
+  it('uses route discovery when listModels is absent or silent', async () => {
+    const llm: NonNullable<EstimatorCatalogDeps['llm']> = {
+      listProviders: () => [{ id: 'self-hosted', name: 'Self hosted' }],
+      listConfigurableProviders: () => [{ provider: 'self-hosted', settingsNs: 'llm.self-hosted' }],
+      discoverModels: async () => [{ id: 'm9' }],
+    }
+    const catalog = await buildEstimatorCatalog({ llm })
+    expect(catalog.providers[0]?.models).toEqual([{ id: 'm9', name: 'm9' }])
+    expect(catalog.providers[0]?.error).toBeUndefined()
+  })
+
+  it('returns the host selection even when the llm service is unavailable', async () => {
+    const catalog = await buildEstimatorCatalog({
+      currentSelection: () => ({ provider: 'p', model: 'm' }),
+    })
+    expect(catalog.providers).toEqual([])
+    expect(catalog.selection).toEqual({ provider: 'p', model: 'm' })
+  })
+})