Reactions for your Discord agent.

import { createHash } from "node:crypto";

export const REACTIONS = [
  "👍", "❤️", "😂", "🎉", "😮", "😢",
  "🤔", "🔥", "💀", "🙌", "👀", "💯",
];

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 = REACTIONS, 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;
}

export type DiscordReaction = { id: string; description: string; emoji: string };
export const DISCORD_REACTIONS: DiscordReaction[] = [
  { id: "approve", description: "Agreement or acknowledgement.", emoji: "👍" },
  { id: "celebrate", description: "Celebrate an achievement or good news.", emoji: "🎉" },
  { id: "laugh", description: "Something funny, when laughter fits the context.", emoji: "😂" },
];

type DiscordInput = Omit<ReactionInput, "eventId" | "message" | "reactions"> & {
  botId: string; channelId: string; messageId: string; text: string;
  reactions?: DiscordReaction[];
};

// Pass a normal user message from your existing Discord bot's message handler.
export async function reactOnDiscord({
  botId, channelId, messageId, text, agent, context = [],
  reactions = DISCORD_REACTIONS, frequency = "balanced",
}: DiscordInput) {
  const token = process.env.DISCORD_BOT_TOKEN;
  if (!token) throw new Error("Set DISCORD_BOT_TOKEN on your server.");
  if (!reactions.length) return;
  const reaction = await chooseReaction({
    eventId: `discord:${botId}:${channelId}:${messageId}`,
    message: text, agent, context, frequency,
    reactions: reactions.map(({ id, description }) => ({ id, description })),
  });
  if (reaction === "none") return;
  const emoji = reactions.find(({ id }) => id === reaction)!.emoji;
  // Unicode emoji or custom name:id, not Discord's <:name:id> display markup.
  const response = await fetch(
    `https://discord.com/api/v10/channels/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(emoji)}/@me`,
    {
      method: "PUT",
      headers: { Authorization: `Bot ${token}` },
      signal: AbortSignal.timeout(5000),
    },
  );
  if (!response.ok) throw new Error(`Discord: HTTP ${response.status}`);
  // Discord returns 204 with no JSON body.
}

// Inside your existing MESSAGE_CREATE worker, using the raw message payload.
// botId is the authenticated bot user's ID; channel/message IDs stay strings.
if (message.author.bot || message.webhook_id || message.author.id === botId ||
    ![0, 19].includes(message.type) || !message.content?.trim()) return;

const reactionTask = reactOnDiscord({
  botId, channelId: message.channel_id, messageId: message.id,
  text: message.content, agent: agentPersonality, context: recentMessages,
  frequency: "balanced",
}).catch(() => console.error("Reaction failed; reply continues."));

const replyTask = Promise.resolve().then(() => replyToDiscord(message));
const [, reply] = await Promise.allSettled([reactionTask, replyTask]);
if (reply.status === "rejected") throw reply.reason;