Merge remote app attribution branch

Resolve the RFC and implementation to defer OpenRouter-specific attribution headers and keep mandatory attribution to User-Agent only.

packages/llm/llm/tests/assembler.spec.ts

@@ -81,36 +81,6 @@ describe('BlockAssembler', () => {
     expect(() => assembler.blocks()).toThrow('BlockAssembler invariant violated')
   })
 
-  it('assembles open blocks at end of stream via flushRemaining', () => {
-    const assembler = new BlockAssembler()
-    assembler.push({ type: 'text-delta', index: 0, text: 'open' })
-    assembler.push({ type: 'reasoning-delta', index: 1, text: 'thinking' })
-
-    // flushReady returns nothing because index 0 is incomplete and blocking
-    const ready = assembler.flushReady()
-    expect(ready).toEqual([])
-
-    // flushRemaining assembles everything still open
-    const remaining = assembler.flushRemaining()
-    expect(remaining).toEqual([
-      { type: 'text', text: 'open' },
-      { type: 'reasoning', text: 'thinking' },
-    ])
-
-    // blocks() now matches the flushed view
-    expect(assembler.blocks()).toEqual(remaining)
-  })
-
-  it('result() omits usage key when no usage was received', () => {
-    const assembler = new BlockAssembler()
-    assembler.push({ type: 'text-delta', index: 0, text: 'msg' })
-    const result = assembler.result()
-    expect(result.message).toBeDefined()
-    expect(result.finish).toEqual({ kind: 'stop' })
-    // usage should NOT be present on the object at all
-    expect('usage' in result).toBe(false)
-  })
-
   it('ignores duplicate block-start for the same index', () => {
     const assembler = new BlockAssembler()
     assembler.push({ type: 'block-start', index: 0, blockType: 'text' })
@@ -142,13 +112,11 @@ describe('BlockAssembler', () => {
     ])
   })
 
-  it('includes usage in result() when usage was received', () => {
+  it('exposes usage via the getter when a usage chunk was received', () => {
     const assembler = new BlockAssembler()
     assembler.push({ type: 'text-delta', index: 0, text: 'msg' })
     assembler.push({ type: 'usage', usage: { inputTokens: 5, outputTokens: 3 } })
-    const result = assembler.result()
-    expect(result.usage).toEqual({ inputTokens: 5, outputTokens: 3 })
-    expect('usage' in result).toBe(true)
+    expect(assembler.usage).toEqual({ inputTokens: 5, outputTokens: 3 })
   })
 })
 
@@ -172,25 +140,25 @@ describe('BlockAssembler regressions (property-test findings)', () => {
     // Found by fast-check (the property-testing RFC): two block-ends at the same index made the
     // streamed prefix (first block) disagree with final blocks() (second
     // block). The first close must win — same straggler rule as post-close
-    // deltas — so streaming and one-shot assembly stay identical.
+    // deltas — so the prefix returned incrementally by push() and the final
+    // blocks() stay identical.
     const chunks: StreamChunk[] = [
       { type: 'block-end', index: 0, block: { type: 'reasoning', text: 'first' } },
       { type: 'block-end', index: 0, block: { type: 'text', text: 'second' } },
     ]
     const streaming = new BlockAssembler()
-    const flushed = []
+    const closed = []
     for (const chunk of chunks) {
-      streaming.push(chunk)
-      flushed.push(...streaming.flushReady())
+      const block = streaming.push(chunk)
+      if (block) closed.push(block)
     }
-    flushed.push(...streaming.flushRemaining())
 
     const oneShot = new BlockAssembler()
     for (const chunk of chunks) oneShot.push(chunk)
 
-    expect(flushed).toEqual([{ type: 'reasoning', text: 'first' }])
+    expect(closed).toEqual([{ type: 'reasoning', text: 'first' }])
     expect(oneShot.blocks()).toEqual([{ type: 'reasoning', text: 'first' }])
-    expect(flushed).toEqual(oneShot.blocks())
+    expect(closed).toEqual(oneShot.blocks())
   })
 
   it('push returns undefined for a duplicate block-end (it closed nothing)', () => {

packages/llm/llm/tests/attribution.spec.ts

@@ -0,0 +1,51 @@
+import { createRequire } from 'node:module'
+import { describe, expect, it } from 'vitest'
+import { APP_IDENTITY, attributionHeaders, userAgent } from '@deepseek-ai/dsh-llm'
+import type { AppIdentity } from '@deepseek-ai/dsh-llm'
+
+const manifest = createRequire(import.meta.url)('../package.json') as { version: string }
+
+/** A white-label identity exercising every override seam. */
+const forkIdentity: AppIdentity = {
+  product: 'fork-agent',
+  version: '9.9.9',
+  url: 'https://example.com/fork-agent',
+}
+
+describe('APP_IDENTITY', () => {
+  it('sources the version from the package manifest, never a hand-copied constant', () => {
+    expect(APP_IDENTITY.version).toBe(manifest.version)
+  })
+
+  it('carries only static public product facts', () => {
+    expect(APP_IDENTITY).toEqual({
+      product: 'deepseek-harness',
+      version: manifest.version,
+      url: 'https://github.com/deepseek-ai/deepseek-harness-sdk',
+    })
+  })
+})
+
+describe('userAgent', () => {
+  it('renders product/version with the +url comment', () => {
+    expect(userAgent()).toBe(
+      `deepseek-harness/${manifest.version} (+https://github.com/deepseek-ai/deepseek-harness-sdk)`,
+    )
+  })
+
+  it('renders a custom identity', () => {
+    expect(userAgent(forkIdentity)).toBe('fork-agent/9.9.9 (+https://example.com/fork-agent)')
+  })
+})
+
+describe('attributionHeaders', () => {
+  it('defaults to the provider-neutral baseline: User-Agent and nothing else', () => {
+    expect(attributionHeaders()).toEqual({ 'user-agent': userAgent() })
+  })
+
+  it('maps a custom identity onto the User-Agent header only', () => {
+    expect(attributionHeaders(forkIdentity)).toEqual({
+      'user-agent': 'fork-agent/9.9.9 (+https://example.com/fork-agent)',
+    })
+  })
+})

packages/llm/llm/tests/properties.spec.ts

@@ -4,13 +4,13 @@
  * The assembler is protocol-shaped: arbitrary interleavings of block-start,
  * deltas, block-end, usage, and finish — valid and malformed (duplicate
  * indices, stragglers after block-end, missing block-start, delta-only). The
- * invariants below are the contract the agent loop and LlmService rely on.
+ * invariants below are the contract the agent loop relies on.
  */
 
 import { describe, expect, it } from 'vitest'
 import fc from 'fast-check'
 import { BlockAssembler } from '@deepseek-ai/dsh-llm'
-import type { ContentBlock, StreamChunk } from '@deepseek-ai/dsh-llm'
+import type { StreamChunk } from '@deepseek-ai/dsh-llm'
 import { CallId } from '@deepseek-ai/dsh-llm'
 
 // A small pool of indices so collisions (duplicate-index bugs) are common.
@@ -55,38 +55,6 @@ function feed(chunks: StreamChunk[]): BlockAssembler {
 }
 
 describe('BlockAssembler properties', () => {
-  it('flushReady() ++ flushRemaining() === blocks(), in order', () => {
-    fc.assert(fc.property(streamArb, (chunks) => {
-      const streaming = new BlockAssembler()
-      const flushed: ContentBlock[] = []
-      for (const chunk of chunks) {
-        streaming.push(chunk)
-        flushed.push(...streaming.flushReady())
-      }
-      flushed.push(...streaming.flushRemaining())
-
-      const oneShot = feed(chunks).blocks()
-      expect(flushed).toEqual(oneShot)
-    }))
-  })
-
-  it('streamBlocks-style flush never yields a block before an earlier open one', () => {
-    // flushReady is strict-order: once it stops at an open index, no later
-    // index may be emitted until that one closes. We assert the flushed prefix
-    // is always a prefix of the final blocks() order.
-    fc.assert(fc.property(streamArb, (chunks) => {
-      const streaming = new BlockAssembler()
-      const flushed: ContentBlock[] = []
-      for (const chunk of chunks) {
-        streaming.push(chunk)
-        flushed.push(...streaming.flushReady())
-      }
-      const finalSoFar = streaming.blocks()
-      // Everything flushed mid-stream is a prefix of the full ordered blocks.
-      expect(finalSoFar.slice(0, flushed.length)).toEqual(flushed)
-    }))
-  })
-
   it('partials map size never exceeds the number of distinct indices seen', () => {
     fc.assert(fc.property(streamArb, (chunks) => {
       const distinct = new Set<number>()
@@ -131,20 +99,4 @@ describe('BlockAssembler properties', () => {
       }
     }))
   })
-
-  it('streaming and one-shot assembly agree on usage and finish', () => {
-    fc.assert(fc.property(streamArb, (chunks) => {
-      // Streaming consumer: push + flush as it goes.
-      const streaming = new BlockAssembler()
-      for (const chunk of chunks) {
-        streaming.push(chunk)
-        streaming.flushReady()
-      }
-      streaming.flushRemaining()
-      // One-shot consumer: push all, then read.
-      const oneShot = feed(chunks)
-      expect(streaming.usage).toEqual(oneShot.usage)
-      expect(streaming.finish).toEqual(oneShot.finish)
-    }))
-  })
 })

packages/llm/llm/tests/service.spec.ts

@@ -19,24 +19,22 @@ const SCRIPT: StreamChunk[] = [
 ]
 
 describe('LlmService', () => {
-  it('routes stream() to the registered adapter and generate() assembles it', async () => {
+  it('routes stream() to the registered adapter', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
     ctx.llm.registerAdapter(['test-model'], new ScriptedAdapter(SCRIPT))
 
     const chunks: StreamChunk[] = []
     for await (const chunk of ctx.llm.stream({ model: 'test-model', messages: [] })) chunks.push(chunk)
-    expect(chunks).toHaveLength(3)
-
-    const result = await ctx.llm.generate({ model: 'test-model', messages: [] })
-    expect(result.message.content).toEqual([{ type: 'text', text: 'hi' }])
-    expect(result.finish).toEqual({ kind: 'stop' })
+    expect(chunks).toEqual(SCRIPT)
   })
 
   it('throws NO_ADAPTER for unregistered models', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    await expect(ctx.llm.generate({ model: 'nope', messages: [] })).rejects.toThrow('no adapter registered')
+    await expect((async () => {
+      for await (const _ of ctx.llm.stream({ model: 'nope', messages: [] })) { /* drain */ }
+    })()).rejects.toThrow('no adapter registered')
   })
 
   it('unregisters adapters when the owning fiber is disposed (HMR safety)', async () => {
@@ -71,21 +69,6 @@ describe('LlmService', () => {
     expect(chunks[0]).toMatchObject({ index: 99 })
   })
 
-  it('lets llm/generate waterfall listeners intercept and transform the result', async () => {
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], new ScriptedAdapter(SCRIPT))
-
-    ctx.on('llm/generate', async function (_options, next) {
-      const result = await next()
-      return { ...result, finish: { kind: 'max-tokens' } as const }
-    })
-
-    const result = await ctx.llm.generate({ model: 'test-model', messages: [] })
-    expect(result.finish).toEqual({ kind: 'max-tokens' })
-    expect(result.message.content).toEqual([{ type: 'text', text: 'hi' }])
-  })
-
   it('creates LlmError with a code for programmatic handling', () => {
     const err = new LlmError('something went wrong', 'CUSTOM_CODE')
     expect(err).toBeInstanceOf(Error)
@@ -116,20 +99,13 @@ describe('LlmService', () => {
     expect(isHarnessError('nope')).toBe(false)
   })
 
-  it('disposes adapter registration on adapter-change event emission', async () => {
+  it('removes the adapter when the returned disposer is called', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
 
-    const changes: string[][] = []
-    ctx.on('llm/adapter-change', () => {
-      changes.push([...ctx.llm.models()])
-    })
-
     const dispose = ctx.llm.registerAdapter(['m1'], new ScriptedAdapter(SCRIPT))
-    expect(changes).toEqual([['m1']])
-
+    expect(ctx.llm.models()).toEqual(['m1'])
     dispose()
-    expect(changes).toEqual([['m1'], []])
     expect(ctx.llm.models()).toEqual([])
   })
 
@@ -147,25 +123,19 @@ describe('LlmService', () => {
     }
   })
 
-  it('rolls back the adapter entry when an adapter-change listener throws (P1-1)', async () => {
+  it('re-registers a model after its prior registration is disposed', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
 
-    // A change listener that throws on the FIRST emit only.
-    let threw = false
-    ctx.on('llm/adapter-change', () => {
-      if (!threw) { threw = true; throw new Error('boom change listener') }
-    })
-
-    // The throwing emit must roll the mutation back, not leak it.
-    expect(() => ctx.llm.registerAdapter(['m1'], new ScriptedAdapter(SCRIPT))).toThrow('boom change listener')
-    expect(ctx.llm.models()).toEqual([]) // entry rolled back, not leaked
-
-    // A subsequent listener-free register of the SAME model succeeds and
-    // contributes exactly once (the duplicate check is not wedged).
     const dispose = ctx.llm.registerAdapter(['m1'], new ScriptedAdapter(SCRIPT))
     expect(ctx.llm.models()).toEqual(['m1'])
     dispose()
     expect(ctx.llm.models()).toEqual([])
+
+    // The duplicate check is not wedged: the same model registers cleanly again.
+    const disposeAgain = ctx.llm.registerAdapter(['m1'], new ScriptedAdapter(SCRIPT))
+    expect(ctx.llm.models()).toEqual(['m1'])
+    disposeAgain()
+    expect(ctx.llm.models()).toEqual([])
   })
 })