@lota-sdk/ui 0.2.3 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/ui",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -18,14 +18,14 @@
     "lint": "bunx oxlint --fix -c ../oxlint.config.ts src",
     "format": "bunx oxfmt src",
     "typecheck": "bunx tsgo --noEmit",
-    "test:unit": "bun test ../tests/unit/ui"
+    "test:unit": "bun run scripts/test-unit.ts"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@lota-sdk/shared": "0.2.3",
+    "@lota-sdk/shared": "0.3.1",
     "ai": "^6.0.145"
   },
   "peerDependencies": {

package/src/chat/attachments.ts

@@ -14,7 +14,15 @@ type UploadedAttachmentPayload = {
   url: string
 }
 
+function hasLocalFile(value: FileUIPart): value is FileUIPart & { file: File } {
+  return 'file' in value && value.file instanceof File
+}
+
 async function toUploadFile(filePart: FileUIPart): Promise<File> {
+  if (hasLocalFile(filePart)) {
+    return filePart.file
+  }
+
   if (!filePart.url) {
     throw new Error('Attachment payload is missing file data.')
   }

package/src/chat/index.ts

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

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

@@ -1,8 +1,8 @@
-import type { FileUIPart, UIMessage } from 'ai'
+import type { UIMessage } from 'ai'
 
-export type ComposerMessage<TFile extends FileUIPart = FileUIPart> = { text: string; files?: TFile[] }
+export type ComposerMessage<TFile = File> = { text: string; files?: TFile[] }
 
-export function validateComposerMessage<TFile extends FileUIPart = FileUIPart>(
+export function validateComposerMessage<TFile = File>(
   message: ComposerMessage<TFile>,
 ): { textContent: string; files: TFile[] } | null {
   const textContent = message.text.trim()

package/src/runtime/index.ts

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

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

@@ -1,5 +1,5 @@
 import { getMessageCreatedAt } from '@lota-sdk/shared'
-import type { FileUIPart, UIMessage } from 'ai'
+import type { UIMessage } from 'ai'
 import { useCallback, useEffect, useMemo, useRef } from 'react'
 
 import { mergeChatMessages } from '../chat/messages'
@@ -21,7 +21,7 @@ interface ActiveThreadLike {
 export interface UseActiveThreadSessionOptions<
   TMessage extends UIMessage & { metadata?: { createdAt?: unknown } },
   TThread extends ActiveThreadLike,
-  TFile extends FileUIPart = FileUIPart,
+  TFile = File,
   TTrackerState = never,
 > {
   threadId: string | null
@@ -49,7 +49,7 @@ export interface UseActiveThreadSessionOptions<
   isThreadBusy?: boolean
 }
 
-export interface UseActiveThreadSessionReturn<TMessage extends UIMessage, TFile extends FileUIPart = FileUIPart> {
+export interface UseActiveThreadSessionReturn<TMessage extends UIMessage, TFile = File> {
   messages: TMessage[]
   status: ChatStatus
   error: Error | undefined
@@ -67,7 +67,7 @@ export interface UseActiveThreadSessionReturn<TMessage extends UIMessage, TFile
 export function useActiveThreadSession<
   TMessage extends UIMessage & { metadata?: { createdAt?: unknown } },
   TThread extends ActiveThreadLike,
-  TFile extends FileUIPart = FileUIPart,
+  TFile = File,
   TTrackerState = never,
 >({
   threadId,

package/src/runtime/use-thread-chat.ts

@@ -58,6 +58,9 @@ export function useThreadChat<UI_MESSAGE extends UIMessage>({
   const onDataRef = useRef(onData)
   const onMessagesSettledRef = useRef(onMessagesSettled)
   const setThreadRunningStateRef = useRef(setThreadRunningState)
+  const attemptedResumeForChatRef = useRef<string | null>(null)
+  const skipNextResumeForChatRef = useRef<string | null>(null)
+  const locallyStartedChatRef = useRef<string | null>(null)
 
   useEffect(() => {
     onDataRef.current = onData
@@ -78,8 +81,8 @@ export function useThreadChat<UI_MESSAGE extends UIMessage>({
     status,
     error,
     clearError,
-    sendMessage,
-    regenerate,
+    sendMessage: sendChatMessage,
+    regenerate: regenerateChat,
     stop: stopChatStream,
     setMessages,
     addToolApprovalResponse,
@@ -98,10 +101,17 @@ export function useThreadChat<UI_MESSAGE extends UIMessage>({
     experimental_throttle: experimentalThrottle,
     sendAutomaticallyWhen,
     onFinish: () => {
+      if (locallyStartedChatRef.current === chatId) {
+        skipNextResumeForChatRef.current = chatId
+        locallyStartedChatRef.current = null
+      }
       setThreadRunningStateRef.current?.(false)
       onMessagesSettledRef.current?.()
     },
     onError: (error) => {
+      if (locallyStartedChatRef.current === chatId) {
+        locallyStartedChatRef.current = null
+      }
       if (!(error instanceof Error && error.name === 'AbortError')) {
         notifyError?.('Chat stream failed.', toError(error))
       }
@@ -113,13 +123,54 @@ export function useThreadChat<UI_MESSAGE extends UIMessage>({
   // Manual resume with ref guard — prevents React StrictMode double-fire.
   // We do NOT pass `resume` to useChat because the AI SDK's built-in effect
   // has no StrictMode guard, causing two concurrent GET streams.
-  const resumedForChatRef = useRef<string | null>(null)
   useEffect(() => {
-    if (!resume || status !== 'ready' || resumedForChatRef.current === chatId) return
-    resumedForChatRef.current = chatId
+    if (!resume || status !== 'ready') return
+    if (skipNextResumeForChatRef.current === chatId) {
+      skipNextResumeForChatRef.current = null
+      return
+    }
+    if (attemptedResumeForChatRef.current === chatId) return
+    attemptedResumeForChatRef.current = chatId
     void resumeStream()
   }, [resume, status, chatId, resumeStream])
 
+  useEffect(() => {
+    if (status === 'ready' && resume) return
+    if (attemptedResumeForChatRef.current === chatId) {
+      attemptedResumeForChatRef.current = null
+    }
+  }, [chatId, resume, status])
+
+  const sendMessage = useCallback<UseChatHelpers<UI_MESSAGE>['sendMessage']>(
+    async (message, options) => {
+      locallyStartedChatRef.current = chatId
+      try {
+        return await sendChatMessage(message, options)
+      } catch (error) {
+        if (locallyStartedChatRef.current === chatId) {
+          locallyStartedChatRef.current = null
+        }
+        throw error
+      }
+    },
+    [chatId, sendChatMessage],
+  )
+
+  const regenerate = useCallback<UseChatHelpers<UI_MESSAGE>['regenerate']>(
+    async (options) => {
+      locallyStartedChatRef.current = chatId
+      try {
+        return await regenerateChat(options)
+      } catch (error) {
+        if (locallyStartedChatRef.current === chatId) {
+          locallyStartedChatRef.current = null
+        }
+        throw error
+      }
+    },
+    [chatId, regenerateChat],
+  )
+
   const stop = useCallback(async () => {
     const stopRequest = threadId && stopRemoteRun ? stopRemoteRun(threadId) : Promise.resolve(null)
     const [stopResponse] = await Promise.allSettled([stopRequest, stopChatStream()])

package/src/runtime/use-thread-management.ts

@@ -5,9 +5,8 @@ const PLACEHOLDER_THREAD_PREFIX = '__placeholder_'
 export interface ThreadManagementItem<TAgentId extends string = string> {
   threadId: string
   title: string
-  status: 'regular' | 'archived'
-  mode: 'direct' | 'group'
-  core: boolean
+  status: 'active' | 'archived'
+  type: string
   isMutable: boolean
   agentId?: TAgentId | null
 }
@@ -63,11 +62,7 @@ export function findReusableRegularGroupThreadId<TThread extends ThreadManagemen
   defaultThreadTitle: string,
 ): string | null {
   const draft = threads.find(
-    (thread) =>
-      thread.mode === 'group' &&
-      !thread.core &&
-      thread.status === 'regular' &&
-      thread.title.trim() === defaultThreadTitle,
+    (thread) => thread.type === 'group' && thread.status === 'active' && thread.title.trim() === defaultThreadTitle,
   )
 
   return draft?.threadId ?? null
@@ -151,7 +146,7 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
         ? (() => {
             const agentId = threadId.slice(placeholderThreadPrefix.length) as TAgentId
             const directThread = allThreadsRef.current.find(
-              (thread) => thread.mode === 'direct' && thread.agentId === agentId,
+              (thread) => thread.type === 'default' && thread.agentId === agentId,
             )
             return directThread?.threadId
           })()
@@ -160,7 +155,7 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
       if (!resolvedThreadId) return
 
       const target = allThreadsRef.current.find((thread) => thread.threadId === resolvedThreadId)
-      const nextAgentId = target?.mode === 'direct' && target.agentId ? target.agentId : null
+      const nextAgentId = target?.type === 'default' && target.agentId ? target.agentId : null
       setCurrentThreadId(resolvedThreadId)
       setSelectedAgentId(nextAgentId)
     },
@@ -243,13 +238,14 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
       const preferredThread =
         primaryDirectAgentId === undefined
           ? threads[0]
-          : (threads.find((thread) => thread.mode === 'direct' && thread.agentId === primaryDirectAgentId) ??
+          : (threads.find((thread) => thread.type === 'default' && thread.agentId === primaryDirectAgentId) ??
             threads[0])
       setCurrentThreadId(preferredThread.threadId)
-      setSelectedAgentId(preferredThread.mode === 'direct' && preferredThread.agentId ? preferredThread.agentId : null)
+      setSelectedAgentId(preferredThread.type === 'default' && preferredThread.agentId ? preferredThread.agentId : null)
       return
     }
 
+    if (!enabled) return
     if (isCreatingThreadRef.current) return
     if (isCreatingThread) return
     isCreatingThreadRef.current = true
@@ -262,6 +258,7 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
         isCreatingThreadRef.current = false
       })
   }, [
+    enabled,
     currentThreadId,
     handleCreateNewThread,
     isCreatingThread,
@@ -276,7 +273,7 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
     if (!currentThreadId?.startsWith(placeholderThreadPrefix)) return
 
     const agentId = currentThreadId.slice(placeholderThreadPrefix.length) as TAgentId
-    const directThread = allThreads.find((thread) => thread.mode === 'direct' && thread.agentId === agentId)
+    const directThread = allThreads.find((thread) => thread.type === 'default' && thread.agentId === agentId)
     if (!directThread) return
 
     setCurrentThreadId(directThread.threadId)
@@ -286,7 +283,7 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
   useEffect(() => {
     if (currentThreadId !== null || selectedAgentId === null) return
 
-    const directThread = allThreads.find((thread) => thread.mode === 'direct' && thread.agentId === selectedAgentId)
+    const directThread = allThreads.find((thread) => thread.type === 'default' && thread.agentId === selectedAgentId)
     if (!directThread) return
 
     setCurrentThreadId(directThread.threadId)
@@ -303,7 +300,7 @@ export function useThreadManagement<TThread extends ThreadManagementItem<TAgentI
     const activeThread = allThreads.find((thread) => thread.threadId === currentThreadId)
     if (!activeThread) return
 
-    const expectedAgentId = activeThread.mode === 'direct' && activeThread.agentId ? activeThread.agentId : null
+    const expectedAgentId = activeThread.type === 'default' && activeThread.agentId ? activeThread.agentId : null
     if (selectedAgentId !== expectedAgentId) {
       setSelectedAgentId(expectedAgentId)
     }

package/src/tools/execution-plan.ts

@@ -1,4 +1,4 @@
-import type { SerializablePlanNode } from '@lota-sdk/shared'
+import type { ExecutionPlanNodeSummary } from '@lota-sdk/shared'
 import { getLatestExecutionPlanResult } from '@lota-sdk/shared'
 
 export { getLatestExecutionPlanResult }
@@ -33,14 +33,13 @@ export function getExecutionPlanStatusLabel(status: string | null | undefined):
 }
 
 export function getExecutionPlanOwnerLabel(
-  node: SerializablePlanNode,
+  node: ExecutionPlanNodeSummary,
   displayNameByOwnerRef: Record<string, string> = {},
 ): string {
-  if (node.owner.executorType === 'agent' && node.owner.ref in displayNameByOwnerRef) {
-    return displayNameByOwnerRef[node.owner.ref]
+  if (node.ownerRef in displayNameByOwnerRef) {
+    return displayNameByOwnerRef[node.ownerRef]
   }
-  if (node.owner.executorType === 'user') return 'User'
-  return node.owner.ref
+  return node.ownerRef
 }
 
 export function buildExecutionPlanToolViewModel(params: { input: unknown; isRunning: boolean; output: unknown }) {
@@ -54,12 +53,11 @@ export function buildExecutionPlanToolViewModel(params: { input: unknown; isRunn
       ? params.input.title.trim()
       : ''
   const title = plan && plan.title.trim() ? plan.title.trim() : inputTitle || 'Execution run'
-  const completedCount = plan ? plan.progress.completed + plan.progress.partial : 0
+  const completedCount = plan ? plan.progress.completed : 0
 
   return {
     actionLabel: getExecutionPlanActionLabel(result?.action ?? 'none', params.isRunning),
     hasPlan: plan !== null,
-    latestEvent: plan ? plan.recentEvents.at(-1)?.message.trim() : undefined,
     plan,
     progressSummary: plan ? `${completedCount}/${plan.progress.total} complete` : 'No active execution run',
     result,

package/src/chat/transport.ts

@@ -1,8 +0,0 @@
-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/runtime/use-lota-chat.ts

@@ -1,13 +0,0 @@
-import type { UIMessage } from 'ai'
-
-import type { UseThreadChatOptions, UseThreadChatReturn } from './use-thread-chat'
-import { useThreadChat } from './use-thread-chat'
-
-export type UseLotaChatOptions<UI_MESSAGE extends UIMessage> = UseThreadChatOptions<UI_MESSAGE>
-export type UseLotaChatReturn<UI_MESSAGE extends UIMessage> = UseThreadChatReturn<UI_MESSAGE>
-
-export function useLotaChat<UI_MESSAGE extends UIMessage>(
-  options: UseLotaChatOptions<UI_MESSAGE>,
-): UseLotaChatReturn<UI_MESSAGE> {
-  return useThreadChat(options)
-}