@swarmclawai/swarmclaw 0.7.2 → 0.7.4

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,15 @@
 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,
+  resolveChatroomWorkspaceDir,
+  resolveAgentApiEndpoint,
+  resolveReplyTargetAgentId,
+} from './chatroom-helpers'
 
 function makeAgents(): Record<string, Agent> {
   const now = Date.now()
@@ -37,6 +45,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 +140,27 @@ 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')
+  })
+
+  it('keeps chatroom execution inside the workspace instead of the repo root', () => {
+    const cwd = buildSyntheticSession(makeAgents().default, 'room-safe').cwd
+    assert.equal(cwd, resolveChatroomWorkspaceDir('room-safe'))
+    assert.match(cwd, /chatrooms[\/\\]room-safe$/)
+  })
+})

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

@@ -1,8 +1,15 @@
+import fs from 'fs'
 import os from 'os'
-import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
+import path from 'path'
+import { loadSettings, loadSkills, loadCredentials, decryptKey, loadSessions, saveSessions } 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 { WORKSPACE_DIR } from './data-dir'
+import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
+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 +41,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 +68,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 +93,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 +116,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.
@@ -172,24 +214,113 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
 }
 
 /** Build a synthetic session object for an agent in a chatroom */
-export function buildSyntheticSession(agent: Agent, chatroomId: string): Session {
+export function resolveChatroomWorkspaceDir(chatroomId: string): string {
+  return path.join(WORKSPACE_DIR, 'chatrooms', chatroomId)
+}
+
+export function resolveSyntheticSessionId(chatroomId: string, agentId: string): string {
+  return `chatroom-${chatroomId}-${agentId}`
+}
+
+function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
   return {
-    id: `chatroom-${chatroomId}-${agent.id}`,
+    claudeCode: null,
+    codex: null,
+    opencode: null,
+    gemini: null,
+  }
+}
+
+export function buildSyntheticSession(agent: Agent, chatroomId: string): Session {
+  const roomWorkspace = resolveChatroomWorkspaceDir(chatroomId)
+  fs.mkdirSync(roomWorkspace, { recursive: true })
+  const now = Date.now()
+  return applyResolvedRoute({
+    id: resolveSyntheticSessionId(chatroomId, agent.id),
     name: `Chatroom session for ${agent.name}`,
-    cwd: process.cwd(),
+    cwd: roomWorkspace,
     user: 'chatroom',
     provider: agent.provider,
     model: agent.model,
     credentialId: agent.credentialId ?? null,
     fallbackCredentialIds: agent.fallbackCredentialIds,
-    apiEndpoint: agent.apiEndpoint ?? null,
+    apiEndpoint: resolveAgentApiEndpoint(agent),
     claudeSessionId: null,
+    codexThreadId: null,
+    opencodeSessionId: null,
+    delegateResumeIds: buildEmptyDelegateResumeIds(),
     messages: [],
-    createdAt: Date.now(),
-    lastActiveAt: Date.now(),
+    createdAt: now,
+    lastActiveAt: now,
+    sessionType: 'human',
     plugins: agent.plugins || agent.tools || [],
     agentId: agent.id,
+  }, resolvePrimaryAgentRoute(agent))
+}
+
+export function ensureSyntheticSession(agent: Agent, chatroomId: string): Session {
+  const roomWorkspace = resolveChatroomWorkspaceDir(chatroomId)
+  fs.mkdirSync(roomWorkspace, { recursive: true })
+  const sessionId = resolveSyntheticSessionId(chatroomId, agent.id)
+  const sessions = loadSessions()
+  const now = Date.now()
+  const existing = sessions[sessionId]
+  const session: Session = existing
+    ? applyResolvedRoute({
+        ...existing,
+        id: sessionId,
+        name: `Chatroom session for ${agent.name}`,
+        cwd: roomWorkspace,
+        user: 'chatroom',
+        provider: agent.provider,
+        model: agent.model,
+        credentialId: agent.credentialId ?? null,
+        fallbackCredentialIds: Array.isArray(agent.fallbackCredentialIds) ? [...agent.fallbackCredentialIds] : [],
+        apiEndpoint: resolveAgentApiEndpoint(agent),
+        sessionType: existing.sessionType || 'human',
+        agentId: agent.id,
+        plugins: agent.plugins || agent.tools || [],
+        tools: agent.plugins || agent.tools || [],
+        createdAt: existing.createdAt || now,
+        lastActiveAt: now,
+      }, resolvePrimaryAgentRoute(agent))
+    : applyResolvedRoute({
+        ...buildSyntheticSession(agent, chatroomId),
+        fallbackCredentialIds: Array.isArray(agent.fallbackCredentialIds) ? [...agent.fallbackCredentialIds] : [],
+        lastActiveAt: now,
+        tools: agent.plugins || agent.tools || [],
+      }, resolvePrimaryAgentRoute(agent))
+
+  if (!Array.isArray(session.messages)) session.messages = []
+  if (!session.delegateResumeIds || typeof session.delegateResumeIds !== 'object') {
+    session.delegateResumeIds = buildEmptyDelegateResumeIds()
   }
+  if (session.codexThreadId === undefined) session.codexThreadId = null
+  if (session.opencodeSessionId === undefined) session.opencodeSessionId = null
+  sessions[sessionId] = session
+  saveSessions(sessions)
+  return session
+}
+
+export function appendSyntheticSessionMessage(
+  sessionId: string,
+  role: 'user' | 'assistant',
+  text: string,
+): void {
+  const trimmed = String(text || '').trim()
+  if (!trimmed) return
+  const sessions = loadSessions()
+  const session = sessions[sessionId]
+  if (!session) return
+  if (!Array.isArray(session.messages)) session.messages = []
+  session.messages.push({
+    role,
+    text: trimmed,
+    time: Date.now(),
+  })
+  session.lastActiveAt = Date.now()
+  sessions[sessionId] = session
+  saveSessions(sessions)
 }
 
 /** Build agent's system prompt including skills and identity context */
@@ -207,6 +338,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/chatroom-session-persistence.test.ts

@@ -0,0 +1,87 @@
+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 { describe, it } 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-chatroom-session-'))
+  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 })
+  }
+}
+
+describe('chatroom synthetic session persistence', () => {
+  it('reuses stored synthetic sessions and preserves delegate resume state', () => {
+    const output = runWithTempDataDir(`
+      const helpersMod = await import('./src/lib/server/chatroom-helpers.ts')
+      const helpers = helpersMod.default || helpersMod
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const storage = storageMod.default || storageMod
+      const now = Date.now()
+      const agent = {
+        id: 'default',
+        name: 'Molly',
+        description: '',
+        systemPrompt: '',
+        provider: 'openai',
+        model: 'gpt-4o',
+        createdAt: now,
+        updatedAt: now,
+        plugins: ['delegate'],
+      }
+
+      const first = helpers.ensureSyntheticSession(agent, 'room-1')
+      helpers.appendSyntheticSessionMessage(first.id, 'user', 'first prompt')
+
+      const sessions = storage.loadSessions()
+      sessions[first.id].delegateResumeIds = {
+        claudeCode: null,
+        codex: 'resume-123',
+        opencode: null,
+        gemini: null,
+      }
+      storage.saveSessions(sessions)
+
+      const second = helpers.ensureSyntheticSession({ ...agent, model: 'gpt-4.1' }, 'room-1')
+      console.log(JSON.stringify({
+        sessionId: second.id,
+        cwd: second.cwd,
+        model: second.model,
+        messageCount: second.messages.length,
+        firstMessage: second.messages[0]?.text || '',
+        delegateResumeIds: second.delegateResumeIds,
+        plugins: second.plugins || [],
+      }))
+    `)
+
+    assert.equal(output.sessionId, 'chatroom-room-1-default')
+    assert.match(String(output.cwd), /chatrooms[\/\\]room-1$/)
+    assert.equal(output.model, 'gpt-4.1')
+    assert.equal(output.messageCount, 1)
+    assert.equal(output.firstMessage, 'first prompt')
+    assert.equal(output.delegateResumeIds?.codex, 'resume-123')
+    assert.deepEqual(output.plugins, ['delegate'])
+  })
+})

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`)