@swarmclawai/swarmclaw 0.7.2 → 0.7.3

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

@@ -60,8 +60,6 @@ function isAutonomousSystemTurn(userText: string): boolean {
   if (!userText) return false
   const text = userText.toUpperCase()
   return text.includes('AGENT_HEARTBEAT_WAKE')
-    || text.includes('SWARM_MAIN_MISSION_TICK')
-    || text.includes('SWARM_MAIN_AUTO_FOLLOWUP')
     || text.includes('SWARM_HEARTBEAT_CHECK')
 }
 
@@ -247,6 +245,9 @@ interface ConnectorActionInput {
   platform?: string
   to?: string
   message?: string
+  messageId?: string
+  targetMessage?: 'last_inbound' | 'last_outbound'
+  emoji?: string
   voiceText?: string
   voiceId?: string
   imageUrl?: string
@@ -255,9 +256,12 @@ interface ConnectorActionInput {
   mimeType?: string
   fileName?: string
   caption?: string
+  replyToMessageId?: string
+  threadId?: string
   delaySec?: number
   followUpMessage?: string
   followUpDelaySec?: number
+  dedupeKey?: string
   approved?: boolean
   ptt?: boolean
 }
@@ -284,13 +288,25 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
     mimeType,
     fileName,
     caption,
+    messageId,
+    targetMessage,
+    emoji,
+    replyToMessageId,
+    threadId,
+    dedupeKey,
     approved,
     ptt,
   } = normalized as ConnectorActionInput
 
   try {
     const actionName = String(action)
-    const { listRunningConnectors, sendConnectorMessage, getConnectorRecentChannelId } = await import('../connectors/manager')
+    const {
+      listRunningConnectors,
+      sendConnectorMessage,
+      getConnectorRecentChannelId,
+      scheduleConnectorFollowUp,
+      performConnectorMessageAction,
+    } = await import('../connectors/manager')
     const running = listRunningConnectors(platform || undefined)
 
     if (actionName === 'list_running' || actionName === 'list_targets') {
@@ -342,6 +358,9 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       return { selected, connector }
     }
 
+    const currentSession = bctx.resolveCurrentSession?.()
+    const sessionId = bctx.ctx?.sessionId || currentSession?.id || undefined
+
     if (actionName === 'send' || actionName === 'send_voice_note' || actionName === 'schedule_followup') {
       const settings = loadSettings()
       if (settings.safetyRequireApprovalForOutbound === true && approved !== true) {
@@ -363,9 +382,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       let channelId = target.channelId
       if (connector.platform === 'whatsapp') channelId = normalizeWhatsAppTarget(channelId)
 
-      const currentSession = bctx.resolveCurrentSession?.()
       const latestUserTurn = parseLatestUserTurn(currentSession)
-      const sessionId = bctx.ctx?.sessionId || currentSession?.id || 'unknown-session'
       const turnKey = buildConnectorActionKey([sessionId, latestUserTurn.time || 'no-user-turn'])
       const multiOutboundAllowed = userExplicitlyWantsMultipleOutbound(latestUserTurn.text)
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -392,6 +409,9 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         const sent = await sendConnectorMessage({
           connectorId: selected.id, channelId, text: '', mediaPath: voicePath, mimeType: 'audio/mpeg',
           fileName: fileName?.trim() || 'voicenote.mp3', caption: caption?.trim() || undefined, ptt: ptt ?? true,
+          sessionId,
+          replyToMessageId: replyToMessageId?.trim() || undefined,
+          threadId: threadId?.trim() || undefined,
         })
         const result = JSON.stringify({ status: 'voice_sent', connectorId: sent.connectorId, platform: sent.platform, to: sent.channelId, voiceFile: voicePath })
         connectorTurnSendBudget.set(turnKey, { count: (existingBudget?.count || 0) + 1, at: now, lastResult: result })
@@ -405,11 +425,54 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         return 'Error: message or media required.'
       }
 
+      if (actionName === 'schedule_followup') {
+        const followupText = (normalized.followUpMessage as string | undefined)?.trim() || message?.trim() || ''
+        if (!followupText && !media.mediaPath && !media.imageUrl && !media.fileUrl) {
+          return 'Error: follow-up message or media required.'
+        }
+        const followupDelay = (() => {
+          const direct = Number(normalized.followUpDelaySec)
+          if (Number.isFinite(direct) && direct >= 0) return direct
+          const fallback = Number(normalized.delaySec)
+          if (Number.isFinite(fallback) && fallback >= 0) return fallback
+          return 300
+        })()
+        const scheduled = scheduleConnectorFollowUp({
+          connectorId: selected.id,
+          channelId,
+          text: followupText,
+          sessionId,
+          delaySec: followupDelay,
+          dedupeKey: dedupeKey?.trim() || undefined,
+          imageUrl: media.imageUrl,
+          fileUrl: media.fileUrl,
+          mediaPath: media.mediaPath,
+          mimeType: mimeType?.trim() || undefined,
+          fileName: fileName?.trim() || undefined,
+          caption: caption?.trim() || undefined,
+          replyToMessageId: replyToMessageId?.trim() || undefined,
+          threadId: threadId?.trim() || undefined,
+          ptt: ptt ?? undefined,
+        })
+        return JSON.stringify({
+          status: 'scheduled',
+          connectorId: selected.id,
+          platform: selected.platform,
+          to: channelId,
+          followUpId: scheduled.followUpId,
+          sendAt: scheduled.sendAt,
+        })
+      }
+
       const sent = await sendConnectorMessage({
         connectorId: selected.id, channelId, text: message?.trim() || '',
+        sessionId,
         imageUrl: media.imageUrl, fileUrl: media.fileUrl, mediaPath: media.mediaPath,
         mimeType: mimeType?.trim() || undefined, fileName: fileName?.trim() || undefined,
-        caption: caption?.trim() || undefined, ptt: ptt ?? undefined,
+        caption: caption?.trim() || undefined,
+        replyToMessageId: replyToMessageId?.trim() || undefined,
+        threadId: threadId?.trim() || undefined,
+        ptt: ptt ?? undefined,
       })
 
       const result = JSON.stringify({ status: 'sent', connectorId: sent.connectorId, platform: sent.platform, to: sent.channelId, messageId: sent.messageId || null })
@@ -417,6 +480,35 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       return result
     }
 
+    if (actionName === 'react' || actionName === 'edit' || actionName === 'delete' || actionName === 'pin') {
+      const resolved = resolveSelectedConnector()
+      if ('error' in resolved) return resolved.error
+      const { selected } = resolved
+      const target = pickChannelTarget({
+        connector: resolved.connector,
+        to,
+        recentChannelId: getConnectorRecentChannelId(selected.id),
+      })
+      if (target.error) return target.error
+      const result = await performConnectorMessageAction({
+        connectorId: selected.id,
+        channelId: selected.platform === 'whatsapp' ? normalizeWhatsAppTarget(target.channelId) : target.channelId,
+        action: actionName,
+        messageId: messageId?.trim() || undefined,
+        emoji: emoji?.trim() || undefined,
+        text: message?.trim() || undefined,
+        sessionId,
+        targetMessage,
+      })
+      return JSON.stringify({
+        status: actionName,
+        connectorId: result.connectorId,
+        platform: result.platform,
+        to: result.channelId,
+        messageId: result.messageId || null,
+      })
+    }
+
     return 'Unknown action.'
   } catch (err: unknown) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`
@@ -440,11 +532,20 @@ const ConnectorPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list_running', 'start', 'stop', 'send', 'send_voice_note'] },
+          action: { type: 'string', enum: ['list_running', 'start', 'stop', 'send', 'send_voice_note', 'schedule_followup', 'react', 'edit', 'delete', 'pin'] },
           connectorId: { type: 'string' },
           platform: { type: 'string' },
           to: { type: 'string' },
-          message: { type: 'string' }
+          message: { type: 'string' },
+          messageId: { type: 'string' },
+          targetMessage: { type: 'string', enum: ['last_inbound', 'last_outbound'] },
+          emoji: { type: 'string' },
+          replyToMessageId: { type: 'string' },
+          threadId: { type: 'string' },
+          delaySec: { type: 'number' },
+          followUpMessage: { type: 'string' },
+          followUpDelaySec: { type: 'number' },
+          dedupeKey: { type: 'string' },
         },
         required: ['action']
       },

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

@@ -34,9 +34,21 @@ export interface ToolBuildContext {
   activePlugins: string[]
 }
 
+function normalizeWorkspaceAlias(cwd: string, filePath: string): string {
+  const trimmed = filePath.trim()
+  if (!trimmed) return trimmed
+  if (trimmed === '/workspace' || trimmed === 'workspace') return cwd
+  if (trimmed.startsWith('/workspace/')) return trimmed.slice('/workspace/'.length)
+  if (trimmed.startsWith('workspace/')) return trimmed.slice('workspace/'.length)
+  return trimmed
+}
+
 export function safePath(cwd: string, filePath: string): string {
-  const resolved = require('path').resolve(cwd, filePath)
-  if (!resolved.startsWith(require('path').resolve(cwd))) {
+  const path = require('path')
+  const normalized = normalizeWorkspaceAlias(cwd, filePath)
+  const resolvedRoot = path.resolve(cwd)
+  const resolved = path.resolve(resolvedRoot, normalized)
+  if (!resolved.startsWith(resolvedRoot)) {
     throw new Error('Path traversal not allowed')
   }
   return resolved

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

@@ -0,0 +1,447 @@
+import crypto from 'crypto'
+import { URL } from 'url'
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import * as cheerio from 'cheerio'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { runStructuredExtraction } from '../structured-extract'
+import type { ToolBuildContext } from './context'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+
+interface CrawledPage {
+  url: string
+  status: number
+  title: string | null
+  depth: number
+  textPreview: string
+  headings: string[]
+  links: string[]
+  hash: string
+}
+
+function cleanText(value: string, max = 1200): string {
+  const normalized = value.replace(/\s+/g, ' ').trim()
+  return normalized.length <= max ? normalized : `${normalized.slice(0, max)}...`
+}
+
+function normalizeUrl(input: string, base?: string): string {
+  const resolved = base ? new URL(input, base) : new URL(input)
+  resolved.hash = ''
+  if (resolved.pathname.endsWith('/') && resolved.pathname !== '/') {
+    resolved.pathname = resolved.pathname.replace(/\/+$/, '')
+  }
+  return resolved.toString()
+}
+
+function shouldIncludeUrl(url: string, params: { includePattern?: string | null; excludePattern?: string | null }) {
+  if (params.includePattern) {
+    try {
+      if (!new RegExp(params.includePattern, 'i').test(url)) return false
+    } catch {
+      return false
+    }
+  }
+  if (params.excludePattern) {
+    try {
+      if (new RegExp(params.excludePattern, 'i').test(url)) return false
+    } catch {
+      return false
+    }
+  }
+  return true
+}
+
+function pageHash(text: string): string {
+  return crypto.createHash('sha1').update(text).digest('hex')
+}
+
+async function fetchCrawlPage(url: string, depth: number): Promise<CrawledPage> {
+  const res = await fetch(url, {
+    headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
+    signal: AbortSignal.timeout(15_000),
+  })
+  const html = await res.text()
+  const $ = cheerio.load(html)
+  $('script, style, noscript').remove()
+
+  const title = cleanText($('title').first().text(), 200) || null
+  const headings = $('h1, h2, h3')
+    .toArray()
+    .map((node) => cleanText($(node).text(), 200))
+    .filter(Boolean)
+    .slice(0, 12)
+  const textPreview = cleanText($('body').text() || $.text(), 1600)
+  const links = $('a[href]')
+    .toArray()
+    .map((node) => $(node).attr('href') || '')
+    .filter(Boolean)
+    .map((href) => {
+      try {
+        return normalizeUrl(href, url)
+      } catch {
+        return null
+      }
+    })
+    .filter((href): href is string => !!href)
+    .slice(0, 200)
+
+  return {
+    url,
+    status: res.status,
+    title,
+    depth,
+    textPreview,
+    headings,
+    links: Array.from(new Set(links)),
+    hash: pageHash(`${title || ''}\n${textPreview}`),
+  }
+}
+
+async function crawlSite(params: {
+  startUrl: string
+  limit: number
+  maxDepth: number
+  sameOrigin: boolean
+  includePattern?: string | null
+  excludePattern?: string | null
+}): Promise<CrawledPage[]> {
+  const startUrl = normalizeUrl(params.startUrl)
+  const startOrigin = new URL(startUrl).origin
+  const queue: Array<{ url: string; depth: number }> = [{ url: startUrl, depth: 0 }]
+  const visited = new Set<string>()
+  const pages: CrawledPage[] = []
+
+  while (queue.length > 0 && pages.length < params.limit) {
+    const current = queue.shift()!
+    if (visited.has(current.url)) continue
+    visited.add(current.url)
+    if (!shouldIncludeUrl(current.url, params)) continue
+    if (params.sameOrigin && new URL(current.url).origin !== startOrigin) continue
+
+    try {
+      const page = await fetchCrawlPage(current.url, current.depth)
+      pages.push(page)
+      if (current.depth >= params.maxDepth) continue
+      for (const link of page.links) {
+        if (visited.has(link)) continue
+        if (params.sameOrigin && new URL(link).origin !== startOrigin) continue
+        queue.push({ url: link, depth: current.depth + 1 })
+      }
+    } catch {
+      // skip failed pages and continue crawling
+    }
+  }
+
+  return pages
+}
+
+async function followPagination(params: {
+  startUrl: string
+  limit: number
+}): Promise<CrawledPage[]> {
+  const pages: CrawledPage[] = []
+  const visited = new Set<string>()
+  let currentUrl = normalizeUrl(params.startUrl)
+  let depth = 0
+
+  while (currentUrl && pages.length < params.limit && !visited.has(currentUrl)) {
+    visited.add(currentUrl)
+    const page = await fetchCrawlPage(currentUrl, depth)
+    pages.push(page)
+
+    const res = await fetch(currentUrl, {
+      headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
+      signal: AbortSignal.timeout(15_000),
+    })
+    const html = await res.text()
+    const $ = cheerio.load(html)
+    const nextHref = $('link[rel="next"]').attr('href')
+      || $('a[rel="next"]').attr('href')
+      || $('a').toArray().map((node) => ({
+        href: $(node).attr('href') || '',
+        text: cleanText($(node).text(), 80).toLowerCase(),
+      })).find((candidate) => /^(next|next page|older|more|continue)/i.test(candidate.text))?.href
+
+    if (!nextHref) break
+    try {
+      currentUrl = normalizeUrl(nextHref, currentUrl)
+    } catch {
+      break
+    }
+    depth += 1
+  }
+
+  return pages
+}
+
+function dedupePages(input: CrawledPage[]): CrawledPage[] {
+  const seen = new Set<string>()
+  const out: CrawledPage[] = []
+  for (const page of input) {
+    const key = `${page.url}|${page.hash}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(page)
+  }
+  return out
+}
+
+async function fetchSitemapUrls(sitemapUrl: string): Promise<string[]> {
+  const res = await fetch(sitemapUrl, {
+    headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
+    signal: AbortSignal.timeout(15_000),
+  })
+  const xml = await res.text()
+  const matches = Array.from(xml.matchAll(/<loc>\s*([^<]+)\s*<\/loc>/gi))
+  return Array.from(new Set(matches.map((match) => match[1]?.trim()).filter((value): value is string => !!value)))
+}
+
+function normalizeSelectorMap(value: unknown): Record<string, string> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  const entries: Array<readonly [string, string]> = []
+  for (const [key, selector] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof selector !== 'string') continue
+    const trimmed = selector.trim()
+    if (!trimmed) continue
+    entries.push([key, trimmed] as const)
+  }
+  return Object.fromEntries(entries)
+}
+
+async function extractSelectorRows(urls: string[], selectors: Record<string, string>) {
+  const rows: Array<Record<string, unknown>> = []
+  for (const url of urls) {
+    const res = await fetch(url, {
+      headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
+      signal: AbortSignal.timeout(15_000),
+    })
+    const html = await res.text()
+    const $ = cheerio.load(html)
+    $('script, style, noscript').remove()
+    const row: Record<string, unknown> = { url }
+    for (const [key, selector] of Object.entries(selectors)) {
+      row[key] = cleanText($(selector).first().text(), 800)
+    }
+    rows.push(row)
+  }
+  return rows
+}
+
+function normalizePagesInput(value: unknown): CrawledPage[] {
+  if (typeof value === 'string' && value.trim()) {
+    try {
+      return JSON.parse(value) as CrawledPage[]
+    } catch {
+      return []
+    }
+  }
+  if (Array.isArray(value)) return value as CrawledPage[]
+  return []
+}
+
+function resolveExtractionSession(bctx: ToolBuildContext) {
+  const session = bctx.resolveCurrentSession?.()
+  if (!session) throw new Error('crawl batch_extract requires an active session context.')
+  return session
+}
+
+async function executeCrawlAction(args: Record<string, unknown>, bctx: ToolBuildContext) {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'crawl_site').trim().toLowerCase()
+
+  try {
+    if (action === 'status') {
+      return JSON.stringify({
+        supports: ['crawl_site', 'follow_pagination', 'extract_sitemap', 'dedupe_pages', 'batch_extract'],
+      })
+    }
+
+    if (action === 'dedupe_pages') {
+      const pages = dedupePages(normalizePagesInput(normalized.pages))
+      return JSON.stringify({ count: pages.length, pages })
+    }
+
+    const startUrl = typeof normalized.url === 'string'
+      ? normalized.url
+      : typeof normalized.startUrl === 'string'
+        ? normalized.startUrl
+        : ''
+
+    const limit = typeof normalized.limit === 'number' ? Math.max(1, Math.min(normalized.limit, 100)) : 20
+    const maxDepth = typeof normalized.maxDepth === 'number' ? Math.max(0, Math.min(normalized.maxDepth, 5)) : 2
+    const sameOrigin = normalized.sameOrigin !== false
+
+    if (action === 'crawl_site' || action === 'extract_sitemap') {
+      const sitemapUrl = typeof normalized.sitemapUrl === 'string' && normalized.sitemapUrl.trim()
+        ? normalized.sitemapUrl.trim()
+        : null
+      const pages = action === 'extract_sitemap' && sitemapUrl
+        ? dedupePages(await Promise.all(
+            (await fetchSitemapUrls(sitemapUrl))
+              .slice(0, limit)
+              .map((url) => fetchCrawlPage(normalizeUrl(url), 0)),
+          ))
+        : dedupePages(await crawlSite({
+            startUrl,
+            limit,
+            maxDepth,
+            sameOrigin,
+            includePattern: typeof normalized.includePattern === 'string' ? normalized.includePattern : null,
+            excludePattern: typeof normalized.excludePattern === 'string' ? normalized.excludePattern : null,
+          }))
+      if (action === 'extract_sitemap') {
+        return JSON.stringify({
+          startUrl: normalizeUrl(startUrl),
+          count: pages.length,
+          urlCount: pages.length,
+          urls: pages.map((page) => page.url),
+        })
+      }
+      return JSON.stringify({
+        startUrl: normalizeUrl(startUrl),
+        count: pages.length,
+        pageCount: pages.length,
+        pages,
+      })
+    }
+
+    if (action === 'follow_pagination') {
+      const pages = dedupePages(await followPagination({ startUrl, limit }))
+      return JSON.stringify({
+        startUrl: normalizeUrl(startUrl),
+        count: pages.length,
+        pageCount: pages.length,
+        pages,
+      })
+    }
+
+    if (action === 'batch_extract') {
+      const seededPages = normalizePagesInput(normalized.pages)
+      if (seededPages.length === 0 && !startUrl) return 'Error: url/startUrl or pages is required.'
+      const pages = seededPages.length > 0
+        ? dedupePages(seededPages)
+        : dedupePages(await crawlSite({
+            startUrl,
+            limit,
+            maxDepth,
+            sameOrigin,
+            includePattern: typeof normalized.includePattern === 'string' ? normalized.includePattern : null,
+            excludePattern: typeof normalized.excludePattern === 'string' ? normalized.excludePattern : null,
+          }))
+      const selectors = normalizeSelectorMap(normalized.selectors)
+      if (Object.keys(selectors).length > 0) {
+        const rows = await extractSelectorRows(pages.map((page) => page.url), selectors)
+        return JSON.stringify({
+          count: pages.length,
+          pageCount: pages.length,
+          rowCount: rows.length,
+          urls: pages.map((page) => page.url),
+          rows,
+        })
+      }
+      const session = resolveExtractionSession(bctx)
+      const sourceText = pages
+        .map((page) => `URL: ${page.url}\nTitle: ${page.title || ''}\nHeadings: ${page.headings.join(' | ')}\nText: ${page.textPreview}`)
+        .join('\n\n---\n\n')
+      const extracted = await runStructuredExtraction({
+        session,
+        text: sourceText,
+        schema: normalized.schema,
+        instruction: typeof normalized.instruction === 'string'
+          ? normalized.instruction
+          : 'Aggregate the crawled pages and extract the requested structured information.',
+        maxChars: typeof normalized.maxChars === 'number' ? Math.max(10_000, normalized.maxChars) : 120_000,
+      })
+      return JSON.stringify({
+        count: pages.length,
+        pageCount: pages.length,
+        urls: pages.map((page) => page.url),
+        object: extracted.object,
+        validationErrors: extracted.validationErrors,
+        provider: extracted.provider,
+        model: extracted.model,
+        raw: normalized.includeRaw === true ? extracted.raw : undefined,
+      })
+    }
+
+    if (!startUrl) return 'Error: url or startUrl is required.'
+
+    return `Error: Unknown action "${action}".`
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const CrawlPlugin: Plugin = {
+  name: 'Crawl',
+  enabledByDefault: false,
+  description: 'Research whole sites by crawling pages, following pagination, deduping results, and batch-extracting structure.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can crawl websites with `crawl`, including sitemap extraction, pagination following, page deduping, and batch structured extraction over many pages.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'crawl',
+      description: 'Site crawler. Actions: crawl_site, follow_pagination, extract_sitemap, dedupe_pages, batch_extract, status.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['crawl_site', 'follow_pagination', 'extract_sitemap', 'dedupe_pages', 'batch_extract', 'status'],
+          },
+          url: { type: 'string' },
+          startUrl: { type: 'string' },
+          sitemapUrl: { type: 'string' },
+          pages: {},
+          limit: { type: 'number' },
+          maxDepth: { type: 'number' },
+          sameOrigin: { type: 'boolean' },
+          includePattern: { type: 'string' },
+          excludePattern: { type: 'string' },
+          selectors: {},
+          schema: {},
+          instruction: { type: 'string' },
+          maxChars: { type: 'number' },
+          includeRaw: { type: 'boolean' },
+        },
+        required: ['action'],
+      },
+      execute: async (args, context) => {
+        const syntheticBuildContext = {
+          cwd: context.session.cwd || process.cwd(),
+          ctx: { sessionId: context.session.id, agentId: context.session.agentId || null },
+          hasPlugin: () => true,
+          hasTool: () => true,
+          cleanupFns: [],
+          commandTimeoutMs: 0,
+          claudeTimeoutMs: 0,
+          cliProcessTimeoutMs: 0,
+          persistDelegateResumeId: () => undefined,
+          readStoredDelegateResumeId: () => null,
+          resolveCurrentSession: () => context.session,
+          activePlugins: context.session.plugins || [],
+        } as ToolBuildContext
+        return executeCrawlAction(args, syntheticBuildContext)
+      },
+    },
+  ],
+}
+
+getPluginManager().registerBuiltin('crawl', CrawlPlugin)
+
+export function buildCrawlTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('crawl')) return []
+  return [
+    tool(
+      async (args) => executeCrawlAction(args, bctx),
+      {
+        name: 'crawl',
+        description: CrawlPlugin.tools![0].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+  ]
+}