@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/fetch-timeout.test.ts

@@ -0,0 +1,54 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { fetchWithTimeout } from './fetch-timeout'
+
+const originalFetch = global.fetch
+const originalSetTimeout = global.setTimeout
+const originalClearTimeout = global.clearTimeout
+
+test.afterEach(() => {
+  global.fetch = originalFetch
+  global.setTimeout = originalSetTimeout
+  global.clearTimeout = originalClearTimeout
+})
+
+test('fetchWithTimeout throws TimeoutError with a clear message on timeout', async () => {
+  global.setTimeout = (((callback: (...args: unknown[]) => void) => {
+    queueMicrotask(() => callback())
+    return 1 as unknown as ReturnType<typeof setTimeout>
+  }) as typeof setTimeout)
+  global.clearTimeout = (() => {}) as typeof clearTimeout
+  global.fetch = (((_input: RequestInfo | URL, init?: RequestInit) => new Promise<Response>((_resolve, reject) => {
+    const onAbort = () => reject(init?.signal?.reason ?? new DOMException('Aborted', 'AbortError'))
+    if (init?.signal?.aborted) onAbort()
+    else init?.signal?.addEventListener('abort', onAbort, { once: true })
+  })) as typeof fetch)
+
+  await assert.rejects(
+    () => fetchWithTimeout('/slow', {}, 5_000),
+    (err: unknown) => {
+      assert.ok(err instanceof Error)
+      assert.equal(err.name, 'TimeoutError')
+      assert.match(err.message, /5000ms/)
+      return true
+    },
+  )
+})
+
+test('fetchWithTimeout preserves caller abort signals', async () => {
+  const controller = new AbortController()
+  const expectedError = new DOMException('Manual cancel', 'AbortError')
+  controller.abort(expectedError)
+  global.fetch = (((_input: RequestInfo | URL, init?: RequestInit) => {
+    return Promise.reject(init?.signal?.reason ?? expectedError)
+  }) as typeof fetch)
+
+  await assert.rejects(
+    () => fetchWithTimeout('/aborted', { signal: controller.signal }, 5_000),
+    (err: unknown) => {
+      assert.strictEqual(err, expectedError)
+      return true
+    },
+  )
+})

package/src/lib/fetch-timeout.ts

@@ -1,16 +1,73 @@
 const MIN_TIMEOUT_MS = 1_000
 
+function createTimeoutError(timeoutMs: number): Error {
+  const error = new Error(`Request timed out after ${timeoutMs}ms`)
+  error.name = 'TimeoutError'
+  return error
+}
+
+function abortWithReason(controller: AbortController, reason: unknown): void {
+  try {
+    controller.abort(reason)
+  } catch {
+    controller.abort()
+  }
+}
+
+function combineAbortSignals(signals: AbortSignal[]): AbortSignal {
+  if (signals.length === 1) return signals[0]
+  if (typeof AbortSignal.any === 'function') return AbortSignal.any(signals)
+
+  const controller = new AbortController()
+  const listeners = new Map<AbortSignal, () => void>()
+  const abortFrom = (signal: AbortSignal) => {
+    for (const [candidate, listener] of listeners.entries()) {
+      candidate.removeEventListener('abort', listener)
+    }
+    abortWithReason(controller, signal.reason)
+  }
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      abortFrom(signal)
+      break
+    }
+    const listener = () => abortFrom(signal)
+    listeners.set(signal, listener)
+    signal.addEventListener('abort', listener, { once: true })
+  }
+
+  return controller.signal
+}
+
+export function isAbortError(err: unknown): boolean {
+  return Boolean(err) && typeof err === 'object' && (err as { name?: string }).name === 'AbortError'
+}
+
+export function isTimeoutError(err: unknown): boolean {
+  return Boolean(err) && typeof err === 'object' && (err as { name?: string }).name === 'TimeoutError'
+}
+
 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)
+  const timeoutController = new AbortController()
+  const timeoutError = createTimeoutError(boundedTimeout)
+  const signal = init.signal
+    ? combineAbortSignals([init.signal, timeoutController.signal])
+    : timeoutController.signal
+  const timer = setTimeout(() => abortWithReason(timeoutController, timeoutError), boundedTimeout)
 
   try {
-    return await fetch(input, { ...init, signal: controller.signal })
+    return await fetch(input, { ...init, signal })
+  } catch (err) {
+    if (timeoutController.signal.aborted && isTimeoutError(timeoutController.signal.reason)) {
+      throw timeoutController.signal.reason
+    }
+    throw err
   } finally {
     clearTimeout(timer)
   }

package/src/lib/live-tool-events.test.ts

@@ -0,0 +1,77 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { applyStreamingToolCall, applyStreamingToolResult, isLikelyToolErrorOutput } from './live-tool-events'
+
+describe('live tool events', () => {
+  it('dedupes consecutive identical pending tool calls', () => {
+    const first = applyStreamingToolCall([], {
+      toolName: 'browser',
+      toolInput: '{"action":"navigate","url":"https://example.com"}',
+      toolCallId: 'call-1',
+    }, 'fallback-1')
+
+    const second = applyStreamingToolCall(first, {
+      toolName: 'browser',
+      toolInput: '{"action":"navigate","url":"https://example.com"}',
+      toolCallId: 'call-1',
+    }, 'fallback-2')
+
+    assert.equal(second.length, 1)
+    assert.equal(second[0]?.id, 'call-1')
+  })
+
+  it('matches parallel same-tool results by toolCallId', () => {
+    const withCalls = applyStreamingToolCall(
+      applyStreamingToolCall([], {
+        toolName: 'read_file',
+        toolInput: '{"path":"a.txt"}',
+        toolCallId: 'call-a',
+      }, 'fallback-a'),
+      {
+        toolName: 'read_file',
+        toolInput: '{"path":"b.txt"}',
+        toolCallId: 'call-b',
+      },
+      'fallback-b',
+    )
+
+    const withFirstResult = applyStreamingToolResult(withCalls, {
+      toolName: 'read_file',
+      toolOutput: 'contents of b',
+      toolCallId: 'call-b',
+    })
+    const withBothResults = applyStreamingToolResult(withFirstResult, {
+      toolName: 'read_file',
+      toolOutput: 'contents of a',
+      toolCallId: 'call-a',
+    })
+
+    assert.equal(withBothResults[0]?.output, 'contents of a')
+    assert.equal(withBothResults[0]?.status, 'done')
+    assert.equal(withBothResults[1]?.output, 'contents of b')
+    assert.equal(withBothResults[1]?.status, 'done')
+  })
+
+  it('uses fallback matching when toolCallId is missing', () => {
+    const withCall = applyStreamingToolCall([], {
+      toolName: 'browser',
+      toolInput: '{"action":"navigate","url":"https://example.com"}',
+    }, 'fallback-nav')
+
+    const withResult = applyStreamingToolResult(withCall, {
+      toolName: 'browser',
+      toolOutput: 'navigated successfully',
+    })
+
+    assert.equal(withResult[0]?.id, 'fallback-nav')
+    assert.equal(withResult[0]?.status, 'done')
+    assert.equal(withResult[0]?.output, 'navigated successfully')
+  })
+
+  it('detects common tool error outputs', () => {
+    assert.equal(isLikelyToolErrorOutput('Error: command failed'), true)
+    assert.equal(isLikelyToolErrorOutput('timeout waiting for response'), true)
+    assert.equal(isLikelyToolErrorOutput('File written successfully'), false)
+  })
+})

package/src/lib/live-tool-events.ts

@@ -0,0 +1,73 @@
+import type { SSEEvent } from '@/types'
+
+export interface StreamingToolEvent {
+  id: string
+  name: string
+  input: string
+  output?: string
+  status: 'running' | 'done' | 'error'
+  toolCallId?: string
+}
+
+export function isLikelyToolErrorOutput(output: string): boolean {
+  const trimmed = output.trim()
+  return /^(Error:|error:|ECONNREFUSED|ETIMEDOUT|timeout|failed)/i.test(trimmed)
+    || output.includes('ECONNREFUSED')
+    || output.includes('ETIMEDOUT')
+    || output.includes('Error:')
+}
+
+export function applyStreamingToolCall(
+  events: StreamingToolEvent[],
+  ev: Pick<SSEEvent, 'toolName' | 'toolInput' | 'toolCallId'>,
+  fallbackId: string,
+): StreamingToolEvent[] {
+  const previous = events[events.length - 1]
+  const name = ev.toolName || 'unknown'
+  const input = ev.toolInput || ''
+
+  if (
+    previous
+    && previous.name === name
+    && previous.input === input
+    && previous.status === 'running'
+    && previous.toolCallId === (ev.toolCallId || previous.toolCallId)
+  ) {
+    return events
+  }
+
+  return [...events, {
+    id: ev.toolCallId || fallbackId,
+    name,
+    input,
+    status: 'running',
+    toolCallId: ev.toolCallId,
+  }]
+}
+
+export function applyStreamingToolResult(
+  events: StreamingToolEvent[],
+  ev: Pick<SSEEvent, 'toolName' | 'toolOutput' | 'toolCallId'>,
+): StreamingToolEvent[] {
+  const index = ev.toolCallId
+    ? events.findLastIndex((entry) => entry.toolCallId === ev.toolCallId && entry.status === 'running')
+    : events.findLastIndex((entry) => entry.name === (ev.toolName || 'unknown') && entry.status === 'running')
+
+  if (index === -1) return events
+
+  const output = ev.toolOutput || ''
+  const nextStatus = isLikelyToolErrorOutput(output) ? 'error' : 'done'
+  const current = events[index]
+
+  if (current.output === output && current.status === nextStatus) {
+    return events
+  }
+
+  const next = [...events]
+  next[index] = {
+    ...current,
+    output,
+    status: nextStatus,
+  }
+  return next
+}

package/src/lib/local-observability.test.ts

@@ -64,10 +64,10 @@ describe('local observability', () => {
   })
 
   it('detects localhost browser hosts', () => {
-    globalThis.window = { location: { hostname: 'localhost' } } as Window
+    globalThis.window = { location: { hostname: "localhost" } } as any
     assert.equal(isLocalhostBrowser(), true)
 
-    globalThis.window = { location: { hostname: 'swarmclaw.ai' } } as Window
+    globalThis.window = { location: { hostname: "swarmclaw.ai" } } as any
     assert.equal(isLocalhostBrowser(), false)
   })
 })

package/src/lib/openclaw-endpoint.test.ts

@@ -5,7 +5,7 @@ import {
   isLocalOpenClawEndpoint,
   normalizeOpenClawEndpoint,
   normalizeProviderEndpoint,
-} from './openclaw-endpoint.ts'
+} from './openclaw-endpoint'
 
 test('normalizeOpenClawEndpoint handles ws/http/path variants', () => {
   assert.equal(

package/src/lib/providers/anthropic.ts

@@ -2,6 +2,7 @@ import fs from 'fs'
 import https from 'https'
 import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS } from './provider-defaults'
+import { resolveImagePath } from '@/lib/server/resolve-image'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
@@ -24,9 +25,9 @@ function fileToContentBlocks(filePath: string): any[] {
   return [{ type: 'text', text: `[Attached file: ${filePath.split('/').pop()}]` }]
 }
 
-export function streamAnthropicChat({ session, message, imagePath, imageUrl, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
+export function streamAnthropicChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise((resolve) => {
-    const messages = buildMessages(session, message, imagePath, loadHistory, imageUrl)
+    const messages = buildMessages(session, message, imagePath, loadHistory)
     const model = session.model || 'claude-sonnet-4-6'
     let usageInput = 0
     let usageOutput = 0
@@ -136,30 +137,25 @@ export function streamAnthropicChat({ session, message, imagePath, imageUrl, api
   })
 }
 
-function urlToImageBlock(url: string): { type: string; source: { type: string; url: string } } {
-  return { type: 'image', source: { type: 'url', url } }
-}
-
-function buildMessages(session: any, message: string, imagePath: string | undefined, loadHistory: (id: string) => any[], imageUrl?: string) {
-  const msgs: Array<{ role: string; content: any }> = []
+function buildMessages(session: Record<string, unknown> & { id: string }, message: string, imagePath: string | undefined, loadHistory: (id: string) => Record<string, unknown>[]) {
+  const msgs: Array<{ role: string; content: unknown }> = []
 
   if (loadHistory) {
     const history = loadHistory(session.id).slice(-40)
     for (const m of history) {
-      if (m.role === 'user' && (m.imagePath || m.imageUrl)) {
-        const blocks = m.imagePath ? fileToContentBlocks(m.imagePath) : []
-        if (m.imageUrl) blocks.push(urlToImageBlock(m.imageUrl))
+      const histImagePath = resolveImagePath(m.imagePath as string | undefined, m.imageUrl as string | undefined)
+      if (m.role === 'user' && histImagePath) {
+        const blocks = fileToContentBlocks(histImagePath)
         msgs.push({ role: 'user', content: [...blocks, { type: 'text', text: m.text }] })
       } else {
-        msgs.push({ role: m.role, content: m.text })
+        msgs.push({ role: m.role as string, content: m.text })
       }
     }
   }
 
-  // Current message with optional attachment
-  if (imagePath || imageUrl) {
-    const blocks = imagePath ? fileToContentBlocks(imagePath) : []
-    if (imageUrl) blocks.push(urlToImageBlock(imageUrl))
+  // Current message with optional attachment (imagePath already resolved by caller)
+  if (imagePath) {
+    const blocks = fileToContentBlocks(imagePath)
     msgs.push({ role: 'user', content: [...blocks, { type: 'text', text: message }] })
   } else {
     msgs.push({ role: 'user', content: message })

package/src/lib/providers/index.ts

@@ -5,6 +5,8 @@ import { streamOpenAiChat } from './openai'
 import { streamOllamaChat } from './ollama'
 import { streamAnthropicChat } from './anthropic'
 import { streamOpenClawChat } from './openclaw'
+import { errorMessage } from '../shared-utils'
+import { sleep } from '@/lib/shared-utils'
 import type { ProviderInfo, ProviderConfig as CustomProviderConfig, ProviderType } from '../../types'
 
 const RETRYABLE_STATUS_CODES = [401, 429, 500, 502, 503]
@@ -392,7 +394,7 @@ export async function streamChatWithFailover(
       lastError = err
       const errObj = err as Record<string, unknown>
       const statusCode = (typeof errObj?.status === 'number' ? errObj.status : typeof errObj?.statusCode === 'number' ? errObj.statusCode : 0) as number
-      const errMessage = err instanceof Error ? err.message : String(err)
+      const errMessage = errorMessage(err)
       const isRetryable = RETRYABLE_STATUS_CODES.includes(statusCode)
         || errMessage?.includes('rate limit')
         || errMessage?.includes('Rate limit')
@@ -409,7 +411,7 @@ export async function streamChatWithFailover(
         // Exponential backoff for rate-limit / server errors (skip for auth rotation)
         if (statusCode !== 401) {
           const delay = Math.min(500 * Math.pow(2, i), 8000)
-          await new Promise((r) => setTimeout(r, delay))
+          await sleep(delay)
         }
         continue
       }

package/src/lib/providers/ollama.ts

@@ -3,6 +3,7 @@ import http from 'http'
 import https from 'https'
 import type { StreamChatOptions } from './index'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
+import { resolveImagePath } from '@/lib/server/resolve-image'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
@@ -144,20 +145,22 @@ function fileToOllamaMsg(text: string, filePath?: string): { content: string; im
   return { content: `[Attached file: ${filePath.split('/').pop()}]\n\n${text}` }
 }
 
-function buildMessages(session: any, message: string, imagePath: string | undefined, loadHistory: (id: string) => any[]) {
+function buildMessages(session: Record<string, unknown>, message: string, imagePath: string | undefined, loadHistory: (id: string) => Record<string, unknown>[]) {
   const msgs: Array<{ role: string; content: string; images?: string[] }> = []
 
   if (loadHistory) {
-    const history = loadHistory(session.id).slice(-40)
+    const history = loadHistory(session.id as string).slice(-40)
     for (const m of history) {
-      if (m.role === 'user' && m.imagePath) {
-        msgs.push({ role: 'user', ...fileToOllamaMsg(m.text, m.imagePath) })
+      const histImagePath = resolveImagePath(m.imagePath as string | undefined, m.imageUrl as string | undefined)
+      if (m.role === 'user' && histImagePath) {
+        msgs.push({ role: 'user', ...fileToOllamaMsg(m.text as string, histImagePath) })
       } else {
-        msgs.push({ role: m.role, content: m.text })
+        msgs.push({ role: m.role as string, content: m.text as string })
       }
     }
   }
 
-  msgs.push({ role: 'user', ...fileToOllamaMsg(message, imagePath) })
+  const resolvedPath = resolveImagePath(imagePath)
+  msgs.push({ role: 'user', ...fileToOllamaMsg(message, resolvedPath ?? undefined) })
   return msgs
 }

package/src/lib/providers/openai.ts

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS } from './provider-defaults'
+import { resolveImagePath } from '@/lib/server/resolve-image'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
@@ -168,34 +169,30 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
   })
 }
 
-function urlToImagePart(url: string): { type: string; image_url: { url: string; detail: string } } {
-  return { type: 'image_url', image_url: { url, detail: 'auto' } }
-}
-
-async function buildMessages(session: any, message: string, imagePath: string | undefined, systemPrompt: string | undefined, loadHistory: (id: string) => any[], imageUrl?: string) {
-  const msgs: Array<{ role: string; content: any }> = []
+async function buildMessages(session: Record<string, unknown>, message: string, imagePath: string | undefined, systemPrompt: string | undefined, loadHistory: (id: string) => Record<string, unknown>[], imageUrl?: string) {
+  const msgs: Array<{ role: string; content: unknown }> = []
 
   if (systemPrompt) {
     msgs.push({ role: 'system', content: systemPrompt })
   }
 
   if (loadHistory) {
-    const history = loadHistory(session.id).slice(-40)
+    const history = loadHistory(session.id as string).slice(-40)
     for (const m of history) {
-      if (m.role === 'user' && (m.imagePath || m.imageUrl)) {
-        const parts = m.imagePath ? await fileToContentParts(m.imagePath) : []
-        if (m.imageUrl) parts.push(urlToImagePart(m.imageUrl))
+      const histImagePath = resolveImagePath(m.imagePath as string | undefined, m.imageUrl as string | undefined)
+      if (m.role === 'user' && histImagePath) {
+        const parts = await fileToContentParts(histImagePath)
         msgs.push({ role: 'user', content: [...parts, { type: 'text', text: m.text }] })
       } else {
-        msgs.push({ role: m.role, content: m.text })
+        msgs.push({ role: m.role as string, content: m.text })
       }
     }
   }
 
   // Current message with optional attachment
-  if (imagePath || imageUrl) {
-    const parts = imagePath ? await fileToContentParts(imagePath) : []
-    if (imageUrl) parts.push(urlToImagePart(imageUrl))
+  const resolvedPath = resolveImagePath(imagePath, imageUrl)
+  if (resolvedPath) {
+    const parts = await fileToContentParts(resolvedPath)
     msgs.push({ role: 'user', content: [...parts, { type: 'text', text: message }] })
   } else {
     msgs.push({ role: 'user', content: message })

package/src/lib/runtime-env.test.ts

@@ -5,24 +5,24 @@ import { isDevelopmentLikeRuntime, isProductionRuntime } from './runtime-env'
 
 describe('runtime env helpers', () => {
   it('treats missing NODE_ENV as development-like', () => {
-    const previousNodeEnv = process.env.NODE_ENV
-    delete process.env.NODE_ENV
+    const previousNodeEnv = process.env.NODE_ENV;
+    delete (process.env as any).NODE_ENV
 
     assert.equal(isDevelopmentLikeRuntime(), true)
     assert.equal(isProductionRuntime(), false)
 
-    if (previousNodeEnv === undefined) delete process.env.NODE_ENV
-    else process.env.NODE_ENV = previousNodeEnv
+    if (previousNodeEnv === undefined) delete (process.env as any).NODE_ENV
+    else (process.env as any).NODE_ENV = previousNodeEnv
   })
 
   it('detects explicit production mode', () => {
-    const previousNodeEnv = process.env.NODE_ENV
-    process.env.NODE_ENV = 'production'
+    const previousNodeEnv = process.env.NODE_ENV;
+    (process.env as any).NODE_ENV = 'production'
 
     assert.equal(isDevelopmentLikeRuntime(), false)
     assert.equal(isProductionRuntime(), true)
 
-    if (previousNodeEnv === undefined) delete process.env.NODE_ENV
-    else process.env.NODE_ENV = previousNodeEnv
+    if (previousNodeEnv === undefined) delete (process.env as any).NODE_ENV
+    else (process.env as any).NODE_ENV = previousNodeEnv
   })
 })

package/src/lib/schedule-dedupe-advanced.test.ts

@@ -5,11 +5,11 @@ import {
   findEquivalentSchedules,
   getScheduleSignatureKey,
   type ScheduleLike,
-} from './schedule-dedupe.ts'
+} from './schedule-dedupe'
 import {
   isAgentCreatedSchedule,
   shouldAutoDeleteScheduleAfterTerminalRun,
-} from './schedule-origin.ts'
+} from './schedule-origin'
 import type { Schedule } from '@/types'
 
 function makeSchedule(partial?: Partial<ScheduleLike>): ScheduleLike {

package/src/lib/schedule-dedupe.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { findDuplicateSchedule, findEquivalentSchedules, getScheduleSignatureKey, type ScheduleLike } from './schedule-dedupe.ts'
+import { findDuplicateSchedule, findEquivalentSchedules, getScheduleSignatureKey, type ScheduleLike } from './schedule-dedupe'
 
 test('findDuplicateSchedule matches active interval schedules with normalized prompts', () => {
   const schedules: Record<string, ScheduleLike> = {

package/src/lib/schedule-dedupe.ts

@@ -1,5 +1,6 @@
 import { CronExpressionParser } from 'cron-parser'
 import type { ScheduleType } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 
 export type ScheduleLike = {
   id?: string
@@ -242,8 +243,8 @@ function countTokenOverlap(a: string[], b: string[]): number {
 
 function hasFuzzyPromptMatch(a: ScheduleSignature, b: ScheduleSignature): boolean {
   if (!a.promptTokens.length || !b.promptTokens.length) return false
-  const uniqueA = [...new Set(a.promptTokens)]
-  const uniqueB = [...new Set(b.promptTokens)]
+  const uniqueA = dedup(a.promptTokens)
+  const uniqueB = dedup(b.promptTokens)
   const overlap = countTokenOverlap(uniqueA, uniqueB)
   if (overlap === 0) return false
   const smallerSize = Math.min(uniqueA.length, uniqueB.length)

package/src/lib/server/agent-thread-session.test.ts

@@ -36,9 +36,9 @@ function runWithTempDataDir(script: string) {
 describe('ensureAgentThreadSession', () => {
   it('creates and reuses an agent shortcut chat for heartbeat-enabled agents', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
+      const storageMod = await import('./src/lib/server/storage')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
-      const helperMod = await import('./src/lib/server/agent-thread-session.ts')
+      const helperMod = await import('./src/lib/server/agent-thread-session')
       const ensureAgentThreadSession = helperMod.ensureAgentThreadSession
         || helperMod.default?.ensureAgentThreadSession
         || helperMod['module.exports']?.ensureAgentThreadSession
@@ -91,9 +91,9 @@ describe('ensureAgentThreadSession', () => {
 
   it('does not create a new shortcut chat when the agent is disabled', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
+      const storageMod = await import('./src/lib/server/storage')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
-      const helperMod = await import('./src/lib/server/agent-thread-session.ts')
+      const helperMod = await import('./src/lib/server/agent-thread-session')
       const ensureAgentThreadSession = helperMod.ensureAgentThreadSession
         || helperMod.default?.ensureAgentThreadSession
         || helperMod['module.exports']?.ensureAgentThreadSession
@@ -136,9 +136,9 @@ describe('ensureAgentThreadSession', () => {
 
   it('propagates explicit OpenClaw gateway agent ids into the shortcut session', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
+      const storageMod = await import('./src/lib/server/storage')
       const storage = storageMod.default || storageMod['module.exports'] || storageMod
-      const helperMod = await import('./src/lib/server/agent-thread-session.ts')
+      const helperMod = await import('./src/lib/server/agent-thread-session')
       const ensureAgentThreadSession = helperMod.ensureAgentThreadSession
         || helperMod.default?.ensureAgentThreadSession
         || helperMod['module.exports']?.ensureAgentThreadSession

package/src/lib/server/agent-thread-session.ts

@@ -3,7 +3,7 @@ import type { Agent, Session } from '@/types'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
 import { isAgentDisabled } from './agent-availability'
 import { WORKSPACE_DIR } from './data-dir'
-import { loadAgents, loadSessions, saveAgents, saveSessions } from './storage'
+import { loadAgents, loadSessions, upsertStoredItem } from './storage'
 
 function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
   return {
@@ -105,8 +105,7 @@ export function ensureAgentThreadSession(agentId: string, user = 'default'): Ses
   const existingId = typeof agent.threadSessionId === 'string' ? agent.threadSessionId : ''
   if (existingId && sessions[existingId]) {
     const session = buildThreadSession(agent, existingId, user, now, sessions[existingId] as Session)
-    sessions[existingId] = session
-    saveSessions(sessions)
+    upsertStoredItem('sessions', existingId, session)
     return session
   }
 
@@ -118,10 +117,9 @@ export function ensureAgentThreadSession(agentId: string, user = 'default'): Ses
   if (legacySession) {
     agent.threadSessionId = legacySession.id
     agent.updatedAt = now
-    saveAgents(agents)
+    upsertStoredItem('agents', agentId, agent)
     const session = buildThreadSession(agent, legacySession.id, user, now, legacySession)
-    sessions[legacySession.id] = session
-    saveSessions(sessions)
+    upsertStoredItem('sessions', legacySession.id, session)
     return session
   }
 
@@ -129,11 +127,10 @@ export function ensureAgentThreadSession(agentId: string, user = 'default'): Ses
 
   const sessionId = `agent-chat-${agentId}-${genId()}`
   const session = buildThreadSession(agent, sessionId, user, now)
-  sessions[sessionId] = session
-  saveSessions(sessions)
+  upsertStoredItem('sessions', sessionId, session)
 
   agent.threadSessionId = sessionId
   agent.updatedAt = now
-  saveAgents(agents)
+  upsertStoredItem('agents', agentId, agent)
   return session
 }