Enviando mensagens e blocos avançados
Texto simples, markdown e JSON do Block Kit — formatação de mensagens do Slack.
Enviando mensagens e blocos avançados é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.
Mensagens de texto simples com say()
A maneira mais simples de publicar uma mensagem no Slack é say(text). O texto aceita mrkdwn — a variante de markdown do Slack. Use *bold*, _italic_, ~strike~, `code` e menções como <@USERID>.
@app.event('app_mention')
def handle_mention(event, say):
user = event['user']
# Simple text response with mrkdwn formatting
say(
text=(
f'Hello <@{user}>!\n'
'*Agent Report:*\n'
'- Tasks completed: `42`\n'
'- Errors: `0`\n'
'- _Runtime: 3.2 seconds_'
),
mrkdwn=True # enabled by default
)
# Slack mentions
say(f'<@{user}> your request is being processed')
say('Posting to <!channel>: all hands meeting tomorrow')Introdução ao Block Kit
O Block Kit é a estrutura de interface do Slack para criar mensagens avançadas e interativas. Em vez de texto simples, você compõe mensagens a partir de blocos tipados: section, header, divider, actions, context. Os blocos são passados como uma lista para o parâmetro blocks de say() ou chat_postMessage().
@app.event('app_mention')
def handle_mention(event, say):
blocks = [
{
'type': 'header',
'text': {'type': 'plain_text', 'text': 'Agent Status Report'}
},
{
'type': 'divider'
},
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': '*Status:* Running\n*Tasks:* 42 completed'
}
}
]
say(
text='Agent Status Report', # fallback for notifications
blocks=blocks
)Blocos de seção com campos de texto
O bloco de seção é o mais versátil. Ele pode exibir texto (mrkdwn ou plain_text), uma lista de pares de chave e valor ou um elemento acessório (botão, imagem ou menu de opções). Use fields para pares de chave e valor lado a lado — é ótimo para painéis.
def build_task_summary_blocks(tasks):
blocks = [
{
'type': 'header',
'text': {'type': 'plain_text', 'text': 'Daily Task Summary'}
},
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': f'Processed *{len(tasks)} tasks* today.'
}
},
{
'type': 'section',
'fields': [
{'type': 'mrkdwn', 'text': f'*Completed:*\n{sum(1 for t in tasks if t["status"]=="done")}'},
{'type': 'mrkdwn', 'text': f'*Failed:*\n{sum(1 for t in tasks if t["status"]=="error")}'},
{'type': 'mrkdwn', 'text': f'*Pending:*\n{sum(1 for t in tasks if t["status"]=="pending")}'},
{'type': 'mrkdwn', 'text': f'*Avg Time:*\n3.2s'}
]
}
]
return blocks
# --- demo ---
tasks = [
{'status': 'done'}, {'status': 'done'}, {'status': 'error'}, {'status': 'pending'}
]
blocks = build_task_summary_blocks(tasks)
for b in blocks:
print(b)
Blocos de cabeçalho e separador
Use blocos de cabeçalho para títulos grandes de seções e blocos separadores para criar separação visual. O bloco de cabeçalho aceita somente plain_text (não aceita mrkdwn). Combine-os para criar mensagens de relatório bem estruturadas.
def build_report_message(title, sections):
blocks = []
# Header
blocks.append({
'type': 'header',
'text': {'type': 'plain_text', 'text': title, 'emoji': True}
})
for section_title, content in sections:
# Divider between sections
blocks.append({'type': 'divider'})
# Section header as bold mrkdwn
blocks.append({
'type': 'section',
'text': {'type': 'mrkdwn', 'text': f'*{section_title}*\n{content}'}
})
return blocks
blocks = build_report_message(
title='Weekly Agent Report',
sections=[
('Emails Processed', '142 emails classified, 38 replies drafted'),
('Tasks Completed', '89 tasks completed, 3 failures logged')
]
)
# --- demo ---
for b in blocks:
print(b)
Blocos de ações com botões
Os blocos de ações contêm elementos interativos, como botões. Cada botão tem um action_id (usado para encaminhar cliques aos manipuladores), um text e um value opcional que transporta dados. Use style: 'primary' para a CTA principal e style: 'danger' para ações destrutivas.
def build_approval_message(task_id, task_description):
blocks = [
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': f'*Task ready for approval:*\n{task_description}'
}
},
{
'type': 'actions',
'elements': [
{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'Approve'},
'style': 'primary',
'action_id': 'approve_task',
'value': task_id
},
{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'Reject'},
'style': 'danger',
'action_id': 'reject_task',
'value': task_id
}
]
}
]
return blocks
# --- demo ---
blocks = build_approval_message('task_42', 'Deploy backend v2.3 to production')
for b in blocks:
print(b)
Blocos de contexto para metadados
Os blocos de contexto exibem um texto pequeno e secundário na parte inferior da mensagem — são perfeitos para metadados, como carimbos de data e hora, fontes ou informações da versão do agente. Eles aceitam mrkdwn e imagens (para ícones pequenos).
import datetime
def add_context_footer(blocks, agent_version='v1.2'):
timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M UTC')
blocks.append({
'type': 'context',
'elements': [
{
'type': 'mrkdwn',
'text': f'Generated by Agent {agent_version} | {timestamp}'
}
]
})
return blocks
# Full message with context footer
blocks = [
{
'type': 'section',
'text': {'type': 'mrkdwn', 'text': 'Analysis complete. See results below.'}
}
]
blocks = add_context_footer(blocks)
print(f'Message has {len(blocks)} blocks')mrkdwn em campos de texto
O mrkdwn do Slack aceita um subconjunto do markdown. As principais opções de formatação para mensagens de agentes são: negrito, itálico, código, links, menções a canais, menções a usuários e listas. Use-as para tornar o conteúdo gerado por IA legível no Slack.
def format_ai_response_as_mrkdwn(title, bullet_points, code_snippet=None):
lines = [f'*{title}*']
for point in bullet_points:
lines.append(f'• {point}')
if code_snippet:
lines.append(f'```{code_snippet}```') # code block
return '\n'.join(lines)
content = format_ai_response_as_mrkdwn(
title='Security Issues Found',
bullet_points=[
'SQL injection risk in `user_search()` function',
'Hardcoded API key in `config.py` line 42',
'Missing HTTPS on login endpoint'
],
code_snippet='SELECT * FROM users WHERE id = " + userId + "\n# ^ UNSAFE: use parameterized queries'
)
print(content)Mensagens efêmeras com respond()
As mensagens efêmeras ficam visíveis somente para o usuário que acionou a ação — não para os outros membros do canal. Use-as para atualizações de status, mensagens de erro e confirmações que não precisam poluir o canal. Elas estão disponíveis somente por meio de respond() (comandos de barra) ou chat_postEphemeral().
@app.command('/check-status')
def handle_status(ack, respond, body, client):
ack()
user_id = body['user_id']
channel_id = body['channel_id']
# Ephemeral: only the user who ran /check-status sees this
respond(
text='Checking agent status...',
response_type='ephemeral'
)
status = get_agent_status()
# Or use chat_postEphemeral for more control
client.chat_postEphemeral(
channel=channel_id,
user=user_id,
text=f'Agent Status: {status}',
blocks=build_status_blocks(status)
)Atualizando mensagens depois do envio
Depois de publicar uma mensagem, você pode atualizá-la usando client.chat_update() com o canal e o carimbo de data e hora da mensagem (ts). Isso é útil para atualizações de progresso: publique uma mensagem inicial “Processando...” e depois atualize-a com o resultado quando terminar.
@app.command('/analyze')
def handle_analyze(ack, say, respond, body, client):
ack()
text = body.get('text', '')
channel = body['channel_id']
# Post initial message
initial = client.chat_postMessage(
channel=channel,
text='Analyzing... this may take a moment.'
)
message_ts = initial['ts']
# Do the work
import threading
def do_work():
result = slow_ai_analysis(text)
# Update the original message with the result
client.chat_update(
channel=channel,
ts=message_ts,
text=f'Analysis complete: {result}',
blocks=build_result_blocks(result)
)
threading.Thread(target=do_work, daemon=True).start()Publicando em canais específicos
Use client.chat_postMessage(channel=channel_id, text=...) para publicar em qualquer canal ao qual seu bot tenha acesso. Encontre os IDs dos canais na API do Slack ou clicando com o botão direito em um canal. Use conversations_list() para consultar canais por nome de forma programática.
def post_alert_to_channel(client, channel_name, alert_message):
# Look up channel ID by name
result = client.conversations_list(
types='public_channel,private_channel',
limit=200
)
channel_id = None
for ch in result['channels']:
if ch['name'] == channel_name:
channel_id = ch['id']
break
if not channel_id:
print(f'Channel #{channel_name} not found')
return None
# Post the alert
response = client.chat_postMessage(
channel=channel_id,
text=alert_message,
unfurl_links=False, # don't expand URLs
unfurl_media=False
)
print(f'Posted to #{channel_name}: ts={response["ts"]}')
return response
# --- demo: minimal stand-in for the Slack client ---
class _FakeClient:
def conversations_list(self, **kwargs):
return {'channels': [{'name': 'alerts', 'id': 'C123'}, {'name': 'general', 'id': 'C456'}]}
def chat_postMessage(self, **kwargs):
print(f"[slack] postMessage to {kwargs['channel']}: {kwargs['text']}")
return {'ts': '1699999999.000100'}
post_alert_to_channel(_FakeClient(), 'alerts', 'Disk usage above 90% on web-1')
Padrão de função construtora de mensagens do Block Kit
Use uma função de construção que aceite dados e retorne uma lista de blocos. Isso separa a formatação das mensagens da lógica de negócio e torna seus blocos reutilizáveis em diferentes manipuladores de eventos.
def build_alert_blocks(level, title, details, link=None):
level_emoji = {'info': ':information_source:',
'warning': ':warning:', 'error': ':x:'}.get(level, '')
blocks = [
{
'type': 'header',
'text': {'type': 'plain_text', 'text': f'{level_emoji} {title}'}
},
{
'type': 'section',
'text': {'type': 'mrkdwn', 'text': details}
}
]
if link:
blocks.append({
'type': 'actions',
'elements': [{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'View Details'},
'url': link,
'action_id': 'view_details'
}]
})
import datetime
blocks.append({
'type': 'context',
'elements': [{'type': 'mrkdwn',
'text': datetime.datetime.now().strftime('%Y-%m-%d %H:%M UTC')}]
})
return blocks
# --- demo ---
blocks = build_alert_blocks('warning', 'High latency', 'p95 latency is 3.2s', link='https://dash.example.com')
for b in blocks:
print(b)
Verificação rápida: tipos de blocos
Teste sua compreensão sobre o Block Kit do Slack.
Recapitulação de mensagens avançadas
Agora seu agente pode publicar mensagens profissionais e interativas no Slack:
- say(text) — texto mrkdwn simples; aceita *bold*, _italic_, `code` e menções
- say(blocks=[...]) — Block Kit para um layout estruturado
- cabeçalho — título grande de seção (somente plain_text)
- seção — corpo de texto com campos opcionais (grade de chave e valor) ou um acessório
- separador — linha de separação horizontal
- ações — contêiner para botões e elementos interativos
- contexto — texto pequeno de metadados na parte inferior
- respond(response_type='ephemeral') — mensagem visível somente para o usuário que acionou a ação
- chat_update(ts=...) — atualiza uma mensagem publicada anteriormente com novo conteúdo
Perguntas Frequentes
A aula “Enviando mensagens e blocos avançados” é grátis?
Sim — o texto completo de “Enviando mensagens e blocos avançados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.
O que vou aprender em “Enviando mensagens e blocos avançados”?
Texto simples, markdown e JSON do Block Kit — formatação de mensagens do Slack. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Agents?
Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Enviando mensagens e blocos avançados”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Agents?
Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Fundamentos do Slack Bolt SDK
- Ouvindo eventos e comandos de barra
- Enviando mensagens e blocos avançados
- Criando um bot de notificações para equipes