@swarmclawai/swarmclaw 0.4.0 → 0.5.0

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

@@ -0,0 +1,181 @@
+'use client'
+
+import { useCallback, useRef, useState } from 'react'
+
+export type ContinuousSpeechState = 'idle' | 'listening' | 'cooldown' | 'waitingForResponse'
+
+interface SpeechRecognitionResult {
+  isFinal: boolean
+  [index: number]: { transcript: string }
+}
+
+interface SpeechRecognitionResultList {
+  readonly length: number
+  [index: number]: SpeechRecognitionResult
+}
+
+interface SpeechRecognitionEvent {
+  resultIndex: number
+  results: SpeechRecognitionResultList
+}
+
+interface SpeechRecognitionErrorEvent {
+  error: string
+}
+
+interface SpeechRecognitionInstance {
+  continuous: boolean
+  interimResults: boolean
+  maxAlternatives: number
+  lang: string
+  onresult: ((e: SpeechRecognitionEvent) => void) | null
+  onerror: ((e: SpeechRecognitionErrorEvent) => void) | null
+  onend: (() => void) | null
+  start(): void
+  stop(): void
+}
+
+interface WindowWithSpeechRecognition {
+  SpeechRecognition?: new () => SpeechRecognitionInstance
+  webkitSpeechRecognition?: new () => SpeechRecognitionInstance
+}
+
+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<SpeechRecognitionInstance | null>(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 w = window as unknown as WindowWithSpeechRecognition
+    const SR = w.SpeechRecognition || w.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: SpeechRecognitionEvent) => {
+      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: SpeechRecognitionErrorEvent) => {
+      // '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 unknown as WindowWithSpeechRecognition).SpeechRecognition || (window as unknown as WindowWithSpeechRecognition).webkitSpeechRecognition)
+
+  return { state, transcript, interimText, start, stop, pause, resume, supported }
+}

package/src/hooks/use-openclaw-gateway.ts

@@ -0,0 +1,63 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { api } from '@/lib/api-client'
+import { useWs } from './use-ws'
+
+/** Call an OpenClaw gateway RPC method via the proxy route. */
+export function useOpenClawRpc<T = unknown>(method: string | null, params?: unknown) {
+  const [data, setData] = useState<T | null>(null)
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const paramsRef = useRef(params)
+  paramsRef.current = params
+
+  const fetch = useCallback(async () => {
+    if (!method) return
+    setLoading(true)
+    setError(null)
+    try {
+      const res = await api<{ ok: boolean; result: T; error?: string }>('POST', '/openclaw/gateway', {
+        method,
+        params: paramsRef.current,
+      })
+      if (res.error) {
+        setError(res.error)
+      } else {
+        setData(res.result)
+      }
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err))
+    } finally {
+      setLoading(false)
+    }
+  }, [method])
+
+  useEffect(() => { fetch() }, [fetch])
+
+  return { data, loading, error, refetch: fetch }
+}
+
+/** Subscribe to an OpenClaw event topic via the WS hub. */
+export function useOpenClawEvent(topic: string, handler: () => void) {
+  useWs(`openclaw:${topic}`, handler)
+}
+
+/** Check gateway connection status. */
+export function useOpenClawConnected() {
+  const [connected, setConnected] = useState(false)
+
+  const check = useCallback(async () => {
+    try {
+      const res = await api<{ connected: boolean }>('GET', '/openclaw/gateway')
+      setConnected(res.connected)
+    } catch {
+      setConnected(false)
+    }
+  }, [])
+
+  useEffect(() => { check() }, [check])
+  useWs('openclaw:agents', check)
+
+  return connected
+}

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/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/notification-sounds.ts

@@ -0,0 +1,58 @@
+let ctx: AudioContext | null = null
+
+function ensureCtx(): AudioContext | null {
+  if (!ctx) {
+    try { ctx = new AudioContext() } catch { return null }
+  }
+  if (ctx.state === 'suspended') ctx.resume()
+  return ctx
+}
+
+function tone(freq: number, duration: number, type: OscillatorType = 'sine', delay = 0) {
+  const c = ensureCtx()
+  if (!c) return
+  const osc = c.createOscillator()
+  const gain = c.createGain()
+  osc.type = type
+  osc.frequency.value = freq
+  gain.gain.setValueAtTime(0.12, c.currentTime + delay)
+  gain.gain.exponentialRampToValueAtTime(0.001, c.currentTime + delay + duration / 1000)
+  osc.connect(gain)
+  gain.connect(c.destination)
+  osc.start(c.currentTime + delay)
+  osc.stop(c.currentTime + delay + duration / 1000)
+}
+
+/** Two ascending tones: C5 → E5 */
+export function playStreamStart() {
+  tone(523, 80, 'sine', 0)
+  tone(659, 80, 'sine', 0.09)
+}
+
+/** Two descending tones: E5 → C5 */
+export function playStreamEnd() {
+  tone(659, 80, 'sine', 0)
+  tone(523, 80, 'sine', 0.09)
+}
+
+/** Single ding: A5 */
+export function playToolComplete() {
+  tone(880, 120, 'triangle')
+}
+
+/** Low buzz: A3 */
+export function playError() {
+  tone(220, 200, 'square')
+}
+
+const LS_KEY = 'sc_sound_notifications'
+
+export function getSoundEnabled(): boolean {
+  if (typeof window === 'undefined') return false
+  return localStorage.getItem(LS_KEY) === '1'
+}
+
+export function setSoundEnabled(v: boolean) {
+  if (typeof window === 'undefined') return
+  localStorage.setItem(LS_KEY, v ? '1' : '0')
+}

package/src/lib/personality-parser.ts

@@ -0,0 +1,97 @@
+import type { PersonalityDraft } from '@/types'
+
+// --- IDENTITY.md ---
+
+export function parseIdentityMd(content: string): PersonalityDraft['identity'] {
+  const result: PersonalityDraft['identity'] = {}
+  const lines = content.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s*(.+?):\s*(.+)$/)
+    if (!match) continue
+    const key = match[1].trim().toLowerCase()
+    const value = match[2].trim()
+    if (key === 'name') result.name = value
+    else if (key === 'creature' || key === 'species' || key === 'type') result.creature = value
+    else if (key === 'vibe' || key === 'personality') result.vibe = value
+    else if (key === 'emoji' || key === 'icon') result.emoji = value
+  }
+  return result
+}
+
+export function serializeIdentityMd(draft: PersonalityDraft['identity']): string {
+  const lines: string[] = ['# Identity', '']
+  if (draft.name) lines.push(`- Name: ${draft.name}`)
+  if (draft.creature) lines.push(`- Creature: ${draft.creature}`)
+  if (draft.vibe) lines.push(`- Vibe: ${draft.vibe}`)
+  if (draft.emoji) lines.push(`- Emoji: ${draft.emoji}`)
+  return lines.join('\n') + '\n'
+}
+
+// --- USER.md ---
+
+export function parseUserMd(content: string): PersonalityDraft['user'] {
+  const result: PersonalityDraft['user'] = {}
+  const contextIdx = content.indexOf('## Context')
+  const headerPart = contextIdx >= 0 ? content.slice(0, contextIdx) : content
+  const contextPart = contextIdx >= 0 ? content.slice(contextIdx + '## Context'.length).trim() : ''
+
+  const lines = headerPart.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s*(.+?):\s*(.+)$/)
+    if (!match) continue
+    const key = match[1].trim().toLowerCase()
+    const value = match[2].trim()
+    if (key === 'name') result.name = value
+    else if (key === 'call them' || key === 'nickname') result.callThem = value
+    else if (key === 'pronouns') result.pronouns = value
+    else if (key === 'timezone') result.timezone = value
+    else if (key === 'notes') result.notes = value
+  }
+
+  if (contextPart) result.context = contextPart
+
+  return result
+}
+
+export function serializeUserMd(draft: PersonalityDraft['user']): string {
+  const lines: string[] = ['# User', '']
+  if (draft.name) lines.push(`- Name: ${draft.name}`)
+  if (draft.callThem) lines.push(`- Call them: ${draft.callThem}`)
+  if (draft.pronouns) lines.push(`- Pronouns: ${draft.pronouns}`)
+  if (draft.timezone) lines.push(`- Timezone: ${draft.timezone}`)
+  if (draft.notes) lines.push(`- Notes: ${draft.notes}`)
+  if (draft.context) {
+    lines.push('', '## Context', '', draft.context)
+  }
+  return lines.join('\n') + '\n'
+}
+
+// --- SOUL.md ---
+
+export function parseSoulMd(content: string): PersonalityDraft['soul'] {
+  const result: PersonalityDraft['soul'] = {}
+  const sections = content.split(/^##\s+/m)
+
+  for (const section of sections) {
+    const nlIdx = section.indexOf('\n')
+    if (nlIdx < 0) continue
+    const heading = section.slice(0, nlIdx).trim().toLowerCase()
+    const body = section.slice(nlIdx + 1).trim()
+
+    if (heading.startsWith('core truth')) result.coreTruths = body
+    else if (heading.startsWith('boundar')) result.boundaries = body
+    else if (heading.startsWith('vibe')) result.vibe = body
+    else if (heading.startsWith('continuity')) result.continuity = body
+  }
+
+  return result
+}
+
+export function serializeSoulMd(draft: PersonalityDraft['soul']): string {
+  const lines: string[] = ['# Soul', '']
+  if (draft.coreTruths) lines.push('## Core Truths', '', draft.coreTruths, '')
+  if (draft.boundaries) lines.push('## Boundaries', '', draft.boundaries, '')
+  if (draft.vibe) lines.push('## Vibe', '', draft.vibe, '')
+  if (draft.continuity) lines.push('## Continuity', '', draft.continuity, '')
+  return lines.join('\n')
+}

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)
       })

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 {

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 {}
         }
       })

package/src/lib/providers/openai.ts

@@ -43,7 +43,7 @@ async function fileToContentParts(filePath: string): Promise<any[]> {
   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 = await buildMessages(session, message, imagePath, systemPrompt, loadHistory)
     const model = session.model || 'gpt-4o'
@@ -52,6 +52,7 @@ export function streamOpenAiChat({ session, message, imagePath, apiKey, systemPr
       model,
       messages,
       stream: true,
+      stream_options: { include_usage: true },
     })
 
     let fullResponse = ''
@@ -136,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 {}
         }
       }