@swarmclawai/swarmclaw 0.6.3 → 0.6.6

package/src/components/wallets/wallet-section.tsx

@@ -0,0 +1,100 @@
+'use client'
+
+import { useState, useCallback } from 'react'
+import { api } from '@/lib/api-client'
+import type { AgentWallet, WalletChain } from '@/types'
+
+interface WalletSectionProps {
+  agentId: string
+  wallet: (Omit<AgentWallet, 'encryptedPrivateKey'> & { balanceLamports?: number; balanceSol?: number }) | null
+  onWalletCreated: () => void
+}
+
+export function WalletSection({ agentId, wallet, onWalletCreated }: WalletSectionProps) {
+  const [creating, setCreating] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [copied, setCopied] = useState(false)
+
+  const createWallet = useCallback(async () => {
+    setCreating(true)
+    setError(null)
+    try {
+      await api('POST', '/wallets', { agentId, chain: 'solana' as WalletChain })
+      onWalletCreated()
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err))
+    } finally {
+      setCreating(false)
+    }
+  }, [agentId, onWalletCreated])
+
+  const copyAddress = useCallback(() => {
+    if (!wallet) return
+    navigator.clipboard.writeText(wallet.publicKey)
+    setCopied(true)
+    setTimeout(() => setCopied(false), 2000)
+  }, [wallet])
+
+  return (
+    <div className="mb-8">
+      <div className="flex items-center gap-2 mb-3">
+        <label className="block font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em]">
+          Wallet
+        </label>
+        <span className="px-1.5 py-0.5 rounded-[4px] bg-amber-500/15 text-amber-400 text-[9px] font-600 uppercase tracking-wide">
+          Experimental
+        </span>
+      </div>
+
+      {!wallet ? (
+        <div className="p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50">
+          <p className="text-[12px] text-text-3/70 mb-3">
+            Create a Solana wallet for this agent to hold funds, pay for services, and trade autonomously.
+          </p>
+          <button
+            type="button"
+            onClick={createWallet}
+            disabled={creating}
+            className="px-3 py-1.5 rounded-[8px] bg-accent-soft text-accent-bright text-[11px] font-600 hover:bg-accent-bright/15 transition-all cursor-pointer disabled:opacity-50 border border-accent-bright/20"
+            style={{ fontFamily: 'inherit' }}
+          >
+            {creating ? 'Creating...' : 'Create Wallet'}
+          </button>
+          {error && <p className="text-[11px] text-red-400 mt-2">{error}</p>}
+        </div>
+      ) : (
+        <div className="p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50 space-y-3">
+          <div className="flex items-center gap-2">
+            <span className="text-[10px] text-text-3/60 uppercase tracking-wide font-600">
+              {wallet.chain}
+            </span>
+            <span className="flex-1" />
+            {typeof wallet.balanceSol === 'number' && (
+              <span className="text-[13px] font-600 text-text-1">
+                {wallet.balanceSol.toFixed(4)} SOL
+              </span>
+            )}
+          </div>
+          <div className="flex items-center gap-2">
+            <code className="text-[11px] text-text-3 bg-black/20 px-2 py-1 rounded-[6px] font-mono truncate flex-1">
+              {wallet.publicKey}
+            </code>
+            <button
+              type="button"
+              onClick={copyAddress}
+              className="shrink-0 px-2 py-1 rounded-[6px] text-[10px] text-text-3 hover:text-text-2 border border-white/[0.08] bg-surface transition-colors cursor-pointer"
+              style={{ fontFamily: 'inherit' }}
+            >
+              {copied ? 'Copied!' : 'Copy'}
+            </button>
+          </div>
+          <div className="flex items-center gap-3 text-[10px] text-text-3/60">
+            <span>Limit: {((wallet.spendingLimitLamports ?? 100_000_000) / 1e9).toFixed(2)} SOL/tx</span>
+            <span>Daily: {((wallet.dailyLimitLamports ?? 1_000_000_000) / 1e9).toFixed(1)} SOL</span>
+            <span>{wallet.requireApproval ? 'Approval required' : 'Auto-send'}</span>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}

package/src/hooks/use-media-query.ts

@@ -2,17 +2,43 @@
 
 import { useCallback, useSyncExternalStore } from 'react'
 
+function supportsMatchMedia(): boolean {
+  return typeof window !== 'undefined' && typeof window.matchMedia === 'function'
+}
+
+function getMatch(query: string): boolean {
+  if (!supportsMatchMedia()) return false
+  try {
+    return window.matchMedia(query).matches
+  } catch {
+    return false
+  }
+}
+
 export function useMediaQuery(query: string): boolean {
   const subscribe = useCallback(
     (callback: () => void) => {
-      const mql = window.matchMedia(query)
-      mql.addEventListener('change', callback)
-      return () => mql.removeEventListener('change', callback)
+      if (!supportsMatchMedia()) return () => {}
+
+      let mql: MediaQueryList
+      try {
+        mql = window.matchMedia(query)
+      } catch {
+        return () => {}
+      }
+
+      if (typeof mql.addEventListener === 'function') {
+        mql.addEventListener('change', callback)
+        return () => mql.removeEventListener('change', callback)
+      }
+
+      mql.addListener(callback)
+      return () => mql.removeListener(callback)
     },
     [query],
   )
 
-  const getSnapshot = () => window.matchMedia(query).matches
+  const getSnapshot = () => getMatch(query)
 
   // Return false during SSR — matches initial client render before hydration
   const getServerSnapshot = () => false

package/src/lib/api-client.ts

@@ -1,39 +1,27 @@
+import { fetchWithTimeout } from '@/lib/fetch-timeout'
+import { safeStorageGet, safeStorageSet, safeStorageRemove } from '@/lib/safe-storage'
+
 const ACCESS_KEY_STORAGE = 'sc_access_key'
 const DEFAULT_API_TIMEOUT_MS = 12_000
 const DEFAULT_GET_RETRIES = 2
 const RETRY_DELAY_BASE_MS = 300
 
 export function getStoredAccessKey(): string {
-  if (typeof window === 'undefined') return ''
-  return localStorage.getItem(ACCESS_KEY_STORAGE) || ''
+  return safeStorageGet(ACCESS_KEY_STORAGE) || ''
 }
 
 export function setStoredAccessKey(key: string) {
-  localStorage.setItem(ACCESS_KEY_STORAGE, key)
+  safeStorageSet(ACCESS_KEY_STORAGE, key)
 }
 
 export function clearStoredAccessKey() {
-  localStorage.removeItem(ACCESS_KEY_STORAGE)
+  safeStorageRemove(ACCESS_KEY_STORAGE)
 }
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
-async function fetchWithTimeout(
-  input: RequestInfo | URL,
-  init: RequestInit,
-  timeoutMs: number,
-): Promise<Response> {
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), timeoutMs)
-  try {
-    return await fetch(input, { ...init, signal: controller.signal })
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
 function isAbortError(err: unknown): boolean {
   if (!err || typeof err !== 'object') return false
   return (err as { name?: string }).name === 'AbortError'

package/src/lib/fetch-timeout.ts

@@ -0,0 +1,17 @@
+const MIN_TIMEOUT_MS = 1_000
+
+export async function fetchWithTimeout(
+  input: RequestInfo | URL,
+  init: RequestInit = {},
+  timeoutMs: number,
+): Promise<Response> {
+  const boundedTimeout = Math.max(MIN_TIMEOUT_MS, Math.trunc(timeoutMs))
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), boundedTimeout)
+
+  try {
+    return await fetch(input, { ...init, signal: controller.signal })
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/src/lib/notification-sounds.ts

@@ -1,3 +1,5 @@
+import { safeStorageGet, safeStorageSet } from '@/lib/safe-storage'
+
 let ctx: AudioContext | null = null
 
 function ensureCtx(): AudioContext | null {
@@ -48,11 +50,9 @@ export function playError() {
 const LS_KEY = 'sc_sound_notifications'
 
 export function getSoundEnabled(): boolean {
-  if (typeof window === 'undefined') return false
-  return localStorage.getItem(LS_KEY) === '1'
+  return safeStorageGet(LS_KEY) === '1'
 }
 
 export function setSoundEnabled(v: boolean) {
-  if (typeof window === 'undefined') return
-  localStorage.setItem(LS_KEY, v ? '1' : '0')
+  safeStorageSet(LS_KEY, v ? '1' : '0')
 }

package/src/lib/safe-storage.ts

@@ -0,0 +1,42 @@
+function canUseLocalStorage(): boolean {
+  return typeof window !== 'undefined' && !!window.localStorage
+}
+
+export function safeStorageGet(key: string): string | null {
+  if (!canUseLocalStorage()) return null
+  try {
+    return window.localStorage.getItem(key)
+  } catch {
+    return null
+  }
+}
+
+export function safeStorageSet(key: string, value: string): boolean {
+  if (!canUseLocalStorage()) return false
+  try {
+    window.localStorage.setItem(key, value)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function safeStorageRemove(key: string): boolean {
+  if (!canUseLocalStorage()) return false
+  try {
+    window.localStorage.removeItem(key)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function safeStorageGetJson<T>(key: string, fallback: T): T {
+  const raw = safeStorageGet(key)
+  if (!raw) return fallback
+  try {
+    return JSON.parse(raw) as T
+  } catch {
+    return fallback
+  }
+}

package/src/lib/server/agent-registry.ts

@@ -63,8 +63,8 @@ export function buildAgentAwarenessBlock(excludeId: string): string {
   })
 
   return [
-    '## Available Agents',
+    '## My Colleagues',
+    'These are the other agents I work alongside. I can hand off tasks to any of them if their skills are a better fit:',
     ...lines,
-    'You can delegate tasks to any agent using the delegate_to_agent tool.',
   ].join('\n')
 }

package/src/lib/server/chat-execution.ts

@@ -109,6 +109,21 @@ function collectToolEvent(ev: SSEEvent, bag: MessageToolEvent[]) {
   }
 }
 
+function shouldReplaceRecentAssistantMessage(params: {
+  previous: Message | null | undefined
+  nextToolEvents: MessageToolEvent[]
+  nextKind: Message['kind']
+  now: number
+}): boolean {
+  const { previous, nextToolEvents, nextKind, now } = params
+  if (!previous || previous.role !== 'assistant') return false
+  if (nextToolEvents.length === 0) return false
+  if (previous.kind && nextKind && previous.kind !== nextKind) return false
+  if (typeof previous.time === 'number' && now - previous.time > 45_000) return false
+  const prevTools = Array.isArray(previous.toolEvents) ? previous.toolEvents.length : 0
+  return prevTools === 0
+}
+
 function requestedToolNamesFromMessage(message: string): string[] {
   const lower = message.toLowerCase()
   const candidates = [
@@ -377,6 +392,11 @@ function buildAgentSystemPrompt(session: any): string | undefined {
 
   const settings = loadSettings()
   const parts: string[] = []
+  // Identity block — agent needs to know who it is
+  const identityLines = [`## My Identity`, `My name is ${agent.name}.`]
+  if (agent.description) identityLines.push(agent.description)
+  identityLines.push('I should always refer to myself by this name. I am not "Assistant" — I have my own name and identity.')
+  parts.push(identityLines.join(' '))
   if (settings.userPrompt) parts.push(settings.userPrompt)
   parts.push(buildCurrentDateTimePromptContext())
   if (agent.soul) parts.push(agent.soul)
@@ -1014,14 +1034,26 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       const persistedText = heartbeatClassification === 'strip'
         ? textForPersistence.replace(/HEARTBEAT_OK/gi, '').trim()
         : textForPersistence
-      current.messages.push({
+      const nowTs = Date.now()
+      const nextAssistantMessage: Message = {
         role: 'assistant',
         text: persistedText,
-        time: Date.now(),
+        time: nowTs,
         thinking: thinkingText || undefined,
         toolEvents: toolEvents.length ? toolEvents : undefined,
         kind: persistedKind,
-      })
+      }
+      const previous = current.messages.at(-1)
+      if (shouldReplaceRecentAssistantMessage({
+        previous,
+        nextToolEvents: toolEvents,
+        nextKind: persistedKind,
+        now: nowTs,
+      })) {
+        current.messages[current.messages.length - 1] = nextAssistantMessage
+      } else {
+        current.messages.push(nextAssistantMessage)
+      }
       changed = true
 
       // Conversation tone detection

package/src/lib/server/chatroom-health.ts

@@ -0,0 +1,60 @@
+import { getProvider } from '@/lib/providers'
+import type { Agent } from '@/types'
+import { resolveApiKey } from './chatroom-helpers'
+import { isProviderCoolingDown } from './provider-health'
+
+export interface ChatroomAgentHealthSkip {
+  agentId: string
+  reason: string
+}
+
+export interface ChatroomAgentHealthResult {
+  healthyAgentIds: string[]
+  skipped: ChatroomAgentHealthSkip[]
+}
+
+/**
+ * Filter chatroom participants to agents that are currently executable.
+ * This should never enforce model diversity rules; it only gates hard runtime blockers.
+ */
+export function filterHealthyChatroomAgents(
+  agentIds: string[],
+  agents: Record<string, Agent>,
+): ChatroomAgentHealthResult {
+  const healthyAgentIds: string[] = []
+  const skipped: ChatroomAgentHealthSkip[] = []
+
+  for (const agentId of agentIds) {
+    const agent = agents[agentId]
+    if (!agent) {
+      skipped.push({ agentId, reason: 'agent_not_found' })
+      continue
+    }
+
+    if (isProviderCoolingDown(agent.provider)) {
+      skipped.push({ agentId, reason: `provider_cooling_down:${agent.provider}` })
+      continue
+    }
+
+    const providerInfo = getProvider(agent.provider)
+    if (!providerInfo) {
+      skipped.push({ agentId, reason: `provider_not_configured:${agent.provider}` })
+      continue
+    }
+
+    const apiKey = resolveApiKey(agent.credentialId)
+    if (providerInfo.requiresApiKey && !apiKey) {
+      skipped.push({ agentId, reason: 'missing_api_credentials' })
+      continue
+    }
+    if (providerInfo.requiresEndpoint && !agent.apiEndpoint) {
+      skipped.push({ agentId, reason: 'missing_api_endpoint' })
+      continue
+    }
+
+    healthyAgentIds.push(agentId)
+  }
+
+  return { healthyAgentIds, skipped }
+}
+

package/src/lib/server/chatroom-helpers.test.ts

@@ -0,0 +1,94 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { Agent, Chatroom } from '@/types'
+import { parseMentions, compactChatroomMessages, buildHistoryForAgent } from './chatroom-helpers'
+
+function makeAgents(): Record<string, Agent> {
+  const now = Date.now()
+  return {
+    default: {
+      id: 'default',
+      name: 'Assistant',
+      description: '',
+      systemPrompt: '',
+      provider: 'openai',
+      model: 'gpt-4o',
+      createdAt: now,
+      updatedAt: now,
+    },
+    agent_analyst: {
+      id: 'agent_analyst',
+      name: 'Analyst',
+      description: '',
+      systemPrompt: '',
+      provider: 'openai',
+      model: 'gpt-4o',
+      createdAt: now,
+      updatedAt: now,
+    },
+  }
+}
+
+describe('chatroom-helpers', () => {
+  it('parses mentions with punctuation and agent ids', () => {
+    const agents = makeAgents()
+    const memberIds = ['default', 'agent_analyst']
+    const mentions = parseMentions('Hey @Assistant, can @agent_analyst review this?', agents, memberIds)
+    assert.deepEqual(mentions, ['default', 'agent_analyst'])
+  })
+
+  it('compacts long chatrooms with a persisted summary message', () => {
+    const now = Date.now()
+    const chatroom: Chatroom = {
+      id: 'room-1',
+      name: 'Room',
+      description: '',
+      agentIds: ['default'],
+      messages: Array.from({ length: 120 }, (_, idx) => ({
+        id: `m-${idx}`,
+        senderId: idx % 2 === 0 ? 'user' : 'default',
+        senderName: idx % 2 === 0 ? 'You' : 'Assistant',
+        role: idx % 2 === 0 ? 'user' : 'assistant',
+        text: `message ${idx}`,
+        mentions: [],
+        reactions: [],
+        time: now + idx,
+      })),
+      createdAt: now,
+      updatedAt: now,
+    }
+
+    const changed = compactChatroomMessages(chatroom, 90)
+    assert.equal(changed, true)
+    assert.equal(chatroom.messages.length, 91)
+    assert.equal(chatroom.messages[0].senderId, 'system')
+    assert.match(chatroom.messages[0].text, /^\[Conversation summary\]/)
+  })
+
+  it('only includes attachment-heavy context for recent history entries', () => {
+    const now = Date.now()
+    const chatroom: Chatroom = {
+      id: 'room-2',
+      name: 'Room',
+      agentIds: ['default'],
+      messages: Array.from({ length: 24 }, (_, idx) => ({
+        id: `x-${idx}`,
+        senderId: idx % 2 === 0 ? 'user' : 'default',
+        senderName: idx % 2 === 0 ? 'You' : 'Assistant',
+        role: idx % 2 === 0 ? 'user' : 'assistant',
+        text: `line ${idx}`,
+        mentions: [],
+        reactions: [],
+        time: now + idx,
+        ...(idx < 10 ? { attachedFiles: [`/tmp/file-${idx}.txt`] } : {}),
+      })),
+      createdAt: now,
+      updatedAt: now,
+    }
+
+    const history = buildHistoryForAgent(chatroom, 'default')
+    const attachmentMarkers = history.filter((msg) => msg.text.includes('[Attached:')).length
+    assert.ok(attachmentMarkers <= 6)
+  })
+})
+

package/src/lib/server/chatroom-helpers.ts

@@ -1,5 +1,6 @@
 import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
+import { genId } from '@/lib/id'
 import type { Chatroom, Agent, Session, Message } from '@/types'
 
 /** Resolve API key from an agent's credentialId */
@@ -11,17 +12,36 @@ export function resolveApiKey(credentialId: string | null | undefined): string |
   try { return decryptKey(cred.encryptedKey) } catch { return null }
 }
 
+const COMPACTION_PREFIX = '[Conversation summary]'
+
+function normalizeMentionToken(raw: string): string {
+  return raw
+    .toLowerCase()
+    .replace(/[.,!?;:]+$/g, '')
+    .replace(/\s+/g, '')
+    .trim()
+}
+
+function truncateText(text: string, max: number): string {
+  const compact = String(text || '').replace(/\s+/g, ' ').trim()
+  if (compact.length <= max) return compact
+  return `${compact.slice(0, Math.max(0, max - 3))}...`
+}
+
 /** Parse @mentions from message text, returns matching agentIds */
 export function parseMentions(text: string, agents: Record<string, Agent>, memberIds: string[]): string[] {
   if (/@all\b/i.test(text)) return [...memberIds]
-  const mentionPattern = /@(\S+)/g
+  const mentionPattern = /(?:^|[\s(])@([a-zA-Z0-9._-]+)/g
   const mentioned: string[] = []
   let match: RegExpExecArray | null
   while ((match = mentionPattern.exec(text)) !== null) {
-    const name = match[1].toLowerCase()
+    const token = normalizeMentionToken(match[1] || '')
+    if (!token) continue
     for (const id of memberIds) {
       const agent = agents[id]
-      if (agent && agent.name.toLowerCase().replace(/\s+/g, '') === name) {
+      const normalizedName = normalizeMentionToken(agent?.name || '')
+      const normalizedId = normalizeMentionToken(id)
+      if (agent && (normalizedName === token || normalizedId === token)) {
         if (!mentioned.includes(id)) mentioned.push(id)
       }
     }
@@ -29,6 +49,34 @@ export function parseMentions(text: string, agents: Record<string, Agent>, membe
   return mentioned
 }
 
+/**
+ * Persisted chatroom compaction so long-lived rooms stay inside context budgets.
+ * Returns true when the message list was compacted.
+ */
+export function compactChatroomMessages(chatroom: Chatroom, keepLast = 90): boolean {
+  const maxKeep = Math.max(20, keepLast)
+  if (!Array.isArray(chatroom.messages) || chatroom.messages.length <= maxKeep) return false
+
+  const dropped = chatroom.messages.length - maxKeep
+  const kept = chatroom.messages.slice(-maxKeep).filter((msg, idx) => {
+    if (idx !== 0) return true
+    return !(msg.senderId === 'system' && typeof msg.text === 'string' && msg.text.startsWith(COMPACTION_PREFIX))
+  })
+  const summaryMessage = {
+    id: genId(),
+    senderId: 'system',
+    senderName: 'System',
+    role: 'assistant' as const,
+    text: `${COMPACTION_PREFIX} ${dropped} earlier chat message(s) were condensed to keep the room responsive.`,
+    mentions: [],
+    reactions: [],
+    time: Date.now(),
+  }
+  chatroom.messages = [summaryMessage, ...kept]
+  chatroom.updatedAt = Date.now()
+  return true
+}
+
 /** Build chatroom context as a system prompt addendum with agent profiles and collaboration guidelines */
 export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<string, Agent>, agentId: string): string {
   const selfAgent = agents[agentId]
@@ -47,9 +95,10 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
     .filter(Boolean)
     .join('\n')
 
-  const recentMessages = chatroom.messages.slice(-30).map((m) => {
-    return `[${m.senderName}]: ${m.text}`
-  }).join('\n')
+  const recentMessages = chatroom.messages
+    .slice(-8)
+    .map((m) => `[${m.senderName}]: ${truncateText(m.text, 180)}`)
+    .join('\n')
 
   const memberCount = chatroom.agentIds.length
   const otherNames = chatroom.agentIds
@@ -70,6 +119,8 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
     '- **You are in a group chat.** Talk like you are in a real-time conversation with teammates — be direct, casual, and concise.',
     '- **Be yourself.** Respond with personality. Don\'t give generic "let me know if you need anything" responses. Actually engage with what was said.',
     '- **Answer the question or react to the message.** If someone says "how are you doing?" just answer naturally. If someone asks a question you can help with, help directly.',
+    '- **Do not meta-narrate user intent.** Avoid phrases like "it seems like you\'re trying to..." — respond directly to what they said.',
+    '- **Handle greetings like a human.** For "hello", "how are you", or light check-ins, give a normal conversational reply instead of tool/process commentary.',
     '- **Keep responses short** unless depth is needed. A few sentences is usually enough. This is a chat, not an essay.',
     '- **@mention teammates** only when you genuinely need their specific expertise. Don\'t tag people just to be polite.',
     '- **Don\'t narrate your capabilities** unless asked. Just demonstrate them by doing things.',
@@ -121,10 +172,12 @@ export function buildAgentSystemPromptForChatroom(agent: Agent): string {
 
 /** Convert chatroom messages to Message history format for LLM */
 export function buildHistoryForAgent(chatroom: Chatroom, agentId: string, imagePath?: string, attachedFiles?: string[]): Message[] {
-  const history = chatroom.messages.slice(-50).map((m) => {
+  const recentMessages = chatroom.messages.slice(-24)
+  const includeAttachmentsFrom = Math.max(0, recentMessages.length - 6)
+  const history = recentMessages.map((m, idx) => {
     let msgText = `[${m.senderName}]: ${m.text}`
-    // Include attachment info in history
-    if (m.attachedFiles?.length) {
+    const includeAttachments = idx >= includeAttachmentsFrom
+    if (includeAttachments && m.attachedFiles?.length) {
       const names = m.attachedFiles.map((f) => f.split('/').pop()).join(', ')
       msgText += `\n[Attached: ${names}]`
     }
@@ -132,8 +185,8 @@ export function buildHistoryForAgent(chatroom: Chatroom, agentId: string, imageP
       role: m.senderId === agentId ? 'assistant' as const : 'user' as const,
       text: msgText,
       time: m.time,
-      ...(m.imagePath ? { imagePath: m.imagePath } : {}),
-      ...(m.attachedFiles ? { attachedFiles: m.attachedFiles } : {}),
+      ...(includeAttachments && m.imagePath ? { imagePath: m.imagePath } : {}),
+      ...(includeAttachments && m.attachedFiles ? { attachedFiles: m.attachedFiles } : {}),
     }
   })
   // Pass through imagePath/attachedFiles from the current message to the last history entry