Reactions for your Slack 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;
}

// Slack names, without surrounding colons. Add workspace custom emoji the same way.
export const SLACK_REACTIONS = [
  { id: "thumbsup", description: "Agreement or acknowledgement." },
  { id: "heart", description: "Warmth, appreciation, or support." },
  { id: "tada", description: "Celebrate an achievement or good news." },
  { id: "eyes", description: "Interest or attention to something worth looking at." },
];

type SlackInput = Omit<ReactionInput, "eventId" | "message" | "reactions"> & {
  teamId: string; botUserId: string; channel: string; timestamp: string; text: string;
  reactions?: { id: string; description: string }[];
};

// Call from your verified, deduplicated message worker, not the webhook response.
export async function reactOnSlack({
  teamId, botUserId, channel, timestamp, text, agent, context = [],
  reactions = SLACK_REACTIONS, frequency = "balanced",
}: SlackInput) {
  const token = process.env.SLACK_BOT_TOKEN;
  if (!token) throw new Error("Set SLACK_BOT_TOKEN on your server.");
  if (!reactions.length) return;
  const reaction = await chooseReaction({
    eventId: `slack:${teamId}:${botUserId}:${channel}:${timestamp}`,
    message: text, agent, context, reactions, frequency,
  });
  if (reaction === "none") return;

  const response = await fetch("https://slack.com/api/reactions.add", {
    method: "POST",
    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
    body: JSON.stringify({ channel, timestamp, name: reaction }),
    signal: AbortSignal.timeout(5000),
  });
  if (!response.ok) throw new Error(`Slack: HTTP ${response.status}`);
  const result = await response.json();
  // Slack can return HTTP 200 for API errors. A repeated reaction is already done.
  if (result.ok !== true && result.error !== "already_reacted") {
    throw new Error(`Slack: ${result.error ?? "Unexpected response"}`);
  }
}

// Inside your verified, deduplicated Events API worker.
// event is the message event from the envelope; teamId is envelope.team_id.
if (event.type !== "message" || event.subtype || event.bot_id ||
    !event.user || event.user === botUserId || !event.text?.trim()) return;

const reactionTask = reactOnSlack({
  teamId, botUserId, channel: event.channel,
  timestamp: event.ts, // Keep the original string, including its decimals.
  text: event.text, agent: agentPersonality, context: recentMessages,
  frequency: "balanced",
}).catch(() => console.error("Reaction failed; reply continues."));

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