@swarmclawai/swarmclaw 1.5.62 → 1.5.63

package/README.md

@@ -399,6 +399,14 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.5.63 Highlights
+
+Chatroom fix from @borislavnnikolov: CLI-backed agents (codex-cli, copilot-cli, gemini-cli, and the rest of the `NON_LANGGRAPH_PROVIDER_IDS` set) now work correctly as chatroom members instead of falling through a LangGraph path they cannot run. With the execution path fixed, the worker-only membership blocks are lifted too, so any non-trashed agent can be added to a room.
+
+- **Direct provider runtime for CLI chatroom turns.** `src/app/api/chatrooms/[id]/chat/route.ts` now branches on `NON_LANGGRAPH_PROVIDER_IDS` and calls `provider.handler.streamChat()` directly for CLI-backed agents while keeping the LangGraph `streamAgentChat` path for everything else. Streaming, tool events, and persisted messages all flow through unchanged.
+- **Full member selection.** The create, update, members, session-tool, and UI layers (`src/app/api/chatrooms/route.ts`, `src/app/api/chatrooms/[id]/route.ts`, `src/app/api/chatrooms/[id]/members/route.ts`, `src/lib/server/session-tools/chatroom.ts`, `src/components/chatrooms/chatroom-sheet.tsx`) no longer reject or hide worker-only agents. Any non-trashed agent is eligible.
+- **Regression test.** `src/app/api/chatrooms/[id]/chat/route.test.ts` proves a `codex-cli`-backed chatroom turn bypasses `streamAgentChat`, streams a response through the provider handler, and persists one assistant reply.
+
 ### v1.5.62 Highlights
 
 Hardens parallel sub-agent dispatch with a concurrency cap, a quorum join policy, and a cycle check — so a fan-out can't accidentally saturate providers, melt a mission budget, or wedge the runtime on a delegation loop.
@@ -432,16 +440,6 @@ Viral-loop release. Adds public share links for missions, skills, and sessions,
 - **Share-link-based skill install.** `POST /api/skills/import` already accepts an http(s) URL; pointing it at `https://<your-host>/api/s/<token>/raw` now installs a shared skill from another SwarmClaw instance without auth handshakes. Pairs naturally with existing `swarmclaw skills import` CLI.
 - **Share-link repository tests.** `share-link-repository.test.ts` covers mint / list / revoke / lookup-by-token round-trip plus expiry handling against a temporary data dir.
 
-### v1.5.58 Highlights
-
-This release broadens the built-in evaluation harness so SwarmClaw runs can be benchmarked against named suites, adds two targeted starter kits, exposes live per-session cost data, tightens auto-skill drafting, and ships a zero-setup demo mission template.
-
-- **Benchmark-style eval suites.** New `SWEBENCH_LITE_SCENARIOS` and `GAIA_L1_SCENARIOS` in `src/lib/server/eval/scenarios-swebench.ts` and `scenarios-gaia.ts` — curated parallels (not the upstream datasets) sized for a single-agent harness run. The shared `EvalScenario` type now carries an optional `suite: 'core' | 'swe-bench-lite' | 'gaia-l1' | 'tool-use' | 'code-action'` tag. `POST /api/eval/suite` accepts `{ suite: "swe-bench-lite" }` to scope a run. New `GET /api/eval/suites` lists every suite with scenario count, max score, and categories. CLI commands: `swarmclaw eval suites`, and `swarmclaw eval suite` still takes a JSON body now including `suite`. Useful for advertising verifiable numbers against a named benchmark instead of a bespoke scoring rubric.
-- **Two additional starter kits.** `inbox_triage` (single Triager agent over email + memory + documents) and `data_analyst` (single Analyst agent over shell + files + web + documents) join the existing seven kits in `src/lib/setup-defaults.ts`. Both are surfaced on the intent-driven setup path alongside Personal Assistant, Research Copilot, Builder Studio, and Delegate Team.
-- **Live per-session usage API.** New `GET /api/usage/live?sessionId=...` returns a lightweight snapshot — records, tokens in/out, estimated cost, firstAt/lastAt, wallclockMs, turns — so frontends can surface a live cost meter without pulling the full aggregated `/api/usage` payload. Without a `sessionId` the route returns the ten most recently active sessions. Registered in the CLI as `swarmclaw usage live`.
-- **Auto-skill drafting is stricter and rate-limited.** `shouldAutoDraftSkillSuggestion` in `chat-turn-finalization.ts` now requires at least 3 tool events in the completed turn (was 1), and a new per-agent daily cap limits automatic drafts to 3 per day per agent to prevent suggestion-inbox spam. Both thresholds are named constants (`AUTO_DRAFT_MIN_TOOL_EVENTS`, `AUTO_DRAFT_DAILY_LIMIT`). Agents with `autoDraftSkillSuggestions = false` are unaffected (auto-drafting remains opt-in per agent).
-- **Hello World demo mission template.** New `hello-world-demo` entry in `BUILT_IN_MISSION_TEMPLATES` — a bounded, zero-setup mission that reads three files in the working directory and writes a one-paragraph markdown summary to `hello-world-report.md`. Budgets (USD 0.25, 20k tokens, 30 turns, 15 min) are small enough to run on a local Ollama model without cost. Intended as the first thing a new user watches an agent complete end to end.
-
 Older releases: https://swarmclaw.ai/docs/release-notes
 
 - GitHub releases: https://github.com/swarmclawai/swarmclaw/releases

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.5.62",
+  "version": "1.5.63",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

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

@@ -297,3 +297,114 @@ test('chatroom route forwards tool activity and records one reply per participat
   assert.deepEqual(output.assistantCounts, { alpha: 1, beta: 1 })
   assert.deepEqual([...new Set(output.agentOrder)].sort(), ['alpha', 'beta'])
 })
+
+test('chatroom route uses direct provider runtime for CLI providers', () => {
+  const output = runWithTempDataDir<{
+    errors: string[]
+    streamedText: string
+    assistantTexts: 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('@/lib/server/chat-execution/stream-agent-chat')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const stream = streamMod.default || streamMod
+
+    const originalHandler = providers.PROVIDERS['codex-cli'].handler
+
+    const now = Date.now()
+    storage.saveAgents({
+      alpha: {
+        id: 'alpha',
+        name: 'Alpha',
+        provider: 'codex-cli',
+        model: 'gpt-5.3-codex',
+        extensions: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveChatrooms({
+      room_1: {
+        id: 'room_1',
+        name: 'CLI Room',
+        agentIds: ['alpha'],
+        messages: [],
+        createdAt: now,
+        updatedAt: now,
+        chatMode: 'sequential',
+        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 () => {
+      throw new Error('streamAgentChat should not be called for codex-cli chatroom turns')
+    })
+    providers.PROVIDERS['codex-cli'].handler = {
+      streamChat: async (opts) => {
+        const reply = 'Codex CLI answered from direct provider runtime.'
+        opts.write('data: ' + JSON.stringify({ t: 'd', text: reply }) + '\\n')
+        return reply
+      },
+    }
+
+    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: 'Say hello to the room.' }),
+        }),
+        { params: Promise.resolve({ id: 'room_1' }) },
+      )
+
+      const events = await readSse(response)
+      const chatroom = storage.loadChatrooms().room_1
+      const assistantTexts = chatroom.messages
+        .filter((entry) => entry.role === 'assistant')
+        .map((entry) => entry.text)
+
+      console.log(JSON.stringify({
+        errors: events.filter((entry) => entry.t === 'err').map((entry) => entry.text),
+        streamedText: events.filter((entry) => entry.t === 'd').map((entry) => entry.text).join(''),
+        assistantTexts,
+      }))
+    } finally {
+      providers.PROVIDERS['codex-cli'].handler = originalHandler
+      stream.setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-chatroom-route-cli-provider-' })
+
+  assert.equal(output.errors.some((text) => /streamAgentChat should not be called/i.test(text)), false)
+  assert.equal(output.streamedText.includes('Codex CLI answered from direct provider runtime.'), true)
+  assert.equal(output.assistantTexts.some((text) => text.includes('Codex CLI answered from direct provider runtime.')), true)
+})

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

@@ -6,6 +6,7 @@ import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { streamAgentChat } from '@/lib/server/chat-execution/stream-agent-chat'
 import { getProvider } from '@/lib/providers'
+import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import {
   resolveApiKey,
   parseMentions,
@@ -231,37 +232,55 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
             let fullText = ''
             let agentError = ''
-            const result = await streamAgentChat({
-              session: syntheticSession,
-              message: messageForAgent,
-              imagePath,
-              attachedFiles,
-              apiKey,
-              systemPrompt: fullSystemPrompt,
-              write: (raw: string) => {
-                const lines = raw.split('\n').filter(Boolean)
-                for (const line of lines) {
-                  if (!line.startsWith('data: ')) continue
-                  try {
-                    const parsed = JSON.parse(line.slice(6).trim())
-                    if (parsed.t === 'd' && parsed.text) {
-                      fullText += parsed.text
-                      writeEvent({ t: 'd', text: parsed.text, agentId: agent.id, agentName: agent.name })
-                    } else if (parsed.t === 'tool_call' || parsed.t === 'tool_result') {
-                      writeEvent({ ...parsed, agentId: agent.id, agentName: agent.name })
-                    } else if (parsed.t === 'err' && parsed.text) {
-                      agentError = parsed.text
-                      writeEvent({ t: 'err', text: parsed.text, agentId: agent.id, agentName: agent.name })
-                    }
-                  } catch {
-                    // skip malformed lines
+            const forwardProviderEvents = (raw: string) => {
+              const lines = raw.split('\n').filter(Boolean)
+              for (const line of lines) {
+                if (!line.startsWith('data: ')) continue
+                try {
+                  const parsed = JSON.parse(line.slice(6).trim())
+                  if (parsed.t === 'd' && parsed.text) {
+                    fullText += parsed.text
+                    writeEvent({ t: 'd', text: parsed.text, agentId: agent.id, agentName: agent.name })
+                  } else if (parsed.t === 'tool_call' || parsed.t === 'tool_result') {
+                    writeEvent({ ...parsed, agentId: agent.id, agentName: agent.name })
+                  } else if (parsed.t === 'err' && parsed.text) {
+                    agentError = parsed.text
+                    writeEvent({ t: 'err', text: parsed.text, agentId: agent.id, agentName: agent.name })
                   }
+                } catch {
+                  // skip malformed lines
                 }
-              },
-              history,
-            })
+              }
+            }
 
-            const rawResponseText = result.finalResponse || result.fullText || fullText
+            let rawResponseText = ''
+            if (NON_LANGGRAPH_PROVIDER_IDS.has(syntheticSession.provider)) {
+              const provider = getProvider(syntheticSession.provider)
+              if (!provider) throw new Error(`Unknown provider: ${syntheticSession.provider}`)
+              rawResponseText = await provider.handler.streamChat({
+                session: syntheticSession,
+                message: messageForAgent,
+                imagePath,
+                apiKey,
+                systemPrompt: fullSystemPrompt,
+                write: forwardProviderEvents,
+                active: new Map<string, unknown>(),
+                loadHistory: () => history,
+              })
+              if (!rawResponseText) rawResponseText = fullText
+            } else {
+              const result = await streamAgentChat({
+                session: syntheticSession,
+                message: messageForAgent,
+                imagePath,
+                attachedFiles,
+                apiKey,
+                systemPrompt: fullSystemPrompt,
+                write: forwardProviderEvents,
+                history,
+              })
+              rawResponseText = result.finalResponse || result.fullText || fullText
+            }
             const responseText = stripAgentReactionTokens(stripHiddenControlTokens(rawResponseText))
 
             // Don't persist empty or error-only messages — they pollute chat history

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

@@ -4,7 +4,6 @@ import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { genId } from '@/lib/id'
-import { isWorkerOnlyAgent, buildWorkerOnlyAgentMessage } from '@/lib/server/agents/agent-availability'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
@@ -18,13 +17,6 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   if (!agentId) return NextResponse.json({ error: 'agentId is required' }, { status: 400 })
 
   const agents = loadAgents()
-  if (isWorkerOnlyAgent(agents[agentId])) {
-    return NextResponse.json(
-      { error: buildWorkerOnlyAgentMessage(agents[agentId], 'join chatrooms') },
-      { status: 400 },
-    )
-  }
-
   if (!chatroom.agentIds.includes(agentId)) {
     chatroom.agentIds.push(agentId)
 

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

@@ -4,7 +4,6 @@ import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { genId } from '@/lib/id'
-import { isWorkerOnlyAgent } from '@/lib/server/agents/agent-availability'
 import {
   ensureChatroomRoutingGuidance,
   synthesizeRoutingGuidanceFromRules,
@@ -78,16 +77,6 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
         { status: 400 },
       )
     }
-    const cliAgentNames = agentIds
-      .filter((agentId) => isWorkerOnlyAgent(agents[agentId]))
-      .map((agentId) => agents[agentId]?.name || agentId)
-    if (cliAgentNames.length > 0) {
-      return NextResponse.json(
-        { error: `CLI-based agents cannot join chatrooms: ${cliAgentNames.join(', ')}. They can only be used for direct chats and delegation.` },
-        { status: 400 },
-      )
-    }
-
     const oldIds = new Set(chatroom.agentIds)
     const newIds = new Set(agentIds)
     const added = agentIds.filter((aid: string) => !oldIds.has(aid))

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

@@ -6,7 +6,6 @@ import { ChatroomCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { z } from 'zod'
 import type { Chatroom, ChatroomMessage } from '@/types'
-import { isWorkerOnlyAgent } from '@/lib/server/agents/agent-availability'
 import {
   ensureChatroomRoutingGuidance,
   synthesizeRoutingGuidanceFromRules,
@@ -61,15 +60,6 @@ export async function POST(req: Request) {
       { status: 400 },
     )
   }
-  const cliAgentNames = requestedAgentIds
-    .filter((agentId) => isWorkerOnlyAgent(knownAgents[agentId]))
-    .map((agentId) => knownAgents[agentId]?.name || agentId)
-  if (cliAgentNames.length > 0) {
-    return NextResponse.json(
-      { error: `CLI-based agents cannot join chatrooms: ${cliAgentNames.join(', ')}. They can only be used for direct chats and delegation.` },
-      { status: 400 },
-    )
-  }
   const agentIds: string[] = requestedAgentIds
   const chatMode = body.chatMode === 'parallel' ? 'parallel' : 'sequential'
   const autoAddress = Boolean(body.autoAddress)

package/src/components/chatrooms/chatroom-sheet.tsx

@@ -9,7 +9,6 @@ import { toast } from 'sonner'
 import { AgentAvatar } from '@/components/agents/agent-avatar'
 import type { Agent } from '@/types'
 import { CheckIcon } from '@/components/shared/check-icon'
-import { WORKER_ONLY_PROVIDER_IDS } from '@/lib/provider-sets'
 
 export function ChatroomSheet() {
   const open = useChatroomStore((s) => s.chatroomSheetOpen)
@@ -105,9 +104,7 @@ export function ChatroomSheet() {
     )
   }
 
-  const agentList = Object.values(agents).filter(
-    (a: Agent) => !a.trashedAt && !WORKER_ONLY_PROVIDER_IDS.has(a.provider)
-  ) as Agent[]
+  const agentList = Object.values(agents).filter((a: Agent) => !a.trashedAt) as Agent[]
 
   return (
     <BottomSheet open={open} onClose={() => setChatroomSheetOpen(false)}>

package/src/lib/server/session-tools/chatroom.ts

@@ -12,7 +12,6 @@ import { log } from '../logger'
 import { debug } from '../debug'
 import { logExecution } from '../execution-log'
 import { logActivity } from '../storage'
-import { WORKER_ONLY_PROVIDER_IDS } from '@/lib/provider-sets'
 
 /**
  * Core Chatroom Execution Logic
@@ -78,12 +77,6 @@ async function executeChatroomAction(args: Record<string, unknown>, context: { a
       const agents = loadAgents()
       const requestedAgentIds = agentIds || []
       const validAgentIds = requestedAgentIds.filter((aid: string) => !!agents[aid])
-      const cliAgentNames = validAgentIds
-        .filter((aid: string) => WORKER_ONLY_PROVIDER_IDS.has(agents[aid]?.provider))
-        .map((aid: string) => agents[aid]?.name || aid)
-      if (cliAgentNames.length > 0) {
-        return `Error: CLI-based agents cannot join chatrooms: ${cliAgentNames.join(', ')}. They can only be used for direct chats and delegation.`
-      }
 
       const chatroom: Chatroom = {
         id,
@@ -208,10 +201,6 @@ async function executeChatroomAction(args: Record<string, unknown>, context: { a
 
     if (action === 'add_agent') {
       if (!agentId) return 'Error: agentId required.'
-      const agents = loadAgents()
-      if (WORKER_ONLY_PROVIDER_IDS.has(agents[agentId]?.provider)) {
-        return `Error: ${agents[agentId]?.name || agentId} is a CLI-based agent and cannot join chatrooms. CLI agents can only be used for direct chats and delegation.`
-      }
       if (!chatroom.agentIds.includes(agentId)) {
         chatroom.agentIds.push(agentId)
         chatroom.updatedAt = Date.now()