Merge remote-tracking branch 'origin/master' into claude/web-llm-pi-ai-config-385e24

# Conflicts: # packages/llm/llm-pi-ai/tests/adapter.spec.ts # packages/llm/llm/README.i18n.yaml
2026-08-06 10:47:36 +08:00
parent 9948a37cbc e88bace07e
commit 17c86bbb25
822 changed files with 18341 additions and 14753 deletions
--- a/packages/llm/llm-deepseek/tests/adapter.spec.ts
+++ b/packages/llm/llm-deepseek/tests/adapter.spec.ts
@@ -2,8 +2,6 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import LlmService, { createUserMessage,
  CONTEXT_WINDOW_EXCEEDED_CODE,
-  errorChain,
-  LlmError,
  ProviderRequestId,
  QUOTA_EXCEEDED_CODE,
  ReasoningEffortId,
@@ -206,18 +204,22 @@ describe('DeepSeekAdapter against a mock server', () => {
      })
  })

-  it('rejects a per-request effort before I/O when thinking is disabled', async () => {
+  it('reports a per-request effort failure before I/O when thinking is disabled', async () => {
    const server = await mockServer([])
    const ctx = await harness(server.url, { thinking: 'disabled' })

-    await expect(assemble(ctx, {
+    const result = await assemble(ctx, {
      model: 'deepseek-v4-flash',
      reasoningEffort: ReasoningEffortId('high'),
      messages: [createUserMessage({
        content: [{ type: 'text', text: 'hi' }],
        source: { kind: 'plugin', plugin: 'test' },
      })],
-    })).rejects.toMatchObject({ code: 'UNSUPPORTED_REASONING_EFFORT' })
+    })
+    expect(result.finish).toMatchObject({
+      kind: 'error',
+      failure: { code: 'UNSUPPORTED_REASONING_EFFORT' },
+    })
    expect(server.requests).toHaveLength(0)
  })

@@ -250,23 +252,22 @@ describe('DeepSeekAdapter against a mock server', () => {
    [400, 'INVALID_REQUEST'],
    [500, 'SERVER'],
    [503, 'SERVER'],
-  ])('maps HTTP %d to LlmError code %s with the body message', async (status, code) => {
+  ])('maps HTTP %d to failure code %s with the body message', async (status, code) => {
    const behavior: Behavior = {
      kind: 'http-error',
      status,
      body: JSON.stringify({ error: { message: `failed with ${status}`, type: 't', code: 'c' } }),
    }
-    const server = await mockServer([behavior, behavior])
+    const server = await mockServer([behavior])
    const ctx = await harness(server.url)
-    await expect(assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toThrow(`failed with ${status}`)
-    await expect(
-      assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] })
-        .catch((error: unknown) => (error as LlmError).code),
-    ).resolves.toBe(code)
+    const result = await assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish).toEqual({
+      kind: 'error',
+      failure: { message: `failed with ${status}`, code, status },
+    })
  })

-  it('classifies a thrown HTTP context-window rejection with the canonical code', async () => {
+  it('classifies an HTTP context-window failure with the canonical code', async () => {
    const server = await mockServer([{
      kind: 'http-error',
      status: 400,
@@ -279,9 +280,11 @@ describe('DeepSeekAdapter against a mock server', () => {
      }),
    }])
    const ctx = await harness(server.url)
-    const code = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
-      .catch((error: unknown) => (error as LlmError).code)
-    expect(code).toBe(CONTEXT_WINDOW_EXCEEDED_CODE)
+    const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish).toMatchObject({
+      kind: 'error',
+      failure: { code: CONTEXT_WINDOW_EXCEEDED_CODE },
+    })
  })

  it('retains status, Retry-After seconds, and provider request id as structured facts', async () => {
@@ -292,19 +295,16 @@ describe('DeepSeekAdapter against a mock server', () => {
      headers: { 'retry-after': '2', 'x-request-id': 'req-429' },
    }])
    const ctx = await harness(server.url)
-    let thrown: unknown
-    try {
-      await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
-    } catch (error: unknown) {
-      thrown = error
-    }
-    expect(thrown).toBeInstanceOf(LlmError)
-    expect((thrown as LlmError).failure).toEqual({
-      message: 'slow down',
-      code: 'RATE_LIMIT',
-      status: 429,
-      providerRetryAfterMs: 2_000,
-      requestId: ProviderRequestId('req-429'),
+    const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish).toEqual({
+      kind: 'error',
+      failure: {
+        message: 'slow down',
+        code: 'RATE_LIMIT',
+        status: 429,
+        providerRetryAfterMs: 2_000,
+        requestId: ProviderRequestId('req-429'),
+      },
    })
  })

@@ -322,16 +322,17 @@ describe('DeepSeekAdapter against a mock server', () => {
        },
      }])
      const ctx = await harness(server.url)
-      await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-        .rejects.toMatchObject({
-          failure: {
-            message: 'come back later',
-            code: 'SERVER',
-            status: 503,
-            providerRetryAfterMs: 3_000,
-            requestId: ProviderRequestId('deepseek-503'),
-          },
-        })
+      const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+      expect(result.finish).toEqual({
+        kind: 'error',
+        failure: {
+          message: 'come back later',
+          code: 'SERVER',
+          status: 503,
+          providerRetryAfterMs: 3_000,
+          requestId: ProviderRequestId('deepseek-503'),
+        },
+      })
    } finally {
      dateNow.mockRestore()
    }
@@ -352,13 +353,11 @@ describe('DeepSeekAdapter against a mock server', () => {
        headers: { 'retry-after': value },
      }])
      const ctx = await harness(server.url)
-      let thrown: LlmError | undefined
-      try {
-        await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
-      } catch (error: unknown) {
-        if (error instanceof LlmError) thrown = error
-      }
-      expect(thrown?.failure).toEqual({ message: 'retry later', code: 'RATE_LIMIT', status: 429 })
+      const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+      expect(result.finish).toEqual({
+        kind: 'error',
+        failure: { message: 'retry later', code: 'RATE_LIMIT', status: 429 },
+      })
    }
  })

@@ -379,53 +378,50 @@ describe('DeepSeekAdapter against a mock server', () => {
  it('keeps the status-line message for JSON error bodies without a message', async () => {
    const server = await mockServer([{ kind: 'http-error', status: 500, body: '{"error":{"type":"x"}}' }])
    const ctx = await harness(server.url)
-    await expect(assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toThrow(/HTTP 500/)
+    const result = await assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish.kind).toBe('error')
+    if (result.finish.kind !== 'error') throw new Error('expected an error finish')
+    expect(result.finish.failure.code).toBe('SERVER')
+    expect(result.finish.failure.message).toMatch(/HTTP 500/)
  })

  it('keeps the status-line message for non-JSON error bodies', async () => {
    const server = await mockServer([{ kind: 'http-error', status: 502, body: 'Bad Gateway', contentType: 'text/plain' }])
    const ctx = await harness(server.url)
-    await expect(assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toThrow(/HTTP 502/)
+    const result = await assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish.kind).toBe('error')
+    if (result.finish.kind !== 'error') throw new Error('expected an error finish')
+    expect(result.finish.failure.code).toBe('SERVER')
+    expect(result.finish.failure.message).toMatch(/HTTP 502/)
  })

  it('maps unusual statuses to HTTP_<status>', () => {
    expect(httpErrorCode(418)).toBe('HTTP_418')
  })

-  it('wraps a transport failure in TRANSPORT with the fetch cause chain in the message', async () => {
-    // Port 1 is reserved/unbound: fetch rejects with `TypeError: fetch failed`
-    // whose actionable detail (ECONNREFUSED) lives on `cause`.
+  it('reports a transport failure with the endpoint in the message', async () => {
+    // Port 1 is reserved/unbound, so the service normalizes the fetch failure.
    const ctx = await harness('http://127.0.0.1:1')
-    let caught: unknown
-    try {
-      await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
-    } catch (error: unknown) {
-      caught = error
-    }
-    expect(caught).toBeInstanceOf(LlmError)
-    const llmError = caught as LlmError
-    expect(llmError.code).toBe('TRANSPORT')
-    expect(llmError.message).toContain('http://127.0.0.1:1')
-    expect(llmError.cause).toBeInstanceOf(TypeError)
-    // The chain renderer reaches the transport diagnosis through the cause.
-    expect(errorChain(llmError)).toMatch(/ECONNREFUSED|EADDRNOTAVAIL|bad port/)
+    const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish).toMatchObject({
+      kind: 'error',
+      failure: {
+        code: 'TRANSPORT',
+        message: 'DeepSeek API request to http://127.0.0.1:1 failed',
+      },
+    })
  })

-  it('classifies an aborted request without losing the transport rejection', async () => {
+  it('classifies an aborted request as an aborted finish', async () => {
    const controller = new AbortController()
    controller.abort()
    const ctx = await harness('http://127.0.0.1:1')
-    let caught: unknown
-    try {
-      await assemble(ctx, { model: 'deepseek-v4-flash', messages: [], signal: controller.signal })
-    } catch (error: unknown) {
-      caught = error
-    }
-    expect(caught).toBeInstanceOf(LlmError)
-    expect(caught).toMatchObject({ code: 'ABORTED' })
-    expect((caught as LlmError).cause).toMatchObject({ name: 'AbortError' })
+    const result = await assemble(ctx, {
+      model: 'deepseek-v4-flash',
+      messages: [],
+      signal: controller.signal,
+    })
+    expect(result.finish).toMatchObject({ kind: 'aborted', failure: { code: 'ABORTED' } })
  })

  it('throws EMPTY_RESPONSE when the response has no body', async () => {
@@ -443,20 +439,17 @@ describe('DeepSeekAdapter against a mock server', () => {
    }
  })

-  it('classifies an abrupt body close as TRANSPORT and retains its cause', async () => {
+  it('classifies an abrupt body close as TRANSPORT', async () => {
    const server = await mockServer([{
      kind: 'close-early',
      events: ['{"choices":[{"delta":{"content":"par"}}]}'],
    }])
    const ctx = await harness(server.url)
-    let caught: unknown
-    try {
-      await assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] })
-    } catch (error: unknown) {
-      caught = error
-    }
-    expect(caught).toMatchObject({ code: 'TRANSPORT' })
-    expect(errorChain(caught)).toMatch(/terminated|socket|without \[DONE\]/)
+    const result = await assemble(ctx,{ model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish.kind).toBe('error')
+    if (result.finish.kind !== 'error') throw new Error('expected an error finish')
+    expect(result.finish.failure.code).toBe('TRANSPORT')
+    expect(result.finish.failure.message).toMatch(/^DeepSeek API stream from .* failed$/)
  })

  it('aborts mid-stream via the request signal', async () => {
@@ -478,7 +471,13 @@ describe('DeepSeekAdapter against a mock server', () => {
    })()

    setTimeout(() => { controller.abort() }, 30)
-    await expect(pending).rejects.toMatchObject({ code: 'ABORTED' })
+    const chunks = await pending
+    expect(chunks).toHaveLength(1)
+    expect(chunks[0]?.type).toBe('finish')
+    if (chunks[0]?.type !== 'finish') throw new Error('expected a finish chunk')
+    expect(chunks[0].reason.kind).toBe('aborted')
+    if (chunks[0].reason.kind !== 'aborted') throw new Error('expected an aborted finish')
+    expect(chunks[0].reason.failure.code).toBe('ABORTED')
  })

  it('maps connection failures to TRANSPORT without losing the cause', async () => {
@@ -878,12 +877,15 @@ describe('plugin registration and config', () => {
    // only the request itself needs a key.
    expect(ctx.llm.listProviders()).toEqual([{ id: 'deepseek-official', name: 'DeepSeek' }])
    await expect(ctx.llm.listModels('deepseek-official')).resolves.toHaveLength(2)
-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toMatchObject({ code: 'MISSING_CREDENTIAL' })
+    const first = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(first.finish).toMatchObject({ kind: 'error', failure: { code: 'MISSING_CREDENTIAL' } })
    // The guidance leads with the credential store — the path that keeps the
    // secret out of configuration files — and mentions a literal key last.
-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toThrow(/store DEEPSEEK_API_KEY through the credentials service.*as a last resort.*"apiKey"/s)
+    const second = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(second.finish.kind).toBe('error')
+    if (second.finish.kind !== 'error') throw new Error('expected an error finish')
+    expect(second.finish.failure.message)
+      .toMatch(/store DEEPSEEK_API_KEY through the credentials service.*as a last resort.*"apiKey"/s)
  })

  it('reads the ambient variable when no credentials seam is mounted', async () => {
@@ -903,8 +905,8 @@ describe('plugin registration and config', () => {
    const ctx = new Context()
    await ctx.plugin(LlmService)
    await ctx.plugin(LlmDeepSeek, { baseURL: 'http://127.0.0.1:1' })
-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toMatchObject({ code: 'MISSING_CREDENTIAL' })
+    const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish).toMatchObject({ kind: 'error', failure: { code: 'MISSING_CREDENTIAL' } })
  })

  it('prefers explicit config over env for key and base URL', async () => {
--- a/packages/llm/llm-deepseek/tests/dynamic-config.spec.ts
+++ b/packages/llm/llm-deepseek/tests/dynamic-config.spec.ts
@@ -96,7 +96,8 @@ describe('request-level dynamic configuration', () => {
    const server = await mockServer([{ kind: 'sse', events: textEvents }])
    const { ctx } = await boot(dir, { baseURL: server.url })

-    await expect(prompt(ctx)).rejects.toMatchObject({ code: 'MISSING_CREDENTIAL' })
+    const keyless = await prompt(ctx)
+    expect(keyless.finish).toMatchObject({ kind: 'error', failure: { code: 'MISSING_CREDENTIAL' } })
    await ctx.credentials.set(KEY_REF, 'sk-arrived')
    await prompt(ctx)
    expect(server.headers[0]?.authorization).toBe('Bearer sk-arrived')
--- a/packages/llm/llm-pi-ai/tests/adapter.spec.ts
+++ b/packages/llm/llm-pi-ai/tests/adapter.spec.ts
@@ -85,7 +85,7 @@ describe('PiAiAdapter provider routing', () => {
    })
  })

-  it('uses a dynamic request effort and rejects unsupported efforts before network I/O', async () => {
+  it('uses a dynamic request effort and reports unsupported efforts before network I/O', async () => {
    const server = await mockServer([{ events: textEvents }, { events: textEvents }])
    const ctx = await harness(server.url, { reasoning: 'max' })

@@ -104,11 +104,15 @@ describe('PiAiAdapter provider routing', () => {
    expect(server.requests[1]).toMatchObject({ thinking: { type: 'disabled' } })
    expect(server.requests[1]).not.toHaveProperty('reasoning_effort')

-    await expect(assemble(ctx, {
+    const unsupported = await assemble(ctx, {
      model: 'deepseek-v4-flash',
      reasoningEffort: ReasoningEffortId('xhigh'),
      messages: [],
-    })).rejects.toMatchObject({ code: 'UNSUPPORTED_REASONING_EFFORT' })
+    })
+    expect(unsupported.finish).toMatchObject({
+      kind: 'error',
+      failure: { code: 'UNSUPPORTED_REASONING_EFFORT' },
+    })
    expect(server.requests).toHaveLength(2)
  })

@@ -142,19 +146,19 @@ describe('PiAiAdapter provider routing', () => {
    expect(adapter.providerInfo('departed')).toEqual({ id: 'departed', name: 'departed' })
  })

-  it('rejects stop sequences rather than silently ignoring them', async () => {
+  it('reports unsupported stop sequences rather than silently ignoring them', async () => {
    const server = await mockServer([])
    const ctx = await harness(server.url)
-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [], stop: ['END'] }))
-      .rejects.toMatchObject({ code: 'UNSUPPORTED_OPTION' })
+    const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [], stop: ['END'] })
+    expect(result.finish).toMatchObject({ kind: 'error', failure: { code: 'UNSUPPORTED_OPTION' } })
    expect(server.requests).toEqual([])
  })

-  it('rejects unknown catalog models before network I/O', async () => {
+  it('reports unknown catalog models before network I/O', async () => {
    const server = await mockServer([])
    const ctx = await harness(server.url)
-    await expect(assemble(ctx, { model: 'not-in-the-catalog', messages: [] }))
-      .rejects.toMatchObject({ code: 'UNKNOWN_MODEL' })
+    const result = await assemble(ctx, { model: 'not-in-the-catalog', messages: [] })
+    expect(result.finish).toMatchObject({ kind: 'error', failure: { code: 'UNKNOWN_MODEL' } })
    expect(server.requests).toEqual([])
  })

@@ -254,8 +258,8 @@ describe('PiAiAdapter provider routing', () => {
    const server = await mockServer([{ events: textEvents, delayMs: 200 }])
    const ctx = await harness(server.url, { streamIdleTimeoutMs: 20 })

-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toMatchObject({ code: 'TIMEOUT' })
+    const result = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(result.finish).toMatchObject({ kind: 'error', failure: { code: 'TIMEOUT' } })
    await Promise.race([
      server.responseClosed,
      new Promise<never>((_resolve, reject) => {
@@ -409,10 +413,12 @@ describe('provider profile lifecycle', () => {
    vi.stubEnv('DEEPSEEK_API_KEY', 'ambient-key')
    const server = await mockServer([{ events: textEvents }])
    const ctx = await harness(server.url, { apiKey: undefined, apiKeyEnv: 'PI_CUSTOM_REF_KEY' })
-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toMatchObject({ code: 'MISSING_CREDENTIAL' })
-    await expect(assemble(ctx, { model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toThrow(/provider route "deepseek".*PI_CUSTOM_REF_KEY/s)
+    const first = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(first.finish).toMatchObject({ kind: 'error', failure: { code: 'MISSING_CREDENTIAL' } })
+    const second = await assemble(ctx, { model: 'deepseek-v4-flash', messages: [] })
+    expect(second.finish.kind).toBe('error')
+    if (second.finish.kind !== 'error') throw new Error('expected an error finish')
+    expect(second.finish.failure.message).toMatch(/provider route "deepseek".*PI_CUSTOM_REF_KEY/s)
    expect(server.requests).toHaveLength(0)
  })

--- a/packages/llm/llm-pi-ai/tests/catalog.spec.ts
+++ b/packages/llm/llm-pi-ai/tests/catalog.spec.ts
@@ -357,8 +357,9 @@ describe('catalog routes with per-model configuration', () => {
      },
    })

-    await expect(assemble(ctx, { provider: 'deepseek', model: 'not-configured', messages: [] }))
-      .rejects.toMatchObject({ code: 'UNKNOWN_MODEL' })
+    const result = await assemble(ctx, { provider: 'deepseek', model: 'not-configured', messages: [] })
+
+    expect(result.finish).toMatchObject({ kind: 'error', failure: { code: 'UNKNOWN_MODEL' } })
    expect(server.requests).toHaveLength(0)
  })

--- a/packages/llm/llm-pi-ai/tests/dynamic-config.spec.ts
+++ b/packages/llm/llm-pi-ai/tests/dynamic-config.spec.ts
@@ -105,8 +105,8 @@ describe('request-level dynamic profiles', () => {
    // composition route stays.
    await ctx.settings.replace(NS, {})
    expect(ctx.llm.listProviders().map(provider => provider.id)).toEqual(['openai'])
-    await expect(assemble(ctx, { provider: 'deepseek', model: 'deepseek-v4-flash', messages: [] }))
-      .rejects.toMatchObject({ code: 'NO_ADAPTER' })
+    const removed = await assemble(ctx, { provider: 'deepseek', model: 'deepseek-v4-flash', messages: [] })
+    expect(removed.finish).toMatchObject({ kind: 'error', failure: { code: 'NO_ADAPTER' } })
  })

  it('rotates the per-request credential referenced by apiKeyEnv', async () => {
--- a/packages/llm/llm-retry/src/history.ts
+++ b/packages/llm/llm-retry/src/history.ts
@@ -1,28 +1,29 @@
-/** Durable request-route lookup for one closed model step. @module @deepseek-ai/dsh-llm-retry/history */
+/** Durable request-route lookup for one open model step. @module @deepseek-ai/dsh-llm-retry/history */

 import type { SessionEvent } from '@deepseek-ai/dsh-session'

 /**
- * Find the provider in force when one step closed, excluding later recovery mutations.
+ * Find the provider in force for one currently open step.
 * Request headers remain effective across turn boundaries until a newer full
 * snapshot changes them; every provider change requires a newer full snapshot.
- * @param events - session events containing the closed step.
+ * @param events - session events ending inside the open step.
 * @param turn - turn that owns the failed step.
 * @param step - failed step whose provider is required.
- * @returns the provider from the request header in force at that step boundary.
+ * @returns the provider from the request header in force for the step.
 */
-export function providerForClosedStep(
+export function providerForOpenStep(
  events: readonly SessionEvent[],
  turn: number,
  step: number,
 ): string | undefined {
-  const stepEndIndex = events.findLastIndex(event =>
-    event.type === 'step/end'
+  const stepStartIndex = events.findLastIndex(event =>
+    event.type === 'step/start'
    && event.data.turn === turn
    && event.data.step === step,
  )
-  if (stepEndIndex < 0) return undefined
-  for (let index = stepEndIndex; index >= 0; index -= 1) {
+  if (stepStartIndex < 0 || events.slice(stepStartIndex + 1).some(event =>
+    event.type === 'step/end' || event.type === 'turn/end')) return undefined
+  for (let index = events.length - 1; index >= 0; index -= 1) {
    // The loop bounds prove this indexed read exists.
    // oxlint-disable-next-line typescript/no-non-null-assertion
    const event = events[index]!
--- a/packages/llm/llm-retry/src/index.ts
+++ b/packages/llm/llm-retry/src/index.ts
@@ -1,5 +1,5 @@
 /**
- * Provider-routed model-request retry policy on the agent loop's closed-step
+ * Provider-routed model-request retry policy on the agent loop's request
 * recovery seam. Each scheduled retry is durable before its cancellable wait.
 *
 * @module @deepseek-ai/dsh-llm-retry
@@ -7,14 +7,13 @@

 import type { Context } from 'cordis'
 import z from 'schemastery'
-import type { Agent, RequestError, RequestErrorAction } from '@deepseek-ai/dsh-agent'
+import type { Agent, RequestErrorAction, RequestFailureContext } from '@deepseek-ai/dsh-agent'
 import type { LlmFailure, ResolvedRetryPolicy } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import { providerForClosedStep } from './history.ts'

 declare module '@deepseek-ai/dsh-session' {
  interface SessionEventMap {
-    /** Durable, non-surface record of one provider-routed retry scheduled after a closed failed step. */
+    /** Durable, non-surface record of one provider-routed retry scheduled after a failed request attempt. */
    'llm/retry': {
      turn: number
      step: number
@@ -174,24 +173,12 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna

  async function recover(
    agent: Agent,
-    turn: number,
-    step: number,
-    _error: RequestError,
-    failure: LlmFailure,
-    priorFailures: readonly LlmFailure[],
-    policy: ResolvedRetryPolicy | undefined,
+    context: RequestFailureContext,
    signal: AbortSignal,
    next: () => Promise<RequestErrorAction>,
  ): Promise<RequestErrorAction> {
+    const { turn, step, provider, failure, retryPolicy: policy } = context
    if (policy === undefined) return next()
-    // The call-local policy belongs to the registration that served this
-    // failure. Recover only the durable provider identity from the header;
-    // downstream recovery may append later state before an always fallback.
-    const provider = providerForClosedStep(agent.session.events, turn, step)
-    /* v8 ignore next 3 -- agent-loop closes only steps whose request header was recorded */
-    if (provider === undefined) {
-      throw new Error(`llm-retry: no request provider for closed turn ${turn}/step ${step}`)
-    }
    if (policy.mode === 'always') {
      if (signal.aborted || lifetime.signal.aborted) return
      const fusedSignal = AbortSignal.any([signal, lifetime.signal])
@@ -213,11 +200,10 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
    }

    const policyKey = retryPolicyKey(policy)
-    const firstPriorTurn = turn - priorFailures.length
    const priorPolicyRetry = agent.session.events.findLast((event): event is SessionEvent<'llm/retry'> =>
      event.type === 'llm/retry'
-      && event.data.turn >= firstPriorTurn
-      && event.data.turn < turn
+      && event.data.turn === turn
+      && event.data.step === step
      && event.data.provider === provider
      && event.data.policyKey === policyKey,
    )
@@ -243,12 +229,7 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna

  const disposeListener = ctx.on('agent/request-error', (
    agent: Agent,
-    turn: number,
-    step: number,
-    error: RequestError,
-    failure: LlmFailure,
-    priorFailures: readonly LlmFailure[],
-    policy: ResolvedRetryPolicy | undefined,
+    context: RequestFailureContext,
    signal: AbortSignal,
    next: () => Promise<RequestErrorAction>,
  ) => {
@@ -256,7 +237,7 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
    // removed. Lifetime cancellation must prevent that stale callback from
    // entering a downstream policy after disposal.
    if (lifetime.signal.aborted) return Promise.resolve<RequestErrorAction>(undefined)
-    return track(recover(agent, turn, step, error, failure, priorFailures, policy, signal, next))
+    return track(recover(agent, context, signal, next))
  })

  ctx.effect(() => async () => {
--- a/packages/llm/llm-retry/src/invariant.ts
+++ b/packages/llm/llm-retry/src/invariant.ts
@@ -5,7 +5,7 @@ import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import type { LlmFailure } from '@deepseek-ai/dsh-llm'
 import { MAX_TIMER_DELAY_MS } from '@deepseek-ai/dsh-timeout'
 import type { InvariantFailure, InvariantInstaller } from '@deepseek-ai/dsh-invariants'
-import { providerForClosedStep } from './history.ts'
+import { providerForOpenStep } from './history.ts'
 import type {} from './index.ts'

 const PACKAGE_NAME = '@deepseek-ai/dsh-llm-retry'
@@ -41,35 +41,7 @@ function validateFailure(value: unknown, fail: InvariantFailure): asserts value
  }
 }

-/** Find the first turn in the structured-failure retry chain containing `turn`. */
-function retryChainStart(history: readonly SessionEvent[], turn: number): number {
-  let startIndex = history.findLastIndex(
-    event => event.type === 'turn/start' && event.data.turn === turn,
-  )
-  while (startIndex >= 0) {
-    const start = history[startIndex]
-    if (start?.type !== 'turn/start' || start.data.trigger.kind !== 'retry') break
-
-    let endIndex = startIndex - 1
-    while (endIndex >= 0 && history[endIndex]?.type !== 'turn/end') endIndex -= 1
-    const end = history[endIndex]
-    if (end?.type !== 'turn/end'
-      || end.data.reason.kind !== 'error'
-      || end.data.reason.failure === undefined) break
-
-    const previousStart = history.findLastIndex(
-      (event, index) =>
-        index < endIndex
-        && event.type === 'turn/start'
-        && event.data.turn === end.data.turn,
-    )
-    if (previousStart < 0) break
-    startIndex = previousStart
-  }
-  return startIndex
-}
-
-/** Validate one retry record against the open turn and most recently closed step. */
+/** Validate one retry record against the currently open request step. */
 function validateRetry(
  history: readonly SessionEvent[],
  event: SessionEvent<'llm/retry'>,
@@ -106,49 +78,34 @@ function validateRetry(
    fail(`llm/retry delayMs must be a finite number within 0..${MAX_TIMER_DELAY_MS}`)
  }

-  const currentTurnEvents: SessionEvent[] = []
-  let openTurn: number | undefined
-  for (const prior of history.slice().reverse()) {
-    if (prior.type === 'turn/end') fail('llm/retry must be appended inside an open turn')
-    if (prior.type === 'turn/start') {
-      openTurn = prior.data.turn
-      break
-    }
-    currentTurnEvents.push(prior)
+  const turnBoundary = history.findLast(prior =>
+    prior.type === 'turn/start' || prior.type === 'turn/end')
+  if (turnBoundary?.type !== 'turn/start') {
+    fail('llm/retry must be appended inside an open turn')
  }
-  if (openTurn === undefined) fail('llm/retry must be appended inside an open turn')
-  if (turn !== openTurn) {
-    fail(`llm/retry names turn ${turn}, but the open turn is ${openTurn}`)
+  if (turn !== turnBoundary.data.turn) {
+    fail(`llm/retry names turn ${turn}, but the open turn is ${turnBoundary.data.turn}`)
  }

-  let closedStep: number | undefined
-  for (const prior of currentTurnEvents) {
-    if (prior.type === 'step/start') {
-      fail(`llm/retry must follow step/end, but step ${prior.data.step} is still open`)
-    }
-    if (prior.type === 'step/end') {
-      closedStep = prior.data.step
-      break
-    }
+  const stepBoundary = history.findLast(prior =>
+    prior.type === 'step/start' || prior.type === 'step/end')
+  if (stepBoundary?.type !== 'step/start') {
+    fail('llm/retry must be appended inside an open step')
  }
-  if (closedStep === undefined || step !== closedStep) {
-    fail(`llm/retry names step ${step}, but the latest closed step is ${String(closedStep)}`)
+  if (step !== stepBoundary.data.step || turn !== stepBoundary.data.turn) {
+    fail(`llm/retry names turn ${turn}/step ${step}, but the open step is ${stepBoundary.data.turn}/${stepBoundary.data.step}`)
  }
-  const routedProvider = providerForClosedStep(history, turn, step)
+  const routedProvider = providerForOpenStep(history, turn, step)
  if (routedProvider !== provider) {
    fail(`llm/retry provider ${provider} does not match the failed request provider ${String(routedProvider)}`)
  }

-  const chainStart = retryChainStart(history, turn)
-  const chain = history.slice(Math.max(chainStart, 0))
-  const lastSuccess = chain.findLastIndex(prior => prior.type === 'assistant/message')
-  const chainRetries = chain.slice(lastSuccess + 1)
-    .filter((prior): prior is SessionEvent<'llm/retry'> => prior.type === 'llm/retry')
-  if (chainRetries.some(prior => prior.data.turn === turn && prior.data.step === step)) {
-    fail(`llm/retry duplicates the retry record for turn ${turn}/step ${step}`)
-  }
-  const priorPolicyRetry = chainRetries.findLast(prior =>
-    prior.data.provider === provider && prior.data.policyKey === policyKey)
+  const priorPolicyRetry = history.findLast((prior): prior is SessionEvent<'llm/retry'> =>
+    prior.type === 'llm/retry'
+    && prior.data.turn === turn
+    && prior.data.step === step
+    && prior.data.provider === provider
+    && prior.data.policyKey === policyKey)
  const expectedRetry = (priorPolicyRetry?.data.retry ?? 0) + 1
  if (retry !== expectedRetry) {
    fail(`llm/retry retry ${retry} must equal provider policy retry ${expectedRetry}`)
--- a/packages/llm/llm-retry/tests/invariant.spec.ts
+++ b/packages/llm/llm-retry/tests/invariant.spec.ts
@@ -1,11 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import SessionStore, { SessionId, type Session } from '@deepseek-ai/dsh-session'
-import { createUserMessage, ProviderRequestId , createMessage } from '@deepseek-ai/dsh-llm'
+import { createUserMessage, ProviderRequestId } from '@deepseek-ai/dsh-llm'
 import { MAX_TIMER_DELAY_MS } from '@deepseek-ai/dsh-timeout'
 import InvariantService from '@deepseek-ai/dsh-invariants'
 import * as RetryInvariant from '@deepseek-ai/dsh-llm-retry/invariant'
-import { providerForClosedStep } from '../src/history.ts'
+import { providerForOpenStep } from '../src/history.ts'

 async function setup(): Promise<Context> {
  const ctx = new Context()
@@ -15,26 +15,24 @@ async function setup(): Promise<Context> {
  return ctx
 }

-function closeStep(ctx: Context, id: string, turn = 1, step = 1) {
+function openStep(ctx: Context, id: string, turn = 1, step = 1) {
  const session = ctx.sessions.create(SessionId(id))
-  session.append('turn/start', { turn, trigger: { kind: 'message', source: { kind: 'user' } } })
+  session.append('turn/start', { turn })
  session.append('step/start', { turn, step })
  session.append('request/header', {
    header: { config: { provider: 'mock', model: 'mock' } },
    reason: 'initial',
  })
-  session.append('step/end', { turn, step })
  return session
 }

 function appendRetryTurn(session: Session, turn: number) {
-  session.append('turn/start', { turn, trigger: { kind: 'retry' } })
+  session.append('turn/start', { turn })
  session.append('step/start', { turn, step: 1 })
  session.append('request/header', {
    header: { config: { provider: 'mock', model: 'mock' } },
    reason: 'initial',
  })
-  session.append('step/end', { turn, step: 1 })
  session.append('llm/retry', { turn, step: 1, ...normal })
 }

@@ -58,28 +56,24 @@ const always = {
 }

 describe('llm-retry invariants', () => {
-  it('has no provider without the requested closed step or a route marker', () => {
-    expect(providerForClosedStep([], 1, 1)).toBeUndefined()
-    expect(providerForClosedStep([{
-      type: 'step/end',
+  it('has no provider without the requested open step or a route marker', () => {
+    expect(providerForOpenStep([], 1, 1)).toBeUndefined()
+    expect(providerForOpenStep([{
+      type: 'step/start',
      data: { turn: 1, step: 1 },
    }] as never, 1, 1)).toBeUndefined()
  })

-  it('accepts bounded and unbounded records after successive closed steps', async () => {
+  it('accepts successive bounded and unbounded records inside their open steps', async () => {
    const ctx = await setup()
-    const session = closeStep(ctx, 'retry-invariant-valid')
+    const session = openStep(ctx, 'retry-invariant-valid')

    expect(() => {
      session.append('llm/retry', { turn: 1, step: 1, ...normal })
-      session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
-      session.append('turn/start', { turn: 2, trigger: { kind: 'retry' } })
-      session.append('step/start', { turn: 2, step: 1 })
-      session.append('step/end', { turn: 2, step: 1 })
      session.append('llm/retry', {
-        turn: 2, step: 1, ...normal, retry: 2, delayMs: 0,
+        turn: 1, step: 1, ...normal, retry: 2, delayMs: 0,
      })
-      const unbounded = closeStep(ctx, 'retry-invariant-always')
+      const unbounded = openStep(ctx, 'retry-invariant-always')
      unbounded.append('llm/retry', { turn: 1, step: 1, ...always })
    }).not.toThrow()
    expect(() => { ctx.emit('tools/change') }).not.toThrow()
@@ -87,7 +81,7 @@ describe('llm-retry invariants', () => {

  it('validates the complete durable failure payload', async () => {
    const ctx = await setup()
-    const complete = closeStep(ctx, 'retry-invariant-complete-failure')
+    const complete = openStep(ctx, 'retry-invariant-complete-failure')
    expect(() => {
      complete.append('llm/retry', {
        turn: 1,
@@ -126,7 +120,7 @@ describe('llm-retry invariants', () => {
      ['request-id-empty', { message: 'failed', code: 'RATE_LIMIT', requestId: '' }, /failure\.requestId/],
    ]
    for (const [name, invalidFailure, message] of invalidFailures) {
-      const session = closeStep(ctx, `retry-invariant-failure-${name}`)
+      const session = openStep(ctx, `retry-invariant-failure-${name}`)
      expect(() => {
        session.append('llm/retry', {
          turn: 1, step: 1, ...always, failure: invalidFailure,
@@ -150,95 +144,75 @@ describe('llm-retry invariants', () => {
    ['delay-type', { ...normal, delayMs: '1' }, /delayMs/],
  ])('rejects invalid retry data: %s', async (name, data, message) => {
    const ctx = await setup()
-    const session = closeStep(ctx, `retry-invariant-${name}`)
+    const session = openStep(ctx, `retry-invariant-${name}`)
    expect(() => {
      session.append('llm/retry', { turn: 1, step: 1, ...data } as never)
    }).toThrow(message)
  })

-  it('rejects records outside the latest closed step of an open turn', async () => {
+  it('rejects records outside the currently open turn and step', async () => {
    const ctx = await setup()
    const absent = ctx.sessions.create(SessionId('retry-invariant-no-turn'))
    expect(() => {
      absent.append('llm/retry', { turn: 1, step: 1, ...normal })
    }).toThrow(/inside an open turn/)

-    const wrongTurn = closeStep(ctx, 'retry-invariant-wrong-turn')
+    const wrongTurn = openStep(ctx, 'retry-invariant-wrong-turn')
    expect(() => {
      wrongTurn.append('llm/retry', { turn: 2, step: 1, ...normal })
    }).toThrow(/open turn is 1/)

-    const openStep = ctx.sessions.create(SessionId('retry-invariant-open-step'))
-    openStep.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-    openStep.append('step/start', { turn: 1, step: 1 })
+    const closedStep = openStep(ctx, 'retry-invariant-closed-step')
+    closedStep.append('step/end', { turn: 1, step: 1 })
    expect(() => {
-      openStep.append('llm/retry', { turn: 1, step: 1, ...normal })
-    }).toThrow(/step 1 is still open/)
+      closedStep.append('llm/retry', { turn: 1, step: 1, ...normal })
+    }).toThrow(/inside an open step/)

    const noStep = ctx.sessions.create(SessionId('retry-invariant-no-step'))
-    noStep.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    noStep.append('turn/start', { turn: 1 })
    expect(() => {
      noStep.append('llm/retry', { turn: 1, step: 1, ...normal })
-    }).toThrow(/latest closed step is undefined/)
+    }).toThrow(/inside an open step/)

-    const wrongStep = closeStep(ctx, 'retry-invariant-wrong-step')
+    const wrongStep = openStep(ctx, 'retry-invariant-wrong-step')
    expect(() => {
      wrongStep.append('llm/retry', { turn: 1, step: 2, ...normal })
-    }).toThrow(/latest closed step is 1/)
+    }).toThrow(/open step is 1\/1/)

-    const closedTurn = closeStep(ctx, 'retry-invariant-closed-turn')
-    closedTurn.append('turn/end', { turn: 1, reason: { kind: 'aborted' } })
+    const closedTurn = openStep(ctx, 'retry-invariant-closed-turn')
+    closedTurn.append('step/end', { turn: 1, step: 1 })
+    closedTurn.append('turn/end', { turn: 1, reason: { kind: 'aborted', reason: { kind: 'user' } },
+    })
    expect(() => {
      closedTurn.append('llm/retry', { turn: 1, step: 1, ...normal })
    }).toThrow(/inside an open turn/)
  })

-  it('rejects a second retry record for the same step', async () => {
+  it('accepts successive retries in one step and rejects skipped numbering', async () => {
    const ctx = await setup()
-    const session = closeStep(ctx, 'retry-invariant-duplicate')
+    const session = openStep(ctx, 'retry-invariant-number-sequence')
    session.append('llm/retry', { turn: 1, step: 1, ...normal })
+    session.append('llm/retry', { turn: 1, step: 1, ...normal, retry: 2 })

    expect(() => {
-      session.append('llm/retry', { turn: 1, step: 1, ...normal, retry: 2 })
-    }).toThrow(/duplicates the retry record/)
+      session.append('llm/retry', { turn: 1, step: 1, ...always, retry: 2 })
+    }).toThrow(/must equal provider policy retry 1/)
  })

-  it('binds retry numbering to the provider policy and resets it after success', async () => {
+  it('binds retry numbering to the provider policy and resets it for a new step', async () => {
    const ctx = await setup()
-    const mismatch = closeStep(ctx, 'retry-invariant-numbering')
+    const mismatch = openStep(ctx, 'retry-invariant-numbering')
    mismatch.append('llm/retry', { turn: 1, step: 1, ...normal })
-    mismatch.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
-    mismatch.append('turn/start', { turn: 2, trigger: { kind: 'retry' } })
-    mismatch.append('step/start', { turn: 2, step: 1 })
-    mismatch.append('step/end', { turn: 2, step: 1 })
    expect(() => {
-      mismatch.append('llm/retry', { turn: 2, step: 1, ...normal, retry: 1 })
+      mismatch.append('llm/retry', { turn: 1, step: 1, ...normal, retry: 1 })
    }).toThrow(/must equal provider policy retry 2/)

-    const reset = closeStep(ctx, 'retry-invariant-reset')
+    const reset = openStep(ctx, 'retry-invariant-reset')
    reset.append('llm/retry', { turn: 1, step: 1, ...normal })
-    reset.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
-    reset.append('turn/start', { turn: 2, trigger: { kind: 'retry' } })
-    reset.append('step/start', { turn: 2, step: 1 })
-    reset.append('assistant/message', {
-      turn: 2,
-      step: 1,
-      message: createMessage({
-        role: 'assistant',
-        content: [{ type: 'text', text: 'success' }],
-        source: {
-          kind: 'model',
-          ...{ provider: 'mock', model: 'mock' },
-        },
-      }),
-    }, { surfaceOp: 'append' })
-    reset.append('step/end', { turn: 2, step: 1 })
-    reset.append('turn/end', { turn: 2, reason: { kind: 'completed' } })
-    reset.append('turn/start', { turn: 3, trigger: { kind: 'message', source: { kind: 'user' } } })
-    reset.append('step/start', { turn: 3, step: 1 })
-    reset.append('step/end', { turn: 3, step: 1 })
+    reset.append('step/end', { turn: 1, step: 1 })
+    reset.append('step/start', { turn: 1, step: 2 })
    expect(() => {
-      reset.append('llm/retry', { turn: 3, step: 1, ...normal })
+      reset.append('llm/retry', { turn: 1, step: 2, ...normal })
    }).not.toThrow()
  })

@@ -262,9 +236,7 @@ describe('llm-retry invariants', () => {
    appendRetryTurn(nonFailureEnd, 2)

    const missingStart = ctx.sessions.create(SessionId('retry-invariant-missing-start'))
-    missingStart.append('turn/end', {
-      turn: 1,
-      reason: { kind: 'error', step: 1, failure },
+    missingStart.append('turn/end', { turn: 1, reason: { kind: 'error', error: failure },
    })
    appendRetryTurn(missingStart, 2)

@@ -274,7 +246,7 @@ describe('llm-retry invariants', () => {

  it('rejects a provider that does not match the failed request route', async () => {
    const ctx = await setup()
-    const session = closeStep(ctx, 'retry-invariant-provider')
+    const session = openStep(ctx, 'retry-invariant-provider')
    expect(() => {
      session.append('llm/retry', { turn: 1, step: 1, ...always, provider: 'other' })
    }).toThrow(/does not match the failed request provider mock/)
@@ -284,7 +256,7 @@ describe('llm-retry invariants', () => {
    const ctx = new Context()
    await ctx.plugin(SessionStore)
    const session = ctx.sessions.create(SessionId('retry-invariant-late'))
-    session.append('step/end', { turn: 1, step: 1 })
+    session.append('step/start', { turn: 1, step: 1 })
    session.append('llm/retry', { turn: 1, step: 1, ...normal })
    await ctx.plugin(InvariantService)
    await expect(ctx.plugin(RetryInvariant)).rejects.toThrow(/inside an open turn/)
--- a/packages/llm/llm-retry/tests/persistence.spec.ts
+++ b/packages/llm/llm-retry/tests/persistence.spec.ts
@@ -32,13 +32,12 @@ describe.each(['jsonl', 'sqlite'] as const)('%s retry-event persistence', (kind)
    const ctx = await backend(kind)
    try {
      const session = ctx.sessions.create(SessionId(`retry-${kind}`))
-      session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+      session.append('turn/start', { turn: 1 })
      session.append('step/start', { turn: 1, step: 1 })
      session.append('request/header', {
        header: { config: { provider: 'mock', model: 'mock' } },
        reason: 'initial',
      })
-      session.append('step/end', { turn: 1, step: 1 })
      const event = session.append('llm/retry', {
        turn: 1,
        step: 1,
@@ -49,13 +48,9 @@ describe.each(['jsonl', 'sqlite'] as const)('%s retry-event persistence', (kind)
        delayMs: 750,
        failure: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
      })
-      session.append('turn/end', {
-        turn: 1,
-        reason: {
-          kind: 'error',
-          step: 1,
-          failure: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
-        },
+      session.append('step/end', { turn: 1, step: 1 })
+      session.append('turn/end', { turn: 1, reason: { kind: 'error', error: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
+      },
      })

      expect(session.deriveMessages()).toEqual([])
--- a/packages/llm/llm-retry/tests/retry.spec.ts
+++ b/packages/llm/llm-retry/tests/retry.spec.ts
@@ -149,15 +149,8 @@ function alwaysConfig(backoff: BackoffConfig = {}): AlwaysRetryPolicyConfig {
  }
 }

-function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
-  return new Promise((resolve) => {
-    const dispose = ctx.on('agent/status', (subject, status) => {
-      if (subject === agent && status === 'idle') {
-        dispose()
-        resolve()
-      }
-    })
-  })
+function waitForIdle(_ctx: Context, agent: Agent): Promise<void> {
+  return agent.whenIdle()
 }

 function waitForRetry(ctx: Context, agent: Agent, retryNumber: number): Promise<Extract<SessionEvent, { type: 'llm/retry' }>> {
@@ -180,7 +173,7 @@ afterEach(async () => {
 })

 describe('provider-routed retry policy', () => {
-  it('records the scheduled delay before opening a fresh request attempt', async () => {
+  it('records the scheduled delay before retrying the request', async () => {
    vi.useFakeTimers()
    const adapter = new ScriptedAdapter([
      new LlmError('busy', 'RATE_LIMIT', { status: 429 }),
@@ -219,7 +212,7 @@ describe('provider-routed retry policy', () => {

    expect(adapter.requests).toHaveLength(2)
    expect(agent.session.events.filter(item => item.type === 'step/start').map(item => item.data))
-      .toEqual([{ turn: 1, step: 1 }, { turn: 2, step: 1 }])
+      .toEqual([{ turn: 1, step: 1 }])
    expect(agent.session.deriveMessages().at(-1)).toEqual({
      id: expect.any(String) as unknown,
      role: 'assistant',
@@ -256,7 +249,7 @@ describe('provider-routed retry policy', () => {
    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => ({
      turn: event.data.turn,
      step: event.data.step,
-    }))).toEqual([{ turn: 2, step: 1 }])
+    }))).toEqual([{ turn: 1, step: 1 }])
    expect(agent.session.deriveMessages().at(-1)).toMatchObject({
      role: 'assistant',
      content: [{ type: 'text', text: 'recovered' }],
@@ -289,14 +282,21 @@ describe('provider-routed retry policy', () => {
    await vi.advanceTimersByTimeAsync(500)
    await idle

+    const retryEvent = agent.session.events.find(event => event.type === 'llm/retry')
    const failedChunks = agent.session.events.filter(event =>
-      event.type === 'assistant/chunk' && event.data.turn === 1 && event.data.step === 1,
+      event.type === 'assistant/chunk'
+      && retryEvent !== undefined
+      && event.seq < retryEvent.seq,
    )
-    expect(failedChunks).toHaveLength(6)
-    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => ({
+    expect(failedChunks).toHaveLength(7)
+    const assistantMessages = agent.session.events.filter(event => event.type === 'assistant/message')
+    expect(assistantMessages.map(event => ({
      turn: event.data.turn,
      step: event.data.step,
-    }))).toEqual([{ turn: 2, step: 1 }])
+    }))).toEqual([{ turn: 1, step: 1 }])
+    expect(failedChunks.every(event =>
+      !assistantMessages[0]?.sourceEventSeqs?.includes(event.seq),
+    )).toBe(true)
    expect(agent.session.events.some(event => event.type === 'tool/call')).toBe(false)
    expect(toolExecutions).toBe(0)
    expect(agent.session.deriveMessages().at(-1)).toMatchObject({
@@ -337,7 +337,7 @@ describe('provider-routed retry policy', () => {
    expect(agent.session.events.filter(event => event.type === 'llm/retry')).toHaveLength(2)
    expect(agent.session.events.at(-1)).toMatchObject({
      type: 'turn/end',
-      data: { reason: { kind: 'error', failure: { message: 'busy three', code: 'SERVER' } } },
+      data: { reason: { kind: 'error', error: { message: 'busy three', code: 'SERVER' } } },
    })
  })

@@ -448,10 +448,14 @@ describe('provider-routed retry policy', () => {

    expect(adapter.requests).toHaveLength(0)
    expect(agent.session.events.some(event => event.type === 'llm/retry')).toBe(false)
-    expect(agent.session.events.at(-1)).toMatchObject({
+    const end = agent.session.events.at(-1)
+    expect(end).toMatchObject({
      type: 'turn/end',
-      data: { reason: { kind: 'error', failure: { code: 'NO_ADAPTER' } } },
+      data: { reason: { kind: 'error', error: { code: 'NO_ADAPTER' } } },
    })
+    if (end?.type === 'turn/end' && end.data.reason.kind === 'error') {
+      expect(end.data.reason.error.message).toContain('no adapter registered for provider')
+    }
  })

  it('selects policy by the failed request provider', async () => {
@@ -539,9 +543,9 @@ describe('provider-routed retry policy', () => {
        backoff: { initialDelayMs: 1, maxDelayMs: 1 },
      }),
    }, (ctx) => {
-      ctx.on('agent/request', async (_agent, turn, _step, _signal, next) => ({
+      ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => ({
        ...await next(),
-        provider: turn === 1 ? 'mock' : 'other',
+        provider: adapter.requests.length === 0 ? 'mock' : 'other',
      }))
    }))
    const agent = context.agentLoop.create(SessionId('retry-provider-budgets'), {
@@ -913,9 +917,7 @@ describe('provider-routed retry policy', () => {
    const captured = Promise.withResolvers<undefined>()
    let invokeCaptured: (() => Promise<void>) | undefined
    const mounted = await harness(adapter, {}, (ctx) => {
-      ctx.on('agent/request-error', (
-        _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-      ) => {
+      ctx.on('agent/request-error', (_agent, _context, _signal, next) => {
        return new Promise<RequestErrorAction>((resolve) => {
          invokeCaptured = async () => { resolve(await next()) }
          captured.resolve(undefined)
@@ -924,9 +926,7 @@ describe('provider-routed retry policy', () => {
    })
    context = mounted.ctx
    let downstreamCalls = 0
-    context.on('agent/request-error', async (
-      _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-    ) => {
+    context.on('agent/request-error', async (_agent, _context, _signal, next) => {
      downstreamCalls += 1
      return next()
    })
@@ -980,9 +980,7 @@ describe('provider-routed retry policy', () => {
      textResponse('must not run'),
    ])
    ;({ ctx: context } = await harness(adapter, { mock: policy }, (ctx) => {
-      ctx.on('agent/request-error', async (
-        agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-      ) => {
+      ctx.on('agent/request-error', async (agent, _context, _signal, next) => {
        agent.cancel({ kind: 'user' })
        return next()
      })
--- a/packages/llm/llm-retry/tests/transport-recovery.spec.ts
+++ b/packages/llm/llm-retry/tests/transport-recovery.spec.ts
@@ -55,14 +55,8 @@ async function harness(
  return ctx
 }

-function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
-  return new Promise((resolve) => {
-    const dispose = ctx.on('agent/status', (subject, status) => {
-      if (subject !== agent || status !== 'idle') return
-      dispose()
-      resolve()
-    })
-  })
+function waitForIdle(_ctx: Context, agent: Agent): Promise<void> {
+  return agent.whenIdle()
 }

 function sendAndWait(ctx: Context, agent: Agent): Promise<void> {
@@ -109,15 +103,15 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {
    expect(server?.requests).toHaveLength(1)
    expect(agent.session.events.filter(event => event.type === 'step/start')
      .map(event => [event.data.turn, event.data.step]))
-      .toEqual([[1, 1], [2, 1]])
+      .toEqual([[1, 1]])
    expect(agent.session.events.filter(event => event.type === 'llm/retry').map(event => event.data.failure.code))
      .toEqual(['TRANSPORT'])
    expect(finalAssistantText(agent)).toBe('connected after retry')
  })

  it.each([
-    ['stream_disconnect', 0] as const,
-    ['partial_disconnect', 2] as const,
+    ['stream_disconnect', 1] as const,
+    ['partial_disconnect', 3] as const,
  ])('retries %s without committing failed chunks', async (behavior, failedChunkCount) => {
    const server = await start([behavior, 'success'], {
      apiKey: 'mock-key',
@@ -136,12 +130,15 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {

    expect(server.requests).toHaveLength(2)
    expect(server.requests[0]?.body).toEqual(server.requests[1]?.body)
+    const retryEvent = agent.session.events.find(event => event.type === 'llm/retry')
    expect(agent.session.events.filter(event =>
-      event.type === 'assistant/chunk' && event.data.turn === 1,
+      event.type === 'assistant/chunk'
+      && retryEvent !== undefined
+      && event.seq < retryEvent.seq,
    )).toHaveLength(failedChunkCount)
    expect(agent.session.events.filter(event => event.type === 'assistant/message')
      .map(event => [event.data.turn, event.data.step]))
-      .toEqual([[2, 1]])
+      .toEqual([[1, 1]])
    expect(agent.session.events.filter(event => event.type === 'llm/retry').map(event => event.data.failure.code))
      .toEqual(['TRANSPORT'])
    expect(finalAssistantText(agent)).toBe('recovered response')
@@ -166,7 +163,7 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {
      .toEqual(['EMPTY_RESPONSE'])
    expect(agent.session.events.filter(event => event.type === 'assistant/message')
      .map(event => [event.data.turn, event.data.step]))
-      .toEqual([[2, 1]])
+      .toEqual([[1, 1]])
    expect(agent.session.events.at(-1)).toMatchObject({
      type: 'turn/end',
      data: { reason: { kind: 'completed' } },
@@ -191,12 +188,12 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {
    expect(server.requests).toHaveLength(1)
    expect(agent.session.events.filter(event =>
      event.type === 'assistant/chunk' && event.data.turn === 1,
-    )).toHaveLength(2)
+    )).toHaveLength(3)
    expect(agent.session.events.some(event => event.type === 'assistant/message')).toBe(false)
    expect(agent.session.events.some(event => event.type === 'llm/retry')).toBe(false)
    expect(agent.session.events.at(-1)).toMatchObject({
      type: 'turn/end',
-      data: { reason: { kind: 'error', failure: { code: 'STREAM_CLOSED' } } },
+      data: { reason: { kind: 'error', error: { message: 'SSE stream ended without [DONE]', code: 'STREAM_CLOSED' } } },
    })
  })

@@ -234,11 +231,15 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {
    await sendAndWait(context, agent)

    expect(server.requests).toHaveLength(3)
-    expect(agent.session.events.filter(event => event.type === 'step/start')).toHaveLength(3)
+    expect(agent.session.events.filter(event => event.type === 'step/start')).toHaveLength(1)
    expect(agent.session.events.filter(event => event.type === 'llm/retry')).toHaveLength(2)
-    expect(agent.session.events.at(-1)).toMatchObject({
+    const end = agent.session.events.at(-1)
+    expect(end).toMatchObject({
      type: 'turn/end',
-      data: { reason: { kind: 'error', failure: { code: 'TRANSPORT' } } },
+      data: { reason: { kind: 'error', error: { code: 'TRANSPORT' } } },
    })
+    if (end?.type === 'turn/end' && end.data.reason.kind === 'error') {
+      expect(end.data.reason.error.message).toContain('DeepSeek API request to')
+    }
  })
 })
--- a/packages/llm/llm/README.i18n.yaml
+++ b/packages/llm/llm/README.i18n.yaml
@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/llm/llm/README.md
-README.md: e09ec685ed0ab1e2492749237c277a874eb3b246
-README.zh.md: ca98e875a90eb16e32bc405d77cd5b2b56644180
+README.md: 18c7d14cd8fc11b6afd5ce509d1693c5b787efd5
+README.zh.md: 886d1cead294e997179fd96d7614c6341e6ce115
--- a/packages/llm/llm/README.md
+++ b/packages/llm/llm/README.md
@@ -18,10 +18,10 @@ An adapter registry plus a single streaming call surface, interceptable via a wa
 - `ctx.llm.listModels(provider: string): Promise<LlmModelInfo[]>` Discover the models one registered provider currently advertises.
 - `ctx.llm.resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>` Resolve validated exact-model identity plus available context, output-default, and reasoning metadata from the owning adapter, with optional cancellation for asynchronous adapters.
 - `ctx.llm.resolveCallConfig(config: LlmCallConfig, signal?: AbortSignal): Promise<LlmCallConfig>` Validate an explicit effort and materialize adapter-configured call defaults without clamping.
- `ctx.llm.prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>` Resolve a config plus detached context metadata and adapter-default provenance in one exact-model lookup, then capture its current adapter registration as one cancellable, one-shot call.
+- `ctx.llm.prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>` Resolve a config plus detached context metadata and adapter-default provenance in one exact-model lookup, then capture its current adapter registration and immutable retry policy as one cancellable, one-shot call.
 - `ctx.llm.stream(options: GenerateOptions): AsyncIterable<StreamChunk>` Stream one model call as raw chunks (token-level deltas). Consumers assemble the chunks into blocks/messages with `BlockAssembler`.

-`LlmService` preserves errors from final adapter selection, synchronous dispatch, iterator construction, and iteration, and binds their provenance to the exact stream handle returned for that model call. `isLlmAdapterFailure(stream, value)` reports only errors from that call's final adapter boundary; `llmFailureOf(stream, value)` returns the adjacent immutable `LlmFailure`; `llmRetryPolicyOf(stream)` returns the immutable policy of the exact registration selected at that boundary, even if the route is later disposed or replaced. A call that never reaches a final adapter has no serving policy. Nested model calls, `llm/stream` middleware, and downstream consumer failures remain unclassified for the outer call. Classification never replaces or mutates the adapter's original coded `Error`.
+`LlmService` normalizes failures from final adapter selection, synchronous dispatch, iterator construction, and iteration into the stream protocol's single terminal form: `finish { kind: 'error' | 'aborted', failure }`. A failure after partial deltas may leave content blocks open; consumers discard that incomplete output. Errors from `llm/stream` middleware, nested calls, adapter cleanup, and downstream consumers remain thrown because they are plugin or consumer failures rather than model-request outcomes. A prepared call exposes the immutable retry policy captured with its exact adapter registration; a route handled entirely by middleware has no serving policy.

 Provider and model metadata is a discovery surface, not a routing whitelist. `registerAdapter()` still owns provider exclusivity and captures the adapter's retry policy for each route, while an adapter may accept model ids absent from `listModels()`; consumers must not reject a request because its model is unlisted. Returned selector metadata is detached and invalid or duplicate adapter entries fail with `INVALID_ADAPTER` or `INVALID_CATALOG`.

@@ -48,7 +48,7 @@ Exact-model metadata is a separate correctness query, not a catalog decoration o

 Message content is an array of typed blocks: `text`, `reasoning`, `tool-call`, `tool-result`. The union is derived from the merge-extensible `ContentBlockMap`, so plugins can add block types via declaration merging. Assistant messages use a model source carrying provider/model provenance and optional adapter-private replay state. Before dispatch, `LlmService` retains that state only when the historical provider route and target provider route are currently owned by the exact same adapter instance; the adapter then decides whether it can restore or convert the state across models/providers. The core block set is limited to blocks every shipping path honors — multimodal content (images, audio, …) has no core block type; a feature that needs one adds it via the map together with the adapter/UI/compaction support that honors it.

-Streaming is a raw chunk protocol (`block-start`, `text-delta`, `reasoning-delta`, `tool-call-delta`, `block-end`, `usage`, `finish`). `BlockAssembler` is the single shared implementation that assembles chunks into blocks/messages.
+Streaming is a raw chunk protocol (`block-start`, `text-delta`, `reasoning-delta`, `tool-call-delta`, `block-end`, `usage`, `finish`). Every adapter outcome reaches consumers as one terminal `finish`; operational failure uses its `error` or `aborted` reason rather than throwing across the stream API. `BlockAssembler` is the single shared implementation that assembles chunks into blocks/messages.

 ### Call configuration (`call-config.ts`)

@@ -71,7 +71,7 @@ Every product adapter sends application identity on provider HTTP requests. `att

 ### Real adapters

-Two adapters implement `LlmAdapter` on different internals: [`@deepseek-ai/dsh-llm-deepseek`](../llm-deepseek) uses direct fetch with `eventsource-parser` SSE framing for the `deepseek-official` route, while [`@deepseek-ai/dsh-llm-pi-ai`](../llm-pi-ai) dynamically resolves configured provider/model pairs through `@earendil-works/pi-ai`. Both follow the `StreamChunk` conventions in `types.ts`: usage precedes finish, tool arguments remain raw strings, and errors take one of two sanctioned paths. See [the twin LLM adapters](../../../.agents/notes/implemented/architecture/2026-06-13-twin-llm-adapters.md) for the design rationale.
+Two adapters implement `LlmAdapter` on different internals: [`@deepseek-ai/dsh-llm-deepseek`](../llm-deepseek) uses direct fetch with `eventsource-parser` SSE framing for the `deepseek-official` route, while [`@deepseek-ai/dsh-llm-pi-ai`](../llm-pi-ai) dynamically resolves configured provider/model pairs through `@earendil-works/pi-ai`. Both follow the `StreamChunk` conventions in `types.ts`: usage precedes finish and tool arguments remain raw strings. Adapter implementations may throw or emit a failure finish internally; `LlmService` exposes both as a terminal failure finish. See [the twin LLM adapters](../../../.agents/notes/implemented/architecture/2026-06-13-twin-llm-adapters.md) for the adapter rationale and [the terminal-failure decision](../../../.agents/notes/implemented/architecture/2026-07-29-terminal-llm-stream-failures.md) for the service boundary.

 ## Model Experience

--- a/packages/llm/llm/README.zh.md
+++ b/packages/llm/llm/README.zh.md
@@ -18,10 +18,10 @@
 - `ctx.llm.listModels(provider: string): Promise<LlmModelInfo[]>` 发现某个已注册提供方当前公布的模型。
 - `ctx.llm.resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>` 从拥有精确路由的适配器解析经校验的确切模型身份，以及可用上下文、输出默认值和推理（reasoning）元数据；异步适配器可选地支持取消。
 - `ctx.llm.resolveCallConfig(config: LlmCallConfig, signal?: AbortSignal): Promise<LlmCallConfig>` 校验显式推理强度，并填入适配器配置的调用默认值，但不自动调整。
- `ctx.llm.prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>` 在一次精确模型查询中解析配置、脱耦的上下文元数据与适配器默认值溯源，再将其当前适配器注册捕获为一次可取消、一次性调用。
+- `ctx.llm.prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>` 在一次精确模型查询中解析配置、脱耦的上下文元数据与适配器默认值溯源，再将当前适配器注册和不可变重试策略捕获为一次可取消、一次性调用。
 - `ctx.llm.stream(options: GenerateOptions): AsyncIterable<StreamChunk>` 将一次模型调用流式输出为原始分片（token 级增量）。消费方使用 `BlockAssembler` 将分片组装为块／消息。

-`LlmService` 保留来自最终适配器选择、同步 dispatch、iterator 构造与迭代的错误，并将其溯源绑定到该次模型调用返回的精确流句柄。`isLlmAdapterFailure(stream, value)` 只报告该调用最终适配器边界的错误；`llmFailureOf(stream, value)` 返回关联的不可变 `LlmFailure`；`llmRetryPolicyOf(stream)` 返回在该边界选中的确切注册所对应的不可变策略，即使之后释放或替换路由也不变。未到达最终适配器的调用没有服务策略。嵌套模型调用、`llm/stream` middleware 和下游消费方失败对外层调用仍未分类。分类绝不替换或更改适配器原有的带代码 `Error`。
+`LlmService` 将最终适配器选择、同步 dispatch、iterator 构造与迭代中的失败规范化为流协议唯一的终止形式：`finish { kind: 'error' | 'aborted', failure }`。部分增量输出后发生失败时，内容块可能仍未闭合；消费方会丢弃这些不完整输出。`llm/stream` middleware、嵌套调用、适配器清理和下游消费方的错误仍会抛出，因为它们属于插件或消费方失败，而非模型请求结果。已准备调用会暴露随其确切适配器注册一同捕获的不可变重试策略；完全由 middleware 处理的路由没有服务策略。

 提供方与模型元数据是发现接口，不是路由白名单。`registerAdapter()` 仍拥有提供方排他性，并为每条路由捕获适配器的重试策略；适配器则可以接受 `listModels()` 中不存在的模型 id，消费方禁止因模型未列出而拒绝请求。返回的 selector 元数据与输入脱离，无效或重复适配器配置项会以 `INVALID_ADAPTER` 或 `INVALID_CATALOG` 失败。

@@ -48,7 +48,7 @@

 消息内容是类型化内容块数组：`text`、`reasoning`、`tool-call`、`tool-result`。联合从可合并扩展的 `ContentBlockMap` 派生，因此插件可以通过 declaration merging 添加块类型。assistant 消息使用模型来源，其中携带提供方／模型溯源与可选适配器私有回放状态。dispatch 前，`LlmService` 只在历史提供方路由与目标提供方路由当前由完全相同的适配器实例拥有时才保留该状态；随后由适配器判定能否在模型／提供方间恢复或转换该状态。核心块集只包含每条已发布路径都支持的块。多模态内容（图像、音频等）没有核心块类型；需要它的功能会通过 map 添加，并一并添加相应的适配器／UI／压缩（compaction）支持。

-流式输出是原始分片协议（`block-start`、`text-delta`、`reasoning-delta`、`tool-call-delta`、`block-end`、`usage`、`finish`）。`BlockAssembler` 是将分片组装为块／消息的唯一共享实现。
+流式输出是原始分片协议（`block-start`、`text-delta`、`reasoning-delta`、`tool-call-delta`、`block-end`、`usage`、`finish`）。每个适配器结果都以一个终止 `finish` 到达消费方；运行故障使用其 `error` 或 `aborted` 原因，而不会跨流 API 抛出。`BlockAssembler` 是将分片组装为块／消息的唯一共享实现。

 ### 调用配置（`call-config.ts`）

@@ -71,7 +71,7 @@

 ### 真实适配器

-两个适配器使用不同内部机制实现 `LlmAdapter`：[`@deepseek-ai/dsh-llm-deepseek`](../llm-deepseek) 针对 `deepseek-official` 路由使用直接 fetch 加 `eventsource-parser` SSE（Server-Sent Events）分帧，[`@deepseek-ai/dsh-llm-pi-ai`](../llm-pi-ai) 则通过 `@earendil-works/pi-ai` 动态解析已配置提供方／模型对。两者都遵循 `StreamChunk` 约定，定义见 `types.ts`：usage 先于 finish，工具参数保持原始字符串，错误使用两种已批准路径之一。设计理由见 [双 LLM 适配器](../../../.agents/notes/implemented/architecture/2026-06-13-twin-llm-adapters.md)。
+两个适配器使用不同内部机制实现 `LlmAdapter`：[`@deepseek-ai/dsh-llm-deepseek`](../llm-deepseek) 针对 `deepseek-official` 路由使用直接 fetch 加 `eventsource-parser` SSE（Server-Sent Events）分帧，[`@deepseek-ai/dsh-llm-pi-ai`](../llm-pi-ai) 则通过 `@earendil-works/pi-ai` 动态解析已配置提供方／模型对。两者都遵循 `types.ts` 中的 `StreamChunk` 约定：usage 先于 finish，工具参数保持原始字符串。适配器实现在内部可以抛出异常或发出失败 finish；`LlmService` 会将两者都暴露为终止失败 finish。适配器理由见[双 LLM 适配器](../../../.agents/notes/implemented/architecture/2026-06-13-twin-llm-adapters.md)，服务边界见[终止失败决策](../../../.agents/notes/implemented/architecture/2026-07-29-terminal-llm-stream-failures.md)。

 ## 模型体验

--- a/packages/llm/llm/src/adapter-failure.ts
+++ b/packages/llm/llm/src/adapter-failure.ts
@@ -1,67 +1,40 @@
 /**
- * Private provider-failure tagging shared by `LlmService` and its consumers.
+ * Normalization for values thrown by a final LLM adapter boundary.
 *
 * @module @deepseek-ai/dsh-llm/adapter-failure
 */

 import { HarnessError } from './error.ts'
-import type { LlmFailure, StreamChunk } from './types.ts'
-import type { ResolvedRetryPolicy } from './retry-policy.ts'
-
-/** Call-local facts captured when one model call enters its final adapter boundary. */
-export interface AdapterFailureScope {
-  /** Errors and normalized facts proven to originate in this call's final adapter boundary. */
-  readonly failures: WeakMap<Error, LlmFailure>
-  /** Immutable policy of the exact adapter registration selected for this call. */
-  retryPolicy?: ResolvedRetryPolicy
-}
-
-/** Call-local failure scopes keyed by the exact stream handle returned to a consumer. */
-const adapterFailureScopes = new WeakMap<AsyncIterable<StreamChunk>, AdapterFailureScope>()
+import type { LlmFailure } from './types.ts'

 /**
- * Bind one call's adapter-failure scope to a unique returned stream handle.
- * @param stream - the waterfall-selected stream for this call.
- * @param failures - errors tagged by this call's final adapter boundary.
- * @returns a unique stream handle that delegates iteration to `stream`.
+ * Detach serializable provider facts from a value thrown by an adapter.
+ * @param value - arbitrary value thrown during adapter dispatch or iteration.
+ * @returns immutable provider-neutral facts suitable for a terminal finish chunk.
 * @internal
 */
-export function bindAdapterFailureScope(
-  stream: AsyncIterable<StreamChunk>,
-  failures: AdapterFailureScope,
-): AsyncIterable<StreamChunk> {
-  const call = {
-    [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-      return stream[Symbol.asyncIterator]()
-    },
-  }
-  adapterFailureScopes.set(call, failures)
-  return call
-}
-
-/**
- * Preserve an adapter's Error identity while tagging its provider origin.
- * @param failures - the call-local final-adapter failure scope.
- * @param value - arbitrary value thrown by adapter dispatch or iteration.
- * @returns the original Error, or a coded Error wrapping a non-Error throw.
- * @internal
- */
-export function markLlmAdapterFailure(
-  failures: AdapterFailureScope,
-  value: unknown,
-): Error & { code?: string } {
+export function normalizeLlmFailure(value: unknown): LlmFailure {
  const error = value instanceof Error
-    ? value as Error & { code?: string }
-    : new HarnessError(String(value), 'UNKNOWN', { cause: value })
+    ? value
+    : new HarnessError(thrownMessage(value), 'UNKNOWN', { cause: value })
  // Cross-package copies preserve own data but not class identity. Trust the
  // carried facts only when both own properties agree after validation.
  const carried = ownFailureSnapshot(error)
-  const failure = carried !== undefined && carried.code === ownErrorCode(error) ? carried : Object.freeze({
+  if (carried !== undefined && carried.code === ownErrorCode(error)) return carried
+  return Object.freeze({
    message: errorMessage(error),
    code: harnessErrorCode(error),
  })
-  failures.failures.set(error, failure)
-  return error
+}
+
+/** Render a non-Error throw without letting hostile coercion escape normalization. */
+function thrownMessage(value: unknown): string {
+  try {
+    const message = String(value)
+    return message.length > 0 ? message : 'LLM adapter failed'
+  } catch (_hostileThrownValue) {
+    return 'LLM adapter failed'
+  }
 }

 /** Read a foreign error's own data-backed `code` without invoking accessors. */
@@ -129,46 +102,3 @@ function errorMessage(error: Error): string {
 function harnessErrorCode(error: Error): string {
  return error instanceof HarnessError ? error.code : 'UNKNOWN'
 }
-
-/**
- * Whether a failure came from final adapter dispatch, iterator construction,
- * or iteration for the call represented by the exact returned stream handle.
- * @param stream - the exact stream returned by the model call being classified.
- * @param value - arbitrary failure caught by a model-call consumer.
- * @returns true only for errors tagged at that call's final adapter boundary.
- */
-export function isLlmAdapterFailure(
-  stream: AsyncIterable<StreamChunk>,
-  value: unknown,
-): value is Error & { code?: string } {
-  const failures = adapterFailureScopes.get(stream)
-  return value instanceof Error && failures !== undefined && failures.failures.has(value)
-}
-
-/**
- * Retrieve normalized provider facts only for an Error tagged by this exact
- * model call's final adapter boundary.
- * @param stream - the exact stream returned to the consumer.
- * @param value - the caught failure.
- * @returns the immutable facts for that call, or `undefined` for middleware, nested, or consumer failures.
- */
-export function llmFailureOf(
-  stream: AsyncIterable<StreamChunk>,
-  value: unknown,
-): LlmFailure | undefined {
-  const failures = adapterFailureScopes.get(stream)
-  return value instanceof Error ? failures?.failures.get(value) : undefined
-}
-
-/**
- * Read the retry policy of the exact registration selected at this call's
- * final adapter boundary. The policy remains available after that registration
- * is disposed or replaced; absence means no final adapter served the call.
- * @param stream - the exact stream returned by the model call.
- * @returns the immutable serving-registration policy, or `undefined`.
- */
-export function llmRetryPolicyOf(
-  stream: AsyncIterable<StreamChunk>,
-): ResolvedRetryPolicy | undefined {
-  return adapterFailureScopes.get(stream)?.retryPolicy
-}
--- a/packages/llm/llm/src/assembler.ts
+++ b/packages/llm/llm/src/assembler.ts
@@ -127,11 +127,15 @@ export class BlockAssembler {

  /**
   * Assemble all blocks seen so far, in stream order.
-   * @returns one block per seen index; an open block assembles from its
-   *   accumulated deltas (an unknown block type never closed by `block-end` throws).
+   * @returns one block per seen index, except that max-token truncation drops
+   *   tool calls that cannot be executed safely; an open block assembles from
+   *   its accumulated deltas (an unknown block type never closed by `block-end` throws).
   */
  blocks(): ContentBlock[] {
-    return this.order.map(index => this.assemble(this.mustGet(index), index))
+    const blocks = this.order.map(index => this.assemble(this.mustGet(index), index))
+    return this.finish.kind === 'max-tokens'
+      ? blocks.filter(block => block.type !== 'tool-call')
+      : blocks
  }

  /** Usage from the `usage` chunk; undefined until one arrives. */
--- a/packages/llm/llm/src/error.ts
+++ b/packages/llm/llm/src/error.ts
@@ -93,7 +93,8 @@ export function isQuotaExceededError(detail: string): boolean {
 /**
 * Render a thrown value with its full `cause` chain and AggregateError
 * members, so transport wrappers like undici's `TypeError: fetch failed`
- * surface the underlying failure instead of masking it. Diagnostic-surface
+ * surface the underlying failure instead of masking it. Plain structured
+ * failures render their own data-backed `message`. Diagnostic-surface
 * rendering only (messages, notices, logs) — never parse the result; route on
 * {@link HarnessError.code}.
 * @param value - the caught value (`unknown` in catch clauses).
@@ -109,7 +110,15 @@ export function errorChain(value: unknown): string {
    if (path.has(current)) return '<circular cause>'
    path.add(current)
    try {
-      if (!(current instanceof Error)) return String(current)
+      if (!(current instanceof Error)) {
+        if (typeof current === 'object' && current !== null) {
+          const descriptor = Object.getOwnPropertyDescriptor(current, 'message')
+          if (descriptor !== undefined && 'value' in descriptor && typeof descriptor.value === 'string') {
+            return descriptor.value
+          }
+        }
+        return String(current)
+      }
      const message = current.message === '' ? current.name : current.message
      const members = current instanceof AggregateError && current.errors.length > 0
        ? ` [${current.errors.map(render).join('; ')}]`
--- a/packages/llm/llm/src/index.ts
+++ b/packages/llm/llm/src/index.ts
@@ -24,8 +24,7 @@ import type { ProviderRequestId } from './brand.ts'
 import { callConfigEquals, deepFreeze } from './call-config.ts'
 import type { LlmCallConfig, LlmCallConfigAdapterDefaults } from './call-config.ts'
 import { HarnessError } from './error.ts'
-import { bindAdapterFailureScope, markLlmAdapterFailure } from './adapter-failure.ts'
-import type { AdapterFailureScope } from './adapter-failure.ts'
+import { normalizeLlmFailure } from './adapter-failure.ts'

 export * from './attribution.ts'
 export * from './brand.ts'
@@ -37,7 +36,6 @@ export * from './retry-policy.ts'
 export { BlockAssembler } from './assembler.ts'
 export { callConfigEquals, deepFreeze, isAgentLoopRequest, markAgentLoopRequest } from './call-config.ts'
 export type { LlmCallConfig, LlmCallConfigAdapterDefaults } from './call-config.ts'
-export { isLlmAdapterFailure, llmFailureOf, llmRetryPolicyOf } from './adapter-failure.ts'

 declare module 'cordis' {
  interface Context {
@@ -126,6 +124,8 @@ export class LlmError extends HarnessError {
 export interface PreparedLlmCall {
  /** Detached, deep-frozen config with any adapter-owned default materialized. */
  readonly config: LlmCallConfig
+  /** Immutable retry policy captured with the adapter registration. */
+  readonly retryPolicy: ResolvedRetryPolicy
  /** Detached context metadata resolved with the registration-bound call. */
  readonly context?: LlmModelContext
  /** Config fields materialized by the captured adapter rather than proposed by the caller. */
@@ -681,12 +681,19 @@ export class LlmService extends Service {
    let dispatched = false
    return Object.freeze({
      config: resolvedConfig,
+      retryPolicy: registration.retryPolicy,
      adapterDefaults,
      ...context === undefined ? {} : { context },
      stream: (options: GenerateOptions): AsyncIterable<StreamChunk> => {
        if (dispatched) {
          throw new LlmError('a prepared LLM call can only be dispatched once', 'INVALID_PREPARED_CALL')
        }
+        if (!callConfigEquals(options, resolvedConfig)) {
+          throw new LlmError(
+            'prepared LLM call config changed before adapter dispatch',
+            'INVALID_PREPARED_CALL',
+          )
+        }
        dispatched = true
        return this.streamWithRegistration(options, { registration, config: resolvedConfig })
      },
@@ -716,22 +723,17 @@ export class LlmService extends Service {
  }

  /**
-   * Final adapter boundary. It tags only failures from adapter selection,
-   * synchronous dispatch, iterator construction, or iteration while preserving
-   * the original Error object. Middleware outside this generator remains
-   * distinguishable as plugin work. An iteration failure skips adapter cleanup
-   * so it cannot suppress the primary provider error. A downstream close awaits
-   * adapter cleanup, whose failures remain ordinary untagged work.
+   * Final adapter boundary. Adapter selection, dispatch, iterator construction,
+   * and iteration failures become one terminal failure chunk. Middleware and
+   * downstream consumer failures remain thrown plugin or consumer errors.
   */
  private async * adapterStream(
    options: GenerateOptions,
-    failures: AdapterFailureScope,
    prepared?: { registration: AdapterRegistration; config: LlmCallConfig },
  ): AsyncGenerator<StreamChunk> {
    let iterator: AsyncIterator<StreamChunk>
    try {
      const registration = prepared?.registration ?? this.registration(options.provider)
-      failures.retryPolicy = registration.retryPolicy
      const resolvedConfig = prepared === undefined
        ? (await this.resolveCallFor(registration, options, options.signal)).config
        : prepared.config
@@ -750,32 +752,34 @@ export class LlmService extends Service {
      const stream = adapter.stream(this.forAdapter(resolvedOptions, adapter))
      iterator = stream[Symbol.asyncIterator]()
    } catch (error: unknown) {
-      throw markLlmAdapterFailure(failures, error)
+      yield adapterFailureChunk(error, options.signal)
+      return
    }

    let completed = false
-    let iterationFailed = false
    try {
      while (true) {
-        let value: StreamChunk
+        let item: { done: true } | { done: false; value: StreamChunk }
        try {
-          const item = await iterator.next()
-          if (item.done) {
-            completed = true
-            return
-          }
-          value = item.value
+          const next = await iterator.next()
+          item = next.done
+            ? { done: true }
+            : { done: false, value: next.value }
        } catch (error: unknown) {
-          iterationFailed = true
-          throw markLlmAdapterFailure(failures, error)
+          completed = true
+          yield adapterFailureChunk(error, options.signal)
+          return
+        }
+        if (item.done) {
+          completed = true
+          return
        }
        // End the adapter-owned try before yielding: consumer/middleware
-        // failures resumed into this generator must remain untagged.
-        yield value
+        // failures resumed into this generator must remain thrown.
+        yield item.value
      }
    } finally {
-      // oxlint-disable-next-line typescript/no-unnecessary-condition -- the iteration catch sets its latch before entering finally.
-      if (!completed && !iterationFailed) {
+      if (!completed) {
        const close = iterator.return?.bind(iterator)
        if (close) await close()
      }
@@ -783,15 +787,13 @@ export class LlmService extends Service {
  }

  /**
-   * Stream one model call as raw chunks (token-level deltas). Throws
-   * `LlmError` with code `NO_ADAPTER` if no adapter is registered for
-   * `options.provider`. Replay state is retained only when the same adapter
-   * instance owns its historical provider and the target provider. Final
-   * adapter selection remains fixed through asynchronous exact-model resolution
-   * and dispatch. Selection, dispatch, and iteration failures retain their
-   * original Error identity and are tagged in a call-local scope for narrow
-   * agent-loop request recovery; middleware and nested-call failures remain
-   * untagged for the outer call.
+   * Stream one model call as raw chunks (token-level deltas). Replay state is
+   * retained only when the same adapter instance owns its historical provider
+   * and the target provider. Final adapter selection remains fixed through
+   * asynchronous exact-model resolution and dispatch. Adapter selection,
+   * dispatch, and iteration failures become terminal `error` or `aborted`
+   * finish chunks; middleware, nested-call, cleanup, and consumer failures
+   * remain thrown.
   * @param options - the full request; `options.provider` selects the adapter.
   * @returns the chunk stream, possibly wrapped by `llm/stream` listeners.
   */
@@ -803,14 +805,23 @@ export class LlmService extends Service {
    options: GenerateOptions,
    prepared?: { registration: AdapterRegistration; config: LlmCallConfig },
  ): AsyncIterable<StreamChunk> {
-    const failures: AdapterFailureScope = { failures: new WeakMap<Error, LlmFailure>() }
-    const stream = this.ctx.waterfall(
+    return this.ctx.waterfall(
      this,
      'llm/stream',
      options,
-      () => this.adapterStream(options, failures, prepared),
+      () => this.adapterStream(options, prepared),
    )
-    return bindAdapterFailureScope(stream, failures)
+  }
+}
+
+/** Convert one adapter throw into the stream protocol's terminal outcome. */
+function adapterFailureChunk(error: unknown, signal?: AbortSignal): StreamChunk {
+  const failure = normalizeLlmFailure(error)
+  return {
+    type: 'finish',
+    reason: signal?.aborted || failure.code === 'ABORTED'
+      ? { kind: 'aborted', failure }
+      : { kind: 'error', failure },
  }
 }

--- a/packages/llm/llm/src/invariant.ts
+++ b/packages/llm/llm/src/invariant.ts
@@ -72,7 +72,9 @@ async function* validateStream(
        usageSeen = true
        break
      case 'finish':
-        if (open.size > 0) fail(`LLM stream finished with ${open.size} open block(s)`)
+        if (open.size > 0 && chunk.reason.kind !== 'error' && chunk.reason.kind !== 'aborted') {
+          fail(`LLM stream finished with ${open.size} open block(s)`)
+        }
        finished = true
        break
    }
--- a/packages/llm/llm/src/types.ts
+++ b/packages/llm/llm/src/types.ts
@@ -192,8 +192,9 @@ export interface LlmResolvedModelInfo extends LlmModelInfo {
 * Raw streaming protocol emitted by adapters.
 * Block indexes correlate interleaved deltas, and `block-end` carries the
 * assembled block. Adapters emit usage before the terminal finish and nothing
- * afterward; tool arguments remain raw JSON strings. Failures either throw or
- * end with `error`/`aborted`, and consumers must handle both paths.
+ * afterward; tool arguments remain raw JSON strings. An adapter implementation
+ * may throw, but `LlmService.stream()` normalizes that failure to a terminal
+ * `error` or `aborted` finish before exposing it to consumers.
 */
 export type StreamChunk =
  | { type: 'block-start'; index: number; blockType: ContentBlockType }
--- a/packages/llm/llm/tests/adapter-failure.spec.ts
+++ b/packages/llm/llm/tests/adapter-failure.spec.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+import { normalizeLlmFailure } from '../src/adapter-failure.ts'
+
+describe('adapter failure normalization', () => {
+  it('contains hostile non-Error coercion', () => {
+    const thrown = { [Symbol.toPrimitive]: () => { throw new Error('coercion failed') } }
+    expect(normalizeLlmFailure(thrown)).toEqual({ message: 'LLM adapter failed', code: 'UNKNOWN' })
+  })
+
+  it('normalizes empty primitive throws and data descriptors without values', () => {
+    expect(normalizeLlmFailure('')).toEqual({ message: 'LLM adapter failed', code: 'UNKNOWN' })
+    expect(normalizeLlmFailure(null)).toEqual({ message: 'null', code: 'UNKNOWN' })
+
+    const error = new Error('provider failed')
+    Object.defineProperty(error, 'failure', { get: () => ({ message: 'ignored', code: 'IGNORED' }) })
+    Object.defineProperty(error, 'code', { get: () => 'IGNORED' })
+    expect(normalizeLlmFailure(error)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+
+    const accessorCode = Object.assign(new Error('provider failed'), {
+      failure: { message: 'provider failed', code: 'FOREIGN' },
+    })
+    Object.defineProperty(accessorCode, 'code', { get: () => 'FOREIGN' })
+    expect(normalizeLlmFailure(accessorCode)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+
+    const primitiveFailure = Object.assign(new Error('provider failed'), {
+      failure: null,
+      code: 'FOREIGN',
+    })
+    expect(normalizeLlmFailure(primitiveFailure)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+  })
+
+  it('contains hostile Error property reflection', () => {
+    const withFailure = new Error('provider failed') as Error & { failure: unknown; code: string }
+    withFailure.failure = { message: 'provider failed', code: 'FOREIGN' }
+    withFailure.code = 'FOREIGN'
+    const hostileCode = new Proxy(withFailure, {
+      getOwnPropertyDescriptor(target, property) {
+        if (property === 'code') throw new Error('code descriptor failed')
+        return Reflect.getOwnPropertyDescriptor(target, property)
+      },
+    })
+    expect(normalizeLlmFailure(hostileCode)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+
+    const hostileFailure = new Proxy(new Error('provider failed'), {
+      getOwnPropertyDescriptor() { throw new Error('failure descriptor failed') },
+    })
+    expect(normalizeLlmFailure(hostileFailure)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+  })
+
+  it('rejects malformed or accessor-backed failure snapshots', () => {
+    const malformed = new Error('provider failed') as Error & { failure: unknown; code: string }
+    malformed.failure = { message: 'provider failed', code: 'FOREIGN', requestId: '' }
+    malformed.code = 'FOREIGN'
+    expect(normalizeLlmFailure(malformed)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+
+    const accessorBacked = new Error('provider failed') as Error & { failure: unknown }
+    accessorBacked.failure = Object.defineProperty({}, 'message', {
+      get() { throw new Error('failure getter failed') },
+    })
+    expect(normalizeLlmFailure(accessorBacked)).toEqual({ message: 'provider failed', code: 'UNKNOWN' })
+  })
+
+  it('falls back when an Error message accessor throws', () => {
+    const error = new Error('provider failed')
+    Object.defineProperty(error, 'message', { get() { throw new Error('message getter failed') } })
+    expect(normalizeLlmFailure(error)).toEqual({ message: 'LLM adapter failed', code: 'UNKNOWN' })
+  })
+})
--- a/packages/llm/llm/tests/service.spec.ts
+++ b/packages/llm/llm/tests/service.spec.ts
@@ -6,11 +6,8 @@ import LlmService, {
  HarnessError,
  isContextWindowExceededError,
  isQuotaExceededError,
-  isLlmAdapterFailure,
  LlmAdapter,
  LlmError,
-  llmFailureOf,
-  llmRetryPolicyOf,
  ProviderRequestId,
  ReasoningEffortId,
  resolveRetryPolicy,
@@ -95,6 +92,12 @@ const SCRIPT: StreamChunk[] = [
  { type: 'finish', reason: { kind: 'stop' } },
 ]

+async function collect(stream: AsyncIterable<StreamChunk>): Promise<StreamChunk[]> {
+  const chunks: StreamChunk[] = []
+  for await (const chunk of stream) chunks.push(chunk)
+  return chunks
+}
+
 describe('LlmService', () => {
  it('recognizes structured and model-capacity context-window overflow details', () => {
    expect(isContextWindowExceededError('context_length_exceeded maximum context length')).toBe(true)
@@ -142,6 +145,8 @@ describe('LlmService', () => {

  it('errorChain survives non-Error values, hostile coercion, and circular causes', () => {
    expect(errorChain('plain string')).toBe('plain string')
+    expect(errorChain({ message: 'structured provider failure', code: 'SERVER' }))
+      .toBe('structured provider failure')
    expect(errorChain({ toString: () => { throw new Error('hostile') } })).toBe('<unrenderable value>')
    const circular = new Error('outer')
    circular.cause = circular
@@ -219,69 +224,61 @@ describe('LlmService', () => {
    )
  })

-  it('keeps the serving registration policy on an in-flight call after route replacement', async () => {
+  it('keeps a prepared registration and retry policy after route replacement', async () => {
    const oldPolicy = resolveRetryPolicy({ mode: 'always' }, 'old retryPolicy')
    const newPolicy = resolveRetryPolicy({ mode: 'normal', maxRetries: 0 }, 'new retryPolicy')
-    const entered = Promise.withResolvers<undefined>()
-    const release = Promise.withResolvers<undefined>()
-    const failure = new LlmError('old route failed', 'AUTH')
-    const oldAdapter = new class extends LlmAdapter {
+    const oldFailure = new LlmError('old route failed', 'AUTH')
+    const ctx = new Context()
+    await ctx.plugin(LlmService)
+    const disposeOld = ctx.llm.registerAdapter(['route'], new class extends ThrowingAdapter {
      override providerRetryPolicy(): typeof oldPolicy {
        return oldPolicy
      }
+    }(oldFailure))
+    const prepared = await ctx.llm.prepareCall({ provider: 'route', model: 'model' })

-      async * stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        entered.resolve(undefined)
-        await release.promise
-        throw failure
-      }
-    }()
-    const newAdapter = new class extends ScriptedAdapter {
+    disposeOld()
+    ctx.llm.registerAdapter(['route'], new class extends ScriptedAdapter {
      override providerRetryPolicy(): typeof newPolicy {
        return newPolicy
      }
-    }(SCRIPT)
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    const disposeOld = ctx.llm.registerAdapter(['route'], oldAdapter)
-    const stream = ctx.llm.stream({ provider: 'route', model: 'model', messages: [] })
-    const outcome = (async (): Promise<unknown> => {
-      try {
-        for await (const _chunk of stream) { /* drain */ }
-      } catch (error: unknown) {
-        return error
-      }
-      return undefined
-    })()
-    await entered.promise
+    }(SCRIPT))

-    disposeOld()
-    ctx.llm.registerAdapter(['route'], newAdapter)
-    release.resolve(undefined)
-
-    expect(await outcome).toBe(failure)
-    expect(llmRetryPolicyOf(stream)).toBe(oldPolicy)
+    const chunks = await collect(prepared.stream({ ...prepared.config, messages: [] }))
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: 'old route failed', code: 'AUTH' },
+      },
+    })
+    expect(prepared.retryPolicy).toBe(oldPolicy)
    expect(ctx.llm.providerRetryPolicy('route')).toBe(newPolicy)
  })

-  it('throws NO_ADAPTER for unregistered providers', async () => {
+  it('normalizes an unregistered provider to a terminal failure', async () => {
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    const stream = ctx.llm.stream({ provider: 'nope', model: 'any-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _ of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
-    expect(caught).toBeInstanceOf(LlmError)
-    expect((caught as LlmError).code).toBe('NO_ADAPTER')
-    expect((caught as LlmError).message).toContain('no adapter registered')
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-    expect(llmRetryPolicyOf(stream)).toBeUndefined()
+
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'nope',
+      model: 'any-model',
+      messages: [],
+    }))
+
+    const finish = chunks.at(-1)
+    expect(finish).toMatchObject({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { code: 'NO_ADAPTER' },
+      },
+    })
+    if (finish?.type !== 'finish' || finish.reason.kind !== 'error') throw new Error('expected error finish')
+    expect(finish.reason.failure.message).toContain('no adapter registered')
  })

-  it.each(['done', 'value'] as const)('tags a throwing IteratorResult.%s getter without replacing its Error', async (field) => {
+  it.each(['done', 'value'] as const)('normalizes a throwing IteratorResult.%s getter', async (field) => {
    const original = new LlmError(`${field} getter failed`, 'RESULT_GETTER_FAILED')
    const result = field === 'done' ? {} : { done: false }
    Object.defineProperty(result, field, { get: () => { throw original } })
@@ -297,31 +294,30 @@ describe('LlmService', () => {
    })
    const adapter = new class extends LlmAdapter {
      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        return {
-          [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-            return iterator
-          },
-        }
+        return { [Symbol.asyncIterator]: () => iterator }
      }
    }()
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)

-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))

-    expect(caught).toBe(original)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: `${field} getter failed`, code: 'RESULT_GETTER_FAILED' },
+      },
+    })
    expect(cleanupLookups).toBe(0)
  })

-  it.each(['dispatch', 'iterator'] as const)('tags synchronous adapter %s failures without replacing their Error', async (boundary) => {
+  it.each(['dispatch', 'iterator'] as const)('normalizes synchronous adapter %s failures', async (boundary) => {
    const original = new LlmError(`${boundary} failed`, 'BOUNDARY_FAILED')
    const adapter = new class extends LlmAdapter {
      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
@@ -331,339 +327,63 @@ describe('LlmService', () => {
    }()
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)

-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))

-    expect(caught).toBe(original)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-    expect(llmFailureOf(stream, caught)).toEqual({
-      message: `${boundary} failed`,
-      code: 'BOUNDARY_FAILED',
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: `${boundary} failed`, code: 'BOUNDARY_FAILED' },
+      },
    })
  })

-  it('keeps structured provider facts beside a frozen third-party Error', async () => {
-    const original = new LlmError('provider busy', 'RATE_LIMIT', {
+  it('preserves structured LlmError facts in the terminal failure', async () => {
+    const failure = new LlmError('provider busy', 'RATE_LIMIT', {
      status: 429,
      providerRetryAfterMs: 1_500,
      requestId: ProviderRequestId('req-7'),
    })
-    Object.freeze(original)
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
+    ctx.llm.registerAdapter(['test'], new ThrowingAdapter(failure))

-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))

-    expect(caught).toBe(original)
-    expect(llmFailureOf(stream, caught)).toEqual({
-      message: 'provider busy',
-      code: 'RATE_LIMIT',
-      status: 429,
-      providerRetryAfterMs: 1_500,
-      requestId: ProviderRequestId('req-7'),
-    })
-  })
-
-  it('does not trust retry facts carried by an unknown third-party Error', async () => {
-    const carried = { message: 'busy', code: 'SERVER', status: 503 }
-    const original = Object.assign(new Error('busy'), { failure: carried })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    const facts = llmFailureOf(stream, original)
-    carried.status = 500
-
-    expect(facts).toEqual({ message: 'busy', code: 'UNKNOWN' })
-    expect(Object.isFrozen(facts)).toBe(true)
-    expect(facts).not.toBe(carried)
-  })
-
-  it('keeps validated failure facts across package copies with matching own codes', async () => {
-    const original = Object.assign(new Error('provider busy'), {
-      code: 'RATE_LIMIT',
-      failure: {
-        message: 'provider busy',
-        code: 'RATE_LIMIT',
-        status: 429,
-        providerRetryAfterMs: 1_500,
-        requestId: 'req-cross-copy',
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: {
+          message: 'provider busy',
+          code: 'RATE_LIMIT',
+          status: 429,
+          providerRetryAfterMs: 1_500,
+          requestId: ProviderRequestId('req-7'),
+        },
      },
    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({
-      message: 'provider busy',
-      code: 'RATE_LIMIT',
-      status: 429,
-      providerRetryAfterMs: 1_500,
-      requestId: 'req-cross-copy',
-    })
  })

-  it('keeps an unknown SDK Error exact without trusting its private code or accessors', async () => {
-    const original = Object.assign(new Error('socket closed'), { code: 'ECONNRESET' })
-    Object.defineProperty(original, 'failure', {
-      get() { throw new Error('SDK failure accessor must not run') },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-
-    expect(original.code).toBe('ECONNRESET')
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'socket closed', code: 'UNKNOWN' })
-  })
-
-  it('keeps an SDK Error exact when its message accessor is hostile', async () => {
-    const original = Object.defineProperty(new Error(), 'message', {
-      get() { throw new Error('SDK message accessor trap') },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'LLM adapter failed', code: 'UNKNOWN' })
-  })
-
-  it('keeps an SDK Error exact without trusting accessor-backed carried facts', async () => {
-    const original = Object.assign(new Error('busy'), {
-      failure: { message: 'busy', code: 'SERVER', status: 503 },
-    })
-    Object.defineProperty(original, 'code', {
-      get() { throw new Error('SDK code accessor must not escape') },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'busy', code: 'UNKNOWN' })
-  })
-
-  it('does not trust carried facts matched only by an inherited code', async () => {
-    class InheritedCodeError extends Error {
-      get code(): string { return 'SERVER' }
-    }
-    const original = Object.assign(new InheritedCodeError('busy'), {
-      failure: { message: 'busy', code: 'SERVER', status: 503 },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'busy', code: 'UNKNOWN' })
-  })
-
-  it('keeps an SDK Error exact when code descriptor inspection is trapped', async () => {
-    const target = Object.assign(new Error('busy'), {
-      code: 'SERVER',
-      failure: { message: 'busy', code: 'SERVER', status: 503 },
-    })
-    const original = new Proxy(target, {
-      getOwnPropertyDescriptor(value, property) {
-        if (property === 'code') throw new Error('SDK code descriptor trap')
-        return Reflect.getOwnPropertyDescriptor(value, property)
-      },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'busy', code: 'UNKNOWN' })
-  })
-
-  it('falls back safely when SDK objects trap failure inspection or expose malformed facts', async () => {
-    const propertyTrap = new Proxy(new HarnessError('descriptor trapped', 'SERVER'), {
-      getOwnPropertyDescriptor(target, property) {
-        if (property === 'failure') throw new Error('SDK descriptor trap')
-        return Reflect.getOwnPropertyDescriptor(target, property)
-      },
-    })
-    const throwingFacts = Object.create(null) as Record<string, unknown>
-    Object.defineProperty(throwingFacts, 'message', {
-      get() { throw new Error('SDK fact getter trap') },
-    })
-    const carrying = (message: string, failure: unknown): HarnessError => Object.defineProperty(
-      new HarnessError(message, 'SERVER'),
-      'failure',
-      { value: failure },
-    )
-    const factGetter = carrying('fact getter failed', throwingFacts)
-    const malformed = carrying('malformed facts', { message: 'provider busy', code: 'SERVER', requestId: 1 })
-    const primitive = carrying('primitive facts', 1)
-    const nullFacts = carrying('null facts', null)
-    const mismatched = carrying('mismatched facts', { message: 'busy', code: 'RATE_LIMIT' })
-
-    for (const [original, expectedMessage] of [
-      [propertyTrap, 'descriptor trapped'],
-      [factGetter, 'fact getter failed'],
-      [malformed, 'malformed facts'],
-      [primitive, 'primitive facts'],
-      [nullFacts, 'null facts'],
-      [mismatched, 'mismatched facts'],
-    ] as const) {
-      const ctx = new Context()
-      await ctx.plugin(LlmService)
-      ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-      const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-      await expect((async () => {
-        for await (const _chunk of stream) { /* drain */ }
-      })()).rejects.toBe(original)
-      expect(llmFailureOf(stream, original)).toEqual({ message: expectedMessage, code: 'SERVER' })
-    }
-  })
-
-  it('retains a stable code from a HarnessError without requiring LlmError facts', async () => {
-    const original = new HarnessError('stable adapter failure', 'ADAPTER_STABLE')
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({
-      message: 'stable adapter failure',
-      code: 'ADAPTER_STABLE',
-    })
-    expect(llmFailureOf(stream, 'not an Error')).toBeUndefined()
-    expect(llmFailureOf({ [Symbol.asyncIterator]: () => stream[Symbol.asyncIterator]() }, original)).toBeUndefined()
-  })
-
-  it('keeps a nested adapter failure scoped to the nested model call', async () => {
-    const original = new LlmError('nested provider failed', 'NESTED_FAILED')
-    const outer = new RecordingAdapter(SCRIPT)
-    const nested = new ThrowingAdapter(original)
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['outer'], outer)
-    ctx.llm.registerAdapter(['nested'], nested)
-    let nestedStream: AsyncIterable<StreamChunk> | undefined
-    ctx.on('llm/stream', (options, next) => {
-      if (options.provider !== 'outer') return next()
-      return (async function* () {
-        nestedStream = ctx.llm.stream({ provider: 'nested', model: 'nested', messages: [] })
-        yield * nestedStream
-      })()
-    })
-
-    const outerStream = ctx.llm.stream({ provider: 'outer', model: 'outer', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of outerStream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBe(original)
-    expect(nestedStream).toBeDefined()
-    expect(isLlmAdapterFailure(nestedStream!, caught)).toBe(true)
-    expect(isLlmAdapterFailure(outerStream, caught)).toBe(false)
-    expect(outer.lastOptions).toBeUndefined()
-  })
-
-  it('keeps call scopes distinct when middleware reuses an iterable', async () => {
-    const firstFailure = new LlmError('first provider failed', 'FIRST_FAILED')
-    const secondFailure = new LlmError('second provider failed', 'SECOND_FAILED')
-    const delegates: AsyncIterable<StreamChunk>[] = []
-    const shared: AsyncIterable<StreamChunk> = {
-      [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-        const delegate = delegates.shift()
-        if (delegate === undefined) throw new Error('shared stream has no call delegate')
-        return delegate[Symbol.asyncIterator]()
-      },
-    }
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['first'], new ThrowingAdapter(firstFailure))
-    ctx.llm.registerAdapter(['second'], new ThrowingAdapter(secondFailure))
-    ctx.on('llm/stream', (_options, next) => {
-      delegates.push(next())
-      return shared
-    })
-
-    const firstStream = ctx.llm.stream({ provider: 'first', model: 'first', messages: [] })
-    const secondStream = ctx.llm.stream({ provider: 'second', model: 'second', messages: [] })
-    const catchFailure = async (stream: AsyncIterable<StreamChunk>): Promise<unknown> => {
-      try {
-        for await (const _chunk of stream) { /* drain */ }
-      } catch (error: unknown) {
-        return error
-      }
-      return new Error('expected adapter to fail')
-    }
-
-    expect(firstStream).not.toBe(secondStream)
-    const firstCaught = await catchFailure(firstStream)
-    expect(firstCaught).toBe(firstFailure)
-    expect(isLlmAdapterFailure(firstStream, firstCaught)).toBe(true)
-    expect(isLlmAdapterFailure(secondStream, firstCaught)).toBe(false)
-    const secondCaught = await catchFailure(secondStream)
-    expect(secondCaught).toBe(secondFailure)
-    expect(isLlmAdapterFailure(secondStream, secondCaught)).toBe(true)
-    expect(isLlmAdapterFailure(firstStream, secondCaught)).toBe(false)
-    expect(delegates).toHaveLength(0)
-  })
-
-  it('propagates a rejected next promptly without awaiting a non-settling return', async () => {
-    const original = new LlmError('provider failed', 'PROVIDER_FAILED')
-    let cleanupCalls = 0
+  it('normalizes arbitrary adapter rejections without throwing them downstream', async () => {
    const adapter = new class extends LlmAdapter {
      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
        return {
          [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
            return {
-              next: () => Promise.reject(original),
-              return: () => {
-                cleanupCalls += 1
-                return new Promise<IteratorResult<StreamChunk>>(() => {})
-              },
+              // Third-party adapters can reject with arbitrary values.
+              // oxlint-disable-next-line typescript/prefer-promise-reject-errors
+              next: () => Promise.reject('plain provider failure'),
            }
          },
        }
@@ -671,30 +391,73 @@ describe('LlmService', () => {
    }()
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)

-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    const failure = (async (): Promise<unknown> => {
-      try {
-        for await (const _chunk of stream) { /* drain */ }
-      } catch (error: unknown) {
-        return error
-      }
-      return new Error('expected adapter iteration to fail')
-    })()
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const timeout = new Promise<Error>((resolve) => {
-      timer = setTimeout(() => { resolve(new Error('adapter failure did not settle promptly')) }, 100)
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))
+
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: 'plain provider failure', code: 'UNKNOWN' },
+      },
    })
-    const caught = await Promise.race([failure, timeout])
-    if (timer !== undefined) clearTimeout(timer)
-
-    expect(caught).toBe(original)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-    expect(cleanupCalls).toBe(0)
  })

-  it('awaits one adapter return on downstream close and leaves its rejection unclassified', async () => {
+  it('maps adapter failure to aborted when the request signal is aborted', async () => {
+    const controller = new AbortController()
+    controller.abort('cancelled')
+    const ctx = new Context()
+    await ctx.plugin(LlmService)
+    ctx.llm.registerAdapter(['test'], new ThrowingAdapter(new Error('stopped')))
+
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+      signal: controller.signal,
+    }))
+
+    expect(chunks.at(-1)).toMatchObject({
+      type: 'finish',
+      reason: { kind: 'aborted', failure: { message: 'stopped' } },
+    })
+  })
+
+  it('leaves middleware and consumer failures thrown', async () => {
+    const middlewareFailure = new Error('middleware failed')
+    const middlewareCtx = new Context()
+    await middlewareCtx.plugin(LlmService)
+    middlewareCtx.llm.registerAdapter(['test'], new ScriptedAdapter(SCRIPT))
+    middlewareCtx.on('llm/stream', () => (async function* () {
+      throw middlewareFailure
+    })())
+    await expect(collect(middlewareCtx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))).rejects.toBe(middlewareFailure)
+
+    const consumerFailure = new Error('consumer failed')
+    const consumerCtx = new Context()
+    await consumerCtx.plugin(LlmService)
+    consumerCtx.llm.registerAdapter(['test'], new ScriptedAdapter(SCRIPT))
+    await expect((async () => {
+      for await (const _chunk of consumerCtx.llm.stream({
+        provider: 'test',
+        model: 'test',
+        messages: [],
+      })) {
+        throw consumerFailure
+      }
+    })()).rejects.toBe(consumerFailure)
+  })
+
+  it('awaits adapter cleanup on downstream close and leaves cleanup failure thrown', async () => {
    const cleanup = new Error('cleanup failed')
    let cleanupCalls = 0
    const adapter = new class extends LlmAdapter {
@@ -714,22 +477,19 @@ describe('LlmService', () => {
    }()
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)

-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) break
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBe(cleanup)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(false)
+    await expect((async () => {
+      for await (const _chunk of ctx.llm.stream({
+        provider: 'test',
+        model: 'test',
+        messages: [],
+      })) break
+    })()).rejects.toBe(cleanup)
    expect(cleanupCalls).toBe(1)
  })

-  it('allows downstream close when the adapter iterator has no return method', async () => {
+  it('allows downstream close when an adapter iterator has no return method', async () => {
    const adapter = new class extends LlmAdapter {
      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
        return {
@@ -741,66 +501,9 @@ describe('LlmService', () => {
    }()
    const ctx = new Context()
    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)

-    let chunks = 0
-    for await (const _chunk of ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })) {
-      chunks += 1
-      break
-    }
-
-    expect(chunks).toBe(1)
-  })
-
-  it('normalizes and tags non-Error adapter failures once', async () => {
-    const adapter = new class extends LlmAdapter {
-      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        return {
-          [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-            // Third-party adapters can reject with arbitrary values.
-            // oxlint-disable-next-line typescript/prefer-promise-reject-errors
-            return { next: () => Promise.reject('plain provider failure') }
-          },
-        }
-      }
-    }()
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
-
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBeInstanceOf(HarnessError)
-    expect(caught).toMatchObject({ code: 'UNKNOWN', cause: 'plain provider failure' })
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-  })
-
-  it('does not tag a failure thrown downstream while consuming adapter output', async () => {
-    const downstream = new Error('consumer failed')
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], new ScriptedAdapter(SCRIPT))
-
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) throw downstream
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBe(downstream)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(false)
-    expect(isLlmAdapterFailure(new ScriptedAdapter(SCRIPT).stream({
-      provider: 'unbound', model: 'unbound', messages: [],
-    }), caught)).toBe(false)
-    expect(isLlmAdapterFailure(stream, 'consumer failed')).toBe(false)
+    for await (const _chunk of ctx.llm.stream({ provider: 'test', model: 'test', messages: [] })) break
  })

  it('unregisters adapters when the owning fiber is disposed (HMR safety)', async () => {
@@ -1119,19 +822,34 @@ describe('LlmService', () => {
    expect(Object.isFrozen(prepared.config)).toBe(true)
    expect(Object.isFrozen(prepared.adapterDefaults)).toBe(true)
    expect(prepared.adapterDefaults).toEqual({ reasoningEffort: true })
-    const stream = prepared.stream({
+    expect(() => prepared.stream({
      ...prepared.config,
      model: 'other',
      messages: [],
-    })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toMatchObject({ code: 'INVALID_PREPARED_CALL' })
+    })).toThrow(expect.objectContaining({ code: 'INVALID_PREPARED_CALL' }))
+    await collect(prepared.stream({
+      ...prepared.config,
+      messages: [],
+    }))
    expect(() => prepared.stream({
      ...prepared.config,
      messages: [],
    })).toThrow(expect.objectContaining({ code: 'INVALID_PREPARED_CALL' }))
+
+    const late = await ctx.llm.prepareCall({ provider: 'route', model: 'model' })
+    const lateOptions = { ...late.config, messages: [] }
+    const lateStream = late.stream(lateOptions)
+    lateOptions.model = 'other'
+    expect(await collect(lateStream)).toContainEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: {
+          message: 'prepared LLM call config changed before adapter dispatch',
+          code: 'INVALID_PREPARED_CALL',
+        },
+      },
+    })
  })

  it('reuses one exact-model lookup for prepared config and context metadata', async () => {
--- a/packages/llm/token-meter/tests/token-meter.spec.ts
+++ b/packages/llm/token-meter/tests/token-meter.spec.ts
@@ -671,7 +671,7 @@ describe('malformed replay and listener lifecycle', () => {
      type: 'turn/start',
      seq: 0,
      time: 1,
-      data: { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } },
+      data: { turn: 1 },
    }] })
    activeMeter.measure(session)
    session.append('user/message', createUserMessage({