@swarmclawai/swarmclaw 0.4.0 → 0.4.5

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

@@ -160,5 +160,38 @@ export function buildSandboxTools(bctx: ToolBuildContext): StructuredToolInterfa
     ),
   )
 
+  // ---- openclaw_sandbox (CLI passthrough) -----------------------------------
+
+  const openclawSandboxPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
+  if (openclawSandboxPath) {
+    tools.push(
+      tool(
+        async ({ code, explain }) => {
+          try {
+            const args = explain ? ['sandbox', 'explain', code] : ['sandbox', 'run', code]
+            const result = spawnSync(openclawSandboxPath, args, {
+              encoding: 'utf-8',
+              timeout: 60_000,
+              maxBuffer: MAX_OUTPUT,
+            })
+            const stdout = truncate((result.stdout || '').trim(), MAX_OUTPUT)
+            const stderr = truncate((result.stderr || '').trim(), MAX_OUTPUT)
+            return JSON.stringify({ exitCode: result.status ?? 0, stdout, stderr })
+          } catch (err: any) {
+            return JSON.stringify({ error: err.message })
+          }
+        },
+        {
+          name: 'openclaw_sandbox',
+          description: 'Execute or explain code through the OpenClaw CLI sandbox. CLI passthrough to `openclaw sandbox run|explain <code>`. Requires openclaw/clawdbot CLI on PATH.',
+          schema: z.object({
+            code: z.string().describe('Code to run or explain'),
+            explain: z.boolean().optional().describe('If true, explain the code instead of running it'),
+          }),
+        },
+      ),
+    )
+  }
+
   return tools
 }

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

@@ -0,0 +1,270 @@
+import * as cheerio from 'cheerio'
+import type { AppSettings } from '@/types'
+
+export interface SearchResult {
+  title: string
+  url: string
+  snippet: string
+}
+
+export interface WebSearchProvider {
+  id: string
+  name: string
+  search(query: string, maxResults: number): Promise<SearchResult[]>
+}
+
+const UA = 'Mozilla/5.0 (compatible; SwarmClaw/1.0)'
+
+// ---------------------------------------------------------------------------
+// DuckDuckGo
+// ---------------------------------------------------------------------------
+
+function decodeDuckDuckGoUrl(rawUrl: string): string {
+  if (!rawUrl) return rawUrl
+  try {
+    const url = rawUrl.startsWith('http')
+      ? new URL(rawUrl)
+      : new URL(rawUrl, 'https://duckduckgo.com')
+    const uddg = url.searchParams.get('uddg')
+    if (uddg) return decodeURIComponent(uddg)
+    return url.toString()
+  } catch {
+    const fromQuery = rawUrl.match(/[?&]uddg=([^&]+)/)?.[1]
+    if (fromQuery) {
+      try { return decodeURIComponent(fromQuery) } catch { /* noop */ }
+    }
+    return rawUrl
+  }
+}
+
+class DuckDuckGoProvider implements WebSearchProvider {
+  id = 'duckduckgo'
+  name = 'DuckDuckGo'
+
+  async search(query: string, maxResults: number): Promise<SearchResult[]> {
+    const url = `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}`
+    const res = await fetch(url, {
+      headers: { 'User-Agent': UA },
+      signal: AbortSignal.timeout(15000),
+    })
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`)
+    const html = await res.text()
+    const $ = cheerio.load(html)
+    const results: SearchResult[] = []
+
+    $('.result').each((_i, el) => {
+      if (results.length >= maxResults) return false
+      const link = $(el).find('a.result__a').first()
+      const rawHref = link.attr('href') || ''
+      const title = link.text().replace(/\s+/g, ' ').trim()
+      if (!rawHref || !title) return
+      const snippet = $(el).find('.result__snippet').first().text().replace(/\s+/g, ' ').trim()
+      results.push({ title, url: decodeDuckDuckGoUrl(rawHref), snippet })
+    })
+
+    if (results.length === 0) {
+      $('a.result__a').each((_i, el) => {
+        if (results.length >= maxResults) return false
+        const rawHref = $(el).attr('href') || ''
+        const title = $(el).text().replace(/\s+/g, ' ').trim()
+        if (!rawHref || !title) return
+        results.push({ title, url: decodeDuckDuckGoUrl(rawHref), snippet: '' })
+      })
+    }
+
+    return results
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Google (scraping)
+// ---------------------------------------------------------------------------
+
+class GoogleProvider implements WebSearchProvider {
+  id = 'google'
+  name = 'Google'
+
+  async search(query: string, maxResults: number): Promise<SearchResult[]> {
+    const url = `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${maxResults}`
+    const res = await fetch(url, {
+      headers: { 'User-Agent': UA, 'Accept-Language': 'en-US,en;q=0.9' },
+      signal: AbortSignal.timeout(15000),
+    })
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`)
+    const html = await res.text()
+    const $ = cheerio.load(html)
+    const results: SearchResult[] = []
+
+    $('div.g').each((_i, el) => {
+      if (results.length >= maxResults) return false
+      const anchor = $(el).find('a').first()
+      const href = anchor.attr('href') || ''
+      if (!href || href.startsWith('/search')) return
+      const title = $(el).find('h3').first().text().replace(/\s+/g, ' ').trim()
+      if (!title) return
+      // Snippet is in various containers depending on Google's layout
+      const snippet = $(el).find('[data-sncf], .VwiC3b, .st').first().text().replace(/\s+/g, ' ').trim()
+      results.push({ title, url: href, snippet })
+    })
+
+    return results
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Bing (scraping)
+// ---------------------------------------------------------------------------
+
+class BingProvider implements WebSearchProvider {
+  id = 'bing'
+  name = 'Bing'
+
+  async search(query: string, maxResults: number): Promise<SearchResult[]> {
+    const url = `https://www.bing.com/search?q=${encodeURIComponent(query)}&count=${maxResults}`
+    const res = await fetch(url, {
+      headers: { 'User-Agent': UA },
+      signal: AbortSignal.timeout(15000),
+    })
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`)
+    const html = await res.text()
+    const $ = cheerio.load(html)
+    const results: SearchResult[] = []
+
+    $('li.b_algo').each((_i, el) => {
+      if (results.length >= maxResults) return false
+      const anchor = $(el).find('h2 a').first()
+      const href = anchor.attr('href') || ''
+      const title = anchor.text().replace(/\s+/g, ' ').trim()
+      if (!href || !title) return
+      const snippet = $(el).find('.b_caption p').first().text().replace(/\s+/g, ' ').trim()
+      results.push({ title, url: href, snippet })
+    })
+
+    return results
+  }
+}
+
+// ---------------------------------------------------------------------------
+// SearXNG (JSON API)
+// ---------------------------------------------------------------------------
+
+class SearXNGProvider implements WebSearchProvider {
+  id = 'searxng'
+  name = 'SearXNG'
+
+  constructor(private baseUrl: string) {}
+
+  async search(query: string, maxResults: number): Promise<SearchResult[]> {
+    const url = `${this.baseUrl.replace(/\/+$/, '')}/search?q=${encodeURIComponent(query)}&format=json`
+    const res = await fetch(url, {
+      headers: { 'User-Agent': UA },
+      signal: AbortSignal.timeout(15000),
+    })
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`)
+    const data = await res.json()
+    const rawResults = Array.isArray(data.results) ? data.results : []
+    return rawResults.slice(0, maxResults).map((r: any) => ({
+      title: r.title || '',
+      url: r.url || '',
+      snippet: r.content || '',
+    }))
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tavily (API key required — from secrets)
+// ---------------------------------------------------------------------------
+
+class TavilyProvider implements WebSearchProvider {
+  id = 'tavily'
+  name = 'Tavily'
+
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number): Promise<SearchResult[]> {
+    const res = await fetch('https://api.tavily.com/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        api_key: this.apiKey,
+        query,
+        max_results: maxResults,
+      }),
+      signal: AbortSignal.timeout(15000),
+    })
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`)
+    const data = await res.json()
+    const rawResults = Array.isArray(data.results) ? data.results : []
+    return rawResults.slice(0, maxResults).map((r: any) => ({
+      title: r.title || '',
+      url: r.url || '',
+      snippet: r.content || '',
+    }))
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Brave Search (API key required — from secrets)
+// ---------------------------------------------------------------------------
+
+class BraveProvider implements WebSearchProvider {
+  id = 'brave'
+  name = 'Brave Search'
+
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number): Promise<SearchResult[]> {
+    const res = await fetch(
+      `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}`,
+      {
+        headers: {
+          'Accept': 'application/json',
+          'Accept-Encoding': 'gzip',
+          'X-Subscription-Token': this.apiKey,
+        },
+        signal: AbortSignal.timeout(15000),
+      },
+    )
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`)
+    const data = await res.json()
+    const rawResults = Array.isArray(data.web?.results) ? data.web.results : []
+    return rawResults.slice(0, maxResults).map((r: any) => ({
+      title: r.title || '',
+      url: r.url || '',
+      snippet: r.description || '',
+    }))
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export async function getSearchProvider(settings: Partial<AppSettings>): Promise<WebSearchProvider> {
+  const providerId = settings.webSearchProvider || 'duckduckgo'
+
+  switch (providerId) {
+    case 'google':
+      return new GoogleProvider()
+    case 'bing':
+      return new BingProvider()
+    case 'searxng': {
+      const url = settings.searxngUrl || 'http://localhost:8080'
+      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)
+    }
+    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)
+    }
+    default:
+      return new DuckDuckGoProvider()
+  }
+}

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

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { loadSessions, saveSessions, loadAgents } from '../storage'
 import type { ToolBuildContext } from './context'
 
@@ -165,7 +165,7 @@ export function buildSessionInfoTools(bctx: ToolBuildContext): StructuredToolInt
               const sourceSession = ctx?.sessionId ? sessions[ctx.sessionId] : null
               const ownerUser = sourceSession?.user || 'system'
 
-              const id = crypto.randomBytes(4).toString('hex')
+              const id = genId()
               const now = Date.now()
               const entry = {
                 id,

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

@@ -5,29 +5,9 @@ import path from 'path'
 import * as cheerio from 'cheerio'
 import { UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
-import { safePath, truncate, MAX_OUTPUT } from './context'
-
-// ---------------------------------------------------------------------------
-// DuckDuckGo redirect-URL decoder
-// ---------------------------------------------------------------------------
-
-function decodeDuckDuckGoUrl(rawUrl: string): string {
-  if (!rawUrl) return rawUrl
-  try {
-    const url = rawUrl.startsWith('http')
-      ? new URL(rawUrl)
-      : new URL(rawUrl, 'https://duckduckgo.com')
-    const uddg = url.searchParams.get('uddg')
-    if (uddg) return decodeURIComponent(uddg)
-    return url.toString()
-  } catch {
-    const fromQuery = rawUrl.match(/[?&]uddg=([^&]+)/)?.[1]
-    if (fromQuery) {
-      try { return decodeURIComponent(fromQuery) } catch { /* noop */ }
-    }
-    return rawUrl
-  }
-}
+import { spawnSync } from 'child_process'
+import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
+import { getSearchProvider } from './search-providers'
 
 // ---------------------------------------------------------------------------
 // Global registry of active browser instances for cleanup sweeps
@@ -86,48 +66,10 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
         async ({ query, maxResults }) => {
           try {
             const limit = Math.min(maxResults || 5, 10)
-            const url = `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}`
-            const res = await fetch(url, {
-              headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
-              signal: AbortSignal.timeout(15000),
-            })
-            if (!res.ok) {
-              return `Error searching web: HTTP ${res.status} ${res.statusText}`
-            }
-            const html = await res.text()
-            const $ = cheerio.load(html)
-            const results: { title: string; url: string; snippet: string }[] = []
-
-            // Primary parser: DuckDuckGo result cards
-            $('.result').each((_i, el) => {
-              if (results.length >= limit) return false
-              const link = $(el).find('a.result__a').first()
-              const rawHref = link.attr('href') || ''
-              const title = link.text().replace(/\s+/g, ' ').trim()
-              if (!rawHref || !title) return
-              const snippet = $(el).find('.result__snippet').first().text().replace(/\s+/g, ' ').trim()
-              results.push({
-                title,
-                url: decodeDuckDuckGoUrl(rawHref),
-                snippet,
-              })
-            })
-
-            // Fallback parser: any result__a anchors
-            if (results.length === 0) {
-              $('a.result__a').each((_i, el) => {
-                if (results.length >= limit) return false
-                const rawHref = $(el).attr('href') || ''
-                const title = $(el).text().replace(/\s+/g, ' ').trim()
-                if (!rawHref || !title) return
-                results.push({
-                  title,
-                  url: decodeDuckDuckGoUrl(rawHref),
-                  snippet: '',
-                })
-              })
-            }
-
+            const { loadSettings } = await import('../storage')
+            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.'
@@ -137,7 +79,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
         },
         {
           name: 'web_search',
-          description: 'Search the web using DuckDuckGo. Returns an array of results with title, url, and snippet.',
+          description: 'Search the web. Returns an array of results with title, url, and snippet.',
           schema: z.object({
             query: z.string().describe('Search query'),
             maxResults: z.number().optional().describe('Maximum results to return (default 5, max 10)'),
@@ -404,5 +346,44 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
     )
   }
 
+  // ---- openclaw_browser (CLI passthrough) -----------------------------------
+
+  if (bctx.hasTool('browser') || bctx.hasTool('openclaw_browser')) {
+    const openclawPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
+    if (openclawPath) {
+      tools.push(
+        tool(
+          async ({ command, args: cmdArgs }) => {
+            try {
+              const spawnArgs = ['browser', command, '--json']
+              if (cmdArgs) spawnArgs.push(...cmdArgs.split(/\s+/).filter(Boolean))
+              const result = spawnSync(openclawPath, spawnArgs, {
+                encoding: 'utf-8',
+                timeout: 60_000,
+                maxBuffer: MAX_OUTPUT,
+              })
+              const stdout = (result.stdout || '').trim()
+              const stderr = (result.stderr || '').trim()
+              if (result.status !== 0) {
+                return `Error (exit ${result.status}): ${stderr || stdout || 'unknown error'}`
+              }
+              return truncate(stdout || '(no output)', MAX_OUTPUT)
+            } catch (err: any) {
+              return `Error: ${err.message}`
+            }
+          },
+          {
+            name: 'openclaw_browser',
+            description: 'Control a browser through the OpenClaw CLI. Requires openclaw/clawdbot CLI on PATH. Passes through to `openclaw browser <command> --json`.',
+            schema: z.object({
+              command: z.string().describe('Browser command (navigate, screenshot, click, type, evaluate, etc.)'),
+              args: z.string().optional().describe('Additional arguments as a space-separated string'),
+            }),
+          },
+        ),
+      )
+    }
+  }
+
   return tools
 }

package/src/lib/server/storage.ts

@@ -43,6 +43,7 @@ const COLLECTIONS = [
   'model_overrides',
   'mcp_servers',
   'webhook_logs',
+  'projects',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -576,6 +577,17 @@ export function saveModelOverrides(m: Record<string, string[]>) {
   saveCollection('model_overrides', m)
 }
 
+// --- Projects ---
+export function loadProjects(): Record<string, any> {
+  return loadCollection('projects')
+}
+
+export function saveProjects(s: Record<string, any>) {
+  saveCollection('projects', s)
+}
+
+export function deleteProject(id: string) { deleteCollectionItem('projects', id) }
+
 // --- Skills ---
 export function loadSkills(): Record<string, any> {
   return loadCollection('skills')

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

@@ -168,11 +168,20 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
   // fallbackCredentialIds is intentionally accepted for compatibility with caller signatures.
   void fallbackCredentialIds
+
+  // Resolve agent's thinking level for provider-native params
+  let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
+  if (session.agentId) {
+    const agentsForThinking = loadAgents()
+    agentThinkingLevel = agentsForThinking[session.agentId]?.thinkingLevel
+  }
+
   const llm = buildChatModel({
     provider: session.provider,
     model: session.model,
     apiKey,
     apiEndpoint: session.apiEndpoint,
+    thinkingLevel: agentThinkingLevel,
   })
 
   // Build stateModifier
@@ -228,6 +237,17 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     stateModifierParts.push('You are a capable AI assistant with tool access. Be execution-oriented and outcome-focused.')
   }
 
+  // Thinking level guidance (applies to all providers via system prompt)
+  if (agentThinkingLevel) {
+    const thinkingGuidance: Record<string, string> = {
+      minimal: 'Be direct and concise. Skip extended analysis.',
+      low: 'Keep reasoning brief. Focus on key conclusions.',
+      medium: 'Provide moderate depth of analysis and reasoning.',
+      high: 'Think deeply and thoroughly. Show detailed reasoning.',
+    }
+    stateModifierParts.push(`## Reasoning Depth\n${thinkingGuidance[agentThinkingLevel]}`)
+  }
+
   if ((session.tools || []).includes('memory') && session.agentId) {
     try {
       const memDb = getMemoryDb()
@@ -612,6 +632,15 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   // Plugin hooks: afterAgentComplete
   await pluginMgr.runHook('afterAgentComplete', { session, response: fullText })
 
+  // OpenClaw auto-sync: push memory if enabled
+  try {
+    const { loadSyncConfig, pushMemoryToOpenClaw } = await import('./openclaw-sync')
+    const syncConfig = loadSyncConfig()
+    if (syncConfig.autoSyncMemory) {
+      pushMemoryToOpenClaw(session.agentId || undefined)
+    }
+  } catch { /* OpenClaw sync not available — ignore */ }
+
   // Clean up browser and other session resources
   await cleanup()
 

package/src/lib/server/task-result.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { extractTaskResult } from './task-result'
+
+describe('extractTaskResult', () => {
+  it('limits artifact extraction to messages from the current run window', () => {
+    const session = {
+      messages: [
+        {
+          role: 'assistant',
+          time: 1_000,
+          text: 'old run artifact: /api/uploads/wiki-old.png',
+        },
+        {
+          role: 'assistant',
+          time: 2_000,
+          text: 'new run artifact: /api/uploads/wiki-new.png',
+        },
+      ],
+    }
+
+    const result = extractTaskResult(session, 'done', { sinceTime: 1_500 })
+    assert.deepEqual(result.artifacts.map((a) => a.url), ['/api/uploads/wiki-new.png'])
+  })
+
+  it('excludes messages without timestamps when sinceTime is provided', () => {
+    const session = {
+      messages: [
+        {
+          role: 'assistant',
+          text: 'undated artifact: /api/uploads/undated.png',
+        },
+        {
+          role: 'assistant',
+          time: 5_000,
+          text: 'dated artifact: /api/uploads/dated.png',
+        },
+      ],
+    }
+
+    const result = extractTaskResult(session, 'done', { sinceTime: 4_000 })
+    assert.deepEqual(result.artifacts.map((a) => a.url), ['/api/uploads/dated.png'])
+  })
+})

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

@@ -43,6 +43,7 @@ function classifyArtifact(filename: string): Artifact['type'] {
 interface MessageLike {
   role?: string
   text?: string
+  time?: number
   imageUrl?: string
   imagePath?: string
   toolEvents?: Array<{ name?: string; output?: string }>
@@ -52,6 +53,10 @@ interface SessionLike {
   messages?: MessageLike[]
 }
 
+interface ExtractTaskResultOptions {
+  sinceTime?: number | null
+}
+
 // ---------------------------------------------------------------------------
 // Core extraction
 // ---------------------------------------------------------------------------
@@ -64,9 +69,13 @@ interface SessionLike {
 export function extractTaskResult(
   session: SessionLike | null | undefined,
   rawResultText: string | null | undefined,
+  options?: ExtractTaskResultOptions,
 ): TaskResult {
   const seen = new Set<string>()
   const artifacts: Artifact[] = []
+  const sinceTime = typeof options?.sinceTime === 'number' && Number.isFinite(options.sinceTime)
+    ? options.sinceTime
+    : null
 
   function addUrl(raw: string) {
     const url = stripSandbox(raw)
@@ -79,6 +88,11 @@ export function extractTaskResult(
   // Walk session messages to collect all artifact URLs
   if (Array.isArray(session?.messages)) {
     for (const msg of session.messages) {
+      if (sinceTime !== null) {
+        const msgTime = typeof msg.time === 'number' && Number.isFinite(msg.time) ? msg.time : null
+        if (msgTime === null || msgTime < sinceTime) continue
+      }
+
       // Explicit image fields
       if (msg.imageUrl) addUrl(msg.imageUrl)
       if (msg.imagePath) {

package/src/lib/tool-definitions.ts

@@ -18,8 +18,10 @@ export const AVAILABLE_TOOLS: ToolDefinition[] = [
   { id: 'codex_cli', label: 'Codex CLI', description: 'Delegate complex tasks to OpenAI Codex CLI' },
   { id: 'opencode_cli', label: 'OpenCode CLI', description: 'Delegate complex tasks to OpenCode CLI' },
   { id: 'browser', label: 'Browser', description: 'Playwright — browse, scrape, interact with web pages' },
-  { id: 'memory', label: 'Memory', description: 'Store and retrieve long-term memories across sessions' },
+  { id: 'memory', label: 'Memory', description: 'Store and retrieve long-term memories across conversations' },
   { id: 'sandbox', label: 'Sandbox', description: 'Run JS/TS/Python code in an isolated Deno sandbox' },
+  { id: 'create_document', label: 'Create Document', description: 'Render markdown to PDF, HTML, or image' },
+  { id: 'create_spreadsheet', label: 'Create Spreadsheet', description: 'Create Excel or CSV files from structured data' },
 ]
 
 export const PLATFORM_TOOLS: ToolDefinition[] = [
@@ -28,9 +30,9 @@ export const PLATFORM_TOOLS: ToolDefinition[] = [
   { id: 'manage_schedules', label: 'Schedules', description: 'Create, edit, and delete schedules' },
   { id: 'manage_skills', label: 'Skills', description: 'Create, edit, and delete skills' },
   { id: 'manage_documents', label: 'Documents', description: 'Upload, search, and delete indexed documents' },
-  { id: 'manage_webhooks', label: 'Webhooks', description: 'Register webhooks that trigger agent sessions' },
+  { id: 'manage_webhooks', label: 'Webhooks', description: 'Register webhooks that trigger agent workflows' },
   { id: 'manage_connectors', label: 'Connectors', description: 'Create, edit, and delete connectors' },
-  { id: 'manage_sessions', label: 'Sessions', description: 'List sessions, send messages, and spawn session work' },
+  { id: 'manage_sessions', label: 'Chats', description: 'List chats, send messages, and spawn agent work' },
   { id: 'manage_secrets', label: 'Secrets', description: 'Store and retrieve encrypted service secrets' },
 ]