Examples

unzip smeet-bot-examples-python.zip
cd smeet-bot-examples/python
python3 -m venv .venv
. .venv/bin/activate              # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env              # then fill in .env

unzip smeet-bot-examples-node.zip
cd smeet-bot-examples/node
cp .env.example .env              # then fill in .env
npm run echo                      # also: faq, status, notify, files, poller, webhook, mock

SMEET_BOT_TOKEN=sbt1_EXAMPLE_REPLACE_WITH_YOUR_TOKEN
SMEET_API_URL=https://messenger.scrile.com/bot-api/v1
SMEET_WEBHOOK_SECRET=EXAMPLE_REPLACE_WITH_YOUR_WEBHOOK_SECRET

python echo_bot.py                # or: node echo_bot.mjs

async function handle(client, update) {
  // Only new messages matter here. Button presses, edits (an edit is a correction, not a new
  // command), access changes and update types added in later API versions are ignored.
  if (update.type !== 'message') return;
  const message = update.message;
  await client.sendMessage(
    { chat_id: message.chat.id, text: replyFor(message) },
    // Same event, same key: a repeated update never produces a second reply.
    { idempotencyKey: smeet.actionKey(update.event_id, 'reply') },
  );
  log.info(`Replied to update ${update.update_id} in chat ${message.chat.id}`);
}

python faq_bot.py                 # or: node faq_bot.mjs

async function handle(client, update) {
  const eventId = update.event_id;
  if (update.type === 'message') {
    const chatId = update.message.chat.id;
    await client.sendMessage({ chat_id: chatId, text: MENU_TEXT, reply_markup: menuMarkup() },
      { idempotencyKey: smeet.actionKey(eventId, 'menu') });
    log.info(`Menu sent to chat ${chatId}`);
    return;
  }
  if (update.type !== 'callback_query') return; // access changes, edits and unknown types need no answer here

  const query = update.callback_query;
  const chatId = query.message.chat.id;
  const data = query.data;
  let text;
  let markup;
  if (data === 'menu') {
    [text, markup] = [MENU_TEXT, menuMarkup()];
  } else if (data.startsWith('faq:') && Object.hasOwn(FAQ, data.slice('faq:'.length))) {
    const [title, answer] = FAQ[data.slice('faq:'.length)];
    [text, markup] = [`${title}\n\n${answer}`, BACK_MARKUP];
  } else {
    // A button from an older version of this bot: say so instead of leaving the user waiting.
    await client.answerCallbackQuery({ callback_query_id: query.id, text: 'This button is out of date. Send /start.' },
      { idempotencyKey: smeet.actionKey(eventId, 'answer') });
    return;
  }

  // Answer the press first: it stops the waiting indicator in the app. Then edit the message.
  await client.answerCallbackQuery({ callback_query_id: query.id }, { idempotencyKey: smeet.actionKey(eventId, 'answer') });
  await client.editMessageText({ chat_id: chatId, message_id: query.message.message_id, text, reply_markup: markup },
    { idempotencyKey: smeet.actionKey(eventId, 'edit') });
  log.info(`Button ${data} handled in chat ${chatId}`);
}

python status_bot.py run                           # keep this running
python status_bot.py notify A-1001 approved        # from your system, whenever a status changes

python file_bot.py                # or: node file_bot.mjs

def send_receipt(client: smeet.Client, chat_id: str, message_id: str, file_id: str) -> None:
    """Download a checked file and answer with a receipt file."""
    info = client.get_file(file_id)  # a ready file comes with download_path
    if info["status"] != "ready":
        log.info("File %s is %s, no receipt", file_id, info["status"])
        return
    content = client.download_file(info["download_path"], max_bytes=MAX_DOWNLOAD)
    receipt = "\n".join([
        "Receipt from the SMeet file bot example",
        f"File name: {info['file_name']}",
        f"Kind: {info['kind']}",
        f"Type: {info.get('mime_type', 'unknown')}",
        f"Size: {len(content)} bytes",
        f"SHA-256: {hashlib.sha256(content).hexdigest()}",
        "",
    ]).encode("utf-8")

    uploaded = client.upload_file(receipt, receipt_name(info["file_name"]), kind="document", mime_type="text/plain",
                                  idempotency_key=smeet.action_key(file_id, "receipt"))
    try:
        ready = smeet.wait_for_file(client, uploaded)  # our own upload is checked as well
    except TimeoutError:
        log.warning("The check of the receipt for file %s did not finish in time", file_id)
        return
    if ready["status"] != "ready":
        log.warning("The receipt for file %s was not accepted: %s", file_id, ready.get("reason") or ready["status"])
        return
    client.send_document(chat_id, ready["file_id"], caption=f"Receipt for {info['file_name']}",
                         reply_to_message_id=message_id,
                         idempotency_key=smeet.action_key(file_id, "receipt", "send"))
    log.info("Receipt for file %s sent to chat %s", file_id, chat_id)

python production_poller.py       # or: node production_poller.mjs

async function accept(client, update, consumerId, epoch) {
  const problem = checkUpdate(update);
  if (problem === null) return true;
  const updateId = update.update_id;
  if (typeof updateId !== 'string') {
    log.error(`An update without update_id was skipped: ${problem}`);
    return false;
  }
  try {
    // One key per delivery position: a replay of the same event gets a new update_id, and
    // rejecting it again must not collide with the first rejection.
    const key = smeet.actionKey(String(update.event_id || 'no-event-id'), 'reject', updateId);
    await client.rejectUpdate(
      { update_id: updateId, reason: `Cannot process this update: ${problem}`, consumer_id: consumerId, epoch },
      { idempotencyKey: key },
    );
    log.warn(`Update ${updateId} moved to FAILED: ${problem}`);
  } catch (error) {
    if (!(error instanceof smeet.ApiError) || error.code !== 'UPDATE_NOT_FOUND') throw error;
    log.info(`Update ${updateId} is no longer pending (${error.code}), nothing to reject`);
  }
  return false;
}

python webhook_bot.py             # or: node webhook_bot.mjs; listens on 127.0.0.1:8080, path /smeet/webhook

location = /smeet/webhook {
    proxy_pass http://127.0.0.1:8080;
}

SMEET_WEBHOOK_SECRET=local-secret python webhook_bot.py
curl -s -X POST localhost:8081/_mock/webhook \
  -d '{"url": "http://127.0.0.1:8080/smeet/webhook", "secret": "local-secret", "pending_policy": "keep"}'

cd smeet-bot-examples
python3 -m venv .venv && . .venv/bin/activate
pip install -r requirements-dev.txt
pytest -v run_examples_test.py    # the tests of the other language are skipped