@swarmclawai/swarmclaw 1.3.6 → 1.4.2

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

@@ -513,7 +513,7 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
   const session = getSession(sessionId)
   if (!session) throw new Error(`Session not found: ${sessionId}`)
   const runStartedAt = Date.now()
-  const runMessageStartIndex = getMessageCount(sessionId)
+  let runMessageStartIndex = getMessageCount(sessionId)
 
   const appSettings = loadSettings()
   const lifecycleRunId = runId || `${sessionId}:${runStartedAt}`
@@ -725,17 +725,10 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
     }
   }
 
-  const providerType = sessionForRun.provider || 'claude-cli'
-  const provider = getProvider(providerType)
-  if (!provider) throw new Error(`Unknown provider: ${providerType}`)
-
-  if (providerType === 'claude-cli' && !fs.existsSync(session.cwd)) {
-    throw new Error(`Directory not found: ${session.cwd}`)
-  }
-
-  const apiKey = resolveApiKeyForSession(sessionForRun, provider)
-  const hideAssistantTranscript = internal && source === 'main-loop-followup'
-
+  // Persist the user message BEFORE provider/credential resolution so that if
+  // provider resolution throws (unknown provider, missing credentials, etc.),
+  // the user message is already in the DB and won't disappear from the chat
+  // when the frontend's refreshMessages overwrites the optimistic local copy.
   const shouldPersistUserMessage = shouldPersistInboundUserMessage(internal, source)
   if (shouldPersistUserMessage) {
     const [linkAnalysis, semantics] = await Promise.all([
@@ -805,8 +798,22 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
         }
       }
     }
+    // Update runMessageStartIndex to account for newly appended user message(s)
+    // so that partial persistence and finalization don't overwrite them.
+    runMessageStartIndex = getMessageCount(sessionId)
   }
 
+  const providerType = sessionForRun.provider || 'claude-cli'
+  const provider = getProvider(providerType)
+  if (!provider) throw new Error(`Unknown provider: ${providerType}`)
+
+  if (providerType === 'claude-cli' && !fs.existsSync(session.cwd)) {
+    throw new Error(`Directory not found: ${session.cwd}`)
+  }
+
+  const apiKey = resolveApiKeyForSession(sessionForRun, provider)
+  const hideAssistantTranscript = internal && source === 'main-loop-followup'
+
   const useLocalOpenClawNativeRuntime = providerType === 'openclaw' && isLocalOpenClawEndpoint(sessionForRun.apiEndpoint)
   const enabledSessionExtensions = getEnabledCapabilityIds(sessionForRun)
   const hasExtensions = enabledSessionExtensions.length > 0

package/src/lib/server/connectors/swarmdock.ts

@@ -22,7 +22,7 @@ interface SwarmDockConfig {
 function parseConfig(connector: Connector): SwarmDockConfig {
   const c = connector.config || {}
   return {
-    apiUrl: c.apiUrl || 'https://api.swarmdock.ai',
+    apiUrl: c.apiUrl || 'https://swarmdock-api.onrender.com',
     walletAddress: c.walletAddress || '',
     agentDescription: c.agentDescription || connector.name || '',
     skills: c.skills || '',

package/src/lib/server/extensions.ts

@@ -874,6 +874,17 @@ class ExtensionManager {
     try {
       const parsed = JSON.parse(fs.readFileSync(EXTENSION_FAILURES, 'utf8')) as Record<string, ExtensionFailureRecord>
       if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
+      // Prune records older than 7 days
+      const maxAgeMs = 7 * 24 * 60 * 60 * 1000
+      const now = Date.now()
+      let pruned = false
+      for (const key of Object.keys(parsed)) {
+        if (now - (parsed[key].lastFailedAt || 0) > maxAgeMs) {
+          delete parsed[key]
+          pruned = true
+        }
+      }
+      if (pruned) this.writeFailureState(parsed)
       return parsed
     } catch {
       return {}

package/src/lib/server/messages/message-repository.ts

@@ -286,6 +286,37 @@ export function clearMessages(sessionId: string): void {
 /** Replace the entire message list (used after in-memory prune operations). */
 export function replaceAllMessages(sessionId: string, messages: Message[]): void {
   perf.measureSync('message-repo', 'replaceAllMessages', () => {
+    // Safety guard: reload current user messages from DB and ensure none are
+    // dropped by the replacement. This prevents races where partial persistence
+    // or finalization load a stale snapshot that's missing recently-appended
+    // user messages.
+    const currentRows = stmts().selectAll.all(sessionId) as Array<{ data: string }>
+    const currentUserMessages: Message[] = []
+    for (const row of currentRows) {
+      const m = parseMsg(row.data)
+      if (m && m.role === 'user') currentUserMessages.push(m)
+    }
+    const replacementUserTimes = new Set(
+      messages.filter(m => m.role === 'user' && typeof m.time === 'number').map(m => m.time),
+    )
+    const missingUsers = currentUserMessages.filter(
+      m => typeof m.time === 'number' && !replacementUserTimes.has(m.time),
+    )
+    if (missingUsers.length > 0) {
+      // Re-insert missing user messages at their correct position (before the
+      // first assistant message that follows them chronologically).
+      for (const user of missingUsers) {
+        let insertIdx = messages.length
+        for (let i = 0; i < messages.length; i++) {
+          if (messages[i].role === 'assistant' && typeof messages[i].time === 'number'
+              && (messages[i].time as number) >= (user.time as number)) {
+            insertIdx = i
+            break
+          }
+        }
+        messages.splice(insertIdx, 0, user)
+      }
+    }
     withTransaction(() => {
       stmts().deleteAll.run(sessionId)
       const ins = stmts().insert

package/src/lib/server/openclaw/sync.ts

@@ -381,7 +381,7 @@ export function syncExtensionsFromOpenClaw(): { imported: number } {
   const openclawExtensionDir = path.join(config.workspacePath, 'plugins')
   if (!fs.existsSync(openclawExtensionDir)) return { imported: 0 }
 
-  const localExtensionDir = path.join(DATA_DIR, 'plugins')
+  const localExtensionDir = path.join(DATA_DIR, 'extensions')
   ensureDir(localExtensionDir)
 
   const files = fs.readdirSync(openclawExtensionDir).filter((f) => f.endsWith('.js'))
@@ -432,7 +432,7 @@ export function setSharedDeviceToken(token: string): void {
 
 // --- Unified Sync Entry Point ---
 
-export type SyncType = 'memory' | 'workspace' | 'schedules' | 'credentials' | 'plugins'
+export type SyncType = 'memory' | 'workspace' | 'schedules' | 'credentials' | 'extensions'
 
 export interface SyncResult {
   type: SyncType
@@ -467,7 +467,7 @@ export async function runSync(params: {
         case 'credentials':
           results.push({ type, action: 'push', result: pushCredentialsToOpenClaw() })
           break
-        case 'plugins':
+        case 'extensions':
           // Extensions only pull from OpenClaw
           break
       }
@@ -492,7 +492,7 @@ export async function runSync(params: {
         case 'credentials':
           results.push({ type, action: 'pull', result: await pullCredentialsFromOpenClaw() })
           break
-        case 'plugins':
+        case 'extensions':
           results.push({ type, action: 'pull', result: syncExtensionsFromOpenClaw() })
           break
       }

package/src/lib/server/protocols/protocol-a2a-delegate.ts

@@ -0,0 +1,135 @@
+import { genId } from '@/lib/id'
+import { log } from '@/lib/server/logger'
+import { errorMessage } from '@/lib/shared-utils'
+import { upsertTask } from '@/lib/server/tasks/task-repository'
+import { notify } from '@/lib/server/ws-hub'
+import { callA2AAgent } from '@/lib/a2a/client'
+import { loadExternalAgents } from '@/lib/server/storage'
+import { appendProtocolEvent, persistRun } from '@/lib/server/protocols/protocol-agent-turn'
+import { now } from '@/lib/server/protocols/protocol-types'
+import type { ProtocolRunDeps } from '@/lib/server/protocols/protocol-types'
+import type { ProtocolPhaseDefinition, ProtocolRun, ProtocolRunPhaseState } from '@/types/protocol'
+import type { BoardTask } from '@/types/task'
+
+const TAG = 'protocol-a2a-delegate'
+
+/**
+ * Process an a2a_delegate phase: call a remote A2A agent and wait for the result.
+ *
+ * Follows the same pattern as processDispatchDelegationPhase:
+ * 1. Create a BoardTask for tracking (with protocolRunId so wakeProtocolRunFromTaskCompletion fires)
+ * 2. Call the remote agent via HTTP
+ * 3. Set protocol run to 'waiting'
+ * 4. When the HTTP call completes, update the task → wake machinery resumes the run
+ */
+export function processA2ADelegatePhase(
+  run: ProtocolRun,
+  phase: ProtocolPhaseDefinition,
+  deps?: ProtocolRunDeps,
+): ProtocolRun {
+  const config = phase.a2aDelegateConfig
+  if (!config?.taskName || !config?.taskMessage) {
+    appendProtocolEvent(run.id, {
+      type: 'failed',
+      phaseId: phase.id,
+      summary: `a2a_delegate phase "${phase.label}" missing a2aDelegateConfig`,
+    }, deps)
+    return persistRun({
+      ...run,
+      status: 'failed',
+      lastError: `a2a_delegate phase "${phase.label}" missing a2aDelegateConfig`,
+      endedAt: run.endedAt || now(deps),
+      updatedAt: now(deps),
+    })
+  }
+
+  // Resolve target URL
+  let targetUrl = config.targetUrl
+  if (!targetUrl && config.targetExternalAgentId) {
+    const externalAgents = loadExternalAgents()
+    const ea = externalAgents[config.targetExternalAgentId]
+    if (ea?.endpoint) {
+      targetUrl = ea.endpoint
+    }
+  }
+
+  if (!targetUrl) {
+    appendProtocolEvent(run.id, {
+      type: 'failed',
+      phaseId: phase.id,
+      summary: `a2a_delegate phase "${phase.label}" — no target URL resolved`,
+    }, deps)
+    return persistRun({
+      ...run,
+      status: 'failed',
+      lastError: `a2a_delegate phase "${phase.label}" — could not resolve target A2A agent URL`,
+      endedAt: run.endedAt || now(deps),
+      updatedAt: now(deps),
+    })
+  }
+
+  // Create a BoardTask for tracking
+  const taskId = genId()
+  const taskData: BoardTask = {
+    id: taskId,
+    title: `A2A: ${config.taskName}`,
+    description: config.taskMessage,
+    status: 'queued',
+    agentId: run.facilitatorAgentId || run.participantAgentIds?.[0] || '',
+    protocolRunId: run.id,
+    sourceType: 'delegation',
+    externalSource: { source: 'a2a', id: taskId },
+    queuedAt: now(deps),
+    createdAt: now(deps),
+    updatedAt: now(deps),
+  }
+  upsertTask(taskId, taskData)
+  notify('tasks')
+
+  appendProtocolEvent(run.id, {
+    type: 'delegation_dispatched',
+    summary: `Dispatched A2A delegation to ${targetUrl}: ${config.taskName}`,
+    phaseId: phase.id,
+    taskId,
+  }, deps)
+
+  log.info(TAG, `Calling remote A2A agent at ${targetUrl}`, { taskName: config.taskName, taskId })
+
+  // Fire the HTTP call asynchronously — when it completes, update the task
+  // The existing wakeProtocolRunFromTaskCompletion machinery will resume the run
+  const resolvedUrl = targetUrl
+  callA2AAgent(resolvedUrl, 'executeTask', {
+    taskId,
+    taskName: config.taskName,
+    message: config.taskMessage,
+  }, {
+    timeout: config.timeoutMs ?? 300_000,
+    credentialId: config.credentialId,
+  }).then(result => {
+    const resultStr = typeof result === 'string' ? result : JSON.stringify(result)
+    upsertTask(taskId, { ...taskData, status: 'completed', result: resultStr, updatedAt: Date.now(), completedAt: Date.now() })
+    notify('tasks')
+    log.info(TAG, `A2A delegation completed for task ${taskId}`)
+    // Dynamic import to break circular dependency (protocol-step-processors → protocol-a2a-delegate → protocol-run-lifecycle → protocol-step-processors)
+    import('@/lib/server/protocols/protocol-run-lifecycle').then(m => m.wakeProtocolRunFromTaskCompletion(taskId))
+  }).catch(err => {
+    log.error(TAG, `A2A delegation failed for task ${taskId}: ${errorMessage(err)}`)
+    if (config.onFailure === 'advance_with_warning') {
+      upsertTask(taskId, { ...taskData, status: 'completed', result: `A2A delegation failed: ${errorMessage(err)}`, error: errorMessage(err), updatedAt: Date.now(), completedAt: Date.now() })
+    } else {
+      upsertTask(taskId, { ...taskData, status: 'failed', error: errorMessage(err), updatedAt: Date.now() })
+    }
+    notify('tasks')
+    import('@/lib/server/protocols/protocol-run-lifecycle').then(m => m.wakeProtocolRunFromTaskCompletion(taskId))
+  })
+
+  const createdTaskIds = [...(run.createdTaskIds || []), taskId]
+  return persistRun({
+    ...run,
+    status: 'waiting',
+    waitingReason: `Waiting for A2A delegation: ${config.taskName}`,
+    createdTaskIds,
+    phaseState: { ...(run.phaseState || { phaseId: phase.id }), dispatchedTaskId: taskId } as ProtocolRunPhaseState,
+    updatedAt: now(deps),
+  })
+}

package/src/lib/server/protocols/protocol-normalization.ts

@@ -171,6 +171,7 @@ function isDiscussionStepKindLocal(kind: string): boolean {
     'wait',
     'dispatch_task',
     'dispatch_delegation',
+    'a2a_delegate',
   ].includes(kind)
 }
 

package/src/lib/server/protocols/protocol-step-helpers.test.ts

@@ -48,7 +48,7 @@ describe('protocol-step-helpers', () => {
       const kinds = [
         'present', 'collect_independent_inputs', 'round_robin',
         'compare', 'decide', 'summarize', 'emit_tasks', 'wait',
-        'dispatch_task', 'dispatch_delegation',
+        'dispatch_task', 'dispatch_delegation', 'a2a_delegate',
       ]
       for (const kind of kinds) {
         const step = { id: `step-${kind}`, kind, label: kind } as never

package/src/lib/server/protocols/protocol-step-helpers.ts

@@ -58,6 +58,7 @@ export function phaseFromStep(step: ProtocolStepDefinition): ProtocolPhaseDefini
     completionCriteria: step.completionCriteria || null,
     taskConfig: step.taskConfig || null,
     delegationConfig: step.delegationConfig || null,
+    a2aDelegateConfig: step.a2aDelegateConfig || null,
   }
 }
 

package/src/lib/server/protocols/protocol-step-processors.ts

@@ -23,6 +23,7 @@ import type * as ProtocolRunLifecycle from '@/lib/server/protocols/protocol-run-
 import { processForEachStep } from '@/lib/server/protocols/protocol-foreach'
 import { processSubflowStep } from '@/lib/server/protocols/protocol-subflow'
 import { processSwarmStep } from '@/lib/server/protocols/protocol-swarm'
+import { processA2ADelegatePhase } from '@/lib/server/protocols/protocol-a2a-delegate'
 import { findRunStep } from '@/lib/server/protocols/protocol-normalization'
 import {
   appendProtocolEvent,
@@ -708,6 +709,7 @@ export async function stepProtocolRun(run: ProtocolRun, deps?: ProtocolRunDeps):
     if (phase.kind === 'emit_tasks') return processEmitTasksPhase(started, phase, deps)
     if (phase.kind === 'dispatch_task') return processDispatchTaskPhase(started, phase, deps)
     if (phase.kind === 'dispatch_delegation') return processDispatchDelegationPhase(started, phase, deps)
+    if (phase.kind === 'a2a_delegate') return processA2ADelegatePhase(started, phase, deps)
     return processWaitPhase(started, phase, deps)
   }
   if (step.kind === 'branch') return processBranchStep(run, step, deps)

package/src/lib/server/protocols/protocol-types.ts

@@ -150,5 +150,6 @@ export function isDiscussionStepKind(kind: ProtocolStepDefinition['kind'] | Prot
     'wait',
     'dispatch_task',
     'dispatch_delegation',
+    'a2a_delegate',
   ].includes(kind)
 }

package/src/lib/server/provider-health.ts

@@ -1,6 +1,9 @@
 import { spawnSync } from 'child_process'
 import { errorMessage, hmrSingleton, jitteredBackoff } from '@/lib/shared-utils'
 import { upsertStoredItem, loadCollection } from './storage'
+import { log } from './logger'
+
+const TAG = 'provider-health'
 
 type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli'
 
@@ -72,7 +75,12 @@ export function markProviderFailure(providerId: string, error: string, credentia
   })
   try {
     upsertStoredItem('provider_health', key, states.get(key)!)
-  } catch {}
+  } catch (err) {
+    log.warn(TAG, 'Failed to persist provider failure state', {
+      providerKey: key,
+      error: errorMessage(err),
+    })
+  }
 }
 
 export function markProviderSuccess(providerId: string, credentialId?: string | null): void {
@@ -88,7 +96,12 @@ export function markProviderSuccess(providerId: string, credentialId?: string |
   })
   try {
     upsertStoredItem('provider_health', key, states.get(key)!)
-  } catch {}
+  } catch (err) {
+    log.warn(TAG, 'Failed to persist provider success state', {
+      providerKey: key,
+      error: errorMessage(err),
+    })
+  }
 }
 
 export function isProviderCoolingDown(providerId: string, credentialId?: string | null): boolean {
@@ -195,7 +208,10 @@ export function restoreProviderHealthState(): number {
       }
     }
     return restored
-  } catch { return 0 }
+  } catch (err) {
+    log.warn(TAG, 'Failed to restore persisted provider health state', { error: errorMessage(err) })
+    return 0
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/lib/server/safe-parse-body.test.ts

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict'
 import { describe, it, before, after } from 'node:test'
+import { z } from 'zod'
 
 let safeParseBody: typeof import('@/lib/server/safe-parse-body').safeParseBody
 before(async () => {
@@ -50,4 +51,35 @@ describe('safeParseBody', () => {
     assert.equal(result.data!.name, 'test')
     assert.equal(result.data!.count, 7)
   })
+
+  it('validates the parsed body against a provided zod schema', async () => {
+    const result = await safeParseBody(
+      jsonRequest(JSON.stringify({ name: 'ok', count: 3 })),
+      z.object({
+        name: z.string().min(1),
+        count: z.number().int().nonnegative(),
+      }),
+    )
+    assert.equal(result.error, undefined)
+    assert.deepEqual(result.data, { name: 'ok', count: 3 })
+  })
+
+  it('returns a 400 validation error when schema parsing fails', async () => {
+    const result = await safeParseBody(
+      jsonRequest(JSON.stringify({ name: '', count: -1 })),
+      z.object({
+        name: z.string().min(1, 'name is required'),
+        count: z.number().int().nonnegative('count must be non-negative'),
+      }),
+    )
+    assert.equal(result.data, undefined)
+    assert.ok(result.error)
+    assert.equal(result.error.status, 400)
+    const body = await result.error.json()
+    assert.equal(body.error, 'Validation failed')
+    assert.deepEqual(body.issues, [
+      { path: 'name', message: 'name is required' },
+      { path: 'count', message: 'count must be non-negative' },
+    ])
+  })
 })

package/src/lib/server/safe-parse-body.ts

@@ -1,4 +1,7 @@
 import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
+import { formatZodError } from '@/lib/validation/schemas'
 
 type SafeResult<T> = { data: T; error?: never } | { data?: never; error: NextResponse }
 
@@ -6,11 +9,25 @@ type SafeResult<T> = { data: T; error?: never } | { data?: never; error: NextRes
  * Wraps `req.json()` so malformed/empty bodies return a 400
  * instead of throwing an unhandled error (500).
  */
-export async function safeParseBody<T = Record<string, unknown>>(req: Request): Promise<SafeResult<T>> {
+export async function safeParseBody<T = Record<string, unknown>>(
+  req: Request,
+  schema?: z.ZodType<T>,
+): Promise<SafeResult<T>> {
+  let raw: unknown
   try {
-    const data = (await req.json()) as T
-    return { data }
+    raw = await req.json()
   } catch {
     return { error: NextResponse.json({ error: 'Invalid or missing request body' }, { status: 400 }) }
   }
+
+  if (!schema) {
+    return { data: raw as T }
+  }
+
+  const parsed = schema.safeParse(raw)
+  if (!parsed.success) {
+    return { error: NextResponse.json(formatZodError(parsed.error), { status: 400 }) }
+  }
+
+  return { data: parsed.data }
 }