@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -0,0 +1,422 @@
+import { genId } from '@/lib/id'
+import { getProvider } from '@/lib/providers'
+import type { Agent, Connector, MessageSource, Session } from '@/types'
+import { WORKSPACE_DIR } from '../data-dir'
+import { ensureAgentThreadSession } from '../agent-thread-session'
+import { syncSessionArchiveMemory } from '../session-archive-memory'
+import { loadAgents, loadSessions, loadStoredItem, upsertStoredItem } from '../storage'
+import { notify } from '../ws-hub'
+import {
+  buildConnectorConversationKey,
+  getConnectorSessionStaleness,
+  resetConnectorSessionRuntime,
+  resolveConnectorSessionPolicy,
+} from './policy'
+import { resolveThreadPersonaLabel } from './thread-context'
+import type { InboundMessage } from './types'
+
+export type ConnectorSession = Session
+export type ConnectorAgent = Agent
+
+export interface ConnectorRuntimeDefaults {
+  provider: Session['provider']
+  model: string
+  apiEndpoint: string | null
+  thinkingLevel: Session['connectorThinkLevel']
+}
+
+export interface ResolvedDirectSession {
+  session: ConnectorSession
+  sessionKey: string
+  wasCreated: boolean
+  staleReason?: string | null
+  clearedMessages?: number
+}
+
+export function findDirectSessionForInbound(connector: Connector, msg: InboundMessage): ConnectorSession | null {
+  if (connector.chatroomId) return null
+  const effectiveAgentId = msg.agentIdOverride || connector.agentId
+  const channelIds = new Set([msg.channelId, msg.channelIdAlt].filter(Boolean))
+  const senderIds = new Set([msg.senderId, msg.senderIdAlt].filter(Boolean))
+  const sessions = Object.values(loadSessions() as Record<string, ConnectorSession>)
+  const candidates = sessions.filter((session) =>
+    session?.agentId === effectiveAgentId
+      && session?.connectorContext?.connectorId === connector.id
+      && (
+        channelIds.has(session?.connectorContext?.channelId || '')
+        || channelIds.has(session?.connectorContext?.channelIdAlt || '')
+      ),
+  )
+  if (msg.threadId) {
+    const threadExact = candidates.find((session) => session?.connectorContext?.threadId === msg.threadId)
+    if (threadExact) return threadExact
+  }
+  const senderExact = candidates.find((session) =>
+    senderIds.has(session?.connectorContext?.senderId || '')
+    || senderIds.has(session?.connectorContext?.senderIdAlt || ''),
+  )
+  if (senderExact) return senderExact
+  return candidates[0] || null
+}
+
+export function persistSessionRecord(session: ConnectorSession): void {
+  session.updatedAt = Date.now()
+  upsertStoredItem('sessions', session.id, session)
+  notify('sessions')
+}
+
+export function updateSessionConnectorContext(
+  session: ConnectorSession,
+  connector: Connector,
+  msg: InboundMessage,
+  sessionKey: string,
+): void {
+  const policy = resolveConnectorSessionPolicy(connector, msg, session)
+  session.connectorContext = {
+    ...(session.connectorContext || {}),
+    connectorId: connector.id,
+    platform: connector.platform,
+    channelId: msg.channelId,
+    channelIdAlt: msg.channelIdAlt || session.connectorContext?.channelIdAlt || null,
+    senderId: msg.senderId,
+    senderIdAlt: msg.senderIdAlt || session.connectorContext?.senderIdAlt || null,
+    senderName: msg.senderName,
+    sessionKey,
+    peerKey: msg.senderIdAlt || msg.senderId,
+    scope: policy.scope,
+    replyMode: policy.replyMode,
+    threadBinding: policy.threadBinding,
+    groupPolicy: policy.groupPolicy,
+    threadId: msg.threadId || session.connectorContext?.threadId || null,
+    threadTitle: msg.threadTitle || session.connectorContext?.threadTitle || null,
+    threadPersonaLabel: resolveThreadPersonaLabel(msg) || session.connectorContext?.threadPersonaLabel || null,
+    threadParentChannelId: msg.threadParentChannelId || session.connectorContext?.threadParentChannelId || null,
+    threadParentChannelName: msg.threadParentChannelName || session.connectorContext?.threadParentChannelName || null,
+    isGroup: !!msg.isGroup,
+    lastInboundAt: Date.now(),
+    lastInboundMessageId: msg.messageId || null,
+    lastInboundReplyToMessageId: msg.replyToMessageId || null,
+    lastInboundThreadId: msg.threadId || null,
+    lastOutboundAt: session.connectorContext?.lastOutboundAt ?? null,
+    lastOutboundMessageId: session.connectorContext?.lastOutboundMessageId ?? null,
+    lastResetAt: session.connectorContext?.lastResetAt ?? null,
+    lastResetReason: session.connectorContext?.lastResetReason ?? null,
+  }
+}
+
+export function describeSessionControls(
+  session: ConnectorSession,
+  connector: Connector,
+  msg: InboundMessage,
+): string {
+  const policy = resolveConnectorSessionPolicy(connector, msg, session)
+  const context = session.connectorContext || {}
+  const sessionAgeSec = Math.max(0, Math.round((Date.now() - (session.createdAt || Date.now())) / 1000))
+  const idleSec = Math.max(0, Math.round((Date.now() - (session.lastActiveAt || Date.now())) / 1000))
+  return [
+    `Session controls for ${connector.platform}/${connector.name}:`,
+    `- Session: ${session.id}`,
+    `- Scope: ${policy.scope}`,
+    `- Reply mode: ${policy.replyMode}`,
+    `- Thread binding: ${policy.threadBinding}`,
+    `- Group policy: ${policy.groupPolicy}`,
+    `- Reset mode: ${policy.resetMode}`,
+    `- Idle timeout: ${policy.idleTimeoutSec ?? 0}s`,
+    `- Max age: ${policy.maxAgeSec ?? 0}s`,
+    `- Daily reset: ${policy.dailyResetAt || 'off'}`,
+    `- Reset timezone: ${policy.resetTimezone || 'local'}`,
+    `- Debounce: ${policy.inboundDebounceMs}ms`,
+    `- Typing indicators: ${policy.typingIndicators ? 'on' : 'off'}`,
+    `- Thinking: ${policy.thinkingLevel || session.thinkingLevel || 'inherit'}`,
+    `- Model: ${session.provider}/${session.model}`,
+    `- Last outbound message: ${context.lastOutboundMessageId || 'none'}`,
+    `- Thread: ${context.threadId || 'none'}`,
+    `- Thread title: ${context.threadTitle || 'none'}`,
+    `- Thread persona: ${context.threadPersonaLabel || 'none'}`,
+    `- Session age: ${sessionAgeSec}s`,
+    `- Idle for: ${idleSec}s`,
+  ].join('\n')
+}
+
+function normalizeSessionSettingKey(raw: string): string {
+  return raw.trim().toLowerCase().replace(/[_-]+/g, '')
+}
+
+export function applySessionSetting(
+  session: ConnectorSession,
+  keyRaw: string,
+  valueRaw: string,
+  msg: InboundMessage,
+): string {
+  const key = normalizeSessionSettingKey(keyRaw)
+  const value = valueRaw.trim()
+  const asInt = () => {
+    const parsed = Number.parseInt(value, 10)
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new Error(`Invalid numeric value for ${keyRaw}: ${valueRaw}`)
+    }
+    return parsed
+  }
+  const asEnum = <T extends string>(allowed: readonly T[], label: string): T | null => {
+    if (!value) return null
+    const normalized = value.toLowerCase()
+    if ((allowed as readonly string[]).includes(normalized)) return normalized as T
+    throw new Error(`Invalid ${label}. Use one of: ${allowed.join(', ')}.`)
+  }
+
+  switch (key) {
+    case 'think':
+    case 'thinkinglevel':
+      session.connectorThinkLevel = asEnum(['minimal', 'low', 'medium', 'high'] as const, '/think level')
+      return `Connector thinking level set to ${session.connectorThinkLevel || 'inherit'}.`
+    case 'reply':
+    case 'replymode':
+      session.connectorReplyMode = asEnum(['off', 'first', 'all'] as const, 'reply mode')
+      return `Reply mode set to ${session.connectorReplyMode || 'inherit'}.`
+    case 'scope':
+    case 'sessionscope':
+      session.connectorSessionScope = asEnum(['main', 'channel', 'peer', 'channel-peer', 'thread'] as const, 'session scope')
+      return `Session scope set to ${session.connectorSessionScope || 'inherit'}.`
+    case 'thread':
+    case 'threadbinding':
+      session.connectorThreadBinding = asEnum(['off', 'prefer', 'strict'] as const, 'thread binding')
+      if (!value) {
+        session.connectorContext = { ...(session.connectorContext || {}), threadId: null }
+      } else if (session.connectorThreadBinding === 'strict' && msg.threadId) {
+        session.connectorContext = { ...(session.connectorContext || {}), threadId: msg.threadId }
+      }
+      return `Thread binding set to ${session.connectorThreadBinding || 'inherit'}.`
+    case 'group':
+    case 'grouppolicy':
+      session.connectorGroupPolicy = asEnum(['open', 'mention', 'reply-or-mention', 'disabled'] as const, 'group policy')
+      return `Group policy set to ${session.connectorGroupPolicy || 'inherit'}.`
+    case 'idle':
+    case 'idletimeout':
+      session.connectorIdleTimeoutSec = asInt()
+      return `Idle timeout set to ${session.connectorIdleTimeoutSec}s.`
+    case 'maxage':
+      session.connectorMaxAgeSec = asInt()
+      return `Max age set to ${session.connectorMaxAgeSec}s.`
+    case 'reset':
+    case 'resetmode': {
+      const normalized = value.toLowerCase()
+      if (!value) {
+        session.sessionResetMode = null
+        return 'Reset mode set to inherit.'
+      }
+      if (normalized !== 'idle' && normalized !== 'daily') {
+        throw new Error('Reset mode must be "idle" or "daily".')
+      }
+      session.sessionResetMode = normalized
+      return `Reset mode set to ${session.sessionResetMode}.`
+    }
+    case 'daily':
+    case 'dailyreset':
+    case 'dailyresetat':
+      if (!value) {
+        session.sessionDailyResetAt = null
+        return 'Daily reset time cleared.'
+      }
+      if (!/^\d{1,2}:\d{2}$/.test(value)) {
+        throw new Error('Daily reset time must be in HH:MM format.')
+      }
+      session.sessionDailyResetAt = value
+      return `Daily reset time set to ${session.sessionDailyResetAt}.`
+    case 'timezone':
+    case 'resettimezone':
+      session.sessionResetTimezone = value || null
+      return `Reset timezone set to ${session.sessionResetTimezone || 'inherit/local'}.`
+    case 'model':
+      session.model = value
+      return `Model set to ${session.model}.`
+    case 'provider': {
+      const provider = getProvider(value)
+      if (!provider) {
+        throw new Error(`Unknown provider "${value}".`)
+      }
+      session.provider = provider.id as Session['provider']
+      session.apiEndpoint = provider.defaultEndpoint || session.apiEndpoint || null
+      return `Provider set to ${session.provider}.`
+    }
+    default:
+      throw new Error(`Unknown session setting "${keyRaw}".`)
+  }
+}
+
+export function applyConnectorRuntimeDefaults(
+  session: ConnectorSession,
+  defaults: ConnectorRuntimeDefaults,
+): void {
+  session.provider = defaults.provider
+  session.model = defaults.model
+  session.apiEndpoint = defaults.apiEndpoint
+  session.connectorThinkLevel = defaults.thinkingLevel
+}
+
+export function resolveDirectSession(params: {
+  connector: Connector
+  msg: InboundMessage
+  agent: ConnectorAgent
+}): ResolvedDirectSession {
+  const { connector, msg, agent } = params
+  const policySeed = resolveConnectorSessionPolicy(connector, msg)
+  const providerInfo = policySeed.providerOverride ? getProvider(policySeed.providerOverride) : null
+  const defaultProvider: Session['provider'] = providerInfo?.id || (agent.provider === 'claude-cli' ? 'anthropic' : agent.provider)
+  const defaultModel = policySeed.modelOverride || agent.model
+  const defaultApiEndpoint = agent.apiEndpoint || providerInfo?.defaultEndpoint || null
+  const runtimeDefaults: ConnectorRuntimeDefaults = {
+    provider: defaultProvider,
+    model: defaultModel,
+    apiEndpoint: defaultApiEndpoint,
+    thinkingLevel: policySeed.thinkingLevel || null,
+  }
+  const sessionKey = buildConnectorConversationKey({
+    connector,
+    msg,
+    agentId: agent.id,
+    policy: policySeed,
+  })
+  const sessions = loadSessions()
+  let session = Object.values(sessions as Record<string, ConnectorSession>).find((item) => item?.name === sessionKey)
+  if (!session) {
+    session = findDirectSessionForInbound(connector, msg) || undefined
+  }
+  let wasCreated = false
+  if (!session) {
+    const id = genId()
+    session = {
+      id,
+      name: sessionKey,
+      cwd: WORKSPACE_DIR,
+      user: 'connector',
+      provider: defaultProvider,
+      model: defaultModel,
+      credentialId: agent.credentialId || null,
+      fallbackCredentialIds: Array.isArray(agent.fallbackCredentialIds) ? [...agent.fallbackCredentialIds] : [],
+      apiEndpoint: defaultApiEndpoint,
+      claudeSessionId: null,
+      codexThreadId: null,
+      opencodeSessionId: null,
+      delegateResumeIds: {
+        claudeCode: null,
+        codex: null,
+        opencode: null,
+        gemini: null,
+      },
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      sessionType: 'human' as const,
+      agentId: agent.id,
+      plugins: agent.plugins || agent.tools || [],
+      thinkingLevel: agent.thinkingLevel || null,
+      connectorThinkLevel: policySeed.thinkingLevel || null,
+    }
+    wasCreated = true
+  }
+  session.name = sessionKey
+  session.agentId = agent.id
+  session.plugins = Array.isArray(session.plugins) ? session.plugins : (agent.plugins || agent.tools || [])
+  session.provider = defaultProvider
+  session.model = defaultModel
+  if (session.credentialId === undefined) session.credentialId = agent.credentialId || null
+  if (!Array.isArray(session.fallbackCredentialIds) && Array.isArray(agent.fallbackCredentialIds)) {
+    session.fallbackCredentialIds = [...agent.fallbackCredentialIds]
+  }
+  if (session.apiEndpoint === undefined || session.apiEndpoint === null) session.apiEndpoint = defaultApiEndpoint
+  if ((session.connectorThinkLevel === undefined || session.connectorThinkLevel === null) && policySeed.thinkingLevel) {
+    session.connectorThinkLevel = policySeed.thinkingLevel
+  }
+
+  const policy = resolveConnectorSessionPolicy(connector, msg, session)
+  const staleness = getConnectorSessionStaleness(session, policy)
+  let clearedMessages = 0
+  if (staleness.stale) {
+    try { syncSessionArchiveMemory(session, { agent }) } catch { /* archive sync is best-effort */ }
+    clearedMessages = resetConnectorSessionRuntime(session, staleness.reason || 'session_refresh')
+    applyConnectorRuntimeDefaults(session, {
+      ...runtimeDefaults,
+      thinkingLevel: policySeed.thinkingLevel || session.connectorThinkLevel || null,
+    })
+  }
+  updateSessionConnectorContext(session, connector, msg, sessionKey)
+  upsertStoredItem('sessions', session.id, session)
+  return {
+    session,
+    sessionKey,
+    wasCreated,
+    staleReason: staleness.reason || null,
+    clearedMessages,
+  }
+}
+
+function mirrorConnectorMessageToAgentThread(
+  session: ConnectorSession,
+  message: Record<string, unknown>,
+): void {
+  if (!session.agentId) return
+  if (typeof session.name !== 'string' || !session.name.startsWith('connector:')) return
+
+  const agents = loadAgents()
+  const agent = agents[session.agentId]
+  const threadSession = agent?.threadSessionId
+    ? loadStoredItem('sessions', agent.threadSessionId) as ConnectorSession | null
+    : ensureAgentThreadSession(session.agentId)
+  if (!threadSession || threadSession.id === session.id) return
+
+  const last = Array.isArray(threadSession.messages) ? threadSession.messages[threadSession.messages.length - 1] : null
+  const source = message.source as MessageSource | undefined
+  const lastSource = (last?.source || null) as MessageSource | null
+  if (
+    last
+    && last.role === message.role
+    && last.text === message.text
+    && lastSource?.platform === source?.platform
+    && lastSource?.connectorId === source?.connectorId
+    && lastSource?.channelId === source?.channelId
+    && lastSource?.messageId === source?.messageId
+  ) {
+    return
+  }
+
+  if (!Array.isArray(threadSession.messages)) threadSession.messages = []
+  threadSession.messages.push({
+    ...message,
+    time: typeof message.time === 'number' ? message.time : Date.now(),
+    historyExcluded: true,
+  } as Session['messages'][number])
+  threadSession.lastActiveAt = Date.now()
+
+  upsertStoredItem('sessions', threadSession.id, threadSession)
+  notify('sessions')
+  notify(`messages:${threadSession.id}`)
+}
+
+export function pushSessionMessage(
+  session: ConnectorSession,
+  role: 'user' | 'assistant',
+  text: string,
+  extra: Record<string, unknown> = {},
+): void {
+  if (!text.trim()) return
+  if (!Array.isArray(session.messages)) session.messages = []
+  const message = { role, text: text.trim(), time: Date.now(), ...extra }
+  session.messages.push(message)
+  session.lastActiveAt = Date.now()
+  mirrorConnectorMessageToAgentThread(session, message)
+}
+
+export function modelHistoryTail(
+  messages: Session['messages'] | null | undefined,
+  limit = 20,
+): Session['messages'] {
+  const filtered = (Array.isArray(messages) ? messages : []).filter((message) => message?.historyExcluded !== true)
+  return filtered.slice(-limit)
+}
+
+export function persistSession(session: ConnectorSession): void {
+  session.updatedAt = Date.now()
+  upsertStoredItem('sessions', session.id, session)
+  notify('sessions')
+  notify(`messages:${session.id}`)
+}

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

@@ -1,8 +1,8 @@
 import { spawn, execSync } from 'child_process'
 import type { ChildProcess } from 'child_process'
 import type { Connector } from '@/types'
-import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
-import { isNoMessage } from './manager'
+import type { PlatformConnector, ConnectorInstance, InboundMessage, ConnectorIngressResult } from './types'
+import { resolveConnectorIngressReply } from './ingress-delivery'
 
 const signal: PlatformConnector = {
   async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
@@ -129,7 +129,7 @@ const signal: PlatformConnector = {
 export async function handleSignalEvent(
   event: any,
   connector: Connector,
-  onMessage: (msg: InboundMessage) => Promise<string>,
+  onMessage: (msg: InboundMessage) => Promise<ConnectorIngressResult>,
 ) {
   // signal-cli JSON output structure varies; handle the common envelope format
   const envelope = event.envelope || event
@@ -151,8 +151,8 @@ export async function handleSignalEvent(
   }
 
   try {
-    const response = await onMessage(inbound)
-    if (isNoMessage(response)) return
+    const reply = await resolveConnectorIngressReply(onMessage, inbound)
+    if (!reply) return
 
     // Send reply back
     const cliPath = connector.config.signalCliPath || 'signal-cli'
@@ -165,14 +165,14 @@ export async function handleSignalEvent(
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          message: response,
+          message: reply.visibleText,
           number: phoneNumber,
           recipients: [inbound.channelId],
         }),
       })
     } else {
       execSync(
-        `${cliPath} -u ${phoneNumber} send -m ${JSON.stringify(response)} ${inbound.channelId}`,
+        `${cliPath} -u ${phoneNumber} send -m ${JSON.stringify(reply.visibleText)} ${inbound.channelId}`,
         { timeout: 15_000 },
       )
     }

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

@@ -3,8 +3,10 @@ import fs from 'fs'
 import path from 'path'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundThreadHistoryEntry } from './types'
+import { resolveConnectorIngressReply } from './ingress-delivery'
+import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime } from './media'
-import { getConnectorReplySendOptions, isNoMessage, recordConnectorOutboundDelivery } from './manager'
+import { dedup, errorMessage } from '@/lib/shared-utils'
 
 function normalizeSlackEmoji(input: string): string {
   const raw = input.trim().replace(/^:|:$/g, '')
@@ -54,7 +56,7 @@ async function hydrateSlackThreadContext(params: {
     const messages = Array.isArray((result as any)?.messages) ? (result as any).messages as any[] : []
     if (!messages.length) return
 
-    const userIds = [...new Set(messages.map((message) => typeof message?.user === 'string' ? message.user : '').filter(Boolean))]
+    const userIds = dedup(messages.map((message) => typeof message?.user === 'string' ? message.user : '').filter(Boolean))
     const nameMap = new Map<string, string>()
     await Promise.all(userIds.map(async (userId) => {
       const name = await resolveSlackUserDisplayName(params.client, userId)
@@ -97,7 +99,7 @@ async function hydrateSlackThreadContext(params: {
     params.inbound.threadPersonaLabel = params.inbound.threadTitle
     params.inbound.threadHistory = history.length ? history : undefined
   } catch (err: unknown) {
-    console.warn(`[slack] Thread context bootstrap failed: ${err instanceof Error ? err.message : String(err)}`)
+    console.warn(`[slack] Thread context bootstrap failed: ${errorMessage(err)}`)
   }
 }
 
@@ -242,38 +244,22 @@ const slack: PlatformConnector = {
       await hydrateSlackThreadContext({ client, inbound, currentTs: msg.ts || undefined, botUserId })
 
       try {
-        const response = await onMessage(inbound)
-
-        if (isNoMessage(response)) return
-
-        const replyOptions = getConnectorReplySendOptions({ connectorId: connector.id, inbound })
-        const threadTs = replyOptions.threadId || replyOptions.replyToMessageId
-        let lastMessageId: string | undefined
-
-        // Slack has a 4000 char limit for messages
-        if (response.length <= 4000) {
-          const sent = await client.chat.postMessage({
-            channel: channelId,
-            text: response,
-            thread_ts: threadTs,
-          })
-          lastMessageId = sent.ts || undefined
-        } else {
-          const chunks = response.match(/[\s\S]{1,3990}/g) || [response]
-          for (const chunk of chunks) {
+        const reply = await resolveConnectorIngressReply(onMessage, inbound)
+        if (!reply) return
+        await deliverChunkedConnectorText({
+          connectorId: connector.id,
+          inbound,
+          text: reply.visibleText,
+          maxSingleMessageLength: 4000,
+          chunkLength: 3990,
+          sendChunk: async (chunk, meta) => {
             const sent = await client.chat.postMessage({
               channel: channelId,
               text: chunk,
-              thread_ts: threadTs,
+              thread_ts: meta.threadId || meta.replyToMessageId,
             })
-            lastMessageId = sent.ts || undefined
-          }
-        }
-        await recordConnectorOutboundDelivery({
-          connectorId: connector.id,
-          inbound,
-          messageId: lastMessageId,
-          state: 'sent',
+            return sent.ts || undefined
+          },
         })
       } catch (err: any) {
         console.error(`[slack] Error handling message:`, err.message)
@@ -316,19 +302,22 @@ const slack: PlatformConnector = {
       })
 
       try {
-        const response = await onMessage(inbound)
-        if (isNoMessage(response)) return
-        const replyOptions = getConnectorReplySendOptions({ connectorId: connector.id, inbound })
-        const sent = await client.chat.postMessage({
-          channel: event.channel,
-          text: response,
-          thread_ts: replyOptions.threadId || replyOptions.replyToMessageId,
-        })
-        await recordConnectorOutboundDelivery({
+        const reply = await resolveConnectorIngressReply(onMessage, inbound)
+        if (!reply) return
+        await deliverChunkedConnectorText({
           connectorId: connector.id,
           inbound,
-          messageId: sent.ts || undefined,
-          state: 'sent',
+          text: reply.visibleText,
+          maxSingleMessageLength: 4000,
+          chunkLength: 3990,
+          sendChunk: async (chunk, meta) => {
+            const sent = await client.chat.postMessage({
+              channel: event.channel,
+              text: chunk,
+              thread_ts: meta.threadId || meta.replyToMessageId,
+            })
+            return sent.ts || undefined
+          },
         })
       } catch (err: any) {
         console.error(`[slack] Error handling mention:`, err.message)
@@ -340,7 +329,7 @@ const slack: PlatformConnector = {
 
     let appStopped = false
 
-    return {
+    const instance: ConnectorInstance = {
       connector,
       isAlive() {
         return !appStopped && !!app.client
@@ -437,6 +426,17 @@ const slack: PlatformConnector = {
         console.log(`[slack] Bot disconnected`)
       },
     }
+
+    // Bolt emits 'error' on unrecoverable failures (auth revoked, socket closed permanently)
+    app.error(async (error) => {
+      const errMsg = error.original?.message || error.message || String(error)
+      console.error(`[slack] App error:`, errMsg)
+      if (appStopped) return
+      appStopped = true
+      instance.onCrash?.(`Slack error: ${errMsg}`)
+    })
+
+    return instance
   },
 }
 

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

@@ -1,5 +1,5 @@
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
-import { isNoMessage } from './manager'
+import { resolveConnectorIngressReply } from './ingress-delivery'
 
 const teams: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
@@ -45,9 +45,9 @@ const teams: PlatformConnector = {
         }
 
         try {
-          const response = await onMessage(inbound)
-          if (isNoMessage(response)) return
-          await context.sendActivity(response)
+          const reply = await resolveConnectorIngressReply(onMessage, inbound)
+          if (!reply) return
+          await context.sendActivity(reply.visibleText)
         } catch (err: any) {
           console.error(`[teams] Error handling message:`, err.message)
           try {