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

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

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
 

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)。
 
 ## 模型体验
 

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
-}

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. */

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('; ')}]`

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 },
   }
 }
 

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
     }

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 }

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' })
+  })
+})

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 () => {