@lota-sdk/ui 0.1.5

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@lota-sdk/ui",
+  "version": "0.1.5",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    },
+    "./chat/*": {
+      "bun": "./src/chat/*.ts",
+      "import": "./src/chat/*.ts",
+      "types": "./src/chat/*.ts"
+    },
+    "./runtime/*": {
+      "bun": "./src/runtime/*.ts",
+      "import": "./src/runtime/*.ts",
+      "types": "./src/runtime/*.ts"
+    },
+    "./tools/*": {
+      "bun": "./src/tools/*.ts",
+      "import": "./src/tools/*.ts",
+      "types": "./src/tools/*.ts"
+    }
+  },
+  "scripts": {
+    "lint": "node ../node_modules/oxlint/bin/oxlint --fix -c ../oxlint.config.ts src",
+    "format": "bunx oxfmt src",
+    "typecheck": "bunx tsgo --noEmit",
+    "test:unit": "bun test ../tests/unit/ui"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@lota-sdk/shared": "0.1.0",
+    "ai": "^6.0.116"
+  },
+  "peerDependencies": {
+    "@ai-sdk/react": "^3.0.118",
+    "@tanstack/react-query": "^5.90.21",
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@ai-sdk/react": "^3.0.118",
+    "@tanstack/react-query": "^5.90.21",
+    "@types/react": "^19.2.14",
+    "react": "^19.2.4"
+  }
+}

package/src/chat/attachments.ts

@@ -0,0 +1,83 @@
+import {
+  ATTACHMENT_MAX_FILE_SIZE_BYTES,
+  ATTACHMENT_MAX_TOTAL_SIZE_BYTES,
+  inferContentType,
+  isSupportedAttachment,
+} from '@lota-sdk/shared/constants/attachments'
+import type { FileUIPart } from 'ai'
+
+type UploadedAttachmentPayload = {
+  filename: string
+  mediaType: string
+  sizeBytes: number
+  storageKey: string
+  url: string
+}
+
+async function toUploadFile(filePart: FileUIPart): Promise<File> {
+  if (!filePart.url) {
+    throw new Error('Attachment payload is missing file data.')
+  }
+
+  const response = await fetch(filePart.url)
+  if (!response.ok) {
+    throw new Error(`Failed to read attachment bytes (${response.status}).`)
+  }
+
+  const blob = await response.blob()
+  const filename = filePart.filename?.trim() || 'attachment'
+  const inferredFile = new File([blob], filename, { type: blob.type || 'application/octet-stream' })
+  const mediaType = filePart.mediaType.trim() || inferContentType(inferredFile)
+
+  return new File([inferredFile], filename, { type: mediaType })
+}
+
+export async function uploadComposerFiles(params: {
+  files: FileUIPart[] | undefined
+  uploadFile: (file: File) => Promise<{ attachment: UploadedAttachmentPayload }>
+  maxFileSizeBytes?: number
+  maxTotalSizeBytes?: number
+  isAttachmentSupported?: (file: File) => boolean
+  toFile?: (filePart: FileUIPart) => Promise<File>
+}): Promise<FileUIPart[]> {
+  if (!params.files || params.files.length === 0) return []
+
+  const toFile = params.toFile ?? toUploadFile
+  const uploads = await Promise.all(params.files.map((filePart) => toFile(filePart)))
+  const maxFileSizeBytes = params.maxFileSizeBytes ?? ATTACHMENT_MAX_FILE_SIZE_BYTES
+  const maxTotalSizeBytes = params.maxTotalSizeBytes ?? ATTACHMENT_MAX_TOTAL_SIZE_BYTES
+  const isAttachmentSupported = params.isAttachmentSupported ?? isSupportedAttachment
+
+  let totalSizeBytes = 0
+  for (const file of uploads) {
+    if (!isAttachmentSupported(file)) {
+      throw new Error(`Unsupported attachment type: ${file.name}`)
+    }
+    if (file.size > maxFileSizeBytes) {
+      throw new Error(`Attachment exceeds ${Math.floor(maxFileSizeBytes / 1024 / 1024)}MB limit.`)
+    }
+    totalSizeBytes += file.size
+  }
+
+  if (totalSizeBytes > maxTotalSizeBytes) {
+    throw new Error('Total attachment size exceeds allowed limit.')
+  }
+
+  return await Promise.all(
+    uploads.map(async (file) => {
+      const response = await params.uploadFile(file)
+      return {
+        type: 'file',
+        mediaType: response.attachment.mediaType,
+        filename: response.attachment.filename,
+        url: response.attachment.url,
+        providerMetadata: {
+          lota: {
+            attachmentStorageKey: response.attachment.storageKey,
+            attachmentSizeBytes: response.attachment.sizeBytes,
+          },
+        },
+      } satisfies FileUIPart
+    }),
+  )
+}

package/src/chat/index.ts

@@ -0,0 +1,4 @@
+export * from './attachments'
+export * from './message-parts'
+export * from './messages'
+export * from './transport'

package/src/chat/message-parts.ts

@@ -0,0 +1,101 @@
+import { isToolUIPart } from 'ai'
+import type { UIDataTypes, UIMessagePart, UITools } from 'ai'
+
+export type MessagePartEntry<TPart> = { part: TPart; index: number }
+
+export type ToolMessagePart<DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = Extract<
+  UIMessagePart<DATA_PARTS, TOOLS>,
+  { type: `tool-${string}` } | { type: 'dynamic-tool' }
+>
+
+function filterRedactedReasoning(text: string): string {
+  return text.replace(/\[REDACTED\]/gi, '').trim()
+}
+
+export function readToolPart<DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools>(
+  part: UIMessagePart<DATA_PARTS, TOOLS>,
+): ToolMessagePart<DATA_PARTS, TOOLS> | null {
+  if (!isToolUIPart(part)) return null
+  return part as ToolMessagePart<DATA_PARTS, TOOLS>
+}
+
+function isTextLikeContent<DATA_PARTS extends UIDataTypes, TOOLS extends UITools>(
+  part: UIMessagePart<DATA_PARTS, TOOLS>,
+): boolean {
+  if (part.type === 'text' || part.type === 'reasoning') {
+    return 'text' in part && typeof part.text === 'string' && part.text.length > 0
+  }
+  if (part.type === 'file' || part.type === 'source-url' || part.type === 'source-document') {
+    return true
+  }
+  return readToolPart(part) !== null
+}
+
+export function consumeReasoningGroup<DATA_PARTS extends UIDataTypes, TOOLS extends UITools>(
+  entries: MessagePartEntry<UIMessagePart<DATA_PARTS, TOOLS>>[],
+  startIndex: number,
+  isMessageStreaming: boolean,
+): { nextEntryIndex: number; stablePartIndex: number; text: string; isStreaming: boolean } | null {
+  const entry = entries.at(startIndex)
+  if (!entry || entry.part.type !== 'reasoning') return null
+
+  const reasoningTexts: string[] = []
+  let hasStreamingReasoningPart = false
+  let nextEntryIndex = startIndex
+
+  while (nextEntryIndex < entries.length) {
+    const currentEntry = entries.at(nextEntryIndex)
+    const part = currentEntry?.part
+    if (!part || part.type !== 'reasoning' || !('text' in part) || typeof part.text !== 'string') {
+      break
+    }
+
+    const reasoningText = filterRedactedReasoning(part.text)
+    if (reasoningText.length > 0) {
+      reasoningTexts.push(reasoningText)
+    }
+    if ('state' in part && part.state === 'streaming') {
+      hasStreamingReasoningPart = true
+    }
+    nextEntryIndex += 1
+  }
+
+  const hasLaterTextLikePart = entries.slice(nextEntryIndex).some((candidate) => isTextLikeContent(candidate.part))
+
+  return {
+    nextEntryIndex,
+    stablePartIndex: entry.index,
+    text: reasoningTexts.join('\n\n'),
+    isStreaming: (hasStreamingReasoningPart || isMessageStreaming) && !hasLaterTextLikePart,
+  }
+}
+
+export function consumeTextGroup<DATA_PARTS extends UIDataTypes, TOOLS extends UITools>(
+  entries: MessagePartEntry<UIMessagePart<DATA_PARTS, TOOLS>>[],
+  startIndex: number,
+  options: { sanitizeText?: (value: string) => string } = {},
+): { nextEntryIndex: number; stablePartIndex: number; text: string } | null {
+  const entry = entries.at(startIndex)
+  if (!entry || entry.part.type !== 'text') return null
+
+  const sanitizeText = options.sanitizeText ?? ((value: string) => value)
+  const textSegments: string[] = []
+  let nextEntryIndex = startIndex
+
+  while (nextEntryIndex < entries.length) {
+    const currentEntry = entries.at(nextEntryIndex)
+    const part = currentEntry?.part
+    if (!part || part.type !== 'text' || !('text' in part) || typeof part.text !== 'string') {
+      break
+    }
+
+    const text = sanitizeText(part.text)
+    if (text.length > 0) {
+      textSegments.push(text)
+    }
+
+    nextEntryIndex += 1
+  }
+
+  return { nextEntryIndex, stablePartIndex: entry.index, text: textSegments.join('\n\n') }
+}

package/src/chat/messages.ts

@@ -0,0 +1,39 @@
+import { getMessageCreatedAt, withMessageCreatedAt } from '@lota-sdk/shared/runtime/chat-message-metadata'
+
+interface TimestampedMessage {
+  id: string
+  metadata?: { createdAt?: unknown }
+}
+
+function normalizeMessage<TMessage extends TimestampedMessage>(message: TMessage): TMessage {
+  return withMessageCreatedAt(message)
+}
+
+function compareChatMessages<TMessage extends TimestampedMessage>(left: TMessage, right: TMessage): number {
+  const leftTime = getMessageCreatedAt(left, { fallback: 0 })
+  const rightTime = getMessageCreatedAt(right, { fallback: 0 })
+  if (leftTime !== rightTime) return leftTime - rightTime
+  return left.id.localeCompare(right.id)
+}
+
+function sortChatMessages<TMessage extends TimestampedMessage>(messages: readonly TMessage[]): TMessage[] {
+  return [...messages].sort(compareChatMessages)
+}
+
+export function normalizeChatMessages<TMessage extends TimestampedMessage>(messages: readonly TMessage[]): TMessage[] {
+  return sortChatMessages(messages.map((message) => normalizeMessage(message)))
+}
+
+export function mergeChatMessages<TMessage extends TimestampedMessage>(
+  ...messageLists: ReadonlyArray<readonly TMessage[]>
+): TMessage[] {
+  const messagesById = new Map<string, TMessage>()
+
+  for (const messages of messageLists) {
+    for (const message of messages) {
+      messagesById.set(message.id, message)
+    }
+  }
+
+  return sortChatMessages(Array.from(messagesById.values()))
+}

package/src/chat/transport.ts

@@ -0,0 +1,8 @@
+import { DefaultChatTransport } from 'ai'
+import type { HttpChatTransportInitOptions, UIMessage } from 'ai'
+
+export type ChatTransportOptions<UI_MESSAGE extends UIMessage> = HttpChatTransportInitOptions<UI_MESSAGE>
+
+export function createChatTransport<UI_MESSAGE extends UIMessage>(options: ChatTransportOptions<UI_MESSAGE>) {
+  return new DefaultChatTransport<UI_MESSAGE>(options)
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './chat'
+export * from './runtime'
+export * from './tools'

package/src/runtime/active-thread-helpers.ts

@@ -0,0 +1,59 @@
+import type { FileUIPart, UIMessage } from 'ai'
+
+export type ComposerMessage<TFile extends FileUIPart = FileUIPart> = { text: string; files?: TFile[] }
+
+export function validateComposerMessage<TFile extends FileUIPart = FileUIPart>(
+  message: ComposerMessage<TFile>,
+): { textContent: string; files: TFile[] } | null {
+  const textContent = message.text.trim()
+  const files = message.files ?? []
+  if (textContent.length === 0 && files.length === 0) return null
+  return { textContent, files }
+}
+
+export function getLatestAssistantMessage<TMessage extends UIMessage>(messages: TMessage[]): TMessage | null {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message.role === 'assistant') return message
+  }
+  return null
+}
+
+export function readLatestDataPart<TData = unknown, TMessage extends UIMessage = UIMessage>(
+  messages: TMessage[],
+  dataPartType: `data-${string}`,
+): TData | null {
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+    const message = messages[messageIndex]
+    if (message.role !== 'assistant') continue
+
+    for (let partIndex = message.parts.length - 1; partIndex >= 0; partIndex -= 1) {
+      const part = message.parts[partIndex]
+      if (part.type !== dataPartType || !('data' in part)) continue
+      return part.data as TData
+    }
+  }
+
+  return null
+}
+
+export function readLatestToolOutput<TOutput = unknown, TMessage extends UIMessage = UIMessage>(
+  messages: TMessage[],
+  toolName: string,
+): TOutput | null {
+  const toolPartType = `tool-${toolName}`
+
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+    const message = messages[messageIndex]
+    if (message.role !== 'assistant') continue
+
+    for (let partIndex = message.parts.length - 1; partIndex >= 0; partIndex -= 1) {
+      const part = message.parts[partIndex]
+      if (part.type !== toolPartType) continue
+      if (!('state' in part) || part.state !== 'output-available' || !('output' in part)) continue
+      return part.output as TOutput
+    }
+  }
+
+  return null
+}

package/src/runtime/index.ts

@@ -0,0 +1,6 @@
+export * from './active-thread-helpers'
+export * from './session-common'
+export * from './use-active-thread-session'
+export * from './use-session-messages'
+export * from './use-thread-chat'
+export * from './use-thread-management'

package/src/runtime/session-common.ts

@@ -0,0 +1,27 @@
+export type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error'
+
+export interface RuntimeLoadingState {
+  isLoading: boolean
+  isRefetching: boolean
+  hasCachedData: boolean
+}
+
+export const ACTIVE_SESSION_POLL_INTERVAL_MS = 15_000
+
+export function isRuntimeRunning(status: ChatStatus): boolean {
+  return status === 'streaming' || status === 'submitted'
+}
+
+export function buildRuntimeLoadingState(params: {
+  sessionId: string | null
+  isPendingMessages: boolean
+  isRefetchingMessages: boolean
+  hasCachedData: boolean
+  isRunning: boolean
+}): RuntimeLoadingState {
+  return {
+    isLoading: Boolean(params.sessionId) && params.isPendingMessages && !params.hasCachedData,
+    isRefetching: params.hasCachedData && params.isRefetchingMessages && !params.isRunning,
+    hasCachedData: params.hasCachedData,
+  }
+}

package/src/runtime/use-active-thread-session.ts

@@ -0,0 +1,264 @@
+import { getMessageCreatedAt } from '@lota-sdk/shared/runtime/chat-message-metadata'
+import type { FileUIPart, UIMessage } from 'ai'
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+
+import { mergeChatMessages } from '../chat/messages'
+import { getLatestAssistantMessage, validateComposerMessage } from './active-thread-helpers'
+import { buildRuntimeLoadingState, isRuntimeRunning } from './session-common'
+import type { ChatStatus, RuntimeLoadingState } from './session-common'
+import type { SessionMessagesPageResponse } from './use-session-messages'
+import { useSessionMessages } from './use-session-messages'
+import type { UseThreadChatOptions } from './use-thread-chat'
+import { useThreadChat } from './use-thread-chat'
+
+type FileMessagePart<TMessage extends UIMessage> = Extract<TMessage['parts'][number], { type: 'file' }>
+
+interface ActiveThreadLike {
+  isRunning?: boolean
+  isCompacting?: boolean
+}
+
+export interface UseActiveThreadSessionOptions<
+  TMessage extends UIMessage & { metadata?: { createdAt?: unknown } },
+  TThread extends ActiveThreadLike,
+  TFile extends FileUIPart = FileUIPart,
+  TTrackerState = never,
+> {
+  threadId: string | null
+  thread: TThread | null
+  sessionMessagesQueryKey: readonly unknown[]
+  fetchLatestPage: (threadId: string) => Promise<SessionMessagesPageResponse>
+  fetchOlderPage: (threadId: string, cursor: string) => Promise<SessionMessagesPageResponse>
+  validateMessages?: (messages: unknown[]) => Promise<TMessage[]>
+  pollIntervalMs: number
+  pollEnabled: boolean
+  threadChat: Omit<UseThreadChatOptions<TMessage>, 'threadId' | 'initialMessages' | 'onMessagesSettled'>
+  validateMessage?: (message: { text: string; files?: TFile[] }) => { textContent: string; files: TFile[] } | null
+  uploadFiles?: (params: { threadId: string; files: TFile[] }) => Promise<Array<FileMessagePart<TMessage>>>
+  buildUserMessage: (params: { textContent: string; fileParts: Array<FileMessagePart<TMessage>> }) => TMessage
+  onBeforeSend?: (params: {
+    threadId: string
+    textContent: string
+    messages: TMessage[]
+    thread: TThread | null
+  }) => Promise<void> | void
+  onMessagesUpdated?: (messages: TMessage[]) => void
+  readTrackerState?: (messages: TMessage[]) => TTrackerState | null
+  onTrackerState?: (params: { threadId: string; trackerState: TTrackerState }) => void
+  notifyError?: (message: string, error: unknown) => void
+  isThreadBusy?: boolean
+}
+
+export interface UseActiveThreadSessionReturn<TMessage extends UIMessage, TFile extends FileUIPart = FileUIPart> {
+  messages: TMessage[]
+  status: ChatStatus
+  error: Error | undefined
+  clearError: () => void
+  regenerate: () => Promise<void>
+  sendMessage: (message: { text: string; files?: TFile[] }) => Promise<void>
+  onStop: () => Promise<void>
+  threadLoadingState: RuntimeLoadingState
+  hasOlderMessages: boolean
+  isLoadingOlderMessages: boolean
+  loadOlderMessages: () => Promise<void>
+  addToolApprovalResponse: (params: { id: string; approved: boolean; reason?: string }) => void
+}
+
+export function useActiveThreadSession<
+  TMessage extends UIMessage & { metadata?: { createdAt?: unknown } },
+  TThread extends ActiveThreadLike,
+  TFile extends FileUIPart = FileUIPart,
+  TTrackerState = never,
+>({
+  threadId,
+  thread,
+  sessionMessagesQueryKey,
+  fetchLatestPage,
+  fetchOlderPage,
+  validateMessages,
+  pollIntervalMs,
+  pollEnabled,
+  threadChat,
+  validateMessage = validateComposerMessage,
+  uploadFiles,
+  buildUserMessage,
+  onBeforeSend,
+  onMessagesUpdated,
+  readTrackerState,
+  onTrackerState,
+  notifyError,
+  isThreadBusy: externalThreadBusy = false,
+}: UseActiveThreadSessionOptions<TMessage, TThread, TFile, TTrackerState>): UseActiveThreadSessionReturn<
+  TMessage,
+  TFile
+> {
+  const {
+    messages: sessionMessages,
+    isLoading: isLoadingMessages,
+    hasOlderMessages,
+    isLoadingOlderMessages,
+    loadOlderMessages,
+    refreshLatestPage,
+  } = useSessionMessages<TMessage>({
+    sessionId: threadId,
+    queryKey: sessionMessagesQueryKey,
+    fetchLatestPage,
+    fetchOlderPage,
+    pollIntervalMs,
+    pollEnabled,
+    validateMessages,
+  })
+
+  const {
+    messages,
+    status: chatStatus,
+    error: chatError,
+    clearError,
+    sendMessage: sendChatMessage,
+    regenerate: regenerateChat,
+    stop: stopChatStream,
+    setMessages,
+    addToolApprovalResponse,
+  } = useThreadChat<TMessage>({
+    ...threadChat,
+    threadId,
+    initialMessages: sessionMessages,
+    onMessagesSettled: refreshLatestPage,
+  })
+
+  const hasRemoteRun = Boolean(thread?.isRunning)
+  const status = hasRemoteRun && !isRuntimeRunning(chatStatus) ? 'streaming' : (chatStatus as ChatStatus)
+  const error = hasRemoteRun ? undefined : chatError
+  const isRunning = isRuntimeRunning(status)
+  const isThreadBusy = isRunning || Boolean(thread?.isCompacting) || externalThreadBusy
+
+  const lastSyncedRef = useRef(sessionMessages)
+  useEffect(() => {
+    if (isRunning && messages.length > 0) return
+    if (lastSyncedRef.current === sessionMessages) return
+    lastSyncedRef.current = sessionMessages
+    if (sessionMessages.length === 0) return
+
+    const latestStreamedAssistant = getLatestAssistantMessage(messages)
+    const latestPersistedAssistant = getLatestAssistantMessage(sessionMessages)
+    const persistedMessageIds = new Set(sessionMessages.map((message) => message.id))
+    const hasPersistedLatestStreamedMessage = latestStreamedAssistant
+      ? persistedMessageIds.has(latestStreamedAssistant.id)
+      : true
+    const hasPersistedCaughtUpByTimestamp =
+      latestStreamedAssistant && latestPersistedAssistant
+        ? getMessageCreatedAt(latestPersistedAssistant, { fallback: 0 }) >=
+          getMessageCreatedAt(latestStreamedAssistant, { fallback: 0 })
+        : false
+
+    if (hasPersistedLatestStreamedMessage || hasPersistedCaughtUpByTimestamp) {
+      setMessages(sessionMessages)
+      return
+    }
+
+    setMessages(mergeChatMessages(messages, sessionMessages))
+  }, [isRunning, messages, sessionMessages, setMessages])
+
+  useEffect(() => {
+    onMessagesUpdated?.(messages)
+  }, [messages, onMessagesUpdated])
+
+  useEffect(() => {
+    if (!threadId || !readTrackerState || !onTrackerState) return
+
+    const trackerState = readTrackerState(messages)
+    if (trackerState === null) return
+
+    onTrackerState({ threadId, trackerState })
+  }, [messages, onTrackerState, readTrackerState, threadId])
+
+  const dispatchMessageNow = useCallback(
+    async (message: { text: string; files?: TFile[] }): Promise<boolean> => {
+      if (!threadId) {
+        notifyError?.('No thread selected.', new Error('No thread selected.'))
+        return false
+      }
+
+      const validated = validateMessage(message)
+      if (!validated) {
+        notifyError?.('Message must include text or at least one attachment.', new Error('Message is empty.'))
+        return false
+      }
+
+      const { textContent, files } = validated
+      let fileParts: Array<FileMessagePart<TMessage>> = []
+      if (files.length > 0 && uploadFiles) {
+        try {
+          fileParts = await uploadFiles({ threadId, files })
+        } catch (error) {
+          notifyError?.('Failed to prepare attachments.', error)
+          return false
+        }
+      }
+
+      try {
+        await onBeforeSend?.({ threadId, textContent, messages, thread })
+        await sendChatMessage(buildUserMessage({ textContent, fileParts }))
+        return true
+      } catch (error) {
+        notifyError?.('Failed to send message.', error)
+        return false
+      }
+    },
+    [
+      buildUserMessage,
+      messages,
+      notifyError,
+      onBeforeSend,
+      sendChatMessage,
+      thread,
+      threadId,
+      uploadFiles,
+      validateMessage,
+    ],
+  )
+
+  const sendMessage = useCallback(
+    async (message: { text: string; files?: TFile[] }) => {
+      if (!threadId || isThreadBusy) return
+      await dispatchMessageNow(message)
+    },
+    [dispatchMessageNow, isThreadBusy, threadId],
+  )
+
+  const regenerate = useCallback(async () => {
+    try {
+      await regenerateChat()
+    } catch (error) {
+      notifyError?.('Failed to regenerate message.', error)
+    }
+  }, [notifyError, regenerateChat])
+
+  const hasCachedData = messages.length > 0 || sessionMessages.length > 0
+  const threadLoadingState = useMemo(
+    () =>
+      buildRuntimeLoadingState({
+        sessionId: threadId,
+        isPendingMessages: isLoadingMessages,
+        isRefetchingMessages: false,
+        hasCachedData,
+        isRunning: isThreadBusy,
+      }),
+    [hasCachedData, isLoadingMessages, isThreadBusy, threadId],
+  )
+
+  return {
+    messages,
+    status,
+    error,
+    clearError,
+    regenerate,
+    sendMessage,
+    onStop: stopChatStream,
+    threadLoadingState,
+    hasOlderMessages,
+    isLoadingOlderMessages,
+    loadOlderMessages,
+    addToolApprovalResponse,
+  }
+}