@swarmclawai/swarmclaw 0.7.8 → 0.8.0

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

@@ -0,0 +1,94 @@
+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-disabled-'))
+  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 persists a visible error for disabled agents', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage.ts')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const threadMod = await import('./src/lib/server/agent-thread-session.ts')
+    const ensureAgentThreadSession = threadMod.ensureAgentThreadSession
+      || threadMod.default?.ensureAgentThreadSession
+      || threadMod['module.exports']?.ensureAgentThreadSession
+    const execMod = await import('./src/lib/server/chat-execution.ts')
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+
+    const now = Date.now()
+    storage.saveAgents({
+      molly: {
+        id: 'molly',
+        name: 'Molly',
+        description: 'Temporarily disabled helper',
+        provider: 'openai',
+        model: 'gpt-test',
+        credentialId: null,
+        apiEndpoint: null,
+        fallbackCredentialIds: [],
+        disabled: false,
+        createdAt: now,
+        updatedAt: now,
+        plugins: ['memory'],
+      },
+    })
+
+    const session = ensureAgentThreadSession('molly')
+    const agents = storage.loadAgents()
+    agents.molly.disabled = true
+    storage.saveAgents(agents)
+
+    const result = await executeSessionChatTurn({
+      sessionId: session.id,
+      message: 'hello',
+      runId: 'run-disabled-smoke',
+    })
+    const persisted = storage.loadSessions()[session.id]
+    const lastMessage = persisted.messages[persisted.messages.length - 1]
+
+    console.log(JSON.stringify({
+      error: result.error || null,
+      text: result.text || null,
+      persisted: result.persisted || false,
+      lastRole: lastMessage?.role || null,
+      lastText: lastMessage?.text || null,
+    }))
+  `)
+
+  assert.equal(output.persisted, true)
+  assert.equal(output.lastRole, 'assistant')
+  assert.match(String(output.error || ''), /disabled/i)
+  assert.match(String(output.text || ''), /disabled/i)
+  assert.match(String(output.lastText || ''), /disabled/i)
+})

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

@@ -6,9 +6,12 @@ import path from 'path'
 import type { MessageToolEvent, SSEEvent } from '@/types'
 import {
   collectToolEvent,
+  deriveTerminalRunError,
   dedupeConsecutiveToolEvents,
+  hasDirectLocalCodingTools,
   isLikelyToolErrorOutput,
   normalizeAssistantArtifactLinks,
+  reconcileConnectorDeliveryText,
   requestedToolNamesFromMessage,
   translateRequestedToolInvocation,
 } from './chat-execution'
@@ -20,6 +23,7 @@ describe('collectToolEvent', () => {
       t: 'tool_call',
       toolName: 'files',
       toolInput: '{"path":"spec.md"}',
+      toolCallId: 'call-1',
     }
 
     collectToolEvent(toolCall, bag)
@@ -29,6 +33,7 @@ describe('collectToolEvent', () => {
       {
         name: 'files',
         input: '{"path":"spec.md"}',
+        toolCallId: 'call-1',
       },
     ])
   })
@@ -39,11 +44,13 @@ describe('collectToolEvent', () => {
       t: 'tool_call',
       toolName: 'files',
       toolInput: '{"path":"spec.md"}',
+      toolCallId: 'call-1',
     }
     const toolResult: SSEEvent = {
       t: 'tool_result',
       toolName: 'files',
       toolOutput: 'Written spec.md (12 bytes)',
+      toolCallId: 'call-1',
     }
 
     collectToolEvent(toolCall, bag)
@@ -56,10 +63,12 @@ describe('collectToolEvent', () => {
         input: '{"path":"spec.md"}',
         output: 'Written spec.md (12 bytes)',
         error: undefined,
+        toolCallId: 'call-1',
       },
       {
         name: 'files',
         input: '{"path":"spec.md"}',
+        toolCallId: 'call-1',
       },
     ])
   })
@@ -70,26 +79,61 @@ describe('collectToolEvent', () => {
       t: 'tool_call',
       toolName: 'shell',
       toolInput: '{"command":"python broken.py"}',
+      toolCallId: 'call-shell',
     }, bag)
     collectToolEvent({
       t: 'tool_result',
       toolName: 'shell',
       toolOutput: 'Error (exit 1): Traceback...',
+      toolCallId: 'call-shell',
     }, bag)
     collectToolEvent({
       t: 'tool_call',
       toolName: 'browser',
       toolInput: '{"command":"click"}',
+      toolCallId: 'call-browser',
     }, bag)
     collectToolEvent({
       t: 'tool_result',
       toolName: 'browser',
       toolOutput: '{"error":"MCP error -32000: invalid_type","issues":[{"code":"invalid_type"}]}',
+      toolCallId: 'call-browser',
     }, bag)
 
     assert.equal(bag[0].error, true)
     assert.equal(bag[1].error, true)
   })
+
+  it('matches parallel same-tool results by toolCallId instead of swapping outputs', () => {
+    const bag: MessageToolEvent[] = []
+    collectToolEvent({
+      t: 'tool_call',
+      toolName: 'wallet_tool',
+      toolInput: '{"action":"balance","chain":"solana"}',
+      toolCallId: 'call-sol',
+    }, bag)
+    collectToolEvent({
+      t: 'tool_call',
+      toolName: 'wallet_tool',
+      toolInput: '{"action":"balance","chain":"ethereum"}',
+      toolCallId: 'call-eth',
+    }, bag)
+    collectToolEvent({
+      t: 'tool_result',
+      toolName: 'wallet_tool',
+      toolOutput: '{"chain":"solana"}',
+      toolCallId: 'call-sol',
+    }, bag)
+    collectToolEvent({
+      t: 'tool_result',
+      toolName: 'wallet_tool',
+      toolOutput: '{"chain":"ethereum"}',
+      toolCallId: 'call-eth',
+    }, bag)
+
+    assert.equal(bag[0].output, '{"chain":"solana"}')
+    assert.equal(bag[1].output, '{"chain":"ethereum"}')
+  })
 })
 
 describe('dedupeConsecutiveToolEvents', () => {
@@ -126,6 +170,57 @@ describe('dedupeConsecutiveToolEvents', () => {
   })
 })
 
+describe('deriveTerminalRunError', () => {
+  it('uses the streamed provider error when no text was produced', () => {
+    assert.equal(
+      deriveTerminalRunError({
+        errorMessage: undefined,
+        fullResponse: '',
+        streamErrors: ['Ollama error (401): invalid api key'],
+        toolEvents: [],
+        internal: false,
+      }),
+      'Ollama error (401): invalid api key',
+    )
+  })
+
+  it('converts empty successful runs into a visible assistant error', () => {
+    assert.equal(
+      deriveTerminalRunError({
+        errorMessage: undefined,
+        fullResponse: '',
+        streamErrors: [],
+        toolEvents: [],
+        internal: false,
+      }),
+      'Run completed without any response text, tool calls, or explicit error details. Check the provider configuration and try again.',
+    )
+  })
+
+  it('does not invent an error when tools ran or when the run was internal', () => {
+    assert.equal(
+      deriveTerminalRunError({
+        errorMessage: undefined,
+        fullResponse: '',
+        streamErrors: [],
+        toolEvents: [{ name: 'files', input: '{"action":"list"}', output: 'spec.md' }],
+        internal: false,
+      }),
+      undefined,
+    )
+    assert.equal(
+      deriveTerminalRunError({
+        errorMessage: undefined,
+        fullResponse: '',
+        streamErrors: [],
+        toolEvents: [],
+        internal: true,
+      }),
+      undefined,
+    )
+  })
+})
+
 describe('requestedToolNamesFromMessage', () => {
   it('does not infer delegate from ordinary delegation prose', () => {
     assert.deepEqual(
@@ -140,6 +235,33 @@ describe('requestedToolNamesFromMessage', () => {
       ['delegate'],
     )
   })
+
+  it('ignores negated web mentions and ordinary browsing prose', () => {
+    assert.deepEqual(
+      requestedToolNamesFromMessage('Do not browse the web for this task.'),
+      [],
+    )
+    assert.deepEqual(
+      requestedToolNamesFromMessage('Avoid using browser for this step.'),
+      [],
+    )
+  })
+
+  it('detects explicit email tool requests', () => {
+    assert.deepEqual(
+      requestedToolNamesFromMessage('Use the email tool to send a welcome email after signup finishes.'),
+      ['email'],
+    )
+  })
+})
+
+describe('hasDirectLocalCodingTools', () => {
+  it('treats shell and file tooling as local coding capability', () => {
+    assert.equal(hasDirectLocalCodingTools({ plugins: ['files'] }), true)
+    assert.equal(hasDirectLocalCodingTools({ plugins: ['shell'] }), true)
+    assert.equal(hasDirectLocalCodingTools({ plugins: ['edit_file'] }), true)
+    assert.equal(hasDirectLocalCodingTools({ plugins: ['delegate'] }), false)
+  })
 })
 
 describe('normalizeAssistantArtifactLinks', () => {
@@ -217,3 +339,38 @@ describe('translateRequestedToolInvocation', () => {
     )
   })
 })
+
+describe('reconcileConnectorDeliveryText', () => {
+  it('overrides false connector success claims when no send succeeded', () => {
+    assert.equal(
+      reconcileConnectorDeliveryText(
+        `I've successfully sent the voice note to your WhatsApp.`,
+        [
+          {
+            name: 'connector_message_tool',
+            input: '{"action":"send_voice_note"}',
+            output: 'Error: {"detail":{"message":"Free users cannot use library voices via the API."}}',
+            error: true,
+          },
+        ],
+      ),
+      `I couldn't send that through the configured connector. Free users cannot use library voices via the API.`,
+    )
+  })
+
+  it('preserves connector success confirmations when a send completed', () => {
+    assert.equal(
+      reconcileConnectorDeliveryText(
+        `I've successfully sent the update to your WhatsApp.`,
+        [
+          {
+            name: 'connector_message_tool',
+            input: '{"action":"send"}',
+            output: '{"status":"sent","to":"447700900444@s.whatsapp.net"}',
+          },
+        ],
+      ),
+      `I've successfully sent the update to your WhatsApp.`,
+    )
+  })
+})