@swarmclawai/swarmclaw 1.4.5 → 1.4.7

package/README.md

@@ -211,6 +211,20 @@ 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.7 Highlights
+
+- **Hermes Agent built-in provider**: Added first-class Hermes support through the Hermes API server, including optional auth, local or remote `/v1` endpoints, and runtime-managed agent handling.
+- **OpenRouter built-in provider**: OpenRouter is now a built-in provider instead of living only behind the generic custom-provider path.
+- **Runtime-managed provider handling**: Hermes now skips SwarmClaw's local extension/tool injection path so its own runtime stays in control, while setup and model discovery still work through the normal provider flow.
+- **Provider docs refresh**: README and docs now reflect the new provider list, remote Hermes API-server support, and logo assets for OpenRouter and Hermes Agent.
+
+### v1.4.6 Highlights
+
+- **SwarmDock startup sync**: Existing SwarmDock agents now authenticate and reconcile their live marketplace profile on connector start, updating stale description, skills, framework/model metadata, and payout wallet fields
+- **Agent wallet fallback**: SwarmDock connectors now fall back to the agent's selected marketplace wallet when no connector-level wallet address is configured
+- **Task filter fix**: The built-in `swarmdock` tool now uses the correct `skills=` task filter when browsing marketplace tasks from chat
+- **SwarmDock SDK bump**: Updated `@swarmdock/sdk` from `0.5.2` to `0.5.3`, aligning the connector with the published metadata-sync fixes
+
 ### 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)
@@ -320,7 +334,9 @@ Then open `http://localhost:3456`.
 
 ## Core Capabilities
 
-- **Providers**: OpenClaw, OpenAI, Anthropic, Ollama, Google, DeepSeek, Groq, Together, Mistral, xAI, Fireworks, Nebius, DeepInfra, plus compatible custom endpoints.
+- **Providers**: OpenClaw, OpenAI, OpenRouter, Anthropic, Ollama, Hermes Agent, Google, DeepSeek, Groq, Together, Mistral, xAI, Fireworks, Nebius, DeepInfra, plus compatible custom endpoints.
+- **OpenRouter**: <img src="public/provider-logos/openrouter.png" alt="OpenRouter logo" width="20" height="20" /> Use OpenRouter as a first-class built-in provider with its standard OpenAI-compatible endpoint and routed model IDs such as `openai/gpt-4.1-mini`.
+- **Hermes Agent**: <img src="public/provider-logos/hermes-agent.png" alt="Hermes Agent logo" width="20" height="20" /> Connect Hermes through its OpenAI-compatible API server, locally or through a reachable remote `/v1` endpoint.
 - **Delegation**: built-in delegation to Claude Code, Codex CLI, OpenCode CLI, Gemini CLI, and native SwarmClaw subagents.
 - **Autonomy**: heartbeat loops, schedules, background jobs, task execution, supervisor recovery, and agent wakeups.
 - **Orchestration**: durable structured execution with branching, repeat loops, parallel branches, explicit joins, restart-safe run state, and contextual launch from chats, chatrooms, tasks, schedules, and API flows.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "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.5.2",
+    "@swarmdock/sdk": "^0.5.3",
     "@tailwindcss/postcss": "^4",
     "@tanstack/react-query": "^5.91.0",
     "@types/better-sqlite3": "^7.6.13",

package/src/app/api/setup/check-provider/route.ts

@@ -7,6 +7,7 @@ import { normalizeOllamaSetupEndpoint, normalizeOpenClawUrl, parseErrorMessage }
 
 type SetupProvider =
   | 'openai'
+  | 'openrouter'
   | 'anthropic'
   | 'google'
   | 'deepseek'
@@ -19,6 +20,7 @@ type SetupProvider =
   | 'deepinfra'
   | 'ollama'
   | 'openclaw'
+  | 'hermes'
 
 interface SetupCheckBody {
   provider?: string
@@ -46,13 +48,14 @@ async function checkOpenAiCompatible(
   modelHint?: string,
 ): Promise<{ ok: boolean; message: string; normalizedEndpoint: string }> {
   const normalizedEndpoint = (endpointRaw || defaultEndpoint).replace(/\/+$/, '')
+  const authHeaders = apiKey ? { authorization: `Bearer ${apiKey}` } : undefined
 
   // First, discover a model to test with (prefer the hint, fall back to the first available model)
   let testModel = modelHint || ''
   if (!testModel) {
     try {
       const modelsRes = await fetch(`${normalizedEndpoint}/models`, {
-        headers: { authorization: `Bearer ${apiKey}` },
+        headers: authHeaders,
         signal: AbortSignal.timeout(8_000),
         cache: 'no-store',
       })
@@ -79,6 +82,8 @@ async function checkOpenAiCompatible(
       'Fireworks AI': 'accounts/fireworks/models/llama4-scout-instruct-basic',
       Nebius: 'deepseek-ai/DeepSeek-R1-0528',
       DeepInfra: 'deepseek-ai/DeepSeek-R1-0528',
+      OpenRouter: 'openai/gpt-4.1-mini',
+      'Hermes Agent': 'hermes-agent',
     }
     testModel = fallbacks[providerName] || 'gpt-4o-mini'
   }
@@ -87,8 +92,8 @@ async function checkOpenAiCompatible(
   const res = await fetch(`${normalizedEndpoint}/chat/completions`, {
     method: 'POST',
     headers: {
-      authorization: `Bearer ${apiKey}`,
       'content-type': 'application/json',
+      ...(authHeaders || {}),
     },
     body: JSON.stringify({
       model: testModel,
@@ -294,6 +299,12 @@ export async function POST(req: Request) {
         const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
         return NextResponse.json(result)
       }
+      case 'openrouter': {
+        if (!apiKey) return NextResponse.json({ ok: false, message: 'OpenRouter API key is required.' })
+        const info = OPENAI_COMPATIBLE_DEFAULTS.openrouter
+        const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
+        return NextResponse.json(result)
+      }
       case 'anthropic': {
         if (!apiKey) return NextResponse.json({ ok: false, message: 'Anthropic API key is required.' })
         const result = await checkAnthropic(apiKey, model)
@@ -313,6 +324,11 @@ export async function POST(req: Request) {
         const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
         return NextResponse.json(result)
       }
+      case 'hermes': {
+        const info = OPENAI_COMPATIBLE_DEFAULTS.hermes
+        const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
+        return NextResponse.json(result)
+      }
       case 'ollama': {
         const result = await checkOllama({
           endpointRaw: endpoint,

package/src/components/agents/agent-sheet.tsx

@@ -35,6 +35,7 @@ const HB_PRESETS = [1800, 3600, 7200, 21600, 43200] as const
 const FALLBACK_ELEVENLABS_VOICE_ID = 'JBFqnCBsd6RMkjVDRZzb'
 const AUTO_SYNC_MODEL_PROVIDER_IDS = new Set<ProviderType>([
   'openai',
+  'openrouter',
   'anthropic',
   'google',
   'deepseek',
@@ -45,6 +46,7 @@ const AUTO_SYNC_MODEL_PROVIDER_IDS = new Set<ProviderType>([
   'fireworks',
   'nebius',
   'deepinfra',
+  'hermes',
   'ollama',
 ])
 const CONNECTION_TEST_TIMEOUT_MS = 40_000
@@ -1645,13 +1647,16 @@ export function AgentSheet() {
         </div>
       )}
 
-      {currentProvider?.requiresEndpoint && (provider === 'openclaw' || (provider === 'ollama' && ollamaMode === 'local')) && (
+      {currentProvider?.requiresEndpoint && (provider !== 'ollama' || ollamaMode === 'local') && (
         <div className="mb-8">
-          <SectionLabel>{provider === 'openclaw' ? 'OpenClaw Endpoint' : 'Endpoint'}</SectionLabel>
+          <SectionLabel>{provider === 'openclaw' ? 'OpenClaw Endpoint' : provider === 'hermes' ? 'Hermes API Endpoint' : 'Endpoint'}</SectionLabel>
           <input type="text" value={apiEndpoint || ''} onChange={(e) => setApiEndpoint(e.target.value || null)} placeholder={currentProvider.defaultEndpoint || 'http://localhost:11434'} className={`${inputClass} font-mono text-[14px]`} />
           {provider === 'openclaw' && (
             <p className="text-[13px] text-text-3/70 mt-2">The URL of your OpenClaw gateway</p>
           )}
+          {provider === 'hermes' && (
+            <p className="text-[13px] text-text-3/70 mt-2">Point this at the Hermes API server, usually <code className="text-text-2">http://127.0.0.1:8642/v1</code>.</p>
+          )}
         </div>
       )}
 
@@ -2502,7 +2507,9 @@ export function AgentSheet() {
               ? 'Claude CLI uses its own built-in capabilities — no additional local tool/platform configuration is needed.'
               : provider === 'codex-cli'
                 ? 'OpenAI Codex CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration needed.'
-                : 'OpenCode CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration needed.'}
+                : provider === 'hermes'
+                  ? 'Hermes Agent runs behind its own API server and tool runtime. SwarmClaw sends prompts to Hermes directly instead of injecting local platform tools.'
+                  : 'OpenCode CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration needed.'}
           </p>
         </div>
       )}

package/src/components/auth/setup-wizard/step-connect.tsx

@@ -329,6 +329,12 @@ export function StepConnect({
                 <p className="text-[12px] text-text-3">Remote example: <code className="text-text-2">https://your-gateway.ts.net/v1</code>.</p>
               </div>
             )}
+            {provider === 'hermes' && (
+              <div className="mt-2 space-y-0.5">
+                <p className="text-[12px] text-text-3">Hermes Agent&apos;s API server defaults to <code className="text-text-2">http://127.0.0.1:8642/v1</code>.</p>
+                <p className="text-[12px] text-text-3">Use any reachable local or remote API-server endpoint exposed by Hermes.</p>
+              </div>
+            )}
           </div>
         )}
 

package/src/components/auth/setup-wizard/utils.test.ts

@@ -265,4 +265,6 @@ test('requiresSetupProviderVerification skips custom providers', () => {
   assert.equal(requiresSetupProviderVerification('custom'), false)
   assert.equal(requiresSetupProviderVerification('openclaw'), false)
   assert.equal(requiresSetupProviderVerification('openai'), true)
+  assert.equal(requiresSetupProviderVerification('openrouter'), true)
+  assert.equal(requiresSetupProviderVerification('hermes'), true)
 })

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/app/view-constants.ts

@@ -131,7 +131,7 @@ export const VIEW_EMPTY_STATES: Record<Exclude<AppView, 'agents' | 'home'>, { ic
     icon: 'zap',
     title: 'Providers',
     description: 'Manage LLM providers including built-in and custom OpenAI-compatible endpoints.',
-    features: ['Built-in support for Claude, OpenAI, Anthropic, and Ollama', 'Add custom OpenAI-compatible providers (OpenRouter, Together, Groq)', 'Configure base URLs, models, and API keys per provider', 'Custom providers work seamlessly with all features'],
+    features: ['Built-in support for OpenAI, OpenRouter, Anthropic, Ollama, Hermes Agent, and CLI runtimes', 'Add custom OpenAI-compatible providers for local or internal gateways', 'Configure base URLs, models, and API keys per provider', 'Built-in and custom providers work seamlessly with all features'],
   },
   skills: {
     icon: 'book',

package/src/lib/orchestrator-config.test.ts

@@ -6,6 +6,7 @@ describe('orchestrator-config', () => {
   it('marks CLI and OpenClaw providers as ineligible', () => {
     assert.equal(isOrchestratorProviderEligible('openai'), true)
     assert.equal(isOrchestratorProviderEligible('openclaw'), false)
+    assert.equal(isOrchestratorProviderEligible('hermes'), false)
     assert.equal(isOrchestratorProviderEligible('codex-cli'), false)
   })
 

package/src/lib/orchestrator-config.ts

@@ -5,6 +5,7 @@ export const NON_ORCHESTRATOR_PROVIDERS = new Set([
   'codex-cli',
   'opencode-cli',
   'openclaw',
+  'hermes',
 ])
 
 export type OrchestratorGovernance = 'autonomous' | 'approval-required' | 'notify-only'

package/src/lib/provider-sets.ts

@@ -1,8 +1,11 @@
 /** CLI providers that use their own tool execution outside the shared tool-runtime path. */
 export const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli'])
 
-/** Providers with native tool/capability support (CLI providers + OpenClaw). */
-export const NATIVE_CAPABILITY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'openclaw'])
+/** Providers that manage their own runtime/tool loop even when reached over an API endpoint. */
+export const RUNTIME_MANAGED_PROVIDER_IDS = new Set(['hermes'])
+
+/** Providers with native tool/capability support (CLI providers + OpenClaw + Hermes). */
+export const NATIVE_CAPABILITY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'openclaw', 'hermes'])
 
 /** Providers that can only act as workers — no coordinator role, no heartbeat, no advanced settings. */
-export const WORKER_ONLY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'openclaw'])
+export const WORKER_ONLY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'openclaw', 'hermes'])

package/src/lib/providers/index.ts

@@ -71,6 +71,23 @@ export const PROVIDERS: Record<string, BuiltinProviderConfig> = {
     requiresEndpoint: false,
     handler: { streamChat: streamOpenAiChat },
   },
+  openrouter: {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    models: ['openai/gpt-4.1-mini'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://openrouter.ai/api/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://openrouter.ai/api/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
   anthropic: {
     id: 'anthropic',
     name: 'Anthropic',
@@ -89,6 +106,24 @@ export const PROVIDERS: Record<string, BuiltinProviderConfig> = {
     defaultEndpoint: 'http://localhost:18789',
     handler: { streamChat: streamOpenClawChat },
   },
+  hermes: {
+    id: 'hermes',
+    name: 'Hermes Agent',
+    models: ['hermes-agent'],
+    requiresApiKey: false,
+    optionalApiKey: true,
+    requiresEndpoint: true,
+    defaultEndpoint: 'http://127.0.0.1:8642/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'http://127.0.0.1:8642/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
   'opencode-cli': {
     id: 'opencode-cli',
     name: 'OpenCode CLI',

package/src/lib/providers/openai.ts

@@ -73,6 +73,10 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
           // Try with stream_options first; if the provider rejects with 400, retry without it
           let res: Response | undefined
           let usageEnabled = true
+          const headers: Record<string, string> = {
+            'Content-Type': contentType,
+          }
+          if (apiKey) headers.Authorization = `Bearer ${apiKey}`
           for (const includeStreamOptions of [true, false]) {
             const payloadObj: Record<string, unknown> = {
               model,
@@ -86,10 +90,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
 
             res = await fetch(url, {
               method: 'POST',
-              headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': contentType,
-              },
+              headers,
               body: payload,
               signal: abortController.signal,
             })

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

@@ -27,6 +27,6 @@ export function buildWorkerOnlyAgentMessage(
   const name = typeof agent?.name === 'string' && agent.name.trim()
     ? agent.name.trim()
     : 'This agent'
-  if (action) return `${name} is a CLI-based agent and cannot ${action}. CLI agents can only be used for direct chats and delegation.`
-  return `${name} is a CLI-based agent and cannot join chatrooms. CLI agents can only be used for direct chats and delegation.`
+  if (action) return `${name} uses a runtime-managed provider and cannot ${action}. Runtime-managed agents can only be used for direct chats and delegation.`
+  return `${name} uses a runtime-managed provider and cannot join chatrooms. Runtime-managed agents can only be used for direct chats and delegation.`
 }

package/src/lib/server/chat-execution/chat-turn-preparation.ts

@@ -44,7 +44,7 @@ import {
   splitCapabilityIds,
 } from '@/lib/capability-selection'
 import { normalizeProviderEndpoint, isLocalOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
-import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
+import { NON_LANGGRAPH_PROVIDER_IDS, RUNTIME_MANAGED_PROVIDER_IDS } from '@/lib/provider-sets'
 import {
   bridgeHumanReplyFromChat,
 } from '@/lib/server/chatrooms/session-mailbox'
@@ -815,9 +815,11 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
   const hideAssistantTranscript = internal && source === 'main-loop-followup'
 
   const useLocalOpenClawNativeRuntime = providerType === 'openclaw' && isLocalOpenClawEndpoint(sessionForRun.apiEndpoint)
+  const useProviderManagedRuntime = RUNTIME_MANAGED_PROVIDER_IDS.has(providerType)
   const enabledSessionExtensions = getEnabledCapabilityIds(sessionForRun)
   const hasExtensions = enabledSessionExtensions.length > 0
     && !NON_LANGGRAPH_PROVIDER_IDS.has(providerType)
+    && !useProviderManagedRuntime
     && !useLocalOpenClawNativeRuntime
 
   const systemPrompt = heartbeatLightContext

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/provider-health.test.ts

@@ -120,6 +120,7 @@ describe('provider-health', () => {
   it('OPENAI_COMPATIBLE_DEFAULTS has expected providers', () => {
     const defaults = providerHealth.OPENAI_COMPATIBLE_DEFAULTS
     assert.ok(defaults.openai)
+    assert.ok(defaults.openrouter)
     assert.ok(defaults.google)
     assert.ok(defaults.deepseek)
     assert.ok(defaults.groq)
@@ -127,11 +128,17 @@ describe('provider-health', () => {
     assert.ok(defaults.mistral)
     assert.ok(defaults.xai)
     assert.ok(defaults.fireworks)
+    assert.ok(defaults.hermes)
 
     // Each entry has name and defaultEndpoint
-    for (const [, val] of Object.entries(defaults)) {
+    for (const [key, val] of Object.entries(defaults)) {
       assert.ok(typeof val.name === 'string' && val.name.length > 0)
-      assert.ok(typeof val.defaultEndpoint === 'string' && val.defaultEndpoint.startsWith('https://'))
+      assert.ok(typeof val.defaultEndpoint === 'string' && val.defaultEndpoint.length > 0)
+      if (key === 'hermes') {
+        assert.ok(val.defaultEndpoint.startsWith('http://'))
+      } else {
+        assert.ok(val.defaultEndpoint.startsWith('https://'))
+      }
     }
   })
 

package/src/lib/server/provider-health.ts

@@ -246,6 +246,7 @@ async function parseErrorMessage(res: Response, fallback: string): Promise<strin
 
 export const OPENAI_COMPATIBLE_DEFAULTS: Record<string, { name: string; defaultEndpoint: string }> = {
   openai: { name: 'OpenAI', defaultEndpoint: 'https://api.openai.com/v1' },
+  openrouter: { name: 'OpenRouter', defaultEndpoint: 'https://openrouter.ai/api/v1' },
   google: { name: 'Google Gemini', defaultEndpoint: 'https://generativelanguage.googleapis.com/v1beta/openai' },
   deepseek: { name: 'DeepSeek', defaultEndpoint: 'https://api.deepseek.com/v1' },
   groq: { name: 'Groq', defaultEndpoint: 'https://api.groq.com/openai/v1' },
@@ -255,15 +256,18 @@ export const OPENAI_COMPATIBLE_DEFAULTS: Record<string, { name: string; defaultE
   fireworks: { name: 'Fireworks AI', defaultEndpoint: 'https://api.fireworks.ai/inference/v1' },
   nebius: { name: 'Nebius', defaultEndpoint: 'https://api.tokenfactory.nebius.com/v1' },
   deepinfra: { name: 'DeepInfra', defaultEndpoint: 'https://api.deepinfra.com/v1/openai' },
+  hermes: { name: 'Hermes Agent', defaultEndpoint: 'http://127.0.0.1:8642/v1' },
 }
 
 export async function pingOpenAiCompatible(
-  apiKey: string,
+  apiKey: string | undefined,
   endpoint: string,
 ): Promise<{ ok: boolean; message: string }> {
   const normalizedEndpoint = endpoint.replace(/\/+$/, '')
+  const headers: Record<string, string> = {}
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`
   const res = await fetch(`${normalizedEndpoint}/models`, {
-    headers: { authorization: `Bearer ${apiKey}` },
+    headers: Object.keys(headers).length > 0 ? headers : undefined,
     signal: AbortSignal.timeout(PING_TIMEOUT_MS),
     cache: 'no-store',
   })
@@ -335,6 +339,7 @@ export async function pingProvider(
   endpoint: string | undefined,
 ): Promise<{ ok: boolean; message: string }> {
   const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli']
+  const OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS = new Set(['hermes'])
   if (CLI_PROVIDERS.includes(provider)) return { ok: true, message: 'CLI provider — skipped.' }
 
   try {
@@ -352,7 +357,7 @@ export async function pingProvider(
     const defaults = OPENAI_COMPATIBLE_DEFAULTS[provider]
     const resolvedEndpoint = endpoint || defaults?.defaultEndpoint
     if (!resolvedEndpoint) return { ok: false, message: `No endpoint for provider "${provider}".` }
-    if (!apiKey) return { ok: false, message: 'No API key configured.' }
+    if (!apiKey && !OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS.has(provider)) return { ok: false, message: 'No API key configured.' }
     return await pingOpenAiCompatible(apiKey, resolvedEndpoint)
   } catch (err: unknown) {
     const msg = err instanceof Error && err.name === 'TimeoutError'

package/src/lib/server/provider-model-discovery.test.ts

@@ -208,6 +208,26 @@ test('resolveDescriptor uses explicit cloud Ollama discovery only when cloud mod
   assert.equal(descriptor?.requiresApiKey, true)
 })
 
+test('resolveDescriptor uses OpenRouter as an OpenAI-compatible provider', () => {
+  const descriptor = resolveDescriptor({
+    providerId: 'openrouter',
+  })
+  assert.equal(descriptor?.strategy, 'openai-compatible')
+  assert.equal(descriptor?.endpoint, 'https://openrouter.ai/api/v1')
+  assert.equal(descriptor?.requiresApiKey, true)
+  assert.equal(descriptor?.optionalApiKey, false)
+})
+
+test('resolveDescriptor uses Hermes as an OpenAI-compatible provider with optional auth', () => {
+  const descriptor = resolveDescriptor({
+    providerId: 'hermes',
+  })
+  assert.equal(descriptor?.strategy, 'openai-compatible')
+  assert.equal(descriptor?.endpoint, 'http://127.0.0.1:8642/v1')
+  assert.equal(descriptor?.requiresApiKey, false)
+  assert.equal(descriptor?.optionalApiKey, true)
+})
+
 // ---------------------------------------------------------------------------
 // ttlForDescriptor
 // ---------------------------------------------------------------------------

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/server/storage.ts

@@ -669,7 +669,7 @@ if (!IS_BUILD_BOOTSTRAP) {
 ## Platform
 
 - **Agents** — Create specialized AI agents (Agents tab → "+") with a provider, model, system prompt, and tools. "Generate with AI" scaffolds agents from a description. Enable cross-agent delegation when an agent should assign work to others.
-- **Providers** — Configure LLM backends in Settings → Providers: Claude Code CLI, OpenAI Codex CLI, OpenCode CLI, Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Together AI, Mistral AI, xAI (Grok), Fireworks AI, Ollama, OpenClaw, or custom OpenAI-compatible endpoints.
+- **Providers** — Configure LLM backends in Settings → Providers: Claude Code CLI, OpenAI Codex CLI, OpenCode CLI, Gemini CLI, GitHub Copilot CLI, Anthropic, OpenAI, OpenRouter, Google Gemini, DeepSeek, Groq, Together AI, Mistral AI, xAI (Grok), Fireworks AI, Nebius, DeepInfra, Ollama, OpenClaw, Hermes Agent, or custom OpenAI-compatible endpoints.
 - **Tasks** — The Task Board tracks work items. Assign agents and they'll execute autonomously.
 - **Schedules** — Cron-based recurring jobs that run agents or tasks automatically.
 - **Skills** — Reusable markdown instruction files agents can discover and use by default; pin them to keep favorite workflows always-on.

package/src/lib/setup-defaults.test.ts

@@ -27,11 +27,21 @@ test('getDefaultModelForProvider returns non-empty for openai', () => {
   assert.ok(model, 'openai model should be truthy')
 })
 
+test('getDefaultModelForProvider returns non-empty for openrouter', () => {
+  const model = getDefaultModelForProvider('openrouter')
+  assert.ok(model, 'openrouter model should be truthy')
+})
+
 test('getDefaultModelForProvider returns non-empty for anthropic', () => {
   const model = getDefaultModelForProvider('anthropic')
   assert.ok(model, 'anthropic model should be truthy')
 })
 
+test('getDefaultModelForProvider returns non-empty for hermes', () => {
+  const model = getDefaultModelForProvider('hermes')
+  assert.ok(model, 'hermes model should be truthy')
+})
+
 test('getDefaultModelForProvider returns non-empty for ollama', () => {
   const model = getDefaultModelForProvider('ollama')
   assert.ok(model, 'ollama model should be truthy')

package/src/lib/setup-defaults.ts

@@ -6,6 +6,7 @@
 export type SetupProvider =
   | 'anthropic'
   | 'openai'
+  | 'openrouter'
   | 'google'
   | 'deepseek'
   | 'groq'
@@ -17,6 +18,7 @@ export type SetupProvider =
   | 'deepinfra'
   | 'ollama'
   | 'openclaw'
+  | 'hermes'
   | 'custom'
 
 export interface SetupProviderOption {
@@ -52,6 +54,19 @@ export const SETUP_PROVIDERS: SetupProviderOption[] = [
     icon: 'O',
     modelLibraryUrl: 'https://platform.openai.com/docs/models',
   },
+  {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    description: 'One API key for a broad multi-provider model catalog through an OpenAI-compatible API.',
+    requiresKey: true,
+    supportsEndpoint: false,
+    defaultEndpoint: 'https://openrouter.ai/api/v1',
+    keyUrl: 'https://openrouter.ai/keys',
+    keyLabel: 'openrouter.ai',
+    badge: 'Catalog',
+    icon: 'R',
+    modelLibraryUrl: 'https://openrouter.ai/models',
+  },
   {
     id: 'openclaw',
     name: 'OpenClaw',
@@ -64,6 +79,18 @@ export const SETUP_PROVIDERS: SetupProviderOption[] = [
     badge: 'First-Tier',
     icon: 'C',
   },
+  {
+    id: 'hermes',
+    name: 'Hermes Agent',
+    description: 'Connect Hermes Agent through its local or remote OpenAI-compatible API server runtime.',
+    requiresKey: false,
+    supportsEndpoint: true,
+    allowMultiple: true,
+    defaultEndpoint: 'http://127.0.0.1:8642/v1',
+    optionalKey: true,
+    badge: 'API Server',
+    icon: 'H',
+  },
   {
     id: 'anthropic',
     name: 'Anthropic',
@@ -192,7 +219,7 @@ export const SETUP_PROVIDERS: SetupProviderOption[] = [
   {
     id: 'custom',
     name: 'Custom Provider',
-    description: 'Any OpenAI-compatible API endpoint (OpenRouter, LM Studio, vLLM, etc.).',
+    description: 'Any OpenAI-compatible API endpoint (LM Studio, vLLM, local gateways, etc.).',
     requiresKey: false,
     supportsEndpoint: true,
     allowMultiple: true,
@@ -598,6 +625,13 @@ export const DEFAULT_AGENTS: Record<SetupProvider, DefaultAgentConfig> = {
     model: 'gpt-4o',
     tools: STARTER_AGENT_TOOLS,
   },
+  openrouter: {
+    name: 'Router',
+    description: 'A helpful assistant powered through OpenRouter.',
+    systemPrompt: SWARMCLAW_ASSISTANT_PROMPT,
+    model: 'openai/gpt-4.1-mini',
+    tools: STARTER_AGENT_TOOLS,
+  },
   google: {
     name: 'Gemini',
     description: 'A helpful Gemini-powered assistant.',
@@ -675,6 +709,13 @@ export const DEFAULT_AGENTS: Record<SetupProvider, DefaultAgentConfig> = {
     model: '',
     tools: STARTER_AGENT_TOOLS,
   },
+  hermes: {
+    name: 'Hermes',
+    description: 'A runtime-backed assistant powered by Hermes Agent.',
+    systemPrompt: SWARMCLAW_ASSISTANT_PROMPT,
+    model: 'hermes-agent',
+    tools: STARTER_AGENT_TOOLS,
+  },
   custom: {
     name: 'Custom Agent',
     description: 'An assistant powered by a custom OpenAI-compatible provider.',

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)' },
 ]
 
 /**

package/src/types/provider.ts

@@ -1,4 +1,4 @@
-export type ProviderType = 'claude-cli' | 'codex-cli' | 'opencode-cli' | 'gemini-cli' | 'copilot-cli' | 'openai' | 'ollama' | 'anthropic' | 'openclaw' | 'google' | 'deepseek' | 'groq' | 'together' | 'mistral' | 'xai' | 'fireworks' | 'nebius' | 'deepinfra'
+export type ProviderType = 'claude-cli' | 'codex-cli' | 'opencode-cli' | 'gemini-cli' | 'copilot-cli' | 'openai' | 'openrouter' | 'ollama' | 'anthropic' | 'openclaw' | 'hermes' | 'google' | 'deepseek' | 'groq' | 'together' | 'mistral' | 'xai' | 'fireworks' | 'nebius' | 'deepinfra'
 export type ProviderId = ProviderType | (string & {})
 
 export interface ProviderInfo {