Messaging Bots

from praisonaiagents import Agent

agent = Agent(name="messaging-bot", instructions="Handle messages on Telegram, Slack, and Discord.")
agent.start("Reply to the user's greeting with a helpful welcome message.")

from praisonaiagents import Agent
from praisonai.bots import Bot

agent = Agent(name="assistant", instructions="Help users")
bot = Bot(
    "slack",
    agent=agent,
    config={
        "outbound_resilience": {
            "max_attempts": 5,
            "dlq_path": "~/.praisonai/state/outbound-dlq.json",
        }
    },
)
bot.run()

from praisonaiagents import Agent
from praisonai.bots import TelegramBot

agent = Agent(
    name="vision-bot",
    instructions="Describe and answer questions about images and documents.",
    llm="gpt-4o",
)

bot = TelegramBot(token="your-telegram-bot-token", agent=agent)

import asyncio
asyncio.run(bot.start())

from praisonaiagents import Agent
from praisonai.bots import Bot

# Zero config — gets search_web, schedule_*, memory, learning, and auto-approval
agent = Agent(name="assistant", instructions="Help the user")
bot = Bot("telegram", agent=agent)
bot.run()

# Same result — no YAML tool list needed
praisonai bot telegram --token $TELEGRAM_BOT_TOKEN

from praisonaiagents import BotConfig

config = BotConfig(
    token="bot-token",              # Bot authentication token
    webhook_url=None,               # Webhook URL (optional)
    command_prefix="/",             # Command prefix
    mention_required=True,          # Require @mention in groups
    typing_indicator=True,          # Show typing indicator
    max_message_length=4096,        # Max message length
    allowed_users=[],               # Empty list → unknown_user_policy decides (default deny)
    allowed_channels=[],            # Allowed channel IDs
    reply_in_thread=False,          # Reply in threads (default: inline)
    thread_threshold=500,           # Auto-thread if response > N chars (0 = disabled)
    group_policy="mention_only",    # Group chat policy: respond_all, mention_only, command_only, observe
    allow_silence=True,             # Agent may return NO_REPLY to stay silent
    auto_approve_tools=True,        # Auto-approve safe tool executions (default: True for chat bots)
    unknown_user_policy="pair",     # "deny" (default) | "pair" | "allow"
    owner_user_id="123456789",      # Platform-specific owner ID (Telegram numeric, Discord snowflake, Slack U-id)
)

from praisonaiagents.bots import BotConfig

config = BotConfig(allowed_users=["telegram:123456"])

config.is_explicitly_allowed("telegram:123456")  # True — on the allowlist
config.is_explicitly_allowed("telegram:99999")   # False — policy decides next

bot.register_command("ping", my_handler, description="Check latency")

# Start Telegram bot
praisonai bot telegram --token $TOKEN

# Start Discord bot
praisonai bot discord --token $TOKEN

# Start Slack bot  
praisonai bot slack --token $TOKEN --app-token $APP_TOKEN

# Start WhatsApp bot (webhook server)
praisonai bot whatsapp --token $TOKEN --phone-id $PHONE_ID --verify-token $VERIFY

# With agent configuration
praisonai bot telegram --token $TOKEN --agent agents.yaml

from praisonaiagents import Agent
from praisonai.bots import WhatsAppBot

agent = Agent(name="assistant", instructions="You are a helpful bot")

bot = WhatsAppBot(
    mode="web",
    agent=agent,
    allowed_numbers=["1234567890", "9876543210"],
    allowed_groups=["120363123456@g.us"],
    respond_to_all=False,  # default
)

import asyncio
asyncio.run(bot.start())

platform: whatsapp
mode: web

respond_to:
  - "1234567890"
  - "9876543210"
respond_to_groups:
  - "120363123456@g.us"
respond_to_all: false

agent:
  name: "My Assistant"
  instructions: "You are a helpful AI assistant."
  llm: "gpt-4o-mini"

praisonai bot start --config bot.yaml

version: '3.8'
services:
  slack-bot:
    image: python:3.11-slim
    environment:
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
      SLACK_APP_TOKEN: ${SLACK_APP_TOKEN}
    command: >
      bash -c "pip install praisonai slack-bolt slack-sdk &&
               praisonai bot slack"
    restart: unless-stopped

agents:
  personal:
    name: "Personal Assistant"
    instructions: "You are a helpful personal assistant."
    llm: "gpt-4o-mini"
  support:
    name: "Support Agent"
    instructions: "You are a customer support agent."
    llm: "gpt-4o-mini"

channels:
  telegram:
    token: "${TELEGRAM_BOT_TOKEN}"
    session:
      max_history: 100
      reset:
        mode: idle
        idle_minutes: 60
      compaction:
        enabled: true
        strategy: summarize
        keep_recent: 10
    routing:
      dm: "personal"
      group: "support"
      default: "personal"
  discord:
    token: "${DISCORD_BOT_TOKEN}"
    routing:
      dm: "personal"
      channel: "support"
      default: "support"
  slack:
    token: "${SLACK_BOT_TOKEN}"
    app_token: "${SLACK_APP_TOKEN}"
    auto_approve_tools: true        # NEW (default: true for chat bots)
    # default_tools:                # NEW — override the safe tool list per channel
    #   - search_web
    #   - store_memory
    routing:
      dm: "personal"
      channel: "support"
      default: "support"
  whatsapp:
    token: "${WHATSAPP_ACCESS_TOKEN}"
    phone_number_id: "${WHATSAPP_PHONE_NUMBER_ID}"
    verify_token: "${WHATSAPP_VERIFY_TOKEN}"
    webhook_port: 8080
    routing:
      dm: "personal"
      default: "personal"

  # Or use WhatsApp Web mode (no tokens needed):
  # whatsapp:
  #   mode: web
  #   routing:
  #     dm: "personal"
  #     default: "personal"

praisonai gateway --config gateway.yaml

agents:
  cfo:
    instructions: "You are a CFO agent specialized in financial analysis and budget planning."
    model: gpt-4o-mini
  ops:
    instructions: "You are an ops agent specialized in system monitoring and infrastructure."
    model: gpt-4o-mini

channels:
  telegram_cfo:
    platform: telegram
    token: ${TELEGRAM_CFO_BOT_TOKEN}
    routes:
      default: cfo
  telegram_ops:
    platform: telegram  
    token: ${TELEGRAM_OPS_BOT_TOKEN}
    routes:
      default: ops

platform: telegram
token: "${TELEGRAM_BOT_TOKEN}"

agent:
  name: "My Assistant"
  instructions: "You are a helpful AI assistant."
  llm: "gpt-4o-mini"
  memory: true
  web_search: true
  tools: [search_web]

praisonai bot start --config bot.yaml

agents:
  searcher:
    name: Researcher
    role: Web Researcher
    goal: Search the web for relevant information on the given topic
    instructions: |
      Search the web thoroughly for information on the user's query.
      Return comprehensive, accurate results with sources.
    tools:
      - search_web

  summarizer:
    name: Summarizer
    role: Content Summarizer
    goal: Create clear, concise summaries of information
    instructions: |
      Take the research findings and create a well-structured summary.
      Highlight key points and insights.
      Keep it concise but informative.

from praisonaiagents import Agent
from praisonaiagents import BotConfig
from praisonai.bots import Bot

agent = Agent(name="cfo", instructions="Answer finance questions using the company knowledge base.")

# Defaults shown for clarity — you get all this without setting anything.
bot = Bot("telegram", agent=agent, config=BotConfig(
    typing_indicator=True,   # renews every 4s
    ack_emoji="⏳",          # instant reaction at T+0
    done_emoji="✅",         # swaps in when the reply lands
))
bot.run()

channels:
  telegram:
    token: ${TELEGRAM_BOT_TOKEN}
    session:
      max_history: 100
      reset:
        mode: both
        idle_minutes: 60
        at_hour: 4

from praisonaiagents import Agent
from praisonaiagents import BotConfig
from praisonai.bots import Bot

agent = Agent(name="assistant", instructions="Be helpful")
config = BotConfig(session_ttl=86400)  # Reap sessions older than 24h

bot = Bot("telegram", agent=agent, config=config)
bot.run()

from praisonaiagents import Agent
from praisonai.bots import Bot, SlackApproval

agent = Agent(
    name="assistant",
    instructions="You are a helpful assistant.",
    approval=SlackApproval(channel="#approvals")  # Approvals go to Slack
)

bot = Bot("telegram", agent=agent)  # Users talk via Telegram
bot.run()