@swarmclawai/swarmclaw 1.2.5 → 1.2.8

package/src/lib/chat/queued-message-queue.test.ts

@@ -1,9 +1,11 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 import {
+  buildQueuedTranscriptMessages,
   createOptimisticQueuedMessage,
   clearQueuedMessagesForSession,
   listQueuedMessagesForSession,
+  mergeQueuedTranscriptMessages,
   removeQueuedMessageById,
   replaceQueuedMessagesForSession,
   snapshotToQueuedMessages,
@@ -82,12 +84,22 @@ describe('queued-message-queue', () => {
     const queued = snapshotToQueuedMessages({
       sessionId: 'session-a',
       activeRunId: 'run-active',
+      activeTurn: {
+        runId: 'run-active',
+        sessionId: 'session-a',
+        text: 'sending now',
+        queuedAt: 4,
+        position: 0,
+      },
       queueLength: 1,
       items: [
         { runId: 'run-queued', sessionId: 'session-a', text: 'queued', queuedAt: 5, position: 1 },
       ],
     })
-    assert.deepEqual(queued.map((item) => item.runId), ['run-queued'])
+    assert.deepEqual(
+      queued.map((item) => [item.runId, item.sending === true]),
+      [['run-active', true], ['run-queued', false]],
+    )
   })
 
   it('preserves attachment and reply metadata from queue snapshots', () => {
@@ -123,6 +135,27 @@ describe('queued-message-queue', () => {
     })
   })
 
+  it('deduplicates an active turn when the snapshot also contains it in the queued items', () => {
+    const queued = snapshotToQueuedMessages({
+      sessionId: 'session-a',
+      activeRunId: 'run-active',
+      activeTurn: {
+        runId: 'run-active',
+        sessionId: 'session-a',
+        text: 'already running',
+        queuedAt: 6,
+        position: 0,
+      },
+      queueLength: 1,
+      items: [
+        { runId: 'run-active', sessionId: 'session-a', text: 'already running', queuedAt: 6, position: 1 },
+      ],
+    })
+
+    assert.deepEqual(queued.map((item) => item.runId), ['run-active'])
+    assert.equal(queued[0]?.sending, true)
+  })
+
   it('sorts queued messages by position and queued time within a session', () => {
     const unsorted: QueuedSessionMessage[] = [
       { runId: 'q4', sessionId: 'session-a', text: 'later', queuedAt: 9, position: 2 },
@@ -135,4 +168,104 @@ describe('queued-message-queue', () => {
       ['q5', 'q6', 'q4'],
     )
   })
+
+  it('builds transcript-ready user messages from sending queued turns', () => {
+    const transcript = buildQueuedTranscriptMessages([
+      { runId: 'q1', sessionId: 'session-a', text: 'sending row', queuedAt: 20, position: 0, sending: true },
+      { runId: 'q2', sessionId: 'session-a', text: 'pending row', queuedAt: 21, position: 1 },
+      { runId: 'q3', sessionId: 'session-b', text: 'other session', queuedAt: 22, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(transcript, [
+      {
+        role: 'user',
+        text: 'sending row',
+        time: 20,
+        kind: 'chat',
+        clientRenderId: 'queued:q1',
+        imagePath: undefined,
+        imageUrl: undefined,
+        attachedFiles: undefined,
+        replyToId: undefined,
+        runId: 'q1',
+      },
+    ])
+  })
+
+  it('merges sending queued turns into the transcript ahead of later assistant output', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'assistant', text: 'Thinking...', time: 25, streaming: true, runId: 'run-active' },
+    ], [
+      { runId: 'run-active', sessionId: 'session-a', text: 'queued first', queuedAt: 20, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(merged.map((message) => [message.role, message.text, message.runId]), [
+      ['user', 'queued first', 'run-active'],
+      ['assistant', 'Thinking...', 'run-active'],
+    ])
+  })
+
+  it('preserves existing sending items when replacing queue for a session', () => {
+    const queueWithSending: QueuedSessionMessage[] = [
+      { runId: 'sending-1', sessionId: 'session-a', text: 'already sending', queuedAt: 1, position: 0, sending: true },
+      { runId: 'q3', sessionId: 'session-a', text: 'queued', queuedAt: 2, position: 1 },
+      { runId: 'q2', sessionId: 'session-b', text: 'other', queuedAt: 3, position: 1 },
+    ]
+    const replaced = replaceQueuedMessagesForSession(queueWithSending, 'session-a', [
+      { runId: 'q4', sessionId: 'session-a', text: 'new queued', queuedAt: 4, position: 1 },
+    ], { activeRunId: null })
+
+    const forSession = listQueuedMessagesForSession(replaced, 'session-a')
+    assert.deepEqual(
+      forSession.map((item) => [item.runId, item.sending === true]),
+      [['sending-1', true], ['q4', false]],
+    )
+  })
+
+  it('deduplicates sending items that appear in nextItems', () => {
+    const queueWithSending: QueuedSessionMessage[] = [
+      { runId: 'run-active', sessionId: 'session-a', text: 'sending', queuedAt: 1, position: 0, sending: true },
+    ]
+    const replaced = replaceQueuedMessagesForSession(queueWithSending, 'session-a', [
+      { runId: 'run-active', sessionId: 'session-a', text: 'sending', queuedAt: 1, position: 0, sending: true },
+      { runId: 'q5', sessionId: 'session-a', text: 'next', queuedAt: 2, position: 1 },
+    ], { activeRunId: 'run-active' })
+
+    const forSession = listQueuedMessagesForSession(replaced, 'session-a')
+    assert.deepEqual(
+      forSession.map((item) => item.runId),
+      ['run-active', 'q5'],
+    )
+  })
+
+  it('inserts sending messages after last persisted message, not by timestamp', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'user', text: 'First', time: 100 },
+      { role: 'assistant', text: 'Reply', time: 200 },
+      { role: 'user', text: 'Second', time: 300 },
+      { role: 'assistant', text: 'Reply 2', time: 400 },
+    ], [
+      // queuedAt is earlier than the last persisted message
+      { runId: 'run-late', sessionId: 'session-a', text: 'queued early', queuedAt: 150, position: 0, sending: true },
+    ], 'session-a')
+
+    // Should appear at the END, not spliced into the middle at time=150
+    assert.deepEqual(merged.map((msg) => msg.text), [
+      'First', 'Reply', 'Second', 'Reply 2', 'queued early',
+    ])
+  })
+
+  it('skips a sending queued turn once the persisted user message is already present', () => {
+    const merged = mergeQueuedTranscriptMessages([
+      { role: 'user', text: 'queued first', time: 20, runId: 'run-active' },
+      { role: 'assistant', text: 'Thinking...', time: 25, streaming: true, runId: 'run-active' },
+    ], [
+      { runId: 'run-active', sessionId: 'session-a', text: 'queued first', queuedAt: 20, position: 0, sending: true },
+    ], 'session-a')
+
+    assert.deepEqual(merged.map((message) => [message.role, message.text, message.runId]), [
+      ['user', 'queued first', 'run-active'],
+      ['assistant', 'Thinking...', 'run-active'],
+    ])
+  })
 })

package/src/lib/chat/queued-message-queue.ts

@@ -1,4 +1,4 @@
-import type { SessionQueueSnapshot, SessionQueuedTurn } from '@/types'
+import type { Message, SessionQueueSnapshot, SessionQueuedTurn } from '@/types'
 
 export interface QueuedSessionMessage extends SessionQueuedTurn {
   optimistic?: boolean
@@ -38,7 +38,23 @@ export function createOptimisticQueuedMessage(
 }
 
 export function snapshotToQueuedMessages(snapshot: SessionQueueSnapshot): QueuedSessionMessage[] {
-  return snapshot.items.map((item) => ({ ...item }))
+  const activeRunId = typeof snapshot.activeRunId === 'string' && snapshot.activeRunId.trim()
+    ? snapshot.activeRunId
+    : null
+  const nextItems: QueuedSessionMessage[] = []
+  if (snapshot.activeTurn && activeRunId && snapshot.activeTurn.runId === activeRunId) {
+    nextItems.push({
+      ...snapshot.activeTurn,
+      sending: true,
+    })
+  }
+  const seenRunIds = new Set(nextItems.map((item) => item.runId))
+  for (const item of snapshot.items) {
+    if (seenRunIds.has(item.runId)) continue
+    nextItems.push({ ...item })
+    seenRunIds.add(item.runId)
+  }
+  return nextItems
 }
 
 interface ReplaceQueuedMessagesOptions {
@@ -60,11 +76,17 @@ export function replaceQueuedMessagesForSession(
   const activeRunId = typeof options.activeRunId === 'string' && options.activeRunId.trim()
     ? options.activeRunId
     : null
+  // Preserve existing "sending" items not covered by the new snapshot —
+  // they'll be cleaned up later by setMessages or the timeout.
+  const existingSending = queue.filter((item) =>
+    item.sessionId === sessionId && item.sending && !nextRunIds.has(item.runId),
+  )
   const consumed = previousForSession
     .filter((item) => !item.optimistic && !nextRunIds.has(item.runId) && activeRunId === item.runId)
     .map((item) => ({ ...item, sending: true }))
   return [
     ...otherSessions,
+    ...existingSending,
     ...consumed,
     ...nextItems,
   ]
@@ -80,6 +102,59 @@ export function listQueuedMessagesForSession(
     .sort((left, right) => left.position - right.position || left.queuedAt - right.queuedAt)
 }
 
+export function buildQueuedTranscriptMessages(
+  queue: QueuedSessionMessage[],
+  sessionId: string | null | undefined,
+): Message[] {
+  return listQueuedMessagesForSession(queue, sessionId)
+    .filter((item) => item.sending === true)
+    .map((item) => ({
+      role: 'user',
+      text: item.text,
+      time: item.queuedAt,
+      kind: 'chat',
+      clientRenderId: `queued:${item.runId}`,
+      imagePath: item.imagePath,
+      imageUrl: item.imageUrl,
+      attachedFiles: item.attachedFiles,
+      replyToId: item.replyToId,
+      runId: item.runId,
+    }))
+}
+
+export function mergeQueuedTranscriptMessages(
+  messages: Message[],
+  queue: QueuedSessionMessage[],
+  sessionId: string | null | undefined,
+): Message[] {
+  const queuedTranscript = buildQueuedTranscriptMessages(queue, sessionId)
+  if (queuedTranscript.length === 0) return messages
+  const merged = [...messages]
+  for (const queuedMessage of queuedTranscript) {
+    const queuedRunId = typeof queuedMessage.runId === 'string' && queuedMessage.runId.trim()
+      ? queuedMessage.runId
+      : null
+    if (queuedRunId && merged.some((message) => message.role === 'user' && message.runId === queuedRunId)) {
+      continue
+    }
+    // Place queued user message before its corresponding assistant response
+    // (same runId), otherwise append after the last persisted message.
+    const sameRunAssistantIndex = queuedRunId
+      ? merged.findIndex((msg) => msg.role === 'assistant' && msg.runId === queuedRunId)
+      : -1
+    if (sameRunAssistantIndex >= 0) {
+      merged.splice(sameRunAssistantIndex, 0, queuedMessage)
+    } else {
+      const lastPersistedIndex = merged.findLastIndex(
+        (msg) => !msg.clientRenderId?.startsWith('queued:'),
+      )
+      const insertAt = lastPersistedIndex >= 0 ? lastPersistedIndex + 1 : merged.length
+      merged.splice(insertAt, 0, queuedMessage)
+    }
+  }
+  return merged
+}
+
 export function removeQueuedMessageById(
   queue: QueuedSessionMessage[],
   id: string,

package/src/lib/providers/index.test.ts

@@ -76,3 +76,111 @@ test('builtin provider override records do not surface as custom providers', ()
 
   assert.equal(output.openAiCount, 1)
 })
+
+test('custom provider resolution includes defaultEndpoint and optionalApiKey', () => {
+  const output = runWithTempDataDir<{
+    defaultEndpoint: string | null
+    optionalApiKey: boolean | null
+    requiresApiKey: boolean | null
+  }>(`
+    const storageModule = await import('@/lib/server/storage')
+    const storage = storageModule.default || storageModule
+    storage.saveProviderConfigs({
+      'custom-llama-server': {
+        id: 'custom-llama-server',
+        name: 'llama-server',
+        type: 'custom',
+        baseUrl: 'http://127.0.0.1:8080/v1',
+        models: ['my-model'],
+        requiresApiKey: false,
+        credentialId: null,
+        isEnabled: true,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const resolved = providers.getProvider('custom-llama-server')
+
+    console.log(JSON.stringify({
+      defaultEndpoint: resolved?.defaultEndpoint ?? null,
+      optionalApiKey: resolved?.optionalApiKey ?? null,
+      requiresApiKey: resolved?.requiresApiKey ?? null,
+    }))
+  `)
+
+  assert.equal(output.defaultEndpoint, 'http://127.0.0.1:8080/v1')
+  assert.equal(output.optionalApiKey, true)
+  assert.equal(output.requiresApiKey, false)
+})
+
+test('custom provider with uuid-style ID resolves correctly', () => {
+  const output = runWithTempDataDir<{
+    resolvedName: string | null
+    hasHandler: boolean
+  }>(`
+    const storageModule = await import('@/lib/server/storage')
+    const storage = storageModule.default || storageModule
+    storage.saveProviderConfigs({
+      'custom-d20b934e': {
+        id: 'custom-d20b934e',
+        name: 'My llama-server',
+        type: 'custom',
+        baseUrl: 'http://127.0.0.1:8080/v1',
+        models: ['llama-3.1-8b'],
+        requiresApiKey: false,
+        credentialId: null,
+        isEnabled: true,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const resolved = providers.getProvider('custom-d20b934e')
+
+    console.log(JSON.stringify({
+      resolvedName: resolved?.name ?? null,
+      hasHandler: typeof resolved?.handler?.streamChat === 'function',
+    }))
+  `)
+
+  assert.equal(output.resolvedName, 'My llama-server')
+  assert.equal(output.hasHandler, true)
+})
+
+test('disabled custom providers are not resolved by getProvider', () => {
+  const output = runWithTempDataDir<{
+    resolved: boolean
+  }>(`
+    const storageModule = await import('@/lib/server/storage')
+    const storage = storageModule.default || storageModule
+    storage.saveProviderConfigs({
+      'custom-disabled': {
+        id: 'custom-disabled',
+        name: 'Disabled Provider',
+        type: 'custom',
+        baseUrl: 'http://127.0.0.1:8080/v1',
+        models: ['test'],
+        requiresApiKey: false,
+        credentialId: null,
+        isEnabled: false,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const resolved = providers.getProvider('custom-disabled')
+
+    console.log(JSON.stringify({
+      resolved: resolved !== null,
+    }))
+  `)
+
+  assert.equal(output.resolved, false)
+})

package/src/lib/providers/index.ts

@@ -286,7 +286,8 @@ function getCustomProviders(): Record<string, CustomProviderConfig> {
     return Object.fromEntries(
       Object.entries(configs).filter(([, config]) => config?.type === 'custom'),
     )
-  } catch {
+  } catch (err) {
+    log.warn(TAG, 'Failed to load custom providers from storage', errorMessage(err))
     return {}
   }
 }
@@ -325,6 +326,7 @@ export function getProviderList(): ProviderInfo[] {
       defaultModels: c.models,
       supportsModelDiscovery: false,
       requiresApiKey: c.requiresApiKey,
+      optionalApiKey: !c.requiresApiKey,
       requiresEndpoint: false as boolean,
       defaultEndpoint: c.baseUrl,
     }))
@@ -348,26 +350,47 @@ export function getProviderList(): ProviderInfo[] {
   return [...builtins, ...customs, ...extensionProviders]
 }
 
+function buildCustomProviderConfig(custom: CustomProviderConfig): BuiltinProviderConfig {
+  return {
+    id: custom.id as ProviderId,
+    name: custom.name,
+    models: custom.models,
+    requiresApiKey: custom.requiresApiKey,
+    optionalApiKey: !custom.requiresApiKey,
+    requiresEndpoint: false,
+    defaultEndpoint: custom.baseUrl,
+    handler: {
+      streamChat: async (opts) => {
+        const patchedSession = { ...opts.session, apiEndpoint: custom.baseUrl }
+        const { streamOpenAiChat } = await import('./openai')
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  }
+}
+
 export function getProvider(id: string): BuiltinProviderConfig | null {
   if (PROVIDERS[id]) return PROVIDERS[id]
-  
+
   // Check custom providers
   const customs = getCustomProviders()
   const custom = customs[id]
   if (custom?.isEnabled) {
-    return {
-      id: custom.id as ProviderId,
-      name: custom.name,
-      models: custom.models,
-      requiresApiKey: custom.requiresApiKey,
-      requiresEndpoint: false,
-      handler: {
-        streamChat: async (opts) => {
-          const patchedSession = { ...opts.session, apiEndpoint: custom.baseUrl }
-          const { streamOpenAiChat } = await import('./openai')
-          return streamOpenAiChat({ ...opts, session: patchedSession })
-        },
-      },
+    return buildCustomProviderConfig(custom)
+  }
+
+  // Fallback: direct single-item DB lookup for custom-* providers
+  if (id.startsWith('custom-') && !custom) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { loadStoredItem } = require('@/lib/server/storage') as typeof import('@/lib/server/storage')
+      const directConfig = loadStoredItem('provider_configs', id) as CustomProviderConfig | null
+      if (directConfig?.type === 'custom' && directConfig.isEnabled) {
+        log.info(TAG, `Resolved custom provider '${id}' via direct DB lookup (batch load missed it)`)
+        return buildCustomProviderConfig(directConfig)
+      }
+    } catch (err) {
+      log.warn(TAG, `Direct DB lookup failed for provider '${id}'`, errorMessage(err))
     }
   }
 

package/src/lib/server/agents/agent-service.ts

@@ -1,5 +1,6 @@
 import { genId } from '@/lib/id'
 import { resolveAgentToolSelection } from '@/lib/agent-default-tools'
+import { normalizeAgentExecuteConfig } from '@/lib/agent-execute-defaults'
 import { normalizeAgentSandboxConfig } from '@/lib/agent-sandbox-defaults'
 import { normalizeCapabilitySelection } from '@/lib/capability-selection'
 import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
@@ -180,6 +181,7 @@ export function createAgent(input: {
     sessionDailyResetAt: typeof body.sessionDailyResetAt === 'string' ? body.sessionDailyResetAt : null,
     sessionResetTimezone: typeof body.sessionResetTimezone === 'string' ? body.sessionResetTimezone : null,
     sandboxConfig: normalizeAgentSandboxConfig(body.sandboxConfig),
+    executeConfig: body.executeConfig === null ? null : normalizeAgentExecuteConfig(body.executeConfig),
     createdAt: now,
     updatedAt: now,
   }
@@ -225,6 +227,9 @@ export function updateAgent(agentId: string, body: Record<string, unknown>): Age
     if (body.sandboxConfig !== undefined) {
       agent.sandboxConfig = normalizeAgentSandboxConfig(body.sandboxConfig)
     }
+    if (body.executeConfig !== undefined) {
+      agent.executeConfig = body.executeConfig === null ? null : normalizeAgentExecuteConfig(body.executeConfig)
+    }
     if (
       body.provider !== undefined
       || body.orchestratorEnabled !== undefined

package/src/lib/server/builtin-extensions.ts

@@ -1,4 +1,5 @@
 import '@/lib/server/session-tools/shell'
+import '@/lib/server/session-tools/execute'
 import '@/lib/server/session-tools/file'
 import '@/lib/server/session-tools/edit_file'
 import '@/lib/server/session-tools/web'

package/src/lib/server/chat-execution/chat-execution-advanced.test.ts

@@ -470,7 +470,7 @@ describe('hasDirectLocalCodingTools', () => {
     assert.equal(hasDirectLocalCodingTools({ tools: ['files'] }), true)
   })
 
-  it('returns true for sandbox extension', () => {
+  it('returns true for legacy sandbox alias', () => {
     assert.equal(hasDirectLocalCodingTools({ tools: ['sandbox'] }), true)
   })
 })

package/src/lib/server/chat-execution/chat-execution-tool-events.test.ts

@@ -259,6 +259,7 @@ describe('hasDirectLocalCodingTools', () => {
   it('treats shell and file tooling as local coding capability', () => {
     assert.equal(hasDirectLocalCodingTools({ extensions: ['files'] }), true)
     assert.equal(hasDirectLocalCodingTools({ extensions: ['shell'] }), true)
+    assert.equal(hasDirectLocalCodingTools({ extensions: ['execute'] }), true)
     assert.equal(hasDirectLocalCodingTools({ extensions: ['edit_file'] }), true)
     assert.equal(hasDirectLocalCodingTools({ extensions: ['delegate'] }), false)
   })

package/src/lib/server/chat-execution/chat-execution-utils.ts

@@ -324,8 +324,6 @@ export function requestedToolNamesFromMessage(message: string): string[] {
     'wallet_tool',
     'http_request',
     'send_file',
-    'sandbox_exec',
-    'sandbox_list_runtimes',
     'schedule_wake',
     'spawn_subagent',
     'ask_human',
@@ -338,6 +336,7 @@ export function requestedToolNamesFromMessage(message: string): string[] {
     'browser',
     'web',
     'shell',
+    'execute',
     'files',
     'edit_file',
     'canvas',
@@ -370,6 +369,7 @@ export function enabledDelegationTools(session: SessionWithTools): DelegateTool[
 export function hasDirectLocalCodingTools(session: SessionWithTools): boolean {
   return [
     'shell',
+    'execute',
     'execute_command',
     'files',
     'edit_file',