@tanstack/ai-client 0.28.0 → 0.29.1

package/src/chat-client.ts

@@ -26,6 +26,7 @@ import {
 } from './connection-adapters'
 import { ChatPersistor } from './client-persistor'
 import { ClearedStreamTracker } from './cleared-stream-tracker'
+import { normalizeMessagesDates } from './message-date-normalizer'
 import { InterruptManager } from './interrupt-manager'
 import type {
   AnyClientTool,
@@ -163,6 +164,20 @@ function resolveTransport(transport: {
   throw new Error('ChatClient: either `connection` or `fetcher` is required.')
 }
 
+function connectionDrainsOnSend(connection: ConnectionAdapter): boolean {
+  return 'connect' in connection
+}
+
+function isIntermediateToolTurn(chunk: StreamChunk): boolean {
+  if (chunk.type !== 'RUN_FINISHED') return false
+  if (chunk.outcome?.type === 'interrupt') return false
+  const extra = chunk as StreamChunk & { finishReason?: unknown }
+  if (extra.finishReason !== undefined) {
+    return extra.finishReason === 'tool_calls'
+  }
+  return tanstackMetadata(chunk)?.finishReason === 'tool_calls'
+}
+
 export interface NormalizedQueueConfig {
   whenBusy: WhenBusy
   drain: 'fifo' | 'batch'
@@ -415,8 +430,19 @@ export class ChatClient<
   private continuationPending = false
   private subscriptionAbortController: AbortController | null = null
   private processingResolve: (() => void) | null = null
+  /**
+   * `connect()` adapters push the full HTTP body into the subscribe queue, then
+   * wait until that queue is idle. After `send()` returns, every chunk from this
+   * request has been processed. Subscribe/send sockets do not drain that way.
+   */
+  private connectionDrainsOnSend = false
   private errorReportedGeneration: number | null = null
   private streamGeneration = 0
+  private continuationGeneration = 0
+  // Generation of the run that opened the current stream. Public
+  // `addToolResult` must use this, not the live counter: `stop()` increments
+  // the live counter, so a post-stop call would otherwise look current.
+  private streamContinuationGeneration = 0
   // Tracks whether a queued checkForContinuation was skipped because
   // continuationPending was true (chained approval scenario)
   private continuationSkipped = false
@@ -512,7 +538,9 @@ export class ChatClient<
     this.byokProvider = options.byokProvider
     this.context = options.context
     this.queueConfig = normalizeQueueOption(options.queue)
-    this.connection = normalizeConnectionAdapter(resolveTransport(options))
+    const transport = resolveTransport(options)
+    this.connectionDrainsOnSend = connectionDrainsOnSend(transport)
+    this.connection = normalizeConnectionAdapter(transport)
 
     // Build client tools map
     this.clientToolsRef = { current: new Map() }
@@ -737,6 +765,7 @@ export class ChatClient<
           const clientTool = clientTools.get(args.toolName)
           const executeFunc = clientTool?.execute
           if (executeFunc) {
+            const continuationGeneration = this.continuationGeneration
             // Capture the run context at execution-start so a tool whose
             // result lands AFTER the originating run finishes still reports
             // back against the originating run, not whatever run is
@@ -763,6 +792,7 @@ export class ChatClient<
                     state: 'output-available',
                   },
                   clientTool,
+                  continuationGeneration,
                   runEventContext,
                 )
               } catch (error: any) {
@@ -775,6 +805,7 @@ export class ChatClient<
                     errorText: error.message,
                   },
                   clientTool,
+                  continuationGeneration,
                   runEventContext,
                 )
               } finally {
@@ -820,6 +851,9 @@ export class ChatClient<
           if (eventType === 'memory:state') {
             this.devtoolsBridge.recordMemoryState(data)
           }
+          if (eventType === 'skills:state') {
+            this.devtoolsBridge.recordSkillsState(data)
+          }
           this.callbacksRef.current.onCustomEvent(eventType, data, context)
         },
       },
@@ -1017,7 +1051,7 @@ export class ChatClient<
       // A send may have started while the fetch was in flight — don't stomp it.
       if (this.isLoading || this.abortController) return
       if (result.messages.length > 0) {
-        this.processor.setMessages(result.messages)
+        this.processor.setMessages(normalizeMessagesDates(result.messages))
       }
       if (result.interrupts && result.interrupts.pending.length > 0) {
         // Pending interrupt = the thread is paused awaiting a human decision, so
@@ -1131,7 +1165,9 @@ export class ChatClient<
       this.clearedStreamTracker.onSessionRunError()
     }
     this.setSessionGenerating(this.activeRunIds.size > 0)
-    if (options?.resolveProcessing !== false) {
+    const skipProcessingResolve =
+      chunk.type === 'RUN_FINISHED' && isIntermediateToolTurn(chunk)
+    if (options?.resolveProcessing !== false && !skipProcessingResolve) {
       this.resolveProcessing()
     }
   }
@@ -1304,6 +1340,21 @@ export class ChatClient<
   ): Promise<boolean> {
     const target = state ?? this.lastResume
     if (!target) return Promise.resolve(false)
+    return this.resumeInterruptsUnsafeForGeneration(
+      resume,
+      target,
+      this.continuationGeneration,
+    )
+  }
+
+  private resumeInterruptsUnsafeForGeneration(
+    resume: Array<RunAgentResumeItem>,
+    target: ChatResumeState,
+    continuationGeneration: number,
+  ): Promise<boolean> {
+    if (continuationGeneration !== this.continuationGeneration) {
+      return Promise.resolve(false)
+    }
     // Auto-executed client tools resolve during the parent stream's
     // `pendingToolExecutions` wait — while `isLoading` is still true.
     // Defer the child continuation until that stream settles so we do not
@@ -1312,7 +1363,13 @@ export class ChatClient<
       return new Promise<boolean>((resolve, reject) => {
         this.queuePostStreamAction(async () => {
           try {
-            resolve(await this.resumeInterruptsUnsafe(resume, target))
+            resolve(
+              await this.resumeInterruptsUnsafeForGeneration(
+                resume,
+                target,
+                continuationGeneration,
+              ),
+            )
           } catch (error) {
             reject(error)
           }
@@ -1336,6 +1393,7 @@ export class ChatClient<
   private async submitInterruptBatch(
     submission: InterruptManagerSubmission,
   ): Promise<void> {
+    const continuationGeneration = this.continuationGeneration
     this.activeInterruptSubmission = submission
     this.interruptSubmissionFailure = undefined
     // Reflect approval decisions in the local message tree immediately so a
@@ -1347,15 +1405,21 @@ export class ChatClient<
       const approvalId = resolution.interruptId
       this.processor.addToolApprovalResponse(approvalId, approved)
     }
-    const resumed = await this.resumeInterruptsUnsafe(
+    const resumed = await this.resumeInterruptsUnsafeForGeneration(
       [...submission.resolutions],
       {
         threadId: submission.threadId,
         runId: submission.interruptedRunId,
       },
+      continuationGeneration,
     ).finally(() => {
-      this.activeInterruptSubmission = undefined
+      // Only clear if this resume still owns the client: `stop()` may have
+      // invalidated it while the submission was settling.
+      if (this.activeInterruptSubmission === submission) {
+        this.activeInterruptSubmission = undefined
+      }
     })
+    if (continuationGeneration !== this.continuationGeneration) return
     const failure = this.takeInterruptSubmissionFailure()
     if (failure !== undefined) {
       throw { errors: failure.errors }
@@ -1678,6 +1742,7 @@ export class ChatClient<
     // persisted pointer with the provider id — so a SECOND reload would
     // `joinRun` an id the log isn't keyed by and never re-attach.
     this.lastResume = { threadId: this.threadId, runId }
+    this.streamContinuationGeneration = this.continuationGeneration
     this.setIsLoading(true)
     this.setStatus('streaming')
     void (async () => {
@@ -2163,6 +2228,7 @@ export class ChatClient<
 
     // Track generation so a superseded stream's cleanup doesn't clobber the new one
     const generation = ++this.streamGeneration
+    this.streamContinuationGeneration = this.continuationGeneration
     // Native interrupt continuation is a fresh child run. The interrupted run
     // is carried as parentRunId and the complete resolution batch as resume.
     const resumeThreadId = this.pendingResumeThreadId
@@ -2305,6 +2371,14 @@ export class ChatClient<
         return false
       }
 
+      // connect() send() already waited until the subscribe queue was idle.
+      // Kick the processing wait so a stream that ends on tool_calls (no
+      // interrupt / stop) cannot hang. Subscribe/send sockets still wait for
+      // a request-ending terminal below.
+      if (this.connectionDrainsOnSend) {
+        this.resolveProcessing()
+      }
+
       // Wait for subscription loop to finish processing all chunks
       await processingComplete
 
@@ -2506,9 +2580,14 @@ export class ChatClient<
    * Stop the current stream
    */
   stop(): void {
+    // Invalidate deferred work from the stopped continuation.
+    this.continuationGeneration++
     const hadLocalStream = this.abortController !== null
     this.cancelInFlightStream({ setReadyStatus: true })
     this.discardPendingSends()
+    this.lastResume = null
+    this.activeInterruptSubmission = undefined
+    this.interruptManager.reset()
     if (hadLocalStream) {
       this.resetSessionGenerating()
     }
@@ -2552,12 +2631,17 @@ export class ChatClient<
    */
   async addToolResult(result: ClientToolResult): Promise<void> {
     const clientTool = this.clientToolsRef.current.get(result.tool)
-    await this.addToolResultForClientTool(result, clientTool)
+    await this.addToolResultForClientTool(
+      result,
+      clientTool,
+      this.streamContinuationGeneration,
+    )
   }
 
   private async addToolResultForClientTool(
     result: ClientToolResult,
     clientTool: AnyClientTool | undefined,
+    continuationGeneration: number,
     context?: ChatClientRunEventContext,
   ): Promise<void> {
     if (clientTool && result.state !== 'output-error') {
@@ -2584,6 +2668,8 @@ export class ChatClient<
       context,
     )
 
+    if (continuationGeneration !== this.continuationGeneration) return
+
     // Always update local message state so the tool-call part is terminal in
     // the UI even when the AG-UI interrupt path owns server continuation.
     this.processor.addToolResult(
@@ -2609,7 +2695,11 @@ export class ChatClient<
 
     // If stream is in progress, queue continuation check for after it ends
     if (this.isLoading) {
-      this.queuePostStreamAction(() => this.checkForContinuation())
+      this.queuePostStreamAction(() =>
+        continuationGeneration === this.continuationGeneration
+          ? this.checkForContinuation()
+          : Promise.resolve(),
+      )
       return
     }
 
@@ -2689,7 +2779,11 @@ export class ChatClient<
    * Queue an action to be executed after the current stream ends
    */
   private queuePostStreamAction(action: () => Promise<void>): void {
-    this.postStreamActions.push(action)
+    const continuationGeneration = this.continuationGeneration
+    this.postStreamActions.push(async () => {
+      if (continuationGeneration !== this.continuationGeneration) return
+      await action()
+    })
   }
 
   /**
@@ -2712,6 +2806,10 @@ export class ChatClient<
    * Check if we should continue the flow and do so if needed
    */
   private async checkForContinuation(): Promise<void> {
+    // stop() bumps continuationGeneration without opening a new stream.
+    if (this.streamContinuationGeneration !== this.continuationGeneration) {
+      return
+    }
     if (this.hasPendingInterrupts()) return
 
     // Prevent duplicate continuation attempts
@@ -2982,12 +3080,12 @@ export class ChatClient<
       this.resetSessionGenerating()
       this.setIsSubscribed(false)
       this.setConnectionStatus('disconnected')
-      this.connection = normalizeConnectionAdapter(
-        resolveTransport({
-          connection: options.connection,
-          fetcher: options.fetcher,
-        }),
-      )
+      const transport = resolveTransport({
+        connection: options.connection,
+        fetcher: options.fetcher,
+      })
+      this.connectionDrainsOnSend = connectionDrainsOnSend(transport)
+      this.connection = normalizeConnectionAdapter(transport)
 
       if (wasSubscribed) {
         this.subscribe()

package/src/connection-adapters.ts

@@ -20,6 +20,7 @@ import type {
   UIMessage,
 } from '@tanstack/ai/client'
 import type { ChatFetcher, ChatPendingInterrupt } from './types'
+import { normalizeMessagesDates } from './message-date-normalizer'
 
 /**
  * Associates connect-wrapped chunks with the run they were produced under.
@@ -573,7 +574,9 @@ async function fetchThreadHydration(
         }
       : null
   return {
-    messages: Array.isArray(data.messages) ? data.messages : [],
+    messages: Array.isArray(data.messages)
+      ? normalizeMessagesDates(data.messages)
+      : [],
     activeRun,
     interrupts,
   }
@@ -1052,6 +1055,28 @@ export function normalizeConnectionAdapter(
     }
   }
 
+  async function waitUntilSubscriberIdle(
+    abortSignal?: AbortSignal,
+  ): Promise<void> {
+    // Idle means the subscriber is waiting for the next chunk, so the
+    // previous chunk has left processIncomingChunk. Empty waiters with an
+    // empty buffer is in-flight delivery, not idle.
+    const idle = () =>
+      activeBuffer.length === 0 &&
+      (activeWaiters.length > 0 || abortSignal?.aborted)
+    for (let i = 0; i < 16 && !abortSignal?.aborted; i++) {
+      if (idle()) return
+      await Promise.resolve()
+    }
+    let macrotaskWaits = 0
+    while (!abortSignal?.aborted) {
+      if (idle()) return
+      await new Promise<void>((resolve) => setTimeout(resolve, 0))
+      macrotaskWaits++
+      if (activeWaiters.length === 0 && macrotaskWaits >= 32) return
+    }
+  }
+
   return {
     subscribe(abortSignal?: AbortSignal): AsyncIterable<StreamChunk> {
       // Transfer ownership to the latest subscriber so only one active
@@ -1159,6 +1184,7 @@ export function normalizeConnectionAdapter(
         }
         throw err
       }
+      await waitUntilSubscriberIdle(abortSignal)
     },
     // Expose joinRun only when the underlying connection is resumable. Require
     // a real function — `'joinRun' in connection` is true for
@@ -1224,7 +1250,7 @@ function buildRunAgentInputBody(
 ): Record<string, unknown> {
   // Precedence (later spreads win): static adapter `body` is the base,
   // overridden by `runContext.forwardedProps`, overridden by per-message `data`.
-  const wireMessages = uiMessagesToWire(messages as Array<UIMessage>)
+  const wireMessages = uiMessagesToWire(messages)
   const forwardedProps = {
     ...options.body,
     ...(runContext?.forwardedProps ?? {}),

package/src/devtools-noop.ts

@@ -87,6 +87,7 @@ export class NoOpChatDevtoolsBridge {
   }
   observeChunk(_chunk: StreamChunk): void {}
   recordMemoryState(_value: unknown): void {}
+  recordSkillsState(_value: unknown): void {}
   beginRun(_runId: string, _threadId: string): void {}
   getCurrentRunEventContext(): ChatClientRunEventContext | undefined {
     return undefined

package/src/devtools.ts

@@ -33,6 +33,11 @@ export interface AIDevtoolsDisplayOptions {
  * payload of the `memory:state` CUSTOM chunk. Kept local so `ai-client` doesn't
  * depend on `ai-memory`; the memory middleware is the producer.
  */
+interface SkillsStateEventValue {
+  catalog?: Array<{ name: string; description: string }>
+  activated?: Array<string>
+}
+
 interface MemoryStateEventValue {
   scope: MemoryScopeLite
   adapter: string
@@ -448,6 +453,49 @@ function getActiveBridgeRegistry(): Map<string, ActiveDevtoolsBridge> {
   return registry
 }
 
+/**
+ * `{...options}` turns `get hookId()` into a data property. Chat/generation
+ * clients mint `threadId` after construct (`ensureThreadId` on mount), so a
+ * spread would freeze `hookId: ''` and DevTools could never select the hook.
+ */
+function withLiveClientIdentity<TSnapshot extends object>(
+  identity: Pick<
+    AIDevtoolsBridgeOptions<TSnapshot>,
+    | 'hookId'
+    | 'clientId'
+    | 'threadId'
+    | 'metadata'
+    | 'getTools'
+    | 'applyToolFixture'
+  >,
+  rest: Pick<AIDevtoolsBridgeOptions<TSnapshot>, 'getSnapshot'> &
+    Partial<
+      Pick<AIDevtoolsBridgeOptions<TSnapshot>, 'getTools' | 'applyToolFixture'>
+    >,
+): AIDevtoolsBridgeOptions<TSnapshot> {
+  return {
+    get hookId() {
+      return identity.hookId
+    },
+    get clientId() {
+      return identity.clientId
+    },
+    get threadId() {
+      return identity.threadId
+    },
+    metadata: identity.metadata,
+    getSnapshot: rest.getSnapshot,
+    ...(rest.getTools || identity.getTools
+      ? { getTools: rest.getTools ?? identity.getTools }
+      : {}),
+    ...(rest.applyToolFixture || identity.applyToolFixture
+      ? {
+          applyToolFixture: rest.applyToolFixture ?? identity.applyToolFixture,
+        }
+      : {}),
+  }
+}
+
 export class ClientDevtoolsBridge<TSnapshot extends object> {
   protected readonly options: AIDevtoolsBridgeOptions<TSnapshot>
   private readonly unsubscribers: Array<Unsubscribe> = []
@@ -712,6 +760,7 @@ export class ClientDevtoolsBridge<TSnapshot extends object> {
       | 'memory:retrieve:started'
       | 'memory:retrieve:completed'
       | 'memory:snapshot'
+      | 'skills:snapshot'
       | AIDevtoolsRunEventType,
     visibility: AIDevtoolsEventVisibility = 'client-state',
     context: { runId?: string } = {},
@@ -770,17 +819,24 @@ export class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnaps
   private lastRunEventContext: ChatClientRunEventContext | undefined
   /** Last transported `memory:state` value, replayed when a panel opens. */
   private lastMemoryStateValue: unknown = null
+  /** Last transported `skills:state` value, replayed when a panel opens. */
+  private lastSkillsStateValue: unknown = null
 
   constructor(options: ChatDevtoolsBridgeOptions) {
-    super({
-      ...options,
-      // Thunk defers `this.applyFixture` lookup until after `super` returns.
-      applyToolFixture: (fixture) => this.applyFixture(fixture),
-    })
+    super(
+      withLiveClientIdentity(options, {
+        getSnapshot: options.getSnapshot,
+        // Thunk defers `this.applyFixture` lookup until after `super` returns.
+        applyToolFixture: (fixture) => this.applyFixture(fixture),
+      }),
+    )
     this.chatOptions = options
     // Auto-attaches run/thread context and auto-emits a snapshot after each
     // event so callers can keep using `this.events.X(...)` with no context arg.
-    this.events = new ChatDevtoolsAwareEventEmitter(options.clientId, this)
+    this.events = new ChatDevtoolsAwareEventEmitter(
+      () => options.clientId,
+      this,
+    )
   }
 
   // --- Stream / run context API -------------------------------------------
@@ -874,6 +930,11 @@ export class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnaps
     this.emitMemoryState(rawValue)
   }
 
+  recordSkillsState(rawValue: unknown): void {
+    this.lastSkillsStateValue = rawValue
+    this.emitSkillsState(rawValue)
+  }
+
   /**
    * Re-emit the browser-side `memory:*` events from a transported
    * `memory:state` value. The devtools store consumes these to render the
@@ -926,10 +987,26 @@ export class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnaps
     }
   }
 
+  private emitSkillsState(rawValue: unknown): void {
+    if (!rawValue || typeof rawValue !== 'object') return
+    const value = rawValue as SkillsStateEventValue
+    const catalog = Array.isArray(value.catalog) ? value.catalog : []
+    const activated = Array.isArray(value.activated) ? value.activated : []
+    const runContext = this.currentRunId ? { runId: this.currentRunId } : {}
+    emitAIDevtoolsEvent('skills:snapshot', {
+      ...this.createEnvelope('skills:snapshot', 'client-state', runContext),
+      catalog,
+      activated,
+    })
+  }
+
   protected override onReplayState(): void {
     if (this.lastMemoryStateValue != null) {
       this.emitMemoryState(this.lastMemoryStateValue)
     }
+    if (this.lastSkillsStateValue != null) {
+      this.emitSkillsState(this.lastSkillsStateValue)
+    }
   }
 
   getCurrentRunEventContext(): ChatClientRunEventContext | undefined {
@@ -1410,10 +1487,11 @@ export class GenerationDevtoolsBridge<TOutput> extends ClientDevtoolsBridge<
   protected readonly getCoreState: () => GenerationDevtoolsCoreState<TOutput>
 
   constructor(options: GenerationDevtoolsBridgeOptions<TOutput>) {
-    super({
-      ...options,
-      getSnapshot: () => this.buildSnapshot(),
-    })
+    super(
+      withLiveClientIdentity(options, {
+        getSnapshot: () => this.buildSnapshot(),
+      }),
+    )
     this.maxRuns = options.maxRuns ?? 20
     this.getCoreState = options.getCoreState
   }
@@ -1759,10 +1837,18 @@ export class VideoDevtoolsBridge<
 // so resolveStreamId() works without the chat client telling it.
 class ChatDevtoolsAwareEventEmitter extends DefaultChatClientEventEmitter {
   constructor(
-    clientId: string,
+    private readonly getClientId: () => string,
     private readonly helper: ChatDevtoolsBridge,
   ) {
-    super(clientId)
+    super(getClientId())
+  }
+
+  protected override emitEvent(
+    eventName: string,
+    data?: Record<string, any>,
+  ): void {
+    this.clientId = this.getClientId()
+    super.emitEvent(eventName, data)
   }
 
   private afterEmit(streamId?: string): void {

package/src/message-date-normalizer.ts

@@ -0,0 +1,29 @@
+import type { UIMessage } from './types'
+
+function validDate(value: unknown): Date | undefined {
+  if (value instanceof Date)
+    return Number.isNaN(value.getTime()) ? undefined : value
+  if (typeof value !== 'string') return undefined
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? undefined : date
+}
+
+export function normalizeMessageDates(message: UIMessage): UIMessage {
+  const messageDate = validDate(message.createdAt)
+  const parts = message.parts.map((part) => {
+    if (part.type !== 'tool-result') return part
+    const date = validDate(part.createdAt)
+    const { createdAt: _ignored, ...rest } = part
+    return date ? { ...rest, createdAt: date } : rest
+  })
+  const { createdAt: _ignored, ...rest } = message
+  return messageDate
+    ? { ...rest, parts, createdAt: messageDate }
+    : { ...rest, parts }
+}
+
+export function normalizeMessagesDates(
+  messages: Array<UIMessage>,
+): Array<UIMessage> {
+  return messages.map(normalizeMessageDates)
+}

package/src/storage-adapters.ts

@@ -1,4 +1,5 @@
-import type { ChatPersistedState, ChatStorageAdapter } from './types'
+import type { ChatPersistedState, ChatStorageAdapter, UIMessage } from './types'
+import { normalizeMessagesDates } from './message-date-normalizer'
 
 export interface WebStoragePersistenceOptions {
   keyPrefix?: string
@@ -45,6 +46,16 @@ function stringifyJson(value: ChatPersistedState): string {
   return serialized
 }
 
+function reviveMessageCreatedAt(message: UIMessage): UIMessage {
+  return normalizeMessagesDates([message]).at(0) ?? message
+}
+
+function revivePersistedState(state: ChatPersistedState): ChatPersistedState {
+  if (state == null || typeof state !== 'object') return state
+  if (!Array.isArray(state.messages)) return state
+  return { ...state, messages: state.messages.map(reviveMessageCreatedAt) }
+}
+
 function createWebStoragePersistence(
   storageName: 'localStorage' | 'sessionStorage',
   options: WebStoragePersistenceOptions,
@@ -69,7 +80,7 @@ function createWebStoragePersistence(
   return {
     getItem(id) {
       const item = getStorage().getItem(key(id))
-      return item === null ? null : deserialize(item)
+      return item === null ? null : revivePersistedState(deserialize(item))
     },
     setItem(id, value) {
       getStorage().setItem(key(id), serialize(value))

package/src/types.ts

@@ -595,10 +595,14 @@ export type ToolCallPart<TTools extends ReadonlyArray<AnyClientTool> = any> =
 
 export interface ToolResultPart {
   type: 'tool-result'
+  id?: string
+  name?: string
   toolCallId: string
   content: string | Array<ContentPart>
   state: ToolResultState
   error?: string // Error message if state is "error"
+  metadata?: Record<string, unknown>
+  createdAt?: Date
 }
 
 export interface ThinkingPart {
@@ -639,6 +643,7 @@ export interface UIMessage<
 > {
   id: string
   role: 'system' | 'user' | 'assistant'
+  name?: string
   parts: Array<MessagePart<TTools, TData>>
   createdAt?: Date
   /**