@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/capability-router.ts

@@ -1,4 +1,5 @@
 import type { AppSettings } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 import { getToolsForCapability, matchToolCapabilitiesForMessage, TOOL_CAPABILITY } from './tool-planning'
 
 export type TaskIntent =
@@ -29,7 +30,7 @@ function containsAny(text: string, terms: string[]): boolean {
 }
 
 function dedupe(values: string[]): string[] {
-  return Array.from(new Set(values.filter(Boolean)))
+  return dedup(values.filter(Boolean))
 }
 
 function isMonitoringOrCurrentEventsRequest(text: string): boolean {
@@ -78,7 +79,7 @@ function normalizeDelegateOrder(value: unknown): DelegateTool[] {
     else if (raw === 'gemini') mapped.push('delegate_to_gemini_cli')
   }
   if (!mapped.length) return fallback
-  const deduped = Array.from(new Set(mapped))
+  const deduped = dedup(mapped)
   for (const tool of fallback) {
     if (!deduped.includes(tool)) deduped.push(tool)
   }

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

@@ -494,6 +494,11 @@ describe('buildToolDisciplineLines advanced', () => {
     const lines = buildToolDisciplineLines(['delegate', 'shell', 'files'])
     assert.ok(lines.some((line) => line.includes('prefer using them directly for straightforward coding')))
   })
+
+  it('tells research-capable agents to try another enabled acquisition path before manual fallback', () => {
+    const lines = buildToolDisciplineLines(['web_search', 'web_fetch', 'http_request', 'shell'])
+    assert.ok(lines.some((line) => line.includes('try one other enabled acquisition path') && line.includes('`shell`') && line.includes('`http_request`')))
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -640,12 +645,12 @@ describe('normalizeAssistantArtifactLinks', () => {
 // getExplicitRequiredToolNames
 // ---------------------------------------------------------------------------
 describe('getExplicitRequiredToolNames', () => {
-  it('requires web_search for research-oriented query when web_search is enabled', () => {
+  it('does not force web_search for generic research phrasing when the tool was not explicitly named', () => {
     const result = getExplicitRequiredToolNames(
       'Search the web for the latest news about AI regulation',
       ['web_search', 'web_fetch', 'browser'],
     )
-    assert.ok(result.includes('web_search') || result.includes('web'))
+    assert.deepEqual(result, [])
   })
 
   it('returns empty when no tool matches the message', () => {
@@ -655,4 +660,12 @@ describe('getExplicitRequiredToolNames', () => {
     )
     assert.deepEqual(result, [])
   })
+
+  it('forces shell when the user explicitly asks for curl execution', () => {
+    const result = getExplicitRequiredToolNames(
+      'Can you run the curl request in the terminal?',
+      ['files', 'shell'],
+    )
+    assert.deepEqual(result, ['shell'])
+  })
 })

package/src/lib/server/chat-execution-connector-delivery.ts

@@ -0,0 +1,67 @@
+import type { MessageToolEvent } from '@/types'
+import { dedupeConsecutiveToolEvents } from './chat-execution-tool-events'
+
+function parseToolJsonObject(raw: string): Record<string, unknown> | null {
+  const trimmed = raw.trim()
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) return null
+  try {
+    const parsed = JSON.parse(trimmed)
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null
+  } catch {
+    return null
+  }
+}
+
+function summarizeConnectorToolFailure(output: string): string {
+  const trimmed = output.trim()
+  const withoutPrefix = trimmed.replace(/^Error:\s*/i, '')
+  const parsed = parseToolJsonObject(withoutPrefix) || parseToolJsonObject(trimmed)
+  if (parsed) {
+    const detail = parsed.detail
+    if (detail && typeof detail === 'object' && !Array.isArray(detail)) {
+      const detailRecord = detail as Record<string, unknown>
+      const message = typeof detailRecord.message === 'string' ? detailRecord.message.trim() : ''
+      if (message) return message
+      const code = typeof detailRecord.code === 'string' ? detailRecord.code.trim() : ''
+      const status = typeof detailRecord.status === 'string' ? detailRecord.status.trim() : ''
+      if (code && status) return `${code}: ${status}`
+      if (code) return code
+      if (status) return status
+    }
+    const message = typeof parsed.message === 'string' ? parsed.message.trim() : ''
+    if (message) return message
+    const error = typeof parsed.error === 'string' ? parsed.error.trim() : ''
+    if (error) return error
+  }
+  return withoutPrefix.replace(/\s+/g, ' ').trim() || 'Connector delivery failed.'
+}
+
+function connectorToolEventSucceeded(event: MessageToolEvent): boolean {
+  if (!event.output) return false
+  const parsed = parseToolJsonObject(event.output)
+  const status = typeof parsed?.status === 'string' ? parsed.status.trim().toLowerCase() : ''
+  return status === 'sent' || status === 'voice_sent' || status === 'scheduled'
+}
+
+const POSITIVE_CONNECTOR_DELIVERY_RE = /\b(?:i(?:'ve| have)?(?: successfully)? sent|i sent|successfully sent|sent to your|voice note (?:has been|was) sent|message (?:has been|was) sent)\b/i
+
+export function reconcileConnectorDeliveryText(text: string, events: MessageToolEvent[]): string {
+  const trimmed = text.trim()
+  if (!trimmed || !POSITIVE_CONNECTOR_DELIVERY_RE.test(trimmed)) return text
+
+  const connectorEvents = dedupeConsecutiveToolEvents(events).filter((event) => event.name === 'connector_message_tool')
+  if (connectorEvents.length === 0) return text
+  if (connectorEvents.some((event) => connectorToolEventSucceeded(event))) return text
+
+  const latestFailure = [...connectorEvents]
+    .reverse()
+    .find((event) => event.error === true && typeof event.output === 'string' && event.output.trim())
+
+  const failureSummary = latestFailure?.output
+    ? summarizeConnectorToolFailure(latestFailure.output)
+    : 'I could not confirm that the connector actually sent anything.'
+
+  return `I couldn't send that through the configured connector. ${failureSummary}`.trim()
+}

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

@@ -35,13 +35,13 @@ function runWithTempDataDir(script: string) {
 
 test('executeSessionChatTurn persists a visible error for disabled agents', () => {
   const output = runWithTempDataDir(`
-    const storageMod = await import('./src/lib/server/storage.ts')
+    const storageMod = await import('./src/lib/server/storage')
     const storage = storageMod.default || storageMod['module.exports'] || storageMod
-    const threadMod = await import('./src/lib/server/agent-thread-session.ts')
+    const threadMod = await import('./src/lib/server/agent-thread-session')
     const ensureAgentThreadSession = threadMod.ensureAgentThreadSession
       || threadMod.default?.ensureAgentThreadSession
       || threadMod['module.exports']?.ensureAgentThreadSession
-    const execMod = await import('./src/lib/server/chat-execution.ts')
+    const execMod = await import('./src/lib/server/chat-execution')
     const executeSessionChatTurn = execMod.executeSessionChatTurn
       || execMod.default?.executeSessionChatTurn
       || execMod['module.exports']?.executeSessionChatTurn

package/src/lib/server/chat-execution-eval-history.test.ts

@@ -35,10 +35,10 @@ function runWithTempDataDir(script: string) {
 
 test('executeSessionChatTurn persists internal eval user turns for same-thread recall', () => {
   const output = runWithTempDataDir(`
-    const storageMod = await import('./src/lib/server/storage.ts')
+    const storageMod = await import('./src/lib/server/storage')
     const storage = storageMod.default || storageMod['module.exports'] || storageMod
-    const providersMod = await import('./src/lib/providers/index.ts')
-    const execMod = await import('./src/lib/server/chat-execution.ts')
+    const providersMod = await import('./src/lib/providers/index')
+    const execMod = await import('./src/lib/server/chat-execution')
     const executeSessionChatTurn = execMod.executeSessionChatTurn
       || execMod.default?.executeSessionChatTurn
       || execMod['module.exports']?.executeSessionChatTurn

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

@@ -1,7 +1,13 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
 import type { Message } from '@/types'
-import { pruneSuppressedHeartbeatStreamMessage, shouldApplySessionFreshnessReset } from './chat-execution'
+import {
+  buildAgentRuntimeCapabilities,
+  buildEnabledToolsAutonomyGuidance,
+  buildNoToolsGuidance,
+  pruneSuppressedHeartbeatStreamMessage,
+  shouldApplySessionFreshnessReset,
+} from './chat-execution'
 
 describe('pruneSuppressedHeartbeatStreamMessage', () => {
   it('removes a trailing streaming assistant heartbeat artifact', () => {
@@ -37,4 +43,39 @@ describe('pruneSuppressedHeartbeatStreamMessage', () => {
     assert.equal(shouldApplySessionFreshnessReset('heartbeat'), true)
     assert.equal(shouldApplySessionFreshnessReset('eval'), false)
   })
+
+  it('does not advertise tool capabilities when no plugins are enabled', () => {
+    assert.deepEqual(buildAgentRuntimeCapabilities([]), ['heartbeats', 'autonomous_loop', 'multi_agent_chat'])
+    assert.deepEqual(buildAgentRuntimeCapabilities(['web']), ['tools', 'heartbeats', 'autonomous_loop', 'multi_agent_chat'])
+  })
+
+  it('tells no-tool agents to report missing capability instead of asking for approval', () => {
+    const guidance = buildNoToolsGuidance().join('\n')
+    assert.match(guidance, /No session tools are enabled/i)
+    assert.match(guidance, /Do not imply that a normal read-only action is waiting on user permission or approval/i)
+    assert.match(guidance, /state that the capability is not enabled in this session/i)
+  })
+
+  it('tells tool-enabled agents to use enabled tools autonomously before asking for permission', () => {
+    const guidance = buildEnabledToolsAutonomyGuidance().join('\n')
+    assert.match(guidance, /Enabled session tools are already available for normal use/i)
+    assert.match(guidance, /Do not ask the user for permission before using enabled tools/i)
+    assert.match(guidance, /attempt that tool path before asking the user to do the work manually/i)
+    assert.match(guidance, /Only surface approval or permission as a blocker when a real runtime tool result explicitly requires approval/i)
+  })
+
+  it('tells tool-enabled agents when approvals are disabled platform-wide', () => {
+    const guidance = buildEnabledToolsAutonomyGuidance({ approvalsEnabled: false }).join('\n')
+    assert.match(guidance, /Approvals are disabled platform-wide in this runtime/i)
+    assert.match(guidance, /Do not tell the user that enabled tool use is waiting on approval/i)
+  })
+
+  it('tells tool-enabled agents which approval categories auto-approve', () => {
+    const guidance = buildEnabledToolsAutonomyGuidance({
+      approvalsEnabled: true,
+      approvalAutoApproveCategories: ['tool_access', 'wallet_action'],
+    }).join('\n')
+    assert.match(guidance, /These approval categories auto-approve in this runtime: tool_access, wallet_action/i)
+    assert.match(guidance, /call the tool and let the runtime auto-approve it instead of asking the user first in prose/i)
+  })
 })

package/src/lib/server/chat-execution-session-sync.test.ts

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-chat-session-sync-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+        BROWSER_PROFILES_DIR: path.join(tempDir, 'browser-profiles'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('executeSessionChatTurn syncs updated agent runtime fields onto its thread session', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const providersMod = await import('./src/lib/providers/index')
+    const threadMod = await import('./src/lib/server/agent-thread-session')
+    const execMod = await import('./src/lib/server/chat-execution')
+    const ensureAgentThreadSession = threadMod.ensureAgentThreadSession
+      || threadMod.default?.ensureAgentThreadSession
+      || threadMod['module.exports']?.ensureAgentThreadSession
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+    const providers = providersMod.PROVIDERS
+      || providersMod.default?.PROVIDERS
+      || providersMod['module.exports']?.PROVIDERS
+
+    providers['test-provider'] = {
+      id: 'test-provider',
+      name: 'Test Provider',
+      models: ['unit'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        async streamChat() {
+          return 'synced'
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      molly: {
+        id: 'molly',
+        name: 'Molly',
+        description: 'Thread session sync test',
+        provider: 'openai',
+        model: 'old-model',
+        credentialId: null,
+        apiEndpoint: null,
+        fallbackCredentialIds: [],
+        disabled: false,
+        heartbeatEnabled: false,
+        heartbeatIntervalSec: null,
+        plugins: ['memory'],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+
+    const session = ensureAgentThreadSession('molly')
+    const agents = storage.loadAgents()
+    agents.molly.provider = 'test-provider'
+    agents.molly.model = 'unit'
+    agents.molly.plugins = []
+    agents.molly.heartbeatEnabled = true
+    agents.molly.heartbeatIntervalSec = 90
+    agents.molly.updatedAt = now + 1
+    storage.saveAgents(agents)
+
+    const result = await executeSessionChatTurn({
+      sessionId: session.id,
+      message: 'hello',
+      runId: 'run-session-sync',
+    })
+
+    const persisted = storage.loadSession(session.id)
+    console.log(JSON.stringify({
+      text: result.text || null,
+      provider: persisted?.provider || null,
+      model: persisted?.model || null,
+      plugins: persisted?.plugins || [],
+      heartbeatEnabled: persisted?.heartbeatEnabled ?? null,
+      heartbeatIntervalSec: persisted?.heartbeatIntervalSec ?? null,
+    }))
+  `)
+
+  assert.equal(output.text, 'synced')
+  assert.equal(output.provider, 'test-provider')
+  assert.equal(output.model, 'unit')
+  assert.deepEqual(output.plugins, [])
+  assert.equal(output.heartbeatEnabled, true)
+  assert.equal(output.heartbeatIntervalSec, 90)
+})

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

@@ -0,0 +1,116 @@
+import type { MessageToolEvent, SSEEvent } from '@/types'
+
+export function extractEventJson(line: string): SSEEvent | null {
+  if (!line.startsWith('data: ')) return null
+  try {
+    return JSON.parse(line.slice(6).trim()) as SSEEvent
+  } catch {
+    return null
+  }
+}
+
+export function isLikelyToolErrorOutput(output: string): boolean {
+  const trimmed = String(output || '').trim()
+  if (!trimmed) return false
+  if (/^(Error(?::|\s*\(exit\b[^)]*\):?)|error:)/i.test(trimmed)) return true
+  if (/\b(MCP error|ECONNREFUSED|ETIMEDOUT|ERR_CONNECTION_REFUSED|ENOENT|EACCES)\b/i.test(trimmed)) return true
+  if (/\binvalid_type\b/i.test(trimmed) && /\b(issue|issues|expected|required|received|zod)\b/i.test(trimmed)) return true
+  try {
+    const parsed = JSON.parse(trimmed) as Record<string, unknown>
+    const status = typeof parsed.status === 'string' ? parsed.status.trim().toLowerCase() : ''
+    if (status === 'error' || status === 'failed') return true
+    if (typeof parsed.error === 'string' && parsed.error.trim()) return true
+  } catch {
+    // Ignore non-JSON tool output.
+  }
+  return false
+}
+
+export function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
+  if (ev.t === 'tool_call') {
+    const previous = bag[bag.length - 1]
+    if (
+      previous
+      && previous.name === (ev.toolName || 'unknown')
+      && previous.input === (ev.toolInput || '')
+      && previous.toolCallId === (ev.toolCallId || previous.toolCallId)
+      && !previous.output
+    ) {
+      return
+    }
+    bag.push({
+      name: ev.toolName || 'unknown',
+      input: ev.toolInput || '',
+      toolCallId: ev.toolCallId,
+    })
+    return
+  }
+  if (ev.t === 'tool_result') {
+    const idx = ev.toolCallId
+      ? bag.findLastIndex((event) => event.toolCallId === ev.toolCallId && !event.output)
+      : bag.findLastIndex((event) => event.name === (ev.toolName || 'unknown') && !event.output)
+    if (idx === -1) return
+    const output = ev.toolOutput || ''
+    bag[idx] = {
+      ...bag[idx],
+      output,
+      error: isLikelyToolErrorOutput(output) || undefined,
+    }
+  }
+}
+
+export function dedupeConsecutiveToolEvents(events: MessageToolEvent[]): MessageToolEvent[] {
+  const sameEvent = (left: MessageToolEvent, right: MessageToolEvent): boolean => (
+    left.name === right.name
+    && left.input === right.input
+    && (left.output || '') === (right.output || '')
+    && (left.error === true) === (right.error === true)
+  )
+  const sameBlock = (startA: number, startB: number, size: number): boolean => {
+    for (let offset = 0; offset < size; offset += 1) {
+      if (!sameEvent(events[startA + offset], events[startB + offset])) return false
+    }
+    return true
+  }
+
+  const deduped: MessageToolEvent[] = []
+  for (let index = 0; index < events.length;) {
+    const remaining = events.length - index
+    let collapsed = false
+    for (let blockSize = Math.floor(remaining / 2); blockSize >= 1; blockSize -= 1) {
+      if (!sameBlock(index, index + blockSize, blockSize)) continue
+      for (let offset = 0; offset < blockSize; offset += 1) deduped.push(events[index + offset])
+      const blockStart = index
+      index += blockSize
+      while (index + blockSize <= events.length && sameBlock(blockStart, index, blockSize)) {
+        index += blockSize
+      }
+      collapsed = true
+      break
+    }
+    if (collapsed) continue
+    deduped.push(events[index])
+    index += 1
+  }
+  return deduped
+}
+
+export function deriveTerminalRunError(params: {
+  errorMessage?: string
+  fullResponse: string
+  streamErrors: string[]
+  toolEvents: MessageToolEvent[]
+  internal: boolean
+}): string | undefined {
+  if (params.errorMessage) return params.errorMessage
+
+  if (params.streamErrors.length > 0 && !params.fullResponse.trim()) {
+    return params.streamErrors[params.streamErrors.length - 1]
+  }
+
+  if (!params.internal && !params.fullResponse.trim() && params.toolEvents.length === 0) {
+    return 'Run completed without any response text, tool calls, or explicit error details. Check the provider configuration and try again.'
+  }
+
+  return undefined
+}