@finalai/final-agent-provider 0.6.3 → 0.7.0

package/dist/modules/channels/slack.mjs

@@ -0,0 +1,1134 @@
+import {
+  defineChannel,
+  packageRef,
+  jsonValueSchema,
+  principalRefSchema
+} from "@finalai/agent-provider";
+import * as z from "zod";
+import {
+  mirrorReceiptKey,
+  settleMirrorReaction,
+  shareReplyReceipt
+} from "./reply-receipts.mjs";
+import { emojiToName, nameToEmoji } from "gemoji";
+import {
+  channelBaseUrl,
+  addSharedReaction,
+  removeSharedReaction,
+  providerPlaceKey,
+  confirmOAuth,
+  deliveryRetention,
+  decisionChoices,
+  decisionSummary,
+  externalKey,
+  freshTimestamp,
+  inTenant,
+  providerOriginSchema,
+  parseJson,
+  personFor,
+  receivePersonMessage,
+  receipt,
+  refString,
+  responseJson,
+  startOAuth,
+  stateKey,
+  takeOAuth,
+  textOf,
+  completionText,
+  verifyHmac
+} from "./channel-utils.mjs";
+const configSchema = z.object({
+  baseUrl: z.string().url().optional(),
+  history: z.union([z.literal("none"), z.literal("linked-members")]).default("none")
+});
+const envelopeSchema = z.object({
+  type: z.string().optional(),
+  team_id: z.string().optional(),
+  enterprise_id: z.string().nullish(),
+  event_id: z.string().optional(),
+  event: z.record(z.string(), jsonValueSchema).optional(),
+  challenge: z.string().optional()
+});
+const messageSchema = z.object({
+  type: z.string(),
+  subtype: z.string().optional(),
+  user: z.string().optional(),
+  channel: z.string().optional(),
+  channel_type: z.string().optional(),
+  text: z.string().optional(),
+  ts: z.string().optional(),
+  thread_ts: z.string().optional(),
+  bot_id: z.string().optional()
+});
+const slackEmoji = (emoji) => {
+  const name = emoji.replace(/^:|:$/g, "");
+  if (/^[a-z0-9_+-]+(?:::skin-tone-[2-6])?$/i.test(name)) return name;
+  const modifiers = [...emoji].filter((character) => /\p{Emoji_Modifier}/u.test(character));
+  if (modifiers.length > 1) return null;
+  const base = emoji.replace(/\p{Emoji_Modifier}/gu, "");
+  const alias = (Object.hasOwn(emojiToName, base) ? emojiToName[base] : void 0) ?? emojiToName[base + "\uFE0F"] ?? emojiToName[base.replace(/\ufe0f/g, "")];
+  if (typeof alias !== "string") return null;
+  const modifier = modifiers[0]?.codePointAt(0);
+  return alias + (modifier == null ? "" : `::skin-tone-${modifier - 127993}`);
+};
+const finalEmoji = (name) => {
+  const match = /^(.+?)(?:::skin-tone-([2-6]))?$/.exec(name);
+  if (match == null || match[1] == null) return `:${name}:`;
+  const emoji = Object.hasOwn(nameToEmoji, match[1]) ? nameToEmoji[match[1]] : void 0;
+  if (emoji == null) return `:${name}:`;
+  if (match[2] == null) return emoji;
+  const characters = [...emoji];
+  characters.splice(1, 0, String.fromCodePoint(127993 + Number(match[2])));
+  return characters.join("");
+};
+const safeSlackText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const slackResponseSchema = z.looseObject({ ok: z.boolean(), error: z.string().optional() });
+const api = async (ctx, method, body) => {
+  const app = await ctx.credentials.app({ tenant: ctx.origin?.place.tenant });
+  const read = ["users.info", "conversations.history", "conversations.replies"].includes(method);
+  const url = new URL(`https://slack.com/api/${method}`);
+  if (read) {
+    for (const [key, value] of Object.entries(body))
+      if (value != null)
+        url.searchParams.set(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+  const data = await responseJson(
+    await ctx.credentials.fetch(url, {
+      method: read ? "GET" : "POST",
+      headers: {
+        authorization: `Bearer ${app.accessToken}`,
+        ...!read ? { "content-type": "application/json" } : {}
+      },
+      ...read ? {} : {
+        body: JSON.stringify({
+          ...body,
+          ...typeof body.text === "string" ? { text: safeSlackText(body.text) } : {}
+        })
+      }
+    })
+  );
+  const status = slackResponseSchema.parse(data);
+  const repeated = method === "reactions.add" && status.error === "already_reacted" || method === "reactions.remove" && status.error === "no_reaction" || method === "chat.delete" && status.error === "message_not_found" || method === "chat.update" && (status.error === "message_not_modified" || status.error === "message_not_found");
+  if (!status.ok && !repeated)
+    throw new Error(`Slack ${method}: ${status.error ?? "unknown error"}`, {
+      cause: { code: status.error ?? "unknown_error" }
+    });
+  return data;
+};
+const classifyMirrorReaction = async (cause) => {
+  const error = z.object({ code: z.string() }).safeParse(cause instanceof Error ? cause.cause : null);
+  if (!error.success) return "retry";
+  if (error.data.code === "message_not_found") return "missing";
+  return [
+    "missing_scope",
+    "not_in_channel",
+    "channel_not_found",
+    "no_permission",
+    "restricted_action",
+    "not_allowed_token_type",
+    "invalid_name",
+    "thread_locked",
+    "not_reactable",
+    "is_archived",
+    "team_access_not_granted",
+    "no_access",
+    "too_many_reactions",
+    "too_many_emoji",
+    "bad_timestamp"
+  ].includes(error.data.code) ? "unavailable" : "retry";
+};
+const responseUrl = (value) => {
+  if (value == null) return null;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname === "hooks.slack.com" && url.port === "" && url.username === "" && url.password === "" && /^\/(?:actions|commands|services)\//.test(url.pathname) ? url.href : null;
+  } catch {
+    return null;
+  }
+};
+const confirmDecision = async (args) => {
+  const { ctx, decisionId } = args;
+  const key = stateKey("slack-decision-confirmed", decisionId);
+  const prior = await ctx.store.get(key);
+  const metadata = z.object({ url: z.string() }).safeParse(await ctx.store.get(stateKey("slack-decision-message", decisionId)));
+  const url = metadata.success ? responseUrl(metadata.data.url) : null;
+  if (url != null && prior !== "replaced") {
+    try {
+      const response = await ctx.credentials.fetch(url, {
+        method: "POST",
+        redirect: "error",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          replace_original: true,
+          text: args.message ?? "This decision has been answered in Final.",
+          blocks: []
+        })
+      });
+      await response.text();
+      if (!response.ok) throw new Error("Slack approval confirmation unavailable.");
+      await ctx.store.set(key, "replaced", { ttlSeconds: 3600 });
+      return;
+    } catch {
+      ctx.log("Slack approval replacement unavailable.");
+    }
+  }
+  if (prior != null || args.channel == null || args.user == null) return;
+  try {
+    await api(ctx, "chat.postEphemeral", {
+      channel: args.channel,
+      user: args.user,
+      ...args.threadTs == null ? {} : { thread_ts: args.threadTs },
+      text: args.message ?? "This decision has been answered in Final."
+    });
+    await ctx.store.set(key, "notified", { ttlSeconds: 3600 });
+  } catch {
+    ctx.log("Slack approval confirmation unavailable.");
+  }
+};
+const slackUserSchema = z.object({
+  user: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    deleted: z.boolean().optional(),
+    enterprise_user: z.object({ id: z.string(), enterprise_id: z.string() }).optional(),
+    profile: z.object({ display_name: z.string().optional(), real_name: z.string().optional() }).optional()
+  })
+});
+const enterpriseTeamsSchema = z.object({
+  teams: z.array(z.string()).max(256),
+  overflow: z.boolean()
+});
+const proveTeam = async (ctx, team, enterprise) => {
+  await ctx.store.set(stateKey("slack-enterprise", team), enterprise);
+  const key = stateKey("slack-enterprise-teams", enterprise);
+  const saved = enterpriseTeamsSchema.safeParse(await ctx.store.get(key));
+  if (saved.success && (saved.data.overflow || saved.data.teams.includes(team))) return;
+  const teams = [...saved.success ? saved.data.teams : [], team];
+  await ctx.store.set(
+    key,
+    teams.length > 256 ? { teams: [], overflow: true } : { teams, overflow: false }
+  );
+};
+const revokeTeam = async (args) => {
+  const { ctx, team, reason } = args;
+  const alias = z.string().safeParse(await ctx.store.get(stateKey("slack-enterprise", team)));
+  const enterprise = args.enterprise ?? (alias.success ? alias.data : void 0);
+  await ctx.people.revoke({ tenant: team, reason });
+  if (enterprise != null && enterprise !== team) {
+    const key = stateKey("slack-enterprise-teams", enterprise);
+    const saved = enterpriseTeamsSchema.safeParse(await ctx.store.get(key));
+    const teams = saved.success ? saved.data.teams.filter((known) => known !== team) : [];
+    if (!saved.success || saved.data.overflow || teams.length === 0) {
+      await ctx.people.revoke({ tenant: enterprise, reason });
+      await ctx.store.set(key, { teams: [], overflow: false });
+    } else await ctx.store.set(key, { teams, overflow: false });
+  }
+  await ctx.store.set(stateKey("slack-enterprise", team), null);
+  await ctx.store.set(stateKey("slack-bot-user", team), null);
+};
+const principalFor = async (ctx, team, user) => {
+  const profile = slackUserSchema.parse(
+    await api(inTenant(ctx, team), "users.info", { user })
+  ).user;
+  if (profile.enterprise_user != null)
+    await proveTeam(ctx, team, profile.enterprise_user.enterprise_id);
+  if (profile.deleted === true)
+    await ctx.people.revoke({
+      principal: {
+        id: profile.enterprise_user?.id ?? profile.id,
+        tenant: profile.enterprise_user?.enterprise_id ?? team
+      },
+      reason: "deactivated"
+    });
+  return {
+    id: profile.enterprise_user?.id ?? profile.id,
+    tenant: profile.enterprise_user?.enterprise_id ?? team,
+    displayName: [profile.profile?.display_name, profile.profile?.real_name, profile.name, profile.id].find(
+      (name) => name != null && name.trim().length > 0
+    ) ?? profile.id
+  };
+};
+const placeFor = (message, tenant) => {
+  if (message.channel == null) return null;
+  const channel = {
+    kind: message.channel_type === "im" || message.channel.startsWith("D") ? "dm" : "channel",
+    id: message.channel,
+    tenant,
+    title: message.channel
+  };
+  return message.thread_ts == null ? channel : {
+    kind: "thread",
+    id: `${message.channel}:${message.thread_ts}`,
+    tenant,
+    parent: channel,
+    title: message.channel
+  };
+};
+const location = (ctx) => ({
+  channel: refString(ctx.origin.ref, "channel") ?? (ctx.origin.place.kind === "thread" ? ctx.origin.place.parent?.id ?? ctx.origin.place.id.split(":")[0] : ctx.origin.place.id),
+  thread_ts: refString(ctx.origin.ref, "threadTs") ?? refString(ctx.origin.ref, "ts") ?? (ctx.origin.place.kind === "thread" ? ctx.origin.place.id.split(":").at(-1) : null)
+});
+const botFor = async (ctx, tenant) => {
+  const key = stateKey("slack-bot-user", tenant);
+  const cached = z.string().safeParse(await ctx.store.get(key));
+  if (cached.success) return cached.data;
+  const bot = z.object({ user_id: z.string().optional() }).parse(await api(ctx, "auth.test", {})).user_id;
+  if (bot != null) await ctx.store.set(key, bot, deliveryRetention);
+  return bot;
+};
+const normalizedText = async (ctx, text, tenant) => {
+  const bot = await botFor(ctx, tenant);
+  return text.replace(/<@([A-Z0-9]+)>/g, (_match, id) => id === bot ? "" : `@${id}`).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").trim();
+};
+const replySchema = z.object({ ts: z.string() });
+const replyKey = (ctx, replyOf) => stateKey(
+  "slack-reply",
+  replyOf?.externalKey ?? refString(ctx.origin.ref, "externalKey") ?? ctx.origin.place.id,
+  replyOf?.turnId ?? ctx.turn.id
+);
+const postReply = async (ctx, text, final, key = replyKey(ctx)) => {
+  const { channel, thread_ts } = location(ctx);
+  if (channel == null) return;
+  const saved = z.object({
+    ts: z.string(),
+    updatedAt: z.number(),
+    final: z.boolean(),
+    text: z.string().optional()
+  }).safeParse(await ctx.store.get(key));
+  if (saved.success && saved.data.final) return;
+  if (saved.success && !final && Date.now() - saved.data.updatedAt < 1e3) {
+    await ctx.store.set(key, { ...saved.data, text: text.slice(0, 11500) }, deliveryRetention);
+    return;
+  }
+  const body = text.slice(0, 11500) + (text.length > 11500 ? "\nContinue in Final \u2192" : "");
+  if (body.length === 0) return;
+  const posted = await api(ctx, saved.success ? "chat.update" : "chat.postMessage", {
+    channel,
+    ...saved.success ? { ts: saved.data.ts } : thread_ts == null ? {} : { thread_ts },
+    text: body
+  });
+  if (saved.success && slackResponseSchema.parse(posted).error === "message_not_found") {
+    await ctx.store.set(key, null);
+    await postReply(ctx, text, final, key);
+    return;
+  }
+  const ts = saved.success ? saved.data.ts : replySchema.parse(posted).ts;
+  await ctx.store.set(
+    key,
+    { ts, updatedAt: Date.now(), final, text: text.slice(0, 11500) },
+    deliveryRetention
+  );
+  await ctx.store.set(
+    stateKey("slack-origin", ctx.origin.place.tenant ?? null, channel, ts),
+    jsonValueSchema.parse({
+      place: ctx.origin.place,
+      externalKey: refString(ctx.origin.ref, "externalKey") ?? ctx.origin.place.id,
+      turnId: ctx.turn.id
+    }),
+    deliveryRetention
+  );
+};
+const savedPartial = async (ctx) => {
+  const receipt2 = z.object({ text: z.string() }).safeParse(await ctx.store.get(replyKey(ctx)));
+  return receipt2.success ? receipt2.data.text : "";
+};
+const sharedReply = async (ctx, args) => {
+  const { channel, thread_ts } = location(ctx);
+  await shareReplyReceipt({
+    bindingId: ctx.binding.id,
+    store: ctx.store,
+    destination: stateKey(
+      "slack",
+      ctx.origin.place.tenant ?? null,
+      channel ?? null,
+      thread_ts ?? null
+    ),
+    messageIds: args.messageIds,
+    originKey: replyKey(ctx),
+    send: (key) => postReply(ctx, args.text, args.final, key),
+    removeDuplicate: async (receipt2, canonical) => {
+      const saved = replySchema.safeParse(receipt2);
+      const target = replySchema.safeParse(canonical);
+      if (saved.success && target.success && saved.data.ts !== target.data.ts && channel != null)
+        await api(ctx, "chat.delete", { channel, ts: saved.data.ts });
+    }
+  });
+};
+const slackChannel = (options = {}) => {
+  const config = configSchema.parse(options);
+  return defineChannel({
+    name: "slack",
+    config,
+    installed: packageRef("@finalai/final-agent-provider/channels/slack"),
+    credentials: { app: "slack" },
+    identity: {
+      kind: "redirect",
+      start: async (args, ctx) => {
+        const app = await ctx.credentials.appInfo();
+        return startOAuth(
+          {
+            ...args,
+            authorizeUrl: "https://slack.com/openid/connect/authorize",
+            clientId: app.clientId,
+            redirectUri: `${channelBaseUrl(config)}/b/${ctx.binding.id}/oauth/callback`,
+            scope: "openid profile"
+          },
+          ctx
+        );
+      }
+    },
+    places: {
+      kinds: ["dm", "channel", "thread"],
+      defaults: (place) => place.kind === "dm" ? { create: "direct-with-agent", replies: "origin", audience: "members" } : null
+    },
+    routes: [
+      {
+        method: "GET",
+        path: "/oauth/callback",
+        handler: async (ctx) => {
+          const saved = await takeOAuth(ctx.request, ctx);
+          if (saved == null)
+            return new Response("Invalid or expired link request", { status: 400 });
+          const app = await ctx.credentials.appInfo();
+          const token = z.object({ ok: z.literal(true), access_token: z.string() }).parse(
+            await responseJson(
+              await ctx.credentials.fetch("https://slack.com/api/openid.connect.token", {
+                method: "POST",
+                body: new URLSearchParams({
+                  client_id: app.clientId,
+                  client_secret: app.clientSecret,
+                  code: saved.code,
+                  redirect_uri: saved.redirectUri,
+                  grant_type: "authorization_code"
+                })
+              })
+            )
+          );
+          const identity = z.object({
+            ok: z.literal(true),
+            sub: z.string(),
+            "https://slack.com/team_id": z.string(),
+            "https://slack.com/user_id": z.string().optional()
+          }).parse(
+            await responseJson(
+              await ctx.credentials.fetch("https://slack.com/api/openid.connect.userInfo", {
+                headers: { authorization: `Bearer ${token.access_token}` }
+              })
+            )
+          );
+          const actual = await principalFor(
+            ctx,
+            identity["https://slack.com/team_id"],
+            identity["https://slack.com/user_id"] ?? identity.sub
+          );
+          const response = await confirmOAuth(
+            { ticket: saved.ticket, expected: saved.principal, actual },
+            ctx
+          );
+          if (response.ok)
+            await ctx.store.set(
+              stateKey(
+                "slack-principal",
+                identity["https://slack.com/team_id"],
+                identity["https://slack.com/user_id"] ?? identity.sub
+              ),
+              jsonValueSchema.parse(actual),
+              deliveryRetention
+            );
+          return response;
+        }
+      },
+      {
+        method: "POST",
+        path: "/webhook",
+        handler: async (ctx) => {
+          const body = await ctx.request.text();
+          let raw = null;
+          let completeJson = false;
+          try {
+            raw = JSON.parse(body);
+            completeJson = true;
+          } catch {
+          }
+          if (!completeJson && ctx.request.headers.get("content-type")?.includes("application/x-www-form-urlencoded")) {
+            const form = new URLSearchParams(body);
+            raw = form.has("payload") ? parseJson(form.get("payload") ?? "") : Object.fromEntries(
+              [...new Set(form.keys())].flatMap((key) => {
+                const value = form.get(key);
+                return value == null ? [] : [[key, value]];
+              })
+            );
+          }
+          const app = await ctx.credentials.appInfo();
+          const timestamp = ctx.request.headers.get("x-slack-request-timestamp");
+          const signature = ctx.request.headers.get("x-slack-signature");
+          if (app.signingSecret == null || !freshTimestamp(timestamp) || signature == null || !signature.startsWith("v0=") || !await verifyHmac({
+            secret: app.signingSecret,
+            body: `v0:${timestamp}:${body}`,
+            signature: signature.slice(3)
+          }))
+            return new Response(null, { status: 401 });
+          const envelope = envelopeSchema.safeParse(raw);
+          if (envelope.success && envelope.data.type === "url_verification" && envelope.data.challenge != null)
+            return Response.json({ challenge: envelope.data.challenge });
+          const slash = z.object({ command: z.literal("/final"), trigger_id: z.string() }).safeParse(raw);
+          if (slash.success) {
+            try {
+              await ctx.receive(jsonValueSchema.parse(raw));
+              const key = stateKey("slack-command-response", slash.data.trigger_id);
+              const text = await ctx.store.get(key);
+              await ctx.store.set(key, null);
+              return Response.json({
+                response_type: "ephemeral",
+                text: typeof text === "string" ? text : "Open Final to check this command."
+              });
+            } catch {
+              return Response.json({
+                response_type: "ephemeral",
+                text: "This command could not be completed. Open Final to check its state."
+              });
+            }
+          }
+          await ctx.receive(jsonValueSchema.parse(raw));
+          return new Response(null, { status: 200 });
+        }
+      }
+    ],
+    receive: async (input, baseContext) => {
+      const tenant = z.object({ team_id: z.string().optional(), team: z.object({ id: z.string() }).optional() }).safeParse(input);
+      const teamId = tenant.success ? tenant.data.team_id ?? tenant.data.team?.id : void 0;
+      const ctx = teamId == null ? baseContext : inTenant(baseContext, teamId);
+      const command = z.object({
+        command: z.literal("/final"),
+        trigger_id: z.string().optional(),
+        text: z.string().default(""),
+        user_id: z.string(),
+        team_id: z.string(),
+        channel_id: z.string()
+      }).safeParse(input);
+      if (command.success) {
+        const principal2 = await principalFor(ctx, command.data.team_id, command.data.user_id);
+        const by = await personFor(ctx, principal2);
+        const place2 = {
+          kind: command.data.channel_id.startsWith("D") ? "dm" : "channel",
+          id: command.data.channel_id,
+          tenant: command.data.team_id
+        };
+        const verb = command.data.text.trim().split(/\s+/)[0];
+        let text2;
+        if (typeof by !== "string") text2 = `${by.message} ${by.linkUrl ?? ""}`;
+        else if (verb === "disconnect") {
+          try {
+            await ctx.places.disconnect(place2, by);
+            text2 = "Disconnected this place from Final.";
+          } catch {
+            text2 = "Could not disconnect this place. Open Final to manage its connection or disconnect its connected parent place.";
+          }
+        } else if (verb === "unlink") {
+          await ctx.people.revoke({ principal: principal2, reason: "provider-revoked" });
+          text2 = "Unlinked your Slack account.";
+        } else {
+          const route = await ctx.places.resolve(place2);
+          text2 = route.kind === "connected" ? "This place is connected to Final. Use /final disconnect to disconnect it." : `Connect this place in Final: ${route.connectUrl}`;
+        }
+        if (command.data.trigger_id != null)
+          await ctx.store.set(stateKey("slack-command-response", command.data.trigger_id), text2, {
+            ttlSeconds: 60
+          });
+        else
+          await api(ctx, place2.kind === "dm" ? "chat.postMessage" : "chat.postEphemeral", {
+            channel: command.data.channel_id,
+            user: command.data.user_id,
+            text: text2
+          }).catch(() => ctx.log("Slack command response unavailable."));
+        return { accepted: true };
+      }
+      const interaction = z.object({
+        type: z.literal("block_actions"),
+        user: z.object({ id: z.string() }),
+        team: z.object({ id: z.string() }),
+        actions: z.array(z.object({ value: z.string() })),
+        channel: z.object({ id: z.string() }).optional(),
+        message: z.object({ thread_ts: z.string().optional(), ts: z.string().optional() }).optional(),
+        response_url: z.string().optional()
+      }).safeParse(input);
+      if (interaction.success) {
+        const refuse = async (reason) => {
+          if (interaction.data.channel != null)
+            await api(ctx, "chat.postEphemeral", {
+              channel: interaction.data.channel.id,
+              user: interaction.data.user.id,
+              ...interaction.data.message?.thread_ts == null ? {} : { thread_ts: interaction.data.message.thread_ts },
+              text: `${reason.message} ${reason.linkUrl ?? reason.connectUrl ?? ""}`
+            }).catch(() => ctx.log("Slack approval response unavailable."));
+          return { accepted: false, refusal: reason };
+        };
+        const principal2 = await principalFor(
+          ctx,
+          interaction.data.team.id,
+          interaction.data.user.id
+        );
+        const by = await personFor(ctx, principal2);
+        if (typeof by !== "string") return refuse(by);
+        const value = interaction.data.actions[0]?.value;
+        if (value == null) return { ignored: true, reason: "no-action" };
+        const saved = z.object({
+          decisionId: z.string(),
+          principal: z.object({ id: z.string(), tenant: z.string().optional() }),
+          outcome: jsonValueSchema
+        }).safeParse(await ctx.store.get(stateKey("slack-decision", value)));
+        if (!saved.success || saved.data.principal.id !== principal2.id || saved.data.principal.tenant !== principal2.tenant)
+          return refuse({
+            refused: "no-access",
+            message: saved.success ? "Only the requester can answer this decision." : "This approval expired. Answer in Final."
+          });
+        const url = responseUrl(interaction.data.response_url);
+        if (url != null)
+          await ctx.store.set(
+            stateKey("slack-decision-message", saved.data.decisionId),
+            { url },
+            { ttlSeconds: 1800 }
+          );
+        const confirm = (message2 = "This decision is no longer waiting in Final.") => confirmDecision({
+          ctx,
+          decisionId: saved.data.decisionId,
+          message: message2,
+          channel: interaction.data.channel?.id,
+          user: interaction.data.user.id
+        });
+        const completed = await ctx.store.get(
+          stateKey("slack-decision-resolved", saved.data.decisionId)
+        );
+        if (completed != null) {
+          await confirm(
+            completed === "answered" ? "This decision has been answered in Final." : void 0
+          );
+          return { accepted: true };
+        }
+        const result2 = await ctx.decisions.resolve({
+          decisionId: saved.data.decisionId,
+          outcome: saved.data.outcome,
+          by
+        });
+        if ("refused" in result2) return refuse(result2);
+        await ctx.store.set(
+          stateKey("slack-decision-resolved", saved.data.decisionId),
+          result2.resolved ? "answered" : "closed",
+          {
+            ttlSeconds: 3600
+          }
+        );
+        await confirm(result2.resolved ? "This decision has been answered in Final." : void 0);
+        return result2.resolved ? { accepted: true } : {
+          accepted: false,
+          refusal: {
+            refused: "no-access",
+            message: "This decision is no longer waiting in Final."
+          }
+        };
+      }
+      const envelope = envelopeSchema.safeParse(input);
+      if (!envelope.success || envelope.data.event == null || envelope.data.team_id == null)
+        return { ignored: true, reason: "not-an-event" };
+      const event = envelope.data.event;
+      if (event.type === "app_uninstalled" || event.type === "tokens_revoked") {
+        if (event.type === "app_uninstalled") {
+          await revokeTeam({
+            ctx,
+            team: envelope.data.team_id,
+            enterprise: envelope.data.enterprise_id ?? void 0,
+            reason: "uninstalled"
+          });
+        } else {
+          const tokens = z.object({
+            oauth: z.array(z.string()).default([]),
+            bot: z.array(z.string()).default([])
+          }).safeParse(event.tokens);
+          if (!tokens.success) return { ignored: true, reason: "invalid-revocation" };
+          if (tokens.data.bot.length > 0)
+            await revokeTeam({
+              ctx,
+              team: envelope.data.team_id,
+              enterprise: envelope.data.enterprise_id ?? void 0,
+              reason: "provider-revoked"
+            });
+          else
+            for (const user of tokens.data.oauth) {
+              const cached = principalRefSchema.safeParse(
+                await ctx.store.get(stateKey("slack-principal", envelope.data.team_id, user))
+              );
+              const principal2 = cached.success ? cached.data : await principalFor(ctx, envelope.data.team_id, user);
+              await ctx.people.revoke({ principal: principal2, reason: "provider-revoked" });
+              await ctx.store.set(stateKey("slack-principal", envelope.data.team_id, user), null);
+            }
+        }
+        return { accepted: true };
+      }
+      if (event.type === "user_change") {
+        const changed = slackUserSchema.shape.user.safeParse(event.user);
+        if (changed.success && changed.data.deleted === true)
+          await ctx.people.revoke({
+            principal: {
+              id: changed.data.enterprise_user?.id ?? changed.data.id,
+              tenant: changed.data.enterprise_user?.enterprise_id ?? envelope.data.team_id
+            },
+            reason: "deactivated"
+          });
+        return { ignored: true, reason: "lifecycle" };
+      }
+      if (event.type === "message" && (event.subtype === "message_changed" || event.subtype === "message_deleted")) {
+        const deleted = event.subtype === "message_deleted" || z.object({ subtype: z.literal("tombstone") }).safeParse(event.message).success;
+        const original = messageSchema.safeParse(deleted ? event.previous_message : event.message);
+        if (!original.success || original.data.user == null || typeof event.channel !== "string")
+          return { ignored: true, reason: "missing-original" };
+        if (original.data.bot_id != null || original.data.subtype === "bot_message")
+          return { ignored: true, reason: "own-message" };
+        const timestamp = original.data.ts ?? (typeof event.deleted_ts === "string" ? event.deleted_ts : null);
+        if (timestamp == null) return { ignored: true, reason: "missing-original" };
+        const mapped = providerOriginSchema.safeParse(
+          await ctx.store.get(
+            stateKey("slack-origin", envelope.data.team_id, event.channel, timestamp)
+          )
+        );
+        if (!mapped.success) return { ignored: true, reason: "unknown-origin" };
+        const place2 = mapped.data.place;
+        const by = await personFor(
+          ctx,
+          await principalFor(ctx, envelope.data.team_id, original.data.user)
+        );
+        if (typeof by !== "string") return { accepted: false, refusal: by };
+        const route = await ctx.places.resolve(place2);
+        if (route.kind !== "connected") return { ignored: true, reason: "unconnected" };
+        const key2 = mapped.data.externalKey;
+        const editedText = !deleted ? await normalizedText(ctx, original.data.text ?? "", envelope.data.team_id) : null;
+        if (editedText != null && editedText.length === 0)
+          return { ignored: true, reason: "empty-message" };
+        return receipt(
+          !deleted ? await ctx.conversation(route.conversation).edit({
+            externalKey: key2,
+            by,
+            content: [
+              {
+                type: "text",
+                text: editedText ?? ""
+              }
+            ]
+          }) : await ctx.conversation(route.conversation).remove({ externalKey: key2, by }).then((result2) => "refused" in result2 ? result2 : { messageId: key2 })
+        );
+      }
+      if (event.type === "reaction_added" || event.type === "reaction_removed") {
+        const parsed2 = z.object({
+          user: z.string(),
+          reaction: z.string(),
+          item: z.object({ channel: z.string(), ts: z.string() })
+        }).safeParse(event);
+        if (!parsed2.success) return { ignored: true, reason: "unsupported-reaction" };
+        const mapped = providerOriginSchema.safeParse(
+          await ctx.store.get(
+            stateKey(
+              "slack-origin",
+              envelope.data.team_id,
+              parsed2.data.item.channel,
+              parsed2.data.item.ts
+            )
+          )
+        );
+        if (!mapped.success) return { ignored: true, reason: "unknown-origin" };
+        if (parsed2.data.user === await botFor(ctx, envelope.data.team_id))
+          return { ignored: true, reason: "own-reaction" };
+        const by = await personFor(
+          ctx,
+          await principalFor(ctx, envelope.data.team_id, parsed2.data.user)
+        );
+        if (typeof by !== "string") return { accepted: false, refusal: by };
+        const route = await ctx.places.resolve(mapped.data.place);
+        if (route.kind !== "connected") return { ignored: true, reason: "unconnected" };
+        const target = mapped.data.turnId != null ? { replyOf: { externalKey: mapped.data.externalKey, turnId: mapped.data.turnId } } : {
+          externalKey: mapped.data.externalKey
+        };
+        const result2 = await ctx.conversation(route.conversation).react({
+          target,
+          emoji: finalEmoji(parsed2.data.reaction),
+          by,
+          op: event.type === "reaction_added" ? "add" : "remove"
+        });
+        return "refused" in result2 ? { accepted: false, refusal: result2 } : { accepted: true };
+      }
+      const parsed = messageSchema.safeParse(event);
+      if (!parsed.success || parsed.data.user == null || parsed.data.ts == null || parsed.data.text == null || parsed.data.bot_id != null || parsed.data.type !== "app_mention" && !(parsed.data.type === "message" && parsed.data.channel_type === "im"))
+        return { ignored: true, reason: "not-a-human-mention" };
+      const message = messageSchema.extend({ user: z.string(), ts: z.string(), text: z.string(), channel: z.string() }).parse(parsed.data);
+      const place = placeFor(message, envelope.data.team_id);
+      if (place == null) return { ignored: true, reason: "no-place" };
+      const text = await normalizedText(ctx, message.text, envelope.data.team_id);
+      if (text.length === 0) return { ignored: true, reason: "empty-message" };
+      const principal = await principalFor(ctx, envelope.data.team_id, message.user);
+      await api(ctx, "reactions.add", {
+        channel: message.channel,
+        timestamp: message.ts,
+        name: "eyes"
+      }).catch(() => ctx.log("Slack acknowledgement unavailable."));
+      const key = externalKey(place.parent ?? place, message.ts);
+      const historyTeam = envelope.data.team_id;
+      const loadContext = async () => config.history === "linked-members" ? historyFor({ ctx, message, team: historyTeam }).catch(() => {
+        ctx.log("Slack history is unavailable for this app grant.");
+        return [];
+      }) : [];
+      await ctx.store.set(
+        stateKey("slack-origin", envelope.data.team_id, message.channel, message.ts),
+        jsonValueSchema.parse({ place, externalKey: key }),
+        deliveryRetention
+      );
+      const result = await receivePersonMessage({
+        ctx,
+        principal,
+        place,
+        resumeAfterLink: place.kind === "dm",
+        text,
+        externalKey: key,
+        loadContext,
+        ref: {
+          externalKey: key,
+          channel: message.channel,
+          ts: message.ts,
+          threadTs: message.thread_ts ?? message.ts,
+          requester: principal.id,
+          user: message.user,
+          tenant: principal.tenant ?? envelope.data.team_id
+        }
+      });
+      if ("accepted" in result && !result.accepted)
+        await api(ctx, place.kind === "dm" ? "chat.postMessage" : "chat.postEphemeral", {
+          channel: message.channel,
+          user: message.user,
+          ...message.thread_ts == null ? {} : { thread_ts: message.thread_ts },
+          text: `${result.refusal.message} ${result.refusal.linkUrl ?? result.refusal.connectUrl ?? ""}`
+        }).catch(() => ctx.log("Slack requester notice unavailable."));
+      return result;
+    },
+    events: {
+      "message.posted": async (data, ctx) => {
+        const key = stateKey("slack-mirror", providerPlaceKey(ctx.origin.place), data.message.id);
+        if (await ctx.store.get(key) != null) return;
+        const { channel, thread_ts } = location(ctx);
+        if (channel == null) return;
+        const result = replySchema.parse(
+          await api(ctx, "chat.postMessage", {
+            channel,
+            ...thread_ts == null ? {} : { thread_ts },
+            text: `From ${data.author.displayName} in Final
+${textOf(data.message.content)}`.slice(
+              0,
+              11500
+            )
+          })
+        );
+        await ctx.store.set(key, result.ts, deliveryRetention);
+      },
+      "message.delta": async (data, ctx) => {
+        const prior = ctx.state.get()?.text ?? await savedPartial(ctx);
+        const delta = data.delta.type === "text" && typeof data.delta.text === "string" ? data.delta.text : "";
+        const text = prior + delta;
+        ctx.state.set({ text });
+        await sharedReply(ctx, { text, final: false, messageIds: [data.messageId] });
+      },
+      "turn.completed": async (data, ctx) => {
+        await sharedReply(ctx, {
+          text: completionText(data, ctx.state.get()?.text ?? await savedPartial(ctx)),
+          final: true,
+          messageIds: data.messages?.map((message) => message.id) ?? []
+        });
+      },
+      "decision.created": async (data, ctx) => {
+        const deliveredKey = stateKey("slack-decision-delivered", data.decisionId);
+        if (await ctx.store.get(deliveredKey) != null) return;
+        const { channel, thread_ts } = location(ctx);
+        const user = refString(ctx.origin.ref, "user") ?? refString(ctx.origin.ref, "requester");
+        const principalId = refString(ctx.origin.ref, "requester") ?? user;
+        const tenant = refString(ctx.origin.ref, "tenant");
+        if (channel == null || user == null) return;
+        const choices = decisionChoices(data.request);
+        const elements = [];
+        for (const choice of choices) {
+          const value = crypto.randomUUID();
+          await ctx.store.set(
+            stateKey("slack-decision", value),
+            {
+              decisionId: data.decisionId,
+              principal: { id: principalId ?? user, ...tenant == null ? {} : { tenant } },
+              outcome: choice.outcome
+            },
+            { ttlSeconds: 3600 }
+          );
+          elements.push({
+            type: "button",
+            text: { type: "plain_text", text: choice.label },
+            action_id: `final_decision_${elements.length}`,
+            value
+          });
+        }
+        try {
+          await api(ctx, "chat.postEphemeral", {
+            channel,
+            user,
+            ...thread_ts == null ? {} : { thread_ts },
+            text: `${decisionSummary(data.request)}
+${elements.length === 0 ? "Answer in Final \u2192" : "Choose an option below."}`,
+            ...elements.length === 0 ? {} : {
+              blocks: [
+                {
+                  type: "section",
+                  text: { type: "plain_text", text: decisionSummary(data.request) }
+                },
+                { type: "actions", elements }
+              ]
+            }
+          });
+        } catch {
+          await api(ctx, "chat.postMessage", {
+            channel,
+            ...thread_ts == null ? {} : { thread_ts },
+            text: "This request needs approval. Answer in Final."
+          });
+        }
+        await ctx.store.set(deliveredKey, true, { ttlSeconds: 3600 });
+      },
+      "decision.resolved": async (data, ctx) => {
+        await ctx.store.set(stateKey("slack-decision-resolved", data.decisionId), "answered", {
+          ttlSeconds: 3600
+        });
+        const { channel, thread_ts } = location(ctx);
+        await confirmDecision({
+          ctx,
+          decisionId: data.decisionId,
+          channel: channel ?? void 0,
+          user: refString(ctx.origin.ref, "user") ?? refString(ctx.origin.ref, "requester") ?? void 0,
+          threadTs: thread_ts ?? void 0
+        });
+      },
+      "message.edited": async (data, ctx) => {
+        if (data.replyOf == null && data.externalKey.startsWith("final:")) {
+          const key = mirrorReceiptKey({
+            provider: "slack",
+            place: ctx.origin.place,
+            externalKey: data.externalKey,
+            messageId: data.message.id
+          });
+          if (key == null) return;
+          const saved2 = z.string().safeParse(await ctx.store.get(key));
+          const { channel: channel2 } = location(ctx);
+          if (!saved2.success || channel2 == null) return;
+          const result = slackResponseSchema.parse(
+            await api(ctx, "chat.update", {
+              channel: channel2,
+              ts: saved2.data,
+              text: `From ${data.author.displayName} in Final
+${textOf(data.message.content)}`.slice(
+                0,
+                11500
+              )
+            })
+          );
+          if (result.error === "message_not_found")
+            await ctx.store.set(key, { deleted: true }, deliveryRetention);
+          return;
+        }
+        if (data.replyOf == null) {
+          const { channel: channel2, thread_ts } = location(ctx);
+          if (channel2 == null) return;
+          const key = stateKey(
+            "slack-prompt-update",
+            providerPlaceKey(ctx.origin.place),
+            data.externalKey
+          );
+          const saved2 = z.object({ ts: z.string(), text: z.string() }).safeParse(await ctx.store.get(key));
+          const text = `Updated in Final:
+${textOf(data.message.content)}`.slice(0, 11500);
+          if (saved2.success && saved2.data.text === text) return;
+          const result = await api(ctx, saved2.success ? "chat.update" : "chat.postMessage", {
+            channel: channel2,
+            ...saved2.success ? { ts: saved2.data.ts } : thread_ts == null ? {} : { thread_ts },
+            text
+          });
+          const missing = saved2.success && slackResponseSchema.parse(result).error === "message_not_found";
+          const current = missing ? await api(ctx, "chat.postMessage", {
+            channel: channel2,
+            ...thread_ts == null ? {} : { thread_ts },
+            text
+          }) : result;
+          await ctx.store.set(
+            key,
+            { ts: saved2.success && !missing ? saved2.data.ts : replySchema.parse(current).ts, text },
+            deliveryRetention
+          );
+          return;
+        }
+        const { channel } = location(ctx);
+        const saved = z.object({ ts: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+        const ts = saved.success ? saved.data.ts : null;
+        if (channel != null && ts != null)
+          await api(ctx, "chat.update", {
+            channel,
+            ts,
+            text: textOf(data.message.content).slice(0, 11500)
+          });
+      },
+      "message.removed": async (data, ctx) => {
+        if (data.replyOf == null && data.externalKey.startsWith("final:")) {
+          const key = mirrorReceiptKey({
+            provider: "slack",
+            place: ctx.origin.place,
+            externalKey: data.externalKey,
+            messageId: data.message.id
+          });
+          if (key == null) return;
+          const saved2 = z.string().safeParse(await ctx.store.get(key));
+          const { channel: channel2 } = location(ctx);
+          if (!saved2.success || channel2 == null) return;
+          await api(ctx, "chat.delete", { channel: channel2, ts: saved2.data });
+          await ctx.store.set(key, { deleted: true }, deliveryRetention);
+          return;
+        }
+        if (data.replyOf == null) {
+          const key = stateKey(
+            "slack-prompt-update",
+            providerPlaceKey(ctx.origin.place),
+            data.externalKey
+          );
+          const saved2 = z.object({ ts: z.string() }).safeParse(await ctx.store.get(key));
+          const { channel: channel2 } = location(ctx);
+          if (saved2.success && channel2 != null) {
+            await api(ctx, "chat.delete", { channel: channel2, ts: saved2.data.ts });
+            await ctx.store.set(key, null);
+          }
+          return;
+        }
+        const { channel } = location(ctx);
+        const saved = z.object({ ts: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+        const ts = saved.success ? saved.data.ts : null;
+        if (channel != null && ts != null) await api(ctx, "chat.delete", { channel, ts });
+      },
+      "reaction.added": async (data, ctx) => {
+        const { channel } = location(ctx);
+        const mirror = data.replyOf == null && data.externalKey.startsWith("final:");
+        const mirrorKey = mirrorReceiptKey({
+          provider: "slack",
+          place: ctx.origin.place,
+          externalKey: data.externalKey
+        });
+        const mirrored = z.string().safeParse(mirrorKey == null ? null : await ctx.store.get(mirrorKey));
+        if (mirror && !mirrored.success) return;
+        const saved = z.object({ ts: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+        const name = slackEmoji(data.emoji);
+        const timestamp = mirror && mirrored.success ? mirrored.data : data.replyOf == null ? refString(ctx.origin.ref, "ts") : saved.success ? saved.data.ts : null;
+        if (channel != null && timestamp != null && name != null)
+          await settleMirrorReaction({
+            ctx,
+            key: mirror ? mirrorKey : null,
+            classify: classifyMirrorReaction,
+            work: () => addSharedReaction({
+              store: ctx.store,
+              key: stateKey(
+                "slack-shared-reaction",
+                ctx.origin.place.tenant ?? null,
+                channel,
+                timestamp,
+                name
+              ),
+              principal: data.principal,
+              add: async () => {
+                const response = slackResponseSchema.parse(
+                  await api(ctx, "reactions.add", { channel, timestamp, name })
+                );
+                return response.error !== "already_reacted";
+              }
+            })
+          });
+      },
+      "reaction.removed": async (data, ctx) => {
+        const { channel } = location(ctx);
+        const mirror = data.replyOf == null && data.externalKey.startsWith("final:");
+        const mirrorKey = mirrorReceiptKey({
+          provider: "slack",
+          place: ctx.origin.place,
+          externalKey: data.externalKey
+        });
+        const mirrored = z.string().safeParse(mirrorKey == null ? null : await ctx.store.get(mirrorKey));
+        if (mirror && !mirrored.success) return;
+        const saved = z.object({ ts: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
+        const name = slackEmoji(data.emoji);
+        const timestamp = mirror && mirrored.success ? mirrored.data : data.replyOf == null ? refString(ctx.origin.ref, "ts") : saved.success ? saved.data.ts : null;
+        if (channel != null && timestamp != null && name != null)
+          await settleMirrorReaction({
+            ctx,
+            key: mirror ? mirrorKey : null,
+            classify: classifyMirrorReaction,
+            work: () => removeSharedReaction({
+              store: ctx.store,
+              key: stateKey(
+                "slack-shared-reaction",
+                ctx.origin.place.tenant ?? null,
+                channel,
+                timestamp,
+                name
+              ),
+              principal: data.principal,
+              remove: async () => {
+                await api(ctx, "reactions.remove", { channel, timestamp, name });
+              }
+            })
+          });
+      }
+    }
+  });
+};
+const historyFor = async (args) => {
+  const { ctx, message } = args;
+  if (message.channel == null) return [];
+  const messages = [];
+  let cursor;
+  for (let page = 0; page < 5; page += 1) {
+    const result = z.object({
+      messages: z.array(messageSchema),
+      response_metadata: z.object({ next_cursor: z.string().optional() }).optional()
+    }).parse(
+      await api(
+        ctx,
+        message.thread_ts == null ? "conversations.history" : "conversations.replies",
+        {
+          channel: message.channel,
+          limit: 100,
+          ...message.ts == null ? {} : { latest: message.ts, inclusive: false },
+          ...message.thread_ts == null ? {} : { ts: message.thread_ts },
+          ...cursor == null ? {} : { cursor }
+        }
+      )
+    );
+    messages.push(...result.messages);
+    cursor = result.response_metadata?.next_cursor;
+    if (cursor == null || cursor.length === 0 || message.thread_ts == null) break;
+  }
+  if (message.thread_ts != null && cursor != null && cursor.length > 0) return [];
+  const recent = messages.sort((a, b) => Number(a.ts ?? 0) - Number(b.ts ?? 0)).slice(-20);
+  const lines = [];
+  const authors = /* @__PURE__ */ new Map();
+  for (const earlier of recent) {
+    if (earlier.user == null || earlier.text == null || earlier.bot_id != null || earlier.ts === message.ts)
+      continue;
+    if (!authors.has(earlier.user)) {
+      const principal = await principalFor(ctx, args.team, earlier.user);
+      const linked = await ctx.people.resolve(principal);
+      authors.set(earlier.user, linked.kind === "member" ? linked.displayName : null);
+    }
+    const name = authors.get(earlier.user);
+    if (name != null) {
+      const text = await normalizedText(ctx, earlier.text, args.team);
+      if (text.length > 0) lines.push(`${name}: ${text}`);
+    }
+  }
+  return lines;
+};
+export {
+  slackChannel
+};
+//# sourceMappingURL=slack.mjs.map