@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/README.md

@@ -148,7 +148,7 @@ curl -fsSL https://raw.githubusercontent.com/swarmclawai/swarmclaw/main/install.
 ```
 
 The installer resolves the latest stable release tag and installs that version by default.
-To pin a version: `SWARMCLAW_VERSION=v0.8.4 curl ... | bash`
+To pin a version: `SWARMCLAW_VERSION=v0.8.7 curl ... | bash`
 
 Or run locally from the repo (friendly for non-technical users):
 
@@ -701,8 +701,8 @@ npm run update:easy     # safe update helper for local installs
 SwarmClaw uses tag-based releases (`vX.Y.Z`) as the stable channel.
 
 ```bash
-# example minor release (v0.8.4 style)
-npm version minor
+# example patch release (v0.8.7 style)
+npm version patch
 git push origin main --follow-tags
 ```
 
@@ -711,14 +711,14 @@ On `v*` tags, GitHub Actions will:
 2. Create a GitHub Release
 3. Build and publish Docker images to `ghcr.io/swarmclawai/swarmclaw` (`:vX.Y.Z`, `:latest`, `:sha-*`)
 
-#### v0.8.4 Release Readiness Notes
+#### v0.8.7 Release Readiness Notes
 
-Before shipping `v0.8.4`, confirm the following user-facing changes are reflected in docs:
+Before shipping `v0.8.7`, confirm the following user-facing changes are reflected in docs:
 
-1. Connector/runtime docs note that the current patch line includes the connector-manager follow-up fix already shipped in the latest app commit.
-2. Chat/session docs still note that the chat index serves lightweight session summaries instead of full transcript payloads, and full messages are loaded from per-chat endpoints.
-3. Operator/runtime docs still note that the daemon owns scheduler/queue startup; background services should be described from the daemon controls rather than as unconditional boot behavior.
-4. Site and README install/version strings are updated to `v0.8.4`, including install snippets, release notes index text, and sidebar/footer labels.
+1. Install/update docs note that `v0.8.7` repairs the committed npm lockfile so `npm ci` succeeds again on clean GitHub Actions and operator installs.
+2. Site and README install/version strings are updated to `v0.8.7`, including install snippets, release notes index text, and sidebar/footer labels.
+3. Release notes make it explicit that this patch is a packaging/install integrity fix on top of the `v0.8.6` runtime changes, not a new behavior rollout.
+4. The release branch and `main` stay aligned so the shipped tag points at the same commit users see on the default branch.
 
 ## CLI
 

package/bin/swarmclaw.js

@@ -110,11 +110,15 @@ async function main() {
   const argv = process.argv.slice(2)
   const top = argv[0]
 
-  // Route 'server' and 'update' subcommands to CJS scripts (no TS dependency).
+  // Route 'server', 'worker', and 'update' subcommands to CJS scripts (no TS dependency).
   if (top === 'server') {
     require('./server-cmd.js').main()
     return
   }
+  if (top === 'worker') {
+    require('./worker-cmd.js').main()
+    return
+  }
   if (top === 'update') {
     require('./update-cmd.js').main()
     return

package/bin/worker-cmd.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+const { spawn } = require('node:child_process')
+
+function printHelp() {
+  const help = `
+Usage: swarmclaw worker [options]
+
+Starts a dedicated background worker process for SwarmClaw to process background
+queues and tasks independently of the Next.js web application.
+
+Options:
+  -h, --help        Show this help message
+`.trim()
+  console.log(help)
+}
+
+function main() {
+  const args = process.argv.slice(3)
+  for (const arg of args) {
+    if (arg === '-h' || arg === '--help') {
+      printHelp()
+      process.exit(0)
+    } else {
+      console.error(`[swarmclaw] Unknown argument: ${arg}`)
+      printHelp()
+      process.exit(1)
+    }
+  }
+
+  const SWARMCLAW_HOME = process.env.SWARMCLAW_HOME || path.join(os.homedir(), '.swarmclaw')
+  const DATA_DIR = path.join(SWARMCLAW_HOME, 'data')
+
+  process.env.DATA_DIR = DATA_DIR
+  process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = '1'
+  // Flag that tells Next.js NOT to start the HTTP/Websocket listener, just boot the daemon.
+  process.env.SWARMCLAW_WORKER_ONLY = '1'
+
+  console.log(`[swarmclaw] Starting dedicated background worker...`)
+  console.log(`[swarmclaw] Data directory: ${DATA_DIR}`)
+
+  // We reuse the built server.js but signal it to only run the daemon
+  const standaloneBase = path.join(SWARMCLAW_HOME, '.next', 'standalone')
+  let serverJs = path.join(standaloneBase, 'server.js')
+  
+  if (!fs.existsSync(serverJs)) {
+     console.error('Standalone server.js not found. Try running: swarmclaw server --build')
+     process.exit(1)
+  }
+
+  const child = spawn(process.execPath, [serverJs], {
+    env: process.env,
+    stdio: 'inherit',
+  })
+
+  child.on('exit', (code) => {
+    process.exit(code || 0)
+  })
+
+  for (const sig of ['SIGINT', 'SIGTERM']) {
+    process.on(sig, () => child.kill(sig))
+  }
+}
+
+if (require.main === module) {
+  main()
+}
+
+module.exports = { main }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "0.8.4",
+  "version": "0.8.7",
   "description": "Self-hosted AI agent orchestration dashboard — manage LLM providers, orchestrate agent swarms, schedule tasks, and bridge agents to chat platforms.",
   "license": "MIT",
   "publishConfig": {
@@ -50,6 +50,7 @@
     "start": "node .next/standalone/server.js",
     "start:standalone": "node .next/standalone/server.js",
     "smoke:browser": "node ./scripts/browser-route-smoke.mjs",
+    "smoke:browser:workbench": "node ./scripts/browser-workbench-smoke.mjs",
     "benchmark:autonomy": "node ./scripts/benchmark-autonomy-harness.mjs",
     "benchmark:agent-regression": "node --import tsx ./scripts/run-agent-regression-suite.ts",
     "lint": "eslint",

package/src/app/api/agents/[id]/route.ts

@@ -1,16 +1,21 @@
 import { NextResponse } from 'next/server'
-import { loadAgents, saveAgents, loadSessions, saveSessions, logActivity } from '@/lib/server/storage'
+import { loadAgents, saveAgents, loadSessions, logActivity, upsertStoredItem, upsertStoredItems } from '@/lib/server/storage'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
 import { mutateItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+import { ensureAgentThreadSession } from '@/lib/server/agent-thread-session'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const ops: CollectionOps<any> = { load: () => loadAgents({ includeTrashed: true }), save: saveAgents, topic: 'agents' }
+const ops: CollectionOps<any> = { load: () => loadAgents({ includeTrashed: true }), save: saveAgents, topic: 'agents', table: 'agents' }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
   const result = mutateItem(ops, id, (agent) => {
     Object.assign(agent, body, { updatedAt: Date.now() })
+    if (Array.isArray(body.plugins) || Array.isArray(body.tools)) {
+      agent.plugins = Array.isArray(body.plugins) ? body.plugins : body.tools
+      delete (agent as Record<string, unknown>).tools
+    }
     if (body.platformAssignScope === 'all' || body.platformAssignScope === 'self') {
       agent.platformAssignScope = body.platformAssignScope
       agent.isOrchestrator = body.platformAssignScope === 'all'
@@ -64,6 +69,10 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   })
   if (!result) return notFound()
 
+  if (result.threadSessionId) {
+    ensureAgentThreadSession(id)
+  }
+
   if (result.threadSessionId) {
     const sessions = loadSessions()
     const shortcut = sessions[result.threadSessionId]
@@ -77,7 +86,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
         shortcut.shortcutForAgentId = id
         changed = true
       }
-      if (changed) saveSessions(sessions)
+      if (changed) upsertStoredItem('sessions', shortcut.id, shortcut)
     }
   }
 
@@ -97,15 +106,16 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
 
   // Detach sessions from the trashed agent
   const sessions = loadSessions()
-  let detachedSessions = 0
+  const detached: Array<[string, unknown]> = []
   for (const session of Object.values(sessions) as Array<Record<string, unknown>>) {
     if (!session || session.agentId !== id) continue
     session.agentId = null
-    detachedSessions += 1
+    detached.push([session.id as string, session])
   }
-  if (detachedSessions > 0) {
-    saveSessions(sessions)
+  if (detached.length > 0) {
+    upsertStoredItems('sessions', detached)
   }
+  const detachedSessions = detached.length
 
   return NextResponse.json({ ok: true, detachedSessions })
 }

package/src/app/api/agents/route.ts

@@ -1,9 +1,11 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
-import { loadAgents, loadSessions, loadUsage, saveAgents, logActivity } from '@/lib/server/storage'
+import { perf } from '@/lib/server/perf'
+import { loadAgents, loadSessions, loadUsage, logActivity, upsertStoredItem } from '@/lib/server/storage'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
 import { notify } from '@/lib/server/ws-hub'
 import { getAgentSpendWindows } from '@/lib/server/cost'
+import { resolveAgentPluginSelection } from '@/lib/agent-default-tools'
 import { AgentCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { z } from 'zod'
 export const dynamic = 'force-dynamic'
@@ -15,6 +17,7 @@ async function ensureDaemonIfNeeded(source: string) {
 
 
 export async function GET(req: Request) {
+  const endPerf = perf.start('api', 'GET /api/agents')
   const agents = loadAgents()
   const sessions = loadSessions()
   const usage = loadUsage()
@@ -37,28 +40,38 @@ export async function GET(req: Request) {
 
   const { searchParams } = new URL(req.url)
   const limitParam = searchParams.get('limit')
-  if (!limitParam) return NextResponse.json(agents)
+  if (!limitParam) {
+    endPerf({ count: Object.keys(agents).length })
+    return NextResponse.json(agents)
+  }
 
   const limit = Math.max(1, Number(limitParam) || 50)
   const offset = Math.max(0, Number(searchParams.get('offset')) || 0)
   const all = Object.values(agents).sort((a, b) => b.updatedAt - a.updatedAt)
   const items = all.slice(offset, offset + limit)
+  endPerf({ count: items.length, total: all.length })
   return NextResponse.json({ items, total: all.length, hasMore: offset + limit < all.length })
 }
 
 export async function POST(req: Request) {
   await ensureDaemonIfNeeded('api/agents:post')
   const raw = await req.json()
+  const rawRecord = raw && typeof raw === 'object' ? raw as Record<string, unknown> : null
   const parsed = AgentCreateSchema.safeParse(raw)
   if (!parsed.success) {
     return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
   }
   const body = parsed.data
+  const plugins = resolveAgentPluginSelection({
+    hasExplicitPlugins: Boolean(rawRecord && Object.prototype.hasOwnProperty.call(rawRecord, 'plugins')),
+    hasExplicitTools: Boolean(rawRecord && Object.prototype.hasOwnProperty.call(rawRecord, 'tools')),
+    plugins: body.plugins,
+    tools: body.tools,
+  })
   const id = genId()
   const now = Date.now()
-  const agents = loadAgents()
   const platformAssignScope = body.platformAssignScope
-  agents[id] = {
+  const agent = {
     id,
     name: body.name,
     description: body.description,
@@ -80,7 +93,7 @@ export async function POST(req: Request) {
     isOrchestrator: platformAssignScope === 'all',
     platformAssignScope,
     subAgentIds: body.subAgentIds,
-    plugins: body.plugins?.length ? body.plugins : (body.tools || []),
+    plugins,
     skills: body.skills,
     skillIds: body.skillIds,
     mcpServerIds: body.mcpServerIds,
@@ -113,8 +126,8 @@ export async function POST(req: Request) {
     createdAt: now,
     updatedAt: now,
   }
-  saveAgents(agents)
-  logActivity({ entityType: 'agent', entityId: id, action: 'created', actor: 'user', summary: `Agent created: "${agents[id].name}"` })
+  upsertStoredItem('agents', id, agent)
+  logActivity({ entityType: 'agent', entityId: id, action: 'created', actor: 'user', summary: `Agent created: "${agent.name}"` })
   notify('agents')
-  return NextResponse.json(agents[id])
+  return NextResponse.json(agent)
 }

package/src/app/api/approvals/route.test.ts

@@ -34,9 +34,9 @@ function runWithTempDataDir(script: string) {
 
 test('GET and POST /api/approvals smoke the pending approval flow end-to-end', () => {
   const output = runWithTempDataDir(`
-    const storageMod = await import('./src/lib/server/storage.ts')
-    const approvalsMod = await import('./src/lib/server/approvals.ts')
-    const routeMod = await import('./src/app/api/approvals/route.ts')
+    const storageMod = await import('./src/lib/server/storage')
+    const approvalsMod = await import('./src/lib/server/approvals')
+    const routeMod = await import('./src/app/api/approvals/route')
     const storage = storageMod.default || storageMod
     const approvals = approvalsMod.default || approvalsMod
     const route = routeMod.default || routeMod
@@ -88,9 +88,9 @@ test('GET and POST /api/approvals smoke the pending approval flow end-to-end', (
 
 test('POST /api/approvals rejects invalid payloads and remains idempotent for repeated decisions', () => {
   const output = runWithTempDataDir(`
-    const storageMod = await import('./src/lib/server/storage.ts')
-    const approvalsMod = await import('./src/lib/server/approvals.ts')
-    const routeMod = await import('./src/app/api/approvals/route.ts')
+    const storageMod = await import('./src/lib/server/storage')
+    const approvalsMod = await import('./src/lib/server/approvals')
+    const routeMod = await import('./src/app/api/approvals/route')
     const storage = storageMod.default || storageMod
     const approvals = approvalsMod.default || approvalsMod
     const route = routeMod.default || routeMod

package/src/app/api/approvals/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server'
 import { listPendingApprovals, submitDecision } from '@/lib/server/approvals'
+import { errorMessage } from '@/lib/shared-utils'
 
 export const dynamic = 'force-dynamic'
 
@@ -17,6 +18,6 @@ export async function POST(req: Request) {
     await submitDecision(id, approved)
     return NextResponse.json({ ok: true })
   } catch (err: unknown) {
-    return NextResponse.json({ error: err instanceof Error ? err.message : String(err) }, { status: 500 })
+    return NextResponse.json({ error: errorMessage(err) }, { status: 500 })
   }
 }

package/src/app/api/auth/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { validateAccessKey, isFirstTimeSetup, markSetupComplete } from '@/lib/server/storage'
 import { AUTH_COOKIE_NAME, getCookieValue } from '@/lib/auth'
 import { isProductionRuntime } from '@/lib/runtime-env'
+import { hmrSingleton } from '@/lib/shared-utils'
 export const dynamic = 'force-dynamic'
 
 interface AuthAttemptEntry {
@@ -9,9 +10,7 @@ interface AuthAttemptEntry {
   lockedUntil: number
 }
 
-const authRateLimitMap = (
-  (globalThis as Record<string, unknown>).__swarmclaw_auth_rate_limit__ ??= new Map()
-) as Map<string, AuthAttemptEntry>
+const authRateLimitMap = hmrSingleton('__swarmclaw_auth_rate_limit__', () => new Map<string, AuthAttemptEntry>())
 
 const MAX_ATTEMPTS = 5
 const LOCKOUT_MS = 15 * 60 * 1000

package/src/app/api/chatrooms/[id]/chat/route.test.ts

@@ -0,0 +1,299 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('chatroom route prevents duplicate chained replies when an already-queued agent is re-mentioned', () => {
+  const output = runWithTempDataDir<{
+    assistantCounts: Record<string, number>
+    startCounts: Record<string, number>
+    doneCounts: Record<string, number>
+    messageTexts: string[]
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chatrooms/[id]/chat/route')
+    const streamMod = await import('./src/lib/server/stream-agent-chat')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const stream = streamMod.default || streamMod
+
+    providers.PROVIDERS['chatroom-provider'] = {
+      id: 'chatroom-provider',
+      name: 'Chatroom Provider',
+      models: ['room-model'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: { streamChat: async () => '' },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      alpha: {
+        id: 'alpha',
+        name: 'Alpha',
+        provider: 'chatroom-provider',
+        model: 'room-model',
+        plugins: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+      beta: {
+        id: 'beta',
+        name: 'Beta',
+        provider: 'chatroom-provider',
+        model: 'room-model',
+        plugins: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveChatrooms({
+      room_1: {
+        id: 'room_1',
+        name: 'Workbench Room',
+        agentIds: ['alpha', 'beta'],
+        messages: [],
+        createdAt: now,
+        updatedAt: now,
+        chatMode: 'sequential',
+        autoAddress: false,
+      },
+    })
+
+    async function readSse(response) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const events = []
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        let idx = buffer.indexOf('\\n\\n')
+        while (idx !== -1) {
+          const chunk = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          const line = chunk
+            .split('\\n')
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith('data: '))
+          if (line) {
+            events.push(JSON.parse(line.slice(6)))
+          }
+          idx = buffer.indexOf('\\n\\n')
+        }
+      }
+      return events
+    }
+
+    stream.setStreamAgentChatForTest(async (opts) => {
+      const agentId = opts.session?.agentId
+      if (agentId === 'alpha') {
+        const reply = '@Beta please double-check this. Alpha found the first issue.'
+        opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+        return { fullText: reply, finalResponse: reply }
+      }
+      if (agentId === 'beta') {
+        const reply = 'Beta checked it and confirmed the fix.'
+        opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+        return { fullText: reply, finalResponse: reply }
+      }
+      return { fullText: '', finalResponse: '' }
+    })
+
+    try {
+      const response = await route.POST(
+        new Request('http://local/api/chatrooms/room_1/chat', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ senderId: 'user', text: '@Alpha @Beta coordinate on this fix.' }),
+        }),
+        { params: Promise.resolve({ id: 'room_1' }) },
+      )
+
+      const events = await readSse(response)
+      const chatroom = storage.loadChatrooms().room_1
+      const assistantMessages = chatroom.messages.filter((entry) => entry.role === 'assistant')
+      const assistantCounts = assistantMessages.reduce((acc, entry) => {
+        acc[entry.senderId] = (acc[entry.senderId] || 0) + 1
+        return acc
+      }, {})
+      const startCounts = events
+        .filter((entry) => entry.t === 'cr_agent_start')
+        .reduce((acc, entry) => {
+          acc[entry.agentId] = (acc[entry.agentId] || 0) + 1
+          return acc
+        }, {})
+      const doneCounts = events
+        .filter((entry) => entry.t === 'cr_agent_done')
+        .reduce((acc, entry) => {
+          acc[entry.agentId] = (acc[entry.agentId] || 0) + 1
+          return acc
+        }, {})
+
+      console.log(JSON.stringify({
+        assistantCounts,
+        startCounts,
+        doneCounts,
+        messageTexts: assistantMessages.map((entry) => entry.text),
+      }))
+    } finally {
+      stream.setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-chatroom-route-test-' })
+
+  assert.deepEqual(output.assistantCounts, { alpha: 1, beta: 1 })
+  assert.deepEqual(output.startCounts, { alpha: 1, beta: 1 })
+  assert.deepEqual(output.doneCounts, { alpha: 1, beta: 1 })
+  assert.equal(output.messageTexts.some((text) => /double-check/i.test(text)), true)
+  assert.equal(output.messageTexts.some((text) => /confirmed the fix/i.test(text)), true)
+})
+
+test('chatroom route forwards tool activity and records one reply per participating agent', () => {
+  const output = runWithTempDataDir<{
+    toolCalls: string[]
+    toolResults: string[]
+    assistantCounts: Record<string, number>
+    agentOrder: string[]
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chatrooms/[id]/chat/route')
+    const streamMod = await import('./src/lib/server/stream-agent-chat')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const stream = streamMod.default || streamMod
+
+    providers.PROVIDERS['chatroom-tool-provider'] = {
+      id: 'chatroom-tool-provider',
+      name: 'Chatroom Tool Provider',
+      models: ['room-tool-model'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: { streamChat: async () => '' },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      alpha: {
+        id: 'alpha',
+        name: 'Alpha',
+        provider: 'chatroom-tool-provider',
+        model: 'room-tool-model',
+        plugins: ['shell'],
+        createdAt: now,
+        updatedAt: now,
+      },
+      beta: {
+        id: 'beta',
+        name: 'Beta',
+        provider: 'chatroom-tool-provider',
+        model: 'room-tool-model',
+        plugins: ['shell'],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveChatrooms({
+      room_1: {
+        id: 'room_1',
+        name: 'Parallel Workbench Room',
+        agentIds: ['alpha', 'beta'],
+        messages: [],
+        createdAt: now,
+        updatedAt: now,
+        chatMode: 'parallel',
+        autoAddress: true,
+      },
+    })
+
+    async function readSse(response) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const events = []
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        let idx = buffer.indexOf('\\n\\n')
+        while (idx !== -1) {
+          const chunk = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          const line = chunk
+            .split('\\n')
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith('data: '))
+          if (line) {
+            events.push(JSON.parse(line.slice(6)))
+          }
+          idx = buffer.indexOf('\\n\\n')
+        }
+      }
+      return events
+    }
+
+    stream.setStreamAgentChatForTest(async (opts) => {
+      const agentId = opts.session?.agentId
+      if (agentId === 'alpha') {
+        opts.write('data: ' + JSON.stringify({
+          t: 'tool_call',
+          toolName: 'shell',
+          toolInput: 'pwd',
+          toolCallId: 'alpha-shell',
+        }) + '\\n')
+        opts.write('data: ' + JSON.stringify({
+          t: 'tool_result',
+          toolName: 'shell',
+          toolOutput: process.env.WORKSPACE_DIR,
+          toolCallId: 'alpha-shell',
+        }) + '\\n')
+        const reply = 'Alpha inspected the workspace root and found the repo is ready.'
+        opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+        return { fullText: reply, finalResponse: reply }
+      }
+      if (agentId === 'beta') {
+        const reply = 'Beta reviewed the plugin path and agrees with Alpha.'
+        opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+        return { fullText: reply, finalResponse: reply }
+      }
+      return { fullText: '', finalResponse: '' }
+    })
+
+    try {
+      const response = await route.POST(
+        new Request('http://local/api/chatrooms/room_1/chat', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ senderId: 'user', text: 'Please inspect the workspace and plugin path.' }),
+        }),
+        { params: Promise.resolve({ id: 'room_1' }) },
+      )
+
+      const events = await readSse(response)
+      const chatroom = storage.loadChatrooms().room_1
+      const assistantMessages = chatroom.messages.filter((entry) => entry.role === 'assistant')
+      const assistantCounts = assistantMessages.reduce((acc, entry) => {
+        acc[entry.senderId] = (acc[entry.senderId] || 0) + 1
+        return acc
+      }, {})
+
+      console.log(JSON.stringify({
+        toolCalls: events.filter((entry) => entry.t === 'tool_call').map((entry) => entry.toolName),
+        toolResults: events.filter((entry) => entry.t === 'tool_result').map((entry) => entry.toolOutput),
+        assistantCounts,
+        agentOrder: assistantMessages.map((entry) => entry.senderId),
+      }))
+    } finally {
+      stream.setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-chatroom-route-tools-' })
+
+  assert.deepEqual(output.toolCalls, ['shell'])
+  assert.equal(output.toolResults.length, 1)
+  assert.deepEqual(output.assistantCounts, { alpha: 1, beta: 1 })
+  assert.deepEqual([...new Set(output.agentOrder)].sort(), ['alpha', 'beta'])
+})