@swarmclawai/swarmclaw 0.4.0 → 0.4.5

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

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)

package/src/lib/server/api-routes.test.ts

@@ -346,17 +346,16 @@ describe('MCP Server API contract', () => {
       assert.match(src, /export\s+async\s+function\s+DELETE/)
     })
 
-    it('MCP POST route assigns an id via crypto.randomBytes', () => {
+    it('MCP POST route assigns an id via genId helper', () => {
       const src = readRoute('mcp-servers', 'route.ts')
-      assert.match(src, /crypto\.randomBytes/)
+      assert.match(src, /const\s+id\s*=\s*genId\(/)
     })
 
-    it('MCP PUT route preserves id and sets updatedAt', () => {
+    it('MCP PUT route preserves id and sets updatedAt via mutateItem', () => {
       const src = readRoute('mcp-servers', '[id]', 'route.ts')
+      assert.match(src, /mutateItem\(/)
       assert.match(src, /updatedAt:\s*Date\.now\(\)/)
-      // Verify id is pinned (spread then override)
-      assert.match(src, /\.\.\.servers\[id\]/)
-      assert.match(src, /\bid\b,/)
+      assert.match(src, /\.\.\.server,\s*\.\.\.body,\s*id,/)
     })
   })
 })

package/src/lib/server/build-llm.ts

@@ -3,10 +3,10 @@ import { ChatOpenAI } from '@langchain/openai'
 import { loadCredentials, decryptKey, loadAgents, loadSettings } from './storage'
 import { getProviderList } from '../providers'
 import { normalizeOpenClawEndpoint } from '../openclaw-endpoint'
+import { NON_LANGGRAPH_PROVIDER_IDS } from '../provider-sets'
 
 const OLLAMA_CLOUD_URL = 'https://ollama.com/v1'
 const OLLAMA_LOCAL_URL = 'http://localhost:11434/v1'
-const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli'])
 
 /**
  * Build a LangChain chat model from provider config.
@@ -18,8 +18,9 @@ export function buildChatModel(opts: {
   model: string
   apiKey: string | null
   apiEndpoint?: string | null
+  thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high'
 }) {
-  const { provider, model, apiKey, apiEndpoint } = opts
+  const { provider, model, apiKey, apiEndpoint, thinkingLevel } = opts
   const providers = getProviderList()
   const providerInfo = providers.find((p) => p.id === provider)
   const endpointRaw = apiEndpoint || providerInfo?.defaultEndpoint || null
@@ -28,11 +29,18 @@ export function buildChatModel(opts: {
     : endpointRaw
 
   if (provider === 'anthropic') {
-    return new ChatAnthropic({
+    const anthropicOpts: Record<string, unknown> = {
       model: model || 'claude-sonnet-4-6',
       anthropicApiKey: apiKey || undefined,
       maxTokens: 8192,
-    })
+    }
+    if (thinkingLevel) {
+      const budgetMap = { minimal: 1024, low: 4096, medium: 8192, high: 16384 }
+      anthropicOpts.thinking = { type: 'enabled', budget_tokens: budgetMap[thinkingLevel] }
+      // Extended thinking requires higher maxTokens (budget + output)
+      anthropicOpts.maxTokens = budgetMap[thinkingLevel] + 8192
+    }
+    return new ChatAnthropic(anthropicOpts as ConstructorParameters<typeof ChatAnthropic>[0])
   }
 
   if (provider === 'ollama') {
@@ -48,6 +56,11 @@ export function buildChatModel(opts: {
 
   // All other providers — OpenAI-compatible with their registered endpoint
   const config: any = { model: model || 'gpt-4o', apiKey: apiKey || undefined }
+  // Map thinking level to reasoning_effort for OpenAI o-series models
+  if (thinkingLevel && provider === 'openai' && /^o\d/.test(model || '')) {
+    const effortMap = { minimal: 'low', low: 'low', medium: 'medium', high: 'high' }
+    config.modelKwargs = { reasoning_effort: effortMap[thinkingLevel] }
+  }
   if (endpoint) {
     config.configuration = { baseURL: endpoint }
     // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware

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

@@ -9,9 +9,11 @@ import {
   loadSkills,
   loadSettings,
   loadUsage,
+  appendUsage,
   active,
 } from './storage'
 import { getProvider } from '@/lib/providers'
+import { estimateCost } from './cost'
 import { log } from './logger'
 import { logExecution } from './execution-log'
 import { streamAgentChat } from './stream-agent-chat'
@@ -22,10 +24,9 @@ import { getMemoryDb } from './memory-db'
 import { routeTaskIntent } from './capability-router'
 import { notify } from './ws-hub'
 import { resolveConcreteToolPolicyBlock, resolveSessionToolPolicy } from './tool-capability-policy'
-import type { MessageToolEvent, SSEEvent } from '@/types'
+import type { MessageToolEvent, SSEEvent, UsageRecord } from '@/types'
 import { markProviderFailure, markProviderSuccess, rankDelegatesByHealth } from './provider-health'
-
-const CLI_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli'])
+import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'
 
 interface SessionWithTools {
@@ -572,8 +573,12 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     kill: () => abortController.abort(),
   })
 
+  // Capture provider-reported usage for the direct (non-tools) path.
+  // Uses a mutable object because TS can't track callback mutations on plain variables.
+  const directUsage = { inputTokens: 0, outputTokens: 0, received: false }
+  const hasTools = !!sessionForRun.tools?.length && !NON_LANGGRAPH_PROVIDER_IDS.has(providerType)
+
   try {
-    const hasTools = !!sessionForRun.tools?.length && !CLI_PROVIDER_IDS.has(providerType)
     // Heartbeat runs are self-contained — skip conversation history to avoid
     // blowing past the context window on long-lived sessions.
     const heartbeatHistory = isAutoRunNoHistory ? [] : undefined
@@ -601,6 +606,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
           write: (raw: string) => parseAndEmit(raw),
           active,
           loadHistory: isAutoRunNoHistory ? () => [] : getSessionMessages,
+          onUsage: (u) => { directUsage.inputTokens = u.inputTokens; directUsage.outputTokens = u.outputTokens; directUsage.received = true },
         })
   } catch (err: any) {
     errorMessage = err?.message || String(err)
@@ -622,6 +628,34 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     markProviderSuccess(providerType)
   }
 
+  // Record usage for the direct (non-tools) streamChat path.
+  // streamAgentChat already calls appendUsage internally for the tools path.
+  if (!hasTools && fullResponse && !errorMessage) {
+    const inputTokens = directUsage.received ? directUsage.inputTokens : Math.ceil(message.length / 4)
+    const outputTokens = directUsage.received ? directUsage.outputTokens : Math.ceil(fullResponse.length / 4)
+    const totalTokens = inputTokens + outputTokens
+    if (totalTokens > 0) {
+      const cost = estimateCost(sessionForRun.model, inputTokens, outputTokens)
+      const history = getSessionMessages(sessionId)
+      const usageRecord: UsageRecord = {
+        sessionId,
+        messageIndex: history.length,
+        model: sessionForRun.model,
+        provider: providerType,
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        estimatedCost: cost,
+        timestamp: Date.now(),
+      }
+      appendUsage(sessionId, usageRecord)
+      emit({
+        t: 'md',
+        text: JSON.stringify({ usage: { inputTokens, outputTokens, totalTokens, estimatedCost: cost } }),
+      })
+    }
+  }
+
   const requestedToolNames = (!internal && source === 'chat')
     ? requestedToolNamesFromMessage(message)
     : []

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

@@ -0,0 +1,54 @@
+import { NextResponse } from 'next/server'
+import { notify } from './ws-hub'
+
+export interface CollectionOps<T> {
+  load: () => Record<string, T>
+  save: (data: Record<string, T>) => void
+  deleteFn?: (id: string) => void
+  topic?: string
+}
+
+/**
+ * Load → 404 check → mutate → save → notify.
+ * `fn` receives the item and the full collection, returns the updated item.
+ */
+export function mutateItem<T>(
+  ops: CollectionOps<T>,
+  id: string,
+  fn: (item: T, all: Record<string, T>) => T,
+): T | null {
+  const all = ops.load()
+  if (!all[id]) return null
+  all[id] = fn(all[id], all)
+  ops.save(all)
+  if (ops.topic) notify(ops.topic)
+  return all[id]
+}
+
+/**
+ * Load → 404 check → delete → notify.
+ * Uses `ops.deleteFn` if provided, otherwise inline `delete` + `save`.
+ */
+export function deleteItem<T>(
+  ops: CollectionOps<T>,
+  id: string,
+): boolean {
+  const all = ops.load()
+  if (!all[id]) return false
+  if (ops.deleteFn) {
+    ops.deleteFn(id)
+  } else {
+    delete all[id]
+    ops.save(all)
+  }
+  if (ops.topic) notify(ops.topic)
+  return true
+}
+
+export function notFound(msg = 'Not found') {
+  return NextResponse.json({ error: msg }, { status: 404 })
+}
+
+export function badRequest(msg: string) {
+  return NextResponse.json({ error: msg }, { status: 400 })
+}