@swarmclawai/swarmclaw 0.6.0 → 0.6.3

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

@@ -20,6 +20,8 @@ import {
 } from '../storage'
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule, type ScheduleLike } from '@/lib/schedule-dedupe'
+import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
+import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
 import type { ToolBuildContext } from './context'
 import { safePath, findBinaryOnPath } from './context'
 
@@ -115,6 +117,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     queuedAt: null,
     startedAt: null,
     completedAt: null,
+    priority: ['low', 'medium', 'high', 'critical'].includes(p.priority) ? p.priority : undefined,
     ...p,
   }),
   manage_schedules: (p) => {
@@ -342,6 +345,24 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   })
                 }
               }
+              // @mention agent resolution for tasks
+              if (toolKey === 'manage_tasks' && parsed.description) {
+                const agents = loadAgents()
+                parsed.agentId = resolveTaskAgentFromDescription(
+                  parsed.description,
+                  parsed.agentId || ctx?.agentId || '',
+                  agents,
+                )
+              }
+              // Task dedup
+              if (toolKey === 'manage_tasks') {
+                const fp = computeTaskFingerprint(parsed.title || 'Untitled Task', parsed.agentId || ctx?.agentId || '')
+                parsed.fingerprint = fp
+                const dupe = findDuplicateTask(all as Record<string, import('@/types').BoardTask>, { fingerprint: fp })
+                if (dupe) {
+                  return JSON.stringify({ ...dupe, deduplicated: true })
+                }
+              }
               const newId = genId()
               const entry = {
                 id: newId,

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

@@ -634,6 +634,69 @@ export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterf
     }
   }
 
+  // check_delegation_status: lets agents check on tasks they delegated
+  if (ctx?.platformAssignScope === 'all' && ctx?.agentId) {
+    tools.push(
+      tool(
+        async ({ taskId }) => {
+          try {
+            const tasks = loadTasks()
+            const task = tasks[taskId] as Record<string, unknown> | undefined
+            if (!task) return `Error: Task "${taskId}" not found.`
+
+            const status = task.status as string || 'unknown'
+            const result = typeof task.result === 'string' ? task.result : null
+            const error = typeof task.error === 'string' ? task.error : null
+            const agentId = task.agentId as string || ''
+            const agents = loadAgents()
+            const agent = agents[agentId]
+            const startedAt = typeof task.startedAt === 'number' ? task.startedAt : null
+            const completedAt = typeof task.completedAt === 'number' ? task.completedAt : null
+
+            const info: Record<string, unknown> = {
+              taskId,
+              status,
+              agentId,
+              agentName: agent?.name || agentId,
+              agentAvatarSeed: agent?.avatarSeed || null,
+              title: task.title || '',
+            }
+
+            if (startedAt) info.startedAt = new Date(startedAt).toISOString()
+            if (completedAt) info.completedAt = new Date(completedAt).toISOString()
+            if (startedAt && !completedAt && status === 'running') {
+              info.runningForSeconds = Math.round((Date.now() - startedAt) / 1000)
+            }
+            if (result) info.result = result.slice(0, 4000)
+            if (error) info.error = error.slice(0, 1000)
+
+            // Include latest comments for context
+            const comments = Array.isArray(task.comments) ? task.comments as Array<{ text: string; author: string; createdAt: number }> : []
+            if (comments.length > 0) {
+              const latest = comments.slice(-3).map((c) => ({
+                author: c.author,
+                text: (c.text || '').slice(0, 500),
+                time: new Date(c.createdAt).toISOString(),
+              }))
+              info.latestComments = latest
+            }
+
+            return JSON.stringify(info)
+          } catch (err: unknown) {
+            return `Error checking task: ${err instanceof Error ? err.message : String(err)}`
+          }
+        },
+        {
+          name: 'check_delegation_status',
+          description: 'Check the status and result of a delegated task. Use this after delegate_to_agent to monitor progress. Returns status (todo/queued/running/completed/failed), result if completed, and latest comments.',
+          schema: z.object({
+            taskId: z.string().describe('The task ID returned by delegate_to_agent'),
+          }),
+        },
+      ),
+    )
+  }
+
   // delegate_to_agent: requires "Assign to Other Agents" (platformAssignScope: 'all')
   if (ctx?.platformAssignScope === 'all' && ctx?.agentId) {
     tools.push(
@@ -698,9 +761,10 @@ export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterf
               taskId,
               agentId: resolvedId,
               agentName: target.name,
+              agentAvatarSeed: target.avatarSeed || null,
               message: startImmediately
-                ? `Task delegated to ${target.name} and queued for immediate execution. Task ID: ${taskId}.`
-                : `Task delegated to ${target.name}. Task ID: ${taskId}. Status: todo. Ask the user if they want to start it now — call again with startImmediately: true to queue it.`,
+                ? `Task delegated to ${target.name} and queued for immediate execution. Task ID: ${taskId}. Use check_delegation_status to monitor progress.`
+                : `Task delegated to ${target.name}. Task ID: ${taskId}. Status: todo (not auto-started). Use delegate_to_agent with startImmediately: true to queue it.`,
             })
           } catch (err: unknown) {
             return `Error delegating task: ${err instanceof Error ? err.message : String(err)}`
@@ -708,12 +772,12 @@ export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterf
         },
         {
           name: 'delegate_to_agent',
-          description: 'Delegate a task to another agent. Creates a task on the task board. By default the task goes to "todo" status. Set startImmediately=true to queue it for execution right away. Ask the user to confirm before starting immediately.',
+          description: 'Delegate a task to another agent. Creates a task on the task board and queues it for immediate execution by default. Set startImmediately=false if you want the task to go to "todo" status instead.',
           schema: z.object({
             agentId: z.string().describe('ID or name of the target agent to delegate to'),
             task: z.string().describe('What the target agent should do'),
             description: z.string().optional().describe('Optional longer description of the task'),
-            startImmediately: z.boolean().optional().default(false).describe('If true, queue the task for immediate execution instead of putting it in todo'),
+            startImmediately: z.boolean().optional().default(true).describe('If true (default), queue the task for immediate execution. Set false to put in todo for manual start.'),
           }),
         },
       ),

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

@@ -6,6 +6,17 @@ import { UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
 import { safePath, truncate, listDirRecursive, MAX_OUTPUT, MAX_FILE } from './context'
 
+const SEND_FILE_DEDUPE_TTL_MS = 30_000
+const recentSendFileResults = new Map<string, { at: number; output: string; uploadPath: string }>()
+
+function pruneRecentSendFileCache(now: number): void {
+  for (const [key, entry] of recentSendFileResults.entries()) {
+    if (now - entry.at > SEND_FILE_DEDUPE_TTL_MS || !fs.existsSync(entry.uploadPath)) {
+      recentSendFileResults.delete(key)
+    }
+  }
+}
+
 export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
 
@@ -197,6 +208,8 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
       tool(
         async ({ filePath: rawPath }) => {
           try {
+            const now = Date.now()
+            pruneRecentSendFileCache(now)
             // Resolve relative to cwd, but also allow absolute paths
             const resolved = path.isAbsolute(rawPath) ? rawPath : path.resolve(bctx.cwd, rawPath)
             if (!fs.existsSync(resolved)) return `Error: file not found: ${rawPath}`
@@ -204,6 +217,13 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
             if (stat.isDirectory()) return `Error: cannot send a directory. Send individual files instead.`
             if (stat.size > 100 * 1024 * 1024) return `Error: file too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 100MB.`
 
+            const sessionId = bctx.ctx?.sessionId || 'no-session'
+            const dedupeKey = `${sessionId}|${resolved}`
+            const cached = recentSendFileResults.get(dedupeKey)
+            if (cached && now - cached.at <= SEND_FILE_DEDUPE_TTL_MS && fs.existsSync(cached.uploadPath)) {
+              return cached.output
+            }
+
             const ext = path.extname(resolved).slice(1).toLowerCase()
             const basename = path.basename(resolved)
             const filename = `${Date.now()}-${basename}`
@@ -212,14 +232,13 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
 
             const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico']
             const VIDEO_EXTS = ['mp4', 'webm', 'mov', 'avi', 'mkv']
+            const AUDIO_EXTS = ['mp3', 'ogg', 'wav', 'aac', 'm4a', 'opus']
 
-            if (IMAGE_EXTS.includes(ext)) {
-              return `![${basename}](/api/uploads/${filename})`
-            } else if (VIDEO_EXTS.includes(ext)) {
-              return `![${basename}](/api/uploads/${filename})`
-            } else {
-              return `[Download ${basename}](/api/uploads/${filename})`
-            }
+            const output = (IMAGE_EXTS.includes(ext) || VIDEO_EXTS.includes(ext) || AUDIO_EXTS.includes(ext))
+              ? `![${basename}](/api/uploads/${filename})`
+              : `[Download ${basename}](/api/uploads/${filename})`
+            recentSendFileResults.set(dedupeKey, { at: now, output, uploadPath: dest })
+            return output
           } catch (err: unknown) {
             return `Error sending file: ${err instanceof Error ? err.message : String(err)}`
           }

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

@@ -0,0 +1,71 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import type { ToolBuildContext } from './context'
+import { findBinaryOnPath, safePath, truncate, MAX_OUTPUT } from './context'
+
+const execFileAsync = promisify(execFile)
+
+const GIT_ACTIONS = [
+  'status', 'log', 'diff', 'commit', 'add', 'push', 'pull',
+  'branch', 'checkout', 'stash', 'merge', 'clone', 'remote',
+  'tag', 'reset', 'show',
+] as const
+
+export function buildGitTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('git')) return []
+
+  const gitPath = findBinaryOnPath('git')
+  if (!gitPath) return []
+
+  return [
+    tool(
+      async ({ action, args, repoPath, timeoutSec }) => {
+        try {
+          const cwd = repoPath ? safePath(bctx.cwd, repoPath) : bctx.cwd
+          const timeout = Math.max(5, Math.min(timeoutSec ?? 60, 300)) * 1000
+
+          // Verify we're in a git repo (except for clone)
+          if (action !== 'clone') {
+            try {
+              await execFileAsync(gitPath, ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 5000 })
+            } catch {
+              return JSON.stringify({ error: `Not a git repository: ${cwd}` })
+            }
+          }
+
+          const cmdArgs = [action, ...(args ?? [])]
+          const result = await execFileAsync(gitPath, cmdArgs, {
+            cwd,
+            timeout,
+            maxBuffer: MAX_OUTPUT,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+          })
+          return JSON.stringify({
+            exitCode: 0,
+            stdout: truncate(result.stdout ?? '', MAX_OUTPUT),
+            stderr: truncate(result.stderr ?? '', MAX_OUTPUT),
+          })
+        } catch (err: unknown) {
+          const execErr = err as { code?: number; stdout?: string; stderr?: string; message?: string }
+          return JSON.stringify({
+            exitCode: execErr.code ?? 1,
+            stdout: truncate(execErr.stdout ?? '', MAX_OUTPUT),
+            stderr: truncate(execErr.stderr ?? execErr.message ?? String(err), MAX_OUTPUT),
+          })
+        }
+      },
+      {
+        name: 'git',
+        description: 'Run git operations. Verify the repo exists before committing or pushing. Use args for subcommand flags (e.g. args: ["-m", "message"] for commit).',
+        schema: z.object({
+          action: z.enum(GIT_ACTIONS).describe('Git subcommand to run'),
+          args: z.array(z.string()).optional().describe('Additional arguments (e.g. ["-m", "fix: typo"], ["--oneline", "-n", "5"])'),
+          repoPath: z.string().optional().describe('Relative path to git repo (defaults to working directory)'),
+          timeoutSec: z.number().optional().describe('Timeout in seconds (default 60, max 300)'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -0,0 +1,57 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { ToolBuildContext } from './context'
+import { truncate, MAX_OUTPUT } from './context'
+
+export function buildHttpTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('http_request')) return []
+
+  return [
+    tool(
+      async ({ method, url, headers, body, timeoutSec, followRedirects }) => {
+        try {
+          const timeout = Math.max(1, Math.min(timeoutSec ?? 30, 120)) * 1000
+          const init: RequestInit = {
+            method,
+            headers: (headers ?? undefined) as Record<string, string> | undefined,
+            signal: AbortSignal.timeout(timeout),
+          }
+          if (body && method !== 'GET' && method !== 'HEAD') {
+            init.body = body
+          }
+          if (followRedirects === false) {
+            init.redirect = 'manual'
+          }
+          const res = await fetch(url, init)
+          const resHeaders: Record<string, string> = {}
+          for (const key of ['content-type', 'location', 'x-request-id', 'retry-after', 'content-length']) {
+            const val = res.headers.get(key)
+            if (val) resHeaders[key] = val
+          }
+          let resBody: string
+          const ct = res.headers.get('content-type') ?? ''
+          if (ct.includes('image/') || ct.includes('audio/') || ct.includes('video/') || ct.includes('application/octet-stream')) {
+            resBody = `[binary content, ${res.headers.get('content-length') ?? 'unknown'} bytes]`
+          } else {
+            resBody = truncate(await res.text(), MAX_OUTPUT)
+          }
+          return JSON.stringify({ status: res.status, statusText: res.statusText, headers: resHeaders, body: resBody })
+        } catch (err: unknown) {
+          return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+        }
+      },
+      {
+        name: 'http_request',
+        description: 'Make an HTTP API request. Supports all methods, custom headers, and request bodies. Returns status, headers, and body.',
+        schema: z.object({
+          method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']).describe('HTTP method'),
+          url: z.string().describe('Full URL to request'),
+          headers: z.record(z.string(), z.string()).optional().describe('Request headers as key-value pairs'),
+          body: z.string().optional().describe('Request body (JSON string, form data, or plain text). Ignored for GET/HEAD.'),
+          timeoutSec: z.number().optional().describe('Timeout in seconds (default 30, max 120)'),
+          followRedirects: z.boolean().optional().describe('Follow redirects (default true). Set false to inspect redirect responses.'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -17,6 +17,10 @@ import { buildContextTools } from './context-mgmt'
 import { buildSandboxTools } from './sandbox'
 import { buildOpenClawNodeTools } from './openclaw-nodes'
 import { buildChatroomTools } from './chatroom'
+import { buildSubagentTools } from './subagent'
+import { buildCanvasTools } from './canvas'
+import { buildHttpTools } from './http'
+import { buildGitTools } from './git'
 
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
@@ -99,6 +103,10 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildSandboxTools(bctx),
     ...buildOpenClawNodeTools(bctx),
     ...buildChatroomTools(bctx),
+    ...buildSubagentTools(bctx),
+    ...buildCanvasTools(bctx),
+    ...buildHttpTools(bctx),
+    ...buildGitTools(bctx),
   )
 
   // ---------------------------------------------------------------------------

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

@@ -60,6 +60,7 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
 
             const formatEntry = (m: any) => {
               let line = `[${m.id}] (${m.agentId ? `agent:${m.agentId}` : 'shared'}) ${m.category}/${m.title}: ${m.content}`
+              if (m.reinforcementCount) line += ` (reinforced ×${m.reinforcementCount})`
               if (m.references?.length) {
                 line += `\n  refs: ${m.references.map((r: any) => {
                   const core = r.path || r.title || r.type

package/src/lib/server/session-tools/search-providers.ts

@@ -260,16 +260,24 @@ export async function getSearchProvider(settings: Partial<AppSettings>): Promise
       return new SearXNGProvider(url)
     }
     case 'tavily': {
-      const { getSecret } = await import('../storage')
-      const secret = await getSecret('tavily')
-      if (!secret?.value) throw new Error('Tavily requires an API key. Add a secret named "tavily" in Secrets.')
-      return new TavilyProvider(secret.value)
+      let apiKey = settings.tavilyApiKey
+      if (!apiKey) {
+        const { getSecret } = await import('../storage')
+        const secret = await getSecret('tavily')
+        apiKey = secret?.value ?? null
+      }
+      if (!apiKey) throw new Error('Tavily requires an API key. Set one in Settings > Web Search.')
+      return new TavilyProvider(apiKey)
     }
     case 'brave': {
-      const { getSecret } = await import('../storage')
-      const secret = await getSecret('brave')
-      if (!secret?.value) throw new Error('Brave Search requires an API key. Add a secret named "brave" in Secrets.')
-      return new BraveProvider(secret.value)
+      let apiKey = settings.braveApiKey
+      if (!apiKey) {
+        const { getSecret } = await import('../storage')
+        const secret = await getSecret('brave')
+        apiKey = secret?.value ?? null
+      }
+      if (!apiKey) throw new Error('Brave Search requires an API key. Set one in Settings > Web Search.')
+      return new BraveProvider(apiKey)
     }
     default:
       return new DuckDuckGoProvider()

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

@@ -0,0 +1,106 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { genId } from '@/lib/id'
+import { loadAgents, loadSessions, saveSessions } from '../storage'
+import { executeSessionChatTurn } from '../chat-execution'
+import { log } from '../logger'
+import type { ToolBuildContext } from './context'
+
+const MAX_RECURSION_DEPTH = 3
+
+function getSessionDepth(sessionId: string | undefined): number {
+  if (!sessionId) return 0
+  const sessions = loadSessions()
+  let depth = 0
+  let current = sessionId
+  while (current && depth < MAX_RECURSION_DEPTH + 1) {
+    const session = sessions[current]
+    if (!session?.parentSessionId) break
+    current = session.parentSessionId
+    depth++
+  }
+  return depth
+}
+
+export function buildSubagentTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const { ctx, hasTool } = bctx
+  if (!hasTool('spawn_subagent')) return []
+
+  return [
+    tool(
+      async ({ agentId, message, cwd }) => {
+        try {
+          // Validate agent exists
+          const agents = loadAgents()
+          const agent = agents[agentId]
+          if (!agent) return `Error: Agent "${agentId}" not found. Available agents: ${Object.values(agents).map((a) => `"${a.id}" (${a.name})`).join(', ')}`
+
+          // Check recursion depth
+          const depth = getSessionDepth(ctx?.sessionId ?? undefined)
+          if (depth >= MAX_RECURSION_DEPTH) {
+            return `Error: Maximum subagent recursion depth (${MAX_RECURSION_DEPTH}) reached. Cannot spawn further subagents.`
+          }
+
+          // Create ephemeral session
+          const sessionId = genId()
+          const now = Date.now()
+          const sessions = loadSessions()
+          sessions[sessionId] = {
+            id: sessionId,
+            name: `subagent-${agent.name}-${sessionId.slice(0, 6)}`,
+            cwd: cwd || bctx.cwd,
+            user: 'agent',
+            provider: agent.provider,
+            model: agent.model,
+            credentialId: agent.credentialId || null,
+            fallbackCredentialIds: agent.fallbackCredentialIds || [],
+            apiEndpoint: agent.apiEndpoint || null,
+            claudeSessionId: null,
+            messages: [],
+            createdAt: now,
+            lastActiveAt: now,
+            sessionType: 'orchestrated',
+            agentId: agent.id,
+            parentSessionId: ctx?.sessionId || null,
+            tools: agent.tools || [],
+          }
+          saveSessions(sessions)
+
+          log.info('subagent', `Spawning subagent "${agent.name}" (depth=${depth + 1})`, {
+            parentSessionId: ctx?.sessionId,
+            childSessionId: sessionId,
+            agentId,
+          })
+
+          // Execute the chat turn
+          const result = await executeSessionChatTurn({
+            sessionId,
+            message,
+            internal: true,
+            source: 'subagent',
+          })
+
+          return JSON.stringify({
+            agentId,
+            agentName: agent.name,
+            sessionId,
+            response: result.text.slice(0, 8000),
+            toolEvents: result.toolEvents?.length || 0,
+            error: result.error || null,
+          })
+        } catch (err: unknown) {
+          return `Error spawning subagent: ${err instanceof Error ? err.message : String(err)}`
+        }
+      },
+      {
+        name: 'spawn_subagent',
+        description: `Delegate a task to another agent. The subagent runs independently and returns its response. Use this to leverage specialized agents for subtasks. Max recursion depth: ${MAX_RECURSION_DEPTH}.`,
+        schema: z.object({
+          agentId: z.string().describe('ID of the agent to delegate to'),
+          message: z.string().describe('The message/task to send to the subagent'),
+          cwd: z.string().optional().describe('Optional working directory for the subagent (defaults to current)'),
+        }),
+      },
+    ),
+  ]
+}