npm install ai @ai-sdk/xai @ai-sdk/anthropic zod
npm install grammy          # Telegram
# WhatsApp Cloud API is plain REST - no SDK needed

// lib/bot/history.ts
import type { ModelMessage } from "ai";

const VERBATIM_TURNS = 12;

export async function buildMessages(conversationId: string): Promise<ModelMessage[]> {
  const convo = await getConversation(conversationId);
  const recent = await getRecentMessages(conversationId, VERBATIM_TURNS);

  const messages: ModelMessage[] = [];
  if (convo.summary) {
    messages.push({
      role: "user",
      content: `[Earlier in this conversation]\n${convo.summary}`,
    });
  }
  for (const m of recent) {
    messages.push({ role: m.role, content: m.content } as ModelMessage);
  }
  return messages;
}

// lib/bot/tools.ts
import { tool } from "ai";
import { z } from "zod";

export const botTools = {
  checkOrder: tool({
    description: "Look up an order by its reference for the CURRENT customer.",
    inputSchema: z.object({ reference: z.string().min(4) }),
    // The model asks. Your code decides - and scopes to the caller.
    execute: async ({ reference }, { experimental_context }) => {
      const { chatId } = experimental_context as { chatId: string };
      const order = await db.order.findFirst({ where: { reference, chatId } });
      return order ?? { error: "not_found" };
    },
  }),

  handoffToHuman: tool({
    description: "Escalate to a human agent when the customer asks or is upset.",
    inputSchema: z.object({ reason: z.string() }),
    execute: async ({ reason }, { experimental_context }) => {
      const { chatId } = experimental_context as { chatId: string };
      await notifyAgents({ chatId, reason });
      return { escalated: true };
    },
  }),
};

// lib/bot/provider.ts - one interface, two providers
import { xai } from "@ai-sdk/xai";
import { anthropic } from "@ai-sdk/anthropic";
import { generateText, stepCountIs } from "ai";

const PRIMARY = xai("grok-4.6");
const FALLBACK = anthropic("claude-sonnet-5");

export async function generateReply(args: Omit<Parameters<typeof generateText>[0], "model">) {
  try {
    return await withBackoff(() => generateText({ model: PRIMARY, ...args }));
  } catch (err) {
    // Same tools, same schema, same persona - only the brain changes
    console.warn("grok failed, falling back to claude", err);
    return generateText({ model: FALLBACK, ...args });
  }
}