@swarmclawai/swarmclaw 0.5.3 → 0.6.2

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/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/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

@@ -16,6 +16,11 @@ import { buildConnectorTools } from './connector'
 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 }
@@ -97,6 +102,11 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildContextTools(bctx),
     ...buildSandboxTools(bctx),
     ...buildOpenClawNodeTools(bctx),
+    ...buildChatroomTools(bctx),
+    ...buildSubagentTools(bctx),
+    ...buildCanvasTools(bctx),
+    ...buildHttpTools(bctx),
+    ...buildGitTools(bctx),
   )
 
   // ---------------------------------------------------------------------------

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

@@ -15,7 +15,8 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
 
     tools.push(
       tool(
-        async ({ action, key, value, category, query, scope, filePaths, references, project, imagePath, linkedMemoryIds, depth, linkedLimit, targetIds, tags }) => {
+        async (input) => {
+          const { action, key, value, category, query, scope, filePaths, references, project, imagePath, linkedMemoryIds, depth, linkedLimit, targetIds, tags, pinned, sharedWith } = input as Record<string, any>
           try {
             const scopeMode = scope || 'auto'
             const currentAgentId = ctx?.agentId || null
@@ -59,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
@@ -98,6 +100,8 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
                 image: storedImage,
                 imagePath: storedImage?.path || undefined,
                 linkedMemoryIds,
+                pinned: pinned === true,
+                sharedWith: Array.isArray(sharedWith) ? sharedWith : undefined,
               })
               const memoryScope = entry.agentId ? 'agent' : 'shared'
               let result = `Stored ${memoryScope} memory "${key}" (id: ${entry.id})`
@@ -220,6 +224,8 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
             linkedLimit: z.number().optional().describe('Max linked memories expanded during traversal. Respects configured server cap.'),
             targetIds: z.array(z.string()).optional().describe('Memory IDs to link/unlink (for link/unlink actions)'),
             tags: z.array(z.string()).optional().describe('Tags for categorizing knowledge entries'),
+            pinned: z.boolean().optional().describe('Mark memory as pinned (always preloaded in agent context). For store action.'),
+            sharedWith: z.array(z.string()).optional().describe('Agent IDs to share this memory with (for store action). They can read it in their context.'),
           }),
         },
       ),

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)'),
+        }),
+      },
+    ),
+  ]
+}