@swarmclawai/swarmclaw 1.4.6 → 1.4.8

package/src/features/swarmfeed/queries.ts

@@ -1,16 +1,43 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import { api } from '@/lib/app/api-client'
-import type { SwarmFeedPost, SwarmFeedChannel, FeedType } from '@/types/swarmfeed'
+import type {
+  CreatePostInput,
+  FeedType,
+  SwarmFeedChannel,
+  SwarmFeedFeedResponse,
+  SwarmFeedNotification,
+  SwarmFeedNotificationsResponse,
+  SwarmFeedPost,
+  SwarmFeedProfile,
+  SwarmFeedSearchResponse,
+  SwarmFeedSearchType,
+  SwarmFeedSuggestedResponse,
+} from '@/types/swarmfeed'
+
+export const swarmFeedQueryKeys = {
+  all: ['swarmfeed'] as const,
+  channels: () => ['swarmfeed', 'channels'] as const,
+  feed: (params: { type: FeedType; agentId?: string; channelId?: string }) => ['swarmfeed', 'feed', params] as const,
+  bookmarks: (agentId: string) => ['swarmfeed', 'bookmarks', agentId] as const,
+  notifications: (agentId: string) => ['swarmfeed', 'notifications', agentId] as const,
+  suggested: (agentId?: string) => ['swarmfeed', 'suggested', agentId || 'public'] as const,
+  search: (params: { query: string; type?: SwarmFeedSearchType }) => ['swarmfeed', 'search', params] as const,
+  profile: (agentId: string, viewerAgentId?: string) => ['swarmfeed', 'profile', agentId, viewerAgentId || null] as const,
+  profilePosts: (agentId: string) => ['swarmfeed', 'profile-posts', agentId] as const,
+  thread: (postId: string) => ['swarmfeed', 'thread', postId] as const,
+}
 
 export async function fetchFeed(
   type: FeedType,
-  params?: { channelId?: string; cursor?: string; limit?: number },
-): Promise<{ posts: SwarmFeedPost[]; nextCursor?: string }> {
+  params?: { agentId?: string; channelId?: string; cursor?: string; limit?: number },
+): Promise<SwarmFeedFeedResponse> {
   const searchParams = new URLSearchParams()
   searchParams.set('type', type)
+  if (params?.agentId) searchParams.set('agentId', params.agentId)
   if (params?.channelId) searchParams.set('channelId', params.channelId)
   if (params?.cursor) searchParams.set('cursor', params.cursor)
   if (params?.limit) searchParams.set('limit', String(params.limit))
-  return api<{ posts: SwarmFeedPost[]; nextCursor?: string }>('GET', `/swarmfeed?${searchParams.toString()}`)
+  return api<SwarmFeedFeedResponse>('GET', `/swarmfeed?${searchParams.toString()}`)
 }
 
 export async function fetchChannels(): Promise<SwarmFeedChannel[]> {
@@ -18,11 +45,167 @@ export async function fetchChannels(): Promise<SwarmFeedChannel[]> {
   return result.channels
 }
 
-export async function submitPost(agentId: string, content: string, channelId?: string, parentId?: string): Promise<SwarmFeedPost> {
+export async function fetchBookmarks(agentId: string): Promise<SwarmFeedPost[]> {
+  const result = await api<SwarmFeedFeedResponse>('GET', `/swarmfeed/bookmarks?agentId=${encodeURIComponent(agentId)}`)
+  return result.posts
+}
+
+export async function fetchNotifications(agentId: string): Promise<SwarmFeedNotification[]> {
+  const result = await api<SwarmFeedNotificationsResponse>('GET', `/swarmfeed/notifications?agentId=${encodeURIComponent(agentId)}`)
+  return result.notifications
+}
+
+export async function fetchSuggestedFollows(agentId?: string): Promise<SwarmFeedSuggestedResponse> {
+  const query = agentId ? `?agentId=${encodeURIComponent(agentId)}` : ''
+  return api<SwarmFeedSuggestedResponse>('GET', `/swarmfeed/suggested${query}`)
+}
+
+export async function searchFeed(query: string, type?: SwarmFeedSearchType): Promise<SwarmFeedSearchResponse> {
+  const params = new URLSearchParams({ q: query })
+  if (type) params.set('type', type)
+  return api<SwarmFeedSearchResponse>('GET', `/swarmfeed/search?${params.toString()}`)
+}
+
+export async function submitPost(
+  agentId: string,
+  input: CreatePostInput,
+): Promise<SwarmFeedPost> {
   return api<SwarmFeedPost>('POST', '/swarmfeed/posts', {
     agentId,
-    content,
-    channelId,
-    parentId,
+    content: input.content,
+    channelId: input.channelId,
+    parentId: input.parentId,
+    quotedPostId: input.quotedPostId,
+  })
+}
+
+export async function fetchProfile(agentId: string, viewerAgentId?: string): Promise<SwarmFeedProfile> {
+  const params = new URLSearchParams()
+  if (viewerAgentId) params.set('viewerAgentId', viewerAgentId)
+  const query = params.toString()
+  return api<SwarmFeedProfile>('GET', `/swarmfeed/profiles/${encodeURIComponent(agentId)}${query ? `?${query}` : ''}`)
+}
+
+export async function fetchProfilePosts(agentId: string): Promise<SwarmFeedPost[]> {
+  const result = await api<SwarmFeedFeedResponse>('GET', `/swarmfeed/profiles/${encodeURIComponent(agentId)}/posts?limit=20&filter=posts`)
+  return result.posts
+}
+
+export async function fetchPostThread(postId: string): Promise<{ post: SwarmFeedPost; replies: SwarmFeedPost[] }> {
+  const [post, replies] = await Promise.all([
+    api<SwarmFeedPost>('GET', `/swarmfeed/posts/${encodeURIComponent(postId)}`),
+    api<SwarmFeedFeedResponse>('GET', `/swarmfeed/posts/${encodeURIComponent(postId)}/replies?limit=30`),
+  ])
+  return { post, replies: replies.posts }
+}
+
+export async function runSwarmFeedAction(input: {
+  action: 'like' | 'unlike' | 'repost' | 'unrepost' | 'bookmark' | 'unbookmark' | 'follow' | 'unfollow' | 'quote_repost'
+  agentId: string
+  postId?: string
+  targetAgentId?: string
+  content?: string
+  channelId?: string
+}): Promise<unknown> {
+  return api('POST', '/swarmfeed/actions', input)
+}
+
+export function useSwarmFeedFeedQuery(params: { type: FeedType; agentId?: string; channelId?: string; enabled?: boolean }) {
+  return useQuery<SwarmFeedFeedResponse>({
+    queryKey: swarmFeedQueryKeys.feed({ type: params.type, agentId: params.agentId, channelId: params.channelId }),
+    queryFn: () => fetchFeed(params.type, { agentId: params.agentId, channelId: params.channelId, limit: 50 }),
+    enabled: params.enabled,
+    staleTime: 15_000,
+  })
+}
+
+export function useSwarmFeedChannelsQuery() {
+  return useQuery<SwarmFeedChannel[]>({
+    queryKey: swarmFeedQueryKeys.channels(),
+    queryFn: fetchChannels,
+    staleTime: 60_000,
+  })
+}
+
+export function useSwarmFeedBookmarksQuery(agentId: string, enabled = true) {
+  return useQuery<SwarmFeedPost[]>({
+    queryKey: swarmFeedQueryKeys.bookmarks(agentId),
+    queryFn: () => fetchBookmarks(agentId),
+    enabled: enabled && !!agentId,
+    staleTime: 15_000,
+  })
+}
+
+export function useSwarmFeedNotificationsQuery(agentId: string, enabled = true) {
+  return useQuery<SwarmFeedNotification[]>({
+    queryKey: swarmFeedQueryKeys.notifications(agentId),
+    queryFn: () => fetchNotifications(agentId),
+    enabled: enabled && !!agentId,
+    staleTime: 15_000,
+  })
+}
+
+export function useSwarmFeedSuggestedQuery(agentId?: string, enabled = true) {
+  return useQuery<SwarmFeedSuggestedResponse>({
+    queryKey: swarmFeedQueryKeys.suggested(agentId),
+    queryFn: () => fetchSuggestedFollows(agentId),
+    enabled,
+    staleTime: 30_000,
+  })
+}
+
+export function useSwarmFeedSearchQuery(params: { query: string; type?: SwarmFeedSearchType; enabled?: boolean }) {
+  return useQuery<SwarmFeedSearchResponse>({
+    queryKey: swarmFeedQueryKeys.search({ query: params.query, type: params.type }),
+    queryFn: () => searchFeed(params.query, params.type),
+    enabled: params.enabled && params.query.trim().length > 0,
+    staleTime: 15_000,
+  })
+}
+
+export function useSwarmFeedProfileQuery(agentId: string, viewerAgentId?: string, enabled = true) {
+  return useQuery<SwarmFeedProfile>({
+    queryKey: swarmFeedQueryKeys.profile(agentId, viewerAgentId),
+    queryFn: () => fetchProfile(agentId, viewerAgentId),
+    enabled: enabled && !!agentId,
+    staleTime: 20_000,
+  })
+}
+
+export function useSwarmFeedProfilePostsQuery(agentId: string, enabled = true) {
+  return useQuery<SwarmFeedPost[]>({
+    queryKey: swarmFeedQueryKeys.profilePosts(agentId),
+    queryFn: () => fetchProfilePosts(agentId),
+    enabled: enabled && !!agentId,
+    staleTime: 20_000,
+  })
+}
+
+export function useSwarmFeedThreadQuery(postId: string, enabled = true) {
+  return useQuery<{ post: SwarmFeedPost; replies: SwarmFeedPost[] }>({
+    queryKey: swarmFeedQueryKeys.thread(postId),
+    queryFn: () => fetchPostThread(postId),
+    enabled: enabled && !!postId,
+    staleTime: 10_000,
+  })
+}
+
+export function useSwarmFeedPostMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ agentId, input }: { agentId: string; input: CreatePostInput }) => submitPost(agentId, input),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: swarmFeedQueryKeys.all })
+    },
+  })
+}
+
+export function useSwarmFeedActionMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: runSwarmFeedAction,
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: swarmFeedQueryKeys.all })
+    },
   })
 }

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/agents/agent-swarm-registration.ts

@@ -1,14 +1,22 @@
 import { registerAgent } from '@/lib/swarmfeed-client'
-import { patchAgent } from '@/lib/server/agents/agent-repository'
+import { getAgent, patchAgent } from '@/lib/server/agents/agent-repository'
 import { log } from '@/lib/server/logger'
 import type { Agent } from '@/types'
 
-/**
- * Auto-register an agent on SwarmFeed when enabled but missing API key.
- * Fire-and-forget — called after agent save, patches agent with the returned credentials.
- */
-export async function tryAutoRegisterSwarmFeed(agent: Agent): Promise<void> {
-  if (!agent.swarmfeedEnabled || agent.swarmfeedApiKey) return
+type EnsureSwarmFeedAgentOptions = {
+  requireEnabled?: boolean
+}
+
+export async function ensureSwarmFeedAgent(
+  agentId: string,
+  options: EnsureSwarmFeedAgentOptions = {},
+): Promise<Agent> {
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent) throw new Error('Agent not found')
+  if (options.requireEnabled !== false && !agent.swarmfeedEnabled) {
+    throw new Error('SwarmFeed is not enabled for this agent')
+  }
+  if (agent.swarmfeedApiKey && agent.swarmfeedAgentId) return agent
 
   log.info('swarm-registration', `Auto-registering agent "${agent.name}" on SwarmFeed`)
   const reg = await registerAgent({
@@ -31,5 +39,20 @@ export async function tryAutoRegisterSwarmFeed(agent: Agent): Promise<void> {
     }
   })
 
-  log.info('swarm-registration', `Agent "${agent.name}" registered on SwarmFeed as ${reg.agentId}`)
+  const updated = getAgent(agentId) as Agent | undefined
+  if (!updated?.swarmfeedApiKey || !updated.swarmfeedAgentId) {
+    throw new Error('Registration succeeded but credentials were not saved')
+  }
+
+  log.info('swarm-registration', `Agent "${updated.name}" registered on SwarmFeed as ${updated.swarmfeedAgentId}`)
+  return updated
+}
+
+/**
+ * Auto-register an agent on SwarmFeed when enabled but missing API key.
+ * Fire-and-forget — called after agent save, patches agent with the returned credentials.
+ */
+export async function tryAutoRegisterSwarmFeed(agent: Agent): Promise<void> {
+  if (!agent.swarmfeedEnabled || (agent.swarmfeedApiKey && agent.swarmfeedAgentId)) return
+  await ensureSwarmFeedAgent(agent.id)
 }

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/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/runtime/heartbeat-service.ts

@@ -30,6 +30,7 @@ import { errorMessage, hmrSingleton, jitteredBackoff } from '@/lib/shared-utils'
 import { logExecution } from '@/lib/server/execution-log'
 import { createNotification } from '@/lib/server/create-notification'
 import { WORKER_ONLY_PROVIDER_IDS } from '@/lib/provider-sets'
+import { buildSwarmFeedHeartbeatGuidance } from '@/lib/server/swarmfeed-runtime'
 
 const HEARTBEAT_TICK_MS = 60_000
 const MAX_CONCURRENT_HEARTBEATS = 1
@@ -378,7 +379,11 @@ export function buildAgentHeartbeatPrompt(
   const effectiveFileContent = isHeartbeatContentEffectivelyEmpty(strippedContent) ? '' : strippedContent
   if (effectiveFileContent) sections.push(`\nHEARTBEAT.md contents:\n${effectiveFileContent.slice(0, 2000)}`)
 
-  const recentMessages = (session.id ? getRecentMessages(session.id, 5) : []) as HeartbeatPromptMessage[]
+  const recentMessages = (
+    Array.isArray(session.messages)
+      ? session.messages.slice(-5)
+      : (session.id ? getRecentMessages(session.id, 5) : [])
+  ) as HeartbeatPromptMessage[]
   const recentContext = recentMessages
     .map((m) => {
       const text = (m.text || '').slice(0, 200)
@@ -416,6 +421,8 @@ export function buildAgentHeartbeatPrompt(
 
   // ── Phase 5: Execution instructions ──
   if (fallbackPrompt !== DEFAULT_HEARTBEAT_PROMPT) sections.push(`\nAgent instructions:\n${fallbackPrompt}`)
+  const swarmFeedGuidance = buildSwarmFeedHeartbeatGuidance(agent as Agent)
+  if (swarmFeedGuidance) sections.push(`\n${swarmFeedGuidance}`)
 
   sections.push('')
   sections.push('You are running an autonomous heartbeat tick. Review your goal and recent context.')

package/src/lib/server/runtime/queue/core.ts

@@ -24,6 +24,7 @@ import { checkAgentBudgetLimits } from '@/lib/server/cost'
 import { enqueueExecution } from '@/lib/server/execution-engine'
 import { extractTaskResult, formatResultBody } from '@/lib/server/tasks/task-result'
 import { checkoutTask } from '@/lib/server/tasks/task-checkout'
+import { queueSwarmFeedTaskCompletionWake } from '@/lib/server/swarmfeed-runtime'
 import {
   classifyRuntimeFailure,
   observeAutonomyRunOutcome,
@@ -1496,6 +1497,7 @@ export async function processNext() {
             text: `Task completed: "${task.title}" (${taskId})`,
           })
           notifyOrchestrators(`Task completed: "${task.title}"`, `task-complete:${taskId}`)
+          queueSwarmFeedTaskCompletionWake(doneTask)
           handleTerminalTaskResultDeliveries(doneTask)
           cleanupTerminalOneOffSchedule(doneTask)
           // Clean up LangGraph checkpoints for completed tasks