@swarmclawai/swarmclaw 0.5.3 → 0.6.0

package/src/lib/tasks.ts

@@ -4,7 +4,7 @@ import type { BoardTask } from '../types'
 export const fetchTasks = (includeArchived = false) =>
   api<Record<string, BoardTask>>('GET', `/tasks${includeArchived ? '?includeArchived=true' : ''}`)
 
-export const createTask = (data: { title: string; description: string; agentId: string }) =>
+export const createTask = (data: { title: string; description: string; agentId: string; status?: string }) =>
   api<BoardTask>('POST', '/tasks', data)
 
 export const updateTask = (id: string, data: Partial<BoardTask>) =>
@@ -18,3 +18,6 @@ export const archiveTask = (id: string) =>
 
 export const unarchiveTask = (id: string) =>
   api<BoardTask>('PUT', `/tasks/${id}`, { status: 'backlog' })
+
+export const bulkUpdateTasks = (ids: string[], data: { status?: string; agentId?: string | null; projectId?: string | null }) =>
+  api<{ updated: number; ids: string[] }>('POST', '/tasks/bulk', { ids, ...data })

package/src/lib/view-routes.ts

@@ -1,9 +1,11 @@
 import type { AppView } from '@/types'
 
-export const DEFAULT_VIEW: AppView = 'agents'
+export const DEFAULT_VIEW: AppView = 'home'
 
 export const VIEW_TO_PATH: Record<AppView, string> = {
+  home: '/',
   agents: '/agents',
+  chatrooms: '/chatrooms',
   schedules: '/schedules',
   memory: '/memory',
   tasks: '/tasks',
@@ -27,3 +29,36 @@ const entries = Object.entries(VIEW_TO_PATH) as [AppView, string][]
 export const PATH_TO_VIEW: Record<string, AppView> = Object.fromEntries(
   entries.map(([view, path]) => [path, view]),
 ) as Record<string, AppView>
+
+/** Views that support deep-linking to a specific entity by ID */
+const VIEWS_WITH_ID = new Set<AppView>(['agents', 'chatrooms'])
+
+// Sorted longest-first so "/mcp-servers" matches before "/" etc.
+const sortedPaths = entries
+  .map(([view, path]) => ({ view, path }))
+  .sort((a, b) => b.path.length - a.path.length)
+
+/** Parse a pathname into { view, id }. Returns null for unknown paths. */
+export function parsePath(pathname: string): { view: AppView; id: string | null } | null {
+  // Exact match first (no trailing ID)
+  const exact = PATH_TO_VIEW[pathname]
+  if (exact) return { view: exact, id: null }
+
+  // Prefix match: "/agents/abc123" → view=agents, id=abc123
+  for (const { view, path } of sortedPaths) {
+    if (pathname.startsWith(path + '/')) {
+      const rest = pathname.slice(path.length + 1)
+      if (rest && !rest.includes('/') && VIEWS_WITH_ID.has(view)) {
+        return { view, id: decodeURIComponent(rest) }
+      }
+    }
+  }
+  return null
+}
+
+/** Build a URL path for a view, optionally with an entity ID. */
+export function buildPath(view: AppView, id?: string | null): string {
+  const base = VIEW_TO_PATH[view]
+  if (id && VIEWS_WITH_ID.has(view)) return `${base}/${encodeURIComponent(id)}`
+  return base
+}

package/src/lib/ws-client.ts

@@ -9,10 +9,20 @@ const listeners = new Map<string, Set<WsCallback>>()
 let connected = false
 
 function getWsUrl(key: string): string {
-  const host = typeof window !== 'undefined' ? window.location.hostname : 'localhost'
-  const port = process.env.NEXT_PUBLIC_WS_PORT || '3457'
-  const protocol = typeof window !== 'undefined' && window.location.protocol === 'https:' ? 'wss' : 'ws'
-  return `${protocol}://${host}:${port}/ws?key=${encodeURIComponent(key)}`
+  if (typeof window === 'undefined') return `ws://localhost:3457/ws?key=${encodeURIComponent(key)}`
+
+  const protocol = window.location.protocol === 'https:' ? 'wss' : 'ws'
+  const pagePort = window.location.port
+  const buildPort = process.env.NEXT_PUBLIC_WS_PORT || '3457'
+
+  // If the page was loaded on a standard HTTP port (80/443/empty) or a port
+  // that doesn't match the expected app port, we're likely behind a reverse
+  // proxy. Use the page's host directly so the proxy can route /ws traffic.
+  const appPort = String((Number(buildPort) || 3457) - 1) // e.g. 3456
+  const behindProxy = !pagePort || pagePort === '80' || pagePort === '443' || pagePort !== appPort
+  const wsHost = behindProxy ? window.location.host : `${window.location.hostname}:${buildPort}`
+
+  return `${protocol}://${wsHost}/ws?key=${encodeURIComponent(key)}`
 }
 
 function handleMessage(event: MessageEvent) {

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

@@ -53,6 +53,7 @@ interface AppState {
 
   agents: Record<string, Agent>
   loadAgents: () => Promise<void>
+  togglePinAgent: (id: string) => void
 
   schedules: Record<string, Schedule>
   loadSchedules: () => Promise<void>
@@ -180,10 +181,18 @@ interface AppState {
   fleetFilter: FleetFilter
   setFleetFilter: (filter: FleetFilter) => void
 
+  // Chat list filter
+  chatFilter: 'all' | 'active' | 'recent'
+  setChatFilter: (filter: 'all' | 'active' | 'recent') => void
+
   // Activity / Audit Trail
   activityEntries: ActivityEntry[]
   loadActivity: (filters?: { entityType?: string; limit?: number }) => Promise<void>
 
+  // Unread tracking (localStorage-backed)
+  lastReadTimestamps: Record<string, number>
+  markChatRead: (id: string) => void
+
   // Notifications
   notifications: AppNotification[]
   unreadNotificationCount: number
@@ -200,7 +209,8 @@ export const useAppStore = create<AppState>((set, get) => ({
   hydrate: () => {
     if (typeof window === 'undefined') return
     const user = localStorage.getItem('sc_user')
-    set({ currentUser: user, _hydrated: true })
+    const savedAgentId = localStorage.getItem('sc_agent')
+    set({ currentUser: user, currentAgentId: savedAgentId, _hydrated: true })
   },
   setUser: (user) => {
     if (user) localStorage.setItem('sc_user', user)
@@ -305,16 +315,18 @@ export const useAppStore = create<AppState>((set, get) => ({
   newSessionOpen: false,
   setNewSessionOpen: (open) => set({ newSessionOpen: open }),
 
-  activeView: 'agents',
+  activeView: 'home',
   setActiveView: (view) => set({ activeView: view }),
 
   currentAgentId: null,
   setCurrentAgent: async (id) => {
     if (!id) {
       set({ currentAgentId: null })
+      if (typeof window !== 'undefined') localStorage.removeItem('sc_agent')
       return
     }
     set({ currentAgentId: id })
+    if (typeof window !== 'undefined') localStorage.setItem('sc_agent', id)
     try {
       const user = get().currentUser || 'default'
       const session = await api<Session>('POST', `/agents/${id}/thread`, { user })
@@ -336,6 +348,14 @@ export const useAppStore = create<AppState>((set, get) => ({
       // ignore
     }
   },
+  togglePinAgent: (id) => {
+    const agents = { ...get().agents }
+    if (agents[id]) {
+      agents[id] = { ...agents[id], pinned: !agents[id].pinned }
+      set({ agents })
+      void api('PUT', `/agents/${id}`, { pinned: agents[id].pinned })
+    }
+  },
 
   schedules: {},
   loadSchedules: async () => {
@@ -584,6 +604,10 @@ export const useAppStore = create<AppState>((set, get) => ({
   fleetFilter: 'all',
   setFleetFilter: (filter) => set({ fleetFilter: filter }),
 
+  // Chat list filter
+  chatFilter: 'all' as const,
+  setChatFilter: (filter) => set({ chatFilter: filter }),
+
   // Activity / Audit Trail
   activityEntries: [],
   loadActivity: async (filters) => {
@@ -599,6 +623,16 @@ export const useAppStore = create<AppState>((set, get) => ({
     }
   },
 
+  // Unread tracking
+  lastReadTimestamps: typeof window !== 'undefined'
+    ? (() => { try { return JSON.parse(localStorage.getItem('sc_last_read') || '{}') } catch { return {} } })()
+    : {},
+  markChatRead: (id) => {
+    const ts = { ...get().lastReadTimestamps, [id]: Date.now() }
+    set({ lastReadTimestamps: ts })
+    try { localStorage.setItem('sc_last_read', JSON.stringify(ts)) } catch { /* ignore */ }
+  },
+
   // Notifications
   notifications: [],
   unreadNotificationCount: 0,

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,22 @@ 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
 }
 
 // Module-level cadence interval (not in state to avoid re-renders)
@@ -128,9 +142,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 +167,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 +180,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 +192,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 +201,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       imagePath,
       imageUrl,
       attachedFiles,
+      ...(replyToId ? { replyToId } : {}),
     }
     clearCadence()
     set((s) => ({
@@ -180,8 +212,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,
     }))
@@ -296,6 +331,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,7 +343,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       } else if (event.t === 'done') {
         // done
       }
-    }, attachedFiles)
+    }, attachedFiles, { replyToId })
 
     clearCadence()
     if (get().soundEnabled && soundFiredStart) playStreamEnd()
@@ -333,13 +370,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) => {

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 }),
+}))