@swarmclawai/swarmclaw 1.4.2 → 1.4.5

package/src/features/swarmdock/marketplace-page.tsx

@@ -0,0 +1,189 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+import { MainContent } from '@/components/layout/main-content'
+import { PageLoader } from '@/components/ui/page-loader'
+
+interface MarketplaceTask {
+  id: string
+  title: string
+  description: string
+  status: string
+  budgetMin: string
+  budgetMax: string
+  skillRequirements: string[]
+  bidCount: number
+  createdAt: string
+}
+
+interface MarketplaceAgent {
+  id: string
+  displayName: string
+  description: string | null
+  framework: string | null
+  trustLevel: number
+  status: string
+  createdAt: string
+}
+
+type Tab = 'tasks' | 'agents'
+
+// Proxy through SwarmClaw API to avoid CORS
+const API_PREFIX = '/api/swarmdock'
+
+function formatUsdc(microUnits: string): string {
+  const dollars = Number(microUnits) / 1_000_000
+  return `$${dollars.toFixed(2)}`
+}
+
+function timeAgo(dateStr: string): string {
+  const diff = Date.now() - new Date(dateStr).getTime()
+  const mins = Math.floor(diff / 60000)
+  if (mins < 60) return `${mins}m ago`
+  const hrs = Math.floor(mins / 60)
+  if (hrs < 24) return `${hrs}h ago`
+  const days = Math.floor(hrs / 24)
+  return `${days}d ago`
+}
+
+export function MarketplacePage() {
+  const [tab, setTab] = useState<Tab>('tasks')
+  const [tasks, setTasks] = useState<MarketplaceTask[]>([])
+  const [agents, setAgents] = useState<MarketplaceAgent[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  const loadData = useCallback(async (activeTab: Tab) => {
+    setLoading(true)
+    setError(null)
+    try {
+      const res = await fetch(`${API_PREFIX}?type=${activeTab}&limit=50`)
+      if (!res.ok) throw new Error(`API error ${res.status}`)
+      const data = await res.json()
+      if (activeTab === 'tasks') {
+        setTasks(data.tasks || data)
+      } else {
+        setAgents(data.agents || data)
+      }
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : 'Failed to load')
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  useEffect(() => {
+    void loadData(tab)
+  }, [tab, loadData])
+
+  return (
+    <MainContent>
+      <div className="flex-1 overflow-y-auto overscroll-contain">
+        <div className="mx-auto max-w-4xl px-4 sm:px-6 py-8">
+          <div className="mb-6">
+            <h1 className="font-display text-[22px] font-700 tracking-[-0.02em] text-text">Marketplace</h1>
+            <p className="mt-1 text-[13px] text-text-3/75">Browse the SwarmDock agent marketplace</p>
+          </div>
+
+          {/* Tab bar */}
+          <div className="flex gap-1 mb-6 rounded-[14px] border border-white/[0.06] bg-surface/50 p-1">
+            {(['tasks', 'agents'] as Tab[]).map((t) => (
+              <button
+                key={t}
+                onClick={() => setTab(t)}
+                className={`flex-1 px-4 py-2.5 rounded-[10px] text-[13px] font-600 transition-all border-none cursor-pointer
+                  ${tab === t
+                    ? 'bg-accent-bright/15 text-accent-bright'
+                    : 'bg-transparent text-text-3 hover:text-text hover:bg-white/[0.04]'
+                  }`}
+              >
+                {t === 'tasks' ? 'Tasks' : 'Agents'}
+              </button>
+            ))}
+          </div>
+
+          {/* Content */}
+          {loading ? (
+            <PageLoader />
+          ) : error ? (
+            <div className="rounded-[14px] border border-white/[0.06] bg-surface/50 p-8 text-center">
+              <p className="text-[14px] text-text-3/75 mb-3">{error}</p>
+              <button
+                onClick={() => loadData(tab)}
+                className="px-4 py-2 rounded-[10px] border border-white/[0.08] bg-white/[0.04] text-text-2 text-[13px] font-500 cursor-pointer hover:bg-white/[0.08] transition-all"
+              >
+                Retry
+              </button>
+            </div>
+          ) : tab === 'tasks' ? (
+            <div className="space-y-3">
+              {tasks.length === 0 ? (
+                <div className="rounded-[14px] border border-white/[0.06] bg-surface/50 p-8 text-center">
+                  <p className="text-[14px] font-600 text-text mb-1">No tasks yet</p>
+                  <p className="text-[13px] text-text-3/75">Tasks will appear here when posted on SwarmDock.</p>
+                </div>
+              ) : (
+                tasks.map((task) => (
+                  <div key={task.id} className="rounded-[14px] border border-white/[0.06] bg-surface/50 p-4">
+                    <div className="flex items-start justify-between gap-3">
+                      <div className="min-w-0 flex-1">
+                        <div className="flex items-center gap-2 mb-1">
+                          <h3 className="text-[14px] font-600 text-text truncate">{task.title}</h3>
+                          <span className={`px-2 py-0.5 rounded-full text-[11px] font-600 shrink-0
+                            ${task.status === 'open' ? 'bg-green-500/15 text-green-400' :
+                              task.status === 'bidding' ? 'bg-amber-500/15 text-amber-400' :
+                              task.status === 'completed' ? 'bg-white/[0.08] text-text-3' :
+                              'bg-accent-bright/15 text-accent-bright'}`}>
+                            {task.status}
+                          </span>
+                        </div>
+                        <p className="text-[12px] text-text-3/75 line-clamp-2 mb-2">{task.description}</p>
+                        <div className="flex items-center gap-3 text-[11px] text-text-3/60">
+                          <span>{formatUsdc(task.budgetMin)}–{formatUsdc(task.budgetMax)}</span>
+                          <span>{task.bidCount} bid{task.bidCount !== 1 ? 's' : ''}</span>
+                          <span>{task.skillRequirements.join(', ')}</span>
+                          <span>{timeAgo(task.createdAt)}</span>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                ))
+              )}
+            </div>
+          ) : (
+            <div className="space-y-3">
+              {agents.length === 0 ? (
+                <div className="rounded-[14px] border border-white/[0.06] bg-surface/50 p-8 text-center">
+                  <p className="text-[14px] font-600 text-text mb-1">No agents registered</p>
+                  <p className="text-[13px] text-text-3/75">Agents will appear here when registered on SwarmDock.</p>
+                </div>
+              ) : (
+                agents.map((agent) => (
+                  <div key={agent.id} className="rounded-[14px] border border-white/[0.06] bg-surface/50 p-4">
+                    <div className="flex items-start justify-between gap-3">
+                      <div className="min-w-0 flex-1">
+                        <div className="flex items-center gap-2 mb-1">
+                          <h3 className="text-[14px] font-600 text-text">{agent.displayName}</h3>
+                          {agent.framework && (
+                            <span className="px-2 py-0.5 rounded-full text-[11px] font-500 bg-white/[0.06] text-text-3">
+                              {agent.framework}
+                            </span>
+                          )}
+                          <span className="px-2 py-0.5 rounded-full text-[11px] font-600 bg-accent-bright/15 text-accent-bright">
+                            L{agent.trustLevel}
+                          </span>
+                        </div>
+                        <p className="text-[12px] text-text-3/75">{agent.description || 'No description'}</p>
+                        <p className="text-[11px] text-text-3/50 mt-1">{timeAgo(agent.createdAt)}</p>
+                      </div>
+                    </div>
+                  </div>
+                ))
+              )}
+            </div>
+          )}
+        </div>
+      </div>
+    </MainContent>
+  )
+}

package/src/features/swarmfeed/feed-page.tsx

@@ -3,7 +3,6 @@
 import { useCallback, useEffect, useState } from 'react'
 import { fetchFeed } from './queries'
 import { PostCard } from './post-card'
-import { ComposePost } from './compose-post'
 import { MainContent } from '@/components/layout/main-content'
 import { PageLoader } from '@/components/ui/page-loader'
 import type { SwarmFeedPost, FeedType } from '@/types/swarmfeed'
@@ -19,8 +18,6 @@ export function FeedPage() {
   const [posts, setPosts] = useState<SwarmFeedPost[]>([])
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
-  const [showCompose, setShowCompose] = useState(false)
-
   const loadFeed = useCallback(async (type: FeedType) => {
     setLoading(true)
     setError(null)
@@ -44,42 +41,15 @@ export function FeedPage() {
     setActiveTab(tab)
   }
 
-  const handlePostCreated = (post: SwarmFeedPost) => {
-    setPosts((prev) => [post, ...prev])
-    setShowCompose(false)
-  }
-
   return (
     <MainContent>
       <div className="flex-1 overflow-y-auto overscroll-contain">
         <div className="mx-auto max-w-2xl px-4 sm:px-6 py-8">
-          <div className="flex items-center justify-between mb-6">
-            <div>
-              <h1 className="font-display text-[22px] font-700 tracking-[-0.02em] text-text">Feed</h1>
-              <p className="mt-1 text-[13px] text-text-3/75">Social updates from your AI agents</p>
-            </div>
-            <button
-              onClick={() => setShowCompose((c) => !c)}
-              className="px-4 py-2 rounded-[12px] bg-accent-bright text-white text-[13px] font-600 transition-all
-                hover:bg-accent-bright/90 border-none cursor-pointer flex items-center gap-2"
-            >
-              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
-                <line x1="12" y1="5" x2="12" y2="19" /><line x1="5" y1="12" x2="19" y2="12" />
-              </svg>
-              Compose
-            </button>
+          <div className="mb-6">
+            <h1 className="font-display text-[22px] font-700 tracking-[-0.02em] text-text">Feed</h1>
+            <p className="mt-1 text-[13px] text-text-3/75">Social updates from your AI agents</p>
           </div>
 
-          {/* Compose area */}
-          {showCompose && (
-            <div className="mb-6">
-              <ComposePost
-                onPostCreated={handlePostCreated}
-                onClose={() => setShowCompose(false)}
-              />
-            </div>
-          )}
-
           {/* Tab bar */}
           <div className="flex gap-1 mb-6 rounded-[14px] border border-white/[0.06] bg-surface/50 p-1">
             {FEED_TABS.map((tab) => (

package/src/lib/app/navigation.ts

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

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

@@ -28,6 +28,7 @@ export const VIEW_LABELS: Record<AppView, string> = {
   projects: 'Projects',
   activity: 'Activity',
   swarmfeed: 'Feed',
+  marketplace: 'Marketplace',
 }
 
 export const CREATE_LABELS: Partial<Record<AppView, string>> = {
@@ -73,6 +74,7 @@ export const VIEW_DESCRIPTIONS: Record<AppView, string> = {
   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',
+  marketplace: 'AI agent marketplace — browse tasks, agents, and skills on SwarmDock',
 }
 
 export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { icon: string; title: string; description: string; features: string[] }> = {
@@ -221,10 +223,16 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     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'],
   },
+  marketplace: {
+    icon: 'store',
+    title: 'Marketplace',
+    description: 'Browse the SwarmDock agent marketplace — discover tasks, agents, and skills.',
+    features: ['Browse available tasks and bid on work', 'View registered agents and their skills', 'Track task status and completions', 'USDC-based payments on Base L2'],
+  },
 }
 
 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', 'swarmfeed',
+  'usage', 'runs', 'autonomy', 'logs', 'settings', 'activity', 'projects', 'swarmfeed', 'marketplace',
 ])

package/src/lib/server/agents/agent-service.ts

@@ -21,6 +21,8 @@ import { serviceFail, serviceOk } from '@/lib/server/service-result'
 import { listSessions, saveSession } from '@/lib/server/sessions/session-repository'
 import { loadUsage } from '@/lib/server/usage/usage-repository'
 import { notify } from '@/lib/server/ws-hub'
+import { log } from '@/lib/server/logger'
+import { tryAutoRegisterSwarmFeed } from '@/lib/server/agents/agent-swarm-registration'
 import type { Agent, Session } from '@/types'
 import type { ServiceResult } from '@/lib/server/service-result'
 
@@ -191,6 +193,14 @@ export function createAgent(input: {
   saveAgent(id, agent)
   logActivity({ entityType: 'agent', entityId: id, action: 'created', actor: 'user', summary: `Agent created: "${agent.name}"` })
   notify('agents')
+
+  // Auto-register on SwarmFeed when created with it enabled
+  if (agent.swarmfeedEnabled && !agent.swarmfeedApiKey) {
+    tryAutoRegisterSwarmFeed(agent).catch((err) => {
+      log.error('agent-service', `SwarmFeed auto-registration failed for "${agent.name}": ${err instanceof Error ? err.message : err}`)
+    })
+  }
+
   return agent
 }
 
@@ -315,6 +325,14 @@ export function updateAgent(agentId: string, body: Record<string, unknown>): Age
   if (Object.keys(budgetChanges).length > 0) {
     logActivity({ entityType: 'budget', entityId: agentId, action: 'configured', actor: 'user', summary: `Budget updated for agent "${updated.name}"`, detail: budgetChanges })
   }
+
+  // Auto-register on SwarmFeed/SwarmDock when enabled without existing credentials
+  if (updated.swarmfeedEnabled && !updated.swarmfeedApiKey) {
+    tryAutoRegisterSwarmFeed(updated).catch((err) => {
+      log.error('agent-service', `SwarmFeed auto-registration failed for "${updated.name}": ${err instanceof Error ? err.message : err}`)
+    })
+  }
+
   return updated
 }
 

package/src/lib/server/agents/agent-swarm-registration.ts

@@ -0,0 +1,35 @@
+import { registerAgent } from '@/lib/swarmfeed-client'
+import { patchAgent } from '@/lib/server/agents/agent-repository'
+import { log } from '@/lib/server/logger'
+import type { Agent } from '@/types'
+
+/**
+ * Auto-register an agent on SwarmFeed when enabled but missing API key.
+ * Fire-and-forget — called after agent save, patches agent with the returned credentials.
+ */
+export async function tryAutoRegisterSwarmFeed(agent: Agent): Promise<void> {
+  if (!agent.swarmfeedEnabled || agent.swarmfeedApiKey) return
+
+  log.info('swarm-registration', `Auto-registering agent "${agent.name}" on SwarmFeed`)
+  const reg = await registerAgent({
+    name: agent.name,
+    description: agent.description || agent.swarmfeedBio || `${agent.name} agent on SwarmClaw`,
+    framework: 'swarmclaw',
+    model: agent.model,
+    avatar: agent.avatarUrl || undefined,
+    bio: agent.swarmfeedBio || undefined,
+  })
+
+  patchAgent(agent.id, (current) => {
+    if (!current) return null
+    return {
+      ...current,
+      swarmfeedApiKey: reg.apiKey,
+      swarmfeedAgentId: reg.agentId,
+      swarmfeedJoinedAt: current.swarmfeedJoinedAt ?? Date.now(),
+      updatedAt: Date.now(),
+    }
+  })
+
+  log.info('swarm-registration', `Agent "${agent.name}" registered on SwarmFeed as ${reg.agentId}`)
+}

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

@@ -2,6 +2,7 @@ import { log } from '@/lib/server/logger'
 import { hmrSingleton } from '@/lib/shared-utils'
 import { logActivity } from '@/lib/server/activity/activity-log'
 import type { Connector, InboundMessage } from '@/types/connector'
+import type { Agent } from '@/types/agent'
 import type { PlatformConnector, ConnectorInstance } from '@/lib/server/connectors/types'
 import { createBoardTaskFromAssignment, updateBoardTaskFromEvent, findBoardTaskBySwarmdockId } from './swarmdock-tasks'
 import { shouldAutoBid, submitAutoBid } from './swarmdock-bidding'
@@ -19,15 +20,15 @@ interface SwarmDockConfig {
   paymentPrivateKey?: string
 }
 
-function parseConfig(connector: Connector): SwarmDockConfig {
+function parseConfig(connector: Connector, agent?: Agent): SwarmDockConfig {
   const c = connector.config || {}
   return {
     apiUrl: c.apiUrl || 'https://swarmdock-api.onrender.com',
     walletAddress: c.walletAddress || '',
-    agentDescription: c.agentDescription || connector.name || '',
-    skills: c.skills || '',
-    autoDiscover: c.autoDiscover === 'true',
-    maxBudget: c.maxBudget || '0',
+    agentDescription: c.agentDescription || agent?.swarmdockDescription || connector.name || '',
+    skills: c.skills || (agent?.swarmdockSkills?.join(',') ?? ''),
+    autoDiscover: c.autoDiscover === 'true' || (agent?.swarmdockMarketplace?.autoDiscover ?? false),
+    maxBudget: c.maxBudget || agent?.swarmdockMarketplace?.maxBudgetUsdc || '0',
     paymentPrivateKey: c.paymentPrivateKey || undefined,
   }
 }
@@ -82,7 +83,13 @@ const taskIdMap = hmrSingleton('__swarmclaw_swarmdock_task_map__', () => new Map
 
 const swarmdock: PlatformConnector = {
   async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
-    const config = parseConfig(connector)
+    // Load agent to use agent-level fields as fallbacks for connector config
+    let agent: Agent | undefined
+    if (connector.agentId) {
+      const { loadAgent } = await import('@/lib/server/agents/agent-repository')
+      agent = (await loadAgent(connector.agentId)) ?? undefined
+    }
+    const config = parseConfig(connector, agent)
     const connectorId = connector.id
     const agentId = connector.agentId || ''
     const privateKey = _botToken || ''
@@ -138,6 +145,21 @@ const swarmdock: PlatformConnector = {
       })
       log.info(TAG, `Registered as ${registration.agent.did} (trust level ${registration.agent.trustLevel})`)
 
+      // Write SwarmDock IDs back to agent record if not already set
+      if (agent && (!agent.swarmdockAgentId || !agent.swarmdockDid)) {
+        const { patchAgent } = await import('@/lib/server/agents/agent-repository')
+        patchAgent(agent.id, (current) => {
+          if (!current) return null
+          return {
+            ...current,
+            swarmdockAgentId: registration.agent.id,
+            swarmdockDid: registration.agent.did,
+            swarmdockListedAt: current.swarmdockListedAt ?? Date.now(),
+            updatedAt: Date.now(),
+          }
+        })
+      }
+
       logActivity({
         entityType: 'connector',
         entityId: connectorId,

package/src/lib/server/session-tools/index.ts

@@ -44,6 +44,8 @@ import { buildSkillsTools } from './skills-tool'
 import { buildFilesTools } from './files-tool'
 import { buildMemoryTool } from './memory-tool'
 import { buildPlatformV2Tools } from './platform-tool'
+import { buildSwarmFeedTools } from './swarmfeed'
+import { buildSwarmDockTools } from './swarmdock'
 import './connector'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { enforceFileAccessPolicy } from './file-access-policy'
@@ -208,6 +210,8 @@ export async function buildSessionTools(cwd: string, enabledExtensions: string[]
       ['files_v2', buildFilesTools],
       ['memory_v2', buildMemoryTool],
       ['platform_v2', buildPlatformV2Tools],
+      ['swarmfeed', buildSwarmFeedTools],
+      ['swarmdock', buildSwarmDockTools],
     ]
 
     for (const [extensionId, builder] of nativeBuilders) {

package/src/lib/server/session-tools/openclaw-nodes.test.ts

@@ -29,7 +29,7 @@ test('executeNodesAction lists nodes against the selected gateway profile', asyn
   const result = JSON.parse(raw)
   assert.equal(result.status, 'ok')
   assert.equal(calls[0]?.method, 'node.list')
-  assert.deepEqual(calls[0]?.params, { profileId: 'gateway-1' })
+  assert.deepEqual(calls[0]?.params, {})
   assert.equal(result.result.nodes[0].nodeId, 'node-1')
 })
 
@@ -71,7 +71,7 @@ test('executeNodesAction routes device pairing approvals to the device RPC surfa
   const result = JSON.parse(raw)
   assert.equal(result.status, 'ok')
   assert.equal(calls[0]?.method, 'device.pair.approve')
-  assert.deepEqual(calls[0]?.params, { requestId: 'req-1', profileId: 'gateway-1' })
+  assert.deepEqual(calls[0]?.params, { requestId: 'req-1' })
 })
 
 test('executeNodesAction forwards notify payloads through node.invoke with a generated idempotency key', async () => {
@@ -106,6 +106,5 @@ test('executeNodesAction forwards notify payloads through node.invoke with a gen
     params: { urgency: 'high', message: 'hello from test' },
     timeoutMs: 5000,
     idempotencyKey: 'fixed-id',
-    profileId: 'gateway-1',
   })
 })

package/src/lib/server/session-tools/openclaw-nodes.ts

@@ -44,18 +44,18 @@ export async function executeNodesAction(args: any, deps: OpenClawNodesDeps = {}
     }
 
     if (action === 'list') {
-      const result = await gateway.rpc('node.list', { profileId })
+      const result = await gateway.rpc('node.list', {})
       return JSON.stringify({ status: 'ok', action, result })
     }
     if (action === 'describe') {
       if (!nodeId) return JSON.stringify({ status: 'error', error: 'nodeId is required for describe.' })
-      const result = await gateway.rpc('node.describe', { nodeId, profileId })
+      const result = await gateway.rpc('node.describe', { nodeId })
       return JSON.stringify({ status: 'ok', action, nodeId, result })
     }
     if (action === 'pairings') {
       const [nodePairings, devicePairings] = await Promise.all([
-        gateway.rpc('node.pair.list', { profileId }),
-        gateway.rpc('device.pair.list', { profileId }),
+        gateway.rpc('node.pair.list', {}),
+        gateway.rpc('device.pair.list', {}),
       ])
       return JSON.stringify({
         status: 'ok',
@@ -69,18 +69,18 @@ export async function executeNodesAction(args: any, deps: OpenClawNodesDeps = {}
     if (action === 'approve_pairing') {
       if (!requestId) return JSON.stringify({ status: 'error', error: 'requestId is required for approve_pairing.' })
       const method = pairingType === 'device' ? 'device.pair.approve' : 'node.pair.approve'
-      const result = await gateway.rpc(method, { requestId, profileId })
+      const result = await gateway.rpc(method, { requestId })
       return JSON.stringify({ status: 'ok', action, pairingType, requestId, result })
     }
     if (action === 'reject_pairing') {
       if (!requestId) return JSON.stringify({ status: 'error', error: 'requestId is required for reject_pairing.' })
       const method = pairingType === 'device' ? 'device.pair.reject' : 'node.pair.reject'
-      const result = await gateway.rpc(method, { requestId, profileId })
+      const result = await gateway.rpc(method, { requestId })
       return JSON.stringify({ status: 'ok', action, pairingType, requestId, result })
     }
     if (action === 'remove_device') {
       if (!deviceId) return JSON.stringify({ status: 'error', error: 'deviceId is required for remove_device.' })
-      const result = await gateway.rpc('device.pair.remove', { deviceId, profileId })
+      const result = await gateway.rpc('device.pair.remove', { deviceId })
       return JSON.stringify({ status: 'ok', action, deviceId, result })
     }
     if (action === 'notify' || action === 'invoke') {
@@ -98,7 +98,6 @@ export async function executeNodesAction(args: any, deps: OpenClawNodesDeps = {}
         params: invokeParams,
         timeoutMs,
         idempotencyKey: generateId(),
-        profileId,
       })
       return JSON.stringify({ status: 'ok', action, nodeId, command: invokeCommand, result })
     }

package/src/lib/server/session-tools/swarmdock.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { getAgent } from '@/lib/server/agents/agent-repository'
+import { log } from '@/lib/server/logger'
+import type { ToolBuildContext } from './context'
+import type { Agent } from '@/types'
+
+const TAG = 'swarmdock-tool'
+
+const SWARMDOCK_SCHEMA = z.object({
+  action: z.enum(['browse_tasks', 'check_status', 'list_skills', 'get_agent_profile']).describe(
+    'The SwarmDock marketplace action to perform',
+  ),
+  taskId: z.string().optional().describe('Task ID for task-specific actions'),
+  skillFilter: z.string().optional().describe('Filter tasks by skill (e.g. "data-analysis")'),
+  limit: z.number().optional().describe('Number of results to return (default: 10)'),
+})
+
+type SwarmDockInput = z.infer<typeof SWARMDOCK_SCHEMA>
+
+async function executeSwarmDock(input: SwarmDockInput, bctx: ToolBuildContext): Promise<string> {
+  const agentId = bctx.ctx?.agentId
+  if (!agentId) return JSON.stringify({ error: 'No agent context' })
+
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent) return JSON.stringify({ error: 'Agent not found' })
+  if (!agent.swarmdockEnabled) return JSON.stringify({ error: 'SwarmDock is not enabled for this agent' })
+
+  try {
+    switch (input.action) {
+      case 'browse_tasks': {
+        const apiUrl = process.env.SWARMDOCK_API_URL || 'https://swarmdock-api.onrender.com'
+        const res = await fetch(`${apiUrl}/api/v1/tasks?limit=${input.limit || 10}${input.skillFilter ? `&skill=${input.skillFilter}` : ''}`)
+        if (!res.ok) {
+          const text = await res.text().catch(() => 'Unknown error')
+          return JSON.stringify({ error: `SwarmDock API error ${res.status}: ${text}` })
+        }
+        const data = await res.json()
+        return JSON.stringify({ tasks: data.tasks || data })
+      }
+
+      case 'check_status': {
+        return JSON.stringify({
+          agent: agent.name,
+          swarmdockEnabled: agent.swarmdockEnabled,
+          swarmdockAgentId: agent.swarmdockAgentId || null,
+          swarmdockDid: agent.swarmdockDid || null,
+          listedAt: agent.swarmdockListedAt || null,
+          skills: agent.swarmdockSkills || [],
+          description: agent.swarmdockDescription || null,
+          marketplace: agent.swarmdockMarketplace || null,
+        })
+      }
+
+      case 'list_skills': {
+        return JSON.stringify({
+          agentSkills: agent.swarmdockSkills || [],
+          description: agent.swarmdockDescription || null,
+        })
+      }
+
+      case 'get_agent_profile': {
+        return JSON.stringify({
+          name: agent.name,
+          description: agent.swarmdockDescription || agent.description || null,
+          skills: agent.swarmdockSkills || [],
+          swarmdockAgentId: agent.swarmdockAgentId || null,
+          swarmdockDid: agent.swarmdockDid || null,
+          walletId: agent.swarmdockWalletId || null,
+          marketplace: agent.swarmdockMarketplace || null,
+        })
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${input.action}` })
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    log.error(TAG, `Action "${input.action}" failed for agent "${agent.name}": ${message}`)
+    return JSON.stringify({ error: message })
+  }
+}
+
+export function buildSwarmDockTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const agentId = bctx.ctx?.agentId
+  if (!agentId) return []
+
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent?.swarmdockEnabled) return []
+
+  return [
+    tool(
+      async (args) => executeSwarmDock(args as SwarmDockInput, bctx),
+      {
+        name: 'swarmdock',
+        description:
+          'Interact with SwarmDock, the AI agent marketplace. ' +
+          'Actions: browse_tasks (find available tasks), check_status (check marketplace registration status), ' +
+          'list_skills (view configured skills), get_agent_profile (view marketplace profile).',
+        schema: SWARMDOCK_SCHEMA,
+      },
+    ),
+  ]
+}