@swarmclawai/swarmclaw 0.3.1 → 0.4.5

package/src/hooks/use-continuous-speech.ts

@@ -0,0 +1,144 @@
+'use client'
+
+import { useCallback, useRef, useState } from 'react'
+
+export type ContinuousSpeechState = 'idle' | 'listening' | 'cooldown' | 'waitingForResponse'
+
+interface UseContinuousSpeechOptions {
+  lang?: string
+  silenceDelayMs?: number
+  onUtterance: (transcript: string) => void
+}
+
+export function useContinuousSpeech(options: UseContinuousSpeechOptions) {
+  const { lang, silenceDelayMs = 800, onUtterance } = options
+  const [state, setState] = useState<ContinuousSpeechState>('idle')
+  const [transcript, setTranscript] = useState('')
+  const [interimText, setInterimText] = useState('')
+
+  const recogRef = useRef<any>(null)
+  const silenceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const activeRef = useRef(false)
+  const accumulatedRef = useRef('')
+
+  const clearSilenceTimer = () => {
+    if (silenceTimerRef.current) {
+      clearTimeout(silenceTimerRef.current)
+      silenceTimerRef.current = null
+    }
+  }
+
+  const startRecognition = useCallback(() => {
+    const SR = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition
+    if (!SR) return
+
+    if (recogRef.current) {
+      try { recogRef.current.stop() } catch { /* noop */ }
+    }
+
+    const recog = new SR()
+    recog.continuous = true
+    recog.interimResults = true
+    recog.maxAlternatives = 1
+    recog.lang = lang || navigator.language || 'en-US'
+
+    recog.onresult = (e: any) => {
+      clearSilenceTimer()
+      let interim = ''
+      let final = ''
+
+      for (let i = e.resultIndex; i < e.results.length; i++) {
+        const result = e.results[i]
+        if (result.isFinal) {
+          final += result[0].transcript
+        } else {
+          interim += result[0].transcript
+        }
+      }
+
+      if (final) {
+        accumulatedRef.current += (accumulatedRef.current ? ' ' : '') + final.trim()
+        setTranscript(accumulatedRef.current)
+        setInterimText('')
+
+        // Start silence timer — after delay, send the utterance
+        silenceTimerRef.current = setTimeout(() => {
+          if (!activeRef.current) return
+          const text = accumulatedRef.current.trim()
+          if (text) {
+            setState('waitingForResponse')
+            onUtterance(text)
+            accumulatedRef.current = ''
+            setTranscript('')
+          }
+        }, silenceDelayMs)
+      } else {
+        setInterimText(interim)
+      }
+    }
+
+    recog.onerror = (e: any) => {
+      // 'no-speech' is normal during silence; 'aborted' when stopping intentionally
+      if (e.error === 'no-speech' || e.error === 'aborted') return
+      console.warn('[continuous-speech] error:', e.error)
+    }
+
+    recog.onend = () => {
+      // Auto-restart if still active (browser may stop recognition periodically)
+      if (activeRef.current && state !== 'waitingForResponse') {
+        try { recog.start() } catch { /* noop */ }
+      }
+    }
+
+    recogRef.current = recog
+    try {
+      recog.start()
+      setState('listening')
+    } catch {
+      setState('idle')
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [lang, silenceDelayMs, onUtterance])
+
+  const start = useCallback(() => {
+    activeRef.current = true
+    accumulatedRef.current = ''
+    setTranscript('')
+    setInterimText('')
+    startRecognition()
+  }, [startRecognition])
+
+  const stop = useCallback(() => {
+    activeRef.current = false
+    clearSilenceTimer()
+    if (recogRef.current) {
+      try { recogRef.current.stop() } catch { /* noop */ }
+      recogRef.current = null
+    }
+    setState('idle')
+    setTranscript('')
+    setInterimText('')
+    accumulatedRef.current = ''
+  }, [])
+
+  const pause = useCallback(() => {
+    clearSilenceTimer()
+    if (recogRef.current) {
+      try { recogRef.current.stop() } catch { /* noop */ }
+    }
+  }, [])
+
+  const resume = useCallback(() => {
+    if (!activeRef.current) return
+    accumulatedRef.current = ''
+    setTranscript('')
+    setInterimText('')
+    setState('listening')
+    startRecognition()
+  }, [startRecognition])
+
+  const supported = typeof window !== 'undefined' &&
+    !!((window as any).SpeechRecognition || (window as any).webkitSpeechRecognition)
+
+  return { state, transcript, interimText, start, stop, pause, resume, supported }
+}

package/src/hooks/use-view-router.ts

@@ -0,0 +1,52 @@
+'use client'
+
+import { useEffect, useRef } from 'react'
+import { useAppStore } from '@/stores/use-app-store'
+import { VIEW_TO_PATH, PATH_TO_VIEW, DEFAULT_VIEW } from '@/lib/view-routes'
+
+export function useViewRouter() {
+  const fromPopstate = useRef(false)
+
+  // Mount: read pathname → set active view
+  useEffect(() => {
+    const view = PATH_TO_VIEW[window.location.pathname]
+    if (view) {
+      useAppStore.getState().setActiveView(view)
+    } else {
+      useAppStore.getState().setActiveView(DEFAULT_VIEW)
+      window.history.replaceState(null, '', VIEW_TO_PATH[DEFAULT_VIEW])
+    }
+  }, [])
+
+  // State→URL: push new path when activeView changes
+  useEffect(() => {
+    let prev = useAppStore.getState().activeView
+    const unsub = useAppStore.subscribe((state) => {
+      const next = state.activeView
+      if (next === prev) return
+      prev = next
+      if (fromPopstate.current) {
+        fromPopstate.current = false
+        return
+      }
+      const targetPath = VIEW_TO_PATH[next]
+      if (targetPath && window.location.pathname !== targetPath) {
+        window.history.pushState(null, '', targetPath)
+      }
+    })
+    return unsub
+  }, [])
+
+  // Popstate: browser back/forward → update view
+  useEffect(() => {
+    const onPopstate = () => {
+      const view = PATH_TO_VIEW[window.location.pathname]
+      if (view) {
+        fromPopstate.current = true
+        useAppStore.getState().setActiveView(view)
+      }
+    }
+    window.addEventListener('popstate', onPopstate)
+    return () => window.removeEventListener('popstate', onPopstate)
+  }, [])
+}

package/src/hooks/use-voice-conversation.ts

@@ -0,0 +1,80 @@
+'use client'
+
+import { useCallback, useRef, useState } from 'react'
+import { useContinuousSpeech } from './use-continuous-speech'
+import { SentenceAccumulator, AudioChunkQueue, fetchStreamTts } from '@/lib/tts-stream'
+import { useChatStore } from '@/stores/use-chat-store'
+
+export type VoiceConversationState = 'idle' | 'listening' | 'processing' | 'speaking'
+
+export function useVoiceConversation() {
+  const [active, setActive] = useState(false)
+  const [voiceState, setVoiceState] = useState<VoiceConversationState>('idle')
+  const accumulatorRef = useRef<SentenceAccumulator | null>(null)
+  const queueRef = useRef<AudioChunkQueue | null>(null)
+  const sendMessage = useChatStore((s) => s.sendMessage)
+
+  const speech = useContinuousSpeech({
+    onUtterance: useCallback((text: string) => {
+      setVoiceState('processing')
+      // Send the transcribed text as a chat message
+      sendMessage(text)
+    }, [sendMessage]),
+  })
+
+  // Called by the chat store's onStreamEvent callback
+  const handleStreamEvent = useCallback((event: { t: string; text?: string }) => {
+    if (!active) return
+
+    if (event.t === 'd' && event.text) {
+      setVoiceState('speaking')
+      if (!accumulatorRef.current) {
+        const queue = new AudioChunkQueue()
+        queueRef.current = queue
+        queue.onComplete = () => {
+          // Resume listening after TTS playback finishes
+          setVoiceState('listening')
+          speech.resume()
+        }
+        accumulatorRef.current = new SentenceAccumulator((sentence) => {
+          queue.enqueue(fetchStreamTts(sentence))
+        })
+      }
+      accumulatorRef.current.push(event.text)
+    } else if (event.t === 'done') {
+      // Flush remaining text to TTS
+      if (accumulatorRef.current) {
+        accumulatorRef.current.flush()
+        accumulatorRef.current = null
+      }
+    }
+  }, [active, speech])
+
+  const start = useCallback(() => {
+    setActive(true)
+    setVoiceState('listening')
+    // Register the stream event handler on the chat store
+    useChatStore.setState({ onStreamEvent: handleStreamEvent, voiceConversationActive: true })
+    speech.start()
+  }, [speech, handleStreamEvent])
+
+  const stop = useCallback(() => {
+    setActive(false)
+    setVoiceState('idle')
+    speech.stop()
+    queueRef.current?.stop()
+    queueRef.current = null
+    accumulatorRef.current = null
+    useChatStore.setState({ onStreamEvent: null, voiceConversationActive: false })
+  }, [speech])
+
+  return {
+    active,
+    state: voiceState,
+    interimText: speech.interimText,
+    transcript: speech.transcript,
+    supported: speech.supported,
+    start,
+    stop,
+  }
+}

package/src/hooks/use-ws.ts

@@ -0,0 +1,66 @@
+'use client'
+
+import { useEffect, useRef } from 'react'
+import { subscribeWs, unsubscribeWs, isWsConnected } from '@/lib/ws-client'
+
+/**
+ * Subscribe to a WebSocket topic. Calls `handler` on push events.
+ * Falls back to polling at `fallbackMs` when WS is disconnected.
+ */
+export function useWs(topic: string, handler: () => void, fallbackMs?: number) {
+  const handlerRef = useRef(handler)
+  handlerRef.current = handler
+  const fallbackMsRef = useRef(fallbackMs)
+  fallbackMsRef.current = fallbackMs
+
+  // WS subscription — only re-runs when topic changes
+  useEffect(() => {
+    if (!topic) return
+
+    const cb = () => handlerRef.current()
+    subscribeWs(topic, cb)
+    return () => { unsubscribeWs(topic, cb) }
+  }, [topic])
+
+  // Fallback polling — separate effect so it doesn't tear down WS subscription
+  useEffect(() => {
+    if (!topic) return
+
+    let fallbackId: ReturnType<typeof setInterval> | null = null
+    const cb = () => handlerRef.current()
+
+    const startFallback = () => {
+      const ms = fallbackMsRef.current
+      if (fallbackId || !ms || ms <= 0) return
+      fallbackId = setInterval(cb, ms)
+    }
+    const stopFallback = () => {
+      if (fallbackId) {
+        clearInterval(fallbackId)
+        fallbackId = null
+      }
+    }
+
+    // Check WS connection state periodically to toggle fallback
+    const checkId = setInterval(() => {
+      const ms = fallbackMsRef.current
+      if (!ms || ms <= 0) {
+        stopFallback()
+      } else if (isWsConnected()) {
+        stopFallback()
+      } else {
+        startFallback()
+      }
+    }, 2000)
+
+    // Start fallback immediately if not connected and fallback is enabled
+    if (!isWsConnected() && fallbackMsRef.current && fallbackMsRef.current > 0) {
+      startFallback()
+    }
+
+    return () => {
+      stopFallback()
+      clearInterval(checkId)
+    }
+  }, [topic])
+}

package/src/instrumentation.ts

@@ -2,7 +2,9 @@ export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
     const { startScheduler } = await import('./lib/server/scheduler')
     const { resumeQueue } = await import('./lib/server/queue')
+    const { initWsServer } = await import('./lib/server/ws-hub')
     startScheduler()
     resumeQueue()
+    initWsServer()
   }
 }

package/src/lib/chat.ts

@@ -12,8 +12,19 @@ export async function streamChat(
   imagePath?: string,
   imageUrl?: string,
   onEvent?: (event: SSEEvent) => void,
+  optionsOrFiles?: StreamChatOptions | string[],
   options?: StreamChatOptions,
 ): Promise<void> {
+  // Support both (options) and (attachedFiles, options) as 6th arg
+  let attachedFiles: string[] | undefined
+  let opts: StreamChatOptions | undefined
+  if (Array.isArray(optionsOrFiles)) {
+    attachedFiles = optionsOrFiles
+    opts = options
+  } else {
+    opts = optionsOrFiles
+  }
+
   const key = getStoredAccessKey()
   const res = await fetch(`/api/sessions/${sessionId}/chat`, {
     method: 'POST',
@@ -25,8 +36,9 @@ export async function streamChat(
       message,
       imagePath,
       imageUrl,
-      internal: !!options?.internal,
-      queueMode: options?.queueMode,
+      attachedFiles,
+      internal: !!opts?.internal,
+      queueMode: opts?.queueMode,
     }),
   })
 

package/src/lib/id.ts

@@ -0,0 +1,6 @@
+import crypto from 'crypto'
+
+/** Generate a random hex ID. Default 4 bytes = 8 hex chars. */
+export function genId(bytes = 4): string {
+  return crypto.randomBytes(bytes).toString('hex')
+}

package/src/lib/projects.ts

@@ -0,0 +1,13 @@
+import { api } from './api-client'
+import type { Project } from '../types'
+
+export const fetchProjects = () => api<Record<string, Project>>('GET', '/projects')
+
+export const createProject = (data: Omit<Project, 'id' | 'createdAt' | 'updatedAt'>) =>
+  api<Project>('POST', '/projects', data)
+
+export const updateProject = (id: string, data: Partial<Project>) =>
+  api<Project>('PUT', `/projects/${id}`, data)
+
+export const deleteProject = (id: string) =>
+  api<string>('DELETE', `/projects/${id}`)

package/src/lib/provider-sets.ts

@@ -0,0 +1,5 @@
+/** CLI providers that use their own tool execution — incompatible with LangGraph orchestration. */
+export const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli'])
+
+/** Providers with native tool/capability support (CLI providers + OpenClaw). */
+export const NATIVE_CAPABILITY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'openclaw'])

package/src/lib/providers/anthropic.ts

@@ -23,10 +23,12 @@ function fileToContentBlocks(filePath: string): any[] {
   return [{ type: 'text', text: `[Attached file: ${filePath.split('/').pop()}]` }]
 }
 
-export function streamAnthropicChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory }: StreamChatOptions): Promise<string> {
+export function streamAnthropicChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory, onUsage }: StreamChatOptions): Promise<string> {
   return new Promise((resolve) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
     const model = session.model || 'claude-sonnet-4-6'
+    let usageInput = 0
+    let usageOutput = 0
 
     const body: Record<string, unknown> = {
       model,
@@ -86,11 +88,22 @@ export function streamAnthropicChat({ session, message, imagePath, apiKey, syste
               fullResponse += parsed.delta.text
               write(`data: ${JSON.stringify({ t: 'd', text: parsed.delta.text })}\n\n`)
             }
+            // message_start carries input token count
+            if (parsed.type === 'message_start' && parsed.message?.usage) {
+              usageInput = parsed.message.usage.input_tokens || 0
+            }
+            // message_delta carries output token count
+            if (parsed.type === 'message_delta' && parsed.usage) {
+              usageOutput = parsed.usage.output_tokens || 0
+            }
           } catch {}
         }
       })
 
       apiRes.on('end', () => {
+        if (onUsage && (usageInput > 0 || usageOutput > 0)) {
+          onUsage({ inputTokens: usageInput, outputTokens: usageOutput })
+        }
         active.delete(session.id)
         resolve(fullResponse)
       })
@@ -113,7 +126,7 @@ function buildMessages(session: any, message: string, imagePath: string | undefi
   const msgs: Array<{ role: string; content: any }> = []
 
   if (loadHistory) {
-    const history = loadHistory(session.id)
+    const history = loadHistory(session.id).slice(-40)
     for (const m of history) {
       if (m.role === 'user' && m.imagePath) {
         const blocks = fileToContentBlocks(m.imagePath)

package/src/lib/providers/index.ts

@@ -13,6 +13,11 @@ export interface ProviderHandler {
   streamChat: (opts: StreamChatOptions) => Promise<string>
 }
 
+export interface StreamChatUsage {
+  inputTokens: number
+  outputTokens: number
+}
+
 export interface StreamChatOptions {
   session: any
   message: string
@@ -22,6 +27,7 @@ export interface StreamChatOptions {
   write: (data: string) => void
   active: Map<string, any>
   loadHistory: (sessionId: string) => any[]
+  onUsage?: (usage: StreamChatUsage) => void
 }
 
 interface BuiltinProviderConfig extends ProviderInfo {
@@ -246,6 +252,7 @@ export function getProviderList(): ProviderInfo[] {
     .map(({ handler, ...info }) => ({
       ...info,
       models: overrides[info.id] || info.models,
+      defaultModels: info.models,
     }))
   const customs = Object.values(getCustomProviders())
     .filter((c) => c.isEnabled)
@@ -253,6 +260,7 @@ export function getProviderList(): ProviderInfo[] {
       id: c.id as any,
       name: c.name,
       models: c.models,
+      defaultModels: c.models,
       requiresApiKey: c.requiresApiKey,
       requiresEndpoint: false,
       defaultEndpoint: c.baseUrl,

package/src/lib/providers/ollama.ts

@@ -6,7 +6,7 @@ import type { StreamChatOptions } from './index'
 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
 
-export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory }: StreamChatOptions): Promise<string> {
+export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage }: StreamChatOptions): Promise<string> {
   return new Promise((resolve) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
     const model = session.model || 'llama3'
@@ -69,6 +69,14 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
               fullResponse += content
               write(`data: ${JSON.stringify({ t: 'd', text: content })}\n\n`)
             }
+            // Final chunk (done: true) carries token counts
+            if (parsed.done && onUsage) {
+              const input = parsed.prompt_eval_count || 0
+              const output = parsed.eval_count || 0
+              if (input > 0 || output > 0) {
+                onUsage({ inputTokens: input, outputTokens: output })
+              }
+            }
           } catch {}
         }
       })
@@ -116,7 +124,7 @@ function buildMessages(session: any, message: string, imagePath: string | undefi
   const msgs: Array<{ role: string; content: string; images?: string[] }> = []
 
   if (loadHistory) {
-    const history = loadHistory(session.id)
+    const history = loadHistory(session.id).slice(-40)
     for (const m of history) {
       if (m.role === 'user' && m.imagePath) {
         msgs.push({ role: 'user', ...fileToOllamaMsg(m.text, m.imagePath) })

package/src/lib/providers/openai.ts

@@ -4,33 +4,55 @@ import type { StreamChatOptions } from './index'
 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
 
-function fileToContentParts(filePath: string): any[] {
+async function fileToContentParts(filePath: string): Promise<any[]> {
   if (!filePath || !fs.existsSync(filePath)) return []
+  const name = filePath.split('/').pop() || 'file'
   if (IMAGE_EXTS.test(filePath)) {
-    const data = fs.readFileSync(filePath).toString('base64')
+    const buf = fs.readFileSync(filePath)
+    if (buf.length === 0) return [{ type: 'text', text: `[Attached image: ${name} — file is empty]` }]
+    const data = buf.toString('base64')
     const ext = filePath.split('.').pop()?.toLowerCase() || 'png'
-    const mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
-    return [{ type: 'image_url', image_url: { url: `data:${mimeType};base64,${data}` } }]
+    let mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
+    if (buf[0] === 0xFF && buf[1] === 0xD8) mimeType = 'image/jpeg'
+    else if (buf[0] === 0x89 && buf[1] === 0x50) mimeType = 'image/png'
+    else if (buf[0] === 0x47 && buf[1] === 0x49) mimeType = 'image/gif'
+    else if (buf[0] === 0x52 && buf[1] === 0x49) mimeType = 'image/webp'
+    return [{ type: 'image_url', image_url: { url: `data:${mimeType};base64,${data}`, detail: 'auto' } }]
   }
-  if (TEXT_EXTS.test(filePath) || filePath.endsWith('.pdf')) {
+  if (filePath.endsWith('.pdf')) {
+    try {
+      // @ts-ignore — pdf-parse types
+      const pdfParse = (await import(/* webpackIgnore: true */ 'pdf-parse')).default
+      const buf = fs.readFileSync(filePath)
+      const result = await pdfParse(buf)
+      const pdfText = (result.text || '').trim()
+      if (!pdfText) return [{ type: 'text', text: `[Attached PDF: ${name} — no extractable text]` }]
+      const maxChars = 100_000
+      const truncated = pdfText.length > maxChars ? pdfText.slice(0, maxChars) + '\n\n[... truncated]' : pdfText
+      return [{ type: 'text', text: `[Attached PDF: ${name} (${result.numpages} pages)]\n\n${truncated}` }]
+    } catch {
+      return [{ type: 'text', text: `[Attached PDF: ${name} — could not extract text]` }]
+    }
+  }
+  if (TEXT_EXTS.test(filePath)) {
     try {
       const text = fs.readFileSync(filePath, 'utf-8')
-      const name = filePath.split('/').pop() || 'file'
       return [{ type: 'text', text: `[Attached file: ${name}]\n\n${text}` }]
     } catch { return [] }
   }
-  return [{ type: 'text', text: `[Attached file: ${filePath.split('/').pop()}]` }]
+  return [{ type: 'text', text: `[Attached file: ${name}]` }]
 }
 
-export function streamOpenAiChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory }: StreamChatOptions): Promise<string> {
+export function streamOpenAiChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory, onUsage }: StreamChatOptions): Promise<string> {
   return new Promise(async (resolve) => {
-    const messages = buildMessages(session, message, imagePath, systemPrompt, loadHistory)
+    const messages = await buildMessages(session, message, imagePath, systemPrompt, loadHistory)
     const model = session.model || 'gpt-4o'
 
     const payload = JSON.stringify({
       model,
       messages,
       stream: true,
+      stream_options: { include_usage: true },
     })
 
     let fullResponse = ''
@@ -115,6 +137,13 @@ export function streamOpenAiChat({ session, message, imagePath, apiKey, systemPr
               fullResponse += delta
               write(`data: ${JSON.stringify({ t: 'd', text: delta })}\n\n`)
             }
+            // Extract usage from the final chunk (stream_options: include_usage)
+            if (parsed.usage && onUsage) {
+              onUsage({
+                inputTokens: parsed.usage.prompt_tokens || 0,
+                outputTokens: parsed.usage.completion_tokens || 0,
+              })
+            }
           } catch {}
         }
       }
@@ -134,7 +163,7 @@ export function streamOpenAiChat({ session, message, imagePath, apiKey, systemPr
   })
 }
 
-function buildMessages(session: any, message: string, imagePath: string | undefined, systemPrompt: string | undefined, loadHistory: (id: string) => any[]) {
+async function buildMessages(session: any, message: string, imagePath: string | undefined, systemPrompt: string | undefined, loadHistory: (id: string) => any[]) {
   const msgs: Array<{ role: string; content: any }> = []
 
   if (systemPrompt) {
@@ -142,10 +171,10 @@ function buildMessages(session: any, message: string, imagePath: string | undefi
   }
 
   if (loadHistory) {
-    const history = loadHistory(session.id)
+    const history = loadHistory(session.id).slice(-40)
     for (const m of history) {
       if (m.role === 'user' && m.imagePath) {
-        const parts = fileToContentParts(m.imagePath)
+        const parts = await fileToContentParts(m.imagePath)
         msgs.push({ role: 'user', content: [...parts, { type: 'text', text: m.text }] })
       } else {
         msgs.push({ role: m.role, content: m.text })
@@ -155,7 +184,7 @@ function buildMessages(session: any, message: string, imagePath: string | undefi
 
   // Current message with optional attachment
   if (imagePath) {
-    const parts = fileToContentParts(imagePath)
+    const parts = await fileToContentParts(imagePath)
     msgs.push({ role: 'user', content: [...parts, { type: 'text', text: message }] })
   } else {
     msgs.push({ role: 'user', content: message })

package/src/lib/providers/openclaw.ts

@@ -63,6 +63,17 @@ function tryLoadIdentityFile(filePath: string): DeviceIdentity | null {
 }
 
 function loadOrCreateDeviceIdentity(): DeviceIdentity {
+  // 0. Check shared device token for cross-synced identity
+  try {
+    const { getSharedDeviceToken } = require('../server/openclaw-sync')
+    const sharedToken = getSharedDeviceToken()
+    if (sharedToken) {
+      // Shared token exists — the connector has already paired.
+      // Still need the keypair, so continue to identity resolution below.
+      // The token will be used during WS connect.
+    }
+  } catch { /* openclaw-sync not available */ }
+
   // 1. Prefer the openclaw CLI's identity — it's likely already paired with the gateway
   const cliIdentityPath = path.join(resolveCliStateDir(), 'identity', 'device.json')
   const cliIdentity = tryLoadIdentityFile(cliIdentityPath)