@finalai/final-agent-provider 0.7.0 → 0.9.0

package/dist/modules/channels/discord.mjs

@@ -1,904 +0,0 @@
-import {
-  defineChannel,
-  packageRef,
-  placeRefSchema,
-  jsonValueSchema
-} from "@finalai/agent-provider";
-import * as z from "zod";
-import {
-  mirrorReceiptKey,
-  settleMirrorReaction,
-  shareReplyReceipt
-} from "./reply-receipts.mjs";
-import { createDiscordDispatch } from "./discord-dispatch.mjs";
-import { runDiscordGateway } from "./discord-gateway.mjs";
-import {
-  channelBaseUrl,
-  addSharedReaction,
-  removeSharedReaction,
-  providerPlaceKey,
-  confirmOAuth,
-  deliveryRetention,
-  createQueue,
-  decisionChoices,
-  decisionSummary,
-  externalKey,
-  freshTimestamp,
-  hexBytes,
-  parseJson,
-  personFor,
-  receivePersonMessage,
-  refString,
-  responseJson,
-  startOAuth,
-  stateKey,
-  takeOAuth,
-  textOf,
-  completionText
-} from "./channel-utils.mjs";
-const configSchema = z.object({
-  baseUrl: z.string().url().optional(),
-  publicKey: z.string().optional(),
-  botId: z.string().optional(),
-  history: z.union([z.literal("none"), z.literal("linked-members")]).default("none")
-});
-const missingMessage = /* @__PURE__ */ Symbol("missing Discord message");
-const missingReactionMessage = /* @__PURE__ */ Symbol("missing Discord reaction message");
-const api = async (ctx, path, body, method) => {
-  const app = await ctx.credentials.app();
-  const response = await ctx.credentials.fetch(`https://discord.com/api/v10${path}`, {
-    signal: ctx.signal,
-    method: method ?? (body == null ? "GET" : "POST"),
-    headers: { authorization: `Bot ${app.accessToken}`, "content-type": "application/json" },
-    ...body == null ? {} : { body: JSON.stringify(body) }
-  });
-  if (response.status === 400 || response.status === 404) {
-    const text = await response.text();
-    const error = z.object({ code: z.number() }).safeParse(parseJson(text));
-    const code = error.success ? error.data.code : null;
-    if (response.status === 404 && (method === "DELETE" || method === "PATCH"))
-      return path.includes("/reactions/") && code === 10008 ? missingReactionMessage : missingMessage;
-    throw new Error(`Channel request failed (${response.status}): ${text.slice(0, 500)}`, {
-      cause: { status: response.status, code }
-    });
-  }
-  return responseJson(response);
-};
-const classifyMirrorReaction = async (cause) => {
-  const error = z.object({ status: z.number(), code: z.number().nullable().optional() }).safeParse(cause instanceof Error ? cause.cause : null);
-  if (!error.success) return "retry";
-  if (error.data.status === 429 || error.data.status >= 500) return "retry";
-  if (error.data.code === 10008) return "missing";
-  if (error.data.code === 10014 || error.data.code === 30010) return "unavailable";
-  return error.data.status === 403 || error.data.status === 404 ? "unavailable" : "retry";
-};
-const botFor = async (ctx, config) => {
-  if (config.botId != null) return config.botId;
-  const cached = z.string().safeParse(await ctx.store.get("discord-bot-id"));
-  if (cached.success) return cached.data;
-  const id = z.object({ id: z.string() }).parse(await api(ctx, "/users/@me")).id;
-  await ctx.store.set("discord-bot-id", id, deliveryRetention);
-  return id;
-};
-const confirmDecision = async (ctx, decisionId) => {
-  await ctx.store.set(stateKey("discord-decision-resolved", decisionId), true, {
-    ttlSeconds: 3600
-  });
-  const saved = z.object({ channel: z.string(), messageId: z.string() }).safeParse(await ctx.store.get(stateKey("discord-decision-delivered", decisionId)));
-  if (!saved.success) return;
-  try {
-    await api(
-      ctx,
-      `/channels/${saved.data.channel}/messages/${saved.data.messageId}`,
-      {
-        content: "This decision has been answered in Final.",
-        components: [],
-        allowed_mentions: { parse: [] }
-      },
-      "PATCH"
-    );
-  } catch {
-    ctx.log("Discord decision confirmation unavailable.");
-  }
-};
-const normalizedText = (text, bot) => text.replace(/<@!?([0-9A-Za-z_-]+)>/g, (_match, id) => id === bot ? "" : `@${id}`).trim();
-const messageSchema = z.object({
-  id: z.string(),
-  channel_id: z.string(),
-  guild_id: z.string().optional(),
-  content: z.string().default(""),
-  author: z.object({ id: z.string(), username: z.string(), bot: z.boolean().optional() }),
-  mentions: z.array(z.object({ id: z.string() })).default([])
-});
-const replyKey = (ctx, replyOf) => stateKey(
-  "discord-reply",
-  replyOf?.externalKey ?? refString(ctx.origin.ref, "externalKey") ?? ctx.origin.place.id,
-  replyOf?.turnId ?? ctx.turn.id
-);
-const reply = async (ctx, text, final, key = replyKey(ctx)) => {
-  const channel = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-  if (channel == null || text.length === 0) return;
-  const saved = z.object({
-    id: 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, 1900) }, deliveryRetention);
-    return;
-  }
-  const content = text.length > 1900 ? `${text.slice(0, 1850)}
-Continue in Final \u2192` : text;
-  const data = await api(
-    ctx,
-    `/channels/${channel}/messages${saved.success ? `/${saved.data.id}` : ""}`,
-    { content, allowed_mentions: { parse: [] } },
-    saved.success ? "PATCH" : "POST"
-  );
-  if (saved.success && data === missingMessage) {
-    await ctx.store.set(key, null);
-    await reply(ctx, text, final, key);
-    return;
-  }
-  const id = saved.success ? saved.data.id : z.object({ id: z.string() }).parse(data).id;
-  await ctx.store.set(
-    key,
-    { id, updatedAt: Date.now(), final, text: text.slice(0, 1900) },
-    deliveryRetention
-  );
-  await ctx.store.set(
-    stateKey("discord-origin", channel, id),
-    jsonValueSchema.parse({
-      ...refString(ctx.origin.ref, "requester") == null ? {} : { principal: { id: refString(ctx.origin.ref, "requester") } },
-      place: ctx.origin.place,
-      externalKey: refString(ctx.origin.ref, "externalKey") ?? ctx.origin.place.id,
-      turnId: ctx.turn.id
-    }),
-    deliveryRetention
-  );
-};
-const savedPartial = async (ctx) => {
-  const receipt = z.object({ text: z.string() }).safeParse(await ctx.store.get(replyKey(ctx)));
-  return receipt.success ? receipt.data.text : "";
-};
-const sharedReply = async (ctx, args) => {
-  const channel = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-  await shareReplyReceipt({
-    bindingId: ctx.binding.id,
-    store: ctx.store,
-    destination: stateKey("discord", channel),
-    messageIds: args.messageIds,
-    originKey: replyKey(ctx),
-    send: (key) => reply(ctx, args.text, args.final, key),
-    removeDuplicate: async (receipt, canonical) => {
-      const schema = z.object({ id: z.string() });
-      const saved = schema.safeParse(receipt);
-      const target = schema.safeParse(canonical);
-      if (saved.success && target.success && saved.data.id !== target.data.id)
-        await api(ctx, `/channels/${channel}/messages/${saved.data.id}`, void 0, "DELETE");
-    }
-  });
-};
-const discordChannel = (options = {}) => {
-  const config = configSchema.parse(options);
-  return defineChannel({
-    name: "discord",
-    config,
-    installed: packageRef("@finalai/final-agent-provider/channels/discord"),
-    credentials: { app: "discord" },
-    identity: {
-      kind: "redirect",
-      start: async (args, ctx) => {
-        const app = await ctx.credentials.appInfo();
-        return startOAuth(
-          {
-            ...args,
-            authorizeUrl: "https://discord.com/oauth2/authorize",
-            clientId: app.clientId,
-            redirectUri: `${channelBaseUrl(config)}/b/${ctx.binding.id}/oauth/callback`,
-            scope: "identify"
-          },
-          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({ access_token: z.string() }).parse(
-            await responseJson(
-              await ctx.credentials.fetch("https://discord.com/api/oauth2/token", {
-                method: "POST",
-                body: new URLSearchParams({
-                  client_id: app.clientId,
-                  client_secret: app.clientSecret,
-                  grant_type: "authorization_code",
-                  code: saved.code,
-                  redirect_uri: saved.redirectUri
-                })
-              })
-            )
-          );
-          const user = z.object({ id: z.string(), username: z.string() }).parse(
-            await responseJson(
-              await ctx.credentials.fetch("https://discord.com/api/users/@me", {
-                headers: { authorization: `Bearer ${token.access_token}` }
-              })
-            )
-          );
-          return confirmOAuth(
-            {
-              ticket: saved.ticket,
-              expected: saved.principal,
-              actual: { id: user.id, displayName: user.username }
-            },
-            ctx
-          );
-        }
-      },
-      {
-        method: "POST",
-        path: "/webhook",
-        handler: async (ctx) => {
-          const body = await ctx.request.text();
-          const timestamp = ctx.request.headers.get("x-signature-timestamp");
-          const signature = hexBytes(ctx.request.headers.get("x-signature-ed25519") ?? "");
-          const bytes = hexBytes(
-            config.publicKey ?? (await ctx.credentials.appInfo()).signingSecret ?? ""
-          );
-          if (!freshTimestamp(timestamp) || signature == null || bytes == null)
-            return new Response(null, { status: 401 });
-          const key = await crypto.subtle.importKey(
-            "raw",
-            new Uint8Array(bytes),
-            "Ed25519",
-            false,
-            ["verify"]
-          );
-          if (!await crypto.subtle.verify(
-            "Ed25519",
-            key,
-            new Uint8Array(signature),
-            new TextEncoder().encode(timestamp + body)
-          ))
-            return new Response(null, { status: 401 });
-          const raw = jsonValueSchema.parse(parseJson(body));
-          const type = z.object({ type: z.number() }).safeParse(raw);
-          if (type.success && type.data.type === 1) return Response.json({ type: 1 });
-          const result = await ctx.receive(raw);
-          const interactionId = z.object({ id: z.string() }).safeParse(raw);
-          const commandText = interactionId.success ? await ctx.store.get(stateKey("discord-command-response", interactionId.data.id)) : null;
-          return Response.json({
-            type: 4,
-            data: {
-              flags: 64,
-              content: typeof commandText === "string" ? commandText : "accepted" in result && !result.accepted ? `${result.refusal.message} ${result.refusal.linkUrl ?? result.refusal.connectUrl ?? ""}` : "Accepted in Final"
-            }
-          });
-        }
-      }
-    ],
-    listeners: [
-      {
-        key: "gateway",
-        run: async (ctx) => {
-          const app = await ctx.credentials.app();
-          const gateway = z.object({ url: z.string() }).parse(await api(ctx, "/gateway/bot"));
-          const botId = await botFor(ctx, config);
-          const dispatch = createDiscordDispatch({
-            store: ctx.store,
-            botId,
-            receive: (input, signal) => {
-              const active = { ...ctx, signal };
-              return ctxReceive(input, active, { ...config, botId });
-            },
-            request: ({ path, body, method, signal }) => api({ ...ctx, signal: signal ?? ctx.signal }, path, body, method)
-          });
-          await runDiscordGateway({
-            ctx,
-            url: gateway.url,
-            token: app.accessToken,
-            receive: dispatch.receive,
-            accepts: dispatch.accepts,
-            connect: (url) => {
-              const socket = new WebSocket(url);
-              const messages = createQueue();
-              let code = null;
-              socket.addEventListener("message", (event) => {
-                if (typeof event.data === "string") messages.push(event.data);
-              });
-              socket.addEventListener("close", (event) => {
-                code = event.code;
-                messages.close();
-              });
-              socket.addEventListener("error", () => {
-                messages.close();
-                socket.close();
-              });
-              return {
-                messages: messages.stream,
-                send: (data) => socket.send(data),
-                close: () => {
-                  socket.close();
-                  messages.close();
-                },
-                closeCode: () => code
-              };
-            }
-          });
-        }
-      }
-    ],
-    receive: async (input, ctx) => ctxReceive(input, ctx, config),
-    events: {
-      "message.posted": async (data, ctx) => {
-        const key = stateKey("discord-mirror", providerPlaceKey(ctx.origin.place), data.message.id);
-        if (await ctx.store.get(key) != null) return;
-        const channel = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-        const result = z.object({ id: z.string() }).parse(
-          await api(ctx, `/channels/${channel}/messages`, {
-            content: `From ${data.author.displayName} in Final
-${textOf(data.message.content)}`.slice(
-              0,
-              2e3
-            ),
-            allowed_mentions: { parse: [] }
-          })
-        );
-        await ctx.store.set(key, result.id, deliveryRetention);
-      },
-      "message.delta": async (data, ctx) => {
-        const text = (ctx.state.get()?.text ?? await savedPartial(ctx)) + (data.delta.type === "text" && typeof data.delta.text === "string" ? data.delta.text : "");
-        ctx.state.set({ text });
-        await sharedReply(ctx, { text, final: false, messageIds: [data.messageId] });
-      },
-      "turn.completed": async (data, ctx) => 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("discord-decision-delivered", data.decisionId);
-        if (await ctx.store.get(deliveredKey) != null) return;
-        const user = refString(ctx.origin.ref, "requester");
-        if (user == null) return;
-        const choices = decisionChoices(data.request);
-        const components = [];
-        for (const choice of choices) {
-          const id = crypto.randomUUID();
-          await ctx.store.set(
-            stateKey("discord-decision", id),
-            { decisionId: data.decisionId, user, outcome: choice.outcome },
-            { ttlSeconds: 3600 }
-          );
-          components.push({
-            type: 2,
-            style: choice.answer === "approve" ? 3 : 4,
-            label: choice.label,
-            custom_id: id
-          });
-        }
-        try {
-          const dm = z.object({ id: z.string() }).parse(await api(ctx, "/users/@me/channels", { recipient_id: user }));
-          const message = z.object({ id: z.string() }).parse(
-            await api(ctx, `/channels/${dm.id}/messages`, {
-              content: `${decisionSummary(data.request)}
-${choices.length === 0 ? "Answer in Final \u2192" : "Choose an option below."}`,
-              ...components.length === 0 ? {} : { components: [{ type: 1, components }] }
-            })
-          );
-          await ctx.store.set(
-            deliveredKey,
-            { channel: dm.id, messageId: message.id },
-            { ttlSeconds: 3600 }
-          );
-        } catch {
-          const channel = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-          await api(ctx, `/channels/${channel}/messages`, {
-            content: "This request needs an approval. Answer in Final.",
-            allowed_mentions: { parse: [] }
-          });
-          await ctx.store.set(deliveredKey, true, { ttlSeconds: 3600 });
-        }
-      },
-      "decision.resolved": async (data, ctx) => confirmDecision(ctx, data.decisionId),
-      "message.edited": async (data, ctx) => {
-        if (data.replyOf == null && data.externalKey.startsWith("final:")) {
-          const key = mirrorReceiptKey({
-            provider: "discord",
-            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));
-          if (!saved2.success) return;
-          const channel2 = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-          const result = await api(
-            ctx,
-            `/channels/${channel2}/messages/${saved2.data}`,
-            {
-              content: `From ${data.author.displayName} in Final
-${textOf(data.message.content)}`.slice(
-                0,
-                2e3
-              ),
-              allowed_mentions: { parse: [] }
-            },
-            "PATCH"
-          );
-          if (result === missingMessage)
-            await ctx.store.set(key, { deleted: true }, deliveryRetention);
-          return;
-        }
-        if (data.replyOf == null) return;
-        const channel = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-        const saved = z.object({ id: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
-        if (channel != null && saved.success)
-          await api(
-            ctx,
-            `/channels/${channel}/messages/${saved.data.id}`,
-            {
-              content: textOf(data.message.content).slice(0, 2e3),
-              allowed_mentions: { parse: [] }
-            },
-            "PATCH"
-          );
-      },
-      "message.removed": async (data, ctx) => {
-        if (data.replyOf == null && data.externalKey.startsWith("final:")) {
-          const key = mirrorReceiptKey({
-            provider: "discord",
-            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));
-          if (!saved2.success) return;
-          const channel2 = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-          await api(ctx, `/channels/${channel2}/messages/${saved2.data}`, void 0, "DELETE");
-          await ctx.store.set(key, { deleted: true }, deliveryRetention);
-          return;
-        }
-        if (data.replyOf == null) return;
-        const channel = refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel") ?? ctx.origin.place.id;
-        const saved = z.object({ id: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
-        if (channel != null && saved.success)
-          await api(ctx, `/channels/${channel}/messages/${saved.data.id}`, void 0, "DELETE");
-      },
-      "reaction.added": async (data, ctx) => {
-        const mirror = data.replyOf == null && data.externalKey.startsWith("final:");
-        const mirrorKey = mirrorReceiptKey({
-          provider: "discord",
-          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 channel = (data.replyOf == null && !mirror ? refString(ctx.origin.ref, "channel") : refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel")) ?? ctx.origin.place.id;
-        const saved = z.object({ id: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
-        const original = z.tuple([z.string().nullable(), z.string(), z.string()]).safeParse(parseJson(data.externalKey));
-        const id = mirror && mirrored.success ? mirrored.data : data.replyOf == null ? refString(ctx.origin.ref, "messageId") ?? (original.success ? original.data[2] : null) : saved.success ? saved.data.id : null;
-        if (channel != null && id != null)
-          await settleMirrorReaction({
-            ctx,
-            key: mirror ? mirrorKey : null,
-            classify: classifyMirrorReaction,
-            work: () => addSharedReaction({
-              store: ctx.store,
-              key: stateKey("discord-shared-reaction", channel, id, data.emoji),
-              principal: data.principal,
-              add: async () => {
-                await api(
-                  ctx,
-                  `/channels/${channel}/messages/${id}/reactions/${encodeURIComponent(data.emoji)}/@me`,
-                  void 0,
-                  "PUT"
-                );
-                return true;
-              }
-            })
-          });
-      },
-      "reaction.removed": async (data, ctx) => {
-        const mirror = data.replyOf == null && data.externalKey.startsWith("final:");
-        const mirrorKey = mirrorReceiptKey({
-          provider: "discord",
-          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 channel = (data.replyOf == null && !mirror ? refString(ctx.origin.ref, "channel") : refString(ctx.origin.ref, "replyChannel") ?? refString(ctx.origin.ref, "channel")) ?? ctx.origin.place.id;
-        const saved = z.object({ id: z.string() }).safeParse(await ctx.store.get(replyKey(ctx, data.replyOf)));
-        const original = z.tuple([z.string().nullable(), z.string(), z.string()]).safeParse(parseJson(data.externalKey));
-        const id = mirror && mirrored.success ? mirrored.data : data.replyOf == null ? refString(ctx.origin.ref, "messageId") ?? (original.success ? original.data[2] : null) : saved.success ? saved.data.id : null;
-        if (channel != null && id != null)
-          await settleMirrorReaction({
-            ctx,
-            key: mirror ? mirrorKey : null,
-            classify: classifyMirrorReaction,
-            work: () => removeSharedReaction({
-              store: ctx.store,
-              key: stateKey("discord-shared-reaction", channel, id, data.emoji),
-              principal: data.principal,
-              remove: async () => {
-                const result = await api(
-                  ctx,
-                  `/channels/${channel}/messages/${id}/reactions/${encodeURIComponent(data.emoji)}/@me`,
-                  void 0,
-                  "DELETE"
-                );
-                if (mirror && result === missingReactionMessage)
-                  throw new Error("Discord reaction message missing.", {
-                    cause: { status: 404, code: 10008 }
-                  });
-              }
-            })
-          });
-      }
-    }
-  });
-};
-const ctxReceive = async (incoming, ctx, config) => {
-  const gatewayInteraction = z.object({ event: z.literal("INTERACTION_CREATE"), data: jsonValueSchema }).safeParse(incoming);
-  const input = gatewayInteraction.success ? gatewayInteraction.data.data : incoming;
-  const command = z.object({
-    id: z.string(),
-    type: z.literal(2),
-    channel_id: z.string(),
-    guild_id: z.string().optional(),
-    channel: z.object({ type: z.number(), parent_id: z.string().nullish(), name: z.string().optional() }).optional(),
-    member: z.object({ user: z.object({ id: z.string() }) }).optional(),
-    user: z.object({ id: z.string() }).optional(),
-    data: z.object({
-      name: z.literal("final"),
-      options: z.array(z.object({ name: z.string() })).optional()
-    })
-  }).safeParse(input);
-  if (command.success) {
-    const user = command.data.member?.user.id ?? command.data.user?.id;
-    if (user == null) return { ignored: true, reason: "missing-command-user" };
-    const principal = { id: user };
-    const by = await personFor(ctx, principal);
-    const verb = command.data.data.options?.[0]?.name;
-    const respond = async (text3) => {
-      await ctx.store.set(stateKey("discord-command-response", command.data.id), text3, {
-        ttlSeconds: 900
-      });
-      return { accepted: true };
-    };
-    if (typeof by !== "string") return respond(`${by.message} ${by.linkUrl ?? ""}`);
-    if (verb === "unlink") {
-      await ctx.people.revoke({ principal, reason: "provider-revoked" });
-      return respond("Unlinked your Discord account.");
-    }
-    let metadata = command.data.channel ?? null;
-    if (metadata == null && command.data.guild_id != null) {
-      try {
-        metadata = z.object({
-          type: z.number(),
-          parent_id: z.string().nullish(),
-          name: z.string().optional()
-        }).parse(await api(ctx, `/channels/${command.data.channel_id}`));
-      } catch {
-        return respond(
-          "This app cannot read the channel. Invite it or open Final to manage the connection."
-        );
-      }
-    }
-    const thread = metadata != null && [10, 11, 12].includes(metadata.type);
-    const place2 = {
-      kind: command.data.guild_id == null ? "dm" : thread ? "thread" : "channel",
-      ...command.data.guild_id == null ? {} : { tenant: command.data.guild_id },
-      id: command.data.channel_id,
-      ...metadata?.name == null ? {} : { title: metadata.name },
-      ...thread && metadata?.parent_id != null ? { parent: { kind: "channel", id: metadata.parent_id, tenant: command.data.guild_id } } : {}
-    };
-    let text2;
-    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 {
-      const route = await ctx.places.resolve(place2);
-      text2 = route.kind === "connected" ? "This place is connected to Final." : `Connect this place in Final: ${route.connectUrl}`;
-    }
-    return respond(text2);
-  }
-  const interaction = z.object({
-    type: z.number(),
-    member: z.object({ user: z.object({ id: z.string() }) }).optional(),
-    user: z.object({ id: z.string() }).optional(),
-    data: z.object({ custom_id: z.string().optional() }).optional()
-  }).safeParse(input);
-  if (interaction.success && interaction.data.type === 3) {
-    const user = interaction.data.member?.user.id ?? interaction.data.user?.id;
-    const id = interaction.data.data?.custom_id;
-    if (user == null || id == null) return { ignored: true, reason: "invalid-action" };
-    const saved = z.object({ user: z.string(), decisionId: z.string(), outcome: jsonValueSchema }).safeParse(await ctx.store.get(stateKey("discord-decision", id)));
-    if (!saved.success || saved.data.user !== user)
-      return {
-        accepted: false,
-        refusal: {
-          refused: "no-access",
-          message: saved.success ? "Only the requester can answer this decision." : "This approval expired. Answer in Final."
-        }
-      };
-    if (await ctx.store.get(stateKey("discord-decision-resolved", saved.data.decisionId)) != null)
-      return {
-        accepted: false,
-        refusal: {
-          refused: "no-access",
-          message: "This decision has already been answered in Final."
-        }
-      };
-    const by = await personFor(ctx, { id: user });
-    if (typeof by !== "string") return { accepted: false, refusal: by };
-    const result2 = await ctx.decisions.resolve({
-      decisionId: saved.data.decisionId,
-      outcome: saved.data.outcome,
-      by
-    });
-    if ("refused" in result2) return { accepted: false, refusal: result2 };
-    await confirmDecision(ctx, saved.data.decisionId);
-    return result2.resolved ? { accepted: true } : {
-      accepted: false,
-      refusal: {
-        refused: "no-access",
-        message: "This decision has already been answered in Final."
-      }
-    };
-  }
-  const event = z.object({ event: z.string(), data: jsonValueSchema }).safeParse(input);
-  if (!event.success) return { ignored: true, reason: "unsupported-event" };
-  if (event.data.event === "GUILD_DELETE") {
-    const guild = z.object({ id: z.string(), unavailable: z.boolean().optional() }).safeParse(event.data.data);
-    if (!guild.success || guild.data.unavailable === true)
-      return { ignored: true, reason: "guild-unavailable" };
-    await ctx.people.revoke({ tenant: guild.data.id, reason: "uninstalled" });
-    return { accepted: true };
-  }
-  if (event.data.event === "MESSAGE_DELETE_BULK") {
-    const bulk = z.object({ channel_id: z.string(), ids: z.array(z.string()).max(100) }).safeParse(event.data.data);
-    if (!bulk.success) return { ignored: true, reason: "invalid-bulk-delete" };
-    let refusal = null;
-    for (const id of bulk.data.ids) {
-      const result2 = await ctxReceive(
-        { event: "MESSAGE_DELETE", data: { channel_id: bulk.data.channel_id, id } },
-        ctx,
-        config
-      );
-      if ("accepted" in result2 && !result2.accepted) refusal ??= result2;
-    }
-    return refusal ?? { accepted: true };
-  }
-  if (event.data.event !== "MESSAGE_CREATE") {
-    const change = z.object({
-      id: z.string().optional(),
-      channel_id: z.string(),
-      author: z.object({ id: z.string() }).optional(),
-      content: z.string().optional(),
-      user_id: z.string().optional(),
-      message_id: z.string().optional(),
-      emoji: z.object({ name: z.string(), id: z.string().nullish() }).optional()
-    }).safeParse(event.data.data);
-    if (!change.success) return { ignored: true, reason: "unsupported-change" };
-    const messageId = change.data.message_id ?? change.data.id;
-    if (messageId == null) return { ignored: true, reason: "missing-message" };
-    const saved = z.object({
-      principal: z.object({ id: z.string() }),
-      externalKey: z.string(),
-      turnId: z.string().optional(),
-      place: placeRefSchema
-    }).safeParse(
-      await ctx.store.get(stateKey("discord-origin", change.data.channel_id, messageId))
-    );
-    if (!saved.success) return { ignored: true, reason: "unknown-origin" };
-    const by = await personFor(ctx, {
-      id: change.data.user_id ?? change.data.author?.id ?? saved.data.principal.id
-    });
-    if (typeof by !== "string") return { accepted: false, refusal: by };
-    const route = await ctx.places.resolve(saved.data.place);
-    if (route.kind !== "connected") return { ignored: true, reason: "unconnected" };
-    const conversation = ctx.conversation(route.conversation);
-    const key2 = saved.data.externalKey;
-    if (saved.data.turnId != null && (event.data.event === "MESSAGE_DELETE" || event.data.event === "MESSAGE_UPDATE"))
-      return { ignored: true, reason: "provider-reply-mutation" };
-    if (event.data.event === "MESSAGE_DELETE") {
-      const result2 = await conversation.remove({ externalKey: key2, by });
-      return "refused" in result2 ? { accepted: false, refusal: result2 } : { accepted: true };
-    }
-    if (event.data.event === "MESSAGE_UPDATE" && change.data.content != null) {
-      if (change.data.content.trim().length === 0)
-        return { ignored: true, reason: "provider-content-unavailable" };
-      const text2 = normalizedText(change.data.content, await botFor(ctx, config));
-      if (text2.length === 0) return { ignored: true, reason: "empty-message" };
-      const result2 = await conversation.edit({
-        externalKey: key2,
-        by,
-        content: [{ type: "text", text: text2 }]
-      });
-      return "refused" in result2 ? { accepted: false, refusal: result2 } : { accepted: true };
-    }
-    if ((event.data.event === "MESSAGE_REACTION_ADD" || event.data.event === "MESSAGE_REACTION_REMOVE") && change.data.emoji != null) {
-      const result2 = await conversation.react({
-        target: saved.data.turnId == null ? { externalKey: key2 } : { replyOf: { externalKey: key2, turnId: saved.data.turnId } },
-        by,
-        emoji: change.data.emoji.id == null ? change.data.emoji.name : `${change.data.emoji.name}:${change.data.emoji.id}`,
-        op: event.data.event === "MESSAGE_REACTION_ADD" ? "add" : "remove"
-      });
-      return "refused" in result2 ? { accepted: false, refusal: result2 } : { accepted: true };
-    }
-    return { ignored: true, reason: "unsupported-change" };
-  }
-  const parsed = messageSchema.safeParse(event.data.data);
-  if (!parsed.success || parsed.data.author.bot === true)
-    return { ignored: true, reason: "not-human" };
-  const message = parsed.data;
-  const botId = await botFor(ctx, config);
-  if (message.guild_id != null && !message.mentions.some((mention) => mention.id === botId))
-    return { ignored: true, reason: "not-mentioned" };
-  const text = normalizedText(message.content, botId);
-  if (text.length === 0) return { ignored: true, reason: "empty-message" };
-  let channelData;
-  try {
-    channelData = await api(ctx, `/channels/${message.channel_id}`);
-  } catch (error) {
-    const failed = z.object({ cause: z.object({ status: z.number() }) }).safeParse(error);
-    if (failed.success && (failed.data.cause.status === 403 || failed.data.cause.status === 404))
-      return { ignored: true, reason: "provider-place-unavailable" };
-    throw error;
-  }
-  const channel = z.object({
-    id: z.string(),
-    type: z.number(),
-    parent_id: z.string().nullish(),
-    name: z.string().optional()
-  }).parse(channelData);
-  const place = {
-    kind: message.guild_id == null ? "dm" : [10, 11, 12].includes(channel.type) ? "thread" : "channel",
-    id: channel.id,
-    ...message.guild_id == null ? {} : { tenant: message.guild_id },
-    ...channel.name == null ? {} : { title: channel.name },
-    ...channel.parent_id == null || ![10, 11, 12].includes(channel.type) ? {} : {
-      parent: {
-        kind: "channel",
-        id: channel.parent_id,
-        ...message.guild_id == null ? {} : { tenant: message.guild_id }
-      }
-    }
-  };
-  await api(ctx, `/channels/${channel.id}/typing`, {}).catch(
-    () => ctx.log("Discord typing indicator unavailable.")
-  );
-  const key = externalKey(
-    {
-      kind: "channel",
-      id: channel.id,
-      ...message.guild_id == null ? {} : { tenant: message.guild_id }
-    },
-    message.id
-  );
-  let replyChannel = channel.id;
-  const person = await ctx.people.resolve({ id: message.author.id });
-  const connected = await ctx.places.resolve(place);
-  if (place.kind === "channel" && person.kind === "member" && connected.kind === "connected") {
-    const threadKey = stateKey("discord-thread", channel.id, message.id);
-    const savedThread = z.string().safeParse(await ctx.store.get(threadKey));
-    if (savedThread.success) replyChannel = savedThread.data;
-    else {
-      try {
-        replyChannel = z.object({ id: z.string() }).parse(
-          await api(ctx, `/channels/${channel.id}/messages/${message.id}/threads`, {
-            name: message.content.replace(/<@!?[0-9A-Za-z_-]+>/g, "").trim().slice(0, 80) || "Final",
-            auto_archive_duration: 1440
-          })
-        ).id;
-        await ctx.store.set(threadKey, replyChannel, deliveryRetention);
-      } catch {
-        const existing = await api(ctx, `/channels/${channel.id}/messages/${message.id}`).then((value) => z.object({ thread: z.object({ id: z.string() }) }).safeParse(value)).catch(() => null);
-        if (existing?.success === true) {
-          replyChannel = existing.data.thread.id;
-          await ctx.store.set(threadKey, replyChannel, deliveryRetention);
-        } else ctx.log("Discord thread unavailable; replying in the source channel.");
-      }
-    }
-  }
-  const result = await receivePersonMessage({
-    ctx,
-    principal: { id: message.author.id, displayName: message.author.username },
-    place,
-    resumeAfterLink: place.kind === "dm",
-    text,
-    externalKey: key,
-    loadContext: async () => config.history === "linked-members" ? await historyFor({
-      ctx,
-      channel: channel.id,
-      currentMessage: message.id,
-      bot: botId
-    }).catch(() => {
-      ctx.log("Discord history is unavailable for this app grant.");
-      return [];
-    }) : [],
-    ref: {
-      externalKey: key,
-      channel: channel.id,
-      replyChannel,
-      messageId: message.id,
-      requester: message.author.id
-    }
-  });
-  await ctx.store.set(
-    stateKey("discord-origin", channel.id, message.id),
-    jsonValueSchema.parse({
-      principal: { id: message.author.id },
-      externalKey: key,
-      place
-    }),
-    deliveryRetention
-  );
-  if ("accepted" in result && !result.accepted) {
-    try {
-      const dm = z.object({ id: z.string() }).parse(await api(ctx, "/users/@me/channels", { recipient_id: message.author.id }));
-      await api(ctx, `/channels/${dm.id}/messages`, {
-        content: `${result.refusal.message} ${result.refusal.linkUrl ?? result.refusal.connectUrl ?? ""}`
-      });
-    } catch {
-      try {
-        await api(ctx, `/channels/${replyChannel}/messages`, {
-          content: "This request could not be handled here. Open Final to link your account or manage this place.",
-          allowed_mentions: { parse: [] }
-        });
-      } catch {
-        ctx.log("Discord requester notice unavailable.");
-      }
-    }
-  }
-  return result;
-};
-const historyFor = async (args) => {
-  const { ctx, channel, currentMessage, bot } = args;
-  const messages = z.array(messageSchema).parse(
-    await api(
-      ctx,
-      `/channels/${channel}/messages?limit=20&before=${encodeURIComponent(currentMessage)}`
-    )
-  );
-  const lines = [];
-  const authors = /* @__PURE__ */ new Map();
-  for (const message of messages.reverse()) {
-    if (message.id === currentMessage || message.author.bot === true || message.content.trim().length === 0)
-      continue;
-    if (!authors.has(message.author.id)) {
-      const person = await ctx.people.resolve({ id: message.author.id });
-      authors.set(message.author.id, person.kind === "member" ? person.displayName : null);
-    }
-    const name = authors.get(message.author.id);
-    if (name != null) {
-      const text = normalizedText(message.content, bot);
-      if (text.length > 0) lines.push(`${name}: ${text}`);
-    }
-  }
-  return lines;
-};
-export {
-  discordChannel
-};
-//# sourceMappingURL=discord.mjs.map