@effect-uai/telegram 0.14.0

package/src/Telegram.ts

@@ -0,0 +1,417 @@
+import {
+  Array as Arr,
+  type Cause,
+  Context,
+  Duration,
+  Effect,
+  Encoding,
+  Layer,
+  Match,
+  Option,
+  Queue,
+  Ref,
+  Schedule,
+  Schema,
+  type Scope,
+  Stream,
+} from "effect"
+import { HttpClient } from "effect/unstable/http"
+import type { MediaSource } from "@effect-uai/core/Media"
+import {
+  CurrentConversation,
+  type ConversationRef,
+  type InboundEvent,
+  MessageId,
+  Messenger,
+  type MessengerLimits,
+  type MessengerService,
+  type Outbound,
+  type OutboundBody,
+} from "@effect-uai/core/Messenger"
+import {
+  type StreamViaEditsOptions,
+  splitForLimit,
+  streamViaEdits,
+} from "@effect-uai/core/MessengerAdapter"
+import * as MessengerError from "@effect-uai/core/MessengerError"
+import * as Api from "./internal/api.js"
+import * as Events from "./internal/events.js"
+
+export type { BotIdentity } from "./internal/events.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/** Telegram's own markup modes. `Text` bodies are sent verbatim under one. */
+export type ParseMode = "HTML" | "MarkdownV2" | "Markdown"
+
+export type Config = Api.Config & {
+  /**
+   * Markup the model is prompted to write. Default `"HTML"`; `"plain"` sends
+   * text with no `parse_mode` at all.
+   */
+  readonly parseMode?: ParseMode | "plain"
+  /** Long-poll wait per `getUpdates` call. Default 30 seconds. */
+  readonly pollTimeout?: Duration.Input
+  /** Tuning for `stream`, which is post-then-edit on Telegram. */
+  readonly stream?: StreamViaEditsOptions
+}
+
+export type TelegramService = MessengerService & {
+  /** From `getMe` at layer build: the identity behind `addressed`. */
+  readonly bot: Events.BotIdentity
+}
+
+/**
+ * Provider-typed tag. Yield this for the bot identity; yield the generic
+ * `Messenger` tag for provider-portable code. Both are registered by {@link layer}.
+ */
+export class Telegram extends Context.Service<Telegram, TelegramService>()(
+  "@betalyra/effect-uai/providers/telegram/Telegram",
+) {}
+
+export const limits: MessengerLimits = { maxText: 4096, maxCaption: 1024 }
+
+// ---------------------------------------------------------------------------
+// Wire results
+// ---------------------------------------------------------------------------
+
+const Me = Schema.Struct({ id: Schema.Number, username: Schema.String })
+const Sent = Schema.Struct({ message_id: Schema.Number })
+const Updates = Schema.Array(Events.Update)
+const RawCall = Schema.Struct({
+  method: Schema.String,
+  params: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+})
+
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+
+const isApiFailure = (e: Api.ApiError): e is Api.ApiFailure => e._tag === "TelegramApiFailure"
+
+const describes = (needle: string) => (e: Api.ApiError) =>
+  isApiFailure(e) && e.description.includes(needle)
+
+const reasonOf = (e: Api.ApiError): string => (isApiFailure(e) ? e.description : "rate limited")
+
+/** An API rejection becomes the verb's `MessengerRequestFailed`; typed errors pass through. */
+const requestFailed =
+  (operation: MessengerError.MessengerOperation) =>
+  (e: Api.ApiError | MessengerError.MessengerError): MessengerError.MessengerError =>
+    Match.value(e).pipe(
+      Match.tag(
+        "TelegramApiFailure",
+        (failure) =>
+          new MessengerError.MessengerRequestFailed({
+            provider: Api.provider,
+            operation,
+            reason: failure.description,
+            raw: failure.raw,
+          }),
+      ),
+      Match.orElse((typed) => typed),
+    )
+
+const unsupported = (capability: string, reason: string) =>
+  new MessengerError.MessengerUnsupported({ provider: Api.provider, capability, reason })
+
+// 401 is a dead token and 409 a second poller on it; nothing else ends the stream.
+const isFatalPoll = (e: Api.ApiError) => isApiFailure(e) && (e.code === 401 || e.code === 409)
+
+// Transient poll failures wait five seconds, or exactly what a 429 asked for.
+const pollBackoff: Schedule.Schedule<number, Api.ApiError> = Schedule.forever.pipe(
+  Schedule.setInputType<Api.ApiError>(),
+  Schedule.modifyDelay(({ input }) =>
+    Effect.succeed(input._tag === "MessengerRateLimited" ? input.retryAfter : Duration.seconds(5)),
+  ),
+)
+
+// ---------------------------------------------------------------------------
+// Outbound params
+// ---------------------------------------------------------------------------
+
+const target = (at: ConversationRef): Api.Params => ({
+  chat_id: at.channel,
+  ...(at.thread !== undefined && { message_thread_id: Number(at.thread) }),
+})
+
+const replyParams = (msg: Outbound): Api.Params =>
+  msg.replyTo === undefined ? {} : { reply_parameters: { message_id: Number(msg.replyTo) } }
+
+const parseParams = (cfg: Config): Api.Params =>
+  cfg.parseMode === "plain" ? {} : { parse_mode: cfg.parseMode ?? "HTML" }
+
+type MediaRoute = { readonly method: string; readonly field: string }
+
+/** The endpoint a `MediaSource` goes through, decided by its MIME type. */
+const mediaRoute = (media: MediaSource): MediaRoute =>
+  Match.value(media.mimeType ?? "").pipe(
+    Match.when(
+      (m) => m.startsWith("image/"),
+      (): MediaRoute => ({ method: "sendPhoto", field: "photo" }),
+    ),
+    Match.when(
+      (m) => m.startsWith("audio/"),
+      (): MediaRoute => ({ method: "sendAudio", field: "audio" }),
+    ),
+    Match.when(
+      (m) => m.startsWith("video/"),
+      (): MediaRoute => ({ method: "sendVideo", field: "video" }),
+    ),
+    Match.orElse((): MediaRoute => ({ method: "sendDocument", field: "document" })),
+  )
+
+const defaultFilename = (media: MediaSource): string =>
+  `file.${media.mimeType?.split("/")[1] ?? "bin"}`
+
+const invalidMedia = (raw: unknown) =>
+  new MessengerError.MessengerRequestFailed({
+    provider: Api.provider,
+    operation: "post",
+    reason: "invalid base64 media",
+    raw,
+  })
+
+// ---------------------------------------------------------------------------
+// Service
+// ---------------------------------------------------------------------------
+
+export const make = (
+  cfg: Config,
+): Effect.Effect<
+  TelegramService,
+  MessengerError.MessengerConnectFailed,
+  HttpClient.HttpClient | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    // Captured once so the verbs need no `HttpClient` of their own.
+    const client = yield* HttpClient.HttpClient
+    const withClient = Effect.provideService(HttpClient.HttpClient, client)
+    const call = (method: string, params?: Api.Params) => withClient(Api.call(cfg)(method, params))
+    const upload = (method: string, params: Api.Params, file: Api.Upload) =>
+      withClient(Api.upload(cfg)(method, params, file))
+
+    const bot = yield* call("getMe").pipe(
+      Api.decoded("getMe", Me),
+      Effect.mapError(
+        (e) =>
+          new MessengerError.MessengerConnectFailed({
+            provider: Api.provider,
+            reason: reasonOf(e),
+            raw: e.raw,
+          }),
+      ),
+    )
+
+    // -- inbound -----------------------------------------------------------
+
+    const inbox = yield* Queue.unbounded<InboundEvent, MessengerError.MessengerError | Cause.Done>()
+    const offset = yield* Ref.make(0)
+    const toEvents = Events.toEvents(bot)
+
+    // Answered before the event is offered, so the client's spinner never
+    // waits on the recipe.
+    const acknowledge = (update: Events.Update) =>
+      Match.value(update).pipe(
+        Match.when({ callback_query: Match.defined }, ({ callback_query }) =>
+          call("answerCallbackQuery", { callback_query_id: callback_query.id }).pipe(Effect.ignore),
+        ),
+        Match.orElse(() => Effect.void),
+      )
+
+    const poll = Effect.gen(function* () {
+      const updates = yield* call("getUpdates", {
+        offset: yield* Ref.get(offset),
+        timeout: Duration.toSeconds(cfg.pollTimeout ?? "30 seconds"),
+        allowed_updates: Events.allowedUpdates,
+      }).pipe(Api.decoded("getUpdates", Updates))
+      yield* Effect.forEach(updates, (update) =>
+        Effect.gen(function* () {
+          yield* Ref.set(offset, update.update_id + 1)
+          yield* acknowledge(update)
+          yield* Queue.offerAll(inbox, toEvents(update))
+        }),
+      )
+    })
+
+    // Transient failures (network, 5xx, 429) back off and poll again; fatal
+    // ones end the stream with `MessengerTransportClosed`.
+    yield* poll.pipe(
+      Effect.retry({ while: (e) => !isFatalPoll(e), schedule: pollBackoff }),
+      Effect.forever,
+      Effect.catch((e) =>
+        Queue.fail(
+          inbox,
+          new MessengerError.MessengerTransportClosed({
+            provider: Api.provider,
+            reason: reasonOf(e),
+            raw: e.raw,
+          }),
+        ),
+      ),
+      Effect.ensuring(Queue.end(inbox)),
+      Effect.forkScoped,
+    )
+
+    // -- outbound ----------------------------------------------------------
+
+    // Telegram rejects markup it cannot parse; the same text then goes out plain.
+    const sendText = (method: string, params: Api.Params) =>
+      call(method, { ...params, ...parseParams(cfg) }).pipe(
+        Effect.catchIf(describes("can't parse entities"), () => call(method, params)),
+      )
+
+    const sendMedia = (
+      at: ConversationRef,
+      msg: Outbound,
+      body: Extract<OutboundBody, { _tag: "Media" }>,
+    ) => {
+      const { method, field } = mediaRoute(body.media)
+      const params = {
+        ...target(at),
+        ...replyParams(msg),
+        ...(body.caption !== undefined && { caption: body.caption, ...parseParams(cfg) }),
+      }
+      const send = (bytes: Uint8Array, mimeType: string) =>
+        upload(method, params, {
+          field,
+          bytes,
+          filename: body.filename ?? defaultFilename(body.media),
+          mimeType,
+        })
+      return Match.value(body.media).pipe(
+        Match.tag("url", ({ url }) => call(method, { ...params, [field]: url })),
+        Match.tag("bytes", ({ bytes, mimeType }) => send(bytes, mimeType)),
+        Match.tag("base64", ({ base64, mimeType }) =>
+          Effect.fromResult(Encoding.decodeBase64(base64)).pipe(
+            Effect.mapError(invalidMedia),
+            Effect.flatMap((bytes) => send(bytes, mimeType)),
+          ),
+        ),
+        Match.exhaustive,
+      )
+    }
+
+    const sendRaw = (payload: unknown) =>
+      Effect.gen(function* () {
+        const { method, params } = yield* Schema.decodeUnknownEffect(RawCall)(payload).pipe(
+          Effect.mapError(
+            () =>
+              new MessengerError.MessengerRequestFailed({
+                provider: Api.provider,
+                operation: "post",
+                reason: "raw payload must be { method, params? }",
+                raw: payload,
+              }),
+          ),
+        )
+        return yield* call(method, params)
+      })
+
+    // The reply lands on the first chunk; the id is the last one's.
+    const sendChunks = (at: ConversationRef, msg: Outbound, text: string) =>
+      Effect.gen(function* () {
+        const [first, ...rest] = splitForLimit(text, limits.maxText)
+        const send = (chunk: string, extra: Api.Params) =>
+          sendText("sendMessage", { ...target(at), ...extra, text: chunk }).pipe(
+            Api.decoded("sendMessage", Sent),
+          )
+        const head = yield* send(first, replyParams(msg))
+        const tail = yield* Effect.forEach(rest, (chunk) => send(chunk, {}))
+        return Option.getOrElse(Arr.last(tail), () => head)
+      })
+
+    const post: MessengerService["post"] = (msg) =>
+      Effect.gen(function* () {
+        const at = yield* CurrentConversation
+        const sent = yield* Match.value(msg.body).pipe(
+          Match.tag("Text", ({ text }) => sendChunks(at, msg, text)),
+          Match.tag("Media", (body) =>
+            sendMedia(at, msg, body).pipe(Api.decoded("sendMedia", Sent)),
+          ),
+          Match.tag("Raw", ({ payload }) => sendRaw(payload).pipe(Api.decoded("raw", Sent))),
+          Match.exhaustive,
+        )
+        return MessageId(String(sent.message_id))
+      }).pipe(Effect.mapError(requestFailed("post")))
+
+    const edit: MessengerService["edit"] = (ref, next) =>
+      Match.value(next.body).pipe(
+        Match.tag("Text", ({ text }) =>
+          sendText("editMessageText", {
+            chat_id: ref.conversation.channel,
+            message_id: Number(ref.id),
+            text,
+          }).pipe(Effect.asVoid, Effect.mapError(requestFailed("edit"))),
+        ),
+        Match.tag("Raw", ({ payload }) =>
+          sendRaw(payload).pipe(Effect.asVoid, Effect.mapError(requestFailed("edit"))),
+        ),
+        Match.tag("Media", () =>
+          Effect.fail(unsupported("media edits", "send a new message instead")),
+        ),
+        Match.exhaustive,
+      )
+
+    // Telegram allows a fixed emoji set; anything else is REACTION_INVALID.
+    const react: MessengerService["react"] = (ref, emoji) =>
+      call("setMessageReaction", {
+        chat_id: ref.conversation.channel,
+        message_id: Number(ref.id),
+        reaction: [{ type: "emoji", emoji }],
+      }).pipe(
+        Effect.asVoid,
+        Effect.catchIf(describes("REACTION_INVALID"), () =>
+          Effect.fail(unsupported("reaction", `${emoji} is not in Telegram's reaction set`)),
+        ),
+        Effect.mapError(requestFailed("react")),
+      )
+
+    // The indicator lasts about five seconds, so it is re-sent every four
+    // until the scope closes. The first send is awaited so a bad chat fails here.
+    const typing: MessengerService["typing"] = Effect.gen(function* () {
+      const at = yield* CurrentConversation
+      const once = call("sendChatAction", { ...target(at), action: "typing" })
+      yield* once.pipe(Effect.mapError(requestFailed("typing")))
+      yield* once.pipe(
+        Effect.ignore,
+        Effect.schedule(Schedule.spaced("4 seconds")),
+        Effect.forkScoped,
+      )
+    })
+
+    return {
+      bot,
+      events: Stream.fromQueue(inbox),
+      post,
+      edit,
+      react,
+      typing,
+      stream: streamViaEdits({ post, edit, limits }, cfg.stream),
+      limits,
+    }
+  })
+
+// ---------------------------------------------------------------------------
+// Layer
+// ---------------------------------------------------------------------------
+
+/**
+ * One poller, registered under both the `Telegram` and `Messenger` tags. The
+ * long-poll loop starts when the layer is built and stops when its scope
+ * closes; `events` ends with it. Telegram allows one poller per token.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<
+  Telegram | Messenger,
+  MessengerError.MessengerConnectFailed,
+  HttpClient.HttpClient
+> =>
+  Layer.effectContext(
+    Effect.map(make(cfg), (service) =>
+      Context.make(Telegram, service).pipe(Context.add(Messenger, service)),
+    ),
+  )

package/src/index.ts

@@ -0,0 +1 @@
+export * as Telegram from "./Telegram.js"

package/src/internal/api.ts

@@ -0,0 +1,133 @@
+import { Array as Arr, Data, Duration, Effect, Redacted, Result, Schema, pipe } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as MessengerError from "@effect-uai/core/MessengerError"
+import * as Multipart from "@effect-uai/core/Multipart"
+
+export const provider = "telegram"
+
+export type Config = {
+  readonly token: Redacted.Redacted
+  /** Defaults to `https://api.telegram.org`. */
+  readonly baseUrl?: string
+}
+
+/**
+ * A Bot API call that came back `ok: false` or never came back at all.
+ * `code` mirrors the HTTP status Telegram puts in `error_code`; each verb
+ * maps this onto its own `MessengerError`.
+ */
+export class ApiFailure extends Data.TaggedError("TelegramApiFailure")<{
+  readonly method: string
+  readonly code?: number
+  readonly description: string
+  readonly raw: unknown
+}> {}
+
+export type ApiError = ApiFailure | MessengerError.MessengerRateLimited
+
+const Envelope = Schema.Struct({
+  ok: Schema.Boolean,
+  result: Schema.optional(Schema.Unknown),
+  description: Schema.optional(Schema.String),
+  error_code: Schema.optional(Schema.Number),
+  parameters: Schema.optional(Schema.Struct({ retry_after: Schema.optional(Schema.Number) })),
+})
+
+export type Params = Readonly<Record<string, unknown>>
+
+/** The file part of a multipart upload. */
+export type Upload = {
+  readonly field: string
+  readonly bytes: Uint8Array
+  readonly filename: string
+  readonly mimeType: string
+}
+
+const endpoint = (cfg: Config, method: string): string =>
+  `${cfg.baseUrl ?? "https://api.telegram.org"}/bot${Redacted.value(cfg.token)}/${method}`
+
+const transportFailure = (method: string) => (raw: unknown) =>
+  new ApiFailure({ method, description: "transport failure", raw })
+
+const rejected = (method: string, envelope: typeof Envelope.Type): ApiError =>
+  envelope.parameters?.retry_after !== undefined
+    ? new MessengerError.MessengerRateLimited({
+        provider,
+        retryAfter: Duration.seconds(envelope.parameters.retry_after),
+        raw: envelope,
+      })
+    : new ApiFailure({
+        method,
+        ...(envelope.error_code !== undefined && { code: envelope.error_code }),
+        description: envelope.description ?? "unknown error",
+        raw: envelope,
+      })
+
+const send = (
+  method: string,
+  request: HttpClientRequest.HttpClientRequest,
+): Effect.Effect<unknown, ApiError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const response = yield* client.execute(request).pipe(Effect.mapError(transportFailure(method)))
+    const json = yield* response.json.pipe(Effect.mapError(transportFailure(method)))
+    const envelope = yield* Schema.decodeUnknownEffect(Envelope)(json).pipe(
+      Effect.mapError(
+        () => new ApiFailure({ method, description: "malformed envelope", raw: json }),
+      ),
+    )
+    return envelope.ok ? envelope.result : yield* rejected(method, envelope)
+  })
+
+/** One JSON-bodied method call. `result` comes back undecoded. */
+export const call =
+  (cfg: Config) =>
+  (method: string, params: Params = {}): Effect.Effect<unknown, ApiError, HttpClient.HttpClient> =>
+    send(
+      method,
+      HttpClientRequest.post(endpoint(cfg, method)).pipe(HttpClientRequest.bodyJsonUnsafe(params)),
+    )
+
+type Entry = readonly [name: string, value: string | File]
+
+// A `File` carries its own filename, so one entry shape covers both kinds.
+const entries = (params: Params, file: Upload): ReadonlyArray<Entry> =>
+  pipe(
+    Object.entries(params),
+    Arr.filterMap(([name, value]) =>
+      value === undefined ? Result.failVoid : Result.succeed([name, String(value)] as const),
+    ),
+    Arr.append([
+      file.field,
+      new File([file.bytes as Uint8Array<ArrayBuffer>], file.filename, { type: file.mimeType }),
+    ] as const),
+  )
+
+const formData = (fields: ReadonlyArray<Entry>): FormData =>
+  fields.reduce((form, [name, value]) => (form.append(name, value), form), new FormData())
+
+/** One multipart method call: string fields plus a single file part. */
+export const upload =
+  (cfg: Config) =>
+  (
+    method: string,
+    params: Params,
+    file: Upload,
+  ): Effect.Effect<unknown, ApiError, HttpClient.HttpClient> =>
+    Effect.gen(function* () {
+      const body = yield* Multipart.bodyMultipart(formData(entries(params, file))).pipe(
+        Effect.mapError(transportFailure(method)),
+      )
+      return yield* send(method, HttpClientRequest.post(endpoint(cfg, method)).pipe(body))
+    })
+
+/** Decode a call's `result`; a shape mismatch is a malformed response, not a defect. */
+export const decoded =
+  <A>(method: string, schema: Schema.Decoder<A>) =>
+  <E, R>(result: Effect.Effect<unknown, E, R>): Effect.Effect<A, E | ApiFailure, R> =>
+    Effect.gen(function* () {
+      const raw = yield* result
+      return yield* Schema.decodeUnknownEffect(schema)(raw).pipe(
+        Effect.mapError(() => new ApiFailure({ method, description: "malformed result", raw })),
+      )
+    })

package/src/internal/events.test.ts

@@ -0,0 +1,112 @@
+import { Schema } from "effect"
+import { describe, expect, it } from "vitest"
+import { type BotIdentity, Update, toEvents } from "./events.js"
+
+const bot: BotIdentity = { id: 42, username: "HelperBot" }
+const events = toEvents(bot)
+
+const alice = { id: 7, is_bot: false, username: "alice" }
+const group = { id: -100123, type: "supergroup" }
+
+/** A `message` update through the real decoder, as the poller hands it over. */
+const message = (fields: Record<string, unknown>) =>
+  events(
+    Schema.decodeUnknownSync(Update)({
+      update_id: 1,
+      message: { message_id: 10, from: alice, chat: group, ...fields },
+    }),
+  )[0]
+
+const entity = (type: string, text: string, needle: string) => ({
+  type,
+  offset: text.indexOf(needle),
+  length: needle.length,
+})
+
+describe("addressed", () => {
+  it("is a DM, a mention, or a reply to the bot, and nothing else", () => {
+    const mentioned = "@helperbot ping"
+    expect(message({ chat: { id: 7, type: "private" }, text: "hi" })).toMatchObject({
+      addressed: true,
+    })
+    expect(
+      message({ text: mentioned, entities: [entity("mention", mentioned, "@helperbot")] }),
+    ).toMatchObject({ addressed: true })
+    expect(
+      message({
+        text: "and?",
+        reply_to_message: { message_id: 9, from: { id: 42, is_bot: true } },
+      }),
+    ).toMatchObject({ addressed: true, replyTo: "9" })
+    expect(
+      message({ text: "and?", reply_to_message: { message_id: 9, from: alice } }),
+    ).toMatchObject({ addressed: false })
+    expect(message({ text: "lunch anyone" })).toMatchObject({ addressed: false })
+  })
+
+  it("strips only the bot's own mention, wherever it sits", () => {
+    const text = "@alice ask @HelperBot: what time is it?"
+    expect(
+      message({
+        text,
+        entities: [entity("mention", text, "@alice"), entity("mention", text, "@HelperBot")],
+      }),
+    ).toMatchObject({ text: "@alice ask : what time is it?" })
+  })
+})
+
+describe("commands", () => {
+  it("parses `/name@bot args` at offset 0 and strips the bot suffix", () => {
+    const text = "/search@HelperBot effect  streams"
+    expect(
+      message({ text, entities: [entity("bot_command", text, "/search@HelperBot")] }),
+    ).toMatchObject({ _tag: "Command", name: "search", args: "effect  streams" })
+  })
+
+  it("leaves a mid-text /word and another bot's command as plain messages", () => {
+    const mid = "try /help later"
+    const other = "/start@OtherBot"
+    expect(message({ text: mid, entities: [entity("bot_command", mid, "/help")] })).toMatchObject({
+      _tag: "Message",
+      text: mid,
+    })
+    expect(message({ text: other, entities: [entity("bot_command", other, other)] })).toMatchObject(
+      { _tag: "Message", addressed: false },
+    )
+  })
+})
+
+describe("threads", () => {
+  it("is the forum topic, never a reply chain's thread id", () => {
+    expect(message({ text: "a", message_thread_id: 5, is_topic_message: true })).toMatchObject({
+      conversation: { channel: "-100123", thread: "5" },
+    })
+    expect(message({ text: "b", message_thread_id: 5 })).toMatchObject({
+      conversation: { channel: "-100123" },
+    })
+    expect(message({ text: "b", message_thread_id: 5 })).not.toHaveProperty("conversation.thread")
+  })
+})
+
+describe("other updates", () => {
+  it("emits one Reaction per emoji and skips custom ones", () => {
+    const update = Schema.decodeUnknownSync(Update)({
+      update_id: 2,
+      message_reaction: {
+        chat: group,
+        message_id: 10,
+        user: alice,
+        new_reaction: [{ type: "emoji", emoji: "👍" }, { type: "custom_emoji" }],
+      },
+    })
+    expect(events(update)).toMatchObject([{ _tag: "Reaction", emoji: "👍", message: "10" }])
+  })
+
+  it("swallows edited messages so they are acked but never re-answered", () => {
+    const update = Schema.decodeUnknownSync(Update)({
+      update_id: 4,
+      edited_message: { message_id: 10, from: alice, chat: group, text: "edited" },
+    })
+    expect(events(update)).toEqual([])
+  })
+})