@finalai/final-agent-provider 0.8.0 → 0.10.0

package/dist/modules/channels/slack.mjs

@@ -1,1134 +0,0 @@
-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