@swarmclawai/swarmclaw 1.3.6 → 1.4.0

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