fix: chat architecture bugs — double response, unbounded caches, missing newline

- Fix critical double response in history endpoint (res.send + res.json crashed)
- Cap currentWork items at 200 to prevent unbounded growth during long runs
- Cap historyCache at 50 entries with LRU eviction
- Add periodic cleanup for historyResponseCache (30s expiry)
- Add tests for SSE client tracking, work item capping, live state cleanup
- Fix syntax error (missing newline) that crashed server on hot-reload

Author: Hex

packages/server/src/agent-backend/openclaw.ts

@@ -116,7 +116,9 @@ export function createOpenClawBackend(config: OpenClawConfig): AgentBackend & {
   const pending = new Map<string, { resolve: (v: unknown) => void; reject: (e: Error) => void }>()
 
   // ── History cache: keyed by sessionKey, invalidated by file mtime+size ──
+  // Capped to 50 entries to prevent unbounded growth
   const historyCache = new Map<string, { turns: ParsedTurn[]; hasMore: boolean; mtime: number; size: number }>()
+  const HISTORY_CACHE_MAX = 50
   let msgId = 0
 
   function getKeyPath(): string {
@@ -810,6 +812,11 @@ export function createOpenClawBackend(config: OpenClawConfig): AgentBackend & {
               mtime: stat.mtimeMs,
               size: stat.size
             })
+            // Evict oldest entries if cache is too large
+            if (historyCache.size > HISTORY_CACHE_MAX) {
+              const firstKey = historyCache.keys().next().value
+              if (firstKey) historyCache.delete(firstKey)
+            }
 
             return { turns, hasMore }
           }

packages/server/src/chat/chat.test.ts

@@ -345,4 +345,66 @@ describe('§2.4 Chat Module (Server)', () => {
     expect(chatModule.getSessionKeyForThread('unknown-thread')).toBeTruthy()
     expect(chatModule.getSessionKeyForThread('unknown-thread')).toMatch(/^agent:main:thread:unknown-thread$/)
   })
+
+  it('MUST track and untrack SSE clients correctly', () => {
+    chatModule.trackSSEClient('thread-1')
+    chatModule.trackSSEClient('thread-1')
+    chatModule.trackSSEClient('thread-2')
+    chatModule.untrackSSEClient('thread-1')
+    // Still one client on thread-1
+    chatModule.untrackSSEClient('thread-1')
+    // Zero clients on thread-1
+    chatModule.untrackSSEClient('thread-1')
+    // Should not go negative — just stays at 0
+    chatModule.untrackSSEClient('thread-2')
+  })
+
+  it('MUST cap accumulated work items at 200 to prevent unbounded growth', () => {
+    // Set up a thread mapping
+    const sessionKey = chatModule.resolveSessionKey('thread-cap')
+
+    // Simulate 250 work events
+    const statusHandlers = backend._handlers.get('chat.work') ?? []
+    for (let i = 0; i < 250; i++) {
+      for (const handler of statusHandlers) {
+        handler({ sessionKey, work: { type: 'tool_call', name: `tool-${i}`, timestamp: Date.now() } })
+      }
+    }
+
+    const live = chatModule.getLiveState('thread-cap')
+    expect(live.work).toBeTruthy()
+    expect(live.work!.length).toBeLessThanOrEqual(200)
+  })
+
+  it('MUST clear live state on chat.turn event', () => {
+    const sessionKey = chatModule.resolveSessionKey('thread-clear')
+
+    // Simulate status + work + stream events
+    const statusHandlers = backend._handlers.get('chat.status') ?? []
+    for (const h of statusHandlers) h({ sessionKey, status: 'working' })
+
+    const workHandlers = backend._handlers.get('chat.work') ?? []
+    for (const h of workHandlers) h({ sessionKey, work: { type: 'tool_call', name: 'test', timestamp: Date.now() } })
+
+    const streamHandlers = backend._handlers.get('chat.stream') ?? []
+    for (const h of streamHandlers) h({ sessionKey, text: 'hello' })
+
+    let live = chatModule.getLiveState('thread-clear')
+    expect(live.status).toBe('working')
+    expect(live.work?.length).toBeGreaterThan(0)
+    expect(live.streamText).toBeTruthy()
+
+    // Now emit turn event — should clear all live state
+    const turnHandlers = backend._handlers.get('chat.turn') ?? []
+    for (const h of turnHandlers)
+      h({
+        sessionKey,
+        turn: { role: 'assistant', content: 'done', workItems: [], thinkingBlocks: [], timestamp: Date.now() }
+      })
+
+    live = chatModule.getLiveState('thread-clear')
+    expect(live.status).toBeUndefined()
+    expect(live.work).toBeUndefined()
+    expect(live.streamText).toBeUndefined()
+  })
 })

packages/server/src/chat/chat.ts

@@ -211,6 +211,8 @@ export function createChatModule(
         } else if (eventName === 'chat.work') {
           const items = currentWork.get(threadKey) ?? []
           items.push(data.work)
+          // Cap accumulated work items to prevent unbounded growth during long agent runs
+          if (items.length > 200) items.splice(0, items.length - 200)
           currentWork.set(threadKey, items)
           // Clear accumulated stream text when a tool call arrives —
           // the text before the tool call was captured as a thinking item

packages/server/src/chat/routes.ts

@@ -94,6 +94,17 @@ export function createChatRoutes(chatModule: ChatModule, backend: AgentBackend,
   const historyResponseCache = new Map<string, { data: any; timestamp: number }>()
   const HISTORY_CACHE_TTL = 5000 // 5s — fresh enough for human perception, avoids constant re-parse
 
+  // Periodic cleanup of stale cache entries (prevent unbounded growth)
+  setInterval(() => {
+    const now = Date.now()
+    for (const [key, entry] of historyResponseCache) {
+      if (now - entry.timestamp > HISTORY_CACHE_TTL * 6) {
+        // 30s expiry
+        historyResponseCache.delete(key)
+      }
+    }
+  }, 30_000)
+
   router.get('/api/threads/:threadKey/history', async (req, res) => {
     const threadKey = req.params.threadKey
     const sessionKey = chatModule.resolveSessionKey(threadKey)
@@ -114,7 +125,6 @@ export function createChatRoutes(chatModule: ChatModule, backend: AgentBackend,
       const json = JSON.stringify(data)
       res.setHeader('Content-Type', 'application/json')
       res.send(json)
-      res.json({ turns: result.turns, hasMore: result.hasMore })
     } catch {
       res.json({ turns: [], hasMore: false })
     }