@swarmclawai/swarmclaw 0.6.7 → 0.6.8

package/src/lib/server/plugins.ts

@@ -1,18 +1,21 @@
 import fs from 'fs'
 import path from 'path'
 import { createRequire } from 'module'
-import type { Plugin, PluginHooks, PluginMeta } from '@/types'
+import type { Plugin, PluginHooks, PluginMeta, PluginToolDef } from '@/types'
 
 import { DATA_DIR } from './data-dir'
 
 const PLUGINS_DIR = path.join(DATA_DIR, 'plugins')
 const PLUGINS_CONFIG = path.join(DATA_DIR, 'plugins.json')
 
+// Hook registrar: maps event names to functions that register a handler
+type HookRegistrar = Record<string, (fn: (...args: unknown[]) => unknown) => void>
+
 // OpenClaw plugin format: { name, version, activate(ctx), deactivate() }
 interface OpenClawPlugin {
   name: string
   version?: string
-  activate: (ctx: Record<string, (fn: (...args: any[]) => any) => void>) => void
+  activate: (ctx: HookRegistrar) => void
   deactivate?: () => void
 }
 
@@ -21,33 +24,39 @@ interface OpenClawPlugin {
  * Supports both SwarmClaw format ({ name, hooks }) and OpenClaw format
  * ({ name, activate(ctx) }) where activate receives event hook registrars.
  */
-function normalizePlugin(mod: any): Plugin | null {
-  const raw = mod.default || mod
+function normalizePlugin(mod: unknown): Plugin | null {
+  const modObj = mod as Record<string, unknown>
+  const raw: Record<string, unknown> = (modObj?.default as Record<string, unknown>) || modObj
 
   // SwarmClaw native format
   if (raw.name && raw.hooks) {
-    return raw as Plugin
+    return {
+      name: raw.name,
+      description: raw.description,
+      hooks: raw.hooks,
+      tools: raw.tools,
+    } as Plugin
   }
 
   // OpenClaw format: { name, activate(ctx), deactivate() }
   if (raw.name && typeof raw.activate === 'function') {
-    const oc = raw as OpenClawPlugin
+    const oc = raw as unknown as OpenClawPlugin
     const hooks: PluginHooks = {}
 
     // OpenClaw's activate receives an object of hook registrars.
     // Map OpenClaw lifecycle names to SwarmClaw hook names.
-    const registrar: Record<string, (fn: (...args: any[]) => any) => void> = {
-      onAgentStart: (fn) => { hooks.beforeAgentStart = fn },
-      onAgentComplete: (fn) => { hooks.afterAgentComplete = fn },
-      onToolCall: (fn) => { hooks.beforeToolExec = fn },
-      onToolResult: (fn) => { hooks.afterToolExec = fn },
-      onMessage: (fn) => { hooks.onMessage = fn },
+    const registrar: HookRegistrar = {
+      onAgentStart: (fn) => { hooks.beforeAgentStart = fn as PluginHooks['beforeAgentStart'] },
+      onAgentComplete: (fn) => { hooks.afterAgentComplete = fn as PluginHooks['afterAgentComplete'] },
+      onToolCall: (fn) => { hooks.beforeToolExec = fn as PluginHooks['beforeToolExec'] },
+      onToolResult: (fn) => { hooks.afterToolExec = fn as PluginHooks['afterToolExec'] },
+      onMessage: (fn) => { hooks.onMessage = fn as PluginHooks['onMessage'] },
     }
 
     try {
       oc.activate(registrar)
-    } catch (err: any) {
-      console.error(`[plugins] OpenClaw activate() failed for ${oc.name}:`, err.message)
+    } catch (err: unknown) {
+      console.error(`[plugins] OpenClaw activate() failed for ${oc.name}:`, err instanceof Error ? err.message : String(err))
       return null
     }
 
@@ -68,9 +77,10 @@ if (!fs.existsSync(PLUGINS_CONFIG)) fs.writeFileSync(PLUGINS_CONFIG, '{}')
 // Use createRequire to avoid Turbopack static analysis of require()
 const dynamicRequire = createRequire(import.meta.url || __filename)
 
-interface LoadedPlugin {
+  interface LoadedPlugin {
   meta: PluginMeta
   hooks: PluginHooks
+  tools?: PluginToolDef[]
 }
 
 class PluginManager {
@@ -112,11 +122,12 @@ class PluginManager {
                 enabled: true,
               },
               hooks: plugin.hooks,
+              tools: plugin.tools,
             })
             console.log(`[plugins] Loaded: ${plugin.name} (${file})`)
           }
-        } catch (err: any) {
-          console.error(`[plugins] Failed to load ${file}:`, err.message)
+        } catch (err: unknown) {
+          console.error(`[plugins] Failed to load ${file}:`, err instanceof Error ? err.message : String(err))
         }
       }
     } catch {
@@ -126,6 +137,17 @@ class PluginManager {
     this.loaded = true
   }
 
+  getPluginTools(): PluginToolDef[] {
+    this.load()
+    const allTools: PluginToolDef[] = []
+    for (const plugin of this.plugins) {
+      if (plugin.tools && Array.isArray(plugin.tools)) {
+        allTools.push(...plugin.tools)
+      }
+    }
+    return allTools
+  }
+
   async runHook<K extends keyof PluginHooks>(
     hookName: K,
     ctx: Parameters<NonNullable<PluginHooks[K]>>[0],
@@ -135,9 +157,9 @@ class PluginManager {
       const hook = plugin.hooks[hookName]
       if (hook) {
         try {
-          await (hook as any)(ctx)
-        } catch (err: any) {
-          console.error(`[plugins] Error in ${plugin.meta.name}.${hookName}:`, err.message)
+          await (hook as (ctx: Parameters<NonNullable<PluginHooks[K]>>[0]) => Promise<void> | void)(ctx)
+        } catch (err: unknown) {
+          console.error(`[plugins] Error in ${plugin.meta.name}.${hookName}:`, err instanceof Error ? err.message : String(err))
         }
       }
     }
@@ -198,8 +220,8 @@ class PluginManager {
       fs.writeFileSync(path.join(PLUGINS_DIR, sanitized), code, 'utf8')
       this.reload()
       return { ok: true }
-    } catch (err: any) {
-      return { ok: false, error: err.message }
+    } catch (err: unknown) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) }
     }
   }
 

package/src/lib/server/query-expansion.ts

@@ -0,0 +1,57 @@
+import { loadAgents, loadSettings, loadCredentials, decryptKey } from './storage'
+import { getProvider } from '../providers'
+
+/**
+ * Expands a single user query into multiple semantic search variants
+ * to improve vector database recall (OpenClaw-style).
+ */
+export async function expandQuery(query: string): Promise<string[]> {
+  const agents = loadAgents()
+  const settings = loadSettings()
+  const defaultAgent = agents[settings.defaultAgentId]
+  if (!defaultAgent) return [query]
+
+  const providerEntry = getProvider(defaultAgent.provider)
+  if (!providerEntry?.handler?.streamChat) return [query]
+
+  const creds = loadCredentials()
+  const cred = creds[defaultAgent.credentialId || '']
+  const apiKey = cred ? decryptKey(cred.encryptedKey) : undefined
+
+  const systemPrompt = `You are a search query expansion assistant. 
+Given a user's question, generate 3 different semantic search queries that would help find the answer in a vector database.
+Use different vocabulary and focus on different aspects of the intent.
+Format your response as a simple newline-separated list. No numbering, no bullets, no introduction.`
+
+  let expanded = ''
+  try {
+    await providerEntry.handler.streamChat({
+      session: { id: 'expansion', messages: [], model: defaultAgent.model, provider: defaultAgent.provider },
+      message: query,
+      apiKey,
+      systemPrompt,
+      write: (raw: string) => {
+        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) expanded += ev.text
+          } catch { /* skip */ }
+        }
+      },
+      active: new Map(),
+      loadHistory: () => [],
+    })
+
+    const variants = expanded.split('\n').map(l => l.trim()).filter(Boolean)
+    if (variants.length > 0) {
+      // Return original query + variants
+      return [query, ...variants.slice(0, 3)]
+    }
+  } catch (err) {
+    console.error('[query-expansion] Failed to expand query:', err)
+  }
+
+  return [query]
+}

package/src/lib/server/queue.ts

@@ -13,6 +13,7 @@ import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { isProtectedMainSession } from './main-session'
 import { cascadeUnblock } from './dag-validation'
+import { performGuardianRollback } from './guardian'
 import type { Agent, BoardTask, Connector, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
@@ -802,6 +803,32 @@ function scheduleRetryOrDeadLetter(task: BoardTask, reason: string): 'retry' | '
     text: `Task moved to dead-letter after ${task.attempts}/${task.maxAttempts} attempts.\n\nReason: ${reason}`,
     createdAt: now,
   })
+
+  // Guardian Auto-Rollback
+  const agents = loadAgents()
+  const agent = task.agentId ? agents[task.agentId] : null
+  if (agent?.autoRecovery) {
+    const cwd = task.projectId 
+      ? path.join(WORKSPACE_DIR, 'projects', task.projectId) 
+      : WORKSPACE_DIR
+    const rollback = performGuardianRollback(cwd)
+    if (rollback.ok) {
+      task.comments.push({
+        id: genId(),
+        author: 'Guardian',
+        text: `Auto-recovery triggered: Workspace successfully rolled back to last clean state.`,
+        createdAt: now + 1,
+      })
+    } else {
+      task.comments.push({
+        id: genId(),
+        author: 'Guardian',
+        text: `Auto-recovery failed: ${rollback.reason}`,
+        createdAt: now + 1,
+      })
+    }
+  }
+
   return 'dead_lettered'
 }
 

package/src/lib/server/session-run-manager.ts

@@ -271,6 +271,9 @@ async function drainExecution(executionKey: string): Promise<void> {
         resultText: result.text,
         error: result.error,
         toolEvents: result.toolEvents,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        estimatedCost: result.estimatedCost,
       })
     } catch (mainLoopErr: any) {
       log.warn('session-run', `Main-loop update failed for ${next.run.id}`, mainLoopErr?.message || String(mainLoopErr))
@@ -372,6 +375,19 @@ export interface EnqueueSessionRunResult {
   abort: () => void
 }
 
+const LONG_TOOL_NAMES: ReadonlySet<string> = new Set(['claude_code', 'codex_cli', 'opencode_cli'])
+
+function computeEffectiveRunTimeoutMs(
+  baseTimeoutMs: number,
+  sessionTools: string[],
+  runtime: { claudeCodeTimeoutMs: number },
+): number {
+  const hasLongTool = sessionTools.some(t => LONG_TOOL_NAMES.has(t))
+  if (!hasLongTool) return baseTimeoutMs
+  const toolTimeout = runtime.claudeCodeTimeoutMs + 120_000
+  return Math.max(baseTimeoutMs, toolTimeout)
+}
+
 export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSessionRunResult {
   const internal = input.internal === true
   const mode = normalizeMode(input.mode, internal)
@@ -379,9 +395,13 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
   const executionKey = executionKeyForSession(input.sessionId)
   const runtime = loadRuntimeSettings()
   const defaultMaxRuntimeMs = runtime.ongoingLoopMaxRuntimeMs ?? (10 * 60_000)
+  const sessions = loadSessions()
+  const sessionData = sessions[input.sessionId]
+  const sessionTools: string[] = sessionData?.tools || []
+  const adjustedDefaultMs = computeEffectiveRunTimeoutMs(defaultMaxRuntimeMs, sessionTools, runtime)
   const effectiveMaxRuntimeMs = typeof input.maxRuntimeMs === 'number'
     ? input.maxRuntimeMs
-    : defaultMaxRuntimeMs
+    : adjustedDefaultMs
 
   const dedupe = findDedupeMatch(input.sessionId, input.dedupeKey)
   if (dedupe) {

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

@@ -2,27 +2,37 @@ import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { ToolBuildContext } from './context'
 import { truncate, MAX_OUTPUT } from './context'
+import { withRetry } from '../tool-retry'
+
+interface HttpRequestArgs {
+  method: string
+  url: string
+  headers?: Record<string, string>
+  body?: string
+  timeoutSec?: number
+  followRedirects?: boolean
+}
 
 export function buildHttpTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   if (!bctx.hasTool('http_request')) return []
 
   return [
     tool(
-      async ({ method, url, headers, body, timeoutSec, followRedirects }) => {
+      (args: HttpRequestArgs) => withRetry(async (_a: HttpRequestArgs) => {
         try {
-          const timeout = Math.max(1, Math.min(timeoutSec ?? 30, 120)) * 1000
+          const timeout = Math.max(1, Math.min(_a.timeoutSec ?? 30, 120)) * 1000
           const init: RequestInit = {
-            method,
-            headers: (headers ?? undefined) as Record<string, string> | undefined,
+            method: _a.method,
+            headers: (_a.headers ?? undefined) as Record<string, string> | undefined,
             signal: AbortSignal.timeout(timeout),
           }
-          if (body && method !== 'GET' && method !== 'HEAD') {
-            init.body = body
+          if (_a.body && _a.method !== 'GET' && _a.method !== 'HEAD') {
+            init.body = _a.body
           }
-          if (followRedirects === false) {
+          if (_a.followRedirects === false) {
             init.redirect = 'manual'
           }
-          const res = await fetch(url, init)
+          const res = await fetch(_a.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)
@@ -39,7 +49,7 @@ export function buildHttpTools(bctx: ToolBuildContext): StructuredToolInterface[
         } catch (err: unknown) {
           return JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
         }
-      },
+      }, args),
       {
         name: 'http_request',
         description: 'Make an HTTP API request. Supports all methods, custom headers, and request bodies. Returns status, headers, and body.',

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

@@ -1,5 +1,6 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { Session } from '@/types'
 import { loadSettings, loadSessions, saveSessions, loadMcpServers } from '../storage'
 import { loadRuntimeSettings } from '../runtime-settings'
 import { log } from '../logger'
@@ -23,6 +24,9 @@ import { buildHttpTools } from './http'
 import { buildGitTools } from './git'
 import { buildWalletTools } from './wallet'
 import { buildOpenClawWorkspaceTools } from './openclaw-workspace'
+import { buildScheduleTools } from './schedule'
+import { getPluginManager } from '../plugins'
+import { jsonSchemaToZod } from '../mcp-client'
 
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
@@ -113,6 +117,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildGitTools(bctx),
     ...buildWalletTools(bctx),
     ...buildOpenClawWorkspaceTools(bctx),
+    ...buildScheduleTools(bctx),
   )
 
   // ---------------------------------------------------------------------------
@@ -151,6 +156,35 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     })
   }
 
+  // ---------------------------------------------------------------------------
+  // Plugin tools — native tools provided by SwarmClaw plugins
+  // ---------------------------------------------------------------------------
+  try {
+    const pluginTools = getPluginManager().getPluginTools()
+    for (const pt of pluginTools) {
+      if (!disabledMcpToolNames.has(pt.name)) {
+        tools.push(
+          tool(
+            async (args) => {
+              const res = await pt.execute(args as Record<string, unknown>, {
+                session: { id: ctx?.sessionId || 'unknown', agentId: ctx?.agentId } as Session,
+                message: '',
+              })
+              return typeof res === 'string' ? res : JSON.stringify(res)
+            },
+            {
+              name: pt.name,
+              description: pt.description,
+              schema: jsonSchemaToZod(pt.parameters),
+            }
+          )
+        )
+      }
+    }
+  } catch (err: unknown) {
+    log.error('session-tools', 'Failed to load plugin tools', { error: err instanceof Error ? err.message : String(err) })
+  }
+
   // request_tool_access: always available
   tools.push(
     tool(

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

@@ -4,6 +4,8 @@ import fs from 'fs'
 import { genId } from '@/lib/id'
 import { getMemoryDb, getMemoryLookupLimits, storeMemoryImageAsset } from '../memory-db'
 import { loadSettings } from '../storage'
+import { expandQuery } from '../query-expansion'
+import type { MemoryEntry } from '@/types'
 import type { ToolBuildContext } from './context'
 
 export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterface[] {
@@ -20,8 +22,9 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
           try {
             const scopeMode = scope || 'auto'
             const currentAgentId = ctx?.agentId || null
-            const canAccessMemory = (m: any) => !m?.agentId || m.agentId === currentAgentId
-            const filterScope = (rows: any[]) => {
+            const canAccessMemory = (m: MemoryEntry) => !m?.agentId || m.agentId === currentAgentId
+            const filterScope = (rows: MemoryEntry[]) => {
+              if (scopeMode === 'all') return rows
               if (scopeMode === 'shared') return rows.filter((m) => !m.agentId)
               if (scopeMode === 'agent') return rows.filter((m) => currentAgentId && m.agentId === currentAgentId)
               return rows.filter(canAccessMemory)
@@ -126,17 +129,42 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
               return formatEntry(found)
             }
             if (action === 'search') {
+              const queries = query ? await expandQuery(query) : [key || '']
+              
               if (effectiveDepth > 0) {
-                const result = memDb.searchWithLinked(query || key, undefined, effectiveDepth, maxPerLookup, effectiveLinkedLimit)
-                const accessible = filterScope(result.entries)
+                const allResults: MemoryEntry[] = []
+                const seenIds = new Set<string>()
+                let anyTruncated = false
+                for (const q of queries) {
+                  const result = memDb.searchWithLinked(q, undefined, effectiveDepth, maxPerLookup, effectiveLinkedLimit)
+                  if (result.truncated) anyTruncated = true
+                  for (const r of result.entries) {
+                    if (!seenIds.has(r.id)) {
+                      seenIds.add(r.id)
+                      allResults.push(r)
+                    }
+                  }
+                }
+                const accessible = filterScope(allResults)
                 if (!accessible.length) return 'No memories found.'
-                let output = accessible.map(formatEntry).join('\n')
-                if (result.truncated) output += `\n\n[Results truncated at ${maxPerLookup} memories / ${effectiveLinkedLimit} linked expansions]`
+                let output = accessible.slice(0, maxPerLookup).map(formatEntry).join('\n')
+                if (anyTruncated) output += `\n\n[Results truncated at ${maxPerLookup} memories / ${effectiveLinkedLimit} linked expansions]`
                 return output
               }
-              const results = filterScope(memDb.search(query || key))
-              if (!results.length) return 'No memories found.'
-              return results.slice(0, maxPerLookup).map(formatEntry).join('\n')
+
+              const allResults: MemoryEntry[] = []
+              const seenIds = new Set<string>()
+              for (const q of queries) {
+                const results = filterScope(memDb.search(q))
+                for (const r of results) {
+                  if (!seenIds.has(r.id)) {
+                    seenIds.add(r.id)
+                    allResults.push(r)
+                  }
+                }
+              }
+              if (!allResults.length) return 'No memories found.'
+              return allResults.slice(0, maxPerLookup).map(formatEntry).join('\n')
             }
             if (action === 'list') {
               const results = filterScope(memDb.list(undefined, maxPerLookup))
@@ -204,14 +232,14 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
         },
         {
           name: 'memory_tool',
-          description: 'My long-term memory — things I remember across conversations. I can store personal notes, recall past context, and build up knowledge over time. Memories can be private to me or shared with other agents. I can also attach files, link related memories, and contribute to a shared knowledge base. Actions: store, get, search, list, delete, link, unlink, knowledge_store, knowledge_search.',
+          description: `My long-term memory — things I remember across conversations. I can store personal notes, recall past context, and build up knowledge over time. Memories can be private to me or shared with other agents. I can also attach files, link related memories, and contribute to a shared knowledge base. Use \`scope: 'all'\` to search memories across all agents (useful when you need context from other agents' work).${bctx.hasTool('manage_agents') || bctx.hasTool('manage_sessions') ? ' As an orchestrator, cross-agent search with scope=all is especially useful for gathering context from sub-agents.' : ''} Actions: store, get, search, list, delete, link, unlink, knowledge_store, knowledge_search.`,
           schema: z.object({
             action: z.enum(['store', 'get', 'search', 'list', 'delete', 'link', 'unlink', 'knowledge_store', 'knowledge_search']).describe('The action to perform'),
             key: z.string().describe('For store: memory title. For get/delete/link/unlink: memory ID. For search: optional query fallback.'),
             value: z.string().optional().describe('The memory content (for store action)'),
             category: z.string().optional().describe('Category like "note", "fact", "preference", "project", "identity" (for store action, defaults to "note")'),
             query: z.string().optional().describe('Search query (alternative to key for search action)'),
-            scope: z.enum(['auto', 'shared', 'agent']).optional().describe('Scope hint: auto (shared + own), shared, or agent'),
+            scope: z.enum(['auto', 'shared', 'agent', 'all']).optional().describe('Scope hint: auto (shared + own), shared (shared only), agent (own only), or all (every agent — cross-agent search)'),
             filePaths: z.array(z.object({
               path: z.string().describe('File or folder path'),
               contextSnippet: z.string().optional().describe('Brief context about this file reference'),

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

@@ -0,0 +1,43 @@
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { z } from 'zod'
+import { enqueueSystemEvent } from '../system-events'
+import { requestHeartbeatNow } from '../heartbeat-wake'
+import type { ToolBuildContext } from './context'
+
+export function buildScheduleTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const tools: StructuredToolInterface[] = []
+  const { ctx, hasTool } = bctx
+
+  if (hasTool('schedule_wake')) {
+    tools.push(
+      tool(
+        async ({ delayMinutes, message }) => {
+          if (!ctx?.sessionId) return 'Cannot schedule wake: no session context.'
+          if (delayMinutes <= 0 || delayMinutes > 1440) return 'delayMinutes must be between 1 and 1440 (24 hours).'
+
+          // Non-durable in-memory timeout for conversational wake events
+          // (For durable cron, use manage_schedules)
+          const delayMs = delayMinutes * 60 * 1000
+          setTimeout(() => {
+            if (ctx.sessionId) {
+              enqueueSystemEvent(ctx.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
+              requestHeartbeatNow({ sessionId: ctx.sessionId, reason: 'scheduled_wake' })
+            }
+          }, delayMs)
+
+          return `Successfully scheduled a wake event in ${delayMinutes} minutes with message: "${message}".`
+        },
+        {
+          name: 'schedule_wake',
+          description: 'Schedule a wake event (reminder) for yourself in this chatroom. Use this to proactively check back on a long-running process or to remind yourself to follow up with the user later.',
+          schema: z.object({
+            delayMinutes: z.number().describe('How many minutes from now to wake up (1-1440).'),
+            message: z.string().describe('The reminder text that will be passed back to you when you wake.'),
+          }),
+        },
+      ),
+    )
+  }
+
+  return tools
+}

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

@@ -9,6 +9,7 @@ import { spawnSync } from 'child_process'
 import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
 import { getSearchProvider } from './search-providers'
 import { dedupeScreenshotMarkdownLines } from './web-output'
+import { withRetry } from '../tool-retry'
 
 // ---------------------------------------------------------------------------
 // Search result compression — summarize verbose results before injecting into context
@@ -32,7 +33,7 @@ async function compressSearchResults(
   if (session.credentialId) {
     const creds = loadCredentials()
     const cred = creds[session.credentialId]
-    if (cred) apiKey = decryptKey(cred)
+    if (cred) apiKey = decryptKey(cred.encryptedKey)
   }
 
   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.'
@@ -116,19 +117,19 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
   if (bctx.hasTool('web_search')) {
     tools.push(
       tool(
-        async ({ query, maxResults }) => {
+        ({ query, maxResults }) => withRetry(async (_args: { query: string; maxResults?: number }) => {
           try {
-            const limit = Math.min(maxResults || 5, 10)
+            const limit = Math.min(_args.maxResults || 5, 10)
             const { loadSettings } = await import('../storage')
             const settings = loadSettings()
             const provider = await getSearchProvider(settings)
-            const results = await provider.search(query, limit)
+            const results = await provider.search(_args.query, limit)
             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)
+                const compressed = await compressSearchResults(results, _args.query, bctx)
                 if (compressed) return compressed
               } catch {
                 // Compression failed — fall through to raw results
@@ -138,7 +139,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
           } catch (err: unknown) {
             return `Error searching web: ${err instanceof Error ? err.message : String(err)}`
           }
-        },
+        }, { query, maxResults }),
         {
           name: 'web_search',
           description: 'Search the web for information. Returns results with title, url, and snippet.',
@@ -156,30 +157,53 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
   if (bctx.hasTool('web_fetch')) {
     tools.push(
       tool(
-        async ({ url }) => {
+        ({ url }) => withRetry(async (_args: { url: string }) => {
           try {
-            const res = await fetch(url, {
+            const res = await fetch(_args.url, {
               headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
               signal: AbortSignal.timeout(15000),
             })
             if (!res.ok) return `HTTP ${res.status}: ${res.statusText}`
+            
+            const contentType = res.headers.get('content-type') || ''
+            if (contentType.includes('application/pdf')) {
+              try {
+                // @ts-expect-error pdf-parse has no type declarations
+                const pdfParse = (await import(/* webpackIgnore: true */ 'pdf-parse')).default
+                const arrayBuffer = await res.arrayBuffer()
+                const result = await pdfParse(Buffer.from(arrayBuffer))
+                return truncate(result.text, MAX_OUTPUT)
+              } catch (err: unknown) {
+                return `Error parsing PDF: ${err instanceof Error ? err.message : String(err)}`
+              }
+            }
+
             const html = await res.text()
+            
+            // Basic YouTube extraction (title and description)
+            if (_args.url.includes('youtube.com/watch') || _args.url.includes('youtu.be/')) {
+               const $ = cheerio.load(html)
+               const title = $('meta[property="og:title"]').attr('content') || $('title').text()
+               const description = $('meta[property="og:description"]').attr('content') || ''
+               return truncate(`YouTube Video: ${title}\n\nDescription:\n${description}\n\n(Transcript extraction requires a specialized tool or API)`, MAX_OUTPUT)
+            }
+
             // Use cheerio for robust HTML text extraction
             const $ = cheerio.load(html)
             $('script, style, noscript, nav, footer, header').remove()
             // Prefer article/main content if available
             const main = $('article, main, [role="main"]').first()
-            let text = (main.length ? main.text() : $('body').text())
+            const text = (main.length ? main.text() : $('body').text())
               .replace(/\s+/g, ' ')
               .trim()
             return truncate(text, MAX_OUTPUT)
           } catch (err: unknown) {
             return `Error fetching URL: ${err instanceof Error ? err.message : String(err)}`
           }
-        },
+        }, { url }),
         {
           name: 'web_fetch',
-          description: 'Fetch a URL and read its content (HTML stripped to text). How I read web pages and pull in external information.',
+          description: 'Fetch a URL and read its content. Supports HTML web pages and direct PDF links. Provides basic metadata for YouTube videos.',
           schema: z.object({
             url: z.string().describe('The URL to fetch'),
           }),