@swarmclawai/swarmclaw 1.3.6 → 1.4.0

package/src/features/swarmfeed/post-card.tsx

@@ -0,0 +1,114 @@
+'use client'
+
+import { useState } from 'react'
+import { AgentAvatar } from '@/components/agents/agent-avatar'
+import type { SwarmFeedPost } from '@/types/swarmfeed'
+
+function formatTimestamp(iso: string): string {
+  const diff = Date.now() - new Date(iso).getTime()
+  const sec = Math.floor(diff / 1000)
+  if (sec < 60) return 'just now'
+  const min = Math.floor(sec / 60)
+  if (min < 60) return `${min}m`
+  const hrs = Math.floor(min / 60)
+  if (hrs < 24) return `${hrs}h`
+  const days = Math.floor(hrs / 24)
+  return `${days}d`
+}
+
+export function PostCard({ post, onLike, onRepost }: {
+  post: SwarmFeedPost
+  onLike?: (postId: string) => void
+  onRepost?: (postId: string) => void
+}) {
+  const [liked, setLiked] = useState(false)
+  const [reposted, setReposted] = useState(false)
+  const [localLikeCount, setLocalLikeCount] = useState(post.likeCount)
+  const [localRepostCount, setLocalRepostCount] = useState(post.repostCount)
+
+  const handleLike = () => {
+    if (!liked) {
+      setLiked(true)
+      setLocalLikeCount((c) => c + 1)
+      onLike?.(post.id)
+    }
+  }
+
+  const handleRepost = () => {
+    if (!reposted) {
+      setReposted(true)
+      setLocalRepostCount((c) => c + 1)
+      onRepost?.(post.id)
+    }
+  }
+
+  return (
+    <div className="rounded-[16px] border border-white/[0.06] bg-surface/70 p-4 sm:p-5 transition-all hover:bg-surface/90">
+      {/* Agent header */}
+      <div className="flex items-center gap-3 mb-3">
+        <AgentAvatar
+          seed={post.agent?.id || post.agentId}
+          avatarUrl={post.agent?.avatar || null}
+          name={post.agent?.name || 'Agent'}
+          size={36}
+        />
+        <div className="min-w-0 flex-1">
+          <div className="flex items-center gap-2">
+            <span className="font-display text-[14px] font-600 text-text truncate">
+              {post.agent?.name || 'Unknown Agent'}
+            </span>
+            <span className="text-[12px] text-text-3/60">{formatTimestamp(post.createdAt)}</span>
+          </div>
+          {post.channelId && (
+            <span className="text-[11px] text-accent-bright/70 font-500">#{post.channelId}</span>
+          )}
+        </div>
+      </div>
+
+      {/* Content */}
+      <div className="text-[14px] leading-[1.65] text-text/90 whitespace-pre-wrap break-words mb-4">
+        {post.content}
+      </div>
+
+      {/* Engagement bar */}
+      <div className="flex items-center gap-5 text-text-3/60">
+        <button
+          onClick={handleLike}
+          className={`flex items-center gap-1.5 text-[12px] font-500 transition-colors bg-transparent border-none cursor-pointer
+            ${liked ? 'text-rose-400' : 'text-text-3/60 hover:text-rose-400'}`}
+        >
+          <svg width="15" height="15" viewBox="0 0 24 24" fill={liked ? 'currentColor' : 'none'} stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <path d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z" />
+          </svg>
+          {localLikeCount > 0 && <span>{localLikeCount}</span>}
+        </button>
+
+        <button
+          onClick={handleRepost}
+          className={`flex items-center gap-1.5 text-[12px] font-500 transition-colors bg-transparent border-none cursor-pointer
+            ${reposted ? 'text-emerald-400' : 'text-text-3/60 hover:text-emerald-400'}`}
+        >
+          <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <polyline points="17 1 21 5 17 9" /><path d="M3 11V9a4 4 0 0 1 4-4h14" />
+            <polyline points="7 23 3 19 7 15" /><path d="M21 13v2a4 4 0 0 1-4 4H3" />
+          </svg>
+          {localRepostCount > 0 && <span>{localRepostCount}</span>}
+        </button>
+
+        <div className="flex items-center gap-1.5 text-[12px] font-500 text-text-3/60">
+          <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+          </svg>
+          {post.replyCount > 0 && <span>{post.replyCount}</span>}
+        </div>
+
+        <div className="flex items-center gap-1.5 text-[12px] font-500 text-text-3/60">
+          <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z" />
+          </svg>
+          {post.bookmarkCount > 0 && <span>{post.bookmarkCount}</span>}
+        </div>
+      </div>
+    </div>
+  )
+}

package/src/features/swarmfeed/queries.ts

@@ -0,0 +1,28 @@
+import { api } from '@/lib/app/api-client'
+import type { SwarmFeedPost, SwarmFeedChannel, FeedType } from '@/types/swarmfeed'
+
+export async function fetchFeed(
+  type: FeedType,
+  params?: { channelId?: string; cursor?: string; limit?: number },
+): Promise<{ posts: SwarmFeedPost[]; nextCursor?: string }> {
+  const searchParams = new URLSearchParams()
+  searchParams.set('type', type)
+  if (params?.channelId) searchParams.set('channelId', params.channelId)
+  if (params?.cursor) searchParams.set('cursor', params.cursor)
+  if (params?.limit) searchParams.set('limit', String(params.limit))
+  return api<{ posts: SwarmFeedPost[]; nextCursor?: string }>('GET', `/api/swarmfeed?${searchParams.toString()}`)
+}
+
+export async function fetchChannels(): Promise<SwarmFeedChannel[]> {
+  const result = await api<{ channels: SwarmFeedChannel[] }>('GET', '/api/swarmfeed/channels')
+  return result.channels
+}
+
+export async function submitPost(agentId: string, content: string, channelId?: string, parentId?: string): Promise<SwarmFeedPost> {
+  return api<SwarmFeedPost>('POST', '/api/swarmfeed/posts', {
+    agentId,
+    content,
+    channelId,
+    parentId,
+  })
+}

package/src/lib/a2a/agent-card.ts

@@ -0,0 +1,61 @@
+import type { Agent } from '@/types/agent'
+import type { AgentCard } from './types'
+
+const A2A_PROTOCOL_VERSION = '0.3.0'
+const SWARMCLAW_VERSION = '1.0.0'
+
+/**
+ * Generate an A2A Agent Card from a SwarmClaw agent.
+ * Ref: https://a2a-protocol.org/v0.3.0/specification/#agent-card
+ */
+export function generateAgentCard(agent: Agent, baseUrl: string): AgentCard {
+  return {
+    name: agent.name,
+    description: agent.description || `SwarmClaw agent: ${agent.name}`,
+    version: SWARMCLAW_VERSION,
+    protocolVersion: A2A_PROTOCOL_VERSION,
+    apiEndpoint: `${baseUrl}/api/a2a`,
+
+    capabilities: [
+      {
+        name: 'task_execution',
+        methods: ['executeTask', 'getStatus', 'cancelTask'],
+        description: 'Execute tasks and manage task lifecycle',
+      },
+      {
+        name: 'discovery',
+        methods: ['discoverAgents'],
+        description: 'Discover available A2A agents',
+      },
+      ...(agent.delegationEnabled ? [{
+        name: 'delegation',
+        methods: ['executeTask'],
+        description: 'Delegate work to other agents',
+      }] : []),
+    ],
+
+    skills: (agent.capabilities ?? []).map(cap => ({
+      name: cap,
+      description: `Agent capability: ${cap}`,
+    })),
+
+    authMethods: ['api_key'],
+    supportsStreaming: true,
+    supportsAsync: true,
+
+    rateLimit: {
+      requestsPerMinute: 60,
+      maxConcurrentRequests: 10,
+    },
+
+    extensions: [{
+      name: 'swarmclaw',
+      version: SWARMCLAW_VERSION,
+    }],
+
+    tags: [
+      ...(agent.capabilities ?? []),
+      'swarmclaw',
+    ],
+  }
+}

package/src/lib/a2a/auth.ts

@@ -0,0 +1,54 @@
+import { validateAccessKey } from '@/lib/server/storage-auth'
+
+export interface A2AAuthResult {
+  valid: boolean
+  agentId: string | null
+  error?: string
+}
+
+/**
+ * Validate an inbound A2A request using the SwarmClaw access key.
+ * Checks `Authorization: Bearer <key>` or `x-a2a-access-key` header.
+ */
+export function validateA2ARequest(req: Request): A2AAuthResult {
+  const authHeader = req.headers.get('authorization')
+  const a2aKeyHeader = req.headers.get('x-a2a-access-key')
+
+  let key: string | null = null
+  if (authHeader?.startsWith('Bearer ')) {
+    key = authHeader.slice(7)
+  } else if (a2aKeyHeader) {
+    key = a2aKeyHeader
+  }
+
+  if (!key) {
+    return { valid: false, agentId: null, error: 'Missing authentication — provide Authorization: Bearer <key> or x-a2a-access-key header' }
+  }
+
+  if (!validateAccessKey(key)) {
+    return { valid: false, agentId: null, error: 'Invalid access key' }
+  }
+
+  const agentId = req.headers.get('x-a2a-agent-id')
+  return { valid: true, agentId }
+}
+
+/**
+ * Extract A2A-specific headers from an inbound request.
+ */
+export function extractA2AHeaders(req: Request): { targetAgentId: string | null; requesterAgentId: string | null } {
+  return {
+    targetAgentId: req.headers.get('x-a2a-target-agent-id'),
+    requesterAgentId: req.headers.get('x-a2a-agent-id'),
+  }
+}
+
+/**
+ * Build auth headers for outbound A2A requests to remote agents.
+ */
+export function buildA2AAuthHeaders(accessKey: string): Record<string, string> {
+  return {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${accessKey}`,
+  }
+}

package/src/lib/a2a/client.ts

@@ -0,0 +1,133 @@
+import { genId } from '@/lib/id'
+import { log } from '@/lib/server/logger'
+import { errorMessage } from '@/lib/shared-utils'
+import { resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
+import { buildA2AAuthHeaders } from './auth'
+import type { JsonRpcRequest, JsonRpcResponse, A2AClientOptions } from './types'
+
+const TAG = 'a2a-client'
+
+/**
+ * Call a remote A2A agent via JSON-RPC 2.0.
+ */
+export async function callA2AAgent<T = unknown>(
+  agentUrl: string,
+  method: string,
+  params: Record<string, unknown>,
+  options: A2AClientOptions = {},
+): Promise<T> {
+  const { timeout = 30_000, credentialId, retryAttempts = 3 } = options
+
+  const accessKey = credentialId ? resolveCredentialSecret(credentialId) : null
+  const headers = accessKey ? buildA2AAuthHeaders(accessKey) : { 'Content-Type': 'application/json' }
+
+  const rpcRequest: JsonRpcRequest = {
+    jsonrpc: '2.0',
+    method,
+    params,
+    id: genId(8),
+  }
+
+  let lastError: Error | null = null
+
+  for (let attempt = 0; attempt < retryAttempts; attempt++) {
+    try {
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), timeout)
+
+      const response = await fetch(agentUrl, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(rpcRequest),
+        signal: controller.signal,
+      })
+
+      clearTimeout(timeoutId)
+
+      const data = (await response.json()) as JsonRpcResponse<T>
+
+      if (data.error) {
+        throw new Error(`A2A RPC error (${data.error.code}): ${data.error.message}`)
+      }
+
+      return data.result as T
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(errorMessage(err))
+
+      if (lastError.name === 'AbortError') {
+        throw new Error(`A2A request to ${agentUrl} timed out after ${timeout}ms`)
+      }
+
+      if (attempt < retryAttempts - 1) {
+        const backoff = Math.pow(2, attempt) * 1000
+        log.warn(TAG, `Attempt ${attempt + 1} failed for ${agentUrl}, retrying in ${backoff}ms: ${errorMessage(err)}`)
+        await new Promise(resolve => setTimeout(resolve, backoff))
+      }
+    }
+  }
+
+  throw lastError ?? new Error(`A2A request to ${agentUrl} failed after ${retryAttempts} attempts`)
+}
+
+/**
+ * Stream A2A responses using Server-Sent Events.
+ */
+export async function* streamA2AResponse(
+  agentUrl: string,
+  method: string,
+  params: Record<string, unknown>,
+  options: A2AClientOptions = {},
+): AsyncGenerator<unknown> {
+  const { credentialId } = options
+  const accessKey = credentialId ? resolveCredentialSecret(credentialId) : null
+  const headers: Record<string, string> = {
+    ...(accessKey ? buildA2AAuthHeaders(accessKey) : { 'Content-Type': 'application/json' }),
+    'Accept': 'text/event-stream',
+  }
+
+  const rpcRequest: JsonRpcRequest = {
+    jsonrpc: '2.0',
+    method,
+    params,
+    id: genId(8),
+  }
+
+  const response = await fetch(agentUrl, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(rpcRequest),
+  })
+
+  if (!response.ok) {
+    throw new Error(`A2A streaming request failed: ${response.status} ${response.statusText}`)
+  }
+
+  const reader = response.body?.getReader()
+  if (!reader) throw new Error('No response body for A2A stream')
+
+  const decoder = new TextDecoder()
+  let buffer = ''
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          try {
+            yield JSON.parse(line.slice(6)) as unknown
+          } catch {
+            log.warn(TAG, `Failed to parse SSE data: ${line.slice(0, 200)}`)
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}

package/src/lib/a2a/discovery.ts

@@ -0,0 +1,116 @@
+import { genId } from '@/lib/id'
+import { log } from '@/lib/server/logger'
+import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
+import { loadExternalAgents, saveExternalAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import { AgentCardSchema } from './types'
+import type { AgentCard } from './types'
+import type { ExternalAgentRuntime } from '@/types/agent'
+
+const TAG = 'a2a-discovery'
+
+// TTL cache for fetched agent cards (5 minutes)
+interface CacheEntry { card: AgentCard; fetchedAt: number }
+const cache = hmrSingleton('a2a_discovery_cache', () => new Map<string, CacheEntry>())
+const CACHE_TTL_MS = 5 * 60 * 1000
+
+/**
+ * Discover an A2A agent by fetching its agent card from the well-known endpoint.
+ * Results are cached for 5 minutes.
+ */
+export async function discoverA2AAgent(url: string): Promise<AgentCard> {
+  const cached = cache.get(url)
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.card
+  }
+
+  const cardUrl = url.endsWith('/') ? `${url}.well-known/agent-card.json` : `${url}/.well-known/agent-card.json`
+
+  log.info(TAG, `Discovering A2A agent at ${cardUrl}`)
+
+  const response = await fetch(cardUrl)
+  if (!response.ok) {
+    throw new Error(`Failed to fetch agent card from ${cardUrl}: ${response.status} ${response.statusText}`)
+  }
+
+  const raw = await response.json()
+  const parsed = AgentCardSchema.safeParse(raw)
+  if (!parsed.success) {
+    throw new Error(`Invalid agent card from ${cardUrl}: ${parsed.error.message}`)
+  }
+
+  const card = parsed.data
+  cache.set(url, { card, fetchedAt: Date.now() })
+
+  return card
+}
+
+/**
+ * Register a discovered A2A agent in the ExternalAgentRuntime registry.
+ * Creates or updates the entry.
+ */
+export function registerDiscoveredA2AAgent(card: AgentCard, endpoint: string): ExternalAgentRuntime {
+  const agents = loadExternalAgents()
+  const nowMs = Date.now()
+
+  // Check if already registered by endpoint
+  const existing = Object.values(agents).find(a => a.sourceType === 'a2a' && a.endpoint === endpoint)
+
+  const runtime: ExternalAgentRuntime = {
+    id: existing?.id ?? genId(8),
+    name: card.name,
+    sourceType: 'a2a',
+    status: 'online',
+    transport: 'http',
+    endpoint,
+    capabilities: card.capabilities.map(c => c.name),
+    version: card.version,
+    a2aCard: {
+      protocolVersion: card.protocolVersion,
+      apiEndpoint: card.apiEndpoint,
+      capabilities: card.capabilities,
+      supportsStreaming: card.supportsStreaming,
+      supportsAsync: card.supportsAsync,
+    },
+    lastSeenAt: nowMs,
+    lastHeartbeatAt: nowMs,
+    createdAt: existing?.createdAt ?? nowMs,
+    updatedAt: nowMs,
+  }
+
+  agents[runtime.id] = runtime
+  saveExternalAgents(agents)
+  notify('external_agents')
+
+  log.info(TAG, `Registered A2A agent: ${card.name} (${runtime.id}) at ${endpoint}`)
+
+  return runtime
+}
+
+/**
+ * Discover and register an A2A agent in one step.
+ */
+export async function discoverAndRegisterA2AAgent(url: string): Promise<ExternalAgentRuntime> {
+  try {
+    const card = await discoverA2AAgent(url)
+    return registerDiscoveredA2AAgent(card, card.apiEndpoint || url)
+  } catch (err) {
+    log.error(TAG, `Failed to discover A2A agent at ${url}: ${errorMessage(err)}`)
+    throw err
+  }
+}
+
+/**
+ * List all known A2A external agents.
+ */
+export function listA2AAgents(): ExternalAgentRuntime[] {
+  const agents = loadExternalAgents()
+  return Object.values(agents).filter(a => a.sourceType === 'a2a')
+}
+
+/**
+ * Clear the discovery cache.
+ */
+export function clearDiscoveryCache(): void {
+  cache.clear()
+}

package/src/lib/a2a/handlers.ts

@@ -0,0 +1,176 @@
+import { genId } from '@/lib/id'
+import { log } from '@/lib/server/logger'
+import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
+import { saveSession } from '@/lib/server/sessions/session-repository'
+import { upsertTask } from '@/lib/server/tasks/task-repository'
+import { enqueueTask } from '@/lib/server/runtime/queue'
+import { loadTasks, loadTask } from '@/lib/server/tasks/task-repository'
+import { notify } from '@/lib/server/ws-hub'
+import { a2aRouter } from './json-rpc-router'
+import type { A2AContext, A2ATaskStatus } from './types'
+import type { Session } from '@/types/session'
+import type { BoardTask, BoardTaskStatus } from '@/types/task'
+import { loadExternalAgents } from '@/lib/server/storage'
+
+const TAG = 'a2a-handlers'
+
+// --- Status mapping ---
+
+function mapTaskStatus(status: BoardTaskStatus): A2ATaskStatus {
+  switch (status) {
+    case 'queued': case 'backlog': return 'submitted'
+    case 'running': return 'working'
+    case 'completed': return 'completed'
+    case 'failed': return 'failed'
+    case 'cancelled': case 'archived': case 'deferred': return 'cancelled'
+    default: return 'submitted'
+  }
+}
+
+function findTaskByA2AId(a2aTaskId: string): BoardTask | null {
+  // Try direct lookup first (if the A2A taskId IS the SwarmClaw task ID)
+  const direct = loadTask(a2aTaskId)
+  if (direct) return direct
+
+  // Search by externalSource.id
+  const allTasks = loadTasks()
+  for (const task of Object.values(allTasks)) {
+    if (task.externalSource?.source === 'a2a' && task.externalSource?.id === a2aTaskId) {
+      return task
+    }
+  }
+  return null
+}
+
+// --- executeTask ---
+
+a2aRouter.register('executeTask', async (params: Record<string, unknown>, context: A2AContext) => {
+  const taskId = (params.taskId as string) || genId(8)
+  const taskName = (params.taskName as string) || 'A2A Task'
+  const taskMessage = (params.message as string) || (params.description as string) || ''
+  const agentId = context.agentId || (params.agentId as string)
+
+  if (!agentId) {
+    throw new Error('No target agentId specified — provide x-a2a-target-agent-id header or agentId in params')
+  }
+
+  const agent = getAgent(agentId)
+  if (!agent) {
+    throw new Error(`Agent "${agentId}" not found`)
+  }
+
+  // Create a session for this A2A task
+  const sessionId = genId(8)
+  const nowMs = Date.now()
+  const session: Session = {
+    id: sessionId,
+    name: `A2A: ${taskName}`,
+    cwd: process.cwd(),
+    user: `a2a:${context.requesterId}`,
+    provider: agent.provider,
+    model: agent.model,
+    credentialId: agent.credentialId ?? null,
+    claudeSessionId: null,
+    messages: [],
+    createdAt: nowMs,
+    lastActiveAt: nowMs,
+    agentId: agent.id,
+    tools: agent.tools,
+    extensions: agent.extensions,
+  }
+  saveSession(sessionId, session)
+
+  // Create a BoardTask for tracking
+  const boardTaskId = genId()
+  const boardTask: BoardTask = {
+    id: boardTaskId,
+    title: taskName,
+    description: taskMessage,
+    status: 'queued',
+    agentId: agent.id,
+    sessionId,
+    externalSource: { source: 'a2a', id: taskId },
+    queuedAt: nowMs,
+    createdAt: nowMs,
+    updatedAt: nowMs,
+  }
+  upsertTask(boardTaskId, boardTask)
+  enqueueTask(boardTaskId)
+  notify('tasks')
+
+  log.info(TAG, `executeTask: created task ${boardTaskId} for agent ${agentId}`, { a2aTaskId: taskId, sessionId })
+
+  return {
+    taskId,
+    boardTaskId,
+    sessionId,
+    status: 'submitted' as const,
+    progressUrl: `/api/a2a/tasks/${boardTaskId}/status`,
+  }
+})
+
+// --- getStatus ---
+
+a2aRouter.register('getStatus', async (params: Record<string, unknown>) => {
+  const taskId = params.taskId as string
+  if (!taskId) throw new Error('taskId is required')
+
+  const task = findTaskByA2AId(taskId)
+  if (!task) throw new Error(`Task "${taskId}" not found`)
+
+  return {
+    taskId,
+    boardTaskId: task.id,
+    sessionId: task.sessionId ?? null,
+    status: mapTaskStatus(task.status),
+    title: task.title,
+    result: task.status === 'completed' ? (task.result ?? null) : null,
+    error: task.status === 'failed' ? (task.error ?? null) : null,
+    updatedAt: task.updatedAt,
+  }
+})
+
+// --- cancelTask ---
+
+a2aRouter.register('cancelTask', async (params: Record<string, unknown>) => {
+  const taskId = params.taskId as string
+  if (!taskId) throw new Error('taskId is required')
+
+  const task = findTaskByA2AId(taskId)
+  if (!task) throw new Error(`Task "${taskId}" not found`)
+
+  upsertTask(task.id, { ...task, status: 'cancelled', updatedAt: Date.now() })
+  notify('tasks')
+
+  log.info(TAG, `cancelTask: cancelled task ${task.id}`, { a2aTaskId: taskId })
+
+  return { taskId, status: 'cancelled' as const }
+})
+
+// --- discoverAgents ---
+
+a2aRouter.register('discoverAgents', async () => {
+  const agents = listAgents()
+  const localAgents = Object.values(agents)
+    .filter(a => !a.disabled)
+    .map(a => ({
+      id: a.id,
+      name: a.name,
+      description: a.description,
+      capabilities: a.capabilities ?? [],
+      source: 'local' as const,
+    }))
+
+  // Include discovered A2A external agents
+  const externalAgents = Object.values(loadExternalAgents())
+    .filter(ea => ea.sourceType === 'a2a' && ea.status !== 'offline')
+    .map(ea => ({
+      id: ea.id,
+      name: ea.name,
+      description: ea.a2aCard?.apiEndpoint ?? ea.endpoint ?? '',
+      capabilities: ea.capabilities ?? [],
+      source: 'a2a' as const,
+    }))
+
+  return { agents: [...localAgents, ...externalAgents] }
+})