@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -3,8 +3,10 @@ import fs from 'fs'
 import path from 'path'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundMediaType } from './types'
+import { resolveConnectorIngressReply } from './ingress-delivery'
+import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime, isAudioMime } from './media'
-import { getConnectorReplySendOptions, isNoMessage, recordConnectorOutboundDelivery } from './manager'
+import { errorMessage } from '@/lib/shared-utils'
 
 const telegram: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
@@ -152,37 +154,25 @@ const telegram: PlatformConnector = {
 
       try {
         await ctx.api.sendChatAction(ctx.chat.id, 'typing')
-        const response = await onMessage(inbound)
-
-        if (isNoMessage(response)) return
-
-        const replyOptions = getConnectorReplySendOptions({ connectorId: connector.id, inbound })
-        const baseOptions: Record<string, unknown> = {}
-        if (replyOptions.replyToMessageId) {
-          baseOptions.reply_parameters = { message_id: Number(replyOptions.replyToMessageId) }
-        }
-        if (replyOptions.threadId) {
-          baseOptions.message_thread_id = Number(replyOptions.threadId)
-        }
-
-        let lastMessageId: string | undefined
-
-        // Telegram has a 4096 char limit
-        if (response.length <= 4096) {
-          const sent = await ctx.api.sendMessage(ctx.chat.id, response, baseOptions as any)
-          lastMessageId = String(sent.message_id)
-        } else {
-          const chunks = response.match(/[\s\S]{1,4090}/g) || [response]
-          for (let i = 0; i < chunks.length; i += 1) {
-            const sent = await ctx.api.sendMessage(ctx.chat.id, chunks[i], (i === 0 ? baseOptions : {}) as any)
-            lastMessageId = String(sent.message_id)
-          }
-        }
-        await recordConnectorOutboundDelivery({
+        const reply = await resolveConnectorIngressReply(onMessage, inbound)
+        if (!reply) return
+        await deliverChunkedConnectorText({
           connectorId: connector.id,
           inbound,
-          messageId: lastMessageId,
-          state: 'sent',
+          text: reply.visibleText,
+          maxSingleMessageLength: 4096,
+          chunkLength: 4090,
+          sendChunk: async (chunk, meta) => {
+            const options: Record<string, unknown> = {}
+            if (meta.isFirstChunk && meta.replyToMessageId) {
+              options.reply_parameters = { message_id: Number(meta.replyToMessageId) }
+            }
+            if (meta.threadId) {
+              options.message_thread_id = Number(meta.threadId)
+            }
+            const sent = await ctx.api.sendMessage(ctx.chat.id, chunk, options as any)
+            return String(sent.message_id)
+          },
         })
       } catch (err: any) {
         console.error(`[telegram] Error handling message:`, err.message)
@@ -195,19 +185,7 @@ 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'],
-      onStart: (botInfo) => {
-        botUsername = botInfo.username || ''
-        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 {
+    const instance: ConnectorInstance = {
       connector,
       isAlive() {
         return botRunning
@@ -293,6 +271,22 @@ const telegram: PlatformConnector = {
         console.log(`[telegram] Bot stopped`)
       },
     }
+
+    // Start polling — not awaited (runs in background)
+    bot.start({
+      allowed_updates: ['message', 'edited_message'],
+      onStart: (botInfo) => {
+        botUsername = botInfo.username || ''
+        console.log(`[telegram] Bot started as @${botInfo.username} — polling for updates`)
+      },
+    }).catch((err: unknown) => {
+      botRunning = false
+      const errMsg = errorMessage(err)
+      console.error(`[telegram] Polling stopped with error:`, errMsg)
+      instance.onCrash?.(`Polling stopped: ${errMsg}`)
+    })
+
+    return instance
   },
 }
 

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

@@ -68,6 +68,34 @@ export interface OutboundTypingOptions {
   threadId?: string
 }
 
+export interface ConnectorRouteResult {
+  managerHandled: boolean
+  visibleText: string
+  delivery: 'sent' | 'silent'
+  messageId?: string
+}
+
+export type ConnectorIngressResult = string | ConnectorRouteResult
+
+export function isConnectorRouteResult(value: unknown): value is ConnectorRouteResult {
+  return !!value
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && typeof (value as ConnectorRouteResult).managerHandled === 'boolean'
+    && typeof (value as ConnectorRouteResult).visibleText === 'string'
+}
+
+export function normalizeConnectorIngressResult(value: ConnectorIngressResult): ConnectorRouteResult {
+  if (isConnectorRouteResult(value)) return value
+  const visibleText = typeof value === 'string' ? value : ''
+  const normalized = visibleText.trim().toUpperCase()
+  return {
+    managerHandled: false,
+    visibleText,
+    delivery: normalized && normalized !== 'NO_MESSAGE' ? 'sent' : 'silent',
+  }
+}
+
 /** A running connector instance */
 export interface ConnectorInstance {
   connector: Connector
@@ -96,6 +124,8 @@ export interface ConnectorInstance {
   sendTyping?: (channelId: string, options?: OutboundTypingOptions) => Promise<void>
   /** Health check: returns true if the underlying connection is alive */
   isAlive?: () => boolean
+  /** Called by the platform when the connection dies terminally (no internal retry) */
+  onCrash?: (error: string) => void
 }
 
 /** Platform-specific connector implementation */
@@ -103,6 +133,6 @@ export interface PlatformConnector {
   start(
     connector: Connector,
     botToken: string,
-    onMessage: (msg: InboundMessage) => Promise<string>,
+    onMessage: (msg: InboundMessage) => Promise<ConnectorIngressResult>,
   ): Promise<ConnectorInstance>
 }

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

@@ -3,10 +3,13 @@ import test from 'node:test'
 import {
   buildWhatsAppTextPayloads,
   buildWhatsAppInboundMessage,
+  isWhatsAppSocketAlive,
   isWhatsAppInboundAllowed,
   normalizeWhatsAppAudioForSend,
   normalizeWhatsAppIdentifier,
+  resolveWhatsAppAllowedIdentifiers,
 } from './whatsapp'
+import { normalizeE164, normalizeWhatsappTarget } from './response-media'
 
 test('buildWhatsAppTextPayloads disables link previews for text sends', () => {
   const payloads = buildWhatsAppTextPayloads('See https://example.com for details')
@@ -32,6 +35,19 @@ test('normalizeWhatsAppIdentifier strips jid wrappers and device suffixes', () =
   assert.equal(normalizeWhatsAppIdentifier('199900000001@lid'), '199900000001')
 })
 
+test('normalizeWhatsAppIdentifier handles international numbers', () => {
+  // Swiss
+  assert.equal(normalizeWhatsAppIdentifier('+41 79 666 68 64@s.whatsapp.net'), '41796666864')
+  // German
+  assert.equal(normalizeWhatsAppIdentifier('491711234567@s.whatsapp.net'), '491711234567')
+  // Brazilian
+  assert.equal(normalizeWhatsAppIdentifier('+55 11 99999-8888'), '5511999998888')
+  // Indian
+  assert.equal(normalizeWhatsAppIdentifier('919876543210:0@s.whatsapp.net'), '919876543210')
+  // Plain number with whatsapp: prefix
+  assert.equal(normalizeWhatsAppIdentifier('whatsapp:+447911123456'), '447911123456')
+})
+
 test('isWhatsAppInboundAllowed matches allow-list entries against alt phone JIDs', () => {
   const allowed = ['15550001111']
   const msg = {
@@ -45,6 +61,28 @@ test('isWhatsAppInboundAllowed matches allow-list entries against alt phone JIDs
   assert.equal(isWhatsAppInboundAllowed({ allowedJids: ['15559990000'], msg }), false)
 })
 
+test('resolveWhatsAppAllowedIdentifiers merges connector and settings approvals', () => {
+  const allowed = resolveWhatsAppAllowedIdentifiers({
+    configuredAllowedJids: '15550001111',
+    settingsContacts: [
+      { id: 'family', label: 'Family', phone: '+1 (666) 000-2222' },
+      { id: 'dup', label: 'Family JID', phone: '16660002222@s.whatsapp.net' },
+    ],
+  })
+
+  assert.deepEqual(allowed, ['15550001111', '16660002222'])
+})
+
+test('resolveWhatsAppAllowedIdentifiers keeps the connector open when no allowedJids are configured', () => {
+  const allowed = resolveWhatsAppAllowedIdentifiers({
+    settingsContacts: [
+      { id: 'family', label: 'Family', phone: '+1 (666) 000-2222' },
+    ],
+  })
+
+  assert.equal(allowed, null)
+})
+
 test('buildWhatsAppInboundMessage includes modern WhatsApp metadata', () => {
   const inbound = buildWhatsAppInboundMessage({
     msg: {
@@ -79,6 +117,34 @@ test('buildWhatsAppInboundMessage includes modern WhatsApp metadata', () => {
   assert.equal(inbound?.text, 'Hey there')
 })
 
+test('isWhatsAppSocketAlive reports disconnected sockets as dead so daemon restarts can run', () => {
+  assert.equal(isWhatsAppSocketAlive({
+    stopped: false,
+    socket: { ws: { isClosed: true } },
+    connectionState: 'close',
+  }), false)
+
+  assert.equal(isWhatsAppSocketAlive({
+    stopped: false,
+    socket: { ws: { isClosing: true } },
+    connectionState: 'connecting',
+  }), false)
+})
+
+test('isWhatsAppSocketAlive keeps QR and active sessions marked live', () => {
+  assert.equal(isWhatsAppSocketAlive({
+    stopped: false,
+    socket: { ws: { isConnecting: true } },
+    connectionState: 'connecting',
+  }), true)
+
+  assert.equal(isWhatsAppSocketAlive({
+    stopped: false,
+    socket: { ws: { isOpen: true } },
+    connectionState: 'open',
+  }), true)
+})
+
 test('normalizeWhatsAppAudioForSend transcodes mp3 voice notes to Android-safe opus/ogg', () => {
   let transcodeCalls = 0
   const converted = normalizeWhatsAppAudioForSend({
@@ -132,3 +198,45 @@ test('normalizeWhatsAppAudioForSend leaves normal audio attachments alone when p
   assert.equal(converted.buffer.toString(), 'music')
   assert.equal(converted.mimeType, 'audio/mpeg')
 })
+
+// ---------------------------------------------------------------------------
+// normalizeE164 — E.164 formatting for all country codes
+// ---------------------------------------------------------------------------
+
+test('normalizeE164 strips formatting and ensures + prefix', () => {
+  assert.equal(normalizeE164('+41 79 666 68 64'), '+41796666864')
+  assert.equal(normalizeE164('(555) 123-4567'), '+5551234567')
+  assert.equal(normalizeE164('whatsapp:+447911123456'), '+447911123456')
+  assert.equal(normalizeE164('491711234567'), '+491711234567')
+  assert.equal(normalizeE164('+55 11 99999-8888'), '+5511999998888')
+})
+
+// ---------------------------------------------------------------------------
+// normalizeWhatsappTarget — JID normalization for outbound messages
+// ---------------------------------------------------------------------------
+
+test('normalizeWhatsappTarget builds user JIDs from plain numbers', () => {
+  assert.equal(normalizeWhatsappTarget('+41796666864'), '41796666864@s.whatsapp.net')
+  assert.equal(normalizeWhatsappTarget('447911123456'), '447911123456@s.whatsapp.net')
+  assert.equal(normalizeWhatsappTarget('+55 11 99999-8888'), '5511999998888@s.whatsapp.net')
+  assert.equal(normalizeWhatsappTarget('(555) 123-4567'), '5551234567@s.whatsapp.net')
+})
+
+test('normalizeWhatsappTarget preserves group JIDs', () => {
+  assert.equal(normalizeWhatsappTarget('120363401234567890@g.us'), '120363401234567890@g.us')
+  assert.equal(normalizeWhatsappTarget('120363-401234567890@g.us'), '120363-401234567890@g.us')
+})
+
+test('normalizeWhatsappTarget extracts phone from user JIDs', () => {
+  assert.equal(normalizeWhatsappTarget('41796666864:0@s.whatsapp.net'), '41796666864@s.whatsapp.net')
+  assert.equal(normalizeWhatsappTarget('15550001111:7@s.whatsapp.net'), '15550001111@s.whatsapp.net')
+})
+
+test('normalizeWhatsappTarget passes through LID JIDs unchanged', () => {
+  assert.equal(normalizeWhatsappTarget('199900000001@lid'), '199900000001@lid')
+})
+
+test('normalizeWhatsappTarget strips whatsapp: prefix', () => {
+  assert.equal(normalizeWhatsappTarget('whatsapp:+447911123456'), '447911123456@s.whatsapp.net')
+  assert.equal(normalizeWhatsappTarget('whatsapp:120363401234567890@g.us'), '120363401234567890@g.us')
+})

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

@@ -12,13 +12,16 @@ import fs from 'fs'
 import os from 'os'
 import { spawnSync } from 'child_process'
 import type { Connector } from '@/types'
+import { dedup, errorMessage } from '@/lib/shared-utils'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import { resolveConnectorIngressReply } from './ingress-delivery'
 import { saveInboundMediaBuffer, mimeFromPath, isImageMime, isAudioMime } from './media'
-import { isNoMessage, recordConnectorOutboundDelivery } from './manager'
+import { recordConnectorOutboundDelivery } from './delivery'
 import { formatTextForWhatsApp } from './whatsapp-text'
+import { getWhatsAppApprovedSenderIds } from './pairing'
 
 import { DATA_DIR } from '../data-dir'
-import { loadConnectors } from '../storage'
+import { loadConnectors, loadSettings } from '../storage'
 
 const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth')
 const INBOUND_DEDUPE_TTL_MS = 2 * 60 * 1000
@@ -29,6 +32,15 @@ const WHATSAPP_VOICE_NOTE_EXTS = new Set(['.ogg', '.opus'])
 
 let cachedFfmpegBinary: string | null | undefined
 
+type WhatsAppSocketState = {
+  ws?: {
+    isOpen?: boolean
+    isClosed?: boolean
+    isClosing?: boolean
+    isConnecting?: boolean
+  } | null
+} | null
+
 export function buildWhatsAppTextPayloads(text: string): Array<{ text: string; linkPreview: null }> {
   const chunks = text.length <= WHATSAPP_SINGLE_MESSAGE_MAX
     ? [text]
@@ -36,6 +48,26 @@ export function buildWhatsAppTextPayloads(text: string): Array<{ text: string; l
   return chunks.map((chunk) => ({ text: chunk, linkPreview: null }))
 }
 
+export function isWhatsAppSocketAlive(params: {
+  stopped: boolean
+  socket: WhatsAppSocketState
+  connectionState?: string | null
+}): boolean {
+  if (params.stopped) return false
+  if (!params.socket) return false
+
+  const ws = params.socket.ws
+  if (!ws) return false
+  if (params.connectionState === 'close') return false
+  if (ws.isClosed || ws.isClosing) return false
+  if (ws.isOpen || ws.isConnecting) return true
+  if (params.connectionState === 'open' || params.connectionState === 'connecting') return true
+
+  // Treat an existing socket with no explicit close signal as live while QR/auth
+  // negotiation is still in progress.
+  return params.connectionState == null
+}
+
 function normalizeMimeType(mimeType?: string): string {
   return String(mimeType || '').toLowerCase().split(';')[0].trim()
 }
@@ -141,6 +173,7 @@ export function normalizeWhatsAppAudioForSend(params: {
   return converted || { buffer: params.buffer, mimeType }
 }
 
+/** Extract the user part from a JID, stripping the server and device suffix */
 function jidUserPart(raw: string): string {
   const trimmed = String(raw || '').trim().toLowerCase()
   if (!trimmed) return ''
@@ -148,16 +181,15 @@ function jidUserPart(raw: string): string {
   return withoutServer.split(':')[0]
 }
 
-/** Normalize a phone number or JID user part for inbound matching */
+/**
+ * Normalize a phone number or JID to a bare-digit identifier for matching.
+ * Works for all country codes — strips formatting, `whatsapp:` prefixes,
+ * JID suffixes (`@s.whatsapp.net`, `@lid`), and device suffixes (`:0`).
+ * Returns bare digits (no `+` prefix) for comparison.
+ */
 export function normalizeWhatsAppIdentifier(raw: string): string {
-  let n = jidUserPart(raw).replace(/[\s\-()]/g, '')
-  // UK local: 07xxx → 447xxx
-  if (n.startsWith('0') && n.length >= 10) {
-    n = '44' + n.slice(1)
-  }
-  // Strip leading +
-  if (n.startsWith('+')) n = n.slice(1)
-  return n.replace(/[^a-z0-9]/g, '')
+  const withoutPrefix = String(raw || '').replace(/^whatsapp:/i, '').trim()
+  return jidUserPart(withoutPrefix).replace(/[^\da-z]/g, '')
 }
 
 function parseAllowedIdentifiers(raw: unknown): string[] | null {
@@ -169,6 +201,19 @@ function parseAllowedIdentifiers(raw: unknown): string[] | null {
   return out.length ? out : null
 }
 
+export function resolveWhatsAppAllowedIdentifiers(params: {
+  configuredAllowedJids?: unknown
+  settingsContacts?: unknown
+}): string[] | null {
+  const configured = parseAllowedIdentifiers(params.configuredAllowedJids)
+  if (!configured?.length) return null
+  const settings = getWhatsAppApprovedSenderIds(params.settingsContacts)
+    .map((entry) => normalizeWhatsAppIdentifier(entry))
+    .filter(Boolean)
+  const merged = dedup([...configured, ...settings])
+  return merged.length ? merged : null
+}
+
 function messageContextInfo(content: any): any {
   return content?.extendedTextMessage?.contextInfo
     || content?.imageMessage?.contextInfo
@@ -190,7 +235,7 @@ export function collectWhatsAppAddressCandidates(msg: Pick<WAMessage, 'key'>): s
   const normalized = raw
     .map((entry) => normalizeWhatsAppIdentifier(String(entry || '')))
     .filter(Boolean)
-  return Array.from(new Set(normalized))
+  return dedup(normalized)
 }
 
 export function isWhatsAppInboundAllowed(params: {
@@ -292,21 +337,38 @@ const whatsapp: PlatformConnector = {
     let sock: ReturnType<typeof makeWASocket> | null = null
     let stopped = false
     let socketGen = 0 // Track socket generation to ignore stale events
+    let connectionState: string | null = 'connecting'
+    let reconnectTimer: ReturnType<typeof setTimeout> | null = null
     const seenInboundMessageIds = new Map<string, number>()
 
+    const clearReconnectTimer = () => {
+      if (!reconnectTimer) return
+      clearTimeout(reconnectTimer)
+      reconnectTimer = null
+    }
+
+    const scheduleReconnect = (delayMs: number) => {
+      if (stopped) return
+      clearReconnectTimer()
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null
+        if (stopped) return
+        startSocket()
+      }, delayMs)
+      reconnectTimer.unref?.()
+    }
+
     const instance: ConnectorInstance = {
       connector,
       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
+        return isWhatsAppSocketAlive({
+          stopped,
+          socket: sock,
+          connectionState,
+        })
       },
       async sendMessage(channelId, text, options) {
         if (!sock) throw new Error('WhatsApp connector is not connected')
@@ -324,7 +386,7 @@ const whatsapp: PlatformConnector = {
             try {
               sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
             } catch (err: unknown) {
-              const errMsg = err instanceof Error ? err.message : String(err)
+              const errMsg = errorMessage(err)
               console.warn(`[whatsapp] Image send failed (${errMsg}); retrying as document: ${fName}`)
               sent = await sock.sendMessage(channelId, { document: buf, fileName: fName, mimetype: mime, caption })
             }
@@ -378,6 +440,8 @@ const whatsapp: PlatformConnector = {
       },
       async stop() {
         stopped = true
+        connectionState = 'close'
+        clearReconnectTimer()
         try { sock?.end(undefined) } catch { /* ignore */ }
         sock = null
         console.log(`[whatsapp] Stopped connector: ${connector.name}`)
@@ -388,6 +452,9 @@ const whatsapp: PlatformConnector = {
     const sentMessageIds = new Set<string>()
 
     const startSocket = () => {
+      if (stopped) return
+      clearReconnectTimer()
+
       // Close previous socket to prevent stale event handlers
       if (sock) {
         try { sock.ev.removeAllListeners('connection.update') } catch { /* ignore */ }
@@ -398,6 +465,7 @@ const whatsapp: PlatformConnector = {
       }
 
       const gen = ++socketGen // Capture generation for stale detection
+      connectionState = 'connecting'
       console.log(`[whatsapp] Starting socket gen=${gen} for ${connector.name} (hasCreds=${instance.hasCredentials})`)
 
       sock = makeWASocket({
@@ -416,6 +484,7 @@ const whatsapp: PlatformConnector = {
         if (gen !== socketGen) return // Ignore events from stale sockets
 
         const { connection, lastDisconnect, qr } = update
+        if (typeof connection === 'string' && connection) connectionState = connection
         console.log(`[whatsapp] Connection update gen=${gen}: connection=${connection}, hasQR=${!!qr}`)
 
         if (qr) {
@@ -444,16 +513,17 @@ const whatsapp: PlatformConnector = {
             if (!stopped) {
               // Recreate auth dir and state for fresh start
               fs.mkdirSync(authDir, { recursive: true })
-              setTimeout(startSocket, 1000)
+              scheduleReconnect(1000)
             }
           } else if (reason === 440) {
             // Conflict — another session replaced this one. Do NOT reconnect
             // (reconnecting would create a ping-pong loop with the other session)
             console.log(`[whatsapp] Session conflict (replaced by another connection) — stopping`)
             instance.authenticated = false
+            instance.onCrash?.('Session conflict — replaced by another connection')
           } else if (!stopped) {
             console.log(`[whatsapp] Reconnecting in 3s...`)
-            setTimeout(startSocket, 3000)
+            scheduleReconnect(3000)
           } else {
             console.log(`[whatsapp] Disconnected permanently`)
           }
@@ -518,7 +588,10 @@ const whatsapp: PlatformConnector = {
 
           const jid = msg.key.remoteJid || ''
           const latestConnector = (loadConnectors()[connector.id] as Connector | undefined) || connector
-          const allowedJids = parseAllowedIdentifiers(latestConnector.config?.allowedJids)
+          const allowedJids = resolveWhatsAppAllowedIdentifiers({
+            configuredAllowedJids: latestConnector.config?.allowedJids,
+            settingsContacts: loadSettings().whatsappApprovedContacts,
+          })
 
           // Match allowed JIDs using normalized numbers
           // Self-chat always passes the filter (it's the bot's own account)
@@ -580,18 +653,17 @@ const whatsapp: PlatformConnector = {
 
           try {
             await sock!.sendPresenceUpdate('composing', jid)
-            const response = await onMessage(inbound)
+            const reply = await resolveConnectorIngressReply(onMessage, inbound)
             await sock!.sendPresenceUpdate('paused', jid)
-
-            if (!isNoMessage(response)) {
-              const sent = await instance.sendMessage?.(jid, response)
-              await recordConnectorOutboundDelivery({
-                connectorId: connector.id,
-                inbound,
-                messageId: sent?.messageId,
-                state: 'sent',
-              })
-            }
+            if (!reply) continue
+
+            const sent = await instance.sendMessage?.(jid, reply.visibleText)
+            await recordConnectorOutboundDelivery({
+              connectorId: connector.id,
+              inbound,
+              messageId: sent?.messageId,
+              state: 'sent',
+            })
           } catch (err: any) {
             console.error(`[whatsapp] Error handling message:`, err.message)
             try {