@swarmclawai/swarmclaw 0.6.3 → 0.6.6

package/src/lib/server/queue.ts

@@ -12,7 +12,7 @@ import { executeSessionChatTurn } from './chat-execution'
 import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { isProtectedMainSession } from './main-session'
-import type { Agent, BoardTask, Message } from '@/types'
+import type { Agent, BoardTask, Connector, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
 const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false, pendingKick: false }) as { processing: boolean; pendingKick: boolean }
@@ -22,6 +22,10 @@ interface SessionMessageLike {
   text?: string
   time?: number
   kind?: 'chat' | 'heartbeat' | 'system' | 'context-clear'
+  source?: {
+    connectorId?: string
+    channelId?: string
+  }
   toolEvents?: Array<{ name?: string; output?: string }>
 }
 
@@ -39,6 +43,20 @@ interface ScheduleTaskMeta extends BoardTask {
   createdByAgentId?: string | null
 }
 
+interface RunningConnectorLike {
+  id: string
+  platform: string
+  agentId: string | null
+  supportsSend: boolean
+  configuredTargets: string[]
+  recentChannelId: string | null
+}
+
+interface ConnectorTaskFollowupTarget {
+  connectorId: string
+  channelId: string
+}
+
 function sameReasons(a?: string[] | null, b?: string[] | null): boolean {
   const av = Array.isArray(a) ? a : []
   const bv = Array.isArray(b) ? b : []
@@ -164,6 +182,135 @@ function maybeResolveUploadMediaPathFromUrl(url: string | undefined): string | u
   return fs.existsSync(fullPath) ? fullPath : undefined
 }
 
+const OUTPUT_FILE_BACKTICK_RE = /`([^`\n]+\.(?:txt|md|json|csv|pdf|png|jpe?g|webp|gif|svg|mp4|webm|mov|zip|tar|gz|log|yml|yaml|xml|html|css|js|ts|tsx|jsx|py|go|rs|java|swift|kt|sql))`/gi
+const OUTPUT_FILE_PATH_RE = /\b((?:\.{1,2}\/|~\/|\/)?[\w./-]+\.(?:txt|md|json|csv|pdf|png|jpe?g|webp|gif|svg|mp4|webm|mov|zip|tar|gz|log|yml|yaml|xml|html|css|js|ts|tsx|jsx|py|go|rs|java|swift|kt|sql))\b/gi
+const MAX_CONNECTOR_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
+function extractLikelyOutputFiles(text: string): string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  const push = (raw: string) => {
+    const value = raw.trim().replace(/^['"]|['"]$/g, '')
+    if (!value || /^https?:\/\//i.test(value)) return
+    if (value.startsWith('/api/uploads/')) return
+    const key = value.toLowerCase()
+    if (seen.has(key)) return
+    seen.add(key)
+    out.push(value)
+  }
+
+  for (const match of text.matchAll(OUTPUT_FILE_BACKTICK_RE)) {
+    push(match[1] || '')
+    if (out.length >= 8) return out
+  }
+  for (const match of text.matchAll(OUTPUT_FILE_PATH_RE)) {
+    push(match[1] || '')
+    if (out.length >= 8) return out
+  }
+
+  return out
+}
+
+function resolveExistingOutputFilePath(fileRef: string, cwd: string): string | null {
+  const ref = (fileRef || '').trim()
+  if (!ref) return null
+  if (ref.startsWith('/api/uploads/')) {
+    return maybeResolveUploadMediaPathFromUrl(ref) || null
+  }
+  const withoutFileScheme = ref.replace(/^file:\/\//i, '')
+  const candidates = path.isAbsolute(withoutFileScheme)
+    ? [withoutFileScheme]
+    : [
+        cwd ? path.resolve(cwd, withoutFileScheme) : '',
+        path.resolve(WORKSPACE_DIR, withoutFileScheme),
+      ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    try {
+      const stat = fs.statSync(candidate)
+      if (stat.isFile()) return candidate
+    } catch {
+      // ignore missing candidate
+    }
+  }
+  return null
+}
+
+function isSendableAttachment(filePath: string): boolean {
+  try {
+    const stat = fs.statSync(filePath)
+    return stat.isFile() && stat.size <= MAX_CONNECTOR_ATTACHMENT_BYTES
+  } catch {
+    return false
+  }
+}
+
+export function resolveTaskOriginConnectorFollowupTarget(params: {
+  task: BoardTask
+  sessions: Record<string, SessionLike>
+  connectors: Record<string, Connector>
+  running: RunningConnectorLike[]
+}): ConnectorTaskFollowupTarget | null {
+  const { task, sessions, connectors, running } = params
+  const metaTask = task as ScheduleTaskMeta
+  const delegatedByAgentId = typeof metaTask.delegatedByAgentId === 'string'
+    ? metaTask.delegatedByAgentId.trim()
+    : ''
+  const sourceSessionId = typeof metaTask.createdInSessionId === 'string'
+    ? metaTask.createdInSessionId.trim()
+    : ''
+  if (!sourceSessionId) return null
+  const sourceSession = sessions[sourceSessionId]
+  if (!sourceSession || !Array.isArray(sourceSession.messages)) return null
+
+  const runningById = new Map<string, RunningConnectorLike>()
+  for (const entry of running) {
+    if (!entry?.id) continue
+    runningById.set(entry.id, entry)
+  }
+
+  for (let i = sourceSession.messages.length - 1; i >= 0; i--) {
+    const message = sourceSession.messages[i]
+    if (!message || message.role !== 'user') continue
+
+    const connectorId = typeof message.source?.connectorId === 'string'
+      ? message.source.connectorId.trim()
+      : ''
+    if (!connectorId) continue
+
+    const connector = connectors[connectorId]
+    if (!connector) continue
+    const ownerId = typeof connector.agentId === 'string' ? connector.agentId.trim() : ''
+    if (ownerId) {
+      const allowedOwners = new Set([task.agentId, delegatedByAgentId].filter(Boolean))
+      if (!allowedOwners.has(ownerId)) continue
+    }
+
+    const runtime = runningById.get(connectorId)
+    if (runtime && !runtime.supportsSend) continue
+
+    const sourceChannel = typeof message.source?.channelId === 'string'
+      ? message.source.channelId.trim()
+      : ''
+    const fallbackChannel = runtime?.recentChannelId
+      || runtime?.configuredTargets?.[0]
+      || connector.config?.outboundJid
+      || connector.config?.outboundTarget
+      || ''
+    const rawChannel = sourceChannel || fallbackChannel
+    if (!rawChannel) continue
+
+    return {
+      connectorId,
+      channelId: connector.platform === 'whatsapp'
+        ? normalizeWhatsappTarget(rawChannel)
+        : rawChannel,
+    }
+  }
+
+  return null
+}
+
 // Task result extraction now uses Zod-validated structured data
 // from ./task-result.ts (extractTaskResult, formatResultBody)
 
@@ -270,37 +417,67 @@ async function notifyConnectorTaskFollowups(params: {
   statusLabel: string
   summaryText: string
   imageUrl?: string
+  mediaPath?: string
+  mediaFileName?: string
 }) {
-  const { task, statusLabel, summaryText, imageUrl } = params
+  const { task, statusLabel, summaryText, imageUrl, mediaPath, mediaFileName } = params
 
   const connectors = loadConnectors()
   const running = (await import('./connectors/manager')).listRunningConnectors()
   const manager = await import('./connectors/manager')
+  const sessions = loadSessions()
 
-  const candidates = running.filter((entry) => {
-    if (!entry.supportsSend || !entry.id) return false
-    const connector = connectors[entry.id]
-    if (!connector) return false
-    if (connector.agentId !== task.agentId) return false
-    return isEnabledFlag(connector.config?.taskFollowups)
+  const candidateByKey = new Map<string, ConnectorTaskFollowupTarget>()
+  const addCandidate = (candidate: ConnectorTaskFollowupTarget | null | undefined) => {
+    if (!candidate?.connectorId || !candidate?.channelId) return
+    const key = `${candidate.connectorId}|${candidate.channelId}`
+    if (!candidateByKey.has(key)) candidateByKey.set(key, candidate)
+  }
+
+  const originTarget = resolveTaskOriginConnectorFollowupTarget({
+    task,
+    sessions: sessions as Record<string, SessionLike>,
+    connectors,
+    running: running as RunningConnectorLike[],
   })
-  if (!candidates.length) return
+  addCandidate(originTarget)
+  const preferredTargetKey = originTarget
+    ? `${originTarget.connectorId}|${originTarget.channelId}`
+    : ''
 
-  const summary = summaryText.trim().slice(0, 1400)
-  for (const candidate of candidates) {
-    const connector = connectors[candidate.id]
+  for (const entry of running) {
+    if (!entry.supportsSend || !entry.id) continue
+    const connector = connectors[entry.id]
     if (!connector) continue
-
-    const channelTargetRaw = candidate.recentChannelId
-      || candidate.configuredTargets[0]
+    if (connector.agentId !== task.agentId) continue
+    if (!isEnabledFlag(connector.config?.taskFollowups)) continue
+    const channelTargetRaw = entry.recentChannelId
+      || entry.configuredTargets[0]
       || connector.config?.outboundJid
       || connector.config?.outboundTarget
       || ''
     if (!channelTargetRaw) continue
+    addCandidate({
+      connectorId: entry.id,
+      channelId: connector.platform === 'whatsapp'
+        ? normalizeWhatsappTarget(channelTargetRaw)
+        : channelTargetRaw,
+    })
+  }
+  const targets = [...candidateByKey.values()].sort((a, b) => {
+    if (!preferredTargetKey) return 0
+    const aKey = `${a.connectorId}|${a.channelId}`
+    const bKey = `${b.connectorId}|${b.channelId}`
+    if (aKey === preferredTargetKey && bKey !== preferredTargetKey) return -1
+    if (bKey === preferredTargetKey && aKey !== preferredTargetKey) return 1
+    return 0
+  })
+  if (!targets.length) return
 
-    const channelId = connector.platform === 'whatsapp'
-      ? normalizeWhatsappTarget(channelTargetRaw)
-      : channelTargetRaw
+  const summary = summaryText.trim().slice(0, 1400)
+  for (const target of targets) {
+    const connector = connectors[target.connectorId]
+    if (!connector) continue
 
     const template = typeof connector.config?.taskFollowupTemplate === 'string'
       ? connector.config.taskFollowupTemplate.trim()
@@ -316,23 +493,29 @@ async function notifyConnectorTaskFollowups(params: {
           `Task ${statusLabel}: ${task.title}`,
           summary || 'No summary provided.',
         ].join('\n\n')
+    const targetKey = `${target.connectorId}|${target.channelId}`
+    const preferredChannelNote = !template && preferredTargetKey && targetKey === preferredTargetKey
+      ? '\n\n(Update sent in the same channel that requested this task.)'
+      : ''
+    const outboundMessage = `${message}${preferredChannelNote}`
 
-    const resolvedMediaPath = maybeResolveUploadMediaPathFromUrl(imageUrl)
+    const resolvedMediaPath = mediaPath || maybeResolveUploadMediaPathFromUrl(imageUrl)
     try {
       await manager.sendConnectorMessage({
-        connectorId: candidate.id,
-        channelId,
-        text: message,
+        connectorId: target.connectorId,
+        channelId: target.channelId,
+        text: outboundMessage,
         ...(resolvedMediaPath
           ? {
               mediaPath: resolvedMediaPath,
-              caption: message,
+              fileName: mediaFileName || path.basename(resolvedMediaPath),
+              caption: outboundMessage,
             }
           : {}),
       })
     } catch (err: unknown) {
       const errMsg = err instanceof Error ? err.message : String(err)
-      console.warn(`[queue] Failed task follow-up send on connector ${candidate.id}: ${errMsg}`)
+      console.warn(`[queue] Failed task follow-up send on connector ${target.connectorId}: ${errMsg}`)
     }
   }
 }
@@ -358,10 +541,16 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     { sinceTime: typeof task.startedAt === 'number' ? task.startedAt : null },
   )
   const resultBody = formatResultBody(taskResult)
+  const outputFileRefs = Array.isArray(task.outputFiles) && task.outputFiles.length > 0
+    ? task.outputFiles
+    : extractLikelyOutputFiles(resultBody)
 
   const statusLabel = task.status === 'completed' ? 'completed' : 'failed'
   const taskLink = `[${task.title}](#task:${task.id})`
   const firstImage = taskResult.artifacts.find((a) => a.type === 'image')
+  const firstArtifactMediaPath = taskResult.artifacts
+    .map((artifact) => maybeResolveUploadMediaPathFromUrl(artifact.url))
+    .find((candidate): candidate is string => Boolean(candidate))
   const now = Date.now()
   let changed = false
 
@@ -377,6 +566,11 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
 
   // Get working directory from execution session
   const execCwd = runSession?.cwd || ''
+  const existingOutputPaths = outputFileRefs
+    .map((fileRef) => resolveExistingOutputFilePath(fileRef, execCwd))
+    .filter((candidate): candidate is string => Boolean(candidate))
+  const firstLocalOutputPath = existingOutputPaths.find((candidate) => isSendableAttachment(candidate))
+  const followupMediaPath = firstArtifactMediaPath || firstLocalOutputPath || undefined
 
   const buildMsg = (text: string): Message => {
     const msg: Message = { role: 'assistant', text, time: now, kind: 'system' }
@@ -387,6 +581,10 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
   const buildResultBlock = (prefix: string): string => {
     const parts = [prefix]
     if (execCwd) parts.push(`Working directory: \`${execCwd}\``)
+    if (outputFileRefs.length > 0) {
+      parts.push(`Output files:\n${outputFileRefs.slice(0, 8).map((fileRef) => `- \`${fileRef}\``).join('\n')}`)
+    }
+    if (task.completionReportPath) parts.push(`Task report: \`${task.completionReportPath}\``)
     if (resumeLines.length > 0) parts.push(resumeLines.join(' | '))
     parts.push(resultBody || 'No summary.')
     return parts.join('\n\n')
@@ -449,6 +647,8 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     statusLabel,
     summaryText: resultBody || '',
     imageUrl: firstImage?.url,
+    mediaPath: followupMediaPath,
+    mediaFileName: followupMediaPath ? path.basename(followupMediaPath) : undefined,
   })
 }
 
@@ -812,6 +1012,8 @@ export async function processNext() {
           )
           const enrichedResult = formatResultBody(taskResult)
           t2[taskId].result = enrichedResult.slice(0, 4000) || null
+          t2[taskId].artifacts = taskResult.artifacts.slice(0, 24)
+          t2[taskId].outputFiles = extractLikelyOutputFiles(enrichedResult).slice(0, 24)
           t2[taskId].updatedAt = Date.now()
           const report = ensureTaskCompletionReport(t2[taskId])
           if (report?.relativePath) t2[taskId].completionReportPath = report.relativePath

package/src/lib/server/scheduler.ts

@@ -146,7 +146,10 @@ async function tick() {
       existingTask.title = `[Sched] ${schedule.name} (run #${schedule.runNumber})`
       existingTask.result = null
       existingTask.error = null
+      existingTask.outputFiles = []
+      existingTask.artifacts = []
       existingTask.sessionId = null
+      existingTask.completionReportPath = null
       existingTask.updatedAt = now
       existingTask.queuedAt = null
       existingTask.startedAt = null

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

@@ -13,7 +13,7 @@ export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterf
   if (hasTool('manage_chatrooms')) {
     tools.push(
       tool(
-        async ({ action, chatroomId, name, description, agentIds, agentId, message }) => {
+        async ({ action, chatroomId, name, description, agentIds, agentId, message, chatMode, autoAddress }) => {
           try {
             const chatrooms = loadChatrooms() as Record<string, Chatroom>
 
@@ -31,13 +31,20 @@ export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterf
             if (action === 'create_chatroom') {
               const id = genId()
               const agents = loadAgents()
-              const validAgentIds = (agentIds || []).filter((aid: string) => agents[aid])
+              const requestedAgentIds = agentIds || []
+              const invalidAgentIds = requestedAgentIds.filter((aid: string) => !agents[aid])
+              if (invalidAgentIds.length > 0) {
+                return `Error: unknown agent IDs: ${invalidAgentIds.join(', ')}`
+              }
+              const validAgentIds = requestedAgentIds
               const chatroom: Chatroom = {
                 id,
                 name: name || 'New Chatroom',
                 description: description || '',
                 agentIds: validAgentIds,
                 messages: [],
+                chatMode: chatMode === 'parallel' ? 'parallel' : 'sequential',
+                autoAddress: Boolean(autoAddress),
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
               }
@@ -124,6 +131,8 @@ export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterf
             name: z.string().optional().describe('Chatroom name (for create_chatroom)'),
             description: z.string().optional().describe('Chatroom description (for create_chatroom)'),
             agentIds: z.array(z.string()).optional().describe('Initial agent IDs (for create_chatroom)'),
+            chatMode: z.enum(['sequential', 'parallel']).optional().describe('Optional orchestration mode for create_chatroom'),
+            autoAddress: z.boolean().optional().describe('Whether to auto-address all members when no @mention is present'),
             agentId: z.string().optional().describe('Agent ID (for add_agent/remove_agent)'),
             message: z.string().optional().describe('Message text (for send_message)'),
           }),

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

@@ -28,7 +28,7 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
         },
         {
           name: 'context_status',
-          description: 'Check current context window usage for this session. Returns estimated tokens used, provider context limit, percentage used, and compaction strategy recommendation.',
+          description: 'Check how much of my context window I\'ve used. Returns my token usage, the model\'s limit, percentage used, and whether I should compact.',
           schema: z.object({}),
         },
       ),
@@ -108,7 +108,7 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
         },
         {
           name: 'context_summarize',
-          description: 'Summarize and compact the conversation history to free context window space. Old messages are consolidated to memory (preserving decisions, key facts, results) and replaced with a summary. Use context_status first to check if compaction is needed.',
+          description: 'Compact my conversation history to free up context space. I\'ll save important decisions, facts, and results to memory, then replace older messages with a summary. I should check context_status first to see if this is needed.',
           schema: z.object({
             keepLastN: z.number().optional().describe('Number of recent messages to keep (default 10, min 2).'),
           }),

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

@@ -21,6 +21,7 @@ import { buildSubagentTools } from './subagent'
 import { buildCanvasTools } from './canvas'
 import { buildHttpTools } from './http'
 import { buildGitTools } from './git'
+import { buildWalletTools } from './wallet'
 
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
@@ -34,7 +35,9 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
   const cliProcessTimeoutMs = runtime.cliProcessTimeoutMs
   const appSettings = loadSettings()
   const toolPolicy = resolveSessionToolPolicy(enabledTools, appSettings)
-  const activeTools = toolPolicy.enabledTools
+  const activeTools = toolPolicy.enabledTools.includes('shell') && !toolPolicy.enabledTools.includes('process')
+    ? [...toolPolicy.enabledTools, 'process']
+    : toolPolicy.enabledTools
   const hasTool = (toolName: string) => activeTools.includes(toolName)
 
   if (toolPolicy.blockedTools.length > 0) {
@@ -107,6 +110,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildCanvasTools(bctx),
     ...buildHttpTools(bctx),
     ...buildGitTools(bctx),
+    ...buildWalletTools(bctx),
   )
 
   // ---------------------------------------------------------------------------
@@ -158,7 +162,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
       },
       {
         name: 'request_tool_access',
-        description: 'Request access to a tool that is currently disabled. The user will be prompted to grant access, and a follow-up "Continue" message will be sent automatically once granted. End your current response after calling this — do NOT tell the user to "let you know" or ask them to confirm; the continuation is automatic.',
+        description: 'Ask the user for access to a tool I don\'t currently have. They\'ll get a prompt to grant it, and once they do, I\'ll automatically continue where I left off. I should end my current response after calling this — no need to ask the user to confirm, it happens on its own.',
         schema: z.object({
           toolId: z.string().describe('The tool ID to request access for (e.g. manage_tasks, shell, claude_code)'),
           reason: z.string().describe('Brief explanation of why you need this tool'),

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

@@ -187,7 +187,7 @@ export function buildMemoryTools(bctx: ToolBuildContext): StructuredToolInterfac
         },
         {
           name: 'memory_tool',
-          description: 'Store and retrieve long-term memories that persist across sessions. Memories can be shared or agent-scoped. Supports file references, image attachments, and linking memories together with depth traversal. Also supports a cross-agent knowledge base via "knowledge_store" and "knowledge_search". Use "store", "get", "search", "list", "delete", "link", "unlink", "knowledge_store", or "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. 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.'),

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

@@ -49,7 +49,7 @@ export function buildShellTools(bctx: ToolBuildContext): StructuredToolInterface
         },
         {
           name: 'execute_command',
-          description: 'Execute a shell command in the session working directory. This is the PRIMARY tool for running servers, dev servers, installing packages, running scripts, git operations, and any command the user wants to run or test. Use background=true for long-running processes like servers. Supports timeout/yield controls.',
+          description: 'Run a shell command in my working directory. This is how I run servers, install packages, execute scripts, use git, and do anything hands-on. Use background=true for long-running processes like dev servers. Supports timeout/yield controls.',
           schema: z.object({
             command: z.string().describe('The shell command to execute'),
             background: z.boolean().optional().describe('If true, start command in background immediately'),

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

@@ -0,0 +1,124 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { ToolBuildContext } from './context'
+import { loadWallets, loadWalletTransactions } from '../storage'
+import type { AgentWallet, WalletTransaction } from '@/types'
+
+export function buildWalletTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasTool('wallet')) return []
+
+  const agentId = bctx.ctx?.agentId
+
+  function getAgentWallet(): AgentWallet | null {
+    if (!agentId) return null
+    const wallets = loadWallets() as Record<string, AgentWallet>
+    return Object.values(wallets).find((w) => w.agentId === agentId) ?? null
+  }
+
+  return [
+    tool(
+      async ({ action, toAddress, amountSol, memo, limit }) => {
+        const wallet = getAgentWallet()
+        if (!wallet) {
+          return JSON.stringify({ error: 'No wallet linked to this agent. Ask the user to create one in the Wallets section.' })
+        }
+
+        switch (action) {
+          case 'balance': {
+            try {
+              const { getBalance, lamportsToSol } = await import('../solana')
+              const balanceLamports = await getBalance(wallet.publicKey)
+              return JSON.stringify({
+                address: wallet.publicKey,
+                chain: wallet.chain,
+                balanceLamports,
+                balanceSol: lamportsToSol(balanceLamports),
+              })
+            } catch (err: unknown) {
+              return JSON.stringify({ error: `Failed to fetch balance: ${err instanceof Error ? err.message : String(err)}` })
+            }
+          }
+
+          case 'address': {
+            return JSON.stringify({
+              address: wallet.publicKey,
+              chain: wallet.chain,
+            })
+          }
+
+          case 'send': {
+            if (!toAddress) return JSON.stringify({ error: 'toAddress is required for send action' })
+            if (!amountSol || amountSol <= 0) return JSON.stringify({ error: 'amountSol must be positive' })
+
+            const { isValidSolanaAddress, solToLamports, lamportsToSol } = await import('../solana')
+            if (!isValidSolanaAddress(toAddress)) {
+              return JSON.stringify({ error: 'Invalid Solana address' })
+            }
+
+            const amountLamports = solToLamports(amountSol)
+
+            // Check per-tx limit
+            const perTxLimit = wallet.spendingLimitLamports ?? 100_000_000
+            if (amountLamports > perTxLimit) {
+              return JSON.stringify({
+                error: `Amount ${amountSol} SOL exceeds per-transaction limit of ${lamportsToSol(perTxLimit)} SOL`,
+              })
+            }
+
+            // Send via API to enforce all limits and approval flow
+            try {
+              const baseUrl = process.env.NEXTAUTH_URL || `http://localhost:${process.env.PORT || 3456}`
+              const res = await fetch(`${baseUrl}/api/wallets/${wallet.id}/send`, {
+                method: 'POST',
+                headers: {
+                  'Content-Type': 'application/json',
+                  'X-Access-Key': process.env.ACCESS_KEY || '',
+                },
+                body: JSON.stringify({ toAddress, amountLamports, memo }),
+              })
+              const result = await res.json()
+              return JSON.stringify(result)
+            } catch (err: unknown) {
+              return JSON.stringify({ error: `Send failed: ${err instanceof Error ? err.message : String(err)}` })
+            }
+          }
+
+          case 'transactions': {
+            const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
+            const walletTxs = Object.values(allTxs)
+              .filter((tx) => tx.walletId === wallet.id)
+              .sort((a, b) => b.timestamp - a.timestamp)
+              .slice(0, limit ?? 10)
+              .map((tx) => ({
+                id: tx.id,
+                type: tx.type,
+                status: tx.status,
+                amountLamports: tx.amountLamports,
+                toAddress: tx.toAddress,
+                fromAddress: tx.fromAddress,
+                signature: tx.signature || undefined,
+                memo: tx.memo,
+                timestamp: tx.timestamp,
+              }))
+
+            return JSON.stringify({ transactions: walletTxs, count: walletTxs.length })
+          }
+
+          default:
+            return JSON.stringify({ error: `Unknown action: ${action}. Use balance, address, send, or transactions.` })
+        }
+      },
+      {
+        name: 'wallet_tool',
+        description: 'Manage your own crypto wallet. Actions: balance (check your SOL balance), address (get your wallet address), send (send SOL from your wallet — subject to your spending limits and user approval), transactions (view your recent transaction history).',
+        schema: z.object({
+          action: z.enum(['balance', 'address', 'send', 'transactions']).describe('Wallet action to perform'),
+          toAddress: z.string().optional().describe('Recipient Solana address (required for send)'),
+          amountSol: z.number().optional().describe('Amount in SOL to send (required for send)'),
+          memo: z.string().optional().describe('Reason or memo for the transaction'),
+          limit: z.number().optional().describe('Number of transactions to return (default 10, for transactions action)'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -0,0 +1,29 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { dedupeScreenshotMarkdownLines } from './web-output'
+
+describe('dedupeScreenshotMarkdownLines', () => {
+  it('prefers screenshot-* image when both browser-* and screenshot-* variants are present', () => {
+    const parts = [
+      '![Screenshot](/api/uploads/browser-1772498741525.png)',
+      '![Screenshot](/api/uploads/screenshot-1772498741526.png)',
+      'Saved to: example_screenshot.png',
+    ]
+
+    const next = dedupeScreenshotMarkdownLines(parts)
+    assert.deepEqual(next, [
+      '![Screenshot](/api/uploads/screenshot-1772498741526.png)',
+      'Saved to: example_screenshot.png',
+    ])
+  })
+
+  it('keeps single image output untouched', () => {
+    const parts = [
+      '![Screenshot](/api/uploads/browser-1772498741525.png)',
+      'Saved to: example_screenshot.png',
+    ]
+
+    const next = dedupeScreenshotMarkdownLines(parts)
+    assert.deepEqual(next, parts)
+  })
+})

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

@@ -0,0 +1,16 @@
+export function dedupeScreenshotMarkdownLines(parts: string[]): string[] {
+  const imageLineRe = /^!\[[^\]]*]\(\/api\/uploads\/([^)]+)\)$/
+  const imageLines = parts
+    .map((line, index) => ({ line: line.trim(), index }))
+    .map((entry) => {
+      const match = entry.line.match(imageLineRe)
+      return match ? { ...entry, filename: match[1] } : null
+    })
+    .filter((entry): entry is { line: string; index: number; filename: string } => !!entry)
+
+  if (imageLines.length <= 1) return parts
+
+  const preferred = imageLines.find((entry) => !entry.filename.startsWith('browser-')) || imageLines[0]
+  const keepIndex = preferred.index
+  return parts.filter((_, index) => !imageLines.some((entry) => entry.index === index) || index === keepIndex)
+}