Gava/agenciapsilmno
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

3.7 Bot auto-triagem WhatsApp: config por tenant + hook nos inbound

Browse Source 
Bot que coleta nome, motivo de busca e preferências ANTES do paciente
entrar no fluxo humano. Terapeuta abre a conversa e já encontra
resumo em conversation_notes.

Banco (migration 20260423000007):
- conversation_bots: config 1 por tenant. enabled, greeting/closing
  messages, steps (JSONB array de {prompt, variable, type}), trigger_mode
  (new_contact | all_unassigned | keyword), trigger_keywords[],
  idle_timeout_minutes, respect_optout.
  Defaults vêm com 4 perguntas úteis: nome, motivo, modalidade,
  horário preferido.
- conversation_bot_sessions: estado por thread. current_step,
  collected_data JSONB, status (active | completed | abandoned_idle |
  abandoned_manual | opted_out). UNIQUE parcial garante 1 ativa por
  (tenant, thread).
- RLS: leitura tenant/saas_admin, escrita admins (config) + service_role
  (sessions, só edge altera).

Shared (_shared/whatsapp-hooks.ts):
- maybeProcessBot: carrega config, busca sessão ativa, avança step
  com resposta, envia próxima pergunta via SendFn. Ao esgotar steps,
  envia closing + cria conversation_notes com resumo das variáveis
  coletadas. Se humano assume (conversation_assignments preenchido),
  sessão marca 'abandoned_manual' e bot sai.
- Trigger modes:
  - 'new_contact' (default): só inicia pra thread sem histórico bot
    E sem paciente vinculado (lead real).
  - 'all_unassigned': qualquer thread sem assignee.
  - 'keyword': matched contra lista; normalizeForMatch já existe.

Integração nos inbound (ambos providers):
- evolution-whatsapp-inbound: chama maybeProcessBot após opt-in/opt-out,
  ANTES do auto-reply. Se bot processou, skip auto-reply (senão duas
  respostas sobrepostas).
- twilio-whatsapp-inbound: idem, usando makeTwilioCreditedSendFn pra
  cobrar crédito de cada mensagem enviada pelo bot.

UI (/configuracoes/conversas-bots):
- Toggle enabled + Select trigger_mode + (se keyword) chips de keywords.
- Textareas greeting/closing.
- Editor de steps: reordenar (up/down), remover, add, editor com prompt
  e variable (regex /^[a-z_][a-z0-9_]*$/).
- Botão "Padrão" restaura mensagens/steps default.
- InputNumber idle_timeout + toggle respect_optout.
- Card inferior: últimas 30 sessões (7 dias) com status, contato,
  nome coletado (primeiro campo), progresso (step X/N), início.
- Entrada na landing de configurações + rota /configuracoes/conversas-bots.

Caveat conhecido: a resolução de conversation_notes.created_by usa
o primeiro admin ativo do tenant (pickAnyAdmin). Pra uma v2 seria
ideal ter um user "bot" sintético dedicado.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Leonardo
2026-04-23 13:54:53 -03:00
parent 4e4bac622c
commit c2c42a1620
7 changed files with 854 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
supabase/functions/_shared/whatsapp-hooks.ts
+220
View File
@@ -369,3 +369,223 @@ export function makeTwilioCreditedSendFn(
return { ok: true, messageId: sendRes.messageId ?? null }
}
}
// ════════════════════════════════════════════════════════════════════════════
// Bot de auto-triagem (3.7)
// ════════════════════════════════════════════════════════════════════════════
type BotStep = { prompt: string; variable: string; type?: string }
type BotConfig = {
enabled: boolean
greeting_message: string
closing_message: string
steps: BotStep[]
trigger_mode: 'new_contact' | 'all_unassigned' | 'keyword'
trigger_keywords: string[]
idle_timeout_minutes: number
respect_optout: boolean
}
/**
* Verifica se o bot deve processar esta inbound. Se sim, avança/inicia
* a sessão e envia a próxima pergunta. Retorna true se processou (caller
* deve skipar auto-reply pra não empilhar respostas).
*
* Caller garante que esta função só é chamada quando:
* - mensagem é inbound (não fromMe)
* - não é opt-out
*/
export async function maybeProcessBot(
supa: SupabaseClient,
tenantId: string,
threadKey: string,
patientId: string | null,
phone: string,
body: string,
sendFn: SendFn
): Promise<{ processed: boolean; status?: string; step?: number; reason?: string }> {
const text = String(body || '').trim()
// Carrega config
const { data: cfg } = await supa
.from('conversation_bots')
.select('*')
.eq('tenant_id', tenantId)
.maybeSingle()
if (!cfg || !cfg.enabled) return { processed: false, reason: 'disabled' }
const config = cfg as BotConfig
if (!Array.isArray(config.steps) || config.steps.length === 0) {
return { processed: false, reason: 'no_steps' }
}
// Busca sessão ativa
const { data: active } = await supa
.from('conversation_bot_sessions')
.select('*')
.eq('tenant_id', tenantId)
.eq('thread_key', threadKey)
.eq('status', 'active')
.maybeSingle()
if (active) {
// Se humano já atribuiu a thread, abandona bot
const { data: assign } = await supa
.from('conversation_assignments')
.select('assigned_to')
.eq('tenant_id', tenantId)
.eq('thread_key', threadKey)
.maybeSingle()
if (assign?.assigned_to) {
await supa.from('conversation_bot_sessions')
.update({ status: 'abandoned_manual', abandoned_at: new Date().toISOString() })
.eq('id', active.id)
return { processed: false, reason: 'human_took_over' }
}
return await advanceSession(supa, config, active, text, phone, sendFn)
}
// Sem sessão ativa — decide se inicia
if (config.trigger_mode === 'new_contact') {
// Inicia só se ainda não existe nenhuma sessão (completada ou abandonada) pra essa thread
const { data: prev } = await supa
.from('conversation_bot_sessions')
.select('id')
.eq('tenant_id', tenantId)
.eq('thread_key', threadKey)
.limit(1)
.maybeSingle()
if (prev) return { processed: false, reason: 'already_bot_history' }
// Também pula se paciente já existe (é contato conhecido)
if (patientId) return { processed: false, reason: 'known_patient' }
} else if (config.trigger_mode === 'keyword') {
const normalized = normalizeForMatch(text)
const matched = (config.trigger_keywords || []).some((kw) => normalized.includes(normalizeForMatch(kw)))
if (!matched) return { processed: false, reason: 'no_keyword_match' }
}
// 'all_unassigned' passa direto
// Inicia nova sessão
return await startSession(supa, config, tenantId, threadKey, phone, sendFn)
}
async function startSession(
supa: SupabaseClient,
config: BotConfig,
tenantId: string,
threadKey: string,
phone: string,
sendFn: SendFn
): Promise<{ processed: boolean; status?: string; step?: number }> {
const { data: session, error: sessErr } = await supa
.from('conversation_bot_sessions')
.insert({
tenant_id: tenantId,
thread_key: threadKey,
contact_number: phone,
current_step: 0,
collected_data: {},
status: 'active'
})
.select('id')
.single()
if (sessErr || !session) return { processed: false }
// Manda greeting + primeira pergunta como 2 mensagens separadas
const firstPrompt = config.steps[0]?.prompt || ''
await sendFn(phone, config.greeting_message)
if (firstPrompt) await sendFn(phone, firstPrompt)
return { processed: true, status: 'started', step: 0 }
}
async function advanceSession(
supa: SupabaseClient,
config: BotConfig,
session: { id: string, current_step: number, collected_data: Record<string, unknown>, tenant_id: string, thread_key: string, contact_number: string | null },
text: string,
phone: string,
sendFn: SendFn
): Promise<{ processed: boolean; status?: string; step?: number }> {
const step = Number(session.current_step) || 0
const currentStep = config.steps[step]
if (!currentStep) {
// Segurança: step fora do range → encerra
await supa.from('conversation_bot_sessions')
.update({ status: 'completed', completed_at: new Date().toISOString() })
.eq('id', session.id)
return { processed: true, status: 'completed', step }
}
// Salva resposta do step atual
const newData = { ...(session.collected_data || {}), [currentStep.variable]: text }
const nextStep = step + 1
const isLast = nextStep >= config.steps.length
if (isLast) {
// Finaliza
await supa.from('conversation_bot_sessions')
.update({
collected_data: newData,
current_step: nextStep,
status: 'completed',
completed_at: new Date().toISOString(),
last_advance_at: new Date().toISOString()
})
.eq('id', session.id)
// Envia closing
if (config.closing_message) await sendFn(phone, config.closing_message)
// Cria nota interna com resumo
try {
const lines = config.steps.map((s) => {
const val = newData[s.variable] ?? '—'
return `• ${s.variable}: ${val}`
})
const summary = `🤖 Triagem automática concluída:\n\n${lines.join('\n')}`
await supa.from('conversation_notes').insert({
tenant_id: session.tenant_id,
thread_key: session.thread_key,
contact_number: session.contact_number,
body: summary,
// created_by obrigatório — usa um user "bot" fictício? Não temos. Pega qualquer admin.
created_by: await pickAnyAdmin(supa, session.tenant_id)
})
} catch (err) {
console.warn('[bot] failed to create summary note:', (err as Error)?.message)
}
return { processed: true, status: 'completed', step: nextStep }
}
// Avança pra próxima pergunta
await supa.from('conversation_bot_sessions')
.update({
collected_data: newData,
current_step: nextStep,
last_advance_at: new Date().toISOString()
})
.eq('id', session.id)
const nextPrompt = config.steps[nextStep]?.prompt || ''
if (nextPrompt) await sendFn(phone, nextPrompt)
return { processed: true, status: 'advanced', step: nextStep }
}
async function pickAnyAdmin(supa: SupabaseClient, tenantId: string): Promise<string> {
const { data } = await supa
.from('tenant_members')
.select('user_id')
.eq('tenant_id', tenantId)
.in('role', ['tenant_admin', 'clinic_admin'])
.eq('status', 'active')
.limit(1)
.maybeSingle()
return (data?.user_id as string) ?? '00000000-0000-0000-0000-000000000000'
}
supabase/functions/evolution-whatsapp-inbound/index.ts
+17 -2
View File
@@ -23,6 +23,7 @@ import {
buildThreadKey,
detectOptoutKeyword,
maybeOptIn,
maybeProcessBot,
maybeSendAutoReply,
registerOptout,
type SendFn
@@ -461,12 +462,26 @@ Deno.serve(async (req: Request) => {
}
}
let botResult: { processed: boolean; status?: string; step?: number; reason?: string } | null = null
if (optoutAction !== 'out') {
const threadKey = buildThreadKey(patientId, fromPhone)
// Bot de triagem tem precedência sobre auto-reply: se o bot processou
// a inbound (iniciou sessão ou avançou step), não manda auto-reply
// pra evitar resposta duplicada.
try {
autoReplyResult = await maybeSendAutoReply(supabase, tenantId, threadKey, fromPhone, 'evolution', sendFn)
botResult = await maybeProcessBot(supabase, tenantId, threadKey, patientId, fromPhone, cleanBody, sendFn)
} catch (err) {
console.error('[auto-reply] unexpected error:', err)
console.error('[bot] unexpected error:', err)
}
if (!botResult?.processed) {
try {
autoReplyResult = await maybeSendAutoReply(supabase, tenantId, threadKey, fromPhone, 'evolution', sendFn)
} catch (err) {
console.error('[auto-reply] unexpected error:', err)
}
}
}
}
supabase/functions/twilio-whatsapp-inbound/index.ts
+24 -1
View File
@@ -25,6 +25,7 @@ import {
buildThreadKey,
detectOptoutKeyword,
maybeOptIn,
maybeProcessBot,
maybeSendAutoReply,
makeTwilioCreditedSendFn,
registerOptout,
@@ -181,8 +182,30 @@ Deno.serve(async (req: Request) => {
}
}
// 3) Auto-reply fora do horario (so se nao foi opt-out)
// 3) Bot de triagem (tem precedência sobre auto-reply)
let botProcessed = false
if (optoutAction !== 'out') {
const threadKey = buildThreadKey(patientId, from)
const botSendFn = makeTwilioCreditedSendFn(
supabase,
tenantId,
channel as unknown as TwilioChannel,
'Bot de triagem WhatsApp'
)
const botRes = await maybeProcessBot(
supabase,
tenantId,
threadKey,
patientId,
from,
body,
botSendFn
)
botProcessed = !!botRes.processed
}
// 4) Auto-reply fora do horario (só se não foi opt-out nem bot)
if (optoutAction !== 'out' && !botProcessed) {
const threadKey = buildThreadKey(patientId, from)
const arSendFn = makeTwilioCreditedSendFn(
supabase,