@swarmclawai/swarmclaw 0.4.0 → 0.5.0

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,58 +66,20 @@ 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.'
-          } catch (err: any) {
-            return `Error searching web: ${err.message}`
+          } catch (err: unknown) {
+            return `Error searching web: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {
           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)'),
@@ -169,8 +111,8 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
               .replace(/\s+/g, ' ')
               .trim()
             return truncate(text, MAX_OUTPUT)
-          } catch (err: any) {
-            return `Error fetching URL: ${err.message}`
+          } catch (err: unknown) {
+            return `Error fetching URL: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {
@@ -374,8 +316,8 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
               ? params.saveTo.trim()
               : undefined
             return await callMcpTool(mcpTool, args, { saveTo })
-          } catch (err: any) {
-            return `Error: ${err.message}`
+          } catch (err: unknown) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {
@@ -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: unknown) {
+              return `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          },
+          {
+            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

@@ -5,6 +5,8 @@ import os from 'os'
 import Database from 'better-sqlite3'
 
 import { DATA_DIR, WORKSPACE_DIR } from './data-dir'
+import type { Message } from '@/types'
+import { ensureMainSessionFlag } from './main-session'
 export const UPLOAD_DIR = path.join(DATA_DIR, 'uploads')
 
 // Ensure directories exist
@@ -13,9 +15,12 @@ for (const dir of [DATA_DIR, UPLOAD_DIR, WORKSPACE_DIR]) {
 }
 
 // --- SQLite Database ---
-const DB_PATH = path.join(DATA_DIR, 'swarmclaw.db')
+const IS_BUILD_BOOTSTRAP = process.env.SWARMCLAW_BUILD_MODE === '1'
+const DB_PATH = IS_BUILD_BOOTSTRAP ? ':memory:' : path.join(DATA_DIR, 'swarmclaw.db')
 const db = new Database(DB_PATH)
-db.pragma('journal_mode = WAL')
+if (!IS_BUILD_BOOTSTRAP) {
+  db.pragma('journal_mode = WAL')
+}
 db.pragma('foreign_keys = ON')
 
 const collectionCacheKey = '__swarmclaw_storage_collection_cache__' as const
@@ -43,6 +48,7 @@ const COLLECTIONS = [
   'model_overrides',
   'mcp_servers',
   'webhook_logs',
+  'projects',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -242,10 +248,12 @@ function migrateFromJson() {
   console.log('[storage] Migration complete. JSON files preserved as backup.')
 }
 
-migrateFromJson()
+if (!IS_BUILD_BOOTSTRAP) {
+  migrateFromJson()
+}
 
 // Seed default agent if agents table is empty
-{
+if (!IS_BUILD_BOOTSTRAP) {
   const defaultStarterTools = [
     'memory',
     'files',
@@ -304,6 +312,7 @@ Be concise and helpful. When users ask how to do something, guide them to the sp
       soul: '',
       isOrchestrator: false,
       tools: defaultStarterTools,
+      heartbeatEnabled: true,
       platformAssignScope: 'all',
       skillIds: [],
       subAgentIds: [],
@@ -340,10 +349,12 @@ function loadEnv() {
     })
   }
 }
-loadEnv()
+if (!IS_BUILD_BOOTSTRAP) {
+  loadEnv()
+}
 
 // Auto-generate CREDENTIAL_SECRET if missing
-if (!process.env.CREDENTIAL_SECRET) {
+if (!IS_BUILD_BOOTSTRAP && !process.env.CREDENTIAL_SECRET) {
   const secret = crypto.randomBytes(32).toString('hex')
   const envPath = path.join(process.cwd(), '.env.local')
   fs.appendFileSync(envPath, `\nCREDENTIAL_SECRET=${secret}\n`)
@@ -353,7 +364,7 @@ if (!process.env.CREDENTIAL_SECRET) {
 
 // Auto-generate ACCESS_KEY if missing (used for simple auth)
 const SETUP_FLAG = path.join(DATA_DIR, '.setup_pending')
-if (!process.env.ACCESS_KEY) {
+if (!IS_BUILD_BOOTSTRAP && !process.env.ACCESS_KEY) {
   const key = crypto.randomBytes(16).toString('hex')
   const envPath = path.join(process.cwd(), '.env.local')
   fs.appendFileSync(envPath, `\nACCESS_KEY=${key}\n`)
@@ -383,7 +394,31 @@ export function markSetupComplete(): void {
 
 // --- Sessions ---
 export function loadSessions(): Record<string, any> {
-  return loadCollection('sessions')
+  const sessions = loadCollection('sessions')
+  const agents = loadCollection('agents')
+  let changed = false
+
+  for (const [id, session] of Object.entries(sessions)) {
+    if (!session || typeof session !== 'object') continue
+
+    if (typeof session.id !== 'string' || !session.id.trim()) {
+      session.id = id
+      changed = true
+    }
+
+    const beforeMainFlag = session.mainSession === true
+    ensureMainSessionFlag(session)
+    if (!beforeMainFlag && session.mainSession === true) changed = true
+
+    const agentId = typeof session.agentId === 'string' ? session.agentId.trim() : ''
+    if (agentId && !Object.prototype.hasOwnProperty.call(agents, agentId)) {
+      session.agentId = null
+      changed = true
+    }
+  }
+
+  if (changed) saveCollection('sessions', sessions)
+  return sessions
 }
 
 export function saveSessions(s: Record<string, any>) {
@@ -451,8 +486,23 @@ export function decryptKey(encrypted: string): string {
 }
 
 // --- Agents ---
-export function loadAgents(): Record<string, any> {
-  return loadCollection('agents')
+export function loadAgents(opts?: { includeTrashed?: boolean }): Record<string, any> {
+  const all = loadCollection('agents')
+  if (opts?.includeTrashed) return all
+  const result: Record<string, any> = {}
+  for (const [id, agent] of Object.entries(all)) {
+    if (!agent.trashedAt) result[id] = agent
+  }
+  return result
+}
+
+export function loadTrashedAgents(): Record<string, any> {
+  const all = loadCollection('agents')
+  const result: Record<string, any> = {}
+  for (const [id, agent] of Object.entries(all)) {
+    if (agent.trashedAt) result[id] = agent
+  }
+  return result
 }
 
 export function saveAgents(p: Record<string, any>) {
@@ -526,12 +576,14 @@ export async function getSecret(key: string): Promise<{
   if (!needle) return null
 
   const secrets = loadSecrets()
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const matches = Object.values(secrets).find((secret: any) => {
     if (!secret || typeof secret !== 'object') return false
     const id = typeof secret.id === 'string' ? secret.id.toLowerCase() : ''
     const name = typeof secret.name === 'string' ? secret.name.toLowerCase() : ''
     const service = typeof secret.service === 'string' ? secret.service.toLowerCase() : ''
     return id === needle || name === needle || service === needle
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
   }) as any | undefined
 
   if (!matches) return null
@@ -576,6 +628,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')
@@ -678,7 +741,7 @@ export function appendWebhookLog(id: string, entry: any) {
   upsertCollectionItem('webhook_logs', id, entry)
 }
 
-export function getSessionMessages(sessionId: string): any[] {
+export function getSessionMessages(sessionId: string): Message[] {
   const stmt = db.prepare('SELECT data FROM sessions WHERE id = ?')
   const row = stmt.get(sessionId) as { data: string } | undefined
   if (!row) return []

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

@@ -10,6 +10,7 @@ import { loadRuntimeSettings, getAgentLoopRecursionLimit } from './runtime-setti
 import { getMemoryDb } from './memory-db'
 import { logExecution } from './execution-log'
 import type { Session, Message, UsageRecord } from '@/types'
+import { extractSuggestions } from './suggestions'
 
 interface StreamAgentChatOpts {
   session: Session
@@ -26,7 +27,7 @@ interface StreamAgentChatOpts {
 
 function buildToolCapabilityLines(enabledTools: string[]): string[] {
   const lines: string[] = []
-  if (enabledTools.includes('shell')) lines.push('- Shell execution is available (`execute_command`). Use it for real checks/build/test steps.')
+  if (enabledTools.includes('shell')) lines.push('- Shell execution is available (`execute_command`). Use it for running servers, installing deps, running scripts, git commands, build/test steps, and any single or chained shell commands. Supports background mode for long-running processes like dev servers.')
   if (enabledTools.includes('process')) lines.push('- Process control is available (`process_tool`) for long-running commands (poll/log/write/kill).')
   if (enabledTools.includes('files') || enabledTools.includes('copy_file') || enabledTools.includes('move_file') || enabledTools.includes('delete_file')) {
     lines.push('- File operations are available (`read_file`, `write_file`, `list_files`, `copy_file`, `move_file`, `send_file`). `delete_file` is destructive and may be disabled unless explicitly enabled.')
@@ -111,10 +112,10 @@ function buildAgenticExecutionPolicy(opts: {
       ? 'When coordinating platform work, inspect existing sessions and avoid duplicating active efforts.'
       : '',
     hasDelegationTool
-      ? `For substantial coding/build/refactor/test requests, prefer CLI delegation first using this order: ${delegationOrder.join(' -> ')}.`
+      ? 'CRITICAL — tool selection: ALWAYS use `execute_command` for running servers, dev servers, HTTP servers, installing dependencies, running scripts, git operations, process management, starting/stopping services, or any command the user wants to "run". Delegation tools (Claude/Codex/OpenCode) CANNOT keep a server running — their session ends and the process dies. `execute_command` with background=true is the ONLY way to run persistent processes.'
       : '',
     hasDelegationTool
-      ? 'Use direct shell/file tool loops yourself mainly for small edits, quick verification, or when delegation tools are unavailable/failing.'
+      ? `Only use CLI delegation (${delegationOrder.join(' -> ')}) for tasks that need deep code understanding across multiple files: large refactors, complex debugging, multi-file code generation, or test suites. Never delegate when the user says "run", "start", "serve", "execute", or "test it locally".`
       : '',
     opts.enabledTools.includes('memory')
       ? 'Memory is active and required for long-horizon work: before major tasks, run memory_tool search/list for relevant prior work; after each meaningful step, store concise reusable notes (what changed, where it lives, constraints, next step). Treat memory as shared context plus your own agent notes, not as user-owned personal profile data.'
@@ -168,11 +169,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 +238,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()
@@ -326,6 +347,16 @@ 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'),
+  )
+
   stateModifierParts.push(
     buildAgenticExecutionPolicy({
       enabledTools: session.tools || [],
@@ -586,6 +617,13 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     if (signal) signal.removeEventListener('abort', abortFromSignal)
   }
 
+  // Extract LLM-generated suggestions from the response and strip the tag
+  const extracted = extractSuggestions(fullText)
+  fullText = extracted.clean
+  if (extracted.suggestions) {
+    write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify({ suggestions: extracted.suggestions }) })}\n\n`)
+  }
+
   // Track cost
   const totalTokens = totalInputTokens + totalOutputTokens
   if (totalTokens > 0) {
@@ -612,14 +650,25 @@ 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()
 
   // If tools were called, finalResponse is the text from the last LLM turn only.
   // Fall back to fullText if the last segment is empty (e.g. agent ended on a tool call
   // with no summary text).
+  // Strip suggestions tag from lastSegment too (connector delivery)
+  const cleanLastSegment = extractSuggestions(lastSegment).clean
   const finalResponse = hasToolCalls
-    ? (lastSegment.trim() || fullText)
+    ? (cleanLastSegment.trim() || fullText)
     : fullText
 
   return { fullText, finalResponse }

package/src/lib/server/suggestions.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+
+const suggestionsSchema = z.array(z.string().min(1).max(80)).length(3)
+
+const SUGGESTIONS_RE = /<suggestions>\s*([\s\S]*?)\s*<\/suggestions>\s*$/
+
+export function extractSuggestions(text: string): { clean: string; suggestions: string[] | null } {
+  const match = text.match(SUGGESTIONS_RE)
+  if (!match) return { clean: text, suggestions: null }
+
+  const clean = text.slice(0, match.index).trimEnd()
+
+  try {
+    const parsed = JSON.parse(match[1])
+    const validated = suggestionsSchema.parse(parsed)
+    return { clean, suggestions: validated }
+  } catch {
+    return { clean, suggestions: null }
+  }
+}

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/server/ws-hub.ts

@@ -83,3 +83,17 @@ export function notify(topic: string, action = 'update', id?: string) {
     }
   }
 }
+
+/** Send an event with a data payload to subscribed browser clients. */
+export function notifyWithPayload(topic: string, data: unknown) {
+  const hub = getHub()
+  if (!hub) return
+
+  const payload = JSON.stringify({ topic, action: 'event', data })
+
+  for (const client of hub.clients) {
+    if (client.topics.has(topic) && client.ws.readyState === WebSocket.OPEN) {
+      client.ws.send(payload)
+    }
+  }
+}

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