@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/chatroom-health.test.ts

@@ -0,0 +1,26 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { Agent } from '@/types'
+import { filterHealthyChatroomAgents } from './chatroom-health'
+
+describe('filterHealthyChatroomAgents', () => {
+  it('treats providers with default endpoints as healthy without explicit agent endpoints', () => {
+    const now = Date.now()
+    const agents: Record<string, Agent> = {
+      agent_writer: {
+        id: 'agent_writer',
+        name: 'Writer',
+        description: '',
+        systemPrompt: '',
+        provider: 'ollama',
+        model: 'glm-5:cloud',
+        createdAt: now,
+        updatedAt: now,
+      },
+    }
+
+    const result = filterHealthyChatroomAgents(['agent_writer'], agents)
+    assert.deepEqual(result.healthyAgentIds, ['agent_writer'])
+    assert.deepEqual(result.skipped, [])
+  })
+})

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

@@ -1,6 +1,6 @@
 import { getProvider } from '@/lib/providers'
 import type { Agent } from '@/types'
-import { resolveApiKey } from './chatroom-helpers'
+import { resolveAgentApiEndpoint, resolveApiKey } from './chatroom-helpers'
 import { isProviderCoolingDown } from './provider-health'
 
 export interface ChatroomAgentHealthSkip {
@@ -47,7 +47,7 @@ export function filterHealthyChatroomAgents(
       skipped.push({ agentId, reason: 'missing_api_credentials' })
       continue
     }
-    if (providerInfo.requiresEndpoint && !agent.apiEndpoint) {
+    if (providerInfo.requiresEndpoint && !resolveAgentApiEndpoint(agent)) {
       skipped.push({ agentId, reason: 'missing_api_endpoint' })
       continue
     }
@@ -57,4 +57,3 @@ export function filterHealthyChatroomAgents(
 
   return { healthyAgentIds, skipped }
 }
-

package/src/lib/server/chatroom-helpers.test.ts

@@ -1,7 +1,14 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import type { Agent, Chatroom } from '@/types'
-import { parseMentions, compactChatroomMessages, buildHistoryForAgent } from './chatroom-helpers'
+import {
+  parseMentions,
+  compactChatroomMessages,
+  buildHistoryForAgent,
+  buildSyntheticSession,
+  resolveAgentApiEndpoint,
+  resolveReplyTargetAgentId,
+} from './chatroom-helpers'
 
 function makeAgents(): Record<string, Agent> {
   const now = Date.now()
@@ -37,6 +44,48 @@ describe('chatroom-helpers', () => {
     assert.deepEqual(mentions, ['default', 'agent_analyst'])
   })
 
+  it('routes reply-only messages back to the replied-to agent', () => {
+    const agents = makeAgents()
+    const memberIds = ['default', 'agent_analyst']
+    const replyTargetAgentId = resolveReplyTargetAgentId('agent-msg', [
+      {
+        id: 'agent-msg',
+        senderId: 'default',
+        senderName: 'Assistant',
+        role: 'assistant',
+        text: 'Here is the previous answer.',
+        mentions: [],
+        reactions: [],
+        time: Date.now(),
+      },
+    ], memberIds)
+    const mentions = parseMentions('Can you expand on that?', agents, memberIds, { replyTargetAgentId })
+    assert.deepEqual(mentions, ['default'])
+  })
+
+  it('keeps explicit mentions ahead of reply-based implicit targeting', () => {
+    const agents = makeAgents()
+    const memberIds = ['default', 'agent_analyst']
+    const mentions = parseMentions('Actually @Analyst should take this one.', agents, memberIds, { replyTargetAgentId: 'default' })
+    assert.deepEqual(mentions, ['agent_analyst'])
+  })
+
+  it('ignores replies to non-agent messages', () => {
+    const replyTargetAgentId = resolveReplyTargetAgentId('user-msg', [
+      {
+        id: 'user-msg',
+        senderId: 'user',
+        senderName: 'You',
+        role: 'user',
+        text: 'Question',
+        mentions: [],
+        reactions: [],
+        time: Date.now(),
+      },
+    ], ['default', 'agent_analyst'])
+    assert.equal(replyTargetAgentId, null)
+  })
+
   it('compacts long chatrooms with a persisted summary message', () => {
     const now = Date.now()
     const chatroom: Chatroom = {
@@ -90,5 +139,21 @@ describe('chatroom-helpers', () => {
     const attachmentMarkers = history.filter((msg) => msg.text.includes('[Attached:')).length
     assert.ok(attachmentMarkers <= 6)
   })
-})
 
+  it('resolves default provider endpoints for chatroom sessions', () => {
+    const now = Date.now()
+    const agent: Agent = {
+      id: 'agent_writer',
+      name: 'Writer',
+      description: '',
+      systemPrompt: '',
+      provider: 'ollama',
+      model: 'glm-5:cloud',
+      createdAt: now,
+      updatedAt: now,
+    }
+
+    assert.equal(resolveAgentApiEndpoint(agent), 'http://localhost:11434')
+    assert.equal(buildSyntheticSession(agent, 'room-1').apiEndpoint, 'http://localhost:11434')
+  })
+})

package/src/lib/server/chatroom-helpers.ts

@@ -1,8 +1,11 @@
 import os from 'os'
 import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
+import { buildIdentityContinuityContext } from './identity-continuity'
 import { genId } from '@/lib/id'
-import type { Chatroom, ChatroomMember, Agent, Session, Message } from '@/types'
+import { getProvider } from '@/lib/providers'
+import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
+import type { Chatroom, ChatroomMember, Agent, Session, Message, ChatroomMessage } from '@/types'
 
 /** Resolve API key from an agent's credentialId */
 export function resolveApiKey(credentialId: string | null | undefined): string | null {
@@ -34,6 +37,14 @@ export function isMuted(chatroom: Chatroom, agentId: string): boolean {
   return new Date(member.mutedUntil).getTime() > Date.now()
 }
 
+export function resolveAgentApiEndpoint(agent: Agent): string | null {
+  const explicit = normalizeProviderEndpoint(agent.provider, agent.apiEndpoint ?? null)
+  if (explicit) return explicit
+  const provider = getProvider(agent.provider)
+  if (!provider?.defaultEndpoint) return null
+  return normalizeProviderEndpoint(agent.provider, provider.defaultEndpoint) || provider.defaultEndpoint.replace(/\/+$/, '')
+}
+
 const COMPACTION_PREFIX = '[Conversation summary]'
 
 function normalizeMentionToken(raw: string): string {
@@ -53,7 +64,12 @@ function truncateText(text: string, max: number): string {
 import { isImplicitlyMentioned } from './chatroom-orchestration'
 
 /** Parse @mentions from message text, returns matching agentIds */
-export function parseMentions(text: string, agents: Record<string, Agent>, memberIds: string[]): string[] {
+export function parseMentions(
+  text: string,
+  agents: Record<string, Agent>,
+  memberIds: string[],
+  opts?: { replyTargetAgentId?: string | null },
+): string[] {
   if (/@all\b/i.test(text)) return [...memberIds]
   const mentionPattern = /(?:^|[\s(])@([a-zA-Z0-9._-]+)/g
   const mentioned: string[] = []
@@ -73,8 +89,17 @@ export function parseMentions(text: string, agents: Record<string, Agent>, membe
     }
   }
 
-  // 2. Implicit mentions (OpenClaw Style - Reading the room)
-  // Only if no explicit mentions found yet
+  // 2. Reply-based implicit mention
+  // Only if no explicit mentions were found.
+  if (mentioned.length === 0) {
+    const replyTargetAgentId = opts?.replyTargetAgentId
+    if (replyTargetAgentId && memberIds.includes(replyTargetAgentId)) {
+      mentioned.push(replyTargetAgentId)
+    }
+  }
+
+  // 3. Implicit mentions (OpenClaw Style - Reading the room)
+  // Only if no explicit mentions were found.
   if (mentioned.length === 0) {
     for (const id of memberIds) {
       const agent = agents[id]
@@ -87,6 +112,19 @@ export function parseMentions(text: string, agents: Record<string, Agent>, membe
   return mentioned
 }
 
+export function resolveReplyTargetAgentId(
+  replyToId: string | undefined,
+  messages: ChatroomMessage[],
+  memberIds: string[],
+): string | null {
+  if (!replyToId) return null
+  const replyMsg = messages.find((m) => m.id === replyToId)
+  if (!replyMsg) return null
+  if (replyMsg.role !== 'assistant') return null
+  if (!memberIds.includes(replyMsg.senderId)) return null
+  return replyMsg.senderId
+}
+
 /**
  * Persisted chatroom compaction so long-lived rooms stay inside context budgets.
  * Returns true when the message list was compacted.
@@ -126,9 +164,9 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
     .map((id) => {
       const a = agents[id]
       if (!a) return null
-      const tools = a.tools?.length ? `Tools: ${a.tools.join(', ')}` : 'No specialized tools'
+      const plugins = (a.plugins || a.tools)?.length ? `Plugins: ${(a.plugins || a.tools)!.join(', ')}` : 'No specialized plugins'
       const desc = a.description || a.soul || 'No description'
-      return `- **${a.name}**: ${desc}\n  ${tools}`
+      return `- **${a.name}**: ${desc}\n  ${plugins}`
     })
     .filter(Boolean)
     .join('\n')
@@ -182,12 +220,12 @@ export function buildSyntheticSession(agent: Agent, chatroomId: string): Session
     model: agent.model,
     credentialId: agent.credentialId ?? null,
     fallbackCredentialIds: agent.fallbackCredentialIds,
-    apiEndpoint: agent.apiEndpoint ?? null,
+    apiEndpoint: resolveAgentApiEndpoint(agent),
     claudeSessionId: null,
     messages: [],
     createdAt: Date.now(),
     lastActiveAt: Date.now(),
-    tools: agent.tools || [],
+    plugins: agent.plugins || agent.tools || [],
     agentId: agent.id,
   }
 }
@@ -207,6 +245,8 @@ export function buildAgentSystemPromptForChatroom(agent: Agent): string {
   if (agent.description) identityLines.push(`Description: ${agent.description}`)
   identityLines.push('I should always embody this identity in the group chat. I am a persistent companion with my own soul and presence.')
   parts.push(identityLines.join('\n'))
+  const continuityBlock = buildIdentityContinuityContext(null, agent)
+  if (continuityBlock) parts.push(continuityBlock)
 
   // 2. Runtime & Capabilities (OpenClaw Style)
   const runtimeLines = [

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

@@ -2,9 +2,94 @@ import { Client, GatewayIntentBits, Events, Partials, AttachmentBuilder } from '
 import fs from 'fs'
 import path from 'path'
 import type { Connector } from '@/types'
-import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundThreadHistoryEntry } from './types'
 import { downloadInboundMediaToUpload, inferInboundMediaType } from './media'
-import { isNoMessage } from './manager'
+import { getConnectorReplySendOptions, isNoMessage, recordConnectorOutboundDelivery } from './manager'
+
+function buildDiscordThreadTitle(params: {
+  threadName?: string
+  channelName?: string
+  starterText?: string
+  fallbackId: string
+}): string {
+  const threadName = String(params.threadName || '').trim()
+  if (threadName) return threadName
+  const snippet = String(params.starterText || '').replace(/\s+/g, ' ').trim().slice(0, 56)
+  if (snippet) return `${params.channelName || 'Discord'} · ${snippet}`
+  return `${params.channelName || 'Discord'} thread ${params.fallbackId}`
+}
+
+function discordSenderName(message: any): string {
+  return message?.member?.displayName
+    || message?.author?.globalName
+    || message?.author?.displayName
+    || message?.author?.username
+    || 'Unknown'
+}
+
+async function hydrateDiscordThreadContext(message: any, inbound: InboundMessage): Promise<void> {
+  const channel = message.channel as any
+  const isThread = typeof channel?.isThread === 'function' && channel.isThread()
+
+  try {
+    if (isThread) {
+      const starter = typeof channel.fetchStarterMessage === 'function'
+        ? await channel.fetchStarterMessage().catch(() => null)
+        : null
+      const historyCollection = channel?.messages && typeof channel.messages.fetch === 'function'
+        ? await channel.messages.fetch({ limit: 8, before: message.id }).catch(() => null)
+        : null
+      const historyMessages = historyCollection
+        ? Array.from(historyCollection.values()).sort((a: any, b: any) => (a.createdTimestamp || 0) - (b.createdTimestamp || 0))
+        : []
+      const history: InboundThreadHistoryEntry[] = historyMessages
+        .filter((item: any) => item?.content?.trim())
+        .map((item: any) => ({
+          role: (item.author?.bot ? 'assistant' : 'user') as 'assistant' | 'user',
+          senderName: discordSenderName(item),
+          text: item.content,
+          messageId: item.id,
+        }))
+
+      inbound.threadParentChannelId = channel?.parentId || undefined
+      inbound.threadParentChannelName = channel?.parent?.name || undefined
+      inbound.threadStarterText = starter?.content?.trim() || undefined
+      inbound.threadStarterSenderName = starter ? discordSenderName(starter) : undefined
+      inbound.threadTitle = buildDiscordThreadTitle({
+        threadName: channel?.name,
+        channelName: inbound.threadParentChannelName || inbound.channelName,
+        starterText: inbound.threadStarterText,
+        fallbackId: inbound.threadId || inbound.channelId,
+      })
+      inbound.threadPersonaLabel = inbound.threadTitle
+      inbound.threadHistory = history.length ? history : undefined
+      return
+    }
+
+    if (message.reference?.messageId && typeof message.fetchReference === 'function') {
+      const starter = await message.fetchReference().catch(() => null)
+      if (!starter) return
+      inbound.threadStarterText = starter.content?.trim() || undefined
+      inbound.threadStarterSenderName = discordSenderName(starter)
+      inbound.threadParentChannelId = inbound.channelId
+      inbound.threadParentChannelName = inbound.channelName
+      inbound.threadTitle = buildDiscordThreadTitle({
+        channelName: inbound.channelName,
+        starterText: inbound.threadStarterText,
+        fallbackId: starter.id || inbound.replyToMessageId || inbound.channelId,
+      })
+      inbound.threadPersonaLabel = inbound.threadTitle
+      inbound.threadHistory = [{
+        role: (starter.author?.bot ? 'assistant' : 'user') as 'assistant' | 'user',
+        senderName: discordSenderName(starter),
+        text: starter.content || '',
+        messageId: starter.id,
+      }].filter((entry) => entry.text.trim().length > 0)
+    }
+  } catch (err: unknown) {
+    console.warn(`[discord] Thread context bootstrap failed: ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
 
 const discord: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
@@ -23,6 +108,23 @@ const discord: PlatformConnector = {
       ? connector.config.channelIds.split(',').map((s) => s.trim()).filter(Boolean)
       : null
 
+    async function resolveTextChannel(targetChannelId: string) {
+      const channel = await client.channels.fetch(targetChannelId)
+      if (!channel || !('send' in channel) || typeof (channel as any).send !== 'function') {
+        throw new Error(`Cannot send to channel ${targetChannelId}`)
+      }
+      return channel as any
+    }
+
+    async function resolveChannelMessage(targetChannelId: string, messageId: string) {
+      const channel = await resolveTextChannel(targetChannelId)
+      const messages = (channel as any).messages
+      if (!messages || typeof messages.fetch !== 'function') {
+        throw new Error(`Channel ${targetChannelId} does not support message actions`)
+      }
+      return await messages.fetch(messageId)
+    }
+
     client.on(Events.MessageCreate, async (message) => {
       console.log(`[discord] Message from ${message.author.username} in ${message.channel.type === 1 ? 'DM' : '#' + ('name' in message.channel ? (message.channel as any).name : message.channelId)}: ${message.content.slice(0, 80)}`)
       // Ignore bot messages
@@ -71,9 +173,17 @@ const discord: PlatformConnector = {
         senderId: message.author.id,
         senderName: message.author.displayName || message.author.username,
         text: message.content || (media.length > 0 ? '(media message)' : ''),
+        isGroup: message.channel.type !== 1,
+        messageId: message.id,
+        mentionsBot: client.user ? message.mentions.users.has(client.user.id) : false,
         imageUrl: firstImage?.url,
         media,
+        replyToMessageId: message.reference?.messageId || undefined,
+        threadId: typeof (message.channel as any).isThread === 'function' && (message.channel as any).isThread()
+          ? message.channelId
+          : undefined,
       }
+      await hydrateDiscordThreadContext(message, inbound)
 
       try {
         // Show typing indicator
@@ -82,16 +192,41 @@ const discord: PlatformConnector = {
 
         if (isNoMessage(response)) return
 
+        const replyOptions = getConnectorReplySendOptions({ connectorId: connector.id, inbound })
+        const targetChannelId = replyOptions.threadId || inbound.channelId
+        const sendChunk = async (chunk: string, isFirstChunk: boolean) => {
+          const channel = await resolveTextChannel(targetChannelId)
+          const payload: Record<string, unknown> = {
+            content: chunk,
+            allowedMentions: { repliedUser: false },
+          }
+          if (isFirstChunk && replyOptions.replyToMessageId) {
+            payload.reply = {
+              messageReference: replyOptions.replyToMessageId,
+              failIfNotExists: false,
+            }
+          }
+          const sent = await channel.send(payload)
+          return String(sent.id || '')
+        }
+
+        let lastMessageId: string | undefined
         // Discord has a 2000 char limit per message
         if (response.length <= 2000) {
-          await message.channel.send(response)
+          lastMessageId = await sendChunk(response, true)
         } else {
           // Split into chunks
           const chunks = response.match(/[\s\S]{1,1990}/g) || [response]
-          for (const chunk of chunks) {
-            await message.channel.send(chunk)
+          for (let i = 0; i < chunks.length; i += 1) {
+            lastMessageId = await sendChunk(chunks[i], i === 0)
           }
         }
+        await recordConnectorOutboundDelivery({
+          connectorId: connector.id,
+          inbound,
+          messageId: lastMessageId,
+          state: 'sent',
+        })
       } catch (err: any) {
         console.error(`[discord] Error handling message:`, err.message)
         try {
@@ -109,10 +244,8 @@ const discord: PlatformConnector = {
         return client.isReady()
       },
       async sendMessage(channelId, text, options) {
-        const channel = await client.channels.fetch(channelId)
-        if (!channel || !('send' in channel) || typeof (channel as any).send !== 'function') {
-          throw new Error(`Cannot send to channel ${channelId}`)
-        }
+        const targetChannelId = options?.threadId?.trim() || channelId
+        const channel = await resolveTextChannel(targetChannelId)
 
         const files: AttachmentBuilder[] = []
         if (options?.mediaPath) {
@@ -125,12 +258,43 @@ const discord: PlatformConnector = {
         }
 
         const content = options?.caption || text || undefined
-        const msg = await (channel as any).send({
+        const payload: Record<string, unknown> = {
           content: content || (files.length ? undefined : '(empty)'),
           files: files.length ? files : undefined,
-        })
+        }
+        if (options?.replyToMessageId) {
+          payload.reply = {
+            messageReference: options.replyToMessageId,
+            failIfNotExists: false,
+          }
+        }
+
+        const msg = await channel.send(payload)
         return { messageId: msg.id }
       },
+      async sendReaction(channelId, messageId, emoji) {
+        const message = await resolveChannelMessage(channelId, messageId)
+        await message.react(emoji)
+      },
+      async editMessage(channelId, messageId, newText) {
+        const message = await resolveChannelMessage(channelId, messageId)
+        await message.edit(newText)
+      },
+      async deleteMessage(channelId, messageId) {
+        const message = await resolveChannelMessage(channelId, messageId)
+        await message.delete()
+      },
+      async pinMessage(channelId, messageId) {
+        const message = await resolveChannelMessage(channelId, messageId)
+        await message.pin()
+      },
+      async sendTyping(channelId, options) {
+        const targetChannelId = options?.threadId?.trim() || channelId
+        const channel = await resolveTextChannel(targetChannelId)
+        if (typeof channel.sendTyping === 'function') {
+          await channel.sendTyping()
+        }
+      },
       async stop() {
         client.destroy()
         console.log(`[discord] Bot disconnected`)

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

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import type { Connector } from '@/types'
+import { buildConnectorDoctorPreview, buildConnectorDoctorReport } from './doctor'
+
+test('buildConnectorDoctorPreview merges overrides onto an existing connector', () => {
+  const base: Connector = {
+    id: 'connector-1',
+    name: 'Existing Connector',
+    platform: 'slack',
+    agentId: 'agent-1',
+    chatroomId: null,
+    credentialId: 'cred-1',
+    config: { replyMode: 'first', threadBinding: 'prefer' },
+    isEnabled: true,
+    status: 'running',
+    createdAt: 1,
+    updatedAt: 1,
+  }
+
+  const preview = buildConnectorDoctorPreview({
+    baseConnector: base,
+    input: {
+      name: 'Preview Connector',
+      agentId: null,
+      chatroomId: 'chatroom-9',
+      config: { replyMode: 'off', sessionScope: 'main' },
+    },
+  })
+
+  assert.equal(preview.name, 'Preview Connector')
+  assert.equal(preview.agentId, null)
+  assert.equal(preview.chatroomId, 'chatroom-9')
+  assert.deepEqual(preview.config, { replyMode: 'off', sessionScope: 'main' })
+})
+
+test('buildConnectorDoctorReport returns effective warnings and policy for preview connectors', () => {
+  const connector = buildConnectorDoctorPreview({
+    input: {
+      platform: 'telegram',
+      config: {
+        sessionScope: 'main',
+        replyMode: 'off',
+        threadBinding: 'off',
+        idleTimeoutSec: '0',
+        maxAgeSec: '0',
+      },
+    },
+  })
+
+  const report = buildConnectorDoctorReport(connector)
+
+  assert.equal(report.policy.scope, 'main')
+  assert.equal(report.policy.replyMode, 'off')
+  assert.ok(report.warnings.some((item) => item.includes('blend unrelated connector conversations')))
+  assert.ok(report.warnings.some((item) => item.includes('freshness reset is disabled')))
+})
+
+test('buildConnectorDoctorReport includes runtime warning for stopped existing connectors', () => {
+  const connector = buildConnectorDoctorPreview({
+    baseConnector: {
+      id: 'connector-2',
+      name: 'Existing Connector',
+      platform: 'slack',
+      agentId: 'agent-1',
+      chatroomId: null,
+      credentialId: 'cred-1',
+      config: {},
+      isEnabled: true,
+      status: 'stopped',
+      createdAt: 1,
+      updatedAt: 1,
+    },
+    input: {},
+  })
+
+  const report = buildConnectorDoctorReport(connector, null, { baseConnector: connector })
+
+  assert.ok(report.warnings.some((item) => item.includes('not currently connected')))
+})