@tanstack/ai-client 0.29.1 → 0.30.0

package/dist/esm/ui/types.d.ts

@@ -0,0 +1,103 @@
+import { AnyClientTool, InferSchemaType, InferToolInput, InferToolOutput, InterruptDefinition, SchemaInput } from '@tanstack/ai/client';
+import { ChatInterrupt, MessagePart, RegisteredGenericInterrupt, StructuredOutputPart, ToolApprovalInterrupt, ToolCallPart, ToolResultPart, UIMessage } from '../types.js';
+export type ChatUIPartKey = 'text' | 'image' | 'audio' | 'video' | 'document' | 'thinking' | 'toolCall' | 'toolResult' | 'structuredOutput' | 'uiResource';
+export type ChatUIPartTypeByKey = {
+    text: 'text';
+    image: 'image';
+    audio: 'audio';
+    video: 'video';
+    document: 'document';
+    thinking: 'thinking';
+    toolCall: 'tool-call';
+    toolResult: 'tool-result';
+    structuredOutput: 'structured-output';
+    uiResource: 'ui-resource';
+};
+export type ChatUIPartOf<TOptions, TKey extends ChatUIPartKey = ChatUIPartKey> = TKey extends ChatUIPartKey ? Extract<MessagePart<ChatUIToolsOf<TOptions>, ChatUIData<TOptions>>, {
+    type: ChatUIPartTypeByKey[TKey];
+}> : never;
+export type ChatUIToolsOf<TOptions> = TOptions extends {
+    tools: infer TTools;
+} ? TTools extends ReadonlyArray<AnyClientTool> ? TTools : any : any;
+export type ChatUIInterruptsOf<TOptions> = TOptions extends {
+    interrupts: infer TInterrupts;
+} ? TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> ? TInterrupts : readonly [] : readonly [];
+export type ChatUISchemaOf<TOptions> = TOptions extends {
+    outputSchema: infer TSchema;
+} ? TSchema extends SchemaInput ? TSchema : undefined : undefined;
+export type ChatUIData<TOptions> = TOptions extends {
+    outputSchema: infer TSchema;
+} ? TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown : unknown;
+export type ChatUIToolName<TOptions> = ChatUIToolsOf<TOptions>[number] extends infer TTool ? TTool extends AnyClientTool ? TTool['name'] : string : string;
+export type ChatUIRegisteredInterruptId<TOptions> = ChatUIInterruptsOf<TOptions>[number] extends infer TDefinition ? TDefinition extends InterruptDefinition<infer TId, any, any, any> ? TId : string : string;
+export type ChatUIHasNamedTools<TOptions> = [ChatUIToolName<TOptions>] extends [
+    never
+] ? false : [string] extends [ChatUIToolName<TOptions>] ? false : true;
+export type ChatUIHasNamedInterrupts<TOptions> = [
+    ChatUIRegisteredInterruptId<TOptions>
+] extends [never] ? false : [string] extends [ChatUIRegisteredInterruptId<TOptions>] ? false : true;
+export type ChatUINamedInterruptId<TOptions> = Exclude<ChatUIRegisteredInterruptId<TOptions>, 'fallback'>;
+export type ChatUIInterruptName<TOptions> = (ChatUIHasNamedTools<TOptions> extends true ? ChatUIToolName<TOptions> : never) | (ChatUIHasNamedInterrupts<TOptions> extends true ? ChatUINamedInterruptId<TOptions> : never);
+type ToolByName<TOptions, TName> = Extract<ChatUIToolsOf<TOptions> extends ReadonlyArray<infer TTool> ? TTool : never, {
+    name: TName;
+}>;
+export type ChatUIInterrupt = ChatInterrupt | ToolApprovalInterrupt;
+export type ChatUIToolApproval<TOptions, TName extends ChatUIToolName<TOptions> = ChatUIToolName<TOptions>> = Extract<ChatInterrupt<ChatUIToolsOf<TOptions>, ChatUIInterruptsOf<TOptions>>, {
+    kind: 'tool-approval';
+    toolName: TName;
+}>;
+export type ChatUIToolPart<TOptions, TName extends ChatUIToolName<TOptions> = ChatUIToolName<TOptions>> = {
+    key: 'toolCall';
+    part: Extract<ToolCallPart<ChatUIToolsOf<TOptions>>, {
+        name: TName;
+    }>;
+    result?: ToolResultPart;
+    interrupt?: Extract<ChatInterrupt<ChatUIToolsOf<TOptions>, ChatUIInterruptsOf<TOptions>>, {
+        kind: 'tool-approval';
+        toolName: TName;
+    }>;
+    input?: InferToolInput<ToolByName<TOptions, TName>>;
+    output?: InferToolOutput<ToolByName<TOptions, TName>>;
+};
+export type RegisteredUIInterrupt<TOptions, TId extends ChatUIRegisteredInterruptId<TOptions> = ChatUIRegisteredInterruptId<TOptions>> = Extract<RegisteredGenericInterrupt<ChatUIInterruptsOf<TOptions>>, {
+    definitionId: TId;
+}>;
+export type ChatUIInterruptOf<TOptions, TName extends ChatUIInterruptName<TOptions> = never> = [TName] extends [never] ? ChatUIInterrupt : TName extends (ChatUIHasNamedTools<TOptions> extends true ? ChatUIToolName<TOptions> : never) ? ChatUIToolApproval<TOptions, TName> : TName extends ChatUINamedInterruptId<TOptions> ? RegisteredUIInterrupt<TOptions, TName> : ChatUIInterrupt;
+export type ChatUISelectedToolPart = {
+    key: 'toolCall';
+    part: ToolCallPart;
+    result?: ToolResultPart;
+    interrupt?: ChatUIInterrupt;
+    input?: unknown;
+    output?: unknown;
+};
+export type ChatUISelectedResultPart = {
+    key: 'toolResult';
+    part: ToolResultPart;
+    matched: boolean;
+};
+export type ChatUISelectedGenericPart = {
+    key: Exclude<ChatUIPartKey, 'toolCall' | 'toolResult'>;
+    part: MessagePart;
+};
+export type ChatUISelectedPart = ChatUISelectedToolPart | ChatUISelectedResultPart | ChatUISelectedGenericPart;
+export type ChatUISelectedPartOf<TOptions, TKey extends ChatUIPartKey = ChatUIPartKey> = TKey extends 'toolCall' ? ChatUIToolPart<TOptions> : TKey extends 'toolResult' ? ChatUISelectedResultPart : {
+    key: TKey;
+    part: ChatUIPartOf<TOptions, TKey>;
+};
+export type ChatUISelectedMessage = {
+    message: UIMessage;
+    parts: Array<ChatUISelectedPart>;
+};
+export type ChatUISelection = {
+    messages: Array<ChatUISelectedMessage>;
+    interrupts: Array<ChatUIInterrupt>;
+};
+export type ChatUISelectInput = {
+    messages: ReadonlyArray<UIMessage>;
+    interrupts?: ReadonlyArray<ChatUIInterrupt>;
+    inlineToolNames?: ReadonlyArray<string>;
+};
+export type ChatUIMessages<TOptions> = Array<UIMessage<ChatUIToolsOf<TOptions>, ChatUIData<TOptions>>>;
+export type ChatUIStructuredPart<TOptions> = StructuredOutputPart<ChatUIData<TOptions>>;
+export {};

package/dist/esm/ui.d.ts

@@ -0,0 +1,3 @@
+export { partTypeToKey, selectChatUI } from './ui/selectors.js';
+export { automaticPartsForMessage, collectInlineToolNames, resolveInterruptComponent, selectMessageUI, } from './ui/selectors.js';
+export type { ChatUIData, ChatUIHasNamedInterrupts, ChatUIHasNamedTools, ChatUIInterrupt, ChatUIInterruptName, ChatUIInterruptOf, ChatUIInterruptsOf, ChatUINamedInterruptId, ChatUIMessages, ChatUIPartKey, ChatUIPartOf, ChatUIPartTypeByKey, ChatUIRegisteredInterruptId, ChatUISchemaOf, ChatUISelectInput, ChatUISelectedGenericPart, ChatUISelectedMessage, ChatUISelectedPart, ChatUISelectedPartOf, ChatUISelectedResultPart, ChatUISelectedToolPart, ChatUISelection, ChatUIStructuredPart, ChatUIToolApproval, ChatUIToolName, ChatUIToolPart, ChatUIToolsOf, RegisteredUIInterrupt, } from './ui/types.js';

package/dist/esm/ui.js

@@ -0,0 +1,2 @@
+import { automaticPartsForMessage, collectInlineToolNames, partTypeToKey, resolveInterruptComponent, selectChatUI, selectMessageUI } from "./ui/selectors.js";
+export { automaticPartsForMessage, collectInlineToolNames, partTypeToKey, resolveInterruptComponent, selectChatUI, selectMessageUI };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-client",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "description": "Framework-agnostic headless client for TanStack AI chat, realtime sessions, streaming transports, and media generations.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -46,6 +46,10 @@
     "./byok": {
       "types": "./dist/esm/byok.d.ts",
       "import": "./dist/esm/byok.js"
+    },
+    "./ui": {
+      "types": "./dist/esm/ui.d.ts",
+      "import": "./dist/esm/ui.js"
     }
   },
   "files": [
@@ -53,8 +57,8 @@
     "src"
   ],
   "dependencies": {
-    "@tanstack/ai": "^0.51.0",
-    "@tanstack/ai-event-client": "^0.11.1",
+    "@tanstack/ai": "^0.52.1",
+    "@tanstack/ai-event-client": "^0.11.2",
     "@tanstack/ai-utils": "^0.4.0"
   },
   "devDependencies": {

package/src/chat-client.ts

@@ -851,6 +851,13 @@ export class ChatClient<
           if (eventType === 'memory:state') {
             this.devtoolsBridge.recordMemoryState(data)
           }
+          if (
+            eventType === 'compaction:started' ||
+            eventType === 'compaction:state' ||
+            eventType === 'compaction:ended'
+          ) {
+            this.devtoolsBridge.recordCompactionEvent(eventType, data)
+          }
           if (eventType === 'skills:state') {
             this.devtoolsBridge.recordSkillsState(data)
           }

package/src/devtools-noop.ts

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

package/src/devtools.ts

@@ -8,6 +8,7 @@ import { DefaultChatClientEventEmitter } from './events'
 import type { AnyClientTool, StreamChunk } from '@tanstack/ai/client'
 import type {
   AIDevtoolsEventVisibility,
+  CompactionMessagePreview,
   MemoryScopeLite,
 } from '@tanstack/ai-event-client'
 import type {
@@ -60,6 +61,127 @@ interface MemoryStateEventValue {
   }
 }
 
+function readCompactionBoundaryValue(rawValue: unknown): {
+  before?: number
+  after?: number
+  messagesBefore?: number
+  messagesAfter?: number
+  reusedCheckpoint?: boolean
+  maxTokens?: number
+  strategyKey?: string
+  durationMs?: number
+} {
+  if (!rawValue || typeof rawValue !== 'object') return {}
+  return {
+    ...('before' in rawValue && typeof rawValue.before === 'number'
+      ? { before: rawValue.before }
+      : {}),
+    ...('after' in rawValue && typeof rawValue.after === 'number'
+      ? { after: rawValue.after }
+      : {}),
+    ...('messagesBefore' in rawValue &&
+    typeof rawValue.messagesBefore === 'number'
+      ? { messagesBefore: rawValue.messagesBefore }
+      : {}),
+    ...('messagesAfter' in rawValue &&
+    typeof rawValue.messagesAfter === 'number'
+      ? { messagesAfter: rawValue.messagesAfter }
+      : {}),
+    ...('reusedCheckpoint' in rawValue &&
+    typeof rawValue.reusedCheckpoint === 'boolean'
+      ? { reusedCheckpoint: rawValue.reusedCheckpoint }
+      : {}),
+    ...('maxTokens' in rawValue && typeof rawValue.maxTokens === 'number'
+      ? { maxTokens: rawValue.maxTokens }
+      : {}),
+    ...('strategyKey' in rawValue && typeof rawValue.strategyKey === 'string'
+      ? { strategyKey: rawValue.strategyKey }
+      : {}),
+    ...('durationMs' in rawValue && typeof rawValue.durationMs === 'number'
+      ? { durationMs: rawValue.durationMs }
+      : {}),
+  }
+}
+
+function readPreviewList(
+  value: unknown,
+): Array<CompactionMessagePreview> | undefined {
+  if (!Array.isArray(value)) return undefined
+  const previews: Array<CompactionMessagePreview> = []
+  for (const item of value) {
+    if (!item || typeof item !== 'object') continue
+    if (!('role' in item) || !('tokens' in item) || !('text' in item)) continue
+    if (
+      typeof item.role !== 'string' ||
+      typeof item.tokens !== 'number' ||
+      typeof item.text !== 'string'
+    ) {
+      continue
+    }
+    previews.push({
+      role: item.role,
+      tokens: item.tokens,
+      text: item.text,
+    })
+  }
+  return previews
+}
+
+function readCompactionStateValue(rawValue: unknown): {
+  before: number
+  after: number
+  messagesBefore: number
+  messagesAfter: number
+  reusedCheckpoint: boolean
+  maxTokens?: number
+  strategyKey?: string
+  dropped?: Array<CompactionMessagePreview>
+  result?: Array<CompactionMessagePreview>
+} | null {
+  if (!rawValue || typeof rawValue !== 'object') return null
+  if (
+    !('before' in rawValue) ||
+    !('after' in rawValue) ||
+    !('messagesBefore' in rawValue) ||
+    !('messagesAfter' in rawValue)
+  ) {
+    return null
+  }
+  if (
+    typeof rawValue.before !== 'number' ||
+    typeof rawValue.after !== 'number' ||
+    typeof rawValue.messagesBefore !== 'number' ||
+    typeof rawValue.messagesAfter !== 'number'
+  ) {
+    return null
+  }
+  const reusedCheckpoint =
+    'reusedCheckpoint' in rawValue && rawValue.reusedCheckpoint === true
+  const maxTokens =
+    'maxTokens' in rawValue && typeof rawValue.maxTokens === 'number'
+      ? rawValue.maxTokens
+      : undefined
+  const strategyKey =
+    'strategyKey' in rawValue && typeof rawValue.strategyKey === 'string'
+      ? rawValue.strategyKey
+      : undefined
+  const dropped =
+    'dropped' in rawValue ? readPreviewList(rawValue.dropped) : undefined
+  const result =
+    'result' in rawValue ? readPreviewList(rawValue.result) : undefined
+  return {
+    before: rawValue.before,
+    after: rawValue.after,
+    messagesBefore: rawValue.messagesBefore,
+    messagesAfter: rawValue.messagesAfter,
+    reusedCheckpoint,
+    ...(maxTokens !== undefined ? { maxTokens } : {}),
+    ...(strategyKey ? { strategyKey } : {}),
+    ...(dropped ? { dropped } : {}),
+    ...(result ? { result } : {}),
+  }
+}
+
 export interface AIDevtoolsClientMetadata extends AIDevtoolsDisplayOptions {
   framework?: string
   hookName: string
@@ -760,6 +882,9 @@ export class ClientDevtoolsBridge<TSnapshot extends object> {
       | 'memory:retrieve:started'
       | 'memory:retrieve:completed'
       | 'memory:snapshot'
+      | 'compaction:started'
+      | 'compaction:state'
+      | 'compaction:ended'
       | 'skills:snapshot'
       | AIDevtoolsRunEventType,
     visibility: AIDevtoolsEventVisibility = 'client-state',
@@ -819,6 +944,11 @@ export class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnaps
   private lastRunEventContext: ChatClientRunEventContext | undefined
   /** Last transported `memory:state` value, replayed when a panel opens. */
   private lastMemoryStateValue: unknown = null
+  /** Transported compaction CUSTOM events, replayed when a panel opens. */
+  private readonly lastCompactionEvents: Array<{
+    eventType: string
+    value: unknown
+  }> = []
   /** Last transported `skills:state` value, replayed when a panel opens. */
   private lastSkillsStateValue: unknown = null
 
@@ -987,6 +1117,55 @@ export class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnaps
     }
   }
 
+  /**
+   * Record a transported compaction CUSTOM event. Called from the chat
+   * client's `onCustomEvent` handler so server-side compaction reaches the
+   * browser DevTools panel.
+   */
+  recordCompactionEvent(eventType: string, rawValue: unknown): void {
+    this.lastCompactionEvents.push({ eventType, value: rawValue })
+    if (this.lastCompactionEvents.length > 60) {
+      this.lastCompactionEvents.splice(0, this.lastCompactionEvents.length - 60)
+    }
+    this.emitCompactionEvent(eventType, rawValue)
+  }
+
+  recordCompactionState(rawValue: unknown): void {
+    this.recordCompactionEvent('compaction:state', rawValue)
+  }
+
+  private emitCompactionEvent(eventType: string, rawValue: unknown): void {
+    const runContext = this.currentRunId ? { runId: this.currentRunId } : {}
+    if (eventType === 'compaction:started') {
+      const value = readCompactionBoundaryValue(rawValue)
+      emitAIDevtoolsEvent('compaction:started', {
+        ...this.createEnvelope(
+          'compaction:started',
+          'client-state',
+          runContext,
+        ),
+        ...value,
+      })
+      return
+    }
+    if (eventType === 'compaction:ended') {
+      const value = readCompactionBoundaryValue(rawValue)
+      emitAIDevtoolsEvent('compaction:ended', {
+        ...this.createEnvelope('compaction:ended', 'client-state', runContext),
+        ...value,
+      })
+      return
+    }
+    if (eventType === 'compaction:state') {
+      const value = readCompactionStateValue(rawValue)
+      if (!value) return
+      emitAIDevtoolsEvent('compaction:state', {
+        ...this.createEnvelope('compaction:state', 'client-state', runContext),
+        ...value,
+      })
+    }
+  }
+
   private emitSkillsState(rawValue: unknown): void {
     if (!rawValue || typeof rawValue !== 'object') return
     const value = rawValue as SkillsStateEventValue
@@ -1004,6 +1183,9 @@ export class ChatDevtoolsBridge extends ClientDevtoolsBridge<AIDevtoolsChatSnaps
     if (this.lastMemoryStateValue != null) {
       this.emitMemoryState(this.lastMemoryStateValue)
     }
+    for (const event of this.lastCompactionEvents) {
+      this.emitCompactionEvent(event.eventType, event.value)
+    }
     if (this.lastSkillsStateValue != null) {
       this.emitSkillsState(this.lastSkillsStateValue)
     }

package/src/ui/selectors.ts

@@ -0,0 +1,178 @@
+import type {
+  MessagePart,
+  ToolApprovalInterrupt,
+  ToolCallPart,
+  ToolResultPart,
+  UIMessage,
+} from '../types'
+import type {
+  ChatUIInterrupt,
+  ChatUIPartKey,
+  ChatUISelectInput,
+  ChatUISelectedMessage,
+  ChatUISelectedPart,
+  ChatUISelection,
+} from './types'
+
+const PART_KEY_BY_TYPE: Record<string, ChatUIPartKey> = {
+  text: 'text',
+  image: 'image',
+  audio: 'audio',
+  video: 'video',
+  document: 'document',
+  thinking: 'thinking',
+  'tool-call': 'toolCall',
+  'tool-result': 'toolResult',
+  'structured-output': 'structuredOutput',
+  'ui-resource': 'uiResource',
+}
+
+export function partTypeToKey(type: string): ChatUIPartKey | string {
+  const mapped = PART_KEY_BY_TYPE[type]
+  if (mapped) return mapped
+  return type.replace(/-([a-z])/g, (_, letter: string) => letter.toUpperCase())
+}
+
+export function collectInlineToolNames(
+  toolInterrupts?: Record<string, unknown>,
+  mappedToolNames?: ReadonlyArray<string>,
+): Array<string> {
+  const listPlaced = new Set(Object.keys(toolInterrupts ?? {}))
+  return (mappedToolNames ?? []).filter((name) => !listPlaced.has(name))
+}
+
+export function resolveInterruptComponent(
+  interrupt: ChatUIInterrupt,
+  interruptsMap:
+    | {
+        tools?: Record<string, unknown>
+        generic?: Record<string, unknown>
+      }
+    | undefined,
+): unknown {
+  if (!interruptsMap) return undefined
+  if (interrupt.kind === 'tool-approval') {
+    return interruptsMap.tools?.[interrupt.toolName]
+  }
+  const generic = interruptsMap.generic
+  if (!generic) return undefined
+  const definitionId =
+    'definitionId' in interrupt && typeof interrupt.definitionId === 'string'
+      ? interrupt.definitionId
+      : undefined
+  if (definitionId && definitionId !== 'fallback') {
+    const registered = generic[definitionId]
+    if (registered) return registered
+  }
+  return generic.fallback
+}
+
+function isToolCallPart(part: MessagePart): part is ToolCallPart {
+  return part.type === 'tool-call'
+}
+
+function isToolResultPart(part: MessagePart): part is ToolResultPart {
+  return part.type === 'tool-result'
+}
+
+function isToolApproval(
+  interrupt: ChatUIInterrupt,
+): interrupt is ToolApprovalInterrupt {
+  return interrupt.kind === 'tool-approval'
+}
+
+export function selectChatUI(input: ChatUISelectInput): ChatUISelection {
+  const messages = input.messages
+  const interrupts = input.interrupts ?? []
+  const inlineToolNames = new Set(input.inlineToolNames ?? [])
+
+  const resultsByCallId = new Map<string, ToolResultPart>()
+  const callIds = new Set<string>()
+  for (const message of messages) {
+    for (const part of message.parts) {
+      if (isToolCallPart(part)) callIds.add(part.id)
+      if (isToolResultPart(part)) resultsByCallId.set(part.toolCallId, part)
+    }
+  }
+
+  const approvalByCallId = new Map<string, ToolApprovalInterrupt>()
+  for (const interrupt of interrupts) {
+    if (isToolApproval(interrupt)) {
+      approvalByCallId.set(interrupt.toolCallId, interrupt)
+    }
+  }
+
+  const selectedMessages: Array<ChatUISelectedMessage> = messages.map(
+    (message) => ({
+      message,
+      parts: message.parts.map((part) =>
+        toSelectedPart(part, resultsByCallId, approvalByCallId, callIds),
+      ),
+    }),
+  )
+
+  return {
+    messages: selectedMessages,
+    interrupts: interrupts.filter((interrupt) => {
+      if (!isToolApproval(interrupt)) return true
+      if (!inlineToolNames.has(interrupt.toolName)) return true
+      return !callIds.has(interrupt.toolCallId)
+    }),
+  }
+}
+
+function toSelectedPart(
+  part: MessagePart,
+  resultsByCallId: Map<string, ToolResultPart>,
+  approvalByCallId: Map<string, ToolApprovalInterrupt>,
+  callIds: Set<string>,
+): ChatUISelectedPart {
+  if (isToolCallPart(part)) {
+    const result = resultsByCallId.get(part.id)
+    const interrupt = approvalByCallId.get(part.id)
+    return {
+      key: 'toolCall',
+      part,
+      ...(result ? { result } : {}),
+      ...(interrupt ? { interrupt } : {}),
+      input: part.input,
+      output: part.output,
+    }
+  }
+
+  if (isToolResultPart(part)) {
+    return {
+      key: 'toolResult',
+      part,
+      matched: callIds.has(part.toolCallId),
+    }
+  }
+
+  return {
+    key: partTypeToKey(part.type) as Exclude<
+      ChatUIPartKey,
+      'toolCall' | 'toolResult'
+    >,
+    part,
+  }
+}
+
+export function automaticPartsForMessage(
+  selected: ChatUISelectedMessage,
+): Array<ChatUISelectedPart> {
+  return selected.parts.filter(
+    (part) => !(part.key === 'toolResult' && part.matched),
+  )
+}
+
+export function selectMessageUI(
+  message: UIMessage,
+  input: Omit<ChatUISelectInput, 'messages'>,
+): ChatUISelectedMessage {
+  return (
+    selectChatUI({ ...input, messages: [message] }).messages[0] ?? {
+      message,
+      parts: [],
+    }
+  )
+}