basalt-ui 1.11.0 → 1.13.0

package/src/agent/part-list.test.tsx

@@ -5,11 +5,14 @@
  * `output` field, so the old `part.state === 'output-available'`-only body left a failed call
  * rendering as name+input and nothing else — the failure was silently invisible. Same gap for
  * `output-denied`, indistinguishable from a still-pending call.
+ *
+ * Plus the `settled` flag's forwarding contract — the field that lets a text renderer drop out of
+ * streaming mode once the message it belongs to has finished.
  */
 import { cleanup, render, screen } from '@testing-library/react'
 import { afterEach, describe, expect, test } from 'bun:test'
 import { PartList } from './part-list'
-import type { ToolCallPart } from './parts'
+import type { AgentPart, ToolCallPart } from './parts'
 
 afterEach(cleanup)
 
@@ -80,3 +83,30 @@ describe('DefaultToolCall — terminal states stay visible', () => {
     expect(screen.queryByText(/Denied/)).toBeNull()
   })
 })
+
+describe('settled — forwarded to every renderer', () => {
+  const TEXT: AgentPart = { id: 't1', type: 'text', text: 'hello' }
+
+  function settledProbe() {
+    const seen: boolean[] = []
+    const components = {
+      text: ({ settled }: { settled: boolean }) => {
+        seen.push(settled)
+        return <div data-testid="probe">{String(settled)}</div>
+      },
+    }
+    return { seen, components }
+  }
+
+  test('defaults to true — a caller that knows nothing about a run renders a finished list', () => {
+    const { seen, components } = settledProbe()
+    render(<PartList parts={[TEXT]} components={components} />)
+    expect(seen).toEqual([true])
+  })
+
+  test('an explicit settled={false} reaches the renderer', () => {
+    const { seen, components } = settledProbe()
+    render(<PartList parts={[TEXT]} components={components} settled={false} />)
+    expect(seen).toEqual([false])
+  })
+})

package/src/agent/part-list.tsx

@@ -19,7 +19,9 @@
  * <PartList
  *   parts={parts}
  *   components={{
- *     text: ({ part }) => <Markdown streaming density="chat">{part.text}</Markdown>,
+ *     text: ({ part, settled }) => (
+ *       <Markdown streaming={!settled} contentTrust="untrusted" density="chat">{part.text}</Markdown>
+ *     ),
  *   }}
  * />
  */
@@ -38,37 +40,48 @@ import type {
 
 // ── Per-type renderer signatures ──────────────────────────────────────────────
 
-export type TextPartRenderer<TPart extends AgentPart = AgentPart> = (props: {
-  part: Extract<TPart, { type: 'text' }>
+/**
+ * The per-renderer argument. `settled` is `false` only while the message these parts belong to is
+ * still streaming — it converges this map toward the `PartRenderContext` a foreign renderer
+ * already receives (`./foreign`), rather than adding a third shape. Additive and
+ * source-compatible: an existing `({ part }) => …` renderer simply ignores it.
+ *
+ * Settlement is MONOTONE — a message that has settled never un-settles.
+ */
+type PartRenderArgs<TPart> = {
+  part: TPart
   index: number
-}) => JSX.Element | null
+  settled: boolean
+}
 
-export type ReasoningPartRenderer<TPart extends AgentPart = AgentPart> = (props: {
-  part: Extract<TPart, { type: 'reasoning' }>
-  index: number
-}) => JSX.Element | null
+export type TextPartRenderer<TPart extends AgentPart = AgentPart> = (
+  props: PartRenderArgs<Extract<TPart, { type: 'text' }>>,
+) => JSX.Element | null
 
-export type ToolCallPartRenderer<TPart extends AgentPart = AgentPart> = (props: {
-  part: Extract<TPart, { type: 'tool' }>
-  index: number
-}) => JSX.Element | null
+export type ReasoningPartRenderer<TPart extends AgentPart = AgentPart> = (
+  props: PartRenderArgs<Extract<TPart, { type: 'reasoning' }>>,
+) => JSX.Element | null
 
-export type SourcePartRenderer<TPart extends AgentPart = AgentPart> = (props: {
-  part: Extract<TPart, { type: 'source' }>
-  index: number
-}) => JSX.Element | null
+export type ToolCallPartRenderer<TPart extends AgentPart = AgentPart> = (
+  props: PartRenderArgs<Extract<TPart, { type: 'tool' }>>,
+) => JSX.Element | null
 
-export type ErrorPartRenderer<TPart extends AgentPart = AgentPart> = (props: {
-  part: Extract<TPart, { type: 'error' }>
-  index: number
-}) => JSX.Element | null
+export type SourcePartRenderer<TPart extends AgentPart = AgentPart> = (
+  props: PartRenderArgs<Extract<TPart, { type: 'source' }>>,
+) => JSX.Element | null
+
+export type ErrorPartRenderer<TPart extends AgentPart = AgentPart> = (
+  props: PartRenderArgs<Extract<TPart, { type: 'error' }>>,
+) => JSX.Element | null
 
 /**
  * Partial map of per-type renderers. Any omitted key falls back to the headless default.
  *
  * @example
  * const renderers: Partial<AgentPartRenderers> = {
- *   text: ({ part }) => <Markdown streaming density="chat">{part.text}</Markdown>,
+ *   text: ({ part, settled }) => (
+ *     <Markdown streaming={!settled} contentTrust="untrusted" density="chat">{part.text}</Markdown>
+ *   ),
  * }
  */
 export type AgentPartRenderers<TPart extends AgentPart = AgentPart> = {
@@ -231,10 +244,17 @@ export type PartListProps<TPart extends AgentPart = AgentPart> = {
   readonly parts: TPart[]
   /**
    * Override individual part renderers. Omitted keys fall back to the headless defaults.
-   * Pass `{ text: ({ part }) => <Markdown streaming density="chat">{part.text}</Markdown> }` to
-   * enable rich markdown rendering.
+   * Pass `{ text: ({ part, settled }) => <Markdown streaming={!settled} contentTrust="untrusted" density="chat">{part.text}</Markdown> }`
+   * to enable rich markdown rendering.
    */
   readonly components?: Partial<AgentPartRenderers<TPart>>
+  /**
+   * `false` while the message these parts belong to is still streaming — forwarded to every
+   * renderer so a text renderer can drop out of streaming mode (and a fenced mermaid/diagram can
+   * upgrade) once the turn finishes. Defaults to `true`: a caller that knows nothing about a run
+   * is rendering a finished list, and un-settled must be opted into by the thing that does know.
+   */
+  readonly settled?: boolean
 }
 
 /**
@@ -251,11 +271,19 @@ export type PartListProps<TPart extends AgentPart = AgentPart> = {
  * // With basalt's own Markdown for the text renderer:
  * import { PartList } from 'basalt-ui/agent'
  * import { Markdown } from 'basalt-ui/content'
- * <PartList parts={parts} components={{ text: ({ part }) => <Markdown streaming density="chat">{part.text}</Markdown> }} />
+ * <PartList
+ *   parts={parts}
+ *   components={{
+ *     text: ({ part, settled }) => (
+ *       <Markdown streaming={!settled} contentTrust="untrusted" density="chat">{part.text}</Markdown>
+ *     ),
+ *   }}
+ * />
  */
 export function PartList<TPart extends AgentPart = AgentPart>({
   parts,
   components,
+  settled = true,
 }: PartListProps<TPart>): JSX.Element {
   // Memoised to avoid rebuilding the renderer map on every streaming re-render (hot path).
   // Cast required because DEFAULT_RENDERERS is typed for the base AgentPart, not the generic TPart.
@@ -277,7 +305,11 @@ export function PartList<TPart extends AgentPart = AgentPart>({
             const Render = renderers.text
             return (
               <Fragment key={part.id}>
-                <Render part={part as Extract<TPart, { type: 'text' }>} index={index} />
+                <Render
+                  part={part as Extract<TPart, { type: 'text' }>}
+                  index={index}
+                  settled={settled}
+                />
               </Fragment>
             )
           }
@@ -285,7 +317,11 @@ export function PartList<TPart extends AgentPart = AgentPart>({
             const Render = renderers.reasoning
             return (
               <Fragment key={part.id}>
-                <Render part={part as Extract<TPart, { type: 'reasoning' }>} index={index} />
+                <Render
+                  part={part as Extract<TPart, { type: 'reasoning' }>}
+                  index={index}
+                  settled={settled}
+                />
               </Fragment>
             )
           }
@@ -293,7 +329,11 @@ export function PartList<TPart extends AgentPart = AgentPart>({
             const Render = renderers.tool
             return (
               <Fragment key={part.id}>
-                <Render part={part as Extract<TPart, { type: 'tool' }>} index={index} />
+                <Render
+                  part={part as Extract<TPart, { type: 'tool' }>}
+                  index={index}
+                  settled={settled}
+                />
               </Fragment>
             )
           }
@@ -301,7 +341,11 @@ export function PartList<TPart extends AgentPart = AgentPart>({
             const Render = renderers.source
             return (
               <Fragment key={part.id}>
-                <Render part={part as Extract<TPart, { type: 'source' }>} index={index} />
+                <Render
+                  part={part as Extract<TPart, { type: 'source' }>}
+                  index={index}
+                  settled={settled}
+                />
               </Fragment>
             )
           }
@@ -309,7 +353,11 @@ export function PartList<TPart extends AgentPart = AgentPart>({
             const Render = renderers.error
             return (
               <Fragment key={part.id}>
-                <Render part={part as Extract<TPart, { type: 'error' }>} index={index} />
+                <Render
+                  part={part as Extract<TPart, { type: 'error' }>}
+                  index={index}
+                  settled={settled}
+                />
               </Fragment>
             )
           }

package/src/agent/parts.test.ts

@@ -3,14 +3,16 @@
  * AgentPart wire format, post-1.11.0 part identity + the seven-state ToolCallPart union.
  *
  * Every AgentPart variant below is validated against parts.ts's `parseAgentPart`, `isStartPart`,
- * and `isToolCallSettled` as they read right now: `id` is required on every variant, and `tool`
- * parts are validated against the seven-state discriminated union mirroring AI SDK v7's
+ * and `isToolCallSettled` as they read right now: `id` is required on every variant, `toolCallId`
+ * is required on the three in-flight tool states and optional on the four settled ones (see the
+ * per-state identity block below), and `tool` parts are validated against the seven-state
+ * discriminated union mirroring AI SDK v7's
  * `UIToolInvocation` (see parts.ts's ToolCallPart doc for the ground-truth corrections against the
  * design spec).
  */
 import { describe, expect, test } from 'bun:test'
 import { isStartPart, isToolCallSettled, parseAgentPart } from './parts'
-import type { AgentPart, ToolCallPart } from './parts'
+import type { AgentPart, ToolCallPart, ToolCallState } from './parts'
 
 /** JSON round-trip a value through JSON.stringify → JSON.parse, mirroring wire transport. */
 function roundTrip(value: unknown): unknown {
@@ -109,10 +111,11 @@ describe('parseAgentPart', () => {
   })
 
   describe('tool', () => {
-    test('rejects a missing toolCallId', () => {
+    test('rejects a non-string toolCallId', () => {
       const raw = {
         id: 'p1',
         type: 'tool',
+        toolCallId: 42,
         toolName: 'search',
         state: 'input-available',
         input: {},
@@ -120,6 +123,120 @@ describe('parseAgentPart', () => {
       expect(parseAgentPart(raw)).toBeNull()
     })
 
+    // ── toolCallId identity, decided per state ──────────────────────────────
+    // An empty string is not a value any state accepts: '' normalizes to absent right here, so the
+    // pre-1.12.0 sentinel can never reach the type or a consumer of it. What an ABSENT id then
+    // means is a per-state decision (see Identified / MaybeIdentified in parts.ts):
+    //   in-flight  (input-streaming, input-available, approval-requested) → REJECTED. The part
+    //     exists only to be closed by a later state, which re-supplies its toolName and input;
+    //     unidentified it could never be closed and would render as a forever-pending chip.
+    //   settled    (approval-responded + the three terminal states)       → KEPT, unidentified.
+    //     It carries the OUTCOME; dropping it would erase how the call ended (silent data loss),
+    //     while keeping it costs only the fold — coalesceParts renders it as its own block.
+    //
+    // The `satisfies Record<ToolCallState, …>` below is an authoring-time exhaustiveness gate: add
+    // a state to the union and this fixture stops typechecking until its identity behaviour is
+    // decided here too. It is an EDITOR/tsc guard only — the package tsconfig excludes `*.test.ts`
+    // from `bun run typecheck`, and `bun test` type-strips rather than typechecks — so the
+    // "covers every state exactly once" test below backs it with a runtime check of the same claim.
+
+    const UNIDENTIFIED_RAW = {
+      'input-streaming': { toolName: 'search', state: 'input-streaming' },
+      'input-available': { toolName: 'search', state: 'input-available', input: { q: 'x' } },
+      'approval-requested': {
+        toolName: 'search',
+        state: 'approval-requested',
+        input: { q: 'x' },
+        approval: { id: 'appr-1' },
+      },
+      'approval-responded': {
+        toolName: 'search',
+        state: 'approval-responded',
+        input: { q: 'x' },
+        approval: { id: 'appr-1', approved: true },
+      },
+      'output-available': {
+        toolName: 'search',
+        state: 'output-available',
+        input: { q: 'x' },
+        output: { hits: 3 },
+      },
+      'output-error': { toolName: 'search', state: 'output-error', errorText: 'boom' },
+      'output-denied': {
+        toolName: 'search',
+        state: 'output-denied',
+        input: { q: 'x' },
+        approval: { id: 'appr-1', approved: false },
+      },
+    } satisfies Record<ToolCallState, Record<string, unknown>>
+
+    const IN_FLIGHT_STATES = [
+      'input-streaming',
+      'input-available',
+      'approval-requested',
+    ] as const satisfies readonly ToolCallState[]
+
+    const SETTLED_STATES = [
+      'approval-responded',
+      'output-available',
+      'output-error',
+      'output-denied',
+    ] as const satisfies readonly ToolCallState[]
+
+    test('the in-flight/settled split covers every tool state exactly once', () => {
+      // Object.keys() is always typed string[] regardless of the object's key type — cast back to
+      // ToolCallState[], which every key of UNIDENTIFIED_RAW genuinely is (used as
+      // UNIDENTIFIED_RAW[state] elsewhere in this file).
+      expect([...IN_FLIGHT_STATES, ...SETTLED_STATES].toSorted()).toEqual(
+        (Object.keys(UNIDENTIFIED_RAW) as ToolCallState[]).toSorted(),
+      )
+    })
+
+    for (const state of IN_FLIGHT_STATES) {
+      test(`${state}: rejects a missing toolCallId — an in-flight part that could never be closed`, () => {
+        expect(parseAgentPart({ id: 'p1', type: 'tool', ...UNIDENTIFIED_RAW[state] })).toBeNull()
+      })
+
+      test(`${state}: rejects an empty-string toolCallId identically (it means absent)`, () => {
+        const raw = { id: 'p1', type: 'tool', toolCallId: '', ...UNIDENTIFIED_RAW[state] }
+        expect(parseAgentPart(raw)).toBeNull()
+      })
+    }
+
+    for (const state of SETTLED_STATES) {
+      test(`${state}: a missing toolCallId keeps the part UNIDENTIFIED — it is never dropped`, () => {
+        const parsed = parseAgentPart({ id: 'p1', type: 'tool', ...UNIDENTIFIED_RAW[state] })
+        expect(parsed).not.toBeNull()
+        expect((parsed as ToolCallPart).state).toBe(state)
+        expect(Object.hasOwn(parsed as object, 'toolCallId')).toBe(false)
+      })
+
+      test(`${state}: an empty-string toolCallId normalizes to absent, never to ""`, () => {
+        const raw = { id: 'p1', type: 'tool', toolCallId: '', ...UNIDENTIFIED_RAW[state] }
+        const parsed = parseAgentPart(raw)
+        expect(parsed).not.toBeNull()
+        expect(Object.hasOwn(parsed as object, 'toolCallId')).toBe(false)
+      })
+
+      test(`${state}: a real toolCallId still carries through`, () => {
+        const raw = { id: 'p1', type: 'tool', toolCallId: 'call-1', ...UNIDENTIFIED_RAW[state] }
+        expect((parseAgentPart(raw) as ToolCallPart | null)?.toolCallId).toBe('call-1')
+      })
+    }
+
+    test('approval-responded: a real toolCallId round-trips through JSON', () => {
+      const part: ToolCallPart = {
+        id: 'p1',
+        type: 'tool',
+        toolCallId: 'call-1',
+        toolName: 'delete_file',
+        state: 'approval-responded',
+        input: { path: '/tmp/x' },
+        approval: { id: 'appr-1', approved: true },
+      }
+      expect(parseAgentPart(roundTrip(part))).toEqual(part)
+    })
+
     test('rejects a missing toolName', () => {
       const raw = {
         id: 'p1',

package/src/agent/parts.ts

@@ -3,7 +3,10 @@
  *
  * Exhaustiveness is enforced at every switch via assertNever (imported from '../register').
  * Adding a new variant without a matching case is a tsc error — see the fixture in
- * apps/playground/src/demo/agent-part.type-guard.ts.
+ * apps/playground/src/demo/agent-part.type-guard.ts. One caveat for code that folds WIRE data on
+ * the render path (`coalesceParts`): keep the compile-time guarantee — bind the value at `never` —
+ * but do NOT let the runtime throw, or one malformed chunk kills the whole transcript. See
+ * `mergeToolPart`'s default branch for that shape.
  *
  * Eden #231 doctrine: the server-side Elysia route MUST declare `: AsyncGenerator<AgentPart>`
  * explicitly and carry NO t.Object/t.Union response schema. Validate at yield-time. See
@@ -78,6 +81,10 @@ export type ReasoningPart = PartBase & {
 // discriminator `tool-${NAME}`. It IS a required field here (ours, not the SDK's) because the chip
 // needs it; a transport mapping from the SDK must DERIVE it from the discriminator, not read it off
 // the invocation.
+//
+// `toolCallId` is required on the three IN-FLIGHT states and OPTIONAL on the four SETTLED ones —
+// see `Identified` / `MaybeIdentified` below. The absence is modelled in the type, never as a
+// sentinel value.
 
 /** The nested approval envelope — mirrors the SDK's shape verbatim, never flattened. */
 type ToolApproval = {
@@ -90,35 +97,66 @@ type ToolApproval = {
 
 type ToolCallBase = PartBase & {
   readonly type: 'tool'
-  /** Required on all seven states (was optional — see parts.ts history). */
-  readonly toolCallId: string
   readonly toolName: string
   /** Wall-clock time from first sighting of this toolCallId to its terminal state. */
   readonly durationMs?: number
   readonly providerExecuted?: boolean
 }
 
+/**
+ * The three IN-FLIGHT states (`input-streaming`, `input-available`, `approval-requested`) carry an
+ * authoritative `toolCallId` — the merge key, and for them it is structural. An in-flight part
+ * exists only to be superseded by the settled part for the same call; with no merge key it can
+ * never be closed, so it would render as a forever-pending chip standing beside the real result.
+ * Nothing is lost by rejecting an unidentified one either: the `toolName` and `input` it carries
+ * are re-supplied on the settled part. `parseToolCallPart` therefore rejects these when the id is
+ * missing or empty.
+ */
+type Identified = ToolCallBase & { readonly toolCallId: string }
+
+/**
+ * The four SETTLED states (`approval-responded` plus the three terminal ones) may legitimately
+ * arrive without a `toolCallId`, for two different reasons.
+ *
+ * `approval-responded` is where the WIRE omits it: the SDK's `tool-approval-response` chunk
+ * carries none, and it is resolved by reverse lookup on `approval.id` (coalesce.ts keeps the
+ * approvalId -> toolCallId side index that does it).
+ *
+ * The three terminal states admit the absence for a different reason — tolerance, not wire shape.
+ * They are self-contained: each carries the OUTCOME of the call, so a missing id costs only the
+ * fold (`coalesceParts` keeps an unresolvable part as its own block and never discards it).
+ * Rejecting one instead would delete the only record of how the call ended — silent data loss in a
+ * transcript, strictly worse than an unfolded block.
+ *
+ * The absence is modelled here rather than smuggled through an empty-string sentinel: the union
+ * previously declared an always-meaningful `string` that the `approval-responded` wire shape
+ * cannot supply, which forced a `''` sentinel into the type and an `as unknown as` cast into every
+ * test that built one. A `''` toolCallId is not a value any state accepts; `parseToolCallPart`
+ * normalizes one to absent at the wire boundary, so it never reaches the type or a consumer.
+ */
+type MaybeIdentified = ToolCallBase & { readonly toolCallId?: string }
+
 export type ToolCallPart =
-  | (ToolCallBase & { readonly state: 'input-streaming'; readonly input?: unknown })
-  | (ToolCallBase & { readonly state: 'input-available'; readonly input: unknown })
-  | (ToolCallBase & {
+  | (Identified & { readonly state: 'input-streaming'; readonly input?: unknown })
+  | (Identified & { readonly state: 'input-available'; readonly input: unknown })
+  | (Identified & {
       readonly state: 'approval-requested'
       readonly input: unknown
       readonly approval: ToolApproval & { readonly approved?: never; readonly reason?: never }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'approval-responded'
       readonly input: unknown
       readonly approval: ToolApproval & { readonly approved: boolean }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'output-available'
       readonly input: unknown
       readonly output: unknown
       readonly preliminary?: boolean
       readonly approval?: ToolApproval & { readonly approved?: true }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'output-error'
       readonly input?: unknown
       /** The SDK's field name — there is no field named `error` anywhere in the union. */
@@ -127,7 +165,7 @@ export type ToolCallPart =
       readonly rawInput?: unknown
       readonly approval?: ToolApproval & { readonly approved?: true }
     })
-  | (ToolCallBase & {
+  | (MaybeIdentified & {
       readonly state: 'output-denied'
       readonly input: unknown
       readonly approval: ToolApproval & { readonly approved: false }
@@ -236,35 +274,53 @@ export function parseAgentPart(raw: unknown): AgentPart | null {
 }
 
 /** Validates the state-discriminated `tool` part shape. Rejects the pre-1.11.0 flat shape
- * (`{type:'tool', output}` with no `state`) and any unrecognized `state` value. */
+ * (`{type:'tool', output}` with no `state`) and any unrecognized `state` value.
+ *
+ * An empty-string `toolCallId` is normalized to absent here — the one place the wire's degenerate
+ * shape is decoded — so `''` never reaches the type or any consumer of it. What an ABSENT id then
+ * means is decided per state, exactly as the union declares it (`Identified` /
+ * `MaybeIdentified`): fatal on the three in-flight states, which exist only to be closed by a
+ * later one and are re-supplied by it; survivable on the four settled states, which carry the
+ * outcome and are kept UNIDENTIFIED rather than dropped. Dropping a settled part would be silent
+ * data loss — the transcript would simply forget how the call ended. */
 function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPart | null {
-  if (typeof obj['toolCallId'] !== 'string') return null
   if (typeof obj['toolName'] !== 'string') return null
   if (typeof obj['state'] !== 'string') return null
 
-  const { toolCallId, toolName } = obj as { toolCallId: string; toolName: string }
+  const rawToolCallId = obj['toolCallId']
+  if (rawToolCallId !== undefined && typeof rawToolCallId !== 'string') return null
+  const toolCallId =
+    typeof rawToolCallId === 'string' && rawToolCallId.length > 0 ? rawToolCallId : undefined
+
+  const toolName = obj['toolName']
   const common = {
     id,
     type: 'tool' as const,
-    toolCallId,
     toolName,
     ...(typeof obj['durationMs'] === 'number' ? { durationMs: obj['durationMs'] } : {}),
     ...(typeof obj['providerExecuted'] === 'boolean'
       ? { providerExecuted: obj['providerExecuted'] }
       : {}),
   }
+  // The three in-flight states below require an identified call; the four settled ones spread
+  // `identity` instead, which is simply empty when the wire supplied no usable id.
+  const identified = toolCallId !== undefined ? { ...common, toolCallId } : null
+  const identity = toolCallId !== undefined ? { toolCallId } : {}
 
   switch (obj['state']) {
     case 'input-streaming':
+      if (identified === null) return null
       return {
-        ...common,
+        ...identified,
         state: 'input-streaming',
         ...('input' in obj ? { input: obj['input'] } : {}),
       }
     case 'input-available':
+      if (identified === null) return null
       if (!('input' in obj)) return null
-      return { ...common, state: 'input-available', input: obj['input'] }
+      return { ...identified, state: 'input-available', input: obj['input'] }
     case 'approval-requested': {
+      if (identified === null) return null
       if (!('input' in obj)) return null
       const approval = parseApproval(obj['approval'])
       // The type declares this state's approval as `{ approved?: never; reason?: never }` — a
@@ -274,7 +330,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
         return null
       }
       return {
-        ...common,
+        ...identified,
         state: 'approval-requested',
         input: obj['input'],
         approval: approval as ToolApproval & { approved?: never; reason?: never },
@@ -284,8 +340,10 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       if (!('input' in obj)) return null
       const approval = parseApproval(obj['approval'])
       if (approval === null || typeof approval.approved !== 'boolean') return null
+      // The state the WIRE ships unidentified — `approval.id` is then its only addressing key.
       return {
         ...common,
+        ...identity,
         state: 'approval-responded',
         input: obj['input'],
         approval: approval as ToolApproval & { approved: boolean },
@@ -297,6 +355,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       if (approval === null || approval.approved !== false) return null
       return {
         ...common,
+        ...identity,
         state: 'output-denied',
         input: obj['input'],
         approval: approval as ToolApproval & { approved: false },
@@ -315,6 +374,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       }
       return {
         ...common,
+        ...identity,
         state: 'output-available',
         input: obj['input'],
         output: obj['output'],
@@ -332,6 +392,7 @@ function parseToolCallPart(id: string, obj: Record<string, unknown>): ToolCallPa
       }
       return {
         ...common,
+        ...identity,
         state: 'output-error',
         errorText: obj['errorText'],
         ...('input' in obj ? { input: obj['input'] } : {}),