@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/validation/schemas.ts

@@ -41,6 +41,21 @@ const AgentSandboxConfigSchema = z.object({
   prune: AgentSandboxPruneSchema,
 }).nullable().optional()
 
+const AgentExecuteConfigSchema = z.object({
+  backend: z.enum(['sandbox', 'host']).optional(),
+  network: z.object({
+    enabled: z.boolean(),
+    allowedUrls: z.array(z.string()).optional(),
+  }).optional(),
+  runtimes: z.object({
+    python: z.boolean().optional(),
+    javascript: z.boolean().optional(),
+    sqlite: z.boolean().optional(),
+  }).optional(),
+  timeout: z.number().int().positive().optional(),
+  credentials: z.array(z.string()).optional(),
+}).nullable().optional()
+
 const AgentRoutingTargetSchema = z.object({
   id: z.string().min(1),
   label: z.string().optional(),
@@ -110,6 +125,7 @@ export const AgentCreateSchema = z.object({
   avatarSeed: z.string().optional(),
   avatarUrl: z.string().nullable().optional().default(null),
   sandboxConfig: AgentSandboxConfigSchema,
+  executeConfig: AgentExecuteConfigSchema,
   autoRecovery: z.boolean().optional().default(false),
   monthlyBudget: z.number().positive().nullable().optional().default(null),
   dailyBudget: z.number().positive().nullable().optional().default(null),
@@ -121,7 +137,7 @@ export const ConnectorCreateSchema = z.object({
   name: z.string().min(1, 'Connector name is required').optional(),
   platform: z.enum([
     'discord', 'telegram', 'slack', 'whatsapp', 'openclaw',
-    'bluebubbles', 'signal', 'teams', 'googlechat', 'matrix', 'email',
+    'bluebubbles', 'signal', 'teams', 'googlechat', 'matrix', 'email', 'swarmdock',
   ]),
   agentId: z.string().nullable().optional().default(null),
   chatroomId: z.string().nullable().optional().default(null),
@@ -380,7 +396,6 @@ export const ProtocolRunCreateSchema = z.object({
   participantAgentIds: z.array(z.string()).min(1, 'Select at least one participant').default([]),
   facilitatorAgentId: z.string().nullable().optional().default(null),
   observerAgentIds: z.array(z.string()).optional().default([]),
-  missionId: z.string().nullable().optional().default(null),
   taskId: z.string().nullable().optional().default(null),
   sessionId: z.string().nullable().optional().default(null),
   parentChatroomId: z.string().nullable().optional().default(null),
@@ -457,6 +472,38 @@ export const ProtocolRunActionSchema = z.object({
   workItemId: z.string().nullable().optional().default(null),
 })
 
+const PortableAgentSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string(),
+  systemPrompt: z.string(),
+  provider: z.string().min(1),
+  model: z.string().min(1),
+  createdAt: z.number().optional(),
+  updatedAt: z.number().optional(),
+  skillIds: z.array(z.string()).optional(),
+}).passthrough()
+
+const PortableSkillSchema = z.object({
+  originalId: z.string().min(1),
+  name: z.string().min(1),
+  content: z.string(),
+}).passthrough()
+
+const PortableScheduleSchema = z.object({
+  originalId: z.string().min(1),
+  originalAgentId: z.string().min(1),
+  name: z.string().min(1),
+}).passthrough()
+
+export const PortableManifestSchema = z.object({
+  formatVersion: z.number().int().nonnegative(),
+  exportedAt: z.string().optional(),
+  agents: z.array(PortableAgentSchema),
+  skills: z.array(PortableSkillSchema),
+  schedules: z.array(PortableScheduleSchema),
+})
+
 /** Format ZodError into a 400-friendly payload */
 export function formatZodError(err: z.ZodError) {
   return { error: 'Validation failed', issues: err.issues.map((i) => ({ path: i.path.join('.'), message: i.message })) }

package/src/stores/slices/data-slice.ts

@@ -1,6 +1,6 @@
 import { StateCreator } from 'zustand'
 import type { AppState } from '../use-app-store'
-import type { NetworkInfo, Directory, ProviderInfo, Credentials, Schedule, AppSettings, StoredSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, ExtensionMeta, Project, ActivityEntry, AppNotification, GatewayProfile } from '../../types'
+import type { NetworkInfo, Directory, ProviderInfo, Credentials, Schedule, AppSettings, StoredSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, ExtensionMeta, Project, ActivityEntry, AppNotification, GatewayProfile, SafeWallet } from '../../types'
 import { api } from '@/lib/app/api-client'
 import { safeStorageGetJson, safeStorageSet } from '@/lib/app/safe-storage'
 import { fetchDirs, fetchProviders, fetchCredentials } from '@/lib/chat/chats'
@@ -24,6 +24,8 @@ export interface DataSlice {
   updateSettings: (patch: Partial<AppSettings>) => Promise<void>
   secrets: Record<string, StoredSecret>
   loadSecrets: () => Promise<void>
+  wallets: Record<string, SafeWallet>
+  loadWallets: () => Promise<void>
   providerConfigs: ProviderConfig[]
   loadProviderConfigs: () => Promise<void>
   gatewayProfiles: GatewayProfile[]
@@ -78,6 +80,8 @@ export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set,
   },
   secrets: {},
   loadSecrets: createLoader<AppState>(set, 'secrets', () => api<Record<string, StoredSecret>>('GET', '/secrets'), {}),
+  wallets: {},
+  loadWallets: createLoader<AppState>(set, 'wallets', () => api<Record<string, SafeWallet>>('GET', '/wallets'), {}),
   providerConfigs: [],
   loadProviderConfigs: createLoader<AppState>(set, 'providerConfigs', () => api<ProviderConfig[]>('GET', '/providers/configs'), []),
   gatewayProfiles: [],

package/src/stores/slices/ui-slice.ts

@@ -95,8 +95,6 @@ export interface UiSlice {
   setFleetFilter: (filter: FleetFilter) => void
   chatFilter: 'all' | 'active' | 'recent'
   setChatFilter: (filter: 'all' | 'active' | 'recent') => void
-  walletPanelAgentId: string | null
-  setWalletPanelAgentId: (id: string | null) => void
   heartbeatHistoryOpen: boolean
   setHeartbeatHistoryOpen: (open: boolean) => void
   agentPrefill: Partial<Agent> | null
@@ -195,8 +193,6 @@ export const createUiSlice: StateCreator<AppState, [], [], UiSlice> = (set, get)
   setFleetFilter: (filter) => { safeStorageSet('sc_fleet_filter', filter); set({ fleetFilter: filter }) },
   chatFilter: 'all' as const,
   setChatFilter: (filter) => set({ chatFilter: filter }),
-  walletPanelAgentId: null,
-  setWalletPanelAgentId: (id) => set({ walletPanelAgentId: id }),
   heartbeatHistoryOpen: false,
   setHeartbeatHistoryOpen: (open) => set({ heartbeatHistoryOpen: open }),
   agentPrefill: null,

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

@@ -451,6 +451,103 @@ describe('useChatStore control-token hygiene', () => {
     assert.equal(useAppStore.getState().sessions['session-1']?.currentRunId, 'run-active')
   })
 
+  it('hydrates the active turn from the backend queue snapshot as a sending placeholder', async () => {
+    const now = Date.now()
+    const session = makeSession()
+    useAppStore.setState({
+      agents: { 'agent-1': makeAgent() },
+      sessions: { [session.id]: session },
+      currentAgentId: 'agent-1',
+    })
+    useChatStore.setState({
+      messages: [],
+      pendingFiles: [],
+      replyingTo: null,
+      toolEvents: [],
+      streamText: '',
+      displayText: '',
+      streaming: false,
+      streamingSessionId: null,
+      streamSource: null,
+      assistantRenderId: null,
+      streamPhase: 'thinking',
+      streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      queuedMessages: [],
+      agentStatus: null,
+      lastUsage: null,
+      hasMoreMessages: false,
+      loadingMore: false,
+      totalMessages: 0,
+    })
+
+    global.fetch = (async (input: RequestInfo | URL) => {
+      const url = String(input)
+      if (url === '/api/chats/session-1/queue') {
+        return jsonResponse({
+          sessionId: 'session-1',
+          activeRunId: 'run-active',
+          activeTurn: {
+            runId: 'run-active',
+            sessionId: 'session-1',
+            text: 'Already running',
+            queuedAt: now,
+            position: 0,
+          },
+          queueLength: 1,
+          items: [
+            { runId: 'run-queued-2', sessionId: 'session-1', text: 'Then refine it', queuedAt: now + 1, position: 1 },
+          ],
+        })
+      }
+      throw new Error(`Unexpected fetch: ${url}`)
+    }) as unknown as typeof fetch
+
+    await useChatStore.getState().loadQueuedMessages('session-1')
+
+    const state = useChatStore.getState()
+    assert.deepEqual(
+      state.queuedMessages.map((item) => [item.runId, item.sending === true]),
+      [['run-active', true], ['run-queued-2', false]],
+    )
+    assert.equal(useAppStore.getState().sessions['session-1']?.queuedCount, 1)
+    assert.equal(useAppStore.getState().sessions['session-1']?.currentRunId, 'run-active')
+  })
+
+  it('clears sending placeholders when a persisted user message with the same runId arrives', () => {
+    useChatStore.setState({
+      messages: [],
+      assistantRenderId: null,
+      queuedMessages: [
+        { runId: 'run-active', sessionId: 'session-1', text: 'Already running', queuedAt: 9, position: 0, sending: true },
+      ],
+      toolEvents: [],
+      streamText: '',
+      displayText: '',
+      streaming: false,
+      streamingSessionId: null,
+      streamSource: null,
+      streamPhase: 'thinking',
+      streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      agentStatus: null,
+      lastUsage: null,
+      hasMoreMessages: false,
+      loadingMore: false,
+      totalMessages: 0,
+    })
+
+    useChatStore.getState().setMessages([
+      { role: 'user', text: 'Already running', time: 10, runId: 'run-active' },
+    ])
+
+    const state = useChatStore.getState()
+    assert.equal(state.queuedMessages.length, 0)
+    assert.equal(state.messages[0]?.runId, 'run-active')
+  })
+
   it('removes optimistic queued items again when the backend enqueue fails', async () => {
     const session = makeSession()
     useAppStore.setState({
@@ -533,4 +630,138 @@ describe('useChatStore control-token hygiene', () => {
     assert.equal(state.assistantRenderId, 'render-1')
     assert.equal(state.messages[1]?.clientRenderId, 'render-1')
   })
+
+  it('preserves transcript totals on local message updates for paginated windows', () => {
+    useChatStore.setState({
+      messages: [
+        { role: 'user', text: 'Ninth', time: 9, bookmarked: false },
+        { role: 'assistant', text: 'Tenth', time: 10 },
+      ],
+      messageStartIndex: 8,
+      assistantRenderId: null,
+      toolEvents: [],
+      streamText: '',
+      displayText: '',
+      streaming: false,
+      streamingSessionId: null,
+      streamSource: null,
+      streamPhase: 'thinking',
+      streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      queuedMessages: [],
+      agentStatus: null,
+      lastUsage: null,
+      hasMoreMessages: true,
+      loadingMore: false,
+      totalMessages: 10,
+    })
+
+    useChatStore.getState().setMessages([
+      { role: 'user', text: 'Ninth', time: 9, bookmarked: true },
+      { role: 'assistant', text: 'Tenth', time: 10 },
+    ])
+
+    const state = useChatStore.getState()
+    assert.equal(state.messageStartIndex, 8)
+    assert.equal(state.totalMessages, 10)
+    assert.equal(state.hasMoreMessages, true)
+    assert.equal(state.messages[0]?.bookmarked, true)
+  })
+
+  it('does not timeout sending items before 60 seconds', () => {
+    const thirtySecondsAgo = Date.now() - 30_000
+    useChatStore.setState({
+      messages: [],
+      assistantRenderId: null,
+      toolEvents: [],
+      streamText: '',
+      displayText: '',
+      streaming: false,
+      streamingSessionId: null,
+      streamSource: null,
+      streamPhase: 'thinking',
+      streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      queuedMessages: [
+        { runId: 'run-old', sessionId: 'session-1', text: 'Waiting', queuedAt: thirtySecondsAgo, position: 0, sending: true },
+      ],
+      agentStatus: null,
+      lastUsage: null,
+      hasMoreMessages: false,
+      loadingMore: false,
+      totalMessages: 0,
+    })
+
+    // setMessages with no matching persisted message — item should survive
+    useChatStore.getState().setMessages([
+      { role: 'user', text: 'Unrelated', time: Date.now() },
+    ])
+
+    const state = useChatStore.getState()
+    assert.equal(state.queuedMessages.length, 1)
+    assert.equal(state.queuedMessages[0]?.runId, 'run-old')
+  })
+
+  it('tracks messageStartIndex when loading more paginated history', async () => {
+    const session = makeSession()
+    useAppStore.setState({
+      agents: { 'agent-1': makeAgent() },
+      sessions: { [session.id]: session },
+      currentAgentId: 'agent-1',
+    })
+    useChatStore.setState({
+      messages: [
+        { role: 'user', text: 'Ninth', time: 9 },
+        { role: 'assistant', text: 'Tenth', time: 10 },
+      ],
+      messageStartIndex: 8,
+      pendingFiles: [],
+      replyingTo: null,
+      toolEvents: [],
+      streamText: '',
+      displayText: '',
+      streaming: false,
+      streamingSessionId: null,
+      streamSource: null,
+      assistantRenderId: null,
+      streamPhase: 'thinking',
+      streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      queuedMessages: [],
+      agentStatus: null,
+      lastUsage: null,
+      hasMoreMessages: true,
+      loadingMore: false,
+      totalMessages: 10,
+    })
+
+    global.fetch = (async (input: RequestInfo | URL) => {
+      const url = String(input)
+      if (url === '/api/chats/session-1/messages?limit=100&before=8') {
+        return jsonResponse({
+          messages: [
+            { role: 'user', text: 'Seventh', time: 7 },
+            { role: 'assistant', text: 'Eighth', time: 8 },
+          ],
+          total: 10,
+          hasMore: true,
+          startIndex: 6,
+        })
+      }
+      throw new Error(`Unexpected fetch: ${url}`)
+    }) as unknown as typeof fetch
+
+    await useChatStore.getState().loadMoreMessages()
+
+    const state = useChatStore.getState()
+    assert.equal(state.messageStartIndex, 6)
+    assert.equal(state.totalMessages, 10)
+    assert.deepEqual(
+      state.messages.map((message) => message.text),
+      ['Seventh', 'Eighth', 'Ninth', 'Tenth'],
+    )
+  })
 })

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

@@ -66,7 +66,8 @@ interface ChatState {
   agentStatus: { goal?: string; status?: string; summary?: string; nextAction?: string } | null
 
   messages: Message[]
-  setMessages: (msgs: Message[]) => void
+  messageStartIndex: number
+  setMessages: (msgs: Message[], options?: { startIndex?: number; totalMessages?: number }) => void
 
   toolEvents: ToolEvent[]
   clearToolEvents: () => void
@@ -136,6 +137,10 @@ interface ChatState {
   loadMoreMessages: () => Promise<void>
 }
 
+/** Safety-net timeout for "sending" queue items. Normally cleaned up by
+ * matchesPersistedQueuedMessage well before this — only fires if matching fails. */
+const SENDING_ITEM_TIMEOUT_MS = 60_000
+
 const CONTROL_TOKEN_PREFIX_RE = /^\s*(?:NO_MESSAGE|HEARTBEAT_OK)(?:(?=[\s.,:;!?()[\]{}"'`-]|$)|(?=[A-Z]))\s*/i
 const CONTROL_TOKEN_LINE_RE = /(^|\n)\s*(?:NO_MESSAGE|HEARTBEAT_OK)\s*(\n|$)/gi
 
@@ -165,6 +170,29 @@ function reconcileMessagesForState(
   return { messages, assistantRenderId: nextAssistantRenderId }
 }
 
+function attachedFilesEqual(left: string[] | undefined, right: string[] | undefined): boolean {
+  if (!left?.length && !right?.length) return true
+  if ((left?.length || 0) !== (right?.length || 0)) return false
+  for (let index = 0; index < (left?.length || 0); index += 1) {
+    if (left?.[index] !== right?.[index]) return false
+  }
+  return true
+}
+
+function matchesPersistedQueuedMessage(message: Message, queued: QueuedSessionMessage): boolean {
+  if (message.role !== 'user') return false
+  const messageRunId = typeof message.runId === 'string' && message.runId.trim() ? message.runId : null
+  const queuedRunId = typeof queued.runId === 'string' && queued.runId.trim() ? queued.runId : null
+  if (messageRunId && queuedRunId) return messageRunId === queuedRunId
+  return (
+    message.text === queued.text
+    && message.replyToId === queued.replyToId
+    && message.imagePath === queued.imagePath
+    && message.imageUrl === queued.imageUrl
+    && attachedFilesEqual(message.attachedFiles, queued.attachedFiles)
+  )
+}
+
 function syncSessionQueueState(sessionId: string, params: {
   queuedCount: number
   currentRunId?: string | null
@@ -203,13 +231,14 @@ export const useChatStore = create<ChatState>((set, get) => ({
   displayText: '',
   agentStatus: null,
   messages: [],
-  setMessages: (msgs) => set((s) => {
+  messageStartIndex: 0,
+  setMessages: (msgs, options) => set((s) => {
     const next = reconcileMessagesForState(msgs, s.messages, s.assistantRenderId)
     // Clear "sending" queue items whose text now appears in the message list
     const queuedMessages = s.queuedMessages.filter((item) => {
       if (!item.sending) return true
-      if (next.messages.some((m) => m.role === 'user' && m.text === item.text)) return false
-      if (Date.now() - item.queuedAt > 15_000) return false
+      if (next.messages.some((message) => matchesPersistedQueuedMessage(message, item))) return false
+      if (Date.now() - item.queuedAt > SENDING_ITEM_TIMEOUT_MS) return false
       return true
     })
     const patch: Partial<ChatState> = {
@@ -217,9 +246,29 @@ export const useChatStore = create<ChatState>((set, get) => ({
       assistantRenderId: next.assistantRenderId,
       queuedMessages,
     }
+    if (typeof options?.startIndex === 'number' && Number.isFinite(options.startIndex)) {
+      patch.messageStartIndex = Math.max(0, Math.trunc(options.startIndex))
+    } else if (next.messages.length === 0) {
+      patch.messageStartIndex = 0
+    }
     if (s.toolEvents.length > 0) patch.toolEvents = []
-    if (s.hasMoreMessages) patch.hasMoreMessages = false
-    if (s.totalMessages !== next.messages.length) patch.totalMessages = next.messages.length
+    if (next.messages.length === 0) {
+      patch.hasMoreMessages = false
+    } else if (
+      typeof options?.startIndex === 'number'
+      && Number.isFinite(options.startIndex)
+      && Math.trunc(options.startIndex) === 0
+      && typeof options?.totalMessages === 'number'
+      && Number.isFinite(options.totalMessages)
+      && Math.max(0, Math.trunc(options.totalMessages)) === next.messages.length
+    ) {
+      patch.hasMoreMessages = false
+    }
+    if (typeof options?.totalMessages === 'number' && Number.isFinite(options.totalMessages)) {
+      patch.totalMessages = Math.max(0, Math.trunc(options.totalMessages))
+    } else if (next.messages.length === 0 && s.totalMessages !== 0) {
+      patch.totalMessages = 0
+    }
     return patch
   }),
   toolEvents: [],
@@ -253,8 +302,8 @@ export const useChatStore = create<ChatState>((set, get) => ({
       const messages = s.messages
       const cleaned = next.filter((item) => {
         if (!item.sending || item.sessionId !== sessionId) return true
-        if (messages.some((m) => m.role === 'user' && m.text === item.text)) return false
-        if (Date.now() - item.queuedAt > 15_000) return false
+        if (messages.some((message) => matchesPersistedQueuedMessage(message, item))) return false
+        if (Date.now() - item.queuedAt > SENDING_ITEM_TIMEOUT_MS) return false
         return true
       })
       return { queuedMessages: cleaned }
@@ -675,7 +724,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       })
       if (msgsRes.ok) {
         const msgs = await msgsRes.json()
-        get().setMessages(msgs)
+        get().setMessages(msgs, { startIndex: 0, totalMessages: msgs.length })
       }
       // Re-send with the new text
       await get().sendMessage(newText)
@@ -703,7 +752,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       })
       if (msgsRes.ok) {
         const msgs = await msgsRes.json()
-        get().setMessages(msgs)
+        get().setMessages(msgs, { startIndex: 0, totalMessages: msgs.length })
       }
       // Re-send the last user message through the normal SSE flow
       if (imagePath) {
@@ -817,15 +866,14 @@ export const useChatStore = create<ChatState>((set, get) => ({
   loadingMore: false,
   totalMessages: 0,
   loadMoreMessages: async () => {
-    const { messages, loadingMore, hasMoreMessages, totalMessages } = get()
+    const { loadingMore, hasMoreMessages, messageStartIndex } = get()
     if (loadingMore || !hasMoreMessages) return
     const sessionId = selectActiveSessionId(useAppStore.getState())
     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 currentStartIndex = messageStartIndex
       const res = await fetch(`/api/chats/${sessionId}/messages?limit=100&before=${currentStartIndex}`, {
         headers: key ? { 'X-Access-Key': key } : undefined,
       })
@@ -840,6 +888,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
           return {
             messages: next.messages,
             assistantRenderId: next.assistantRenderId,
+            messageStartIndex: data.startIndex,
             hasMoreMessages: data.hasMore,
             totalMessages: data.total,
             loadingMore: false,