@swarmclawai/swarmclaw 1.4.7 → 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/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/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