@swarmclawai/swarmclaw 0.7.3 → 0.7.5

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

@@ -28,6 +28,7 @@ import { getPluginManager } from './plugins'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
 import { routeTaskIntent } from './capability-router'
 import { notify } from './ws-hub'
+import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
 import { resolveConcreteToolPolicyBlock, resolveSessionToolPolicy } from './tool-capability-policy'
 import { pluginIdMatches } from './tool-aliases'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
@@ -132,14 +133,10 @@ export function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
     const idx = bag.findLastIndex((e) => e.name === (ev.toolName || 'unknown') && !e.output)
     if (idx === -1) return
     const output = ev.toolOutput || ''
-    const isError = /^(Error:|error:)/i.test(output.trim())
-      || output.includes('ECONNREFUSED')
-      || output.includes('ETIMEDOUT')
-      || output.includes('Error:')
     bag[idx] = {
       ...bag[idx],
       output,
-      error: isError || undefined,
+      error: isLikelyToolErrorOutput(output) || undefined,
     }
   }
 }
@@ -191,15 +188,124 @@ function extractDelegateResponse(outputText: string): string | null {
   }
 }
 
+const MANAGE_PLATFORM_RESOURCE_TO_TOOL: Record<string, string> = {
+  agent: 'manage_agents',
+  agents: 'manage_agents',
+  task: 'manage_tasks',
+  tasks: 'manage_tasks',
+  schedule: 'manage_schedules',
+  schedules: 'manage_schedules',
+  skill: 'manage_skills',
+  skills: 'manage_skills',
+  document: 'manage_documents',
+  documents: 'manage_documents',
+  secret: 'manage_secrets',
+  secrets: 'manage_secrets',
+  connector: 'manage_connectors',
+  connectors: 'manage_connectors',
+  session: 'manage_sessions',
+  sessions: 'manage_sessions',
+}
+
+export function translateRequestedToolInvocation(
+  requestedName: string,
+  rawArgs: Record<string, unknown>,
+  messageFallback: string,
+  availableToolNames?: Iterable<string>,
+): { toolName: string; args: Record<string, unknown> } {
+  const available = new Set(availableToolNames || [])
+
+  if (requestedName === 'web_search') {
+    return {
+      toolName: 'web',
+      args: {
+        action: 'search',
+        query: typeof rawArgs.query === 'string' ? rawArgs.query : messageFallback.trim(),
+        maxResults: typeof rawArgs.maxResults === 'number' ? rawArgs.maxResults : 5,
+      },
+    }
+  }
+  if (requestedName === 'web_fetch') {
+    return {
+      toolName: 'web',
+      args: {
+        action: 'fetch',
+        url: rawArgs.url,
+      },
+    }
+  }
+  if (requestedName === 'delegate_to_claude_code') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'claude' } }
+  }
+  if (requestedName === 'delegate_to_codex_cli') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'codex' } }
+  }
+  if (requestedName === 'delegate_to_opencode_cli') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'opencode' } }
+  }
+  if (requestedName === 'delegate_to_gemini_cli') {
+    return { toolName: 'delegate', args: { ...rawArgs, backend: 'gemini' } }
+  }
+
+  const managePrefix = 'manage_'
+  if (requestedName === 'manage_platform') {
+    const resource = typeof rawArgs.resource === 'string'
+      ? rawArgs.resource.trim().toLowerCase()
+      : ''
+    const specificTool = MANAGE_PLATFORM_RESOURCE_TO_TOOL[resource]
+    if (specificTool && available.has(specificTool) && !available.has('manage_platform')) {
+      return { toolName: specificTool, args: rawArgs }
+    }
+    return { toolName: requestedName, args: rawArgs }
+  }
+
+  if (requestedName.startsWith(managePrefix) && requestedName !== 'manage_platform') {
+    if (!available.has(requestedName) && available.has('manage_platform')) {
+      const resource = requestedName.slice(managePrefix.length)
+      if (resource) {
+        const { action, id, data, ...rest } = rawArgs
+        const nextArgs: Record<string, unknown> = { resource, ...rest }
+        if (action !== undefined) nextArgs.action = action
+        if (id !== undefined) nextArgs.id = id
+        if (data !== undefined) nextArgs.data = data
+        return {
+          toolName: 'manage_platform',
+          args: nextArgs,
+        }
+      }
+    }
+    return { toolName: requestedName, args: rawArgs }
+  }
+
+  return { toolName: requestedName, args: rawArgs }
+}
+
+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
+}
+
 function normalizeWorkspaceSandboxLinks(text: string, cwd: string): string {
-  return text.replace(/sandbox:\/workspace\/([^\s)"'\]`]+)/g, (raw, relativePath: string) => {
+  return text.replace(/\[([^\]]+)\]\(sandbox:\/workspace\/([^)]+)\)/g, (raw, label: string, relativePath: string) => {
     const normalized = String(relativePath || '').replace(/^\/+/, '')
     if (!normalized) return raw
     const resolvedCwd = path.resolve(cwd)
     const resolved = path.resolve(resolvedCwd, normalized)
     if (!resolved.startsWith(resolvedCwd)) return raw
     if (!fs.existsSync(resolved)) return raw
-    return `/api/files/serve?path=${encodeURIComponent(resolved)}`
+    return `[${label}](/api/files/serve?path=${encodeURIComponent(resolved)})`
   })
 }
 
@@ -520,18 +626,41 @@ function syncSessionFromAgent(sessionId: string): void {
   if (!agent) return
 
   let changed = false
+  const route = resolvePrimaryAgentRoute(agent)
   if (!session.provider && agent.provider) { session.provider = agent.provider; changed = true }
   if ((session.model === undefined || session.model === null || session.model === '') && agent.model !== undefined) {
     session.model = agent.model
     changed = true
   }
-  if (session.credentialId === undefined && agent.credentialId !== undefined) {
-    session.credentialId = agent.credentialId ?? null
-    changed = true
-  }
-  if ((session.apiEndpoint === undefined || session.apiEndpoint === null) && agent.apiEndpoint !== undefined) {
-    const normalized = normalizeProviderEndpoint(agent.provider, agent.apiEndpoint ?? null)
-    if (normalized !== session.apiEndpoint) { session.apiEndpoint = normalized; changed = true }
+  if (route) {
+    const resolved = applyResolvedRoute({ ...session }, route)
+    if (session.provider !== resolved.provider) { session.provider = resolved.provider; changed = true }
+    if (session.model !== resolved.model) { session.model = resolved.model; changed = true }
+    if ((session.credentialId || null) !== (resolved.credentialId || null)) {
+      session.credentialId = resolved.credentialId ?? null
+      changed = true
+    }
+    if (JSON.stringify(session.fallbackCredentialIds || []) !== JSON.stringify(resolved.fallbackCredentialIds || [])) {
+      session.fallbackCredentialIds = [...resolved.fallbackCredentialIds]
+      changed = true
+    }
+    if ((session.apiEndpoint || null) !== (resolved.apiEndpoint || null)) {
+      session.apiEndpoint = resolved.apiEndpoint ?? null
+      changed = true
+    }
+    if ((session.gatewayProfileId || null) !== (resolved.gatewayProfileId || null)) {
+      session.gatewayProfileId = resolved.gatewayProfileId ?? null
+      changed = true
+    }
+  } else {
+    if (session.credentialId === undefined && agent.credentialId !== undefined) {
+      session.credentialId = agent.credentialId ?? null
+      changed = true
+    }
+    if ((session.apiEndpoint === undefined || session.apiEndpoint === null) && agent.apiEndpoint !== undefined) {
+      const normalized = normalizeProviderEndpoint(agent.provider, agent.apiEndpoint ?? null)
+      if (normalized !== session.apiEndpoint) { session.apiEndpoint = normalized; changed = true }
+    }
   }
   if (!Array.isArray(session.plugins)) {
     session.plugins = Array.isArray(agent.plugins) ? [...agent.plugins] : []
@@ -719,6 +848,12 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   let sessionForRun = pluginsForRun === session.plugins
     ? session
     : { ...session, plugins: pluginsForRun }
+  if (agentForSession) {
+    const preferredRoute = resolvePrimaryAgentRoute(agentForSession)
+    if (preferredRoute) {
+      sessionForRun = applyResolvedRoute({ ...sessionForRun }, preferredRoute)
+    }
+  }
   let effectiveMessage = message
 
   if (pluginsForRun.length > 0) {
@@ -825,14 +960,14 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     detail: {
       source,
       internal,
-      provider: session.provider,
-      model: session.model,
+      provider: sessionForRun.provider,
+      model: sessionForRun.model,
       messagePreview: effectiveMessage.slice(0, 200),
       hasImage: !!(imagePath || imageUrl),
     },
   })
 
-  const providerType = session.provider || 'claude-cli'
+  const providerType = sessionForRun.provider || 'claude-cli'
   const provider = getProvider(providerType)
   if (!provider) throw new Error(`Unknown provider: ${providerType}`)
 
@@ -840,7 +975,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     throw new Error(`Directory not found: ${session.cwd}`)
   }
 
-  const apiKey = resolveApiKeyForSession(session, provider)
+  const apiKey = resolveApiKeyForSession(sessionForRun, provider)
 
   if (!internal) {
     const linkAnalysis = await runLinkUnderstanding(message)
@@ -1105,57 +1240,6 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     : null
   const calledNames = new Set((toolEvents || []).map((t) => t.name))
 
-  const translateToolInvocation = (
-    requestedName: string,
-    rawArgs: Record<string, unknown>,
-  ): { toolName: string; args: Record<string, unknown> } => {
-    if (requestedName === 'web_search') {
-      return {
-        toolName: 'web',
-        args: {
-          action: 'search',
-          query: typeof rawArgs.query === 'string' ? rawArgs.query : message.trim(),
-          maxResults: typeof rawArgs.maxResults === 'number' ? rawArgs.maxResults : 5,
-        },
-      }
-    }
-    if (requestedName === 'web_fetch') {
-      return {
-        toolName: 'web',
-        args: {
-          action: 'fetch',
-          url: rawArgs.url,
-        },
-      }
-    }
-    if (requestedName === 'delegate_to_claude_code') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'claude' } }
-    }
-    if (requestedName === 'delegate_to_codex_cli') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'codex' } }
-    }
-    if (requestedName === 'delegate_to_opencode_cli') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'opencode' } }
-    }
-    if (requestedName === 'delegate_to_gemini_cli') {
-      return { toolName: 'delegate', args: { ...rawArgs, backend: 'gemini' } }
-    }
-
-    const managePrefix = 'manage_'
-    if (requestedName.startsWith(managePrefix) && requestedName !== 'manage_platform') {
-      const resource = requestedName.slice(managePrefix.length)
-      if (resource) {
-        const { action, id, data, ...rest } = rawArgs
-        return {
-          toolName: 'manage_platform',
-          args: { resource, action, id, data, ...rest },
-        }
-      }
-    }
-
-    return { toolName: requestedName, args: rawArgs }
-  }
-
   const invokeSessionTool = async (toolName: string, args: Record<string, unknown>, failurePrefix: string): Promise<boolean> => {
     const blockedReason = resolveConcreteToolPolicyBlock(toolName, toolPolicy, appSettings)
     if (blockedReason) {
@@ -1179,8 +1263,12 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       mcpDisabledTools: agent?.mcpDisabledTools,
     })
     try {
-      const translated = translateToolInvocation(toolName, args)
-      const selectedTool = tools.find((t) => t?.name === translated.toolName) as StructuredToolInterface | undefined
+      const directTool = tools.find((t) => t?.name === toolName) as StructuredToolInterface | undefined
+      const availableToolNames = tools.map((candidate) => candidate?.name).filter(Boolean)
+      const translated = directTool
+        ? { toolName, args }
+        : translateRequestedToolInvocation(toolName, args, message, availableToolNames)
+      const selectedTool = directTool || tools.find((t) => t?.name === translated.toolName) as StructuredToolInterface | undefined
       if (!selectedTool?.invoke) return false
       const toolInput = JSON.stringify(translated.args)
       emit({ t: 'tool_call', toolName, toolInput })

package/src/lib/server/chatroom-helpers.test.ts

@@ -6,6 +6,7 @@ import {
   compactChatroomMessages,
   buildHistoryForAgent,
   buildSyntheticSession,
+  resolveChatroomWorkspaceDir,
   resolveAgentApiEndpoint,
   resolveReplyTargetAgentId,
 } from './chatroom-helpers'
@@ -156,4 +157,10 @@ describe('chatroom-helpers', () => {
     assert.equal(resolveAgentApiEndpoint(agent), 'http://localhost:11434')
     assert.equal(buildSyntheticSession(agent, 'room-1').apiEndpoint, 'http://localhost:11434')
   })
+
+  it('keeps chatroom execution inside the workspace instead of the repo root', () => {
+    const cwd = buildSyntheticSession(makeAgents().default, 'room-safe').cwd
+    assert.equal(cwd, resolveChatroomWorkspaceDir('room-safe'))
+    assert.match(cwd, /chatrooms[\/\\]room-safe$/)
+  })
 })

package/src/lib/server/chatroom-helpers.ts

@@ -1,10 +1,14 @@
+import fs from 'fs'
 import os from 'os'
-import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
+import path from 'path'
+import { loadSettings, loadSkills, loadCredentials, decryptKey, loadSessions, saveSessions } from './storage'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { buildIdentityContinuityContext } from './identity-continuity'
 import { genId } from '@/lib/id'
 import { getProvider } from '@/lib/providers'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
+import { WORKSPACE_DIR } from './data-dir'
+import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
 import type { Chatroom, ChatroomMember, Agent, Session, Message, ChatroomMessage } from '@/types'
 
 /** Resolve API key from an agent's credentialId */
@@ -210,11 +214,31 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
 }
 
 /** Build a synthetic session object for an agent in a chatroom */
-export function buildSyntheticSession(agent: Agent, chatroomId: string): Session {
+export function resolveChatroomWorkspaceDir(chatroomId: string): string {
+  return path.join(WORKSPACE_DIR, 'chatrooms', chatroomId)
+}
+
+export function resolveSyntheticSessionId(chatroomId: string, agentId: string): string {
+  return `chatroom-${chatroomId}-${agentId}`
+}
+
+function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
   return {
-    id: `chatroom-${chatroomId}-${agent.id}`,
+    claudeCode: null,
+    codex: null,
+    opencode: null,
+    gemini: null,
+  }
+}
+
+export function buildSyntheticSession(agent: Agent, chatroomId: string): Session {
+  const roomWorkspace = resolveChatroomWorkspaceDir(chatroomId)
+  fs.mkdirSync(roomWorkspace, { recursive: true })
+  const now = Date.now()
+  return applyResolvedRoute({
+    id: resolveSyntheticSessionId(chatroomId, agent.id),
     name: `Chatroom session for ${agent.name}`,
-    cwd: process.cwd(),
+    cwd: roomWorkspace,
     user: 'chatroom',
     provider: agent.provider,
     model: agent.model,
@@ -222,12 +246,81 @@ export function buildSyntheticSession(agent: Agent, chatroomId: string): Session
     fallbackCredentialIds: agent.fallbackCredentialIds,
     apiEndpoint: resolveAgentApiEndpoint(agent),
     claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    delegateResumeIds: buildEmptyDelegateResumeIds(),
     messages: [],
-    createdAt: Date.now(),
-    lastActiveAt: Date.now(),
+    createdAt: now,
+    lastActiveAt: now,
+    sessionType: 'human',
     plugins: agent.plugins || agent.tools || [],
     agentId: agent.id,
+  }, resolvePrimaryAgentRoute(agent))
+}
+
+export function ensureSyntheticSession(agent: Agent, chatroomId: string): Session {
+  const roomWorkspace = resolveChatroomWorkspaceDir(chatroomId)
+  fs.mkdirSync(roomWorkspace, { recursive: true })
+  const sessionId = resolveSyntheticSessionId(chatroomId, agent.id)
+  const sessions = loadSessions()
+  const now = Date.now()
+  const existing = sessions[sessionId]
+  const session: Session = existing
+    ? applyResolvedRoute({
+        ...existing,
+        id: sessionId,
+        name: `Chatroom session for ${agent.name}`,
+        cwd: roomWorkspace,
+        user: 'chatroom',
+        provider: agent.provider,
+        model: agent.model,
+        credentialId: agent.credentialId ?? null,
+        fallbackCredentialIds: Array.isArray(agent.fallbackCredentialIds) ? [...agent.fallbackCredentialIds] : [],
+        apiEndpoint: resolveAgentApiEndpoint(agent),
+        sessionType: existing.sessionType || 'human',
+        agentId: agent.id,
+        plugins: agent.plugins || agent.tools || [],
+        tools: agent.plugins || agent.tools || [],
+        createdAt: existing.createdAt || now,
+        lastActiveAt: now,
+      }, resolvePrimaryAgentRoute(agent))
+    : applyResolvedRoute({
+        ...buildSyntheticSession(agent, chatroomId),
+        fallbackCredentialIds: Array.isArray(agent.fallbackCredentialIds) ? [...agent.fallbackCredentialIds] : [],
+        lastActiveAt: now,
+        tools: agent.plugins || agent.tools || [],
+      }, resolvePrimaryAgentRoute(agent))
+
+  if (!Array.isArray(session.messages)) session.messages = []
+  if (!session.delegateResumeIds || typeof session.delegateResumeIds !== 'object') {
+    session.delegateResumeIds = buildEmptyDelegateResumeIds()
   }
+  if (session.codexThreadId === undefined) session.codexThreadId = null
+  if (session.opencodeSessionId === undefined) session.opencodeSessionId = null
+  sessions[sessionId] = session
+  saveSessions(sessions)
+  return session
+}
+
+export function appendSyntheticSessionMessage(
+  sessionId: string,
+  role: 'user' | 'assistant',
+  text: string,
+): void {
+  const trimmed = String(text || '').trim()
+  if (!trimmed) return
+  const sessions = loadSessions()
+  const session = sessions[sessionId]
+  if (!session) return
+  if (!Array.isArray(session.messages)) session.messages = []
+  session.messages.push({
+    role,
+    text: trimmed,
+    time: Date.now(),
+  })
+  session.lastActiveAt = Date.now()
+  sessions[sessionId] = session
+  saveSessions(sessions)
 }
 
 /** Build agent's system prompt including skills and identity context */

package/src/lib/server/chatroom-session-persistence.test.ts

@@ -0,0 +1,87 @@
+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 { describe, it } 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-chatroom-session-'))
+  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'),
+      },
+      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 })
+  }
+}
+
+describe('chatroom synthetic session persistence', () => {
+  it('reuses stored synthetic sessions and preserves delegate resume state', () => {
+    const output = runWithTempDataDir(`
+      const helpersMod = await import('./src/lib/server/chatroom-helpers.ts')
+      const helpers = helpersMod.default || helpersMod
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const storage = storageMod.default || storageMod
+      const now = Date.now()
+      const agent = {
+        id: 'default',
+        name: 'Molly',
+        description: '',
+        systemPrompt: '',
+        provider: 'openai',
+        model: 'gpt-4o',
+        createdAt: now,
+        updatedAt: now,
+        plugins: ['delegate'],
+      }
+
+      const first = helpers.ensureSyntheticSession(agent, 'room-1')
+      helpers.appendSyntheticSessionMessage(first.id, 'user', 'first prompt')
+
+      const sessions = storage.loadSessions()
+      sessions[first.id].delegateResumeIds = {
+        claudeCode: null,
+        codex: 'resume-123',
+        opencode: null,
+        gemini: null,
+      }
+      storage.saveSessions(sessions)
+
+      const second = helpers.ensureSyntheticSession({ ...agent, model: 'gpt-4.1' }, 'room-1')
+      console.log(JSON.stringify({
+        sessionId: second.id,
+        cwd: second.cwd,
+        model: second.model,
+        messageCount: second.messages.length,
+        firstMessage: second.messages[0]?.text || '',
+        delegateResumeIds: second.delegateResumeIds,
+        plugins: second.plugins || [],
+      }))
+    `)
+
+    assert.equal(output.sessionId, 'chatroom-room-1-default')
+    assert.match(String(output.cwd), /chatrooms[\/\\]room-1$/)
+    assert.equal(output.model, 'gpt-4.1')
+    assert.equal(output.messageCount, 1)
+    assert.equal(output.firstMessage, 'first prompt')
+    assert.equal(output.delegateResumeIds?.codex, 'resume-123')
+    assert.deepEqual(output.plugins, ['delegate'])
+  })
+})