@swarmclawai/swarmclaw 1.3.6 → 1.4.2

package/src/lib/a2a/json-rpc-router.ts

@@ -0,0 +1,38 @@
+import { hmrSingleton, errorMessage } from '@/lib/shared-utils'
+import type { A2AMethod, A2AMethodHandler, A2AContext, JsonRpcRequest, JsonRpcResponse } from './types'
+import { JSON_RPC_ERRORS } from './types'
+
+export class JsonRpcRouter {
+  private handlers = new Map<string, A2AMethodHandler>()
+
+  register(method: A2AMethod | string, handler: A2AMethodHandler): void {
+    this.handlers.set(method, handler)
+  }
+
+  async route(request: JsonRpcRequest, context: A2AContext): Promise<JsonRpcResponse> {
+    const handler = this.handlers.get(request.method)
+    if (!handler) {
+      return {
+        jsonrpc: '2.0',
+        error: { code: JSON_RPC_ERRORS.METHOD_NOT_FOUND, message: 'Method not found', data: { method: request.method } },
+        id: request.id,
+      }
+    }
+    try {
+      const result = await handler(request.params ?? {}, context)
+      return { jsonrpc: '2.0', result, id: request.id }
+    } catch (err) {
+      return {
+        jsonrpc: '2.0',
+        error: { code: JSON_RPC_ERRORS.INTERNAL_ERROR, message: errorMessage(err) },
+        id: request.id,
+      }
+    }
+  }
+
+  listMethods(): string[] {
+    return [...this.handlers.keys()]
+  }
+}
+
+export const a2aRouter = hmrSingleton('a2a_jsonrpc_router', () => new JsonRpcRouter())

package/src/lib/a2a/types.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod'
+
+// --- A2A Agent Card ---
+// Ref: https://a2a-protocol.org/v0.3.0/specification/#agent-card
+
+export const AgentCardCapabilitySchema = z.object({
+  name: z.string(),
+  methods: z.array(z.string()).optional(),
+  description: z.string().optional(),
+})
+
+export const AgentCardSkillSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  parameters: z.record(z.string(), z.unknown()).optional(),
+  returns: z.record(z.string(), z.unknown()).optional(),
+})
+
+export const AgentCardSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  version: z.string(),
+  protocolVersion: z.string().default('0.3.0'),
+  apiEndpoint: z.string().url(),
+  capabilities: z.array(AgentCardCapabilitySchema).default([]),
+  skills: z.array(AgentCardSkillSchema).default([]),
+  authMethods: z.array(z.enum(['api_key', 'ed25519', 'oauth2'])).default(['api_key']),
+  supportsStreaming: z.boolean().default(true),
+  supportsAsync: z.boolean().default(true),
+  rateLimit: z.object({
+    requestsPerMinute: z.number().optional(),
+    maxConcurrentRequests: z.number().optional(),
+  }).optional(),
+  extensions: z.array(z.object({
+    name: z.string(),
+    version: z.string(),
+    url: z.string().url().optional(),
+  })).default([]),
+  tags: z.array(z.string()).default([]),
+  icon: z.string().url().optional(),
+  website: z.string().url().optional(),
+})
+
+export type AgentCard = z.infer<typeof AgentCardSchema>
+
+// --- JSON-RPC 2.0 ---
+// Ref: https://www.jsonrpc.org/specification
+
+export const JsonRpcRequestSchema = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.string(),
+  params: z.record(z.string(), z.unknown()).optional(),
+  id: z.union([z.string(), z.number()]).optional(),
+})
+
+export type JsonRpcRequest = z.infer<typeof JsonRpcRequestSchema>
+
+export interface JsonRpcResponse<T = unknown> {
+  jsonrpc: '2.0'
+  result?: T
+  error?: { code: number; message: string; data?: unknown }
+  id?: string | number
+}
+
+// --- A2A Method Types ---
+
+export type A2AMethod = 'executeTask' | 'getStatus' | 'cancelTask' | 'discoverAgents'
+
+export type A2AMethodHandler = (params: Record<string, unknown>, context: A2AContext) => Promise<unknown>
+
+export interface A2AContext {
+  agentId: string
+  requesterId: string
+  timestamp: Date
+}
+
+export type A2ATaskStatus = 'submitted' | 'working' | 'completed' | 'failed' | 'cancelled'
+
+// --- A2A Client Options ---
+
+export interface A2AClientOptions {
+  timeout?: number
+  credentialId?: string | null
+  retryAttempts?: number
+}
+
+// --- JSON-RPC Error Codes ---
+
+export const JSON_RPC_ERRORS = {
+  PARSE_ERROR: -32700,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  AUTH_FAILED: -32000,
+} as const

package/src/lib/app/navigation.ts

@@ -31,6 +31,7 @@ const VIEW_TO_PATH: Record<AppView, string> = {
   settings: '/settings',
   projects: '/projects',
   activity: '/activity',
+  swarmfeed: '/swarmfeed',
 }
 
 /** Build a URL path for a given view, optionally with an entity ID. */

package/src/lib/app/report-client-error.ts

@@ -0,0 +1,52 @@
+'use client'
+
+type ReportClientErrorInput = {
+  source: string
+  error: Error | string | unknown
+  componentStack?: string | null
+  digest?: string | null
+}
+
+const reportedClientErrors = new Set<string>()
+
+function truncate(value: string | null | undefined, max: number): string | undefined {
+  if (!value) return undefined
+  return value.length > max ? value.slice(0, max) : value
+}
+
+export function reportClientError(input: ReportClientErrorInput) {
+  if (typeof window === 'undefined') return
+
+  const message = input.error instanceof Error
+    ? input.error.message
+    : typeof input.error === 'string'
+      ? input.error
+      : String(input.error)
+
+  const stack = input.error instanceof Error ? input.error.stack : undefined
+  const fingerprint = [
+    input.source,
+    message,
+    input.digest || '',
+    input.componentStack || '',
+  ].join('|')
+
+  if (reportedClientErrors.has(fingerprint)) return
+  reportedClientErrors.add(fingerprint)
+
+  void fetch('/api/logs', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      source: input.source,
+      message: truncate(message, 1000),
+      stack: truncate(stack, 8000),
+      componentStack: truncate(input.componentStack, 8000),
+      digest: truncate(input.digest, 200),
+      url: truncate(window.location.href, 2000),
+      pathname: truncate(window.location.pathname, 1000),
+      userAgent: truncate(window.navigator.userAgent, 1000),
+    }),
+    keepalive: true,
+  }).catch(() => {})
+}

package/src/lib/app/view-constants.ts

@@ -27,6 +27,7 @@ export const VIEW_LABELS: Record<AppView, string> = {
   settings: 'Settings',
   projects: 'Projects',
   activity: 'Activity',
+  swarmfeed: 'Feed',
 }
 
 export const CREATE_LABELS: Partial<Record<AppView, string>> = {
@@ -71,6 +72,7 @@ export const VIEW_DESCRIPTIONS: Record<AppView, string> = {
   settings: 'Manage defaults, providers, secrets, and automation settings',
   projects: 'Group agents, tasks & schedules into projects',
   activity: 'Audit trail of all entity mutations',
+  swarmfeed: 'Social feed for AI agents to post, follow, and engage',
 }
 
 export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { icon: string; title: string; description: string; features: string[] }> = {
@@ -213,10 +215,16 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     description: 'Audit trail of all entity mutations across the system.',
     features: ['Track agent, task, and connector changes', 'Filter by entity type and action', 'Real-time updates via WebSocket', 'Relative timestamps'],
   },
+  swarmfeed: {
+    icon: 'rss',
+    title: 'Feed',
+    description: 'A social feed where your AI agents post updates, follow each other, and engage with content.',
+    features: ['Agents post status updates and insights', 'Follow agents and browse trending content', 'Channel-based topic organization', 'Like, repost, and reply interactions'],
+  },
 }
 
 export const FULL_WIDTH_VIEWS = new Set<AppView>([
   'home', 'org_chart', 'inbox', 'chatrooms', 'protocols', 'schedules', 'secrets', 'wallets', 'providers', 'skills',
   'connectors', 'webhooks', 'mcp_servers', 'knowledge', 'extensions',
-  'usage', 'runs', 'autonomy', 'logs', 'settings', 'activity', 'projects',
+  'usage', 'runs', 'autonomy', 'logs', 'settings', 'activity', 'projects', 'swarmfeed',
 ])

package/src/lib/providers/anthropic.ts

@@ -26,119 +26,131 @@ async function fileToContentBlocks(filePath: string): Promise<Array<Record<strin
 }
 
 export function streamAnthropicChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
-  return new Promise(async (resolve, reject) => {
-    const messages = await buildMessages(session, message, imagePath, loadHistory)
-    const model = session.model || 'claude-sonnet-4-6'
-    let usageInput = 0
-    let usageOutput = 0
-
-    const body: Record<string, unknown> = {
-      model,
-      max_tokens: ANTHROPIC_MAX_TOKENS,
-      messages,
-      stream: true,
-    }
-    if (systemPrompt) {
-      body.system = systemPrompt
-    }
+  return new Promise((resolve, reject) => {
+    ;(async () => {
+      try {
+        const messages = await buildMessages(session, message, imagePath, loadHistory)
+        const model = session.model || 'claude-sonnet-4-6'
+        let usageInput = 0
+        let usageOutput = 0
+
+        const body: Record<string, unknown> = {
+          model,
+          max_tokens: ANTHROPIC_MAX_TOKENS,
+          messages,
+          stream: true,
+        }
+        if (systemPrompt) {
+          body.system = systemPrompt
+        }
 
-    const payload = JSON.stringify(body)
-    const abortController = { aborted: false }
-    let fullResponse = ''
-    let apiReqRef: ReturnType<typeof https.request> | null = null
+        const payload = JSON.stringify(body)
+        const abortController = { aborted: false }
+        let fullResponse = ''
+        let apiReqRef: ReturnType<typeof https.request> | null = null
+
+        if (signal) {
+          if (signal.aborted) {
+            abortController.aborted = true
+          } else {
+            signal.addEventListener('abort', () => {
+              abortController.aborted = true
+              apiReqRef?.destroy()
+            }, { once: true })
+          }
+        }
 
-    if (signal) {
-      if (signal.aborted) {
-        abortController.aborted = true
-      } else {
-        signal.addEventListener('abort', () => {
-          abortController.aborted = true
-          apiReqRef?.destroy()
-        }, { once: true })
-      }
-    }
+        const apiReq = https.request({
+          hostname: PROVIDER_DEFAULTS.anthropic,
+          path: '/v1/messages',
+          method: 'POST',
+          timeout: 60_000,
+          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', () => {
+              const msg = `Anthropic error ${apiRes.statusCode}: ${errBody.slice(0, 200)}`
+              log.error(TAG, `[${session.id}] ${msg}`)
+              let errMsg = `Anthropic API error (${apiRes.statusCode})`
+              try {
+                const parsed = JSON.parse(errBody)
+                if (parsed.error?.message) errMsg = parsed.error.message
+              } catch {}
+              writeSSE(write, 'err', errMsg)
+              active.delete(session.id)
+              reject(new Error(msg))
+            })
+            return
+          }
+
+          let buf = ''
+          let malformedChunkLogged = false
+          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
+                  writeSSE(write, 'd', parsed.delta.text)
+                }
+                if (parsed.type === 'message_start' && parsed.message?.usage) {
+                  usageInput = parsed.message.usage.input_tokens || 0
+                }
+                if (parsed.type === 'message_delta' && parsed.usage) {
+                  usageOutput = parsed.usage.output_tokens || 0
+                }
+              } catch {
+                if (!malformedChunkLogged) {
+                  malformedChunkLogged = true
+                  log.warn(TAG, `[${session.id}] failed to parse Anthropic stream chunk`, {
+                    sample: data.slice(0, 200),
+                  })
+                }
+              }
+            }
+          })
 
-    const apiReq = https.request({
-      hostname: PROVIDER_DEFAULTS.anthropic,
-      path: '/v1/messages',
-      method: 'POST',
-      timeout: 60_000,
-      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', () => {
-          const msg = `Anthropic error ${apiRes.statusCode}: ${errBody.slice(0, 200)}`
-          log.error(TAG, `[${session.id}] ${msg}`)
-          let errMsg = `Anthropic API error (${apiRes.statusCode})`
-          try {
-            const parsed = JSON.parse(errBody)
-            if (parsed.error?.message) errMsg = parsed.error.message
-          } catch {}
-          writeSSE(write, 'err', errMsg)
-          active.delete(session.id)
-          reject(new Error(msg))
+          apiRes.on('end', () => {
+            if (onUsage && (usageInput > 0 || usageOutput > 0)) {
+              onUsage({ inputTokens: usageInput, outputTokens: usageOutput })
+            }
+            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
-              writeSSE(write, 'd', parsed.delta.text)
-            }
-            if (parsed.type === 'message_start' && parsed.message?.usage) {
-              usageInput = parsed.message.usage.input_tokens || 0
-            }
-            if (parsed.type === 'message_delta' && parsed.usage) {
-              usageOutput = parsed.usage.output_tokens || 0
-            }
-          } catch {}
-        }
-      })
+        apiReqRef = apiReq
+        active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
-      apiRes.on('end', () => {
-        if (onUsage && (usageInput > 0 || usageOutput > 0)) {
-          onUsage({ inputTokens: usageInput, outputTokens: usageOutput })
-        }
-        active.delete(session.id)
-        resolve(fullResponse)
-      })
-    })
-
-    apiReqRef = apiReq
-    active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
-
-    apiReq.on('timeout', () => {
-      log.error(TAG, `[${session.id}] anthropic request timed out after 60s`)
-      apiReq.destroy(new Error('Request timed out after 60s'))
-    })
-
-    apiReq.on('error', (e) => {
-      log.error(TAG, `[${session.id}] anthropic request error:`, e.message)
-      writeSSE(write, 'err', e.message)
-      active.delete(session.id)
-      reject(e)
-    })
-
-    apiReq.end(payload)
+        apiReq.on('timeout', () => {
+          log.error(TAG, `[${session.id}] anthropic request timed out after 60s`)
+          apiReq.destroy(new Error('Request timed out after 60s'))
+        })
+
+        apiReq.on('error', (e) => {
+          log.error(TAG, `[${session.id}] anthropic request error:`, e.message)
+          writeSSE(write, 'err', e.message)
+          active.delete(session.id)
+          reject(e)
+        })
+
+        apiReq.end(payload)
+      } catch (err) { reject(err) }
+    })()
   })
 }
 

package/src/lib/providers/ollama.ts

@@ -2,6 +2,7 @@ import fs from 'fs'
 import http from 'http'
 import https from 'https'
 import type { StreamChatOptions } from './index'
+import { streamOpenAiChat } from './openai'
 import { IMAGE_EXTS, TEXT_EXTS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
 import { log } from '@/lib/server/logger'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
@@ -9,23 +10,34 @@ import { resolveImagePath } from '@/lib/server/resolve-image'
 
 const TAG = 'provider-ollama'
 
-export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
+/** Ollama Cloud uses the OpenAI-compatible /v1 endpoint, not the native /api/chat protocol. */
+const OLLAMA_CLOUD_OPENAI_ENDPOINT = 'https://ollama.com/v1'
+
+export function streamOllamaChat(opts: StreamChatOptions): Promise<string> {
+  const { session, apiKey, write, active } = opts
+  const runtime = resolveOllamaRuntimeConfig({
+    model: session.model,
+    ollamaMode: session.ollamaMode,
+    apiKey,
+    apiEndpoint: session.apiEndpoint,
+  })
+
+  if (runtime.useCloud) {
+    if (!runtime.apiKey) {
+      writeSSE(write, 'err', 'Ollama Cloud model requires an API key. Set OLLAMA_API_KEY or attach an Ollama credential.')
+      active.delete(session.id)
+      return Promise.resolve('')
+    }
+    // Delegate to OpenAI-compatible handler with the cloud endpoint
+    const cloudSession = { ...session, model: runtime.model || 'llama3', apiEndpoint: OLLAMA_CLOUD_OPENAI_ENDPOINT }
+    return streamOpenAiChat({ ...opts, session: cloudSession, apiKey: runtime.apiKey })
+  }
+
+  const { message, imagePath, loadHistory, onUsage, signal } = opts
   return new Promise((resolve, reject) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
-    const runtime = resolveOllamaRuntimeConfig({
-      model: session.model,
-      ollamaMode: session.ollamaMode,
-      apiKey,
-      apiEndpoint: session.apiEndpoint,
-    })
     const model = runtime.model || 'llama3'
     const endpoint = runtime.endpoint
-    if (runtime.useCloud && !runtime.apiKey) {
-      writeSSE(write, 'err', 'Ollama Cloud model requires an API key. Set OLLAMA_API_KEY or attach an Ollama credential.')
-      active.delete(session.id)
-      resolve('')
-      return
-    }
 
     const parsed = new URL(endpoint)
     const isHttps = parsed.protocol === 'https:'
@@ -81,6 +93,7 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
       }
 
       let buf = ''
+      let malformedChunkLogged = false
       apiRes.on('data', (chunk: Buffer) => {
         if (abortController.aborted) return
         buf += chunk.toString()
@@ -103,7 +116,14 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
                 onUsage({ inputTokens: input, outputTokens: output })
               }
             }
-          } catch {}
+          } catch {
+            if (!malformedChunkLogged) {
+              malformedChunkLogged = true
+              log.warn(TAG, `[${session.id}] failed to parse Ollama stream chunk`, {
+                sample: line.slice(0, 200),
+              })
+            }
+          }
         }
       })