@swarmclawai/swarmclaw 0.6.7 → 0.7.0

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

@@ -3,65 +3,100 @@ import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { loadSessions, saveSessions } from '../storage'
 import { notify } from '../ws-hub'
 import type { ToolBuildContext } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const { ctx, hasTool } = bctx
-  if (!hasTool('canvas')) return []
+/**
+ * Core Canvas Execution Logic
+ */
+async function executeCanvasAction(args: Record<string, unknown>, context: { sessionId?: string }) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = normalized.action as string
+  const content = normalized.content as string | undefined
+  try {
+    const sessionId = context.sessionId
+    if (!sessionId) return 'Error: no active session for canvas.'
 
-  return [
-    tool(
-      async ({ action, content }) => {
-        try {
-          const sessionId = ctx?.sessionId
-          if (!sessionId) return 'Error: no active session for canvas.'
+    const sessions = loadSessions()
+    const session = sessions[sessionId]
+    if (!session) return 'Error: session not found.'
 
-          const sessions = loadSessions()
-          const session = sessions[sessionId]
-          if (!session) return 'Error: session not found.'
+    if (action === 'present') {
+      if (!content) return 'Error: content is required for present action.'
+      ;(session as Record<string, unknown>).canvasContent = content
+      session.lastActiveAt = Date.now()
+      sessions[sessionId] = session
+      saveSessions(sessions)
+      notify(`canvas:${sessionId}`)
+      return JSON.stringify({ ok: true, action: 'present', contentLength: content.length })
+    }
 
-          if (action === 'present') {
-            if (!content) return 'Error: content is required for present action.'
-            ;(session as Record<string, unknown>).canvasContent = content
-            session.lastActiveAt = Date.now()
-            sessions[sessionId] = session
-            saveSessions(sessions)
-            notify(`canvas:${sessionId}`)
-            return JSON.stringify({ ok: true, action: 'present', contentLength: content.length })
-          }
+    if (action === 'hide') {
+      ;(session as Record<string, unknown>).canvasContent = null
+      session.lastActiveAt = Date.now()
+      sessions[sessionId] = session
+      saveSessions(sessions)
+      notify(`canvas:${sessionId}`)
+      return JSON.stringify({ ok: true, action: 'hide' })
+    }
 
-          if (action === 'hide') {
-            ;(session as Record<string, unknown>).canvasContent = null
-            session.lastActiveAt = Date.now()
-            sessions[sessionId] = session
-            saveSessions(sessions)
-            notify(`canvas:${sessionId}`)
-            return JSON.stringify({ ok: true, action: 'hide' })
-          }
+    if (action === 'snapshot') {
+      const current = (session as Record<string, unknown>).canvasContent
+      return JSON.stringify({
+        ok: true,
+        action: 'snapshot',
+        hasContent: !!current,
+        contentLength: typeof current === 'string' ? current.length : 0,
+        preview: typeof current === 'string' ? current.slice(0, 500) : null,
+      })
+    }
 
-          if (action === 'snapshot') {
-            const current = (session as Record<string, unknown>).canvasContent
-            return JSON.stringify({
-              ok: true,
-              action: 'snapshot',
-              hasContent: !!current,
-              contentLength: typeof current === 'string' ? current.length : 0,
-              preview: typeof current === 'string' ? current.slice(0, 500) : null,
-            })
-          }
+    return `Unknown canvas action "${action}".`
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
 
-          return `Unknown canvas action "${action}". Valid: present, hide, snapshot`
-        } catch (err: unknown) {
-          return `Error: ${err instanceof Error ? err.message : String(err)}`
-        }
+/**
+ * Register as a Built-in Plugin
+ */
+const CanvasPlugin: Plugin = {
+  name: 'Core Canvas',
+  description: 'Present live HTML/CSS/JS content to the user in an interactive canvas panel.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'canvas',
+      description: 'Interact with the live canvas panel.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['present', 'hide', 'snapshot'] },
+          content: { type: 'string' }
+        },
+        required: ['action']
       },
+      execute: async (args, context) => executeCanvasAction(args, { sessionId: context.session.id })
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('canvas', CanvasPlugin)
+
+/**
+ * Legacy Bridge
+ */
+export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('canvas')) return []
+  return [
+    tool(
+      async (args) => executeCanvasAction(args, { sessionId: bctx.ctx?.sessionId || undefined }),
       {
         name: 'canvas',
-        description: 'Present live HTML/CSS/JS content to the user in an interactive canvas panel. Use "present" to show content, "hide" to dismiss, "snapshot" to check current state. The canvas renders in a sandboxed iframe alongside the chat.',
-        schema: z.object({
-          action: z.enum(['present', 'hide', 'snapshot']).describe('Canvas action to perform'),
-          content: z.string().optional().describe('HTML content to render (required for "present"). Can include inline CSS and JS.'),
-        }),
-      },
-    ),
+        description: CanvasPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
+    )
   ]
 }

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

@@ -4,142 +4,145 @@ 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'
+import type { Chatroom, Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
 
-export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const tools: StructuredToolInterface[] = []
-  const { hasTool } = bctx
+/**
+ * Core Chatroom Execution Logic
+ */
+async function executeChatroomAction(args: Record<string, unknown>, context: { agentId?: string | null }) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = normalized.action as string
+  const chatroomId = (normalized.chatroomId ?? normalized.chatroom_id) as string | undefined
+  const name = normalized.name as string | undefined
+  const description = normalized.description as string | undefined
+  const agentIds = (normalized.agentIds ?? normalized.agent_ids) as string[] | undefined
+  const agentId = (normalized.agentId ?? normalized.agent_id) as string | undefined
+  const message = (normalized.message ?? normalized.text) as string | undefined
+  const chatMode = (normalized.chatMode ?? normalized.chat_mode) as string | undefined
+  const autoAddress = (normalized.autoAddress ?? normalized.auto_address) as boolean | undefined
+  try {
+    const chatrooms = loadChatrooms() as Record<string, Chatroom>
 
-  if (hasTool('manage_chatrooms')) {
-    tools.push(
-      tool(
-        async ({ action, chatroomId, name, description, agentIds, agentId, message, chatMode, autoAddress }) => {
-          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 === '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 requestedAgentIds = agentIds || []
+      const validAgentIds = requestedAgentIds.filter((aid: string) => !!agents[aid])
+      
+      const chatroom: Chatroom = {
+        id,
+        name: name || 'New Chatroom',
+        description: description || '',
+        agentIds: validAgentIds,
+        messages: [],
+        chatMode: chatMode === 'parallel' ? 'parallel' : 'sequential',
+        autoAddress: Boolean(autoAddress),
+        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 (action === 'create_chatroom') {
-              const id = genId()
-              const agents = loadAgents()
-              const requestedAgentIds = agentIds || []
-              const invalidAgentIds = requestedAgentIds.filter((aid: string) => !agents[aid])
-              if (invalidAgentIds.length > 0) {
-                return `Error: unknown agent IDs: ${invalidAgentIds.join(', ')}`
-              }
-              const validAgentIds = requestedAgentIds
-              const chatroom: Chatroom = {
-                id,
-                name: name || 'New Chatroom',
-                description: description || '',
-                agentIds: validAgentIds,
-                messages: [],
-                chatMode: chatMode === 'parallel' ? 'parallel' : 'sequential',
-                autoAddress: Boolean(autoAddress),
-                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.'
+    const chatroom = chatrooms[chatroomId]
+    if (!chatroom) return `Error: chatroom not found.`
 
-            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 required.'
+      if (!chatroom.agentIds.includes(agentId)) {
+        chatroom.agentIds.push(agentId)
+        chatroom.updatedAt = Date.now()
+        saveChatrooms(chatrooms)
+        notify('chatrooms'); notify(`chatroom:${chatroomId}`)
+      }
+      return JSON.stringify({ ok: true, agentIds: chatroom.agentIds })
+    }
 
-            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 === 'send_message') {
+      if (!message) return 'Error: message required.'
+      const msgId = genId()
+      const agents = loadAgents()
+      const senderName = context.agentId ? (agents[context.agentId]?.name || 'Agent') : 'Agent'
+      chatroom.messages.push({
+        id: msgId,
+        senderId: context.agentId || 'agent',
+        senderName,
+        role: 'assistant' as const,
+        text: message,
+        mentions: [],
+        reactions: [],
+        time: Date.now(),
+      })
+      chatroom.updatedAt = Date.now()
+      saveChatrooms(chatrooms)
+      notify(`chatroom:${chatroomId}`)
+      return JSON.stringify({ ok: true, messageId: msgId })
+    }
 
-            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 })
-            }
+    return `Unknown action "${action}".`
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
 
-            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)
-            }
+/**
+ * Register as a Built-in Plugin
+ */
+const ChatroomPlugin: Plugin = {
+  name: 'Core Chatrooms',
+  description: 'Manage SwarmClaw routing rules and multi-agent chatrooms.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'manage_chatrooms',
+      description: 'Manage multi-agent chatrooms and collaboration.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['list_chatrooms', 'create_chatroom', 'add_agent', 'remove_agent', 'list_members', 'send_message'] },
+          chatroomId: { type: 'string' },
+          name: { type: 'string' },
+          agentId: { type: 'string' },
+          message: { type: 'string' }
+        },
+        required: ['action']
+      },
+      execute: async (args, context) => executeChatroomAction(args, { agentId: context.session.agentId })
+    }
+  ]
+}
 
-            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 })
-            }
+getPluginManager().registerBuiltin('chatroom', ChatroomPlugin)
 
-            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)'),
-            chatMode: z.enum(['sequential', 'parallel']).optional().describe('Optional orchestration mode for create_chatroom'),
-            autoAddress: z.boolean().optional().describe('Whether to auto-address all members when no @mention is present'),
-            agentId: z.string().optional().describe('Agent ID (for add_agent/remove_agent)'),
-            message: z.string().optional().describe('Message text (for send_message)'),
-          }),
-        },
-      ),
+/**
+ * Legacy Bridge
+ */
+export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('manage_chatrooms')) return []
+  return [
+    tool(
+      async (args) => executeChatroomAction(args, { agentId: bctx.ctx?.agentId }),
+      {
+        name: 'manage_chatrooms',
+        description: ChatroomPlugin.tools![0].description,
+        schema: z.object({}).passthrough()
+      }
     )
-  }
-
-  return tools
+  ]
 }