Ventana de 24 h y costos (Cloud API)

import { OutsideSessionWindowError } from '@botmesh/core'

try {
  await bot.send(chatId, 'Tu pedido ya va en camino')
} catch (err) {
  if (!(err instanceof OutsideSessionWindowError)) throw err
  await bot.send(chatId, {
    kind: 'template',
    name: 'order_update',
    language: 'es',
    components: [/* parámetros de la plantilla, en formato de Graph */],
  })
}

import { CloudAPIProvider } from '@botmesh/meta'

const provider = new CloudAPIProvider({
  accessToken: process.env.META_TOKEN!,
  phoneNumberId: process.env.META_PHONE_ID!,
  verifyToken: process.env.META_VERIFY_TOKEN!,
  appSecret: process.env.META_APP_SECRET!,
  sessionWindow: {
    reopenTemplate: { kind: 'template', name: 'resume_conversation', language: 'es' },
    reopenTemplateByKind: {
      document: { kind: 'template', name: 'document_ready', language: 'es' },
    },
    onReport: (r) => logger.info({ chatId: r.chatId, outcome: r.outcome }, 'ventana de sesión'),
  },
})

import { SessionWindowReopenedError } from '@botmesh/meta'

try {
  await bot.send(chatId, 'Te enviamos tu factura')
} catch (err) {
  if (err instanceof SessionWindowReopenedError) {
    // err.template ya salió; err.queued === true → se entrega cuando el usuario responda
  } else throw err
}

sessionWindow: {
  reopenTemplate: async ({ chatId }) => {
    const lang = await users.language(chatId)
    return { kind: 'template', name: 'resume_conversation', language: lang }
  },
}

import type { SessionWindowStore } from '@botmesh/meta'

const store: SessionWindowStore = {
  async get(key) {
    const raw = await redis.hGet('wa:window', key)
    return raw ? JSON.parse(raw) : undefined
  },
  async set(key, state) { await redis.hSet('wa:window', key, JSON.stringify(state)) },
  async delete(key) { await redis.hDel('wa:window', key) },
}

new CloudAPIProvider({ /* ... */ sessionWindow: { store, reopenTemplate } })

import { SessionWindowManager } from '@botmesh/meta'

const windows = new SessionWindowManager({ store, reopenTemplate })

const sales = new CloudAPIProvider({ /* ... */ phoneNumberId: 'SALES_ID', sessionWindow: windows })
const support = new CloudAPIProvider({ /* ... */ phoneNumberId: 'SUPPORT_ID', sessionWindow: windows })

sales.sessionWindow === windows.forScope('SALES_ID') // true (memoizado)

const sw = provider.sessionWindow!
await sw.state(chatId)     // 'open' | 'closed' | 'unknown'
await sw.isOpen(chatId)    // true solo si se sabe abierta
await sw.expiresAt(chatId) // epoch ms en que se cierra la ventana, o undefined
sw.pending(chatId)         // envíos encolados del chat
sw.clearPending(chatId)    // los descarta (cada uno se notifica como 'dropped')

import { pricingOf } from '@botmesh/meta'

bot.on('status', (status) => {
  const pricing = pricingOf(status.platformData)
  if (pricing?.billable) metrics.increment(`wa.billable.${pricing.category ?? 'unknown'}`)
})

const provider = new CloudAPIProvider({
  /* ... */
  usage: { rates: { marketing: 0.0625, utility: 0.008 } }, // precio por mensaje facturable
})

provider.usage!.forChat(chatId) // { messages, billable, free, estimatedCost, byCategory } | undefined
provider.usage!.totals()        // lo mismo, sumando todos los chats
provider.usage!.chats()         // chats con contadores, del actualizado hace más tiempo al más reciente
provider.usage!.reset(chatId)   // limpia un chat (los totales se conservan); reset() lo limpia todo