Build a Telegram AI agent with memory and a tool

create table chat_messages (
  id bigint generated always as identity primary key,
  chat_id bigint not null,
  role text not null check (role in ('user', 'assistant')),
  content text not null,
  created_at timestamptz not null default now()
);
create index on chat_messages (chat_id, created_at desc);

create table processed_updates (
  update_id bigint primary key,
  created_at timestamptz not null default now()
);

curl "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/deleteWebhook"
curl "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/getUpdates"

import { timingSafeEqual } from "node:crypto";
import { runAgent } from "./agent";
import { claimUpdate } from "./store";

const TELEGRAM = "https://api.telegram.org/bot" + process.env.TELEGRAM_BOT_TOKEN;

function secretMatches(header: string | null): boolean {
  const expected = Buffer.from(process.env.TELEGRAM_WEBHOOK_SECRET ?? "");
  const given = Buffer.from(header ?? "");
  return expected.length > 0 && given.length === expected.length && timingSafeEqual(given, expected);
}

async function sendMessage(chatId: number, text: string): Promise<void> {
  const res = await fetch(TELEGRAM + "/sendMessage", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ chat_id: chatId, text: text.slice(0, 4096) }),
  });
  if (!res.ok) throw new Error("sendMessage failed with status " + res.status);
}

export async function POST(req: Request): Promise<Response> {
  if (!secretMatches(req.headers.get("x-telegram-bot-api-secret-token"))) {
    return new Response("forbidden", { status: 403 });
  }
  const update = await req.json();
  const chatId: number | undefined = update.message?.chat?.id;
  const text: string | undefined = update.message?.text;
  if (!chatId || !text) return new Response("ok");
  // Insert-or-skip on update_id, so Telegram's retries never double-reply.
  if (!(await claimUpdate(update.update_id))) return new Response("ok");

  try {
    const reply = await runAgent(chatId, text.slice(0, 2000));
    await sendMessage(chatId, reply);
  } catch (error) {
    console.error("telegram agent failed", { updateId: update.update_id, error: String(error) });
    await sendMessage(chatId, "Sorry, something went wrong on our side. A person will follow up here.");
  }
  return new Response("ok");
}

import { loadHistory, saveTurn } from "./store";
import { getOrderStatus } from "./orders";

const SYSTEM =
  "You answer order questions for Brightline Supplies on Telegram. " +
  "Use get_order_status for any order number. Never guess a status or date. " +
  "If the user needs a refund, a complaint handled or anything you can't look up, " +
  "say a person will follow up. Keep replies under 80 words.";

const tools = [
  {
    name: "get_order_status",
    description: "Look up the current status and delivery estimate of one order. Call it only with an order number the user gave.",
    input_schema: {
      type: "object",
      properties: { order_number: { type: "string", description: "Order number such as A-10422" } },
      required: ["order_number"],
    },
  },
];

type Block = { type: string; text?: string; id?: string; input?: { order_number?: string } };

async function callClaude(messages: unknown[]) {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": process.env.ANTHROPIC_API_KEY ?? "",
      "anthropic-version": "2026-10-21",
      "content-type": "application/json",
    },
    body: JSON.stringify({ model: "claude-sonnet-5-5", max_tokens: 1024, system: SYSTEM, tools, messages }),
  });
  if (!res.ok) throw new Error("Claude API error " + res.status);
  return (await res.json()) as { stop_reason: string; content: Block[] };
}

export async function runAgent(chatId: number, userText: string): Promise<string> {
  const messages: unknown[] = [...(await loadHistory(chatId, 20)), { role: "user", content: userText }];
  for (let round = 0; round < 4; round++) {
    const response = await callClaude(messages);
    messages.push({ role: "assistant", content: response.content });
    if (response.stop_reason !== "tool_use") {
      const reply = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
      await saveTurn(chatId, userText, reply);
      return reply;
    }
    const results = [];
    for (const block of response.content) {
      if (block.type !== "tool_use") continue;
      const output = await getOrderStatus(block.input?.order_number ?? "");
      results.push({ type: "tool_result", tool_use_id: block.id, content: JSON.stringify(output) });
    }
    messages.push({ role: "user", content: results });
  }
  throw new Error("agent hit the tool-round limit");
}

curl "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/setWebhook" \
  --data-urlencode "url=https://your-app.example.com/api/telegram" \
  --data-urlencode "secret_token=$TELEGRAM_WEBHOOK_SECRET" \
  --data-urlencode 'allowed_updates=["message"]'

curl "https://api.telegram.org/bot$TELEGRAM_BOT_TOKEN/getWebhookInfo"