@swarmclawai/swarmclaw 0.5.3 → 0.6.2

package/src/stores/use-chat-store.ts

@@ -68,6 +68,10 @@ interface ChatState {
   pendingImage: PendingFile | null
   setPendingImage: (img: PendingFile | null) => void
 
+  // Reply-to
+  replyingTo: { message: Message; index: number } | null
+  setReplyingTo: (reply: { message: Message; index: number } | null) => void
+
   devServer: DevServerStatus | null
   setDevServer: (ds: DevServerStatus | null) => void
 
@@ -83,12 +87,31 @@ interface ChatState {
   sendHeartbeat: (sessionId: string) => Promise<void>
   stopStreaming: () => void
 
+  // Thinking/reasoning text during streaming
+  thinkingText: string
+  thinkingStartTime: number
+
   // Rich trace blocks during streaming (F13)
   streamTraces: ChatTraceBlock[]
 
   // Voice conversation
   voiceConversationActive: boolean
   onStreamEvent: ((event: { t: string; text?: string }) => void) | null
+
+  // Message queue (send while streaming)
+  queuedMessages: string[]
+  addQueuedMessage: (text: string) => void
+  removeQueuedMessage: (index: number) => void
+  shiftQueuedMessage: () => string | undefined
+
+  // Context clearing
+  clearContext: () => Promise<void>
+
+  // Pagination
+  hasMoreMessages: boolean
+  loadingMore: boolean
+  totalMessages: number
+  loadMoreMessages: () => Promise<void>
 }
 
 // Module-level cadence interval (not in state to avoid re-renders)
@@ -116,7 +139,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
   displayText: '',
   agentStatus: null,
   messages: [],
-  setMessages: (msgs) => set({ messages: msgs, toolEvents: [] }),
+  setMessages: (msgs) => set({ messages: msgs, toolEvents: [], hasMoreMessages: false, totalMessages: msgs.length }),
   toolEvents: [],
   clearToolEvents: () => set({ toolEvents: [] }),
   lastUsage: null,
@@ -128,9 +151,21 @@ export const useChatStore = create<ChatState>((set, get) => ({
     setSoundEnabled(next)
     set({ soundEnabled: next })
   },
+  thinkingText: '',
+  thinkingStartTime: 0,
   streamTraces: [],
   voiceConversationActive: false,
   onStreamEvent: null,
+  queuedMessages: [],
+  addQueuedMessage: (text) => set((s) => ({ queuedMessages: [...s.queuedMessages, text] })),
+  removeQueuedMessage: (index) => set((s) => ({ queuedMessages: s.queuedMessages.filter((_, i) => i !== index) })),
+  shiftQueuedMessage: () => {
+    const q = get().queuedMessages
+    if (!q.length) return undefined
+    const next = q[0]
+    set({ queuedMessages: q.slice(1) })
+    return next
+  },
 
   pendingFiles: [],
   addPendingFile: (f) => set((s) => ({ pendingFiles: [...s.pendingFiles, f] })),
@@ -141,6 +176,10 @@ export const useChatStore = create<ChatState>((set, get) => ({
   get pendingImage() { const files = get().pendingFiles; return files.length ? files[0] : null },
   setPendingImage: (img) => set({ pendingFiles: img ? [img] : [] }),
 
+  // Reply-to
+  replyingTo: null,
+  setReplyingTo: (reply) => set({ replyingTo: reply }),
+
   previewContent: null,
   setPreviewContent: (content) => set({ previewContent: content }),
 
@@ -150,7 +189,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
   setDebugOpen: (open) => set({ debugOpen: open }),
 
   sendMessage: async (text: string) => {
-    const { pendingFiles } = get()
+    const { pendingFiles, replyingTo } = get()
     if ((!text.trim() && !pendingFiles.length) || get().streaming) return
     const sessionId = useAppStore.getState().currentSessionId
     if (!sessionId) return
@@ -162,6 +201,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
     const attachedFiles = pendingFiles.length > 1
       ? pendingFiles.map((f) => f.path)
       : undefined
+    const replyToId = replyingTo?.message?.replyToId ? undefined : replyingTo?.message ? `msg-${replyingTo.index}` : undefined
 
     const userMsg: Message = {
       role: 'user',
@@ -170,6 +210,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       imagePath,
       imageUrl,
       attachedFiles,
+      ...(replyToId ? { replyToId } : {}),
     }
     clearCadence()
     set((s) => ({
@@ -180,8 +221,11 @@ export const useChatStore = create<ChatState>((set, get) => ({
       streamToolName: '',
       displayText: '',
       agentStatus: null,
+      thinkingText: '',
+      thinkingStartTime: Date.now(),
       messages: [...s.messages, userMsg],
       pendingFiles: [],
+      replyingTo: null,
       toolEvents: [],
       lastUsage: null,
     }))
@@ -241,7 +285,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
           set({ displayText: fullText })
         }
       } else if (event.t === 'md') {
-        // Parse metadata events (usage/run/queue). Ignore unknown keys.
+        // Parse metadata events (usage/run/queue/thinking). Ignore unknown keys.
         try {
           const meta = JSON.parse(event.text || '{}')
           if (meta.usage) {
@@ -250,6 +294,9 @@ export const useChatStore = create<ChatState>((set, get) => ({
           if (meta.suggestions) {
             suggestions = meta.suggestions
           }
+          if (meta.thinking && typeof meta.thinking === 'string') {
+            set({ thinkingText: meta.thinking })
+          }
         } catch {
           // Ignore non-JSON metadata payloads.
         }
@@ -296,6 +343,8 @@ export const useChatStore = create<ChatState>((set, get) => ({
           set({ streamText: fullText })
           if (get().soundEnabled) playError()
         }
+      } else if (event.t === 'thinking') {
+        set((s) => ({ thinkingText: s.thinkingText + (event.text || '') }))
       } else if (event.t === 'status') {
         try {
           const parsed = JSON.parse(event.text || '{}')
@@ -306,17 +355,19 @@ export const useChatStore = create<ChatState>((set, get) => ({
       } else if (event.t === 'done') {
         // done
       }
-    }, attachedFiles)
+    }, attachedFiles, { replyToId })
 
     clearCadence()
     if (get().soundEnabled && soundFiredStart) playStreamEnd()
     if (fullText.trim()) {
       const currentToolEvents = get().toolEvents
+      const thinkingSnapshot = get().thinkingText || undefined
       const assistantMsg: Message = {
         role: 'assistant',
         text: fullText.trim(),
         time: Date.now(),
         kind: 'chat',
+        thinking: thinkingSnapshot,
         toolEvents: currentToolEvents.length ? currentToolEvents.map(e => ({
           name: e.name,
           input: e.input,
@@ -333,13 +384,21 @@ export const useChatStore = create<ChatState>((set, get) => ({
         displayText: '',
         streamPhase: 'thinking' as const,
         streamToolName: '',
+        thinkingText: '',
+        thinkingStartTime: 0,
       }))
       if (get().ttsEnabled && !get().voiceConversationActive) speak(fullText)
     } else {
-      set({ streaming: false, streamingSessionId: null, streamText: '', displayText: '', streamPhase: 'thinking' as const, streamToolName: '' })
+      set({ streaming: false, streamingSessionId: null, streamText: '', displayText: '', streamPhase: 'thinking' as const, streamToolName: '', thinkingText: '', thinkingStartTime: 0 })
     }
 
     useAppStore.getState().loadSessions()
+
+    // Auto-dequeue: if there are queued messages, send the next one
+    const nextQueued = get().shiftQueuedMessage()
+    if (nextQueued) {
+      setTimeout(() => get().sendMessage(nextQueued), 100)
+    }
   },
 
   editAndResend: async (messageIndex: number, newText: string) => {
@@ -480,6 +539,55 @@ export const useChatStore = create<ChatState>((set, get) => ({
     useAppStore.getState().loadSessions()
   },
 
+  clearContext: async () => {
+    const sessionId = useAppStore.getState().currentSessionId
+    if (!sessionId || get().streaming) return
+    const marker: Message = { role: 'user', text: '', kind: 'context-clear', time: Date.now() }
+    set((s) => ({ messages: [...s.messages, marker] }))
+    try {
+      const key = getStoredAccessKey()
+      await fetch(`/api/sessions/${sessionId}/messages`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...(key ? { 'X-Access-Key': key } : {}) },
+        body: JSON.stringify({ kind: 'context-clear' }),
+      })
+    } catch {
+      // Ignore — marker is already in local state
+    }
+  },
+
+  hasMoreMessages: false,
+  loadingMore: false,
+  totalMessages: 0,
+  loadMoreMessages: async () => {
+    const { messages, loadingMore, hasMoreMessages, totalMessages } = get()
+    if (loadingMore || !hasMoreMessages) return
+    const sessionId = useAppStore.getState().currentSessionId
+    if (!sessionId) return
+    set({ loadingMore: true })
+    try {
+      const key = getStoredAccessKey()
+      // Find the earliest message's original index (startIndex tracked on initial load)
+      const currentStartIndex = totalMessages - messages.length
+      const res = await fetch(`/api/sessions/${sessionId}/messages?limit=100&before=${currentStartIndex}`, {
+        headers: key ? { 'X-Access-Key': key } : undefined,
+      })
+      if (res.ok) {
+        const data = await res.json() as { messages: Message[]; total: number; hasMore: boolean; startIndex: number }
+        set((s) => ({
+          messages: [...data.messages, ...s.messages],
+          hasMoreMessages: data.hasMore,
+          totalMessages: data.total,
+          loadingMore: false,
+        }))
+      } else {
+        set({ loadingMore: false })
+      }
+    } catch {
+      set({ loadingMore: false })
+    }
+  },
+
   stopStreaming: async () => {
     const sessionId = useAppStore.getState().currentSessionId
     if (sessionId) {

package/src/stores/use-chatroom-store.ts

@@ -0,0 +1,276 @@
+'use client'
+
+import { create } from 'zustand'
+import { api, getStoredAccessKey } from '@/lib/api-client'
+import type { Chatroom, ChatroomMessage, SSEEvent } from '@/types'
+import type { PendingFile } from '@/stores/use-chat-store'
+
+interface ToolEvent {
+  name: string
+  input: string
+  output?: string
+}
+
+interface StreamingAgent {
+  text: string
+  name: string
+  error?: string
+  toolEvents: ToolEvent[]
+}
+
+interface ChatroomState {
+  chatrooms: Record<string, Chatroom>
+  currentChatroomId: string | null
+  streaming: boolean
+  streamingAgents: Map<string, StreamingAgent>
+  chatroomSheetOpen: boolean
+  editingChatroomId: string | null
+
+  // File uploads
+  pendingFiles: PendingFile[]
+  addPendingFile: (f: PendingFile) => void
+  removePendingFile: (index: number) => void
+  clearPendingFiles: () => void
+
+  // Reply-to
+  replyingTo: ChatroomMessage | null
+  setReplyingTo: (msg: ChatroomMessage | null) => void
+
+  loadChatrooms: () => Promise<void>
+  createChatroom: (data: { name: string; description?: string; agentIds?: string[]; chatMode?: 'sequential' | 'parallel'; autoAddress?: boolean }) => Promise<Chatroom>
+  updateChatroom: (id: string, data: Partial<Chatroom>) => Promise<void>
+  deleteChatroom: (id: string) => Promise<void>
+  setCurrentChatroom: (id: string | null) => void
+  sendMessage: (text: string) => Promise<void>
+  toggleReaction: (messageId: string, emoji: string) => Promise<void>
+  togglePin: (messageId: string) => Promise<void>
+  addMember: (agentId: string) => Promise<void>
+  removeMember: (agentId: string) => Promise<void>
+  setChatroomSheetOpen: (open: boolean) => void
+  setEditingChatroomId: (id: string | null) => void
+}
+
+export const useChatroomStore = create<ChatroomState>((set, get) => ({
+  chatrooms: {},
+  currentChatroomId: null,
+  streaming: false,
+  streamingAgents: new Map(),
+  chatroomSheetOpen: false,
+  editingChatroomId: null,
+
+  // File uploads
+  pendingFiles: [],
+  addPendingFile: (f) => set((s) => ({ pendingFiles: [...s.pendingFiles, f] })),
+  removePendingFile: (index) => set((s) => ({ pendingFiles: s.pendingFiles.filter((_, i) => i !== index) })),
+  clearPendingFiles: () => set({ pendingFiles: [] }),
+
+  // Reply-to
+  replyingTo: null,
+  setReplyingTo: (msg) => set({ replyingTo: msg }),
+
+  loadChatrooms: async () => {
+    const chatrooms = await api<Record<string, Chatroom>>('GET', '/chatrooms')
+    set({ chatrooms })
+  },
+
+  createChatroom: async (data) => {
+    const chatroom = await api<Chatroom>('POST', '/chatrooms', data)
+    set((s) => ({ chatrooms: { ...s.chatrooms, [chatroom.id]: chatroom } }))
+    return chatroom
+  },
+
+  updateChatroom: async (id, data) => {
+    const chatroom = await api<Chatroom>('PUT', `/chatrooms/${id}`, data)
+    set((s) => ({ chatrooms: { ...s.chatrooms, [id]: chatroom } }))
+  },
+
+  deleteChatroom: async (id) => {
+    await api('DELETE', `/chatrooms/${id}`)
+    set((s) => {
+      const chatrooms = { ...s.chatrooms }
+      delete chatrooms[id]
+      return {
+        chatrooms,
+        currentChatroomId: s.currentChatroomId === id ? null : s.currentChatroomId,
+      }
+    })
+  },
+
+  setCurrentChatroom: (id) => set({ currentChatroomId: id }),
+
+  sendMessage: async (text) => {
+    const { currentChatroomId, streaming, pendingFiles, replyingTo } = get()
+    if (!currentChatroomId || streaming || (!text.trim() && !pendingFiles.length)) return
+
+    set({ streaming: true, streamingAgents: new Map(), pendingFiles: [], replyingTo: null })
+
+    const imagePath = pendingFiles.length > 0 && pendingFiles[0].file.type.startsWith('image/')
+      ? pendingFiles[0].path
+      : undefined
+    const attachedFiles = pendingFiles.length > 0
+      ? pendingFiles.map((f) => f.path)
+      : undefined
+
+    const key = getStoredAccessKey()
+    try {
+      const res = await fetch(`/api/chatrooms/${currentChatroomId}/chat`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(key ? { 'X-Access-Key': key } : {}),
+        },
+        body: JSON.stringify({
+          text,
+          ...(imagePath ? { imagePath } : {}),
+          ...(attachedFiles ? { attachedFiles } : {}),
+          ...(replyingTo ? { replyToId: replyingTo.id } : {}),
+        }),
+      })
+
+      if (!res.ok || !res.body) {
+        set({ streaming: false })
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buf = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buf += decoder.decode(value, { stream: true })
+        const lines = buf.split('\n')
+        buf = lines.pop() || ''
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue
+          try {
+            const event = JSON.parse(line.slice(6)) as SSEEvent
+            const agentId = event.agentId
+            const agentName = event.agentName
+
+            if (event.t === 'cr_agent_start' && agentId && agentName) {
+              set((s) => {
+                const agents = new Map(s.streamingAgents)
+                agents.set(agentId, { text: '', name: agentName, toolEvents: [] })
+                return { streamingAgents: agents }
+              })
+            } else if (event.t === 'tool_call' && agentId && event.toolName) {
+              set((s) => {
+                const agents = new Map(s.streamingAgents)
+                const existing = agents.get(agentId)
+                if (existing) {
+                  agents.set(agentId, {
+                    ...existing,
+                    toolEvents: [...existing.toolEvents, { name: event.toolName!, input: event.toolInput || '' }],
+                  })
+                }
+                return { streamingAgents: agents }
+              })
+            } else if (event.t === 'tool_result' && agentId) {
+              set((s) => {
+                const agents = new Map(s.streamingAgents)
+                const existing = agents.get(agentId)
+                if (existing && existing.toolEvents.length > 0) {
+                  const updatedEvents = [...existing.toolEvents]
+                  const last = updatedEvents[updatedEvents.length - 1]
+                  updatedEvents[updatedEvents.length - 1] = { ...last, output: event.toolOutput || event.text || '' }
+                  agents.set(agentId, { ...existing, toolEvents: updatedEvents })
+                }
+                return { streamingAgents: agents }
+              })
+            } else if (event.t === 'd' && agentId && event.text) {
+              set((s) => {
+                const agents = new Map(s.streamingAgents)
+                const existing = agents.get(agentId)
+                if (existing) {
+                  agents.set(agentId, { ...existing, text: existing.text + event.text })
+                }
+                return { streamingAgents: agents }
+              })
+            } else if (event.t === 'err' && agentId && event.text) {
+              set((s) => {
+                const agents = new Map(s.streamingAgents)
+                const existing = agents.get(agentId)
+                if (existing) {
+                  agents.set(agentId, { ...existing, error: event.text })
+                }
+                return { streamingAgents: agents }
+              })
+            } else if (event.t === 'cr_agent_done' && agentId) {
+              const currentAgent = get().streamingAgents.get(agentId)
+              if (currentAgent?.error) {
+                setTimeout(() => {
+                  set((s) => {
+                    const agents = new Map(s.streamingAgents)
+                    agents.delete(agentId)
+                    return { streamingAgents: agents }
+                  })
+                }, 4000)
+              } else {
+                set((s) => {
+                  const agents = new Map(s.streamingAgents)
+                  agents.delete(agentId)
+                  return { streamingAgents: agents }
+                })
+              }
+              try {
+                const { currentChatroomId: cid } = get()
+                if (cid) {
+                  const chatroom = await api<Chatroom>('GET', `/chatrooms/${cid}`)
+                  set((s) => ({ chatrooms: { ...s.chatrooms, [cid]: chatroom } }))
+                }
+              } catch { /* will catch on next WS push */ }
+            } else if (event.t === 'done') {
+              break
+            }
+          } catch {
+            // skip malformed
+          }
+        }
+      }
+    } finally {
+      set({ streaming: false, streamingAgents: new Map() })
+      try {
+        const { currentChatroomId: cid } = get()
+        if (cid) {
+          const chatroom = await api<Chatroom>('GET', `/chatrooms/${cid}`)
+          set((s) => ({ chatrooms: { ...s.chatrooms, [cid]: chatroom } }))
+        }
+      } catch { /* ignore */ }
+    }
+  },
+
+  toggleReaction: async (messageId, emoji) => {
+    const { currentChatroomId } = get()
+    if (!currentChatroomId) return
+    await api('POST', `/chatrooms/${currentChatroomId}/reactions`, { messageId, emoji })
+    const chatroom = await api<Chatroom>('GET', `/chatrooms/${currentChatroomId}`)
+    set((s) => ({ chatrooms: { ...s.chatrooms, [currentChatroomId]: chatroom } }))
+  },
+
+  togglePin: async (messageId) => {
+    const { currentChatroomId } = get()
+    if (!currentChatroomId) return
+    await api('POST', `/chatrooms/${currentChatroomId}/pins`, { messageId })
+    const chatroom = await api<Chatroom>('GET', `/chatrooms/${currentChatroomId}`)
+    set((s) => ({ chatrooms: { ...s.chatrooms, [currentChatroomId]: chatroom } }))
+  },
+
+  addMember: async (agentId) => {
+    const { currentChatroomId } = get()
+    if (!currentChatroomId) return
+    const chatroom = await api<Chatroom>('POST', `/chatrooms/${currentChatroomId}/members`, { agentId })
+    set((s) => ({ chatrooms: { ...s.chatrooms, [currentChatroomId]: chatroom } }))
+  },
+
+  removeMember: async (agentId) => {
+    const { currentChatroomId } = get()
+    if (!currentChatroomId) return
+    const chatroom = await api<Chatroom>('DELETE', `/chatrooms/${currentChatroomId}/members`, { agentId })
+    set((s) => ({ chatrooms: { ...s.chatrooms, [currentChatroomId]: chatroom } }))
+  },
+
+  setChatroomSheetOpen: (open) => set({ chatroomSheetOpen: open }),
+  setEditingChatroomId: (id) => set({ editingChatroomId: id }),
+}))