@swarmclawai/swarmclaw 0.6.2 → 0.6.3

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

@@ -6,6 +6,17 @@ import { UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
 import { safePath, truncate, listDirRecursive, MAX_OUTPUT, MAX_FILE } from './context'
 
+const SEND_FILE_DEDUPE_TTL_MS = 30_000
+const recentSendFileResults = new Map<string, { at: number; output: string; uploadPath: string }>()
+
+function pruneRecentSendFileCache(now: number): void {
+  for (const [key, entry] of recentSendFileResults.entries()) {
+    if (now - entry.at > SEND_FILE_DEDUPE_TTL_MS || !fs.existsSync(entry.uploadPath)) {
+      recentSendFileResults.delete(key)
+    }
+  }
+}
+
 export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
 
@@ -197,6 +208,8 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
       tool(
         async ({ filePath: rawPath }) => {
           try {
+            const now = Date.now()
+            pruneRecentSendFileCache(now)
             // Resolve relative to cwd, but also allow absolute paths
             const resolved = path.isAbsolute(rawPath) ? rawPath : path.resolve(bctx.cwd, rawPath)
             if (!fs.existsSync(resolved)) return `Error: file not found: ${rawPath}`
@@ -204,6 +217,13 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
             if (stat.isDirectory()) return `Error: cannot send a directory. Send individual files instead.`
             if (stat.size > 100 * 1024 * 1024) return `Error: file too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 100MB.`
 
+            const sessionId = bctx.ctx?.sessionId || 'no-session'
+            const dedupeKey = `${sessionId}|${resolved}`
+            const cached = recentSendFileResults.get(dedupeKey)
+            if (cached && now - cached.at <= SEND_FILE_DEDUPE_TTL_MS && fs.existsSync(cached.uploadPath)) {
+              return cached.output
+            }
+
             const ext = path.extname(resolved).slice(1).toLowerCase()
             const basename = path.basename(resolved)
             const filename = `${Date.now()}-${basename}`
@@ -212,14 +232,13 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
 
             const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico']
             const VIDEO_EXTS = ['mp4', 'webm', 'mov', 'avi', 'mkv']
+            const AUDIO_EXTS = ['mp3', 'ogg', 'wav', 'aac', 'm4a', 'opus']
 
-            if (IMAGE_EXTS.includes(ext)) {
-              return `![${basename}](/api/uploads/${filename})`
-            } else if (VIDEO_EXTS.includes(ext)) {
-              return `![${basename}](/api/uploads/${filename})`
-            } else {
-              return `[Download ${basename}](/api/uploads/${filename})`
-            }
+            const output = (IMAGE_EXTS.includes(ext) || VIDEO_EXTS.includes(ext) || AUDIO_EXTS.includes(ext))
+              ? `![${basename}](/api/uploads/${filename})`
+              : `[Download ${basename}](/api/uploads/${filename})`
+            recentSendFileResults.set(dedupeKey, { at: now, output, uploadPath: dest })
+            return output
           } catch (err: unknown) {
             return `Error sending file: ${err instanceof Error ? err.message : String(err)}`
           }

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

@@ -278,10 +278,9 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
 
       if (Array.isArray(content)) {
         const parts: string[] = []
-        let hasBinaryImage = false
+        const contentHasBinaryImage = content.some((c) => c.type === 'image' && !!c.data)
         for (const c of content) {
           if (c.type === 'image' && c.data) {
-            hasBinaryImage = true
             const imageBuffer = Buffer.from(c.data, 'base64')
             const filename = `screenshot-${Date.now()}.png`
             const filepath = path.join(UPLOAD_DIR, filename)
@@ -306,8 +305,8 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
               if (fs.existsSync(srcPath)) {
                 const ext = path.extname(srcPath).slice(1).toLowerCase()
                 const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp']
-                // Skip file-path images if we already have a binary image (avoids duplicates)
-                if (IMAGE_EXTS.includes(ext) && hasBinaryImage) {
+                // Skip file-path images whenever MCP already returned image binary payloads.
+                if (IMAGE_EXTS.includes(ext) && contentHasBinaryImage) {
                   parts.push(isError ? text : cleanPlaywrightOutput(text))
                 } else {
                   const filename = `browser-${Date.now()}.${ext}`

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

@@ -127,6 +127,12 @@ function buildAgenticExecutionPolicy(opts: {
     opts.enabledTools.includes('manage_connectors')
       ? 'If the user wants proactive outreach (e.g., WhatsApp updates), configure connectors and pair with schedules/tasks to deliver status updates.'
       : '',
+    opts.enabledTools.includes('manage_connectors')
+      ? 'Autonomous outreach is allowed for significant events (completed/failed tasks, blockers, deadlines, meaningful reminders from memory). Avoid casual or repetitive check-ins.'
+      : '',
+    opts.enabledTools.includes('manage_connectors')
+      ? 'When you proactively message through connectors, keep it concise and purposeful, and avoid sending duplicate updates about the same event.'
+      : '',
     opts.enabledTools.includes('manage_sessions')
       ? 'When coordinating platform work, inspect existing sessions and avoid duplicating active efforts.'
       : '',
@@ -164,6 +170,7 @@ function buildAgenticExecutionPolicy(opts: {
     'The test: if you saw this message from a friend, would you feel compelled to type something back? If not, NO_MESSAGE.',
     'Ask for confirmation only for high-risk or irreversible actions. For normal low-risk research/build steps, proceed autonomously.',
     'Default behavior is execution, not interrogation: do not ask exploratory clarification questions when a safe next action exists.',
+    'Do not end every response with a question. Use declarative completion statements by default, and only ask a question when a concrete missing detail blocks the next action.',
     'Do not pause for a "continue" confirmation after the user has already asked you to execute a goal. Keep moving until blocked by permissions, missing credentials, or hard tool failures.',
     'Never repeat one-time side effects that are already complete (for example creating the same schedule/task again). Verify state first, then either continue execution or reply HEARTBEAT_OK.',
     'For main-loop tick messages that begin with "SWARM_MAIN_MISSION_TICK" or "SWARM_MAIN_AUTO_FOLLOWUP", follow that response contract exactly and include one valid [MAIN_LOOP_META] JSON line when you are not returning HEARTBEAT_OK.',