@vellumai/vellum-gateway 0.12.2-staging.6 → 0.12.2-staging.7

package/AGENTS.md

@@ -90,6 +90,8 @@ Gateway inbound events use a channel-discriminated union model (`GatewayInboundE
 
 Trust/guardian decisions must be keyed on `actorExternalId` only — never fall back to `conversationExternalId` for actor identity.
 
+**Room admission is one verdict, two adapter halves.** Whether the gateway acts on an inbound message at all is decided by `channels/room-admission.ts` over a neutral candidate: self and bot authors drop first, a direct chat is admitted on its own lane without a mention, a room only when the message addresses the bot, a chat kind the product does not serve is refused, and an unknown bot identity drops rather than admits. Each channel builds the candidate from its own facts (`discord/admit.ts`, `telegram/admit.ts`): how the platform proves a chat is direct (guild absence, `chat.type`) and how it proves a message is addressed (a mentions array, text entities, a reply to the bot's post). Extend the verdict, never a copy of it; a platform-only rule rides a neutral fact (Discord's legacy allow-list is `roomAllowed`). A drop is never silent: every channel logs it through `channels/admission-drop-log.ts`, one promoted line per reason and conversation, with a drop that names no conversation promoted every time. Slack's socket filter predates this and still carries the same rules inline; converging it is queued with the Slack envelope work.
+
 Physical DB column names (`externalUserId`, `externalChatId`) are unchanged; the rename is at the API/type layer only.
 
 **Provider words that are not our words.** A Discord **guild** is what Discord's
@@ -193,7 +195,7 @@ Both the flat (`/v1/channel-admission-policy/...`) and assistant-scoped (`/v1/as
 
 - **Gateway kill switch** — `handle-inbound.ts` enforces the `no_one` floor before forwarding. Zero contact-table lookups, zero daemon I/O, true kill.
 - **Runtime floor** — every other policy flows through the gateway unchanged; the runtime evaluates rank-vs-floor inside `admission-policy.ts`. This keeps the canonical gateway classifier (`gateway/src/risk/trust-verdict-resolver.ts`) as the single source of `TrustClass` truth (no fork): the runtime consumes the stamped verdict; the daemon's `actor-trust-resolver.ts` is only a residual sync guardian-or-unknown view for the vellum reset-drift path.
-- **Gateway vs runtime reciprocity** — the gateway section in `gateway/CLAUDE.md` records _which channels the gateway enforces_; the assistant section records _how the runtime classifies_. Either side getting out of sync is a bug, not an over-defended boundary.
+- **Gateway vs runtime reciprocity**: this section records _which channels the gateway enforces_; the runtime's evaluation lives in `assistant/src/runtime/routes/inbound-stages/admission-policy.ts`, which reads `TRUST_CLASS_RANK` and `ADMISSION_FLOOR` from the shared contract. Either side getting out of sync is a bug, not an over-defended boundary.
 
 **Adding a new policy**: extend the `AdmissionPolicy` union in `packages/gateway-client/src/admission-policy-contract.ts`, add its floor in `ADMISSION_FLOOR`, update the openapi schema, and update `gateway/src/__tests__/channel-admission-policy-routes.test.ts` + `assistant/src/runtime/routes/inbound-stages/admission-policy.test.ts`. Do not add a 6th floor without also bumping the `TRUST_CLASS_RANK` ceiling to match.
 

package/README.md

@@ -106,7 +106,7 @@ The gateway normalizes Telegram `callback_query` updates (inline button clicks)
 
 These fields are forwarded to the runtime in the `/channels/inbound` payload alongside the standard `conversationExternalId`, `externalMessageId`, and actor metadata. The runtime uses `callbackData` to route the click to the appropriate approval handler.
 
-**Normalization constraints:** Only DM-only (`private` chat type) callback queries are processed. Group and channel callbacks are dropped and acknowledged with `answerCallbackQuery` so the Telegram button spinner clears. Callback queries with no `data` field or no associated `message` are also dropped.
+**Normalization constraints:** Callback queries from private chats, groups, and supergroups are processed; a tap on a keyboard the bot posted is addressed to the bot by construction, and who may press it is the runtime's decision. Callbacks from broadcast channels are dropped and acknowledged with `answerCallbackQuery` so the Telegram button spinner clears. Callback queries with no `data` field or no associated `message` are also dropped. Every drop is logged with its reason before the update is acknowledged (`telegram/drop-log.ts`).
 
 **Stale callback blocking:** When the runtime receives `callbackData` that does not match any pending approval (e.g., a button from an old prompt), it returns `stale_ignored` and does not process the payload as a regular message. This is enforced regardless of whether the callback has non-empty content. The gateway sends a best-effort `answerCallbackQuery` acknowledgment for normalized callback updates (including stale, rejected, and forward-failure paths) so the button spinner clears promptly. Transient forwarding failures may still return `500` so Telegram retries update delivery.
 

package/node_modules/@vellumai/environments/src/shell.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   buildShellInvocation,
+  buildShellSpawnFlags,
   pathListDelimiter,
   prependUniquePathEntries,
 } from "./shell.js";
@@ -38,6 +39,26 @@ describe("buildShellInvocation", () => {
   });
 });
 
+describe("buildShellSpawnFlags", () => {
+  test("creates a POSIX process group and hides Windows consoles", () => {
+    expect(buildShellSpawnFlags("linux")).toEqual({
+      detached: true,
+      windowsHide: true,
+    });
+    expect(buildShellSpawnFlags("darwin")).toEqual({
+      detached: true,
+      windowsHide: true,
+    });
+  });
+
+  test("does not detach Windows children that use piped stdio", () => {
+    expect(buildShellSpawnFlags("win32")).toEqual({
+      detached: false,
+      windowsHide: true,
+    });
+  });
+});
+
 describe("path list handling", () => {
   test("uses the platform delimiter", () => {
     expect(pathListDelimiter("win32")).toBe(";");

package/node_modules/@vellumai/environments/src/shell.ts

@@ -5,6 +5,11 @@ export interface ShellInvocation {
   args: string[];
 }
 
+export interface ShellSpawnFlags {
+  detached: boolean;
+  windowsHide: true;
+}
+
 const WINDOWS_UTF8_PREAMBLE =
   "try { [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 } catch {}; " +
   "$OutputEncoding = [System.Text.Encoding]::UTF8; " +
@@ -43,6 +48,25 @@ export function buildShellInvocation(
   return { command: "bash", args: ["-c", "--", command] };
 }
 
+/**
+ * Spawn flags for assistant-owned shell children (sandbox bash, local
+ * host_bash fallback, sanitized CLI bash, skill runners, scheduled scripts).
+ *
+ * POSIX uses a new process group so timeout/abort can SIGKILL the tree via
+ * `-pid`. Windows process trees are torn down with `taskkill /T`, which does
+ * not need a detached process. Combining `DETACHED_PROCESS`,
+ * `CREATE_NO_WINDOW`, and piped stdio on Windows can emit `close` with exit
+ * 0 and empty pipes without running the encoded command.
+ */
+export function buildShellSpawnFlags(
+  hostPlatform: NodeJS.Platform = process.platform,
+): ShellSpawnFlags {
+  return {
+    detached: hostPlatform !== "win32",
+    windowsHide: true,
+  };
+}
+
 export function pathListDelimiter(
   hostPlatform: NodeJS.Platform = process.platform,
 ): string {

package/node_modules/@vellumai/gateway-client/src/inbound-contract.ts

@@ -83,8 +83,14 @@ export const SourceMetadataSchema = z
     clientTimezone: z.string().optional(),
     /** Channel command intent (e.g. Telegram /start). */
     commandIntent: CommandIntentSchema.optional(),
-    /** Slack-specific: whether the bot was @-mentioned. */
-    slackBotMentioned: z.boolean().optional(),
+    /**
+     * Whether the message addresses the assistant by name, an @-mention on
+     * the platforms that have one. Stated by the channel's normalizer only
+     * where it proved the answer; absent means "not established". Read to
+     * decide whether a reply is expected before any text exists, never to
+     * admit or deny: admission is the gate's job, upstream of this.
+     */
+    botMentioned: z.boolean().optional(),
     /**
      * Slack-specific: the `edited.ts` float-string from a `message_changed`
      * event. Used by the daemon to reject out-of-order edit deliveries whose

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/vellum-gateway",
-  "version": "0.12.2-staging.6",
+  "version": "0.12.2-staging.7",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/telegram-normalize.test.ts

@@ -1,6 +1,29 @@
 import { describe, test, expect } from "bun:test";
-import { normalizeTelegramUpdate } from "../telegram/normalize.js";
+import {
+  normalizeTelegramUpdate,
+  type TelegramDropReason,
+  type TelegramNormalization,
+} from "../telegram/normalize.js";
 import { verifyWebhookSecret } from "../telegram/verify.js";
+import type { GatewayInboundEvent } from "../types.js";
+
+/** The event a normalization produced, failing the test if it dropped. */
+function eventOf(result: TelegramNormalization): GatewayInboundEvent {
+  if (result.dropped) {
+    throw new Error(`expected an event, got drop: ${result.reason}`);
+  }
+  return result.event;
+}
+
+function expectDrop(
+  result: TelegramNormalization,
+  reason: TelegramDropReason,
+): void {
+  expect(result.dropped).toBe(true);
+  if (result.dropped) {
+    expect(result.reason).toBe(reason);
+  }
+}
 
 describe("normalizeTelegramUpdate", () => {
   const validPayload = {
@@ -21,36 +44,36 @@ describe("normalizeTelegramUpdate", () => {
   };
 
   test("normalizes a valid private text message", () => {
-    const result = normalizeTelegramUpdate(validPayload);
-    expect(result).not.toBeNull();
-    expect(result!.version).toBe("v1");
-    expect(result!.sourceChannel).toBe("telegram");
-    expect(result!.message.content).toBe("Hello bot");
-    expect(result!.message.conversationExternalId).toBe("99001");
-    expect(result!.message.externalMessageId).toBe("123456");
-    expect(result!.actor.actorExternalId).toBe("55001");
-    expect(result!.actor.username).toBe("testuser");
-    expect(result!.actor.displayName).toBe("Test User");
-    expect(result!.actor.firstName).toBe("Test");
-    expect(result!.actor.lastName).toBe("User");
-    expect(result!.actor.languageCode).toBe("en");
-    expect(result!.actor.isBot).toBe(false);
-    expect(result!.source.updateId).toBe("123456");
-    expect(result!.source.messageId).toBe("42");
-    expect(result!.source.chatType).toBe("private");
-    expect(result!.raw).toEqual(validPayload);
+    const result = eventOf(normalizeTelegramUpdate(validPayload));
+    expect(result.version).toBe("v1");
+    expect(result.sourceChannel).toBe("telegram");
+    expect(result.message.content).toBe("Hello bot");
+    expect(result.message.conversationExternalId).toBe("99001");
+    expect(result.message.externalMessageId).toBe("123456");
+    expect(result.actor.actorExternalId).toBe("55001");
+    expect(result.actor.username).toBe("testuser");
+    expect(result.actor.displayName).toBe("Test User");
+    expect(result.actor.firstName).toBe("Test");
+    expect(result.actor.lastName).toBe("User");
+    expect(result.actor.languageCode).toBe("en");
+    expect(result.actor.isBot).toBe(false);
+    expect(result.source.updateId).toBe("123456");
+    expect(result.source.messageId).toBe("42");
+    expect(result.source.chatType).toBe("private");
+    expect(result.raw).toEqual(validPayload);
   });
 
-  test("returns null for unsupported message types (e.g. sticker-only)", () => {
+  test("drops unsupported message types (e.g. sticker-only)", () => {
     const payload = {
       update_id: 1,
       message: {
         message_id: 1,
         chat: { id: 1, type: "private" },
+        from: { id: 7 },
         sticker: { file_id: "abc" },
       },
     };
-    expect(normalizeTelegramUpdate(payload)).toBeNull();
+    expectDrop(normalizeTelegramUpdate(payload), "no_supported_content");
   });
 
   test("normalizes a photo message", () => {
@@ -83,11 +106,10 @@ describe("normalizeTelegramUpdate", () => {
         caption: "Check this out",
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.content).toBe("Check this out");
-    expect(result!.message.attachments).toHaveLength(1);
-    expect(result!.message.attachments![0]).toEqual({
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.content).toBe("Check this out");
+    expect(result.message.attachments).toHaveLength(1);
+    expect(result.message.attachments![0]).toEqual({
       type: "photo",
       fileId: "large_id",
       fileSize: undefined,
@@ -106,11 +128,10 @@ describe("normalizeTelegramUpdate", () => {
         ],
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.content).toBe("");
-    expect(result!.message.attachments).toHaveLength(1);
-    expect(result!.message.attachments![0].fileId).toBe("only_id");
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.content).toBe("");
+    expect(result.message.attachments).toHaveLength(1);
+    expect(result.message.attachments![0].fileId).toBe("only_id");
   });
 
   test("normalizes a document message", () => {
@@ -130,11 +151,10 @@ describe("normalizeTelegramUpdate", () => {
         caption: "Here is the report",
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.content).toBe("Here is the report");
-    expect(result!.message.attachments).toHaveLength(1);
-    expect(result!.message.attachments![0]).toEqual({
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.content).toBe("Here is the report");
+    expect(result.message.attachments).toHaveLength(1);
+    expect(result.message.attachments![0]).toEqual({
       type: "document",
       fileId: "doc_file_id",
       fileName: "report.pdf",
@@ -158,40 +178,38 @@ describe("normalizeTelegramUpdate", () => {
         },
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.content).toBe("");
-    expect(result!.message.attachments).toHaveLength(1);
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.content).toBe("");
+    expect(result.message.attachments).toHaveLength(1);
   });
 
   test("text-only messages have no attachments field", () => {
-    const result = normalizeTelegramUpdate(validPayload);
-    expect(result).not.toBeNull();
-    expect(result!.message.attachments).toBeUndefined();
+    const result = eventOf(normalizeTelegramUpdate(validPayload));
+    expect(result.message.attachments).toBeUndefined();
   });
 
-  test("returns null for group messages", () => {
+  test("drops group messages when the bot's identity is unknown", () => {
     const payload = {
       ...validPayload,
       message: { ...validPayload.message, chat: { id: 99001, type: "group" } },
     };
-    expect(normalizeTelegramUpdate(payload)).toBeNull();
+    expectDrop(normalizeTelegramUpdate(payload), "bot_identity_unknown");
   });
 
-  test("returns null for payloads without update_id", () => {
+  test("drops payloads without update_id", () => {
     const { update_id: _, ...rest } = validPayload;
-    expect(normalizeTelegramUpdate(rest)).toBeNull();
+    expectDrop(normalizeTelegramUpdate(rest), "missing_update_id");
   });
 
-  test("returns null for payloads without chat id", () => {
+  test("drops payloads without chat id", () => {
     const payload = {
       update_id: 1,
       message: { message_id: 1, text: "hello", chat: {} },
     };
-    expect(normalizeTelegramUpdate(payload)).toBeNull();
+    expectDrop(normalizeTelegramUpdate(payload), "missing_chat");
   });
 
-  test("returns null when from.id is missing", () => {
+  test("drops a message when from.id is missing", () => {
     const payload = {
       update_id: 1,
       message: {
@@ -201,15 +219,15 @@ describe("normalizeTelegramUpdate", () => {
       },
     };
     const result = normalizeTelegramUpdate(payload);
-    expect(result).toBeNull();
+    expectDrop(result, "missing_sender");
   });
 
-  test("returns null for callback_query without message context", () => {
+  test("drops callback_query without message context", () => {
     const payload = {
       update_id: 1,
       callback_query: { id: "abc", from: { id: 123 }, data: "some_data" },
     };
-    expect(normalizeTelegramUpdate(payload)).toBeNull();
+    expectDrop(normalizeTelegramUpdate(payload), "callback_without_message");
   });
 
   test("normalizes an edited_message update as an edit", () => {
@@ -227,15 +245,14 @@ describe("normalizeTelegramUpdate", () => {
         },
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.eventKind).toBe("edit");
-    expect(result!.message.content).toBe("Hello bot (edited)");
-    expect(result!.message.conversationExternalId).toBe("99001");
-    expect(result!.message.externalMessageId).toBe("200");
-    expect(result!.source.updateId).toBe("200");
-    expect(result!.source.messageId).toBe("42");
-    expect(result!.actor.actorExternalId).toBe("55001");
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.eventKind).toBe("edit");
+    expect(result.message.content).toBe("Hello bot (edited)");
+    expect(result.message.conversationExternalId).toBe("99001");
+    expect(result.message.externalMessageId).toBe("200");
+    expect(result.source.updateId).toBe("200");
+    expect(result.source.messageId).toBe("42");
+    expect(result.actor.actorExternalId).toBe("55001");
   });
 
   test("prefers message over edited_message when both are present", () => {
@@ -254,10 +271,9 @@ describe("normalizeTelegramUpdate", () => {
         from: { id: 55001, is_bot: false },
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.isEdit).toBeUndefined();
-    expect(result!.message.content).toBe("Original");
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.isEdit).toBeUndefined();
+    expect(result.message.content).toBe("Original");
   });
 
   test("classifies an edited_message with photo as an edit", () => {
@@ -278,14 +294,13 @@ describe("normalizeTelegramUpdate", () => {
         caption: "Updated caption",
       },
     };
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.eventKind).toBe("edit");
-    expect(result!.message.content).toBe("Updated caption");
-    expect(result!.message.attachments).toHaveLength(1);
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.eventKind).toBe("edit");
+    expect(result.message.content).toBe("Updated caption");
+    expect(result.message.attachments).toHaveLength(1);
   });
 
-  test("returns null for edited_message in group chat", () => {
+  test("drops edited_message in a group when the bot's identity is unknown", () => {
     const payload = {
       update_id: 500,
       edited_message: {
@@ -295,7 +310,7 @@ describe("normalizeTelegramUpdate", () => {
         from: { id: 55001, is_bot: false },
       },
     };
-    expect(normalizeTelegramUpdate(payload)).toBeNull();
+    expectDrop(normalizeTelegramUpdate(payload), "bot_identity_unknown");
   });
 });
 
@@ -322,30 +337,29 @@ describe("normalizeTelegramUpdate: callback_query", () => {
       },
     };
 
-    const result = normalizeTelegramUpdate(payload);
-
-    expect(result).not.toBeNull();
-    expect(result!.version).toBe("v1");
-    expect(result!.sourceChannel).toBe("telegram");
-    expect(result!.message.content).toBe("apr:run-abc:approve");
-    expect(result!.message.conversationExternalId).toBe("12345");
-    expect(result!.message.externalMessageId).toBe("5001");
-    expect(result!.message.callbackQueryId).toBe("cbq-123");
-    expect(result!.message.callbackData).toBe("apr:run-abc:approve");
-    expect(result!.message.attachments).toBeUndefined();
-    expect(result!.actor.actorExternalId).toBe("67890");
-    expect(result!.actor.username).toBe("testuser");
-    expect(result!.actor.displayName).toBe("Test User");
-    expect(result!.actor.firstName).toBe("Test");
-    expect(result!.actor.lastName).toBe("User");
-    expect(result!.actor.languageCode).toBe("en");
-    expect(result!.actor.isBot).toBe(false);
-    expect(result!.source.updateId).toBe("5001");
-    expect(result!.source.messageId).toBe("42");
-    expect(result!.source.chatType).toBe("private");
+    const result = eventOf(normalizeTelegramUpdate(payload));
+
+    expect(result.version).toBe("v1");
+    expect(result.sourceChannel).toBe("telegram");
+    expect(result.message.content).toBe("apr:run-abc:approve");
+    expect(result.message.conversationExternalId).toBe("12345");
+    expect(result.message.externalMessageId).toBe("5001");
+    expect(result.message.callbackQueryId).toBe("cbq-123");
+    expect(result.message.callbackData).toBe("apr:run-abc:approve");
+    expect(result.message.attachments).toBeUndefined();
+    expect(result.actor.actorExternalId).toBe("67890");
+    expect(result.actor.username).toBe("testuser");
+    expect(result.actor.displayName).toBe("Test User");
+    expect(result.actor.firstName).toBe("Test");
+    expect(result.actor.lastName).toBe("User");
+    expect(result.actor.languageCode).toBe("en");
+    expect(result.actor.isBot).toBe(false);
+    expect(result.source.updateId).toBe("5001");
+    expect(result.source.messageId).toBe("42");
+    expect(result.source.chatType).toBe("private");
   });
 
-  test("returns null when callback_query has no message (inline mode edge case)", () => {
+  test("drops a callback_query with no message (inline mode edge case)", () => {
     const payload = {
       update_id: 5002,
       callback_query: {
@@ -361,10 +375,10 @@ describe("normalizeTelegramUpdate: callback_query", () => {
     };
 
     const result = normalizeTelegramUpdate(payload);
-    expect(result).toBeNull();
+    expectDrop(result, "callback_without_message");
   });
 
-  test("returns null when callback_query has no data", () => {
+  test("drops a callback_query with no data", () => {
     const payload = {
       update_id: 5003,
       callback_query: {
@@ -384,10 +398,10 @@ describe("normalizeTelegramUpdate: callback_query", () => {
     };
 
     const result = normalizeTelegramUpdate(payload);
-    expect(result).toBeNull();
+    expectDrop(result, "callback_without_data");
   });
 
-  test("returns null when callback_query message has no chat id", () => {
+  test("drops a callback_query whose message has no chat id", () => {
     const payload = {
       update_id: 5004,
       callback_query: {
@@ -408,10 +422,10 @@ describe("normalizeTelegramUpdate: callback_query", () => {
     };
 
     const result = normalizeTelegramUpdate(payload);
-    expect(result).toBeNull();
+    expectDrop(result, "callback_without_message");
   });
 
-  test("returns null when callback_query from.id is missing", () => {
+  test("drops a callback_query when from.id is missing", () => {
     const payload = {
       update_id: 5005,
       callback_query: {
@@ -427,7 +441,7 @@ describe("normalizeTelegramUpdate: callback_query", () => {
     };
 
     const result = normalizeTelegramUpdate(payload);
-    expect(result).toBeNull();
+    expectDrop(result, "missing_sender");
   });
 
   test("callback_query does not set isEdit or attachments", () => {
@@ -450,10 +464,9 @@ describe("normalizeTelegramUpdate: callback_query", () => {
       },
     };
 
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.isEdit).toBeUndefined();
-    expect(result!.message.attachments).toBeUndefined();
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.isEdit).toBeUndefined();
+    expect(result.message.attachments).toBeUndefined();
   });
 
   test("regular text messages are unaffected by callback_query support", () => {
@@ -472,11 +485,10 @@ describe("normalizeTelegramUpdate: callback_query", () => {
       },
     };
 
-    const result = normalizeTelegramUpdate(payload);
-    expect(result).not.toBeNull();
-    expect(result!.message.content).toBe("Hello world");
-    expect(result!.message.callbackQueryId).toBeUndefined();
-    expect(result!.message.callbackData).toBeUndefined();
+    const result = eventOf(normalizeTelegramUpdate(payload));
+    expect(result.message.content).toBe("Hello world");
+    expect(result.message.callbackQueryId).toBeUndefined();
+    expect(result.message.callbackData).toBeUndefined();
   });
 });