@swarmclawai/swarmclaw 0.6.0 → 0.6.2

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

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

@@ -9,6 +9,58 @@ import { spawnSync } from 'child_process'
 import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
 import { getSearchProvider } from './search-providers'
 
+// ---------------------------------------------------------------------------
+// Search result compression — summarize verbose results before injecting into context
+// ---------------------------------------------------------------------------
+
+async function compressSearchResults(
+  results: Array<{ title?: string; url?: string; snippet?: string }>,
+  query: string,
+  bctx: ToolBuildContext,
+): Promise<string | null> {
+  const session = bctx.resolveCurrentSession?.()
+  if (!session?.provider || !session?.model) return null
+
+  const { getProvider } = await import('@/lib/providers')
+  const { loadCredentials, decryptKey } = await import('../storage')
+  const providerEntry = getProvider(session.provider)
+  if (!providerEntry?.handler?.streamChat) return null
+
+  // Resolve API key
+  let apiKey: string | undefined
+  if (session.credentialId) {
+    const creds = loadCredentials()
+    const cred = creds[session.credentialId]
+    if (cred) apiKey = decryptKey(cred)
+  }
+
+  const systemPrompt = 'You are a search result summarizer. Condense search results into a concise reference. Keep key facts, URLs, and data points. Remove filler and redundancy. Output plain text, not JSON.'
+  const message = `Query: "${query}"\n\nResults:\n${JSON.stringify(results, null, 1)}\n\nSummarize these results concisely.`
+
+  let compressed = ''
+  await providerEntry.handler.streamChat({
+    session: { ...session, messages: [] },
+    message,
+    apiKey,
+    systemPrompt,
+    write: (raw: string) => {
+      // Extract text data from SSE lines
+      const lines = raw.split('\n').filter(Boolean)
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue
+        try {
+          const ev = JSON.parse(line.slice(6))
+          if (ev.t === 'd' && ev.text) compressed += ev.text
+        } catch { /* skip */ }
+      }
+    },
+    active: new Map(),
+    loadHistory: () => [],
+  })
+
+  return compressed.trim() || null
+}
+
 // ---------------------------------------------------------------------------
 // Global registry of active browser instances for cleanup sweeps
 // ---------------------------------------------------------------------------
@@ -70,9 +122,18 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             const settings = loadSettings()
             const provider = await getSearchProvider(settings)
             const results = await provider.search(query, limit)
-            return results.length > 0
-              ? JSON.stringify(results, null, 2)
-              : 'No results found.'
+            if (results.length === 0) return 'No results found.'
+            const raw = JSON.stringify(results, null, 2)
+            // Compress search results if they exceed 2000 chars
+            if (raw.length > 2000) {
+              try {
+                const compressed = await compressSearchResults(results, query, bctx)
+                if (compressed) return compressed
+              } catch {
+                // Compression failed — fall through to raw results
+              }
+            }
+            return raw
           } catch (err: unknown) {
             return `Error searching web: ${err instanceof Error ? err.message : String(err)}`
           }
@@ -284,6 +345,49 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
       return JSON.stringify(result)
     }
 
+    // Best-effort cookie/consent banner dismissal after navigation
+    const dismissCookieBanners = async (
+      mcpCall: (toolName: string, args: Record<string, unknown>) => Promise<string>,
+    ) => {
+      // Wait briefly for consent overlays to appear
+      await new Promise((r) => setTimeout(r, 1500))
+      const js = `
+        (() => {
+          const sel = [
+            // Common "Reject" / "Reject all" / "Decline" buttons
+            'button[id*="reject" i]', 'button[class*="reject" i]',
+            'a[id*="reject" i]', 'a[class*="reject" i]',
+            '[data-testid*="reject" i]', '[data-action="reject"]',
+            // OneTrust
+            '#onetrust-reject-all-handler',
+            // Cookiebot
+            '#CybotCookiebotDialogBodyButtonDecline',
+            // Didomi
+            '#didomi-notice-disagree-button',
+            // Quantcast / IAB TCF
+            '.qc-cmp2-summary-buttons button:first-child',
+            'button.sp_choice_type_12',
+            // Generic patterns
+            'button[aria-label*="reject" i]', 'button[aria-label*="decline" i]',
+            'button[aria-label*="deny" i]', 'button[aria-label*="refuse" i]',
+          ];
+          for (const s of sel) {
+            const el = document.querySelector(s);
+            if (el && el.offsetParent !== null) { el.click(); return 'dismissed:' + s; }
+          }
+          // Fallback: find buttons by visible text
+          const btns = [...document.querySelectorAll('button, a[role="button"], [class*="cookie"] button, [class*="consent"] button, [id*="cookie"] button')];
+          const rejectRe = /^(reject|reject all|decline|deny|refuse|no,? thanks|only necessary|necessary only)$/i;
+          for (const b of btns) {
+            const txt = (b.textContent || '').trim();
+            if (rejectRe.test(txt) && b.offsetParent !== null) { b.click(); return 'dismissed:text=' + txt; }
+          }
+          return 'none';
+        })()
+      `
+      await mcpCall('browser_evaluate', { expression: js })
+    }
+
     // Action-to-MCP tool mapping
     const MCP_TOOL_MAP: Record<string, string> = {
       navigate: 'browser_navigate',
@@ -315,7 +419,14 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             const saveTo = typeof params.saveTo === 'string' && params.saveTo.trim()
               ? params.saveTo.trim()
               : undefined
-            return await callMcpTool(mcpTool, args, { saveTo })
+            const result = await callMcpTool(mcpTool, args, { saveTo })
+
+            // After navigation, attempt to dismiss cookie consent banners
+            if (action === 'navigate') {
+              try { await dismissCookieBanners(callMcpTool) } catch { /* best-effort */ }
+            }
+
+            return result
           } catch (err: unknown) {
             return `Error: ${err instanceof Error ? err.message : String(err)}`
           }

package/src/lib/server/stream-agent-chat.ts

@@ -9,6 +9,7 @@ import { getPluginManager } from './plugins'
 import { loadRuntimeSettings, getAgentLoopRecursionLimit } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
 import { logExecution } from './execution-log'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import type { Session, Message, UsageRecord } from '@/types'
 import { extractSuggestions } from './suggestions'
 
@@ -227,6 +228,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     stateModifierParts.push(systemPrompt!.trim())
   } else {
     if (settings.userPrompt) stateModifierParts.push(settings.userPrompt)
+    stateModifierParts.push(buildCurrentDateTimePromptContext())
   }
 
   // Load agent context when a full prompt was not already composed by the route layer.
@@ -400,15 +402,17 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     }
   }
 
-  stateModifierParts.push(
-    [
-      '## Follow-up Suggestions',
-      'At the end of every response, include a <suggestions> block with exactly 3 short',
-      'follow-up prompts the user might want to send next, as a JSON array. Keep each under 60 chars.',
-      'Make them contextual to what you just said. Example:',
-      '<suggestions>["Set up a Discord connector", "Create a research agent", "Show the task board"]</suggestions>',
-    ].join('\n'),
-  )
+  if (settings.suggestionsEnabled !== false) {
+    stateModifierParts.push(
+      [
+        '## Follow-up Suggestions',
+        'At the end of every response, include a <suggestions> block with exactly 3 short',
+        'follow-up prompts the user might want to send next, as a JSON array. Keep each under 60 chars.',
+        'Make them contextual to what you just said. Example:',
+        '<suggestions>["Set up a Discord connector", "Create a research agent", "Show the task board"]</suggestions>',
+      ].join('\n'),
+    )
+  }
 
   stateModifierParts.push(
     buildAgenticExecutionPolicy({
@@ -548,8 +552,18 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     // Context manager failure — continue with full history
   }
 
+  // Apply context-clear boundary: slice from most recent context-clear marker
+  let contextStart = 0
+  for (let i = effectiveHistory.length - 1; i >= 0; i--) {
+    if (effectiveHistory[i].kind === 'context-clear') {
+      contextStart = i + 1
+      break
+    }
+  }
+  const postClearHistory = effectiveHistory.slice(contextStart)
+
   const langchainMessages: Array<HumanMessage | AIMessage> = []
-  for (const m of effectiveHistory.slice(-20)) {
+  for (const m of postClearHistory.slice(-20)) {
     if (m.role === 'user') {
       langchainMessages.push(new HumanMessage({ content: await buildLangChainContent(m.text, m.imagePath, m.attachedFiles) }))
     } else {
@@ -567,6 +581,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   let totalInputTokens = 0
   let totalOutputTokens = 0
   let lastToolInput: unknown = null
+  let accumulatedThinking = ''
 
   // Plugin hooks: beforeAgentStart
   const pluginMgr = getPluginManager()
@@ -603,9 +618,11 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
             for (const block of chunk.content) {
               // Anthropic extended thinking blocks
               if (block.type === 'thinking' && block.thinking) {
+                accumulatedThinking += block.thinking
                 write(`data: ${JSON.stringify({ t: 'thinking', text: block.thinking })}\n\n`)
               // OpenClaw [[thinking]] prefix convention
               } else if (typeof block.text === 'string' && block.text.startsWith('[[thinking]]')) {
+                accumulatedThinking += block.text.slice(12)
                 write(`data: ${JSON.stringify({ t: 'thinking', text: block.text.slice(12) })}\n\n`)
               } else if (block.text) {
                 fullText += block.text
@@ -730,6 +747,11 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify({ suggestions: extracted.suggestions }) })}\n\n`)
   }
 
+  // Emit full thinking text as metadata so the client can persist it
+  if (accumulatedThinking) {
+    write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify({ thinking: accumulatedThinking }) })}\n\n`)
+  }
+
   // Track cost
   const totalTokens = totalInputTokens + totalOutputTokens
   if (totalTokens > 0) {

package/src/lib/server/task-mention.ts

@@ -0,0 +1,41 @@
+import type { Agent } from '@/types'
+
+/**
+ * Parse @AgentName mentions from text and resolve to an agent ID.
+ * Uses case-insensitive exact match, then falls back to starts-with.
+ */
+export function parseMentionedAgentId(
+  description: string,
+  agents: Record<string, Agent>,
+): string | null {
+  const mentionRegex = /@(\S+)/g
+  const agentList = Object.values(agents)
+  let match: RegExpExecArray | null
+
+  while ((match = mentionRegex.exec(description)) !== null) {
+    const mention = match[1].toLowerCase()
+
+    // Exact name match (case-insensitive)
+    const exact = agentList.find((a) => a.name.toLowerCase() === mention)
+    if (exact) return exact.id
+
+    // Starts-with match (for partial names like @code matching "CodeBot")
+    const startsWith = agentList.find((a) => a.name.toLowerCase().startsWith(mention))
+    if (startsWith) return startsWith.id
+  }
+
+  return null
+}
+
+/**
+ * Resolve task agent: if description has an @mention, use that agent.
+ * Otherwise fall back to currentAgentId.
+ */
+export function resolveTaskAgentFromDescription(
+  description: string,
+  currentAgentId: string,
+  agents: Record<string, Agent>,
+): string {
+  const mentioned = parseMentionedAgentId(description, agents)
+  return mentioned || currentAgentId
+}

package/src/lib/sessions.ts

@@ -34,6 +34,16 @@ export const deleteSession = (id: string) =>
 export const fetchMessages = (id: string) =>
   api<Message[]>('GET', `/sessions/${id}/messages`)
 
+export interface PaginatedMessages {
+  messages: Message[]
+  total: number
+  hasMore: boolean
+  startIndex: number
+}
+
+export const fetchMessagesPaginated = (id: string, limit: number = 100) =>
+  api<PaginatedMessages>('GET', `/sessions/${id}/messages?limit=${limit}`)
+
 export const clearMessages = (id: string) =>
   api<string>('POST', `/sessions/${id}/clear`)