Tapbacks for your iMessage agent.

import { createHash } from "node:crypto";

// These IDs belong to this example. Map them to your provider's Tapback names.
export const TAPBACKS = [
  { id: "love", description: "Heart: warmth, affection, or support." },
  { id: "like", description: "Thumbs-up: acknowledge or agree without implying a task is done." },
  { id: "dislike", description: "Thumbs-down: disagree with an idea or express disapproval; never dismiss distress." },
  { id: "laugh", description: "Ha ha: something funny. Laugh with the user, not at their distress." },
  { id: "emphasize", description: "Double exclamation: strong surprise, excitement, or emphasis." },
  { id: "question", description: "Question mark: confusion or uncertainty about what was said." },
];

export type ReactionOption = string | { id: string; description: string };
export type ContextMessage = { role: "user" | "assistant"; content: string; reaction?: string };
export type ReactionInput = {
  eventId: string; message: string; agent?: string;
  context?: ContextMessage[]; reactions?: ReactionOption[];
  frequency?: "reserved" | "balanced" | "expressive";
};

// Server only. eventId must identify this message across all your conversations.
export async function chooseReaction({
  eventId, message, agent, context = [], reactions = TAPBACKS, frequency = "balanced",
}: ReactionInput): Promise<string> {
  const key = process.env.EMOTE_API_KEY;
  if (!key) throw new Error("Set EMOTE_API_KEY on your server.");
  if (!eventId) throw new Error("A stable eventId is required.");

  const response = await fetch("https://useemote.com/v1/react", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${key}`,
      "Content-Type": "application/json",
      "Idempotency-Key": createHash("sha256").update(eventId).digest("hex"),
    },
    body: JSON.stringify({ message, agent, context, reactions, frequency }),
    signal: AbortSignal.timeout(3000),
  });
  if (!response.ok) throw new Error(`Emote: HTTP ${response.status}`);
  const reaction = await response.json();
  const allowed = reactions.map((option) => typeof option === "string" ? option : option.id);
  if (typeof reaction !== "string" || (reaction !== "none" && !allowed.includes(reaction))) {
    throw new Error("Unexpected Emote response.");
  }
  return reaction;
}

type IMessageInput = Omit<ReactionInput, "eventId" | "message"> & {
  accountId: string; chatId: string; messageId: string; text: string;
  sendTapback: (target: { chatId: string; messageId: string; kind: string }) => Promise<void>;
  isMessageActive: (target: { chatId: string; messageId: string }) => Promise<boolean>;
};

export async function reactOnIMessage({
  accountId, chatId, messageId, text, agent, context = [], frequency = "balanced", reactions = TAPBACKS,
  sendTapback, isMessageActive,
}: IMessageInput) {
  const startedAt = Date.now();
  const reaction = await chooseReaction({
    eventId: JSON.stringify(["imessage", accountId, chatId, messageId]),
    message: text, agent, context, frequency, reactions,
  });
  if (reaction === "none" || Date.now() - startedAt > 5000) return;
  if (!(await isMessageActive({ chatId, messageId }))) return;

  // Implement this callback using your provider. Preserve any message-part ID
  // in your adapter when the provider requires one to target a Tapback.
  await sendTapback({ chatId, messageId, kind: reaction });
}