@swarmclawai/swarmclaw 0.2.0

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

@@ -0,0 +1,83 @@
+'use client'
+
+import { useCallback, useRef, useState } from 'react'
+
+interface SpeechRecognitionErrorEvent {
+  error?: string
+}
+
+interface SpeechRecognitionEvent {
+  results: { [index: number]: { [index: number]: { transcript: string } } }
+}
+
+interface UseSpeechRecognitionOptions {
+  lang?: string
+}
+
+export function useSpeechRecognition(onResult: (text: string) => void, options?: UseSpeechRecognitionOptions) {
+  const [recording, setRecording] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const recogRef = useRef<{
+    stop: () => void
+    start: () => void
+    continuous: boolean
+    interimResults: boolean
+    lang: string
+    maxAlternatives?: number
+    onresult?: (e: SpeechRecognitionEvent) => void
+    onerror?: (e: SpeechRecognitionErrorEvent) => void
+    onend?: () => void
+  } | null>(null)
+
+  const toggle = useCallback(() => {
+    setError(null)
+    if (recording) {
+      recogRef.current?.stop()
+      setRecording(false)
+      return
+    }
+
+    const SR = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition
+    if (!SR) {
+      setError('Speech recognition is not supported in this browser.')
+      return
+    }
+
+    const recog = new SR()
+    recog.continuous = false
+    recog.interimResults = false
+    recog.maxAlternatives = 1
+    recog.lang = options?.lang || (typeof navigator !== 'undefined' ? navigator.language : 'en-US')
+
+    recog.onresult = (e: SpeechRecognitionEvent) => {
+      setRecording(false)
+      const transcript = e.results?.[0]?.[0]?.transcript?.trim() || ''
+      if (transcript) onResult(transcript)
+    }
+    recog.onerror = (e: SpeechRecognitionErrorEvent) => {
+      setRecording(false)
+      const code = e?.error || 'unknown'
+      const message = code === 'not-allowed'
+        ? 'Microphone access denied. Allow mic permission and try again.'
+        : code === 'no-speech'
+          ? 'No speech detected. Try again.'
+          : `Speech recognition error: ${code}`
+      setError(message)
+    }
+    recog.onend = () => setRecording(false)
+
+    recogRef.current = recog
+    setRecording(true)
+    try {
+      recog.start()
+    } catch {
+      setRecording(false)
+      setError('Could not start speech recognition.')
+    }
+  }, [recording, onResult, options?.lang])
+
+  const supported = typeof window !== 'undefined' &&
+    !!((window as any).SpeechRecognition || (window as any).webkitSpeechRecognition)
+
+  return { recording, toggle, supported, error }
+}

package/src/instrumentation.ts

@@ -0,0 +1,8 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { startScheduler } = await import('./lib/server/scheduler')
+    const { resumeQueue } = await import('./lib/server/queue')
+    startScheduler()
+    resumeQueue()
+  }
+}

package/src/lib/agents.ts

@@ -0,0 +1,13 @@
+import { api } from './api-client'
+import type { Agent } from '../types'
+
+export const fetchAgents = () => api<Record<string, Agent>>('GET', '/agents')
+
+export const createAgent = (data: Omit<Agent, 'id' | 'createdAt' | 'updatedAt'>) =>
+  api<Agent>('POST', '/agents', data)
+
+export const updateAgent = (id: string, data: Partial<Agent>) =>
+  api<Agent>('PUT', `/agents/${id}`, data)
+
+export const deleteAgent = (id: string) =>
+  api<string>('DELETE', `/agents/${id}`)

package/src/lib/api-client.ts

@@ -0,0 +1,100 @@
+const ACCESS_KEY_STORAGE = 'sc_access_key'
+const DEFAULT_API_TIMEOUT_MS = 12_000
+const DEFAULT_GET_RETRIES = 2
+const RETRY_DELAY_BASE_MS = 300
+
+export function getStoredAccessKey(): string {
+  if (typeof window === 'undefined') return ''
+  return localStorage.getItem(ACCESS_KEY_STORAGE) || ''
+}
+
+export function setStoredAccessKey(key: string) {
+  localStorage.setItem(ACCESS_KEY_STORAGE, key)
+}
+
+export function clearStoredAccessKey() {
+  localStorage.removeItem(ACCESS_KEY_STORAGE)
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function fetchWithTimeout(
+  input: RequestInfo | URL,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<Response> {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    return await fetch(input, { ...init, signal: controller.signal })
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+function isAbortError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false
+  return (err as { name?: string }).name === 'AbortError'
+}
+
+export async function api<T = unknown>(
+  method: string,
+  path: string,
+  body?: unknown,
+  options?: { timeoutMs?: number; retries?: number },
+): Promise<T> {
+  const key = getStoredAccessKey()
+  const timeoutMs = Math.max(1_000, Math.trunc(options?.timeoutMs ?? DEFAULT_API_TIMEOUT_MS))
+  const upperMethod = method.toUpperCase()
+  const retries = Math.max(0, Math.trunc(options?.retries ?? (upperMethod === 'GET' ? DEFAULT_GET_RETRIES : 0)))
+
+  const requestInit: RequestInit = {
+    method: upperMethod,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(key ? { 'X-Access-Key': key } : {}),
+    },
+  }
+  if (body) requestInit.body = JSON.stringify(body)
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const r = await fetchWithTimeout('/api' + path, requestInit, timeoutMs)
+
+      if (r.status === 401) {
+        // Clear stored key on auth failure, redirect to login
+        clearStoredAccessKey()
+        if (typeof window !== 'undefined') {
+          window.dispatchEvent(new Event('sc_auth_required'))
+        }
+        throw new Error('Unauthorized — invalid access key')
+      }
+
+      const ct = r.headers.get('content-type') || ''
+
+      if (!r.ok) {
+        if (ct.includes('json')) {
+          const payload = await r.json().catch(() => null) as { error?: unknown; message?: unknown } | null
+          const msg =
+            (typeof payload?.error === 'string' && payload.error.trim())
+            || (typeof payload?.message === 'string' && payload.message.trim())
+            || `Request failed (${r.status})`
+          throw new Error(msg)
+        }
+        const text = (await r.text().catch(() => '')).trim()
+        throw new Error(text || `Request failed (${r.status})`)
+      }
+
+      if (ct.includes('json')) return r.json() as Promise<T>
+      return r.text() as unknown as T
+    } catch (err) {
+      const isLastAttempt = attempt >= retries
+      const retryable = isAbortError(err) || (err instanceof TypeError && !String(err.message || '').includes('Unauthorized'))
+      if (isLastAttempt || !retryable) throw err
+      await sleep(RETRY_DELAY_BASE_MS * (attempt + 1))
+    }
+  }
+  throw new Error('Request failed')
+}

package/src/lib/chat.ts

@@ -0,0 +1,60 @@
+import type { SSEEvent } from '../types'
+import { getStoredAccessKey } from './api-client'
+
+interface StreamChatOptions {
+  internal?: boolean
+  queueMode?: 'followup' | 'steer' | 'collect'
+}
+
+export async function streamChat(
+  sessionId: string,
+  message: string,
+  imagePath?: string,
+  imageUrl?: string,
+  onEvent?: (event: SSEEvent) => void,
+  options?: StreamChatOptions,
+): Promise<void> {
+  const key = getStoredAccessKey()
+  const res = await fetch(`/api/sessions/${sessionId}/chat`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(key ? { 'X-Access-Key': key } : {}),
+    },
+    body: JSON.stringify({
+      message,
+      imagePath,
+      imageUrl,
+      internal: !!options?.internal,
+      queueMode: options?.queueMode,
+    }),
+  })
+
+  if (!res.ok || !res.body) {
+    onEvent?.({ t: 'err', text: `Request failed (${res.status})` })
+    onEvent?.({ t: 'done' })
+    return
+  }
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buf = ''
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    buf += decoder.decode(value, { stream: true })
+    const lines = buf.split('\n')
+    buf = lines.pop() || ''
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue
+      try {
+        const event = JSON.parse(line.slice(6)) as SSEEvent
+        // Forward all event types including tool_call and tool_result
+        onEvent?.(event)
+      } catch {
+        // skip malformed
+      }
+    }
+  }
+}

package/src/lib/memory.ts

@@ -0,0 +1,42 @@
+import { api } from './api-client'
+import type { MemoryEntry } from '../types'
+
+interface MemoryQueryOptions {
+  q?: string
+  agentId?: string
+  depth?: number
+  limit?: number
+  linkedLimit?: number
+  envelope?: boolean
+}
+
+export const searchMemory = (opts: MemoryQueryOptions = {}) => {
+  const params = new URLSearchParams()
+  if (opts.q) params.set('q', opts.q)
+  if (opts.agentId) params.set('agentId', opts.agentId)
+  if (typeof opts.depth === 'number') params.set('depth', String(opts.depth))
+  if (typeof opts.limit === 'number') params.set('limit', String(opts.limit))
+  if (typeof opts.linkedLimit === 'number') params.set('linkedLimit', String(opts.linkedLimit))
+  if (opts.envelope) params.set('envelope', 'true')
+  const qs = params.toString()
+  return api<MemoryEntry[]>('GET', `/memory${qs ? '?' + qs : ''}`)
+}
+
+export const getMemory = (id: string, opts: Omit<MemoryQueryOptions, 'q' | 'agentId'> = {}) => {
+  const params = new URLSearchParams()
+  if (typeof opts.depth === 'number') params.set('depth', String(opts.depth))
+  if (typeof opts.limit === 'number') params.set('limit', String(opts.limit))
+  if (typeof opts.linkedLimit === 'number') params.set('linkedLimit', String(opts.linkedLimit))
+  if (opts.envelope) params.set('envelope', 'true')
+  const qs = params.toString()
+  return api<MemoryEntry | MemoryEntry[]>('GET', `/memory/${id}${qs ? '?' + qs : ''}`)
+}
+
+export const createMemory = (data: Omit<MemoryEntry, 'id' | 'createdAt' | 'updatedAt'>) =>
+  api<MemoryEntry>('POST', '/memory', data)
+
+export const updateMemory = (id: string, data: Partial<MemoryEntry>) =>
+  api<MemoryEntry>('PUT', `/memory/${id}`, data)
+
+export const deleteMemory = (id: string) =>
+  api<string>('DELETE', `/memory/${id}`)

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

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  deriveOpenClawWsUrl,
+  normalizeOpenClawEndpoint,
+  normalizeProviderEndpoint,
+} from './openclaw-endpoint.ts'
+
+test('normalizeOpenClawEndpoint handles ws/http/path variants', () => {
+  assert.equal(
+    normalizeOpenClawEndpoint('ws://127.0.0.1:18789'),
+    'http://127.0.0.1:18789/v1',
+  )
+  assert.equal(
+    normalizeOpenClawEndpoint('http://localhost:18789'),
+    'http://localhost:18789/v1',
+  )
+  assert.equal(
+    normalizeOpenClawEndpoint('http://localhost:18789/v1/chat/completions'),
+    'http://localhost:18789/v1',
+  )
+})
+
+test('deriveOpenClawWsUrl strips v1 suffix and preserves host', () => {
+  assert.equal(
+    deriveOpenClawWsUrl('http://localhost:18789/v1'),
+    'ws://localhost:18789',
+  )
+  assert.equal(
+    deriveOpenClawWsUrl('https://openclaw.example.com/v1'),
+    'wss://openclaw.example.com',
+  )
+})
+
+test('normalizeProviderEndpoint only rewrites openclaw provider', () => {
+  assert.equal(
+    normalizeProviderEndpoint('openclaw', 'ws://localhost:18789'),
+    'http://localhost:18789/v1',
+  )
+  assert.equal(
+    normalizeProviderEndpoint('openai', 'https://api.openai.com/v1/'),
+    'https://api.openai.com/v1',
+  )
+  assert.equal(
+    normalizeProviderEndpoint('openai', null),
+    null,
+  )
+})

package/src/lib/openclaw-endpoint.ts

@@ -0,0 +1,67 @@
+const DEFAULT_OPENCLAW_ENDPOINT = 'http://localhost:18789/v1'
+
+function hasScheme(value: string): boolean {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(value)
+}
+
+function parseUrl(raw: string): URL | null {
+  const value = raw.trim()
+  if (!value) return null
+  try {
+    return new URL(hasScheme(value) ? value : `http://${value}`)
+  } catch {
+    return null
+  }
+}
+
+function toHttpProtocol(protocol: string): string {
+  if (protocol === 'ws:') return 'http:'
+  if (protocol === 'wss:') return 'https:'
+  return protocol
+}
+
+function cleanPath(pathname: string): string {
+  let path = pathname.replace(/\/+$/, '')
+  const lower = path.toLowerCase()
+
+  if (lower.endsWith('/chat/completions')) {
+    path = path.slice(0, -'/chat/completions'.length)
+  }
+  if (path.toLowerCase().endsWith('/models')) {
+    path = path.slice(0, -'/models'.length)
+  }
+
+  path = path.replace(/\/+$/, '')
+  if (!path || path === '/') return '/v1'
+  if (!/\/v1$/i.test(path)) return `${path}/v1`
+  return path
+}
+
+export function normalizeOpenClawEndpoint(input?: string | null): string {
+  const parsed = parseUrl(input || '') || parseUrl(DEFAULT_OPENCLAW_ENDPOINT)!
+  parsed.protocol = toHttpProtocol(parsed.protocol)
+  parsed.pathname = cleanPath(parsed.pathname || '/')
+  parsed.search = ''
+  parsed.hash = ''
+  return parsed.toString().replace(/\/+$/, '')
+}
+
+export function deriveOpenClawWsUrl(input?: string | null): string {
+  const api = normalizeOpenClawEndpoint(input)
+  const parsed = parseUrl(api) || parseUrl(DEFAULT_OPENCLAW_ENDPOINT)!
+  parsed.protocol = parsed.protocol === 'https:' ? 'wss:' : 'ws:'
+  parsed.pathname = parsed.pathname.replace(/\/v1$/i, '') || '/'
+  parsed.search = ''
+  parsed.hash = ''
+  const value = parsed.toString()
+  return value.endsWith('/') ? value.slice(0, -1) : value
+}
+
+export function normalizeProviderEndpoint(provider: string | null | undefined, endpoint: string | null | undefined): string | null {
+  if (typeof endpoint !== 'string') return null
+  const trimmed = endpoint.trim()
+  if (!trimmed) return null
+  if (provider === 'openclaw') return normalizeOpenClawEndpoint(trimmed)
+  return trimmed.replace(/\/+$/, '')
+}
+

package/src/lib/provider-config.ts

@@ -0,0 +1,13 @@
+import { api } from './api-client'
+import type { ProviderConfig } from '../types'
+
+export const fetchProviderConfigs = () => api<ProviderConfig[]>('GET', '/providers/configs')
+
+export const createProviderConfig = (data: Partial<ProviderConfig>) =>
+  api<ProviderConfig>('POST', '/providers', data)
+
+export const updateProviderConfig = (id: string, data: Partial<ProviderConfig>) =>
+  api<ProviderConfig>('PUT', `/providers/${id}`, data)
+
+export const deleteProviderConfig = (id: string) =>
+  api<{ ok: boolean }>('DELETE', `/providers/${id}`)

package/src/lib/providers/anthropic.ts

@@ -0,0 +1,135 @@
+import fs from 'fs'
+import https from 'https'
+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 fileToContentBlocks(filePath: string): any[] {
+  if (!filePath || !fs.existsSync(filePath)) return []
+  if (IMAGE_EXTS.test(filePath)) {
+    const data = fs.readFileSync(filePath).toString('base64')
+    const ext = filePath.split('.').pop()?.toLowerCase() || 'png'
+    const mediaType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
+    return [{ type: 'image', source: { type: 'base64', media_type: mediaType, data } }]
+  }
+  if (TEXT_EXTS.test(filePath) || filePath.endsWith('.pdf')) {
+    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()}]` }]
+}
+
+export function streamAnthropicChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory }: StreamChatOptions): Promise<string> {
+  return new Promise((resolve) => {
+    const messages = buildMessages(session, message, imagePath, loadHistory)
+    const model = session.model || 'claude-sonnet-4-6'
+
+    const body: Record<string, unknown> = {
+      model,
+      max_tokens: 8192,
+      messages,
+      stream: true,
+    }
+    if (systemPrompt) {
+      body.system = systemPrompt
+    }
+
+    const payload = JSON.stringify(body)
+    const abortController = { aborted: false }
+    let fullResponse = ''
+
+    const apiReq = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'x-api-key': apiKey || '',
+        'anthropic-version': '2023-06-01',
+        'Content-Type': 'application/json',
+      },
+    }, (apiRes) => {
+      if (apiRes.statusCode !== 200) {
+        let errBody = ''
+        apiRes.on('data', (c: Buffer) => errBody += c)
+        apiRes.on('end', () => {
+          console.error(`[${session.id}] anthropic error ${apiRes.statusCode}:`, errBody.slice(0, 200))
+          let errMsg = `Anthropic API error (${apiRes.statusCode})`
+          try {
+            const parsed = JSON.parse(errBody)
+            if (parsed.error?.message) errMsg = parsed.error.message
+          } catch {}
+          write(`data: ${JSON.stringify({ t: 'err', text: errMsg })}\n\n`)
+          active.delete(session.id)
+          resolve(fullResponse)
+        })
+        return
+      }
+
+      let buf = ''
+      apiRes.on('data', (chunk: Buffer) => {
+        if (abortController.aborted) return
+        buf += chunk.toString()
+        const lines = buf.split('\n')
+        buf = lines.pop()!
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue
+          const data = line.slice(6).trim()
+          if (!data) continue
+          try {
+            const parsed = JSON.parse(data)
+            if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+              fullResponse += parsed.delta.text
+              write(`data: ${JSON.stringify({ t: 'd', text: parsed.delta.text })}\n\n`)
+            }
+          } catch {}
+        }
+      })
+
+      apiRes.on('end', () => {
+        active.delete(session.id)
+        resolve(fullResponse)
+      })
+    })
+
+    active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
+
+    apiReq.on('error', (e) => {
+      console.error(`[${session.id}] anthropic request error:`, e.message)
+      write(`data: ${JSON.stringify({ t: 'err', text: e.message })}\n\n`)
+      active.delete(session.id)
+      resolve(fullResponse)
+    })
+
+    apiReq.end(payload)
+  })
+}
+
+function buildMessages(session: any, message: string, imagePath: string | undefined, loadHistory: (id: string) => any[]) {
+  const msgs: Array<{ role: string; content: any }> = []
+
+  if (loadHistory) {
+    const history = loadHistory(session.id)
+    for (const m of history) {
+      if (m.role === 'user' && m.imagePath) {
+        const blocks = fileToContentBlocks(m.imagePath)
+        msgs.push({ role: 'user', content: [...blocks, { type: 'text', text: m.text }] })
+      } else {
+        msgs.push({ role: m.role, content: m.text })
+      }
+    }
+  }
+
+  // Current message with optional attachment
+  if (imagePath) {
+    const blocks = fileToContentBlocks(imagePath)
+    msgs.push({ role: 'user', content: [...blocks, { type: 'text', text: message }] })
+  } else {
+    msgs.push({ role: 'user', content: message })
+  }
+  return msgs
+}