@swarmclawai/swarmclaw 0.4.0 → 0.5.0

package/src/lib/providers/openclaw.ts

@@ -63,6 +63,18 @@ function tryLoadIdentityFile(filePath: string): DeviceIdentity | null {
 }
 
 function loadOrCreateDeviceIdentity(): DeviceIdentity {
+  // 0. Check shared device token for cross-synced identity
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    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)
@@ -333,8 +345,22 @@ export function streamOpenClawChat({ session, message, imagePath, apiKey, write,
             for (const p of payloads) {
               const text = typeof p.text === 'string' ? p.text.trimEnd() : ''
               if (text) {
-                fullResponse += text
-                write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+                // Detect [[trace]], [[tool]], [[tool-result]], [[meta]] prefixes
+                const traceMatch = text.match(/^\[\[(thinking|tool|tool-result|trace|meta)\]\]/)
+                if (traceMatch) {
+                  const traceType = traceMatch[1]
+                  const traceContent = text.slice(traceMatch[0].length)
+                  if (traceType === 'meta') {
+                    write(`data: ${JSON.stringify({ t: 'md', text: traceContent })}\n\n`)
+                  } else {
+                    // Include as text (client-side will parse trace markers)
+                    fullResponse += text
+                    write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+                  }
+                } else {
+                  fullResponse += text
+                  write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+                }
               }
             }
             if (!fullResponse && msg.payload?.summary) {

package/src/lib/runtime-loop.ts

@@ -11,5 +11,5 @@ export const DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES = 60
 
 // Tool/process timeouts
 export const DEFAULT_SHELL_COMMAND_TIMEOUT_SEC = 30
-export const DEFAULT_CLAUDE_CODE_TIMEOUT_SEC = 120
-export const DEFAULT_CLI_PROCESS_TIMEOUT_SEC = 300
+export const DEFAULT_CLAUDE_CODE_TIMEOUT_SEC = 1800
+export const DEFAULT_CLI_PROCESS_TIMEOUT_SEC = 1800

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 {
@@ -342,13 +343,27 @@ function resolveApiKeyForSession(session: SessionWithCredentials, provider: Prov
 
 function classifyHeartbeatResponse(text: string, ackMaxChars: number): 'suppress' | 'strip' | 'keep' {
   const trimmed = text.trim()
-  if (trimmed === 'HEARTBEAT_OK') return 'suppress'
-  const stripped = trimmed.replace(/HEARTBEAT_OK/gi, '').trim()
+  if (trimmed === 'HEARTBEAT_OK' || trimmed === 'NO_MESSAGE') return 'suppress'
+  const stripped = trimmed.replace(/HEARTBEAT_OK/gi, '').replace(/NO_MESSAGE/gi, '').trim()
   if (!stripped) return 'suppress'
   if (stripped.length <= ackMaxChars) return 'suppress'
   return stripped.length < trimmed.length ? 'strip' : 'keep'
 }
 
+function estimateConversationTone(text: string): string {
+  const t = text || ''
+  // Technical: code blocks, function signatures, technical terms
+  if (/```/.test(t) || /\b(function|const|let|var|import|export|class|interface|async|await|return)\b/.test(t)) return 'technical'
+  if (/\b(error|bug|debug|stack trace|exception|null|undefined|TypeError)\b/i.test(t)) return 'technical'
+  // Empathetic: emotional/supportive language
+  if (/\b(understand|feel|sorry|empathize|appreciate|grateful|tough|difficult|challenging)\b/i.test(t)) return 'empathetic'
+  // Formal: academic/business language
+  if (/\b(furthermore|regarding|consequently|therefore|henceforth|pursuant|accordingly|notwithstanding)\b/i.test(t)) return 'formal'
+  // Casual: contractions, exclamations, informal language
+  if (/\b(gonna|wanna|gotta|yeah|hey|awesome|cool|lol|btw|tbh)\b/i.test(t) || /!{2,}/.test(t)) return 'casual'
+  return 'neutral'
+}
+
 const AUTO_MEMORY_MIN_INTERVAL_MS = 45 * 60 * 1000
 
 function normalizeMemoryText(value: string): string {
@@ -572,8 +587,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 +620,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 +642,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)
     : []
@@ -782,6 +830,26 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const finalText = (fullResponse || '').trim() || (!internal && errorMessage ? `Error: ${errorMessage}` : '')
   const textForPersistence = stripMainLoopMetaForPersistence(finalText, internal)
 
+  // Emit status SSE event from [MAIN_LOOP_META] if present
+  if (internal && finalText) {
+    const metaMatch = finalText.match(/\[MAIN_LOOP_META\]\s*(\{[^\n]*\})/i)
+    if (metaMatch) {
+      try {
+        const meta = JSON.parse(metaMatch[1])
+        const statusPayload: Record<string, string | undefined> = {}
+        if (meta.goal) statusPayload.goal = String(meta.goal)
+        if (meta.status) statusPayload.status = String(meta.status)
+        if (meta.summary) statusPayload.summary = String(meta.summary)
+        if (meta.next_action) statusPayload.nextAction = String(meta.next_action)
+        if (Object.keys(statusPayload).length > 0) {
+          emit({ t: 'status', text: JSON.stringify(statusPayload) })
+        }
+      } catch {
+        // ignore malformed meta JSON
+      }
+    }
+  }
+
   // HEARTBEAT_OK suppression
   const heartbeatConfig = input.heartbeatConfig
   let heartbeatClassification: 'suppress' | 'strip' | 'keep' | null = null
@@ -841,6 +909,14 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       })
       changed = true
 
+      // Conversation tone detection
+      if (!internal) {
+        const tone = estimateConversationTone(persistedText)
+        if (tone !== current.conversationTone) {
+          current.conversationTone = tone
+        }
+      }
+
       // Target routing for non-suppressed heartbeat alerts
       if (isHeartbeatRun && heartbeatConfig?.target && heartbeatConfig.target !== 'none' && heartbeatConfig.showAlerts !== false) {
         try {

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

package/src/lib/server/connectors/bluebubbles.test.ts

@@ -0,0 +1,217 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import bluebubbles from './bluebubbles.ts'
+import type { Connector } from '@/types'
+import type { InboundMessage } from './types'
+
+type FetchCall = {
+  url: string
+  init?: RequestInit
+}
+
+type MockResponse = {
+  ok: boolean
+  status: number
+  json: () => Promise<unknown>
+  text: () => Promise<string>
+}
+
+function jsonResponse(status: number, body: unknown): MockResponse {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+    text: async () => JSON.stringify(body),
+  }
+}
+
+function textResponse(status: number, text: string): MockResponse {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => {
+      throw new Error('not json')
+    },
+    text: async () => text,
+  }
+}
+
+const originalFetch = globalThis.fetch
+
+test.afterEach(() => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(globalThis as any).fetch = originalFetch
+})
+
+test('bluebubbles connector processes inbound webhook payloads and sends replies', async () => {
+  const calls: FetchCall[] = []
+  const queue: MockResponse[] = [
+    jsonResponse(200, { ok: true }), // ping
+    jsonResponse(200, { data: { guid: 'msg-1' } }), // send reply
+  ]
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(globalThis as any).fetch = async (url: string, init?: RequestInit) => {
+    calls.push({ url: String(url), init })
+    const next = queue.shift()
+    assert.ok(next, 'unexpected fetch call')
+    return next
+  }
+
+  const received: InboundMessage[] = []
+  const connector = {
+    id: 'bb-1',
+    name: 'BlueBubbles Test',
+    platform: 'bluebubbles',
+    agentId: 'agent-1',
+    credentialId: null,
+    config: {
+      serverUrl: 'http://127.0.0.1:1234',
+    },
+    isEnabled: true,
+    status: 'running',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  } as unknown as Connector
+
+  const instance = await bluebubbles.start(connector, 'pw-test', async (msg) => {
+    received.push(msg)
+    return 'pong'
+  })
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handler = (globalThis as any).__swarmclaw_bluebubbles_handler_bb_1__
+    assert.equal(typeof handler, 'undefined', 'sanity: wrong handler key should be undefined')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const validHandler = (globalThis as any)[`__swarmclaw_bluebubbles_handler_${connector.id}__`]
+    assert.equal(typeof validHandler, 'function')
+
+    await validHandler({
+      type: 'new-message',
+      data: {
+        guid: 'm-123',
+        text: 'hello there',
+        isFromMe: false,
+        isGroup: false,
+        handle: { address: '+15551234567', displayName: 'Alice' },
+        chatGuid: 'iMessage;-;+15551234567',
+      },
+    })
+
+    assert.equal(received.length, 1)
+    assert.equal(received[0].text, 'hello there')
+    assert.equal(received[0].senderId, '+15551234567')
+    assert.equal(received[0].channelId, 'iMessage;-;+15551234567')
+
+    assert.equal(calls.length, 2)
+    assert.ok(calls[0].url.includes('/api/v1/ping'))
+    assert.ok(calls[1].url.includes('/api/v1/message/text'))
+
+    const body = JSON.parse(String(calls[1].init?.body || '{}'))
+    assert.equal(body.chatGuid, 'iMessage;-;+15551234567')
+    assert.equal(body.message, 'pong')
+  } finally {
+    await instance.stop()
+  }
+})
+
+test('bluebubbles connector supports array-wrapped webhook payload and NO_MESSAGE suppression', async () => {
+  const calls: FetchCall[] = []
+  const queue: MockResponse[] = [
+    jsonResponse(200, { ok: true }), // ping
+  ]
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(globalThis as any).fetch = async (url: string, init?: RequestInit) => {
+    calls.push({ url: String(url), init })
+    const next = queue.shift()
+    assert.ok(next, 'unexpected fetch call')
+    return next
+  }
+
+  const connector = {
+    id: 'bb-2',
+    name: 'BlueBubbles Test 2',
+    platform: 'bluebubbles',
+    agentId: 'agent-2',
+    credentialId: null,
+    config: {
+      serverUrl: 'http://127.0.0.1:1234',
+    },
+    isEnabled: true,
+    status: 'running',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  } as unknown as Connector
+
+  const instance = await bluebubbles.start(connector, 'pw-test', async () => 'NO_MESSAGE')
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handler = (globalThis as any)[`__swarmclaw_bluebubbles_handler_${connector.id}__`]
+    assert.equal(typeof handler, 'function')
+
+    await handler({
+      type: 'new-message',
+      data: [
+        {
+          guid: 'm-124',
+          text: '',
+          isFromMe: false,
+          handle: { address: 'test@example.com', displayName: 'Taylor' },
+          chatGuid: 'iMessage;-;test@example.com',
+          attachments: [{ mimeType: 'image/png', transferName: 'a.png', totalBytes: 128 }],
+        },
+      ],
+    })
+
+    assert.equal(calls.length, 1, 'should not call send endpoint when NO_MESSAGE is returned')
+  } finally {
+    await instance.stop()
+  }
+})
+
+test('bluebubbles sendMessage posts to message/text endpoint', async () => {
+  const calls: FetchCall[] = []
+  const queue: MockResponse[] = [
+    jsonResponse(200, { ok: true }), // ping
+    textResponse(200, ''), // send
+  ]
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(globalThis as any).fetch = async (url: string, init?: RequestInit) => {
+    calls.push({ url: String(url), init })
+    const next = queue.shift()
+    assert.ok(next, 'unexpected fetch call')
+    return next
+  }
+
+  const connector = {
+    id: 'bb-3',
+    name: 'BlueBubbles Test 3',
+    platform: 'bluebubbles',
+    agentId: 'agent-3',
+    credentialId: null,
+    config: {
+      serverUrl: 'http://127.0.0.1:1234',
+    },
+    isEnabled: true,
+    status: 'running',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  } as unknown as Connector
+
+  const instance = await bluebubbles.start(connector, 'pw-test', async () => 'ok')
+
+  try {
+    await instance.sendMessage?.('iMessage;-;+15550001111', 'hello outbound')
+    assert.equal(calls.length, 2)
+    assert.ok(calls[1].url.includes('/api/v1/message/text'))
+    const body = JSON.parse(String(calls[1].init?.body || '{}'))
+    assert.equal(body.chatGuid, 'iMessage;-;+15550001111')
+    assert.equal(body.message, 'hello outbound')
+  } finally {
+    await instance.stop()
+  }
+})