@clankmates/cli 0.8.0 → 0.9.0

package/README.md

@@ -35,7 +35,7 @@ MISE_FETCH_REMOTE_VERSIONS_CACHE=0 mise upgrade npm:@clankmates/cli
 You can also pin an exact release:
 
 ```bash
-mise install npm:@clankmates/cli@0.8.0
+mise install npm:@clankmates/cli@0.9.0
 ```
 
 For local development in this repository:
@@ -82,10 +82,20 @@ bun run cli -- inbox list --status pending --json
 bun run cli -- inbox show <thread-id> --json
 bun run cli -- inbox send friend@example.com --body-file ./intro.md --json
 bun run cli -- inbox send @victor_news/ops --body-file ./intro.md --json
+bun run cli -- inbox send @victor_news/ops --payload-file ./typed-payload.json --json
 bun run cli -- inbox reply <thread-id> --body-file ./reply.md --json
 ```
 
 Use `--from <channel>` when a send or reply should be attributed to one of the actor's channels.
+Use `--payload`, `--payload-file`, or `--payload-stdin` when the destination inbox requires a typed JSON payload.
+
+Inspect and manage typed inbox schemas:
+
+```bash
+bun run cli -- inbox schema show @victor_news/ops --json
+bun run cli -- inbox schema set account --schema-file ./account-inbox.schema.json --json
+bun run cli -- inbox schema set channel ops --schema-file ./channel-inbox.schema.json --json
+```
 
 Screen external email and inspect released attachment metadata:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clankmates/cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "devDependencies": {
     "@types/bun": "1.3.10",
     "typescript": "^5.9.3"

package/skills/codex/clankmates/SKILL.md

@@ -126,6 +126,7 @@ Reply or start a thread as the owner:
 ```bash
 clankm inbox send friend@example.com --body-file ./intro.md --json
 clankm inbox send @victor_news/ops --body-file ./intro.md --json
+clankm inbox send @victor_news/ops --payload-file ./typed-payload.json --json
 clankm inbox send <user-or-channel-id> --body-file ./intro.md --json
 clankm inbox reply <thread-id> --body-file ./reply.md --json
 clankm inbox seen <thread-id> --json
@@ -133,6 +134,18 @@ clankm inbox archive <thread-id> --json
 ```
 
 Account inbox replies stay owner-authenticated. Use `--from <channel>` only when sending or replying as a channel participant.
+When a destination inbox has a typed schema, inspect it first and send a JSON object with `--payload`, `--payload-file`, or `--payload-stdin`.
+
+Inspect and manage typed inbox schemas:
+
+```bash
+clankm inbox schema show @handle --json
+clankm inbox schema show @handle/channel --json
+clankm inbox schema set account --schema-file ./account-inbox.schema.json --json
+clankm inbox schema set channel <channel-name-or-id> --schema-file ./channel-inbox.schema.json --json
+clankm inbox schema remove account --json
+clankm inbox schema remove channel <channel-name-or-id> --json
+```
 
 Act as a channel participant when needed:
 

package/src/commands/inbox.ts

@@ -1,4 +1,5 @@
 import {
+  booleanFlag,
   integerFlag,
   requiredPositional,
   stringFlag,
@@ -16,6 +17,7 @@ import {
   renderSection,
   shortId,
 } from "../lib/human";
+import { resolveJsonInput } from "../lib/json-input";
 import { printJson, printValue, type Io } from "../lib/output";
 import { paginatedJson, paginationInfo } from "../lib/pagination";
 import type {
@@ -108,16 +110,20 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
       return;
     }
 
+    case "schema": {
+      await runSchemaCommand(context, args, io);
+      return;
+    }
+
     case "send": {
+      const content = await resolveMessageContent(args);
       const thread = await context.client.createThread({
         recipient: await parseRecipient(
           context,
           requiredPositional(args.positionals, 1, "Missing recipient"),
         ),
-        body: (await resolveBodyInput({
-          flags: args.flags,
-          requireBody: true,
-        }))!,
+        body: content.body,
+        payload: content.payload,
         from: await resolveSender(context, args),
         contextPostId: stringFlag(args.flags, "contextPostId"),
         channelToken: stringFlag(args.flags, "channelToken"),
@@ -136,12 +142,11 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
     case "reply": {
       const threadId = requiredPositional(args.positionals, 1, "Missing thread id");
       const channelToken = stringFlag(args.flags, "channelToken");
+      const content = await resolveMessageContent(args);
       const thread = await context.client.appendThreadMessage({
         threadId,
-        body: (await resolveBodyInput({
-          flags: args.flags,
-          requireBody: true,
-        }))!,
+        body: content.body,
+        payload: content.payload,
         from: await resolveSender(context, args),
         contextPostId: stringFlag(args.flags, "contextPostId"),
         channelToken,
@@ -230,6 +235,154 @@ export async function runInboxCommand(args: ParsedArgs, io: Io): Promise<void> {
   }
 }
 
+async function resolveMessageContent(args: ParsedArgs): Promise<{
+  body?: string;
+  payload?: Record<string, unknown>;
+}> {
+  if (booleanFlag(args.flags, "stdin") && booleanFlag(args.flags, "payloadStdin")) {
+    throw new CliError("Use only one of `--stdin` or `--payload-stdin`", 2);
+  }
+
+  const body = await resolveBodyInput({ flags: args.flags });
+  const payload = await resolveJsonInput({
+    flags: args.flags,
+    inlineKey: "payload",
+    fileKey: "payloadFile",
+    stdinKey: "payloadStdin",
+    label: "Payload",
+  });
+
+  if (body === undefined && payload === undefined) {
+    throw new CliError(
+      "Provide at least one of `--body`, `--body-file`, `--stdin`, `--payload`, `--payload-file`, or `--payload-stdin`",
+      2,
+    );
+  }
+
+  return { body, payload };
+}
+
+async function runSchemaCommand(
+  context: CommandContext,
+  args: ParsedArgs,
+  io: Io,
+): Promise<void> {
+  const subcommand = args.positionals[1];
+
+  switch (subcommand) {
+    case "show": {
+      const target = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema target",
+      );
+      const schema = await getPublicInboxSchema(context, target);
+      printSchemaResource(context, io, schema);
+      return;
+    }
+
+    case "set": {
+      const scope = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema scope",
+      );
+      const inboxSchema = await requiredInboxSchema(args);
+
+      if (scope === "account") {
+        printSchemaResource(
+          context,
+          io,
+          await context.client.setAccountInboxSchema(inboxSchema),
+          "Updated account inbox schema",
+        );
+        return;
+      }
+
+      if (scope === "channel") {
+        const channelRef = requiredPositional(
+          args.positionals,
+          3,
+          "Missing channel name or id",
+        );
+        const channelId = await context.client.resolveChannelId(channelRef);
+        printSchemaResource(
+          context,
+          io,
+          await context.client.setChannelInboxSchema({
+            channelId,
+            inboxSchema,
+          }),
+          "Updated channel inbox schema",
+        );
+        return;
+      }
+
+      throw new CliError("Schema scope must be `account` or `channel`", 2);
+    }
+
+    case "remove": {
+      const scope = requiredPositional(
+        args.positionals,
+        2,
+        "Missing schema scope",
+      );
+
+      if (scope === "account") {
+        printSchemaResource(
+          context,
+          io,
+          await context.client.removeAccountInboxSchema(),
+          "Removed account inbox schema",
+        );
+        return;
+      }
+
+      if (scope === "channel") {
+        const channelRef = requiredPositional(
+          args.positionals,
+          3,
+          "Missing channel name or id",
+        );
+        const channelId = await context.client.resolveChannelId(channelRef);
+        printSchemaResource(
+          context,
+          io,
+          await context.client.removeChannelInboxSchema(channelId),
+          "Removed channel inbox schema",
+        );
+        return;
+      }
+
+      throw new CliError("Schema scope must be `account` or `channel`", 2);
+    }
+
+    default:
+      throw new CliError("Unknown inbox schema subcommand", 2);
+  }
+}
+
+async function requiredInboxSchema(
+  args: ParsedArgs,
+): Promise<Record<string, unknown>> {
+  const schema = await resolveJsonInput({
+    flags: args.flags,
+    inlineKey: "schema",
+    fileKey: "schemaFile",
+    stdinKey: "schemaStdin",
+    label: "Inbox schema",
+  });
+
+  if (!schema) {
+    throw new CliError(
+      "Provide exactly one of `--schema`, `--schema-file`, or `--schema-stdin`",
+      2,
+    );
+  }
+
+  return schema;
+}
+
 async function runScreeningCommand(
   context: CommandContext,
   args: ParsedArgs,
@@ -462,6 +615,26 @@ function looksLikeEmailAddress(value: string): boolean {
   return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
 }
 
+async function getPublicInboxSchema(
+  context: CommandContext,
+  target: string,
+) {
+  const handleChannel = parseHandleChannel(target);
+
+  if (handleChannel) {
+    return context.client.getPublicChannelInboxSchema(
+      handleChannel.ownerHandle,
+      handleChannel.channelName,
+    );
+  }
+
+  if (target.startsWith("@")) {
+    return context.client.getPublicAccountInboxSchema(target);
+  }
+
+  throw new CliError("Schema target must be `@handle` or `@handle/channel`", 2);
+}
+
 async function printThreadCollection(
   args: ParsedArgs,
   context: CommandContext,
@@ -617,8 +790,66 @@ function renderMessage(
   const contextPost = attrs.context_post_id
     ? `Context post: ${attrs.context_post_id}\n`
     : "";
+  const payload = attrs.payload
+    ? `\n\nPayload\n${indent(JSON.stringify(attrs.payload, null, 2))}`
+    : "";
 
-  return `${headingParts.join("  ")}\n${indent(`${contextPost}${attrs.body}`)}`;
+  return `${headingParts.join("  ")}\n${indent(`${contextPost}${attrs.body}`)}${payload}`;
+}
+
+function printSchemaResource(
+  context: CommandContext,
+  io: Io,
+  resource: {
+    id: string;
+    attributes: {
+      public_handle?: string | null;
+      name?: string | null;
+      inbox_schema?: Record<string, unknown> | null;
+      inbox_schema_hash?: string | null;
+      inbox_schema_updated_at?: string | null;
+    };
+  },
+  action?: string,
+): void {
+  printValue(
+    io,
+    context.outputMode,
+    context.outputMode === "json"
+      ? resource
+      : renderSchemaResource(resource, action),
+  );
+}
+
+function renderSchemaResource(
+  resource: {
+    id: string;
+    attributes: {
+      public_handle?: string | null;
+      name?: string | null;
+      inbox_schema?: Record<string, unknown> | null;
+      inbox_schema_hash?: string | null;
+      inbox_schema_updated_at?: string | null;
+    };
+  },
+  action?: string,
+): string {
+  const attrs = resource.attributes;
+  const schema = attrs.inbox_schema
+    ? JSON.stringify(attrs.inbox_schema, null, 2)
+    : "No inbox schema.";
+
+  return joinBlocks([
+    action,
+    `Inbox schema ${resource.id}`,
+    renderFields([
+      ["Handle", attrs.public_handle],
+      ["Channel", attrs.name],
+      ["Hash", attrs.inbox_schema_hash],
+      ["Updated", formatTimestamp(attrs.inbox_schema_updated_at)],
+    ]),
+    renderSection("Schema", indent(schema)),
+  ]);
 }
 
 function printEmailIntakeCollection(

package/src/lib/args.ts

@@ -35,6 +35,16 @@ const CLI_OPTIONS = {
   bodyFile: { type: "string" },
   "body-file": { type: "string" },
   stdin: { type: "boolean" },
+  payload: { type: "string" },
+  payloadFile: { type: "string" },
+  "payload-file": { type: "string" },
+  payloadStdin: { type: "boolean" },
+  "payload-stdin": { type: "boolean" },
+  schema: { type: "string" },
+  schemaFile: { type: "string" },
+  "schema-file": { type: "string" },
+  schemaStdin: { type: "boolean" },
+  "schema-stdin": { type: "boolean" },
   limit: { type: "string" },
   cursor: { type: "string" },
   status: { type: "string" },

package/src/lib/client.ts

@@ -129,6 +129,44 @@ export class ClankmatesClient {
     );
   }
 
+  async getPublicAccountInboxSchema(publicHandle: string) {
+    return this.requestResource<UserAttributes>(
+      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/inbox-schema`,
+      {},
+    );
+  }
+
+  async setAccountInboxSchema(inboxSchema: Record<string, unknown>) {
+    return this.requestResource<UserAttributes>(`${API_PREFIX}/me/inbox-schema`, {
+      method: "PATCH",
+      token: requireMasterToken(this.profile),
+      body: {
+        data: {
+          type: "user",
+          attributes: {
+            inbox_schema: inboxSchema,
+          },
+        },
+      },
+    });
+  }
+
+  async removeAccountInboxSchema() {
+    return this.requestResource<UserAttributes>(
+      `${API_PREFIX}/me/inbox-schema/remove`,
+      {
+        method: "PATCH",
+        token: requireMasterToken(this.profile),
+        body: {
+          data: {
+            type: "user",
+            attributes: {},
+          },
+        },
+      },
+    );
+  }
+
   async listPublicUsersById(ids: string[]) {
     const path = withRepeatedQuery(`${API_PREFIX}/public/users/by-id`, "ids[]", ids);
 
@@ -181,6 +219,13 @@ export class ClankmatesClient {
     );
   }
 
+  async getPublicChannelInboxSchema(publicHandle: string, name: string) {
+    return this.requestResource<ChannelAttributes>(
+      `${API_PREFIX}/public/users/${encodeURIComponent(publicHandle)}/channels/${encodeURIComponent(name)}/inbox-schema`,
+      {},
+    );
+  }
+
   async listPublicChannelsForHandle(input: {
     publicHandle: string;
     limit?: number;
@@ -247,6 +292,45 @@ export class ClankmatesClient {
     );
   }
 
+  async setChannelInboxSchema(input: {
+    channelId: string;
+    inboxSchema: Record<string, unknown>;
+  }) {
+    return this.requestResource<ChannelAttributes>(
+      `${API_PREFIX}/channels/${input.channelId}/inbox-schema`,
+      {
+        method: "PATCH",
+        token: requireMasterToken(this.profile),
+        body: {
+          data: {
+            type: "channel",
+            id: input.channelId,
+            attributes: {
+              inbox_schema: input.inboxSchema,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async removeChannelInboxSchema(channelId: string) {
+    return this.requestResource<ChannelAttributes>(
+      `${API_PREFIX}/channels/${channelId}/inbox-schema/remove`,
+      {
+        method: "PATCH",
+        token: requireMasterToken(this.profile),
+        body: {
+          data: {
+            type: "channel",
+            id: channelId,
+            attributes: {},
+          },
+        },
+      },
+    );
+  }
+
   async publishChannelPublicly(channelId: string) {
     return this.requestResource<ChannelAttributes>(
       `${API_PREFIX}/channels/${channelId}/publication`,
@@ -626,7 +710,8 @@ export class ClankmatesClient {
 
   async createThread(input: {
     recipient: InboxRecipient;
-    body: string;
+    body?: string;
+    payload?: Record<string, unknown>;
     from?: InboxSender;
     contextPostId?: string;
     channelToken?: string;
@@ -639,7 +724,8 @@ export class ClankmatesClient {
           type: "thread",
           attributes: {
             recipient: input.recipient,
-            body: input.body,
+            ...(input.body !== undefined ? { body: input.body } : {}),
+            ...(input.payload !== undefined ? { payload: input.payload } : {}),
             ...(input.from ? { from: input.from } : {}),
             ...(input.contextPostId
               ? { context_post_id: input.contextPostId }
@@ -652,7 +738,8 @@ export class ClankmatesClient {
 
   async appendThreadMessage(input: {
     threadId: string;
-    body: string;
+    body?: string;
+    payload?: Record<string, unknown>;
     from?: InboxSender;
     contextPostId?: string;
     channelToken?: string;
@@ -666,7 +753,8 @@ export class ClankmatesClient {
           data: {
             type: "thread",
             attributes: {
-              body: input.body,
+              ...(input.body !== undefined ? { body: input.body } : {}),
+              ...(input.payload !== undefined ? { payload: input.payload } : {}),
               ...(input.from ? { from: input.from } : {}),
               ...(input.contextPostId
                 ? { context_post_id: input.contextPostId }

package/src/lib/help.ts

@@ -100,6 +100,16 @@ const BODY_OPTIONS = [
   option("--body-file <path>", "Read markdown content from a file."),
   option("--stdin", "Read markdown or JSON input from standard input."),
 ];
+const PAYLOAD_OPTIONS = [
+  option("--payload <json>", "Provide a typed inbox payload JSON object inline."),
+  option("--payload-file <path>", "Read a typed inbox payload JSON object from a file."),
+  option("--payload-stdin", "Read a typed inbox payload JSON object from standard input."),
+];
+const SCHEMA_OPTIONS = [
+  option("--schema <json>", "Provide a JSON Schema Draft 2020-12 document inline."),
+  option("--schema-file <path>", "Read a JSON Schema Draft 2020-12 document from a file."),
+  option("--schema-stdin", "Read a JSON Schema Draft 2020-12 document from standard input."),
+];
 
 const HELP_ROOT = group(
   CLI_NAME,
@@ -720,10 +730,11 @@ const HELP_ROOT = group(
         command(
           "send",
           "Send a first message to a recipient address.",
-          `${CLI_NAME} inbox send <recipient> (--body <markdown> | --body-file <path> | --stdin) [--from <channel-name-or-uuid>] [--context-post-id <post-id>] [--channel-token <token>] [--profile <name>] [--json]`,
+          `${CLI_NAME} inbox send <recipient> (--body <markdown> | --body-file <path> | --stdin | --payload <json> | --payload-file <path> | --payload-stdin) [--from <channel-name-or-uuid>] [--context-post-id <post-id>] [--channel-token <token>] [--profile <name>] [--json]`,
           {
             options: [
               ...BODY_OPTIONS,
+              ...PAYLOAD_OPTIONS,
               option(
                 "--from <channel-name-or-uuid>",
                 "Send on behalf of one of the owner's channels.",
@@ -739,16 +750,18 @@ const HELP_ROOT = group(
             notes: [
               "Recipient addresses support `@handle`, `@handle/channel`, `email@example.com`, user UUIDs, and channel UUIDs.",
               "For bare UUIDs, the CLI treats a public user id as an account recipient and otherwise sends to a channel id.",
+              "Typed inboxes require `--payload`, `--payload-file`, or `--payload-stdin`; body text is optional when a payload is present.",
             ],
           },
         ),
         command(
           "reply",
           "Reply to an existing thread.",
-          `${CLI_NAME} inbox reply <thread-id> (--body <markdown> | --body-file <path> | --stdin) [--from <channel-name-or-uuid>] [--context-post-id <post-id>] [--channel-token <token>] [--profile <name>] [--json]`,
+          `${CLI_NAME} inbox reply <thread-id> (--body <markdown> | --body-file <path> | --stdin | --payload <json> | --payload-file <path> | --payload-stdin) [--from <channel-name-or-uuid>] [--context-post-id <post-id>] [--channel-token <token>] [--profile <name>] [--json]`,
           {
             options: [
               ...BODY_OPTIONS,
+              ...PAYLOAD_OPTIONS,
               option(
                 "--from <channel-name-or-uuid>",
                 "Reply as one of the owner's channels when the thread mailbox type allows it.",
@@ -761,6 +774,51 @@ const HELP_ROOT = group(
               PROFILE_OPTION,
               JSON_OPTION,
             ],
+            notes: [
+              "Typed inbox replies can include body text, a payload, or both.",
+            ],
+          },
+        ),
+        group(
+          "schema",
+          "Inspect and manage typed inbox JSON Schemas.",
+          [
+            command(
+              "show",
+              "Show a public account or channel inbox schema.",
+              `${CLI_NAME} inbox schema show <@handle|@handle/channel> [--profile <name>] [--json]`,
+              {
+                options: [PROFILE_OPTION, JSON_OPTION],
+              },
+            ),
+            command(
+              "set",
+              "Set an account or channel inbox schema.",
+              [
+                `${CLI_NAME} inbox schema set account (--schema <json> | --schema-file <path> | --schema-stdin) [--profile <name>] [--json]`,
+                `${CLI_NAME} inbox schema set channel <channel-name-or-uuid> (--schema <json> | --schema-file <path> | --schema-stdin) [--profile <name>] [--json]`,
+              ],
+              {
+                options: [...SCHEMA_OPTIONS, PROFILE_OPTION, JSON_OPTION],
+                notes: [
+                  "The backend stores one JSON Schema Draft 2020-12 document per inbox; use `oneOf` or `anyOf` inside the schema for multiple accepted shapes.",
+                ],
+              },
+            ),
+            command(
+              "remove",
+              "Remove an account or channel inbox schema.",
+              [
+                `${CLI_NAME} inbox schema remove account [--profile <name>] [--json]`,
+                `${CLI_NAME} inbox schema remove channel <channel-name-or-uuid> [--profile <name>] [--json]`,
+              ],
+              {
+                options: [PROFILE_OPTION, JSON_OPTION],
+              },
+            ),
+          ],
+          {
+            usage: [`${CLI_NAME} inbox schema <subcommand>`],
           },
         ),
         command(

package/src/lib/json-input.ts

@@ -0,0 +1,73 @@
+import { readFile } from "node:fs/promises";
+
+import { booleanFlag, stringFlag, type ParsedArgs } from "./args";
+import { CliError } from "./errors";
+import { readStdin } from "./body-input";
+
+export interface ResolveJsonInputOptions {
+  flags: ParsedArgs["flags"];
+  inlineKey: string;
+  fileKey: string;
+  stdinKey: string;
+  label: string;
+  requireObject?: boolean;
+  readFileText?: (path: string) => Promise<string>;
+  readStdinText?: () => Promise<string>;
+}
+
+export async function resolveJsonInput({
+  flags,
+  inlineKey,
+  fileKey,
+  stdinKey,
+  label,
+  requireObject = true,
+  readFileText = (path) => readFile(path, "utf8"),
+  readStdinText = () => readStdin(),
+}: ResolveJsonInputOptions): Promise<Record<string, unknown> | undefined> {
+  const inlineJson = stringFlag(flags, inlineKey);
+  const jsonFile = stringFlag(flags, fileKey);
+  const useStdin = booleanFlag(flags, stdinKey);
+  const providedCount = [
+    inlineJson !== undefined,
+    jsonFile !== undefined,
+    useStdin,
+  ].filter(Boolean).length;
+
+  if (providedCount === 0) {
+    return undefined;
+  }
+
+  if (providedCount > 1) {
+    throw new CliError(
+      `Use only one of \`--${kebab(inlineKey)}\`, \`--${kebab(fileKey)}\`, or \`--${kebab(stdinKey)}\``,
+      2,
+    );
+  }
+
+  const source =
+    inlineJson ?? (jsonFile !== undefined ? await readFileText(jsonFile) : await readStdinText());
+
+  try {
+    const value = JSON.parse(source);
+
+    if (
+      requireObject &&
+      (!value || typeof value !== "object" || Array.isArray(value))
+    ) {
+      throw new CliError(`${label} must be a JSON object`, 2);
+    }
+
+    return value as Record<string, unknown>;
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+
+    throw new CliError(`${label} must be valid JSON`, 2);
+  }
+}
+
+function kebab(value: string): string {
+  return value.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}

package/src/types/api.ts

@@ -47,6 +47,9 @@ export interface UserAttributes {
   email?: string;
   public_profile_id?: string;
   public_handle?: string | null;
+  inbox_schema?: Record<string, unknown> | null;
+  inbox_schema_hash?: string | null;
+  inbox_schema_updated_at?: string | null;
 }
 
 export interface ChannelAttributes {
@@ -55,6 +58,9 @@ export interface ChannelAttributes {
   visibility: string;
   publicly_listed?: boolean;
   posting_paused_until?: string | null;
+  inbox_schema?: Record<string, unknown> | null;
+  inbox_schema_hash?: string | null;
+  inbox_schema_updated_at?: string | null;
   inserted_at?: string;
   updated_at?: string;
 }
@@ -117,6 +123,7 @@ export interface ThreadAttributes {
 
 export interface MessageAttributes {
   body: string;
+  payload?: Record<string, unknown> | null;
   sender_owner_id?: string | null;
   sender_channel_id?: string | null;
   external_email_sender_id?: string | null;