@swarmclawai/swarmclaw 1.4.3 → 1.4.6

package/README.md

@@ -211,6 +211,15 @@ SwarmClaw agents can join [SwarmFeed](https://swarmfeed.ai) — a social network
 
 Read the docs at [swarmclaw.ai/docs/swarmfeed](https://swarmclaw.ai/docs/swarmfeed) and visit [swarmfeed.ai](https://swarmfeed.ai) for the platform itself.
 
+### v1.4.5 Highlights
+
+- **OpenClaw 2026.4.x compatibility**: Fixed WebSocket protocol errors when connecting to OpenClaw 2026.4.2+ gateways (`profileId` was incorrectly included in RPC params)
+- **OpenClaw dependency bump**: Updated minimum OpenClaw from `2026.2.26` to `2026.4.2`
+
+### v1.4.4 Highlights
+
+- **SwarmDock SDK bump**: Updated `@swarmdock/sdk` from `0.4.1` to `0.5.2`, picking up new error types, skill templates, and agent primitives
+
 ### v1.4.3 Highlights
 
 - **SwarmDock agent opt-in**: Agents can now opt into the SwarmDock marketplace directly from their settings sheet with description, skills, wallet, and auto-bid configuration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.4.3",
+  "version": "1.4.6",
   "description": "Self-hosted AI runtime for OpenClaw, delegation, autonomy, runtime skills, crypto wallets, and chat platform connectors.",
   "license": "MIT",
   "publishConfig": {
@@ -73,7 +73,7 @@
     "cli": "node ./bin/swarmclaw.js",
     "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
     "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts",
-    "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
+    "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/connectors/swarmdock.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/session-tools/swarmdock.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
     "test:runtime": "tsx --test src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/safe-parse-body.test.ts src/app/api/approvals/route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/logs/route.test.ts src/app/api/tts/route.test.ts",
     "test:builder": "tsx --test src/features/protocols/builder/utils/nodes-to-template.test.ts src/features/protocols/builder/utils/template-to-nodes.test.ts src/features/protocols/builder/validators/dag-validator.test.ts",
     "test:e2e": "tsx .workbench/browser-e2e/run.ts",
@@ -91,7 +91,7 @@
     "@multiavatar/multiavatar": "^1.0.7",
     "@playwright/mcp": "^0.0.68",
     "@slack/bolt": "^4.6.0",
-    "@swarmdock/sdk": "^0.4.1",
+    "@swarmdock/sdk": "^0.5.3",
     "@tailwindcss/postcss": "^4",
     "@tanstack/react-query": "^5.91.0",
     "@types/better-sqlite3": "^7.6.13",
@@ -128,7 +128,7 @@
     "next": "16.1.7",
     "next-themes": "^0.4.6",
     "nodemailer": "^8.0.1",
-    "openclaw": "^2026.2.26",
+    "openclaw": "^2026.4.2",
     "pdf-parse": "^2.4.5",
     "qrcode": "^1.5.4",
     "radix-ui": "^1.4.3",

package/src/app/api/openclaw/gateway/route.ts

@@ -61,7 +61,9 @@ export async function POST(req: Request) {
   }
 
   try {
-    const result = await gw.rpc(method, params)
+    const rpcParams = { ...params }
+    delete rpcParams.profileId
+    const result = await gw.rpc(method, rpcParams)
     return NextResponse.json({ ok: true, result })
   } catch (err: unknown) {
     const message = errorMessage(err)

package/src/components/connectors/connector-sheet.tsx

@@ -358,7 +358,7 @@ const PLATFORMS: {
     tokenLabel: 'SwarmDock Identity Key',
     tokenHelp: 'Encrypted Ed25519 private key used to authenticate this agent on SwarmDock.',
     configFields: [
-      { key: 'apiUrl', label: 'API URL', placeholder: 'https://api.swarmdock.ai', help: 'SwarmDock marketplace API endpoint' },
+      { key: 'apiUrl', label: 'API URL', placeholder: 'https://swarmdock-api.onrender.com', help: 'SwarmDock marketplace API endpoint' },
       { key: 'walletAddress', label: 'Base L2 Wallet Address', placeholder: '0x...', help: 'USDC wallet on Base L2 for payments' },
       { key: 'agentDescription', label: 'Marketplace Description', placeholder: 'Specialized in...', help: 'Description on your SwarmDock profile' },
       { key: 'skills', label: 'Skills (comma-separated)', placeholder: 'data-analysis,web-design', help: 'Skill IDs for task matching' },

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

@@ -0,0 +1,200 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { Agent } from '@/types/agent'
+import type { Connector } from '@/types/connector'
+import type { AgentWallet } from '@/types/swarmdock'
+
+import {
+  buildDesiredSwarmDockProfile,
+  buildSwarmDockAgentBackfill,
+  buildSwarmDockSkillPayload,
+  diffSwarmDockProfile,
+  resolveSwarmDockConfig,
+  resolveSwarmDockWalletAddress,
+  syncSwarmDockProfile,
+} from './swarmdock'
+
+function makeConnector(config: Record<string, string> = {}): Connector {
+  return {
+    id: 'conn-1',
+    name: 'SwarmDock Analyst',
+    platform: 'swarmdock',
+    agentId: 'agent-1',
+    chatroomId: null,
+    credentialId: null,
+    config,
+    isEnabled: true,
+    status: 'running',
+    createdAt: 1,
+    updatedAt: 1,
+  }
+}
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    id: 'agent-1',
+    name: 'SwarmDock Analyst',
+    description: 'Local agent',
+    systemPrompt: 'You are helpful.',
+    provider: 'openai',
+    model: 'gpt-4.1',
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  }
+}
+
+function makeWallet(overrides: Partial<AgentWallet> = {}): AgentWallet {
+  return {
+    id: 'wallet-1',
+    agentId: 'agent-1',
+    walletAddress: '0x000000000000000000000000000000000000dEaD',
+    chain: 'base',
+    createdAt: 1,
+    ...overrides,
+  }
+}
+
+test('resolveSwarmDockWalletAddress only accepts the selected wallet for the owning agent', () => {
+  const agent = makeAgent({ swarmdockWalletId: 'wallet-1' })
+
+  assert.equal(resolveSwarmDockWalletAddress(agent, makeWallet()), '0x000000000000000000000000000000000000dEaD')
+  assert.equal(resolveSwarmDockWalletAddress(agent, makeWallet({ id: 'wallet-2' })), '')
+  assert.equal(resolveSwarmDockWalletAddress(agent, makeWallet({ agentId: 'agent-2' })), '')
+})
+
+test('resolveSwarmDockConfig uses agent defaults and wallet fallback when connector config is incomplete', () => {
+  const connector = makeConnector({ autoDiscover: 'true' })
+  const agent = makeAgent({
+    swarmdockDescription: 'Marketplace specialist',
+    swarmdockSkills: ['data-analysis', 'reporting'],
+    swarmdockMarketplace: { enabled: true, autoDiscover: false, maxBudgetUsdc: '2500000', autoBid: false, autoBidMaxPrice: '0', taskNotifications: true, preferredCategories: [] },
+  })
+
+  const config = resolveSwarmDockConfig(connector, agent, '0x000000000000000000000000000000000000dEaD')
+
+  assert.equal(config.apiUrl, 'https://swarmdock-api.onrender.com')
+  assert.equal(config.walletAddress, '0x000000000000000000000000000000000000dEaD')
+  assert.equal(config.agentDescription, 'Marketplace specialist')
+  assert.equal(config.skills, 'data-analysis,reporting')
+  assert.equal(config.autoDiscover, true)
+  assert.equal(config.maxBudget, '2500000')
+})
+
+test('buildSwarmDockSkillPayload produces stable skill definitions', () => {
+  assert.deepEqual(buildSwarmDockSkillPayload('data-analysis'), [{
+    skillId: 'data-analysis',
+    skillName: 'data analysis',
+    description: 'data-analysis capability',
+    category: 'data-analysis',
+    tags: [],
+    inputModes: ['text'],
+    outputModes: ['text'],
+    pricingModel: 'per-task',
+    basePrice: '1000000',
+    examplePrompts: [
+      'Perform a data analysis task',
+      'Help me with data analysis',
+      'I need data analysis work done',
+      'Complete a data analysis assignment',
+      'Handle a data analysis request',
+    ],
+  }])
+})
+
+test('diffSwarmDockProfile is a no-op when the live profile already matches local state', () => {
+  const connector = makeConnector()
+  const agent = makeAgent({ swarmdockDescription: 'Marketplace specialist', swarmdockSkills: ['data-analysis'] })
+  const desired = buildDesiredSwarmDockProfile(
+    connector,
+    resolveSwarmDockConfig(connector, agent, '0x000000000000000000000000000000000000dEaD'),
+    agent,
+  )
+
+  const diff = diffSwarmDockProfile({
+    id: 'dock-agent-1',
+    did: 'did:key:test',
+    createdAt: '2026-04-01T12:00:00.000Z',
+    displayName: desired.displayName,
+    description: desired.description,
+    framework: desired.framework,
+    modelProvider: desired.modelProvider ?? null,
+    modelName: desired.modelName ?? null,
+    walletAddress: desired.walletAddress,
+    skills: desired.skills,
+  }, desired)
+
+  assert.deepEqual(diff.profileFields, {})
+  assert.equal(diff.shouldUpdateSkills, false)
+})
+
+test('syncSwarmDockProfile patches drifted fields and updates skills only when needed', async () => {
+  const desired = {
+    displayName: 'SwarmDock Analyst',
+    description: 'Marketplace specialist',
+    framework: 'swarmclaw',
+    modelProvider: 'openai',
+    modelName: 'gpt-4.1',
+    walletAddress: '0x000000000000000000000000000000000000dEaD',
+    skills: buildSwarmDockSkillPayload('data-analysis'),
+  }
+
+  const calls: {
+    profileUpdates: unknown[]
+    skillUpdates: unknown[]
+  } = {
+    profileUpdates: [],
+    skillUpdates: [],
+  }
+
+  const result = await syncSwarmDockProfile(
+    {
+      profile: {
+        get: async () => ({
+          id: 'dock-agent-1',
+          did: 'did:key:test',
+          createdAt: '2026-04-01T12:00:00.000Z',
+          displayName: 'Old Name',
+          description: null,
+          framework: null,
+          modelProvider: null,
+          modelName: null,
+          walletAddress: '0x0000000000000000000000000000000000000000',
+          skills: [],
+        }),
+        update: async (fields) => {
+          calls.profileUpdates.push(fields)
+        },
+        updateSkills: async (skills) => {
+          calls.skillUpdates.push(skills)
+        },
+      },
+    },
+    desired,
+  )
+
+  assert.equal(result.updatedProfile, true)
+  assert.equal(result.updatedSkills, true)
+  assert.deepEqual(calls.profileUpdates, [{
+    displayName: 'SwarmDock Analyst',
+    description: 'Marketplace specialist',
+    framework: 'swarmclaw',
+    modelProvider: 'openai',
+    modelName: 'gpt-4.1',
+    walletAddress: '0x000000000000000000000000000000000000dEaD',
+  }])
+  assert.equal(calls.skillUpdates.length, 1)
+})
+
+test('buildSwarmDockAgentBackfill uses the live profile createdAt timestamp', () => {
+  const backfill = buildSwarmDockAgentBackfill({
+    id: 'dock-agent-1',
+    did: 'did:key:test',
+    createdAt: '2026-04-01T12:00:00.000Z',
+  })
+
+  assert.equal(backfill.swarmdockAgentId, 'dock-agent-1')
+  assert.equal(backfill.swarmdockDid, 'did:key:test')
+  assert.equal(backfill.swarmdockListedAt, Date.parse('2026-04-01T12:00:00.000Z'))
+})

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

@@ -3,12 +3,54 @@ 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 { AgentWallet } from '@/types/swarmdock'
 import type { PlatformConnector, ConnectorInstance } from '@/lib/server/connectors/types'
 import { createBoardTaskFromAssignment, updateBoardTaskFromEvent, findBoardTaskBySwarmdockId } from './swarmdock-tasks'
 import { shouldAutoBid, submitAutoBid } from './swarmdock-bidding'
-import type { Task, SSEEvent, TaskSubmitInput } from '@swarmdock/shared'
+import type {
+  Agent as SwarmDockAgentProfile,
+  AgentSkill,
+  AgentUpdateInput,
+  SSEEvent,
+  Task,
+  TaskSubmitInput,
+} from '@swarmdock/shared'
 
 const TAG = 'swarmdock'
+const DEFAULT_SWARMDOCK_API_URL = 'https://swarmdock-api.onrender.com'
+
+export interface SwarmDockSkillPayload {
+  skillId: string
+  skillName: string
+  description: string
+  category: string
+  tags: string[]
+  inputModes: string[]
+  outputModes: string[]
+  pricingModel: string
+  basePrice: string
+  examplePrompts: string[]
+}
+
+export interface DesiredSwarmDockProfile {
+  displayName: string
+  description: string
+  framework: string
+  modelProvider?: string
+  modelName?: string
+  walletAddress: string
+  skills: SwarmDockSkillPayload[]
+}
+
+type SwarmDockProfileSnapshot = Pick<
+  SwarmDockAgentProfile,
+  'id' | 'did' | 'createdAt' | 'displayName' | 'description' | 'framework' | 'modelProvider' | 'modelName' | 'walletAddress'
+> & {
+  skills?: Array<Pick<
+    AgentSkill,
+    'skillId' | 'skillName' | 'description' | 'category' | 'tags' | 'inputModes' | 'outputModes' | 'pricingModel' | 'basePrice' | 'examplePrompts'
+  >>
+}
 
 interface SwarmDockConfig {
   apiUrl: string
@@ -20,19 +62,174 @@ interface SwarmDockConfig {
   paymentPrivateKey?: string
 }
 
-function parseConfig(connector: Connector, agent?: Agent): SwarmDockConfig {
+function clean(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function parseTimestamp(value: string | null | undefined): number | null {
+  if (!value) return null
+  const parsed = Date.parse(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+export function resolveSwarmDockWalletAddress(agent?: Agent, wallet?: AgentWallet | null): string {
+  if (!agent?.swarmdockWalletId || !wallet) return ''
+  if (wallet.id !== agent.swarmdockWalletId) return ''
+  if (wallet.agentId !== agent.id) return ''
+  return clean(wallet.walletAddress)
+}
+
+export function resolveSwarmDockConfig(
+  connector: Connector,
+  agent?: Agent,
+  fallbackWalletAddress?: string | null,
+): SwarmDockConfig {
   const c = connector.config || {}
   return {
-    apiUrl: c.apiUrl || 'https://swarmdock-api.onrender.com',
-    walletAddress: c.walletAddress || '',
-    agentDescription: c.agentDescription || agent?.swarmdockDescription || connector.name || '',
-    skills: c.skills || (agent?.swarmdockSkills?.join(',') ?? ''),
+    apiUrl: clean(c.apiUrl) || DEFAULT_SWARMDOCK_API_URL,
+    walletAddress: clean(c.walletAddress) || clean(fallbackWalletAddress),
+    agentDescription: clean(c.agentDescription) || clean(agent?.swarmdockDescription) || clean(connector.name),
+    skills: clean(c.skills) || (Array.isArray(agent?.swarmdockSkills) ? agent.swarmdockSkills.join(',') : ''),
     autoDiscover: c.autoDiscover === 'true' || (agent?.swarmdockMarketplace?.autoDiscover ?? false),
-    maxBudget: c.maxBudget || agent?.swarmdockMarketplace?.maxBudgetUsdc || '0',
-    paymentPrivateKey: c.paymentPrivateKey || undefined,
+    maxBudget: clean(c.maxBudget) || clean(agent?.swarmdockMarketplace?.maxBudgetUsdc) || '0',
+    paymentPrivateKey: clean(c.paymentPrivateKey) || undefined,
   }
 }
 
+export function buildSwarmDockSkillPayload(skills: string): SwarmDockSkillPayload[] {
+  return skills
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .map((skillId) => ({
+      skillId,
+      skillName: skillId.replace(/-/g, ' '),
+      description: `${skillId} capability`,
+      category: skillId,
+      tags: [],
+      basePrice: '1000000',
+      inputModes: ['text'],
+      outputModes: ['text'],
+      pricingModel: 'per-task',
+      examplePrompts: generateExamplePrompts(skillId),
+    }))
+}
+
+export function buildDesiredSwarmDockProfile(
+  connector: Connector,
+  config: SwarmDockConfig,
+  agent?: Agent,
+): DesiredSwarmDockProfile {
+  return {
+    displayName: connector.name,
+    description: config.agentDescription,
+    framework: 'swarmclaw',
+    modelProvider: agent?.provider,
+    modelName: agent?.model,
+    walletAddress: config.walletAddress,
+    skills: buildSwarmDockSkillPayload(config.skills),
+  }
+}
+
+function normalizeComparableSkills(skills: Array<Pick<
+  AgentSkill | SwarmDockSkillPayload,
+  'skillId' | 'skillName' | 'description' | 'category' | 'tags' | 'inputModes' | 'outputModes' | 'pricingModel' | 'basePrice' | 'examplePrompts'
+>>): SwarmDockSkillPayload[] {
+  return skills
+    .map((skill) => ({
+      skillId: skill.skillId,
+      skillName: skill.skillName,
+      description: skill.description,
+      category: skill.category,
+      tags: [...(skill.tags ?? [])],
+      inputModes: [...(skill.inputModes ?? [])],
+      outputModes: [...(skill.outputModes ?? [])],
+      pricingModel: skill.pricingModel,
+      basePrice: String(skill.basePrice),
+      examplePrompts: [...(skill.examplePrompts ?? [])],
+    }))
+    .sort((a, b) => a.skillId.localeCompare(b.skillId))
+}
+
+export function diffSwarmDockProfile(
+  liveProfile: SwarmDockProfileSnapshot,
+  desired: DesiredSwarmDockProfile,
+): { profileFields: AgentUpdateInput; shouldUpdateSkills: boolean } {
+  const profileFields: AgentUpdateInput = {}
+
+  if (liveProfile.displayName !== desired.displayName) profileFields.displayName = desired.displayName
+  if ((liveProfile.description ?? '') !== desired.description) profileFields.description = desired.description
+  if ((liveProfile.framework ?? '') !== desired.framework) profileFields.framework = desired.framework
+  if ((liveProfile.modelProvider ?? '') !== (desired.modelProvider ?? '')) profileFields.modelProvider = desired.modelProvider ?? ''
+  if ((liveProfile.modelName ?? '') !== (desired.modelName ?? '')) profileFields.modelName = desired.modelName ?? ''
+  if (liveProfile.walletAddress !== desired.walletAddress) profileFields.walletAddress = desired.walletAddress
+
+  const liveSkills = normalizeComparableSkills(liveProfile.skills ?? [])
+  const desiredSkills = normalizeComparableSkills(desired.skills)
+  const shouldUpdateSkills = JSON.stringify(liveSkills) !== JSON.stringify(desiredSkills)
+
+  return { profileFields, shouldUpdateSkills }
+}
+
+export async function syncSwarmDockProfile(
+  client: {
+    profile: {
+      get: () => Promise<SwarmDockProfileSnapshot>
+      update: (fields: AgentUpdateInput) => Promise<unknown>
+      updateSkills: (skills: SwarmDockSkillPayload[]) => Promise<unknown>
+    }
+  },
+  desired: DesiredSwarmDockProfile,
+): Promise<{ liveProfile: SwarmDockProfileSnapshot; updatedProfile: boolean; updatedSkills: boolean }> {
+  const liveProfile = await client.profile.get()
+  const { profileFields, shouldUpdateSkills } = diffSwarmDockProfile(liveProfile, desired)
+  const updatedProfile = Object.keys(profileFields).length > 0
+
+  if (updatedProfile) {
+    await client.profile.update(profileFields)
+  }
+  if (shouldUpdateSkills) {
+    await client.profile.updateSkills(desired.skills)
+  }
+
+  return { liveProfile, updatedProfile, updatedSkills: shouldUpdateSkills }
+}
+
+export function buildSwarmDockAgentBackfill(
+  profile: Pick<SwarmDockAgentProfile, 'id' | 'did'> & { createdAt?: string | null },
+): Pick<Agent, 'swarmdockAgentId' | 'swarmdockDid' | 'swarmdockListedAt'> {
+  return {
+    swarmdockAgentId: profile.id,
+    swarmdockDid: profile.did,
+    swarmdockListedAt: parseTimestamp(profile.createdAt) ?? Date.now(),
+  }
+}
+
+async function persistSwarmDockAgentBackfill(
+  agent: Agent | undefined,
+  profile: Pick<SwarmDockAgentProfile, 'id' | 'did'> & { createdAt?: string | null },
+) {
+  if (!agent) return
+  const backfill = buildSwarmDockAgentBackfill(profile)
+  const { patchAgent } = await import('@/lib/server/agents/agent-repository')
+  patchAgent(agent.id, (current) => {
+    if (!current) return null
+
+    const needsId = !current.swarmdockAgentId
+    const needsDid = !current.swarmdockDid
+    const needsListedAt = current.swarmdockListedAt == null
+    if (!needsId && !needsDid && !needsListedAt) return current
+
+    return {
+      ...current,
+      ...(needsId ? { swarmdockAgentId: backfill.swarmdockAgentId } : {}),
+      ...(needsDid ? { swarmdockDid: backfill.swarmdockDid } : {}),
+      ...(needsListedAt ? { swarmdockListedAt: backfill.swarmdockListedAt } : {}),
+      updatedAt: Date.now(),
+    }
+  })
+}
+
 function buildTaskPrompt(task: Task): string {
   const lines: string[] = [
     `# SwarmDock Task: ${task.title}`,
@@ -89,7 +286,13 @@ const swarmdock: PlatformConnector = {
       const { loadAgent } = await import('@/lib/server/agents/agent-repository')
       agent = (await loadAgent(connector.agentId)) ?? undefined
     }
-    const config = parseConfig(connector, agent)
+    let walletAddressFallback = ''
+    if (agent?.swarmdockWalletId) {
+      const { loadWallet } = await import('@/lib/server/wallets/wallet-repository')
+      walletAddressFallback = resolveSwarmDockWalletAddress(agent, loadWallet(agent.swarmdockWalletId))
+    }
+
+    const config = resolveSwarmDockConfig(connector, agent, walletAddressFallback)
     const connectorId = connector.id
     const agentId = connector.agentId || ''
     const privateKey = _botToken || ''
@@ -118,47 +321,21 @@ const swarmdock: PlatformConnector = {
         : {}),
     })
 
-    // Register agent on SwarmDock (Ed25519 challenge-response)
-    const skillList = config.skills
-      .split(',')
-      .map((s) => s.trim())
-      .filter(Boolean)
-      .map((skillId) => ({
-        skillId,
-        skillName: skillId.replace(/-/g, ' '),
-        description: `${skillId} capability`,
-        category: skillId,
-        basePrice: '1000000', // $1.00 default
-        inputModes: ['text'],
-        outputModes: ['text'],
-        examplePrompts: generateExamplePrompts(skillId),
-      }))
+    const desiredProfile = buildDesiredSwarmDockProfile(connector, config, agent)
 
     log.info(TAG, `Registering agent "${connector.name}" on SwarmDock at ${config.apiUrl}`)
     try {
       const registration = await client.register({
-        displayName: connector.name,
-        description: config.agentDescription,
-        framework: 'swarmclaw',
-        walletAddress: config.walletAddress,
-        skills: skillList,
+        displayName: desiredProfile.displayName,
+        description: desiredProfile.description,
+        framework: desiredProfile.framework,
+        modelProvider: desiredProfile.modelProvider,
+        modelName: desiredProfile.modelName,
+        walletAddress: desiredProfile.walletAddress,
+        skills: desiredProfile.skills,
       })
       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(),
-          }
-        })
-      }
+      await persistSwarmDockAgentBackfill(agent, registration.agent)
 
       logActivity({
         entityType: 'connector',
@@ -171,6 +348,14 @@ const swarmdock: PlatformConnector = {
       if (err instanceof ConflictError) {
         log.info(TAG, `Agent already registered, authenticating`)
         await client.authenticate()
+        const syncResult = await syncSwarmDockProfile(client, desiredProfile)
+        await persistSwarmDockAgentBackfill(agent, syncResult.liveProfile)
+        if (syncResult.updatedProfile || syncResult.updatedSkills) {
+          log.info(
+            TAG,
+            `Synchronized live SwarmDock profile${syncResult.updatedProfile ? ' fields' : ''}${syncResult.updatedProfile && syncResult.updatedSkills ? ' and' : ''}${syncResult.updatedSkills ? ' skills' : ''}`,
+          )
+        }
       } else {
         throw err
       }

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.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-swarmdock-tool-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('swarmdock tool browses tasks with the plural skills filter', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage')
+    const toolsMod = await import('./src/lib/server/session-tools')
+    const storage = storageMod.default || storageMod
+    const toolsApi = toolsMod.default || toolsMod
+
+    let requestedUrl = null
+    globalThis.fetch = async (url) => {
+      requestedUrl = String(url)
+      return new Response(JSON.stringify({ tasks: [{ id: 'task-1' }] }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      })
+    }
+
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'SwarmDock Agent',
+        description: 'local',
+        systemPrompt: 'You are helpful.',
+        provider: 'openai',
+        model: 'gpt-4.1',
+        swarmdockEnabled: true,
+        swarmdockSkills: ['data-analysis'],
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['swarmdock'], {
+      sessionId: 'session-1',
+      agentId: 'agent_1',
+      delegationEnabled: false,
+      delegationTargetMode: 'all',
+      delegationTargetAgentIds: [],
+    })
+
+    try {
+      const tool = built.tools.find((entry) => entry.name === 'swarmdock')
+      const raw = await tool.invoke({ action: 'browse_tasks', skillFilter: 'data-analysis', limit: 2 })
+      console.log(JSON.stringify({ requestedUrl, body: JSON.parse(raw) }))
+    } finally {
+      await built.cleanup()
+    }
+  `)
+
+  assert.match(String(output.requestedUrl || ''), /\/api\/v1\/tasks\?limit=2&skills=data-analysis$/)
+  assert.deepEqual(output.body, { tasks: [{ id: 'task-1' }] })
+})

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

@@ -30,7 +30,7 @@ async function executeSwarmDock(input: SwarmDockInput, bctx: ToolBuildContext):
     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}` : ''}`)
+        const res = await fetch(`${apiUrl}/api/v1/tasks?limit=${input.limit || 10}${input.skillFilter ? `&skills=${input.skillFilter}` : ''}`)
         if (!res.ok) {
           const text = await res.text().catch(() => 'Unknown error')
           return JSON.stringify({ error: `SwarmDock API error ${res.status}: ${text}` })

package/src/lib/tool-definitions.ts

@@ -30,7 +30,7 @@ export const AVAILABLE_TOOLS: ToolDefinition[] = [
   { id: 'replicate', label: 'Replicate', description: 'Run any AI model on Replicate — image generation, LLMs, audio, video, and more', extensionId: 'replicate' },
   { id: 'google_workspace', label: 'Google Workspace', description: 'Run Google Workspace CLI (`gws`) commands for Drive, Docs, Sheets, Gmail, Calendar, Chat, and more', extensionId: 'google_workspace' },
   { id: 'swarmfeed', label: 'SwarmFeed', description: 'Post, reply, like, repost, and browse the SwarmFeed social network (auto-enabled when SwarmFeed is on)' },
-  { id: 'swarmdock', label: 'SwarmDock', description: 'Browse tasks, check status, and manage marketplace profile on SwarmDock (auto-enabled when SwarmDock is on)' },
+  { id: 'swarmdock', label: 'SwarmDock', description: 'Browse tasks and inspect marketplace status/profile on SwarmDock (auto-enabled when SwarmDock is on)' },
 ]
 
 /**