@swarmclawai/swarmclaw 0.5.2 → 0.6.0

package/src/lib/server/memory-db.ts

@@ -329,6 +329,7 @@ function normalizeImage(rawImage: unknown, legacyImagePath?: string | null): Mem
 function initDb() {
   const db = new Database(DB_PATH)
   db.pragma('journal_mode = WAL')
+  db.pragma('busy_timeout = 5000')
 
   db.exec(`
     CREATE TABLE IF NOT EXISTS memories (
@@ -354,10 +355,15 @@ function initDb() {
     'linkedMemoryIds TEXT',
     '"references" TEXT',
     'image TEXT',
+    'pinned INTEGER DEFAULT 0',
+    'sharedWith TEXT',
   ]) {
     try { db.exec(`ALTER TABLE memories ADD COLUMN ${col}`) } catch { /* already exists */ }
   }
 
+  // Partial index for fast pinned-memory lookups
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(agentId, updatedAt DESC) WHERE pinned = 1`)
+
   // FTS5 virtual table for full-text search
   db.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -448,14 +454,14 @@ function initDb() {
     insert: db.prepare(`
       INSERT INTO memories (
         id, agentId, sessionId, category, title, content, metadata, embedding,
-        "references", filePaths, image, imagePath, linkedMemoryIds, createdAt, updatedAt
+        "references", filePaths, image, imagePath, linkedMemoryIds, pinned, sharedWith, createdAt, updatedAt
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `),
     update: db.prepare(`
       UPDATE memories
       SET agentId=?, sessionId=?, category=?, title=?, content=?, metadata=?, embedding=?,
-          "references"=?, filePaths=?, image=?, imagePath=?, linkedMemoryIds=?, updatedAt=?
+          "references"=?, filePaths=?, image=?, imagePath=?, linkedMemoryIds=?, pinned=?, sharedWith=?, updatedAt=?
       WHERE id=?
     `),
     delete: db.prepare(`DELETE FROM memories WHERE id=?`),
@@ -467,6 +473,9 @@ function initDb() {
     },
     listAll: db.prepare(`SELECT * FROM memories ORDER BY updatedAt DESC LIMIT ?`),
     listByAgent: db.prepare(`SELECT * FROM memories WHERE agentId=? ORDER BY updatedAt DESC LIMIT ?`),
+    listByAgentOrShared: db.prepare(`SELECT * FROM memories WHERE agentId=? OR sharedWith LIKE ? ORDER BY updatedAt DESC LIMIT ?`),
+    listPinnedByAgent: db.prepare(`SELECT * FROM memories WHERE pinned = 1 AND agentId = ? ORDER BY updatedAt DESC LIMIT ?`),
+    listPinnedAll: db.prepare(`SELECT * FROM memories WHERE pinned = 1 ORDER BY updatedAt DESC LIMIT ?`),
     search: db.prepare(`
       SELECT m.* FROM memories m
       INNER JOIN memories_fts f ON m.rowid = f.rowid
@@ -479,6 +488,12 @@ function initDb() {
       WHERE memories_fts MATCH ? AND m.agentId = ?
       LIMIT ${MAX_FTS_RESULT_ROWS}
     `),
+    searchByAgentOrShared: db.prepare(`
+      SELECT m.* FROM memories m
+      INNER JOIN memories_fts f ON m.rowid = f.rowid
+      WHERE memories_fts MATCH ? AND (m.agentId = ? OR m.sharedWith LIKE ?)
+      LIMIT ${MAX_FTS_RESULT_ROWS}
+    `),
     // Remove a linked ID from all memories that reference it (cleanup on delete)
     findMemoriesLinkingTo: db.prepare(`SELECT * FROM memories WHERE linkedMemoryIds LIKE ?`),
     updateLinks: db.prepare(`UPDATE memories SET linkedMemoryIds = ?, updatedAt = ? WHERE id = ?`),
@@ -489,6 +504,7 @@ function initDb() {
       LIMIT 1
     `),
     allRowsByUpdated: db.prepare(`SELECT * FROM memories ORDER BY updatedAt DESC`),
+    countsByAgent: db.prepare(`SELECT COALESCE(agentId, '_global') AS agentKey, COUNT(*) AS cnt FROM memories GROUP BY agentKey`),
     exactDuplicateBySessionCategory: db.prepare(`
       SELECT * FROM memories
       WHERE sessionId = ? AND category = ? AND title = ? AND content = ?
@@ -517,6 +533,8 @@ function initDb() {
       image,
       imagePath: image?.path || undefined,
       linkedMemoryIds: linkedMemoryIds.length ? linkedMemoryIds : undefined,
+      pinned: row.pinned === 1,
+      sharedWith: parseJsonSafe<string[]>(row.sharedWith, []).length ? parseJsonSafe<string[]>(row.sharedWith, []) : undefined,
       createdAt: typeof row.createdAt === 'number' ? row.createdAt : Date.now(),
       updatedAt: typeof row.updatedAt === 'number' ? row.updatedAt : Date.now(),
     }
@@ -562,6 +580,8 @@ function initDb() {
         const duplicate = stmts.exactDuplicateBySessionCategory.get(sessionId, category, title, content) as Record<string, unknown> | undefined
         if (duplicate) return rowToEntry(duplicate)
       }
+      const pinned = data.pinned ? 1 : 0
+      const sharedWith = Array.isArray(data.sharedWith) && data.sharedWith.length ? JSON.stringify(data.sharedWith) : null
       stmts.insert.run(
         id, data.agentId || null, sessionId,
         category, title, content,
@@ -572,6 +592,8 @@ function initDb() {
         image ? JSON.stringify(image) : null,
         image?.path || null,
         linkedMemoryIds.length ? JSON.stringify(linkedMemoryIds) : null,
+        pinned,
+        sharedWith,
         now, now,
       )
       // Compute embedding in background (fire-and-forget)
@@ -617,6 +639,8 @@ function initDb() {
       const nextLinked = normalizeLinkedMemoryIds(merged.linkedMemoryIds, id)
       const prevLinked = normalizeLinkedMemoryIds(existingEntry.linkedMemoryIds, id)
       const now = Date.now()
+      const pinnedVal = merged.pinned ? 1 : 0
+      const sharedWithVal = Array.isArray(merged.sharedWith) && merged.sharedWith.length ? JSON.stringify(merged.sharedWith) : null
       stmts.update.run(
         merged.agentId || null, merged.sessionId || null,
         merged.category, merged.title, merged.content,
@@ -627,6 +651,8 @@ function initDb() {
         image ? JSON.stringify(image) : null,
         image?.path || null,
         nextLinked.length ? JSON.stringify(nextLinked) : null,
+        pinnedVal,
+        sharedWithVal,
         now, id,
       )
 
@@ -755,11 +781,11 @@ function initDb() {
     search(query: string, agentId?: string): MemoryEntry[] {
       if (shouldSkipSearchQuery(query)) return []
       const startedAt = Date.now()
-      // FTS keyword search
+      // FTS keyword search (includes memories shared with this agent)
       const ftsQuery = buildFtsQuery(query)
       const ftsResults: MemoryEntry[] = ftsQuery
         ? (agentId
-            ? stmts.searchByAgent.all(ftsQuery, agentId) as any[]
+            ? stmts.searchByAgentOrShared.all(ftsQuery, agentId, `%"${agentId}"%`) as any[]
             : stmts.search.all(ftsQuery) as any[]
           ).map(rowToEntry)
         : []
@@ -838,11 +864,26 @@ function initDb() {
     list(agentId?: string, limit = 200): MemoryEntry[] {
       const safeLimit = Math.max(1, Math.min(500, Math.trunc(limit)))
       const rows = agentId
-        ? stmts.listByAgent.all(agentId, safeLimit) as any[]
+        ? stmts.listByAgentOrShared.all(agentId, `%"${agentId}"%`, safeLimit) as any[]
         : stmts.listAll.all(safeLimit) as any[]
       return rows.map(rowToEntry)
     },
 
+    listPinned(agentId?: string, limit = 20): MemoryEntry[] {
+      const safeLimit = Math.max(1, Math.min(100, Math.trunc(limit)))
+      const rows = agentId
+        ? stmts.listPinnedByAgent.all(agentId, safeLimit) as any[]
+        : stmts.listPinnedAll.all(safeLimit) as any[]
+      return rows.map(rowToEntry)
+    },
+
+    countsByAgent(): Record<string, number> {
+      const rows = stmts.countsByAgent.all() as { agentKey: string; cnt: number }[]
+      const result: Record<string, number> = {}
+      for (const row of rows) result[row.agentKey] = row.cnt
+      return result
+    },
+
     getByAgent(agentId: string, limit = 200): MemoryEntry[] {
       const safeLimit = Math.max(1, Math.min(500, Math.trunc(limit)))
       return (stmts.listByAgent.all(agentId, safeLimit) as any[]).map(rowToEntry)
@@ -1019,6 +1060,8 @@ export function addKnowledge(params: {
   title: string
   content: string
   tags?: string[]
+  scope?: 'global' | 'agent'
+  agentIds?: string[]
   createdByAgentId?: string | null
   createdBySessionId?: string | null
 }): MemoryEntry {
@@ -1031,6 +1074,8 @@ export function addKnowledge(params: {
     content: params.content,
     metadata: {
       tags: params.tags || [],
+      scope: params.scope || 'global',
+      agentIds: params.scope === 'agent' ? (params.agentIds || []) : [],
       createdByAgentId: params.createdByAgentId || null,
       createdBySessionId: params.createdBySessionId || null,
     },

package/src/lib/server/openclaw-gateway.ts

@@ -77,6 +77,7 @@ export class OpenClawGateway {
   private _connected = false
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
   private reconnectDelay = 800
+  private consecutiveFailures = 0
   private shouldReconnect = false
   private wsUrl = ''
   private token: string | undefined
@@ -104,6 +105,7 @@ export class OpenClawGateway {
       this.ws = result.ws
       this._connected = true
       this.reconnectDelay = 800
+      this.consecutiveFailures = 0
       console.log('[openclaw-gateway] Connected to gateway')
 
       this.ws.on('message', (data) => {
@@ -149,12 +151,18 @@ export class OpenClawGateway {
 
   private scheduleReconnect() {
     if (this.reconnectTimer || !this.shouldReconnect) return
+    this.consecutiveFailures++
+    // After many failures, back off to 10 minutes to avoid hammering a down server
+    const maxDelay = this.consecutiveFailures >= 10 ? 600_000 : 15_000
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null
       if (!this.shouldReconnect) return
       this.doConnect().catch(() => {})
     }, this.reconnectDelay)
-    this.reconnectDelay = Math.min(this.reconnectDelay * 2, 15_000)
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, maxDelay)
+    if (this.consecutiveFailures % 5 === 0) {
+      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failures, next retry in ${Math.round(this.reconnectDelay / 1000)}s`)
+    }
   }
 
   private rejectAllPending(reason: string) {

package/src/lib/server/provider-health.ts

@@ -111,3 +111,128 @@ export function getProviderHealthSnapshot(): Record<string, ProviderHealthState
   return out
 }
 
+// ---------------------------------------------------------------------------
+// Lightweight provider ping functions (extracted from check-provider/route.ts)
+// ---------------------------------------------------------------------------
+
+const PING_TIMEOUT_MS = 8_000
+
+async function parseErrorMessage(res: Response, fallback: string): Promise<string> {
+  const text = await res.text().catch(() => '')
+  if (!text) return fallback
+  try {
+    const parsed = JSON.parse(text)
+    if (typeof parsed?.error?.message === 'string' && parsed.error.message.trim()) return parsed.error.message.trim()
+    if (typeof parsed?.error === 'string' && parsed.error.trim()) return parsed.error.trim()
+    if (typeof parsed?.message === 'string' && parsed.message.trim()) return parsed.message.trim()
+    if (typeof parsed?.detail === 'string' && parsed.detail.trim()) return parsed.detail.trim()
+  } catch { /* non-JSON */ }
+  return text.slice(0, 300).trim() || fallback
+}
+
+export const OPENAI_COMPATIBLE_DEFAULTS: Record<string, { name: string; defaultEndpoint: string }> = {
+  openai: { name: 'OpenAI', defaultEndpoint: 'https://api.openai.com/v1' },
+  google: { name: 'Google Gemini', defaultEndpoint: 'https://generativelanguage.googleapis.com/v1beta/openai' },
+  deepseek: { name: 'DeepSeek', defaultEndpoint: 'https://api.deepseek.com/v1' },
+  groq: { name: 'Groq', defaultEndpoint: 'https://api.groq.com/openai/v1' },
+  together: { name: 'Together AI', defaultEndpoint: 'https://api.together.xyz/v1' },
+  mistral: { name: 'Mistral AI', defaultEndpoint: 'https://api.mistral.ai/v1' },
+  xai: { name: 'xAI (Grok)', defaultEndpoint: 'https://api.x.ai/v1' },
+  fireworks: { name: 'Fireworks AI', defaultEndpoint: 'https://api.fireworks.ai/inference/v1' },
+}
+
+export async function pingOpenAiCompatible(
+  apiKey: string,
+  endpoint: string,
+): Promise<{ ok: boolean; message: string }> {
+  const normalizedEndpoint = endpoint.replace(/\/+$/, '')
+  const res = await fetch(`${normalizedEndpoint}/models`, {
+    headers: { authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(PING_TIMEOUT_MS),
+    cache: 'no-store',
+  })
+  if (!res.ok) {
+    const detail = await parseErrorMessage(res, `Provider returned ${res.status}.`)
+    return { ok: false, message: detail }
+  }
+  return { ok: true, message: 'Connected.' }
+}
+
+export async function pingAnthropic(apiKey: string): Promise<{ ok: boolean; message: string }> {
+  const res = await fetch('https://api.anthropic.com/v1/models', {
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    signal: AbortSignal.timeout(PING_TIMEOUT_MS),
+    cache: 'no-store',
+  })
+  if (!res.ok) {
+    const detail = await parseErrorMessage(res, `Anthropic returned ${res.status}.`)
+    return { ok: false, message: detail }
+  }
+  return { ok: true, message: 'Connected to Anthropic.' }
+}
+
+export async function pingOllama(endpoint: string): Promise<{ ok: boolean; message: string }> {
+  const normalizedEndpoint = (endpoint || 'http://localhost:11434').replace(/\/+$/, '')
+  const res = await fetch(`${normalizedEndpoint}/api/tags`, {
+    signal: AbortSignal.timeout(PING_TIMEOUT_MS),
+    cache: 'no-store',
+  })
+  if (!res.ok) {
+    const detail = await parseErrorMessage(res, `Ollama returned ${res.status}.`)
+    return { ok: false, message: detail }
+  }
+  return { ok: true, message: 'Connected to Ollama.' }
+}
+
+export async function pingOpenClaw(
+  apiKey: string | undefined,
+  endpoint: string,
+): Promise<{ ok: boolean; message: string }> {
+  const { wsConnect } = await import('@/lib/providers/openclaw')
+  let url = (endpoint || 'http://localhost:18789').replace(/\/+$/, '')
+  if (!/^(https?|wss?):\/\//i.test(url)) url = `http://${url}`
+  const wsUrl = url.replace(/^http:/i, 'ws:').replace(/^https:/i, 'wss:')
+  const result = await wsConnect(wsUrl, apiKey || undefined, true, PING_TIMEOUT_MS)
+  if (result.ws) try { result.ws.close() } catch { /* ignore */ }
+  return { ok: result.ok, message: result.ok ? 'Connected to OpenClaw.' : result.message }
+}
+
+/**
+ * Ping a provider to check reachability. Returns `{ ok, message }`.
+ * Skips CLI-based providers (claude-cli, codex-cli, opencode-cli) — returns ok.
+ */
+export async function pingProvider(
+  provider: string,
+  apiKey: string | undefined,
+  endpoint: string | undefined,
+): Promise<{ ok: boolean; message: string }> {
+  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli']
+  if (CLI_PROVIDERS.includes(provider)) return { ok: true, message: 'CLI provider — skipped.' }
+
+  try {
+    if (provider === 'anthropic') {
+      if (!apiKey) return { ok: false, message: 'No API key configured.' }
+      return await pingAnthropic(apiKey)
+    }
+    if (provider === 'ollama') {
+      return await pingOllama(endpoint || 'http://localhost:11434')
+    }
+    if (provider === 'openclaw') {
+      return await pingOpenClaw(apiKey, endpoint || 'http://localhost:18789')
+    }
+    // OpenAI-compatible providers (openai, google, deepseek, groq, together, mistral, xai, fireworks, custom)
+    const defaults = OPENAI_COMPATIBLE_DEFAULTS[provider]
+    const resolvedEndpoint = endpoint || defaults?.defaultEndpoint
+    if (!resolvedEndpoint) return { ok: false, message: `No endpoint for provider "${provider}".` }
+    if (!apiKey) return { ok: false, message: 'No API key configured.' }
+    return await pingOpenAiCompatible(apiKey, resolvedEndpoint)
+  } catch (err: unknown) {
+    const msg = err instanceof Error && err.name === 'TimeoutError'
+      ? 'Connection timed out.'
+      : (err instanceof Error ? err.message : String(err))
+    return { ok: false, message: msg }
+  }
+}

package/src/lib/server/queue.ts

@@ -12,7 +12,8 @@ import { getCheckpointSaver } from './langgraph-checkpoint'
 import { isProtectedMainSession } from './main-session'
 import type { Agent, BoardTask, Message } from '@/types'
 
-let processing = false
+// HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
+const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false }) as { processing: boolean }
 
 interface SessionMessageLike {
   role?: string
@@ -467,8 +468,8 @@ function dequeueNextRunnableTask(queue: string[], tasks: Record<string, BoardTas
 }
 
 export async function processNext() {
-  if (processing) return
-  processing = true
+  if (_queueState.processing) return
+  _queueState.processing = true
 
   try {
     // Recover orphaned tasks: status is 'queued' but missing from the queue array
@@ -805,7 +806,7 @@ export async function processNext() {
       }
     }
   } finally {
-    processing = false
+    _queueState.processing = false
   }
 }
 

package/src/lib/server/scheduler.ts

@@ -4,6 +4,8 @@ import { enqueueTask } from './queue'
 import { CronExpressionParser } from 'cron-parser'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
+import { enqueueSystemEvent } from './system-events'
+import { requestHeartbeatNow } from './heartbeat-wake'
 
 const TICK_INTERVAL = 60_000 // 60 seconds
 let intervalId: ReturnType<typeof setInterval> | null = null
@@ -192,5 +194,11 @@ async function tick() {
       type: 'schedule_fired',
       text: `Schedule fired: "${schedule.name}" (${schedule.id}) run #${schedule.runNumber} — task ${taskId}`,
     })
+
+    // Enqueue system event + heartbeat wake for the schedule's agent
+    if (schedule.createdInSessionId) {
+      enqueueSystemEvent(schedule.createdInSessionId, `Schedule triggered: ${schedule.name}`)
+    }
+    requestHeartbeatNow({ agentId: schedule.agentId, reason: 'schedule' })
   }
 }

package/src/lib/server/session-run-manager.ts

@@ -37,6 +37,7 @@ interface QueueEntry {
   maxRuntimeMs?: number
   modelOverride?: string
   heartbeatConfig?: { ackMaxChars: number; showOk: boolean; showAlerts: boolean; target: string | null }
+  replyToId?: string
   resolve: (value: ExecuteChatTurnResult) => void
   reject: (error: Error) => void
   promise: Promise<ExecuteChatTurnResult>
@@ -245,6 +246,7 @@ async function drainExecution(executionKey: string): Promise<void> {
       onEvent: (event) => emitToSubscribers(next, event),
       modelOverride: next.modelOverride,
       heartbeatConfig: next.heartbeatConfig,
+      replyToId: next.replyToId,
     })
 
     const failed = !!result.error
@@ -344,6 +346,7 @@ export interface EnqueueSessionRunInput {
   maxRuntimeMs?: number
   modelOverride?: string
   heartbeatConfig?: { ackMaxChars: number; showOk: boolean; showAlerts: boolean; target: string | null }
+  replyToId?: string
 }
 
 export interface EnqueueSessionRunResult {
@@ -454,6 +457,7 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
     maxRuntimeMs: effectiveMaxRuntimeMs > 0 ? effectiveMaxRuntimeMs : undefined,
     modelOverride: input.modelOverride,
     heartbeatConfig: input.heartbeatConfig,
+    replyToId: input.replyToId,
     resolve,
     reject,
     promise,

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

@@ -0,0 +1,136 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { loadChatrooms, saveChatrooms, loadAgents } from '../storage'
+import { genId } from '@/lib/id'
+import { notify } from '../ws-hub'
+import type { ToolBuildContext } from './context'
+import type { Chatroom } from '@/types'
+
+export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const tools: StructuredToolInterface[] = []
+  const { hasTool } = bctx
+
+  if (hasTool('manage_chatrooms')) {
+    tools.push(
+      tool(
+        async ({ action, chatroomId, name, description, agentIds, agentId, message }) => {
+          try {
+            const chatrooms = loadChatrooms() as Record<string, Chatroom>
+
+            if (action === 'list_chatrooms') {
+              const list = Object.values(chatrooms).map((cr) => ({
+                id: cr.id,
+                name: cr.name,
+                description: cr.description,
+                memberCount: cr.agentIds.length,
+                messageCount: cr.messages.length,
+              }))
+              return JSON.stringify(list)
+            }
+
+            if (action === 'create_chatroom') {
+              const id = genId()
+              const agents = loadAgents()
+              const validAgentIds = (agentIds || []).filter((aid: string) => agents[aid])
+              const chatroom: Chatroom = {
+                id,
+                name: name || 'New Chatroom',
+                description: description || '',
+                agentIds: validAgentIds,
+                messages: [],
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+              }
+              chatrooms[id] = chatroom
+              saveChatrooms(chatrooms)
+              notify('chatrooms')
+              return JSON.stringify({ ok: true, chatroom: { id, name: chatroom.name, agentIds: validAgentIds } })
+            }
+
+            if (!chatroomId) return 'Error: chatroomId is required for this action.'
+            const chatroom = chatrooms[chatroomId]
+            if (!chatroom) return `Error: chatroom not found: ${chatroomId}`
+
+            if (action === 'add_agent') {
+              if (!agentId) return 'Error: agentId is required.'
+              const agents = loadAgents()
+              if (!agents[agentId]) return `Error: agent not found: ${agentId}`
+              if (!chatroom.agentIds.includes(agentId)) {
+                chatroom.agentIds.push(agentId)
+                chatroom.updatedAt = Date.now()
+                chatrooms[chatroomId] = chatroom
+                saveChatrooms(chatrooms)
+                notify('chatrooms')
+                notify(`chatroom:${chatroomId}`)
+              }
+              return JSON.stringify({ ok: true, agentIds: chatroom.agentIds })
+            }
+
+            if (action === 'remove_agent') {
+              if (!agentId) return 'Error: agentId is required.'
+              chatroom.agentIds = chatroom.agentIds.filter((id: string) => id !== agentId)
+              chatroom.updatedAt = Date.now()
+              chatrooms[chatroomId] = chatroom
+              saveChatrooms(chatrooms)
+              notify('chatrooms')
+              notify(`chatroom:${chatroomId}`)
+              return JSON.stringify({ ok: true, agentIds: chatroom.agentIds })
+            }
+
+            if (action === 'list_members') {
+              const agents = loadAgents()
+              const members = chatroom.agentIds.map((id: string) => {
+                const agent = agents[id]
+                return agent ? { id, name: agent.name, description: agent.description } : { id, name: 'Unknown' }
+              })
+              return JSON.stringify(members)
+            }
+
+            if (action === 'send_message') {
+              if (!message) return 'Error: message is required.'
+              const msgId = genId()
+              const senderName = bctx.ctx?.agentId
+                ? (loadAgents()[bctx.ctx.agentId]?.name || 'Agent')
+                : 'Agent'
+              chatroom.messages.push({
+                id: msgId,
+                senderId: bctx.ctx?.agentId || 'agent',
+                senderName,
+                role: 'assistant' as const,
+                text: message,
+                mentions: [],
+                reactions: [],
+                time: Date.now(),
+              })
+              chatroom.updatedAt = Date.now()
+              chatrooms[chatroomId] = chatroom
+              saveChatrooms(chatrooms)
+              notify(`chatroom:${chatroomId}`)
+              return JSON.stringify({ ok: true, messageId: msgId })
+            }
+
+            return `Error: unknown action "${action}". Valid actions: list_chatrooms, create_chatroom, add_agent, remove_agent, list_members, send_message`
+          } catch (err: unknown) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`
+          }
+        },
+        {
+          name: 'manage_chatrooms',
+          description: 'Manage chatrooms for multi-agent collaboration. Actions: list_chatrooms, create_chatroom, add_agent, remove_agent, list_members, send_message.',
+          schema: z.object({
+            action: z.enum(['list_chatrooms', 'create_chatroom', 'add_agent', 'remove_agent', 'list_members', 'send_message'])
+              .describe('The action to perform'),
+            chatroomId: z.string().optional().describe('Chatroom ID (required for most actions except list/create)'),
+            name: z.string().optional().describe('Chatroom name (for create_chatroom)'),
+            description: z.string().optional().describe('Chatroom description (for create_chatroom)'),
+            agentIds: z.array(z.string()).optional().describe('Initial agent IDs (for create_chatroom)'),
+            agentId: z.string().optional().describe('Agent ID (for add_agent/remove_agent)'),
+            message: z.string().optional().describe('Message text (for send_message)'),
+          }),
+        },
+      ),
+    )
+  }
+
+  return tools
+}

package/src/lib/server/session-tools/context-mgmt.ts

@@ -1,6 +1,9 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
-import { loadSessions, saveSessions } from '../storage'
+import { HumanMessage } from '@langchain/core/messages'
+import { loadSessions, saveSessions, loadCredentials, decryptKey } from '../storage'
+import { buildChatModel } from '../build-llm'
+import { getProvider } from '@/lib/providers'
 import type { ToolBuildContext } from './context'
 
 export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterface[] {
@@ -19,8 +22,8 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
             const systemPromptTokens = 2000
             const status = getContextStatus(messages, systemPromptTokens, session.provider, session.model)
             return JSON.stringify(status)
-          } catch (err: any) {
-            return `Error: ${err.message || String(err)}`
+          } catch (err: unknown) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {
@@ -46,20 +49,33 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
               return JSON.stringify({ status: 'no_action', reason: 'Not enough messages to compact', messageCount: messages.length })
             }
 
-            const generateSummary = async (text: string): Promise<string> => {
-              const lines = text.split('\n\n').filter(Boolean)
-              const keyLines: string[] = []
-              for (const line of lines) {
-                if (line.length > 20) {
-                  keyLines.push(line.slice(0, 200))
-                }
-              }
-              let summary = ''
-              for (const line of keyLines) {
-                if (summary.length + line.length > 2000) break
-                summary += line + '\n'
+            // Resolve API key for the session's provider
+            let apiKey: string | null = null
+            const providerInfo = getProvider(session.provider)
+            if ((providerInfo?.requiresApiKey || providerInfo?.optionalApiKey) && session.credentialId) {
+              try {
+                const creds = loadCredentials()
+                const cred = creds[session.credentialId]
+                if (cred) apiKey = decryptKey(cred.encryptedKey)
+              } catch { /* continue without key */ }
+            }
+
+            // Build LLM summarizer using the session's provider/model
+            const generateSummary = async (prompt: string): Promise<string> => {
+              const llm = buildChatModel({
+                provider: session.provider,
+                model: session.model,
+                apiKey,
+                apiEndpoint: session.apiEndpoint,
+              })
+              const response = await llm.invoke([new HumanMessage(prompt)])
+              if (typeof response.content === 'string') return response.content
+              if (Array.isArray(response.content)) {
+                return response.content
+                  .map((b: Record<string, unknown>) => (typeof b.text === 'string' ? b.text : ''))
+                  .join('')
               }
-              return summary.trim() || 'Previous conversation context was pruned.'
+              return ''
             }
 
             const result = await summarizeAndCompact({
@@ -67,6 +83,8 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
               keepLastN: keep,
               agentId: ctx?.agentId || session.agentId || null,
               sessionId: ctx.sessionId,
+              provider: session.provider,
+              model: session.model,
               generateSummary,
             })
 
@@ -84,8 +102,8 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
               summaryAdded: result.summaryAdded,
               remainingMessages: result.messages.length,
             })
-          } catch (err: any) {
-            return `Error: ${err.message || String(err)}`
+          } catch (err: unknown) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {

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

@@ -16,6 +16,7 @@ import { buildConnectorTools } from './connector'
 import { buildContextTools } from './context-mgmt'
 import { buildSandboxTools } from './sandbox'
 import { buildOpenClawNodeTools } from './openclaw-nodes'
+import { buildChatroomTools } from './chatroom'
 
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
@@ -97,6 +98,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildContextTools(bctx),
     ...buildSandboxTools(bctx),
     ...buildOpenClawNodeTools(bctx),
+    ...buildChatroomTools(bctx),
   )
 
   // ---------------------------------------------------------------------------