@swarmclawai/swarmclaw 0.6.4 → 0.6.7

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

@@ -3,7 +3,9 @@ import {
   loadConnectors, saveConnectors, loadSessions, saveSessions,
   loadAgents, loadCredentials, decryptKey, loadSettings, loadSkills,
   loadChatrooms, saveChatrooms,
+  upsertConnectorHealthEvent,
 } from '../storage'
+import type { ConnectorHealthEventType } from '@/types'
 import { WORKSPACE_DIR } from '../data-dir'
 import { UPLOAD_DIR } from '../storage'
 import fs from 'fs'
@@ -16,12 +18,17 @@ import { requestHeartbeatNow } from '../heartbeat-wake'
 import { buildCurrentDateTimePromptContext } from '../prompt-runtime-context'
 import {
   parseMentions,
+  compactChatroomMessages,
   buildChatroomSystemPrompt,
   buildSyntheticSession,
   buildAgentSystemPromptForChatroom,
   buildHistoryForAgent,
   resolveApiKey as resolveApiKeyHelper,
 } from '../chatroom-helpers'
+import { filterHealthyChatroomAgents } from '../chatroom-health'
+import { evaluateRoutingRules } from '../chatroom-routing'
+import { markProviderFailure, markProviderSuccess } from '../provider-health'
+import { getProvider } from '@/lib/providers'
 import type { Connector, MessageSource, Chatroom, ChatroomMessage } from '@/types'
 import type { ConnectorInstance, InboundMessage, InboundMedia } from './types'
 import {
@@ -35,6 +42,7 @@ import {
   parsePairingPolicy,
   type PairingPolicy,
 } from './pairing'
+import { enrichInboundMessageWithAudioTranscript } from './inbound-audio-transcription'
 
 function resolveUploadPathFromUrl(rawUrl: string): string | null {
   if (!rawUrl) return null
@@ -271,6 +279,35 @@ const followupKey = '__swarmclaw_connector_followups__' as const
 const scheduledFollowups: Map<string, ScheduledConnectorFollowup> =
   g[followupKey] ?? (g[followupKey] = new Map<string, ScheduledConnectorFollowup>())
 
+/** Reconnect state per connector — tracks backoff and retry attempts for crash recovery */
+export interface ConnectorReconnectState {
+  attempts: number
+  lastAttemptAt: number
+  nextRetryAt: number
+  backoffMs: number
+  error: string
+}
+
+const reconnectStateKey = '__swarmclaw_connector_reconnect_state__' as const
+const reconnectState: Map<string, ConnectorReconnectState> =
+  g[reconnectStateKey] ?? (g[reconnectStateKey] = new Map<string, ConnectorReconnectState>())
+
+const RECONNECT_INITIAL_BACKOFF_MS = 1_000
+const RECONNECT_MAX_BACKOFF_MS = 5 * 60 * 1_000
+const RECONNECT_MAX_ATTEMPTS = 10
+
+/** Record a health event for a connector (persisted to connector_health collection) */
+function recordHealthEvent(connectorId: string, event: ConnectorHealthEventType, message?: string): void {
+  const id = genId()
+  upsertConnectorHealthEvent(id, {
+    id,
+    connectorId,
+    event,
+    message: message || undefined,
+    timestamp: new Date().toISOString(),
+  })
+}
+
 type RouteMessageHandler = (connector: Connector, msg: InboundMessage) => Promise<string>
 const routeHandlerKey = '__swarmclaw_connector_route_handler__' as const
 const routeMessageHandlerRef: { current: RouteMessageHandler } =
@@ -309,6 +346,7 @@ export async function getPlatform(platform: string) {
     case 'teams':     return (await import('./teams')).default
     case 'googlechat': return (await import('./googlechat')).default
     case 'matrix':    return (await import('./matrix')).default
+    case 'email':     return (await import('./email')).default
     default: throw new Error(`Unknown platform: ${platform}`)
   }
 }
@@ -657,10 +695,27 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
   if (!chatroom) return '[Error] Chatroom not found.'
 
   const agents = loadAgents()
+  const preferredCredentialId = (() => {
+    if (connector.agentId && agents[connector.agentId]?.credentialId) {
+      return agents[connector.agentId].credentialId as string
+    }
+    for (const agentId of chatroom.agentIds) {
+      const credentialId = agents[agentId]?.credentialId
+      if (credentialId) return credentialId as string
+    }
+    return null
+  })()
+  msg = await enrichInboundMessageWithAudioTranscript({
+    msg,
+    preferredCredentialId,
+  })
+
   const source: MessageSource = {
     platform: connector.platform,
     connectorId: connector.id,
     connectorName: connector.name,
+    channelId: msg.channelId,
+    senderId: msg.senderId,
     senderName: msg.senderName,
   }
   const inboundText = formatInboundUserText(msg)
@@ -669,10 +724,17 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
 
   // Parse mentions from the message text
   let mentions = parseMentions(msg.text || '', agents, chatroom.agentIds)
-  // Auto-address: if enabled and no explicit mentions, address all agents
+  // Routing rules: if no explicit mentions, evaluate keyword/capability rules
+  if (mentions.length === 0 && chatroom.routingRules?.length) {
+    const agentList = chatroom.agentIds.map((id) => agents[id]).filter(Boolean)
+    mentions = evaluateRoutingRules(msg.text || '', chatroom.routingRules, agentList)
+  }
+  // Auto-address: if enabled and still no mentions, address all agents
   if (chatroom.autoAddress && mentions.length === 0) {
     mentions = [...chatroom.agentIds]
   }
+  const mentionHealth = filterHealthyChatroomAgents(mentions, agents)
+  mentions = mentionHealth.healthyAgentIds
 
   // Create and persist the user message in the chatroom
   const userMessage: ChatroomMessage = {
@@ -689,12 +751,23 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
     source,
   }
   chatroom.messages.push(userMessage)
+  compactChatroomMessages(chatroom)
   chatroom.updatedAt = Date.now()
   chatrooms[chatroomId] = chatroom
   saveChatrooms(chatrooms)
   notify('chatrooms')
   notify(`chatroom:${chatroomId}`)
 
+  if (mentions.length === 0) {
+    if (mentionHealth.skipped.length > 0) {
+      const skippedSummary = mentionHealth.skipped
+        .map((row) => `${agents[row.agentId]?.name || row.agentId}: ${row.reason}`)
+        .join(', ')
+      return `[Error] No healthy agents were available for this request. Skipped: ${skippedSummary}`
+    }
+    return '[Error] No agents were selected for this request.'
+  }
+
   // Process mentioned agents sequentially and collect responses
   const responses: string[] = []
   for (const agentId of mentions) {
@@ -704,6 +777,23 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
     const apiKey = resolveApiKeyHelper(agent.credentialId)
     const freshChatrooms = loadChatrooms()
     const freshChatroom = freshChatrooms[chatroomId] as Chatroom
+    if (compactChatroomMessages(freshChatroom)) {
+      freshChatrooms[chatroomId] = freshChatroom
+      saveChatrooms(freshChatrooms)
+      notify(`chatroom:${chatroomId}`)
+    }
+
+    const providerInfo = getProvider(agent.provider)
+    if (providerInfo?.requiresApiKey && !apiKey) {
+      markProviderFailure(agent.provider, 'missing_api_credentials')
+      responses.push(`[${agent.name}] [Error] Missing API credentials.`)
+      continue
+    }
+    if (providerInfo?.requiresEndpoint && !agent.apiEndpoint) {
+      markProviderFailure(agent.provider, 'missing_api_endpoint')
+      responses.push(`[${agent.name}] [Error] Missing endpoint configuration.`)
+      continue
+    }
 
     const syntheticSession = buildSyntheticSession(agent, chatroomId)
     const agentSystemPrompt = buildAgentSystemPromptForChatroom(agent)
@@ -730,6 +820,7 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
           platform: connector.platform,
           connectorId: connector.id,
           connectorName: connector.name,
+          channelId: msg.channelId,
         }
         const agentMessage: ChatroomMessage = {
           id: genId(),
@@ -737,7 +828,10 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
           senderName: agent.name,
           role: 'assistant',
           text: responseText,
-          mentions: parseMentions(responseText, agents, freshChatroom.agentIds),
+          mentions: filterHealthyChatroomAgents(
+            parseMentions(responseText, agents, freshChatroom.agentIds),
+            agents,
+          ).healthyAgentIds,
           reactions: [],
           time: Date.now(),
           source: agentSource,
@@ -750,10 +844,14 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
         saveChatrooms(latestChatrooms)
         notify(`chatroom:${chatroomId}`)
 
+        markProviderSuccess(agent.provider)
         responses.push(`[${agent.name}] ${responseText}`)
+      } else {
+        markProviderSuccess(agent.provider)
       }
     } catch (err: unknown) {
       const errMsg = err instanceof Error ? err.message : String(err)
+      markProviderFailure(agent.provider, errMsg)
       console.error(`[connector] Chatroom agent ${agent.name} error:`, errMsg)
     }
   }
@@ -798,6 +896,10 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   if (!effectiveAgentId) return '[Error] Connector has no agent configured.'
   const agent = agents[effectiveAgentId]
   if (!agent) return '[Error] Connector agent not found.'
+  msg = await enrichInboundMessageWithAudioTranscript({
+    msg,
+    preferredCredentialId: agent.credentialId || null,
+  })
 
   // Enqueue system event + heartbeat wake for the agent
   const preview = (msg.text || '').slice(0, 80)
@@ -931,9 +1033,14 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
     return commandResult
   }
 
-  // Build system prompt: [userPrompt] \n\n [soul] \n\n [systemPrompt]
+  // Build system prompt: [identity] \n\n [userPrompt] \n\n [soul] \n\n [systemPrompt]
   const settings = loadSettings()
   const promptParts: string[] = []
+  // Identity block — agent needs to know who it is
+  const identityLines = [`## My Identity`, `My name is ${agent.name}.`]
+  if (agent.description) identityLines.push(agent.description)
+  identityLines.push('I should always refer to myself by this name. I am not "Assistant" — I have my own name and identity.')
+  promptParts.push(identityLines.join(' '))
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
   promptParts.push(buildCurrentDateTimePromptContext())
   if (agent.soul) promptParts.push(agent.soul)
@@ -960,6 +1067,11 @@ Do not end every reply with a question.
 Only ask a question when a specific missing detail blocks progress.
 When a task is complete, state the result plainly and stop.
 
+## Async Update Routing
+When you start work that may finish later (task, schedule, delegated run), tell the user where updates will be sent.
+Default to this same ${msg.platform} chat unless the user requested another destination.
+If channel preference is ambiguous and there are multiple reasonable destinations, ask one short routing question.
+
 ## Knowing When Not to Reply
 Real conversations have natural pauses — not every message needs a response. Reply with exactly "NO_MESSAGE" (nothing else) to stay silent when replying would feel unnatural or forced.
 Stay silent for simple acknowledgments ("okay", "alright", "cool", "got it", "sounds good"), conversation closers ("thanks", "bye", "night", "ttyl"), reactions (emoji, "haha", "lol"), and forwarded content with no question attached.
@@ -987,6 +1099,8 @@ If media sending fails, report the exact error and retry with a corrected path/t
     platform: connector.platform,
     connectorId: connector.id,
     connectorName: connector.name,
+    channelId: msg.channelId,
+    senderId: msg.senderId,
     senderName: msg.senderName,
   }
   session.messages.push({
@@ -1002,6 +1116,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
   const s1 = loadSessions()
   s1[session.id] = session
   saveSessions(s1)
+  notify(`messages:${session.id}`)
 
   // Stream the response
   let fullText = ''
@@ -1109,6 +1224,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
     platform: connector.platform,
     connectorId: connector.id,
     connectorName: connector.name,
+    channelId: msg.channelId,
   }
   if (fullText.trim()) {
     session.messages.push({ role: 'assistant', text: fullText.trim(), time: Date.now(), source: assistantSource })
@@ -1235,7 +1351,7 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     botToken = connector.config.password
   }
 
-  if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal') {
+  if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal' && connector.platform !== 'email') {
     throw new Error('No bot token configured')
   }
 
@@ -1262,14 +1378,17 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     notify('connectors')
 
     console.log(`[connector] Started ${connector.platform} connector: ${connector.name}`)
+    recordHealthEvent(connectorId, 'started', `${connector.platform} connector "${connector.name}" started`)
   } catch (err: unknown) {
+    const errMsg = err instanceof Error ? err.message : String(err)
     connector.status = 'error'
     connector.isEnabled = false
-    connector.lastError = err instanceof Error ? err.message : String(err)
+    connector.lastError = errMsg
     connector.updatedAt = Date.now()
     connectors[connectorId] = connector
     saveConnectors(connectors)
     notify('connectors')
+    recordHealthEvent(connectorId, 'error', errMsg)
     throw err
   }
 }
@@ -1301,6 +1420,7 @@ export async function stopConnector(connectorId: string): Promise<void> {
   }
 
   console.log(`[connector] Stopped connector: ${connectorId}`)
+  recordHealthEvent(connectorId, 'stopped', `Connector stopped`)
 }
 
 /** Get the runtime status of a connector */
@@ -1581,3 +1701,117 @@ export function scheduleConnectorFollowUp(params: {
 
   return { followUpId, sendAt }
 }
+
+/**
+ * Check health of all running connectors via `isAlive()`.
+ * Dead connectors that are still enabled get automatic reconnection with exponential backoff.
+ * After RECONNECT_MAX_ATTEMPTS, the connector is marked as error and retries stop.
+ */
+export async function checkConnectorHealth(): Promise<void> {
+  const connectors = loadConnectors()
+  let connectorsDirty = false
+
+  for (const [id, instance] of running.entries()) {
+    // If the instance has no isAlive method, skip (e.g. OpenClaw, BlueBubbles)
+    if (typeof instance.isAlive !== 'function') continue
+
+    if (instance.isAlive()) {
+      // Connector is healthy — clear any reconnect state
+      if (reconnectState.has(id)) {
+        console.log(`[connector-health] Connector "${instance.connector.name}" recovered`)
+        reconnectState.delete(id)
+      }
+      continue
+    }
+
+    // Connector is dead but still in the running Map
+    console.warn(`[connector-health] Connector "${instance.connector.name}" (${id}) isAlive=false — removing from running`)
+    recordHealthEvent(id, 'disconnected', `Connector "${instance.connector.name}" detected as dead (isAlive=false)`)
+
+    // Clean up the dead instance
+    try { await instance.stop() } catch { /* ignore */ }
+    running.delete(id)
+
+    const connector = connectors[id] as Connector | undefined
+    if (!connector) continue
+
+    // If the connector is not enabled, don't attempt reconnect
+    if (!connector.isEnabled) {
+      reconnectState.delete(id)
+      continue
+    }
+
+    // Attempt reconnect with backoff
+    const state = reconnectState.get(id) ?? {
+      attempts: 0,
+      lastAttemptAt: 0,
+      nextRetryAt: 0,
+      backoffMs: RECONNECT_INITIAL_BACKOFF_MS,
+      error: '',
+    }
+
+    // Check if we've exceeded max attempts
+    if (state.attempts >= RECONNECT_MAX_ATTEMPTS) {
+      console.warn(`[connector-health] Connector "${connector.name}" exceeded ${RECONNECT_MAX_ATTEMPTS} reconnect attempts — marking as error`)
+      connector.status = 'error'
+      connector.lastError = `Auto-reconnect gave up after ${RECONNECT_MAX_ATTEMPTS} attempts: ${state.error}`
+      connector.updatedAt = Date.now()
+      connectors[id] = connector
+      connectorsDirty = true
+      reconnectState.delete(id)
+      notify('connectors')
+      continue
+    }
+
+    const now = Date.now()
+
+    // Check if enough time has passed for the next retry
+    if (now < state.nextRetryAt) {
+      // Not yet time to retry — keep state and skip
+      continue
+    }
+
+    state.attempts += 1
+    state.lastAttemptAt = now
+    reconnectState.set(id, state)
+
+    try {
+      console.log(`[connector-health] Reconnecting "${connector.name}" (attempt ${state.attempts}/${RECONNECT_MAX_ATTEMPTS})`)
+      await startConnector(id)
+      // Success — clear reconnect state
+      reconnectState.delete(id)
+      console.log(`[connector-health] Connector "${connector.name}" reconnected successfully`)
+      recordHealthEvent(id, 'reconnected', `Connector "${connector.name}" reconnected after ${state.attempts} attempt(s)`)
+    } catch (err: unknown) {
+      const errorMsg = err instanceof Error ? err.message : String(err)
+      state.error = errorMsg
+      state.backoffMs = Math.min(RECONNECT_MAX_BACKOFF_MS, RECONNECT_INITIAL_BACKOFF_MS * (2 ** state.attempts))
+      state.nextRetryAt = now + state.backoffMs
+      reconnectState.set(id, state)
+      console.warn(`[connector-health] Reconnect failed for "${connector.name}" (attempt ${state.attempts}/${RECONNECT_MAX_ATTEMPTS}): ${errorMsg}. Next retry at ${new Date(state.nextRetryAt).toISOString()}`)
+    }
+  }
+
+  if (connectorsDirty) {
+    saveConnectors(connectors)
+  }
+
+  // Purge reconnect state for connectors that no longer exist
+  for (const id of reconnectState.keys()) {
+    if (!connectors[id]) reconnectState.delete(id)
+  }
+}
+
+/** Get the reconnect state for a specific connector (null if not in reconnect cycle) */
+export function getReconnectState(connectorId: string): ConnectorReconnectState | null {
+  return reconnectState.get(connectorId) ?? null
+}
+
+/** Get all reconnect states (for dashboard/API) */
+export function getAllReconnectStates(): Record<string, ConnectorReconnectState> {
+  const result: Record<string, ConnectorReconnectState> = {}
+  for (const [id, state] of reconnectState.entries()) {
+    result[id] = { ...state }
+  }
+  return result
+}

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

@@ -1185,6 +1185,9 @@ const openclaw: PlatformConnector = {
           throw err
         }
       },
+      isAlive() {
+        return !stopped && connected && !!ws && ws.readyState === WebSocket.OPEN
+      },
       async stop() {
         stopped = true
         cleanupSocket()

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

@@ -193,8 +193,13 @@ const slack: PlatformConnector = {
     await app.start()
     console.log(`[slack] Bot connected (socket mode)`)
 
+    let appStopped = false
+
     return {
       connector,
+      isAlive() {
+        return !appStopped && !!app.client
+      },
       async sendMessage(channelId, text, options) {
         const webClient = app.client
 
@@ -248,6 +253,7 @@ const slack: PlatformConnector = {
         return { messageId: lastTs }
       },
       async stop() {
+        appStopped = true
         await app.stop()
         console.log(`[slack] Bot disconnected`)
       },

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

@@ -40,8 +40,18 @@ const telegram: PlatformConnector = {
     bot.on('message', async (ctx) => {
       if (!ctx.message || !ctx.from || !ctx.chat) return
       const chatId = String(ctx.chat.id)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const raw = ctx.message as any
       const text = raw.text || raw.caption || ''
+
+      // Filter out Telegram service/system messages (read receipts, reactions, etc.)
+      // that appear as short bracketed strings like [rr], [e], [read] etc.
+      const hasMedia = raw.photo || raw.video || raw.audio || raw.voice || raw.document || raw.animation
+      if (!hasMedia && /^\[.{1,5}\]$/.test(text.trim())) {
+        console.log(`[telegram] Ignoring system event from ${ctx.from.first_name}: ${text}`)
+        return
+      }
+
       console.log(`[telegram] Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
 
       // Filter by allowed chats if configured
@@ -157,6 +167,9 @@ const telegram: PlatformConnector = {
       }
     })
 
+    // Track whether the bot is actively polling
+    let botRunning = true
+
     // Start polling — not awaited (runs in background)
     bot.start({
       allowed_updates: ['message', 'edited_message'],
@@ -164,11 +177,15 @@ const telegram: PlatformConnector = {
         console.log(`[telegram] Bot started as @${botInfo.username} — polling for updates`)
       },
     }).catch((err) => {
+      botRunning = false
       console.error(`[telegram] Polling stopped with error:`, err.message || err)
     })
 
     return {
       connector,
+      isAlive() {
+        return botRunning
+      },
       async sendMessage(channelId, text, options) {
         const chatId = channelId
         const caption = options?.caption || text || undefined
@@ -221,6 +238,7 @@ const telegram: PlatformConnector = {
         return { messageId: lastId }
       },
       async stop() {
+        botRunning = false
         await bot.stop()
         console.log(`[telegram] Bot stopped`)
       },

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

@@ -62,6 +62,8 @@ export interface ConnectorInstance {
   deleteMessage?: (channelId: string, messageId: string) => Promise<void>
   /** Rich messaging: pin a message */
   pinMessage?: (channelId: string, messageId: string) => Promise<void>
+  /** Health check: returns true if the underlying connection is alive */
+  isAlive?: () => boolean
 }
 
 /** Platform-specific connector implementation */

package/src/lib/server/connectors/whatsapp-text.test.ts

@@ -0,0 +1,29 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { formatTextForWhatsApp } from './whatsapp-text'
+
+describe('formatTextForWhatsApp', () => {
+  it('converts markdown links to readable whatsapp text', () => {
+    const input = 'See [Google](https://google.com) and [https://x.com](https://x.com)'
+    const output = formatTextForWhatsApp(input)
+    assert.equal(output, 'See Google: https://google.com and https://x.com')
+  })
+
+  it('converts common markdown emphasis syntax', () => {
+    const input = '**Bold** __Italic__ ~~Strike~~'
+    const output = formatTextForWhatsApp(input)
+    assert.equal(output, 'Bold Italic Strike')
+  })
+
+  it('removes headings and preserves body text', () => {
+    const input = '# Title\n\n## Subtitle\nBody line'
+    const output = formatTextForWhatsApp(input)
+    assert.equal(output, 'Title\n\nSubtitle\nBody line')
+  })
+
+  it('converts code fences to plain text content', () => {
+    const input = '```ts\nconst x = 1\n```\n\nDone.'
+    const output = formatTextForWhatsApp(input)
+    assert.equal(output, 'const x = 1\n\nDone.')
+  })
+})

package/src/lib/server/connectors/whatsapp-text.ts

@@ -0,0 +1,26 @@
+import removeMarkdown from 'remove-markdown'
+
+export function stripMarkdownForPlainChat(raw: string): string {
+  const source = String(raw || '').replace(/\r\n?/g, '\n')
+  if (!source) return ''
+
+  let text = removeMarkdown(source, {
+    gfm: true,
+    useImgAltText: true,
+    replaceLinksWithURL: true,
+    separateLinksAndTexts: ': ',
+  })
+
+  // Collapse duplicate "url: url" patterns when link label already equals URL.
+  text = text.replace(/(https?:\/\/[^\s]+): \1/g, '$1')
+  text = text.replace(/\n{3,}/g, '\n\n')
+  return text.trim()
+}
+
+/**
+ * Convert markdown-heavy model output into WhatsApp-friendly plain text.
+ * Uses a markdown parser package instead of ad-hoc regex-only stripping.
+ */
+export function formatTextForWhatsApp(raw: string): string {
+  return stripMarkdownForPlainChat(raw)
+}

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

@@ -12,6 +12,7 @@ import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { saveInboundMediaBuffer, mimeFromPath, isImageMime, isAudioMime } from './media'
 import { isNoMessage } from './manager'
+import { formatTextForWhatsApp } from './whatsapp-text'
 
 import { DATA_DIR } from '../data-dir'
 
@@ -65,17 +66,28 @@ const whatsapp: PlatformConnector = {
       qrDataUrl: null,
       authenticated: false,
       hasCredentials: hasStoredCreds(authDir),
+      isAlive() {
+        if (stopped || !sock) return false
+        // Check the underlying WebSocket connection state
+        const ws = sock.ws
+        if (!ws) return false
+        // If authenticated, the connection is alive
+        // If we have a socket but not yet authenticated (QR phase), still considered alive
+        return !stopped
+      },
       async sendMessage(channelId, text, options) {
         if (!sock) throw new Error('WhatsApp connector is not connected')
+        const normalizedText = formatTextForWhatsApp(text || '')
+        const normalizedCaption = formatTextForWhatsApp(options?.caption || normalizedText)
         // Local file path takes priority
         if (options?.mediaPath) {
           if (!fs.existsSync(options.mediaPath)) throw new Error(`File not found: ${options.mediaPath}`)
           const buf = fs.readFileSync(options.mediaPath)
           const mime = options.mimeType || mimeFromPath(options.mediaPath)
-          const caption = options.caption || text || undefined
+          const caption = normalizedCaption || undefined
           const fName = options.fileName || path.basename(options.mediaPath)
           let sent
-          if (isImageMime(mime)) {
+          if (isImageMime(mime) || mime.startsWith('video/')) {
             try {
               sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
             } catch (err: unknown) {
@@ -94,7 +106,7 @@ const whatsapp: PlatformConnector = {
         if (options?.imageUrl) {
           const sent = await sock.sendMessage(channelId, {
             image: { url: options.imageUrl },
-            caption: options.caption || text || undefined,
+            caption: normalizedCaption || undefined,
           })
           if (sent?.key?.id) sentMessageIds.add(sent.key.id)
           return { messageId: sent?.key?.id || undefined }
@@ -104,13 +116,13 @@ const whatsapp: PlatformConnector = {
             document: { url: options.fileUrl },
             fileName: options.fileName || 'attachment',
             mimetype: options.mimeType || 'application/octet-stream',
-            caption: options.caption || text || undefined,
+            caption: normalizedCaption || undefined,
           })
           if (sent?.key?.id) sentMessageIds.add(sent.key.id)
           return { messageId: sent?.key?.id || undefined }
         }
 
-        const payload = text || options?.caption || ''
+        const payload = normalizedText || normalizedCaption || ''
         const chunks = payload.length <= 4096 ? [payload] : (payload.match(/[\s\S]{1,4000}/g) || [payload])
         let lastMessageId: string | undefined
         for (const chunk of chunks) {