@inline-openclaw/inline 0.0.20 → 0.0.22

package/dist/index.js

@@ -5539,17 +5539,6 @@ var require_websocket_server = __commonJS((exports, module) => {
   }
 });
 
-// src/index.ts
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-
-// src/inline/channel.ts
-import {
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID2,
-  formatPairingApproveHint,
-  PAIRING_APPROVED_MESSAGE
-} from "openclaw/plugin-sdk";
-
 // ../protocol/dist/core.js
 var import_runtime = __toESM(require_commonjs(), 1);
 var import_runtime2 = __toESM(require_commonjs(), 1);
@@ -5711,6 +5700,9 @@ var Method;
   Method2[Method2["SET_BOT_COMMANDS"] = 44] = "SET_BOT_COMMANDS";
   Method2[Method2["GET_PEER_BOT_COMMANDS"] = 45] = "GET_PEER_BOT_COMMANDS";
   Method2[Method2["SHOW_CHAT_IN_SIDEBAR"] = 46] = "SHOW_CHAT_IN_SIDEBAR";
+  Method2[Method2["RESERVE_CHAT_IDS"] = 47] = "RESERVE_CHAT_IDS";
+  Method2[Method2["INVOKE_MESSAGE_ACTION"] = 48] = "INVOKE_MESSAGE_ACTION";
+  Method2[Method2["ANSWER_MESSAGE_ACTION"] = 49] = "ANSWER_MESSAGE_ACTION";
 })(Method || (Method = {}));
 var PushNotificationProvider;
 (function(PushNotificationProvider2) {
@@ -7013,38 +7005,15 @@ class MessageReplies$Type extends import_runtime4.MessageType {
 }
 var MessageReplies = new MessageReplies$Type;
 
-class Message$Type extends import_runtime4.MessageType {
+class MessageActions$Type extends import_runtime4.MessageType {
   constructor() {
-    super("Message", [
-      { no: 1, name: "id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "from_id", kind: "scalar", T: 3, L: 0 },
-      { no: 3, name: "peer_id", kind: "message", T: () => Peer },
-      { no: 4, name: "chat_id", kind: "scalar", T: 3, L: 0 },
-      { no: 5, name: "message", kind: "scalar", opt: true, T: 9 },
-      { no: 6, name: "out", kind: "scalar", T: 8 },
-      { no: 7, name: "date", kind: "scalar", T: 3, L: 0 },
-      { no: 8, name: "mentioned", kind: "scalar", opt: true, T: 8 },
-      { no: 9, name: "reply_to_msg_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 10, name: "media", kind: "message", T: () => MessageMedia },
-      { no: 11, name: "edit_date", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 12, name: "grouped_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 13, name: "attachments", kind: "message", T: () => MessageAttachments },
-      { no: 14, name: "reactions", kind: "message", T: () => MessageReactions },
-      { no: 15, name: "is_sticker", kind: "scalar", opt: true, T: 8 },
-      { no: 6000, name: "has_link", kind: "scalar", opt: true, T: 8 },
-      { no: 16, name: "entities", kind: "message", T: () => MessageEntities },
-      { no: 17, name: "send_mode", kind: "enum", opt: true, T: () => ["MessageSendMode", MessageSendMode] },
-      { no: 18, name: "fwd_from", kind: "message", T: () => MessageFwdHeader },
-      { no: 19, name: "replies", kind: "message", T: () => MessageReplies }
+    super("MessageActions", [
+      { no: 1, name: "rows", kind: "message", repeat: 1, T: () => MessageActionRow }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.id = 0n;
-    message.fromId = 0n;
-    message.chatId = 0n;
-    message.out = false;
-    message.date = 0n;
+    message.rows = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7055,64 +7024,7 @@ class Message$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.id = reader.int64().toBigInt();
-          break;
-        case 2:
-          message.fromId = reader.int64().toBigInt();
-          break;
-        case 3:
-          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
-          break;
-        case 4:
-          message.chatId = reader.int64().toBigInt();
-          break;
-        case 5:
-          message.message = reader.string();
-          break;
-        case 6:
-          message.out = reader.bool();
-          break;
-        case 7:
-          message.date = reader.int64().toBigInt();
-          break;
-        case 8:
-          message.mentioned = reader.bool();
-          break;
-        case 9:
-          message.replyToMsgId = reader.int64().toBigInt();
-          break;
-        case 10:
-          message.media = MessageMedia.internalBinaryRead(reader, reader.uint32(), options, message.media);
-          break;
-        case 11:
-          message.editDate = reader.int64().toBigInt();
-          break;
-        case 12:
-          message.groupedId = reader.int64().toBigInt();
-          break;
-        case 13:
-          message.attachments = MessageAttachments.internalBinaryRead(reader, reader.uint32(), options, message.attachments);
-          break;
-        case 14:
-          message.reactions = MessageReactions.internalBinaryRead(reader, reader.uint32(), options, message.reactions);
-          break;
-        case 15:
-          message.isSticker = reader.bool();
-          break;
-        case 6000:
-          message.hasLink = reader.bool();
-          break;
-        case 16:
-          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
-          break;
-        case 17:
-          message.sendMode = reader.int32();
-          break;
-        case 18:
-          message.fwdFrom = MessageFwdHeader.internalBinaryRead(reader, reader.uint32(), options, message.fwdFrom);
-          break;
-        case 19:
-          message.replies = MessageReplies.internalBinaryRead(reader, reader.uint32(), options, message.replies);
+          message.rows.push(MessageActionRow.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -7126,66 +7038,25 @@ class Message$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.id !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.id);
-    if (message.fromId !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.fromId);
-    if (message.peerId)
-      Peer.internalBinaryWrite(message.peerId, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.chatId !== 0n)
-      writer.tag(4, import_runtime.WireType.Varint).int64(message.chatId);
-    if (message.message !== undefined)
-      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.message);
-    if (message.out !== false)
-      writer.tag(6, import_runtime.WireType.Varint).bool(message.out);
-    if (message.date !== 0n)
-      writer.tag(7, import_runtime.WireType.Varint).int64(message.date);
-    if (message.mentioned !== undefined)
-      writer.tag(8, import_runtime.WireType.Varint).bool(message.mentioned);
-    if (message.replyToMsgId !== undefined)
-      writer.tag(9, import_runtime.WireType.Varint).int64(message.replyToMsgId);
-    if (message.media)
-      MessageMedia.internalBinaryWrite(message.media, writer.tag(10, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.editDate !== undefined)
-      writer.tag(11, import_runtime.WireType.Varint).int64(message.editDate);
-    if (message.groupedId !== undefined)
-      writer.tag(12, import_runtime.WireType.Varint).int64(message.groupedId);
-    if (message.attachments)
-      MessageAttachments.internalBinaryWrite(message.attachments, writer.tag(13, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.reactions)
-      MessageReactions.internalBinaryWrite(message.reactions, writer.tag(14, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.isSticker !== undefined)
-      writer.tag(15, import_runtime.WireType.Varint).bool(message.isSticker);
-    if (message.hasLink !== undefined)
-      writer.tag(6000, import_runtime.WireType.Varint).bool(message.hasLink);
-    if (message.entities)
-      MessageEntities.internalBinaryWrite(message.entities, writer.tag(16, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.sendMode !== undefined)
-      writer.tag(17, import_runtime.WireType.Varint).int32(message.sendMode);
-    if (message.fwdFrom)
-      MessageFwdHeader.internalBinaryWrite(message.fwdFrom, writer.tag(18, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.replies)
-      MessageReplies.internalBinaryWrite(message.replies, writer.tag(19, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.rows.length; i++)
+      MessageActionRow.internalBinaryWrite(message.rows[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var Message = new Message$Type;
+var MessageActions = new MessageActions$Type;
 
-class MessageFwdHeader$Type extends import_runtime4.MessageType {
+class MessageActionRow$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageFwdHeader", [
-      { no: 1, name: "from_peer_id", kind: "message", T: () => Peer },
-      { no: 2, name: "from_id", kind: "scalar", T: 3, L: 0 },
-      { no: 3, name: "from_message_id", kind: "scalar", T: 3, L: 0 }
+    super("MessageActionRow", [
+      { no: 1, name: "actions", kind: "message", repeat: 1, T: () => MessageAction }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.fromId = 0n;
-    message.fromMessageId = 0n;
+    message.actions = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7196,13 +7067,7 @@ class MessageFwdHeader$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.fromPeerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.fromPeerId);
-          break;
-        case 2:
-          message.fromId = reader.int64().toBigInt();
-          break;
-        case 3:
-          message.fromMessageId = reader.int64().toBigInt();
+          message.actions.push(MessageAction.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -7216,29 +7081,30 @@ class MessageFwdHeader$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.fromPeerId)
-      Peer.internalBinaryWrite(message.fromPeerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.fromId !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.fromId);
-    if (message.fromMessageId !== 0n)
-      writer.tag(3, import_runtime.WireType.Varint).int64(message.fromMessageId);
+    for (let i = 0;i < message.actions.length; i++)
+      MessageAction.internalBinaryWrite(message.actions[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MessageFwdHeader = new MessageFwdHeader$Type;
+var MessageActionRow = new MessageActionRow$Type;
 
-class MessageEntities$Type extends import_runtime4.MessageType {
+class MessageAction$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageEntities", [
-      { no: 1, name: "entities", kind: "message", repeat: 1, T: () => MessageEntity }
+    super("MessageAction", [
+      { no: 1, name: "action_id", kind: "scalar", T: 9 },
+      { no: 2, name: "text", kind: "scalar", T: 9 },
+      { no: 3, name: "callback", kind: "message", oneof: "action", T: () => MessageActionCallback },
+      { no: 4, name: "copy_text", kind: "message", oneof: "action", T: () => MessageActionCopyText }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.entities = [];
+    message.actionId = "";
+    message.text = "";
+    message.action = { oneofKind: undefined };
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7249,7 +7115,22 @@ class MessageEntities$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.entities.push(MessageEntity.internalBinaryRead(reader, reader.uint32(), options));
+          message.actionId = reader.string();
+          break;
+        case 2:
+          message.text = reader.string();
+          break;
+        case 3:
+          message.action = {
+            oneofKind: "callback",
+            callback: MessageActionCallback.internalBinaryRead(reader, reader.uint32(), options, message.action.callback)
+          };
+          break;
+        case 4:
+          message.action = {
+            oneofKind: "copyText",
+            copyText: MessageActionCopyText.internalBinaryRead(reader, reader.uint32(), options, message.action.copyText)
+          };
           break;
         default:
           let u = options.readUnknownField;
@@ -7263,33 +7144,31 @@ class MessageEntities$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.entities.length; i++)
-      MessageEntity.internalBinaryWrite(message.entities[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.actionId !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.actionId);
+    if (message.text !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.text);
+    if (message.action.oneofKind === "callback")
+      MessageActionCallback.internalBinaryWrite(message.action.callback, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.action.oneofKind === "copyText")
+      MessageActionCopyText.internalBinaryWrite(message.action.copyText, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MessageEntities = new MessageEntities$Type;
+var MessageAction = new MessageAction$Type;
 
-class MessageEntity$Type extends import_runtime4.MessageType {
+class MessageActionCallback$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageEntity", [
-      { no: 1, name: "type", kind: "enum", T: () => ["MessageEntity.Type", MessageEntity_Type, "TYPE_"] },
-      { no: 2, name: "offset", kind: "scalar", T: 3, L: 0 },
-      { no: 3, name: "length", kind: "scalar", T: 3, L: 0 },
-      { no: 4, name: "mention", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityMention },
-      { no: 5, name: "text_url", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityTextUrl },
-      { no: 6, name: "pre", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityPre }
+    super("MessageActionCallback", [
+      { no: 1, name: "data", kind: "scalar", T: 12 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.type = 0;
-    message.offset = 0n;
-    message.length = 0n;
-    message.entity = { oneofKind: undefined };
+    message.data = new Uint8Array(0);
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7300,31 +7179,7 @@ class MessageEntity$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.type = reader.int32();
-          break;
-        case 2:
-          message.offset = reader.int64().toBigInt();
-          break;
-        case 3:
-          message.length = reader.int64().toBigInt();
-          break;
-        case 4:
-          message.entity = {
-            oneofKind: "mention",
-            mention: MessageEntity_MessageEntityMention.internalBinaryRead(reader, reader.uint32(), options, message.entity.mention)
-          };
-          break;
-        case 5:
-          message.entity = {
-            oneofKind: "textUrl",
-            textUrl: MessageEntity_MessageEntityTextUrl.internalBinaryRead(reader, reader.uint32(), options, message.entity.textUrl)
-          };
-          break;
-        case 6:
-          message.entity = {
-            oneofKind: "pre",
-            pre: MessageEntity_MessageEntityPre.internalBinaryRead(reader, reader.uint32(), options, message.entity.pre)
-          };
+          message.data = reader.bytes();
           break;
         default:
           let u = options.readUnknownField;
@@ -7338,35 +7193,25 @@ class MessageEntity$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.type !== 0)
-      writer.tag(1, import_runtime.WireType.Varint).int32(message.type);
-    if (message.offset !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.offset);
-    if (message.length !== 0n)
-      writer.tag(3, import_runtime.WireType.Varint).int64(message.length);
-    if (message.entity.oneofKind === "mention")
-      MessageEntity_MessageEntityMention.internalBinaryWrite(message.entity.mention, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.entity.oneofKind === "textUrl")
-      MessageEntity_MessageEntityTextUrl.internalBinaryWrite(message.entity.textUrl, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.entity.oneofKind === "pre")
-      MessageEntity_MessageEntityPre.internalBinaryWrite(message.entity.pre, writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.data.length)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).bytes(message.data);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MessageEntity = new MessageEntity$Type;
+var MessageActionCallback = new MessageActionCallback$Type;
 
-class MessageEntity_MessageEntityMention$Type extends import_runtime4.MessageType {
+class MessageActionCopyText$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageEntity.MessageEntityMention", [
-      { no: 1, name: "user_id", kind: "scalar", T: 3, L: 0 }
+    super("MessageActionCopyText", [
+      { no: 1, name: "text", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.userId = 0n;
+    message.text = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7377,7 +7222,7 @@ class MessageEntity_MessageEntityMention$Type extends import_runtime4.MessageTyp
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.userId = reader.int64().toBigInt();
+          message.text = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -7391,25 +7236,25 @@ class MessageEntity_MessageEntityMention$Type extends import_runtime4.MessageTyp
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.userId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.userId);
+    if (message.text !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.text);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MessageEntity_MessageEntityMention = new MessageEntity_MessageEntityMention$Type;
+var MessageActionCopyText = new MessageActionCopyText$Type;
 
-class MessageEntity_MessageEntityTextUrl$Type extends import_runtime4.MessageType {
+class MessageActionResponseUi$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageEntity.MessageEntityTextUrl", [
-      { no: 1, name: "url", kind: "scalar", T: 9 }
+    super("MessageActionResponseUi", [
+      { no: 1, name: "toast", kind: "message", oneof: "kind", T: () => MessageActionToast }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.url = "";
+    message.kind = { oneofKind: undefined };
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7420,7 +7265,10 @@ class MessageEntity_MessageEntityTextUrl$Type extends import_runtime4.MessageTyp
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.url = reader.string();
+          message.kind = {
+            oneofKind: "toast",
+            toast: MessageActionToast.internalBinaryRead(reader, reader.uint32(), options, message.kind.toast)
+          };
           break;
         default:
           let u = options.readUnknownField;
@@ -7434,25 +7282,25 @@ class MessageEntity_MessageEntityTextUrl$Type extends import_runtime4.MessageTyp
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.url !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.url);
+    if (message.kind.oneofKind === "toast")
+      MessageActionToast.internalBinaryWrite(message.kind.toast, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MessageEntity_MessageEntityTextUrl = new MessageEntity_MessageEntityTextUrl$Type;
+var MessageActionResponseUi = new MessageActionResponseUi$Type;
 
-class MessageEntity_MessageEntityPre$Type extends import_runtime4.MessageType {
+class MessageActionToast$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageEntity.MessageEntityPre", [
-      { no: 1, name: "language", kind: "scalar", T: 9 }
+    super("MessageActionToast", [
+      { no: 1, name: "text", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.language = "";
+    message.text = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -7463,7 +7311,7 @@ class MessageEntity_MessageEntityPre$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.language = reader.string();
+          message.text = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -7477,20 +7325,500 @@ class MessageEntity_MessageEntityPre$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.language !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.language);
+    if (message.text !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.text);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MessageEntity_MessageEntityPre = new MessageEntity_MessageEntityPre$Type;
+var MessageActionToast = new MessageActionToast$Type;
 
-class MessageReactions$Type extends import_runtime4.MessageType {
+class Message$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MessageReactions", [
-      { no: 1, name: "reactions", kind: "message", repeat: 1, T: () => Reaction }
+    super("Message", [
+      { no: 1, name: "id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "from_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 4, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 5, name: "message", kind: "scalar", opt: true, T: 9 },
+      { no: 6, name: "out", kind: "scalar", T: 8 },
+      { no: 7, name: "date", kind: "scalar", T: 3, L: 0 },
+      { no: 8, name: "mentioned", kind: "scalar", opt: true, T: 8 },
+      { no: 9, name: "reply_to_msg_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 10, name: "media", kind: "message", T: () => MessageMedia },
+      { no: 11, name: "edit_date", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 12, name: "grouped_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 13, name: "attachments", kind: "message", T: () => MessageAttachments },
+      { no: 14, name: "reactions", kind: "message", T: () => MessageReactions },
+      { no: 15, name: "is_sticker", kind: "scalar", opt: true, T: 8 },
+      { no: 6000, name: "has_link", kind: "scalar", opt: true, T: 8 },
+      { no: 16, name: "entities", kind: "message", T: () => MessageEntities },
+      { no: 17, name: "send_mode", kind: "enum", opt: true, T: () => ["MessageSendMode", MessageSendMode] },
+      { no: 18, name: "fwd_from", kind: "message", T: () => MessageFwdHeader },
+      { no: 19, name: "replies", kind: "message", T: () => MessageReplies },
+      { no: 20, name: "actions", kind: "message", T: () => MessageActions }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.id = 0n;
+    message.fromId = 0n;
+    message.chatId = 0n;
+    message.out = false;
+    message.date = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.id = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.fromId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 4:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 5:
+          message.message = reader.string();
+          break;
+        case 6:
+          message.out = reader.bool();
+          break;
+        case 7:
+          message.date = reader.int64().toBigInt();
+          break;
+        case 8:
+          message.mentioned = reader.bool();
+          break;
+        case 9:
+          message.replyToMsgId = reader.int64().toBigInt();
+          break;
+        case 10:
+          message.media = MessageMedia.internalBinaryRead(reader, reader.uint32(), options, message.media);
+          break;
+        case 11:
+          message.editDate = reader.int64().toBigInt();
+          break;
+        case 12:
+          message.groupedId = reader.int64().toBigInt();
+          break;
+        case 13:
+          message.attachments = MessageAttachments.internalBinaryRead(reader, reader.uint32(), options, message.attachments);
+          break;
+        case 14:
+          message.reactions = MessageReactions.internalBinaryRead(reader, reader.uint32(), options, message.reactions);
+          break;
+        case 15:
+          message.isSticker = reader.bool();
+          break;
+        case 6000:
+          message.hasLink = reader.bool();
+          break;
+        case 16:
+          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
+          break;
+        case 17:
+          message.sendMode = reader.int32();
+          break;
+        case 18:
+          message.fwdFrom = MessageFwdHeader.internalBinaryRead(reader, reader.uint32(), options, message.fwdFrom);
+          break;
+        case 19:
+          message.replies = MessageReplies.internalBinaryRead(reader, reader.uint32(), options, message.replies);
+          break;
+        case 20:
+          message.actions = MessageActions.internalBinaryRead(reader, reader.uint32(), options, message.actions);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.id !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.id);
+    if (message.fromId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.fromId);
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.chatId !== 0n)
+      writer.tag(4, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.message !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.message);
+    if (message.out !== false)
+      writer.tag(6, import_runtime.WireType.Varint).bool(message.out);
+    if (message.date !== 0n)
+      writer.tag(7, import_runtime.WireType.Varint).int64(message.date);
+    if (message.mentioned !== undefined)
+      writer.tag(8, import_runtime.WireType.Varint).bool(message.mentioned);
+    if (message.replyToMsgId !== undefined)
+      writer.tag(9, import_runtime.WireType.Varint).int64(message.replyToMsgId);
+    if (message.media)
+      MessageMedia.internalBinaryWrite(message.media, writer.tag(10, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.editDate !== undefined)
+      writer.tag(11, import_runtime.WireType.Varint).int64(message.editDate);
+    if (message.groupedId !== undefined)
+      writer.tag(12, import_runtime.WireType.Varint).int64(message.groupedId);
+    if (message.attachments)
+      MessageAttachments.internalBinaryWrite(message.attachments, writer.tag(13, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.reactions)
+      MessageReactions.internalBinaryWrite(message.reactions, writer.tag(14, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.isSticker !== undefined)
+      writer.tag(15, import_runtime.WireType.Varint).bool(message.isSticker);
+    if (message.hasLink !== undefined)
+      writer.tag(6000, import_runtime.WireType.Varint).bool(message.hasLink);
+    if (message.entities)
+      MessageEntities.internalBinaryWrite(message.entities, writer.tag(16, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.sendMode !== undefined)
+      writer.tag(17, import_runtime.WireType.Varint).int32(message.sendMode);
+    if (message.fwdFrom)
+      MessageFwdHeader.internalBinaryWrite(message.fwdFrom, writer.tag(18, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.replies)
+      MessageReplies.internalBinaryWrite(message.replies, writer.tag(19, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.actions)
+      MessageActions.internalBinaryWrite(message.actions, writer.tag(20, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var Message = new Message$Type;
+
+class MessageFwdHeader$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageFwdHeader", [
+      { no: 1, name: "from_peer_id", kind: "message", T: () => Peer },
+      { no: 2, name: "from_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "from_message_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.fromId = 0n;
+    message.fromMessageId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.fromPeerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.fromPeerId);
+          break;
+        case 2:
+          message.fromId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.fromMessageId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.fromPeerId)
+      Peer.internalBinaryWrite(message.fromPeerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.fromId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.fromId);
+    if (message.fromMessageId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.fromMessageId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageFwdHeader = new MessageFwdHeader$Type;
+
+class MessageEntities$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntities", [
+      { no: 1, name: "entities", kind: "message", repeat: 1, T: () => MessageEntity }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.entities = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.entities.push(MessageEntity.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.entities.length; i++)
+      MessageEntity.internalBinaryWrite(message.entities[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntities = new MessageEntities$Type;
+
+class MessageEntity$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity", [
+      { no: 1, name: "type", kind: "enum", T: () => ["MessageEntity.Type", MessageEntity_Type, "TYPE_"] },
+      { no: 2, name: "offset", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "length", kind: "scalar", T: 3, L: 0 },
+      { no: 4, name: "mention", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityMention },
+      { no: 5, name: "text_url", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityTextUrl },
+      { no: 6, name: "pre", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityPre }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = 0;
+    message.offset = 0n;
+    message.length = 0n;
+    message.entity = { oneofKind: undefined };
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.type = reader.int32();
+          break;
+        case 2:
+          message.offset = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.length = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.entity = {
+            oneofKind: "mention",
+            mention: MessageEntity_MessageEntityMention.internalBinaryRead(reader, reader.uint32(), options, message.entity.mention)
+          };
+          break;
+        case 5:
+          message.entity = {
+            oneofKind: "textUrl",
+            textUrl: MessageEntity_MessageEntityTextUrl.internalBinaryRead(reader, reader.uint32(), options, message.entity.textUrl)
+          };
+          break;
+        case 6:
+          message.entity = {
+            oneofKind: "pre",
+            pre: MessageEntity_MessageEntityPre.internalBinaryRead(reader, reader.uint32(), options, message.entity.pre)
+          };
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.type !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.type);
+    if (message.offset !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.offset);
+    if (message.length !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.length);
+    if (message.entity.oneofKind === "mention")
+      MessageEntity_MessageEntityMention.internalBinaryWrite(message.entity.mention, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.entity.oneofKind === "textUrl")
+      MessageEntity_MessageEntityTextUrl.internalBinaryWrite(message.entity.textUrl, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.entity.oneofKind === "pre")
+      MessageEntity_MessageEntityPre.internalBinaryWrite(message.entity.pre, writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity = new MessageEntity$Type;
+
+class MessageEntity_MessageEntityMention$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity.MessageEntityMention", [
+      { no: 1, name: "user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.userId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.userId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.userId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.userId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity_MessageEntityMention = new MessageEntity_MessageEntityMention$Type;
+
+class MessageEntity_MessageEntityTextUrl$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity.MessageEntityTextUrl", [
+      { no: 1, name: "url", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.url = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.url = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.url !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.url);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity_MessageEntityTextUrl = new MessageEntity_MessageEntityTextUrl$Type;
+
+class MessageEntity_MessageEntityPre$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity.MessageEntityPre", [
+      { no: 1, name: "language", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.language = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.language = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.language !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.language);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity_MessageEntityPre = new MessageEntity_MessageEntityPre$Type;
+
+class MessageReactions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageReactions", [
+      { no: 1, name: "reactions", kind: "message", repeat: 1, T: () => Reaction }
     ]);
   }
   create(value) {
@@ -9011,7 +9339,10 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { no: 44, name: "getBotCommands", kind: "message", oneof: "input", T: () => GetBotCommandsInput },
       { no: 45, name: "setBotCommands", kind: "message", oneof: "input", T: () => SetBotCommandsInput },
       { no: 46, name: "getPeerBotCommands", kind: "message", oneof: "input", T: () => GetPeerBotCommandsInput },
-      { no: 47, name: "showChatInSidebar", kind: "message", oneof: "input", T: () => ShowChatInSidebarInput }
+      { no: 47, name: "showChatInSidebar", kind: "message", oneof: "input", T: () => ShowChatInSidebarInput },
+      { no: 48, name: "reserveChatIds", kind: "message", oneof: "input", T: () => ReserveChatIdsInput },
+      { no: 49, name: "invokeMessageAction", kind: "message", oneof: "input", T: () => InvokeMessageActionInput },
+      { no: 50, name: "answerMessageAction", kind: "message", oneof: "input", T: () => AnswerMessageActionInput }
     ]);
   }
   create(value) {
@@ -9306,6 +9637,24 @@ class RpcCall$Type extends import_runtime4.MessageType {
             showChatInSidebar: ShowChatInSidebarInput.internalBinaryRead(reader, reader.uint32(), options, message.input.showChatInSidebar)
           };
           break;
+        case 48:
+          message.input = {
+            oneofKind: "reserveChatIds",
+            reserveChatIds: ReserveChatIdsInput.internalBinaryRead(reader, reader.uint32(), options, message.input.reserveChatIds)
+          };
+          break;
+        case 49:
+          message.input = {
+            oneofKind: "invokeMessageAction",
+            invokeMessageAction: InvokeMessageActionInput.internalBinaryRead(reader, reader.uint32(), options, message.input.invokeMessageAction)
+          };
+          break;
+        case 50:
+          message.input = {
+            oneofKind: "answerMessageAction",
+            answerMessageAction: AnswerMessageActionInput.internalBinaryRead(reader, reader.uint32(), options, message.input.answerMessageAction)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -9412,6 +9761,12 @@ class RpcCall$Type extends import_runtime4.MessageType {
       GetPeerBotCommandsInput.internalBinaryWrite(message.input.getPeerBotCommands, writer.tag(46, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.input.oneofKind === "showChatInSidebar")
       ShowChatInSidebarInput.internalBinaryWrite(message.input.showChatInSidebar, writer.tag(47, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "reserveChatIds")
+      ReserveChatIdsInput.internalBinaryWrite(message.input.reserveChatIds, writer.tag(48, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "invokeMessageAction")
+      InvokeMessageActionInput.internalBinaryWrite(message.input.invokeMessageAction, writer.tag(49, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "answerMessageAction")
+      AnswerMessageActionInput.internalBinaryWrite(message.input.answerMessageAction, writer.tag(50, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -9469,7 +9824,10 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { no: 44, name: "getBotCommands", kind: "message", oneof: "result", T: () => GetBotCommandsResult },
       { no: 45, name: "setBotCommands", kind: "message", oneof: "result", T: () => SetBotCommandsResult },
       { no: 46, name: "getPeerBotCommands", kind: "message", oneof: "result", T: () => GetPeerBotCommandsResult },
-      { no: 47, name: "showChatInSidebar", kind: "message", oneof: "result", T: () => ShowChatInSidebarResult }
+      { no: 47, name: "showChatInSidebar", kind: "message", oneof: "result", T: () => ShowChatInSidebarResult },
+      { no: 48, name: "reserveChatIds", kind: "message", oneof: "result", T: () => ReserveChatIdsResult },
+      { no: 49, name: "invokeMessageAction", kind: "message", oneof: "result", T: () => InvokeMessageActionResult },
+      { no: 50, name: "answerMessageAction", kind: "message", oneof: "result", T: () => AnswerMessageActionResult }
     ]);
   }
   create(value) {
@@ -9764,6 +10122,24 @@ class RpcResult$Type extends import_runtime4.MessageType {
             showChatInSidebar: ShowChatInSidebarResult.internalBinaryRead(reader, reader.uint32(), options, message.result.showChatInSidebar)
           };
           break;
+        case 48:
+          message.result = {
+            oneofKind: "reserveChatIds",
+            reserveChatIds: ReserveChatIdsResult.internalBinaryRead(reader, reader.uint32(), options, message.result.reserveChatIds)
+          };
+          break;
+        case 49:
+          message.result = {
+            oneofKind: "invokeMessageAction",
+            invokeMessageAction: InvokeMessageActionResult.internalBinaryRead(reader, reader.uint32(), options, message.result.invokeMessageAction)
+          };
+          break;
+        case 50:
+          message.result = {
+            oneofKind: "answerMessageAction",
+            answerMessageAction: AnswerMessageActionResult.internalBinaryRead(reader, reader.uint32(), options, message.result.answerMessageAction)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -9870,6 +10246,12 @@ class RpcResult$Type extends import_runtime4.MessageType {
       GetPeerBotCommandsResult.internalBinaryWrite(message.result.getPeerBotCommands, writer.tag(46, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.result.oneofKind === "showChatInSidebar")
       ShowChatInSidebarResult.internalBinaryWrite(message.result.showChatInSidebar, writer.tag(47, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "reserveChatIds")
+      ReserveChatIdsResult.internalBinaryWrite(message.result.reserveChatIds, writer.tag(48, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "invokeMessageAction")
+      InvokeMessageActionResult.internalBinaryWrite(message.result.invokeMessageAction, writer.tag(49, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "answerMessageAction")
+      AnswerMessageActionResult.internalBinaryWrite(message.result.answerMessageAction, writer.tag(50, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -12930,7 +13312,8 @@ class EditMessageInput$Type extends import_runtime4.MessageType {
       { no: 2, name: "peer_id", kind: "message", T: () => InputPeer },
       { no: 3, name: "text", kind: "scalar", T: 9 },
       { no: 7, name: "entities", kind: "message", T: () => MessageEntities },
-      { no: 8, name: "parse_markdown", kind: "scalar", opt: true, T: 8 }
+      { no: 8, name: "parse_markdown", kind: "scalar", opt: true, T: 8 },
+      { no: 9, name: "actions", kind: "message", T: () => MessageActions }
     ]);
   }
   create(value) {
@@ -12961,6 +13344,9 @@ class EditMessageInput$Type extends import_runtime4.MessageType {
         case 8:
           message.parseMarkdown = reader.bool();
           break;
+        case 9:
+          message.actions = MessageActions.internalBinaryRead(reader, reader.uint32(), options, message.actions);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -12983,6 +13369,8 @@ class EditMessageInput$Type extends import_runtime4.MessageType {
       MessageEntities.internalBinaryWrite(message.entities, writer.tag(7, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.parseMarkdown !== undefined)
       writer.tag(8, import_runtime.WireType.Varint).bool(message.parseMarkdown);
+    if (message.actions)
+      MessageActions.internalBinaryWrite(message.actions, writer.tag(9, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -13221,7 +13609,275 @@ class InputMediaDocument$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.documentId = reader.int64().toBigInt();
+          message.documentId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.documentId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.documentId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var InputMediaDocument = new InputMediaDocument$Type;
+
+class InputMediaVoice$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("InputMediaVoice", [
+      { no: 1, name: "voice_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.voiceId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.voiceId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.voiceId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.voiceId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var InputMediaVoice = new InputMediaVoice$Type;
+
+class InputMediaNudge$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("InputMediaNudge", []);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    return target ?? this.create();
+  }
+  internalBinaryWrite(message, writer, options) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var InputMediaNudge = new InputMediaNudge$Type;
+
+class SendMessageInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SendMessageInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "message", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "reply_to_msg_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 4, name: "random_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 5, name: "media", kind: "message", T: () => InputMedia },
+      { no: 1000, name: "temporary_send_date", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 6, name: "is_sticker", kind: "scalar", opt: true, T: 8 },
+      { no: 6000, name: "has_link", kind: "scalar", opt: true, T: 8 },
+      { no: 7, name: "entities", kind: "message", T: () => MessageEntities },
+      { no: 8, name: "parse_markdown", kind: "scalar", opt: true, T: 8 },
+      { no: 9, name: "send_mode", kind: "enum", opt: true, T: () => ["MessageSendMode", MessageSendMode] },
+      { no: 10, name: "actions", kind: "message", T: () => MessageActions }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.message = reader.string();
+          break;
+        case 3:
+          message.replyToMsgId = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.randomId = reader.int64().toBigInt();
+          break;
+        case 5:
+          message.media = InputMedia.internalBinaryRead(reader, reader.uint32(), options, message.media);
+          break;
+        case 1000:
+          message.temporarySendDate = reader.int64().toBigInt();
+          break;
+        case 6:
+          message.isSticker = reader.bool();
+          break;
+        case 6000:
+          message.hasLink = reader.bool();
+          break;
+        case 7:
+          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
+          break;
+        case 8:
+          message.parseMarkdown = reader.bool();
+          break;
+        case 9:
+          message.sendMode = reader.int32();
+          break;
+        case 10:
+          message.actions = MessageActions.internalBinaryRead(reader, reader.uint32(), options, message.actions);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.message !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.message);
+    if (message.replyToMsgId !== undefined)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.replyToMsgId);
+    if (message.randomId !== undefined)
+      writer.tag(4, import_runtime.WireType.Varint).int64(message.randomId);
+    if (message.media)
+      InputMedia.internalBinaryWrite(message.media, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.temporarySendDate !== undefined)
+      writer.tag(1000, import_runtime.WireType.Varint).int64(message.temporarySendDate);
+    if (message.isSticker !== undefined)
+      writer.tag(6, import_runtime.WireType.Varint).bool(message.isSticker);
+    if (message.hasLink !== undefined)
+      writer.tag(6000, import_runtime.WireType.Varint).bool(message.hasLink);
+    if (message.entities)
+      MessageEntities.internalBinaryWrite(message.entities, writer.tag(7, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.parseMarkdown !== undefined)
+      writer.tag(8, import_runtime.WireType.Varint).bool(message.parseMarkdown);
+    if (message.sendMode !== undefined)
+      writer.tag(9, import_runtime.WireType.Varint).int32(message.sendMode);
+    if (message.actions)
+      MessageActions.internalBinaryWrite(message.actions, writer.tag(10, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SendMessageInput = new SendMessageInput$Type;
+
+class SendMessageResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SendMessageResult", [
+      { no: 2, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.updates = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 2:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SendMessageResult = new SendMessageResult$Type;
+
+class InvokeMessageActionInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("InvokeMessageActionInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "action_id", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.messageId = 0n;
+    message.actionId = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.actionId = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -13235,25 +13891,29 @@ class InputMediaDocument$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.documentId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.documentId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.messageId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
+    if (message.actionId !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.actionId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var InputMediaDocument = new InputMediaDocument$Type;
+var InvokeMessageActionInput = new InvokeMessageActionInput$Type;
 
-class InputMediaVoice$Type extends import_runtime4.MessageType {
+class InvokeMessageActionResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("InputMediaVoice", [
-      { no: 1, name: "voice_id", kind: "scalar", T: 3, L: 0 }
+    super("InvokeMessageActionResult", [
+      { no: 1, name: "interaction_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.voiceId = 0n;
+    message.interactionId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13264,7 +13924,7 @@ class InputMediaVoice$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.voiceId = reader.int64().toBigInt();
+          message.interactionId = reader.int64().toBigInt();
           break;
         default:
           let u = options.readUnknownField;
@@ -13278,56 +13938,26 @@ class InputMediaVoice$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.voiceId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.voiceId);
-    let u = options.writeUnknownFields;
-    if (u !== false)
-      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-    return writer;
-  }
-}
-var InputMediaVoice = new InputMediaVoice$Type;
-
-class InputMediaNudge$Type extends import_runtime4.MessageType {
-  constructor() {
-    super("InputMediaNudge", []);
-  }
-  create(value) {
-    const message = globalThis.Object.create(this.messagePrototype);
-    if (value !== undefined)
-      import_runtime3.reflectionMergePartial(this, message, value);
-    return message;
-  }
-  internalBinaryRead(reader, length, options, target) {
-    return target ?? this.create();
-  }
-  internalBinaryWrite(message, writer, options) {
+    if (message.interactionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.interactionId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var InputMediaNudge = new InputMediaNudge$Type;
+var InvokeMessageActionResult = new InvokeMessageActionResult$Type;
 
-class SendMessageInput$Type extends import_runtime4.MessageType {
+class AnswerMessageActionInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SendMessageInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
-      { no: 2, name: "message", kind: "scalar", opt: true, T: 9 },
-      { no: 3, name: "reply_to_msg_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 4, name: "random_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 5, name: "media", kind: "message", T: () => InputMedia },
-      { no: 1000, name: "temporary_send_date", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 6, name: "is_sticker", kind: "scalar", opt: true, T: 8 },
-      { no: 6000, name: "has_link", kind: "scalar", opt: true, T: 8 },
-      { no: 7, name: "entities", kind: "message", T: () => MessageEntities },
-      { no: 8, name: "parse_markdown", kind: "scalar", opt: true, T: 8 },
-      { no: 9, name: "send_mode", kind: "enum", opt: true, T: () => ["MessageSendMode", MessageSendMode] }
+    super("AnswerMessageActionInput", [
+      { no: 1, name: "interaction_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "ui", kind: "message", T: () => MessageActionResponseUi }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.interactionId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13338,37 +13968,10 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          message.interactionId = reader.int64().toBigInt();
           break;
         case 2:
-          message.message = reader.string();
-          break;
-        case 3:
-          message.replyToMsgId = reader.int64().toBigInt();
-          break;
-        case 4:
-          message.randomId = reader.int64().toBigInt();
-          break;
-        case 5:
-          message.media = InputMedia.internalBinaryRead(reader, reader.uint32(), options, message.media);
-          break;
-        case 1000:
-          message.temporarySendDate = reader.int64().toBigInt();
-          break;
-        case 6:
-          message.isSticker = reader.bool();
-          break;
-        case 6000:
-          message.hasLink = reader.bool();
-          break;
-        case 7:
-          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
-          break;
-        case 8:
-          message.parseMarkdown = reader.bool();
-          break;
-        case 9:
-          message.sendMode = reader.int32();
+          message.ui = MessageActionResponseUi.internalBinaryRead(reader, reader.uint32(), options, message.ui);
           break;
         default:
           let u = options.readUnknownField;
@@ -13382,78 +13985,39 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.peerId)
-      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.message !== undefined)
-      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.message);
-    if (message.replyToMsgId !== undefined)
-      writer.tag(3, import_runtime.WireType.Varint).int64(message.replyToMsgId);
-    if (message.randomId !== undefined)
-      writer.tag(4, import_runtime.WireType.Varint).int64(message.randomId);
-    if (message.media)
-      InputMedia.internalBinaryWrite(message.media, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.temporarySendDate !== undefined)
-      writer.tag(1000, import_runtime.WireType.Varint).int64(message.temporarySendDate);
-    if (message.isSticker !== undefined)
-      writer.tag(6, import_runtime.WireType.Varint).bool(message.isSticker);
-    if (message.hasLink !== undefined)
-      writer.tag(6000, import_runtime.WireType.Varint).bool(message.hasLink);
-    if (message.entities)
-      MessageEntities.internalBinaryWrite(message.entities, writer.tag(7, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.parseMarkdown !== undefined)
-      writer.tag(8, import_runtime.WireType.Varint).bool(message.parseMarkdown);
-    if (message.sendMode !== undefined)
-      writer.tag(9, import_runtime.WireType.Varint).int32(message.sendMode);
+    if (message.interactionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.interactionId);
+    if (message.ui)
+      MessageActionResponseUi.internalBinaryWrite(message.ui, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SendMessageInput = new SendMessageInput$Type;
+var AnswerMessageActionInput = new AnswerMessageActionInput$Type;
 
-class SendMessageResult$Type extends import_runtime4.MessageType {
+class AnswerMessageActionResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SendMessageResult", [
-      { no: 2, name: "updates", kind: "message", repeat: 1, T: () => Update }
-    ]);
+    super("AnswerMessageActionResult", []);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.updates = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
   }
   internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case 2:
-          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
+    return target ?? this.create();
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.updates.length; i++)
-      Update.internalBinaryWrite(message.updates[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SendMessageResult = new SendMessageResult$Type;
+var AnswerMessageActionResult = new AnswerMessageActionResult$Type;
 
 class ForwardMessagesInput$Type extends import_runtime4.MessageType {
   constructor() {
@@ -13906,25 +14470,161 @@ class SearchMessagesResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.messages.length; i++)
-      Message.internalBinaryWrite(message.messages[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.messages.length; i++)
+      Message.internalBinaryWrite(message.messages[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SearchMessagesResult = new SearchMessagesResult$Type;
+
+class InputChatParticipant$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("InputChatParticipant", [
+      { no: 1, name: "user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.userId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.userId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.userId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.userId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var InputChatParticipant = new InputChatParticipant$Type;
+
+class ReserveChatIdsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ReserveChatIdsInput", [
+      { no: 1, name: "count", kind: "scalar", T: 5 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.count = 0;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.count = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.count !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.count);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var ReserveChatIdsInput = new ReserveChatIdsInput$Type;
+
+class ReservedChatId$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ReservedChatId", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "expires_at", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chatId = 0n;
+    message.expiresAt = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.expiresAt = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.expiresAt !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.expiresAt);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SearchMessagesResult = new SearchMessagesResult$Type;
+var ReservedChatId = new ReservedChatId$Type;
 
-class InputChatParticipant$Type extends import_runtime4.MessageType {
+class ReserveChatIdsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("InputChatParticipant", [
-      { no: 1, name: "user_id", kind: "scalar", T: 3, L: 0 }
+    super("ReserveChatIdsResult", [
+      { no: 1, name: "reservations", kind: "message", repeat: 1, T: () => ReservedChatId }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.userId = 0n;
+    message.reservations = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13935,7 +14635,7 @@ class InputChatParticipant$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.userId = reader.int64().toBigInt();
+          message.reservations.push(ReservedChatId.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -13949,15 +14649,15 @@ class InputChatParticipant$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.userId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.userId);
+    for (let i = 0;i < message.reservations.length; i++)
+      ReservedChatId.internalBinaryWrite(message.reservations[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var InputChatParticipant = new InputChatParticipant$Type;
+var ReserveChatIdsResult = new ReserveChatIdsResult$Type;
 
 class CreateChatInput$Type extends import_runtime4.MessageType {
   constructor() {
@@ -13967,7 +14667,8 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
       { no: 3, name: "description", kind: "scalar", opt: true, T: 9 },
       { no: 4, name: "emoji", kind: "scalar", opt: true, T: 9 },
       { no: 5, name: "is_public", kind: "scalar", T: 8 },
-      { no: 6, name: "participants", kind: "message", repeat: 1, T: () => InputChatParticipant }
+      { no: 6, name: "participants", kind: "message", repeat: 1, T: () => InputChatParticipant },
+      { no: 7, name: "reserved_chat_id", kind: "scalar", opt: true, T: 3, L: 0 }
     ]);
   }
   create(value) {
@@ -14002,6 +14703,9 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
         case 6:
           message.participants.push(InputChatParticipant.internalBinaryRead(reader, reader.uint32(), options));
           break;
+        case 7:
+          message.reservedChatId = reader.int64().toBigInt();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -14026,6 +14730,8 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
       writer.tag(5, import_runtime.WireType.Varint).bool(message.isPublic);
     for (let i = 0;i < message.participants.length; i++)
       InputChatParticipant.internalBinaryWrite(message.participants[i], writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.reservedChatId !== undefined)
+      writer.tag(7, import_runtime.WireType.Varint).int64(message.reservedChatId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -14338,7 +15044,9 @@ class Update$Type extends import_runtime4.MessageType {
       { no: 31, name: "pinned_messages", kind: "message", oneof: "update", T: () => UpdatePinnedMessages },
       { no: 32, name: "chat_moved", kind: "message", oneof: "update", T: () => UpdateChatMoved },
       { no: 33, name: "dialog_notification_settings", kind: "message", oneof: "update", T: () => UpdateDialogNotificationSettings },
-      { no: 34, name: "chat_open", kind: "message", oneof: "update", T: () => UpdateChatOpen }
+      { no: 34, name: "chat_open", kind: "message", oneof: "update", T: () => UpdateChatOpen },
+      { no: 35, name: "message_action_invoked", kind: "message", oneof: "update", T: () => UpdateMessageActionInvoked },
+      { no: 36, name: "message_action_answered", kind: "message", oneof: "update", T: () => UpdateMessageActionAnswered }
     ]);
   }
   create(value) {
@@ -14545,6 +15253,18 @@ class Update$Type extends import_runtime4.MessageType {
             chatOpen: UpdateChatOpen.internalBinaryRead(reader, reader.uint32(), options, message.update.chatOpen)
           };
           break;
+        case 35:
+          message.update = {
+            oneofKind: "messageActionInvoked",
+            messageActionInvoked: UpdateMessageActionInvoked.internalBinaryRead(reader, reader.uint32(), options, message.update.messageActionInvoked)
+          };
+          break;
+        case 36:
+          message.update = {
+            oneofKind: "messageActionAnswered",
+            messageActionAnswered: UpdateMessageActionAnswered.internalBinaryRead(reader, reader.uint32(), options, message.update.messageActionAnswered)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -14623,6 +15343,10 @@ class Update$Type extends import_runtime4.MessageType {
       UpdateDialogNotificationSettings.internalBinaryWrite(message.update.dialogNotificationSettings, writer.tag(33, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.update.oneofKind === "chatOpen")
       UpdateChatOpen.internalBinaryWrite(message.update.chatOpen, writer.tag(34, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "messageActionInvoked")
+      UpdateMessageActionInvoked.internalBinaryWrite(message.update.messageActionInvoked, writer.tag(35, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "messageActionAnswered")
+      UpdateMessageActionAnswered.internalBinaryWrite(message.update.messageActionAnswered, writer.tag(36, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -15579,6 +16303,133 @@ class UpdateChatOpen$Type extends import_runtime4.MessageType {
 }
 var UpdateChatOpen = new UpdateChatOpen$Type;
 
+class UpdateMessageActionInvoked$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateMessageActionInvoked", [
+      { no: 1, name: "interaction_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "message_id", kind: "scalar", T: 3, L: 0 },
+      { no: 4, name: "actor_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 5, name: "action_id", kind: "scalar", T: 9 },
+      { no: 6, name: "data", kind: "scalar", T: 12 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.interactionId = 0n;
+    message.chatId = 0n;
+    message.messageId = 0n;
+    message.actorUserId = 0n;
+    message.actionId = "";
+    message.data = new Uint8Array(0);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.interactionId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.actorUserId = reader.int64().toBigInt();
+          break;
+        case 5:
+          message.actionId = reader.string();
+          break;
+        case 6:
+          message.data = reader.bytes();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.interactionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.interactionId);
+    if (message.chatId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.messageId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.messageId);
+    if (message.actorUserId !== 0n)
+      writer.tag(4, import_runtime.WireType.Varint).int64(message.actorUserId);
+    if (message.actionId !== "")
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.actionId);
+    if (message.data.length)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).bytes(message.data);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateMessageActionInvoked = new UpdateMessageActionInvoked$Type;
+
+class UpdateMessageActionAnswered$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateMessageActionAnswered", [
+      { no: 1, name: "interaction_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "ui", kind: "message", T: () => MessageActionResponseUi }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.interactionId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.interactionId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.ui = MessageActionResponseUi.internalBinaryRead(reader, reader.uint32(), options, message.ui);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.interactionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.interactionId);
+    if (message.ui)
+      MessageActionResponseUi.internalBinaryWrite(message.ui, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateMessageActionAnswered = new UpdateMessageActionAnswered$Type;
+
 class UpdateDeleteChat$Type extends import_runtime4.MessageType {
   constructor() {
     super("UpdateDeleteChat", [
@@ -18052,7 +18903,9 @@ var rpcInputKindByMethod = {
   35: "moveThread",
   36: "rotateBotToken",
   37: "updateBotProfile",
-  38: "getMessages"
+  38: "getMessages",
+  48: "invokeMessageAction",
+  49: "answerMessageAction"
 };
 var rpcResultKindByMethod = {
   0: undefined,
@@ -18093,7 +18946,9 @@ var rpcResultKindByMethod = {
   35: "moveThread",
   36: "rotateBotToken",
   37: "updateBotProfile",
-  38: "getMessages"
+  38: "getMessages",
+  48: "invokeMessageAction",
+  49: "answerMessageAction"
 };
 
 // ../sdk/dist/sdk/logger.js
@@ -18103,19 +18958,23 @@ var noopLogger = {};
 import { readFileSync } from "node:fs";
 var cached = null;
 var getSdkVersion = () => {
-  if (cached)
+  if (cached !== null)
     return cached;
   try {
     const pkgUrl = new URL("../../package.json", import.meta.url);
     const raw = readFileSync(pkgUrl, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && "version" in parsed && typeof parsed.version === "string") {
-      const version = parsed.version;
+      const version = parsed.version.trim();
+      if (!version) {
+        cached = undefined;
+        return cached;
+      }
       cached = version;
       return version;
     }
   } catch {}
-  cached = "unknown";
+  cached = undefined;
   return cached;
 };
 
@@ -18126,6 +18985,8 @@ var defaultApiBaseUrl = "https://api.inline.chat";
 var defaultVideoWidth = 1280;
 var defaultVideoHeight = 720;
 var defaultVideoDuration = 1;
+var defaultCatchUpTotalLimit = 1000;
+var defaultColdStartCatchUpWindow = defaultCatchUpTotalLimit;
 function extractFirstMessageId(updates) {
   for (const update of updates ?? []) {
     if (update.update.oneofKind === "newMessage") {
@@ -18153,6 +19014,7 @@ class InlineSdkClient {
   saveTimer = null;
   saveInFlight = null;
   catchUpInFlightByChatId = new Map;
+  catchUpRequestedByChatId = new Map;
   constructor(options) {
     this.options = options;
     this.log = options.logger ?? noopLogger;
@@ -18160,12 +19022,13 @@ class InlineSdkClient {
     this.fetchImpl = options.fetch ?? fetch;
     const url = resolveRealtimeUrl(this.httpBaseUrl);
     this.transport = options.transport ?? new WebSocketTransport({ url, logger: options.logger });
+    const sdkVersion = getSdkVersion();
     this.protocol = new ProtocolClient({
       transport: this.transport,
       getConnectionInit: () => ({
         token: options.token,
         layer: sdkLayer,
-        clientVersion: getSdkVersion()
+        ...sdkVersion ? { clientVersion: sdkVersion } : {}
       }),
       logger: options.logger,
       defaultRpcTimeoutMs: options.rpcTimeoutMs
@@ -18292,6 +19155,7 @@ class InlineSdkClient {
           ...params.replyToMsgId != null ? { replyToMsgId: asInlineId(params.replyToMsgId, "replyToMsgId") } : {},
           ...params.parseMarkdown != null ? { parseMarkdown: params.parseMarkdown } : {},
           ...params.entities != null ? { entities: params.entities } : {},
+          ...params.actions != null ? { actions: params.actions } : {},
           ...params.sendMode === "silent" ? { sendMode: MessageSendMode.MODE_SILENT } : {}
         }
       });
@@ -18399,6 +19263,33 @@ class InlineSdkClient {
       }
     });
   }
+  async invokeMessageAction(params) {
+    const peerId = this.inputPeerFromTarget(params, "invokeMessageAction");
+    const actionId = params.actionId.trim();
+    if (!actionId) {
+      throw new Error("invokeMessageAction: `actionId` must be non-empty");
+    }
+    const result = await this.invoke(Method.INVOKE_MESSAGE_ACTION, {
+      oneofKind: "invokeMessageAction",
+      invokeMessageAction: {
+        peerId,
+        messageId: asInlineId(params.messageId, "messageId"),
+        actionId
+      }
+    });
+    return {
+      interactionId: result.invokeMessageAction.interactionId
+    };
+  }
+  async answerMessageAction(params) {
+    await this.invoke(Method.ANSWER_MESSAGE_ACTION, {
+      oneofKind: "answerMessageAction",
+      answerMessageAction: {
+        interactionId: asInlineId(params.interactionId, "interactionId"),
+        ...params.ui != null ? { ui: params.ui } : {}
+      }
+    });
+  }
   async invokeRaw(method, input = { oneofKind: undefined }, options) {
     if (hasMethodMapping(method)) {
       this.assertMethodInputMatch(method, input);
@@ -18565,6 +19456,32 @@ class InlineSdkClient {
         });
         return;
       }
+      case "messageActionInvoked": {
+        const payload = update.update.messageActionInvoked;
+        await this.eventStream.send({
+          kind: "message.action.invoke",
+          interactionId: payload.interactionId,
+          chatId: payload.chatId,
+          messageId: payload.messageId,
+          actorUserId: payload.actorUserId,
+          actionId: payload.actionId,
+          data: payload.data,
+          seq,
+          date
+        });
+        return;
+      }
+      case "messageActionAnswered": {
+        const payload = update.update.messageActionAnswered;
+        await this.eventStream.send({
+          kind: "message.action.answered",
+          interactionId: payload.interactionId,
+          ui: payload.ui,
+          seq,
+          date
+        });
+        return;
+      }
       case "chatHasNewUpdates": {
         const payload = update.update.chatHasNewUpdates;
         await this.eventStream.send({
@@ -18573,7 +19490,7 @@ class InlineSdkClient {
           seq,
           date
         });
-        await this.catchUpChat({ chatId: payload.chatId, peer: payload.peerId, updateSeq: payload.updateSeq, update });
+        this.requestCatchUpChat({ chatId: payload.chatId, peer: payload.peerId, updateSeq: payload.updateSeq });
         return;
       }
       case "spaceHasNewUpdates": {
@@ -18602,21 +19519,50 @@ class InlineSdkClient {
       this.scheduleStateSave();
     }
   }
-  async catchUpChat(params) {
-    const key = params.chatId.toString();
-    const lastSeq = this.state.lastSeqByChatId?.[key];
-    const startSeq = lastSeq ?? params.updateSeq;
-    if (params.updateSeq <= startSeq)
-      return;
+  requestCatchUpChat(params) {
+    const previous = this.catchUpRequestedByChatId.get(params.chatId);
+    this.catchUpRequestedByChatId.set(params.chatId, {
+      endSeq: Math.max(previous?.endSeq ?? 0, params.updateSeq),
+      peer: params.peer ?? previous?.peer
+    });
     if (this.catchUpInFlightByChatId.has(params.chatId)) {
-      await this.catchUpInFlightByChatId.get(params.chatId);
       return;
     }
-    const task = this.doCatchUpChat(params.chatId, params.peer, startSeq, params.updateSeq).finally(() => {
+    const task = this.drainCatchUpChat(params.chatId).catch((error) => {
+      this.catchUpRequestedByChatId.delete(params.chatId);
+      this.log.warn?.("GET_UPDATES catch-up failed; continuing live delivery", {
+        chatId: params.chatId.toString(),
+        error: extractErrorMessage(error)
+      });
+    }).finally(() => {
       this.catchUpInFlightByChatId.delete(params.chatId);
     });
     this.catchUpInFlightByChatId.set(params.chatId, task);
-    await task;
+  }
+  async drainCatchUpChat(chatId) {
+    const key = chatId.toString();
+    while (true) {
+      const request = this.catchUpRequestedByChatId.get(chatId);
+      if (!request)
+        return;
+      const lastSeq = this.state.lastSeqByChatId?.[key];
+      const startSeq = lastSeq ?? Math.max(0, request.endSeq - defaultColdStartCatchUpWindow);
+      if (request.endSeq <= startSeq) {
+        this.catchUpRequestedByChatId.delete(chatId);
+        return;
+      }
+      const stop = await this.doCatchUpChat(chatId, request.peer, startSeq, request.endSeq);
+      if (stop) {
+        this.catchUpRequestedByChatId.delete(chatId);
+        return;
+      }
+      const latest = this.catchUpRequestedByChatId.get(chatId);
+      const syncedSeq = this.state.lastSeqByChatId?.[key] ?? 0;
+      if (!latest || latest.endSeq <= syncedSeq) {
+        this.catchUpRequestedByChatId.delete(chatId);
+        return;
+      }
+    }
   }
   async doCatchUpChat(chatId, peer, startSeq, endSeq) {
     let cursor = startSeq;
@@ -18634,7 +19580,7 @@ class InlineSdkClient {
           }),
           startSeq: BigInt(cursor),
           seqEnd: BigInt(endSeq),
-          totalLimit: 1000
+          totalLimit: defaultCatchUpTotalLimit
         })
       });
       const payload = result.getUpdates;
@@ -18645,12 +19591,12 @@ class InlineSdkClient {
           this.state.dateCursor = payload.date;
         }
         this.scheduleStateSave();
-        return;
+        return true;
       }
       const deliveredSeq = Number(payload.seq ?? 0n);
       if (!Number.isSafeInteger(deliveredSeq)) {
         this.log.warn?.("GET_UPDATES returned non-integer seq; aborting catch-up", { chatId: chatId.toString() });
-        return;
+        return true;
       }
       this.bumpChatSeq(chatId, deliveredSeq);
       for (const update of payload.updates) {
@@ -18661,13 +19607,14 @@ class InlineSdkClient {
       }
       this.scheduleStateSave();
       if (payload.final)
-        return;
+        return true;
       if (deliveredSeq <= cursor) {
         this.log.warn?.("GET_UPDATES made no progress; aborting catch-up", { chatId: chatId.toString(), cursor, deliveredSeq });
-        return;
+        return true;
       }
       cursor = deliveredSeq;
     }
+    return false;
   }
   peerToInputPeer(peer, chatId) {
     if (!peer) {
@@ -19002,15 +19949,6 @@ class JsonFileStateStore {
     await rename(tempPath, this.path);
   }
 }
-// src/inline/config-schema.ts
-import {
-  BlockStreamingCoalesceSchema,
-  DmPolicySchema,
-  GroupPolicySchema,
-  ToolPolicySchema,
-  requireOpenAllowFrom
-} from "openclaw/plugin-sdk";
-
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -32534,15 +33472,255 @@ function number3(params) {
 function boolean3(params) {
   return _coercedBoolean(ZodBoolean, params);
 }
-function bigint3(params) {
-  return _coercedBigint(ZodBigInt, params);
+function bigint3(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date4(params) {
+  return _coercedDate(ZodDate, params);
+}
+
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
+config(en_default());
+// src/openclaw-compat.ts
+var MB = 1024 * 1024;
+var VALID_ACCOUNT_ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
+var INVALID_ACCOUNT_ID_CHARS_RE = /[^a-z0-9_-]+/g;
+var LEADING_DASH_RE = /^-+/g;
+var TRAILING_DASH_RE = /-+$/g;
+var BLOCKED_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+var DEFAULT_ACCOUNT_ID = "default";
+var PAIRING_APPROVED_MESSAGE = "✅ OpenClaw access approved. Send a message to start chatting.";
+function normalizeAccountId(value) {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed)
+    return DEFAULT_ACCOUNT_ID;
+  const normalized = VALID_ACCOUNT_ID_RE.test(trimmed) ? trimmed.toLowerCase() : trimmed.toLowerCase().replace(INVALID_ACCOUNT_ID_CHARS_RE, "-").replace(LEADING_DASH_RE, "").replace(TRAILING_DASH_RE, "").slice(0, 64);
+  if (!normalized || BLOCKED_OBJECT_KEYS.has(normalized)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return normalized;
+}
+function emptyPluginConfigSchema() {
+  function error48(message) {
+    return { success: false, error: { issues: [{ path: [], message }] } };
+  }
+  return {
+    safeParse(value) {
+      if (value === undefined) {
+        return { success: true, data: undefined };
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return error48("expected config object");
+      }
+      if (Object.keys(value).length > 0) {
+        return error48("config must be empty");
+      }
+      return { success: true, data: value };
+    },
+    jsonSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {}
+    }
+  };
+}
+function buildChannelConfigSchema(schema) {
+  const schemaWithJson = schema;
+  if (typeof schemaWithJson.toJSONSchema === "function") {
+    return {
+      schema: schemaWithJson.toJSONSchema({
+        target: "draft-07",
+        unrepresentable: "any"
+      })
+    };
+  }
+  return {
+    schema: {
+      type: "object",
+      additionalProperties: true
+    }
+  };
+}
+function formatPairingApproveHint(channelId) {
+  return `Approve via: openclaw pairing list ${channelId} / openclaw pairing approve ${channelId} <code>`;
+}
+var GroupPolicySchema = exports_external.enum(["open", "disabled", "allowlist"]);
+var DmPolicySchema = exports_external.enum(["pairing", "allowlist", "open", "disabled"]);
+var BlockStreamingCoalesceSchema = exports_external.object({
+  minChars: exports_external.number().int().positive().optional(),
+  maxChars: exports_external.number().int().positive().optional(),
+  idleMs: exports_external.number().int().nonnegative().optional()
+}).strict();
+var ToolPolicyBaseSchema = exports_external.object({
+  allow: exports_external.array(exports_external.string()).optional(),
+  alsoAllow: exports_external.array(exports_external.string()).optional(),
+  deny: exports_external.array(exports_external.string()).optional()
+}).strict();
+var ToolPolicySchema = ToolPolicyBaseSchema.superRefine((value, ctx) => {
+  if (value.allow && value.allow.length > 0 && value.alsoAllow && value.alsoAllow.length > 0) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "tools policy cannot set both allow and alsoAllow in the same scope (merge alsoAllow into allow, or remove allow and use profile + alsoAllow)"
+    });
+  }
+}).optional();
+function requireOpenAllowFrom(params) {
+  if (params.policy !== "open") {
+    return;
+  }
+  const allow = (params.allowFrom ?? []).map((entry) => String(entry).trim()).filter(Boolean);
+  if (allow.includes("*")) {
+    return;
+  }
+  params.ctx.addIssue({
+    code: exports_external.ZodIssueCode.custom,
+    path: params.path,
+    message: params.message
+  });
+}
+function resolveControlCommandGate(params) {
+  const mode = params.modeWhenAccessGroupsOff ?? "allow";
+  let commandAuthorized = false;
+  if (!params.useAccessGroups) {
+    if (mode === "allow") {
+      commandAuthorized = true;
+    } else if (mode === "deny") {
+      commandAuthorized = false;
+    } else {
+      const anyConfigured = params.authorizers.some((entry) => entry.configured);
+      commandAuthorized = !anyConfigured || params.authorizers.some((entry) => entry.configured && entry.allowed);
+    }
+  } else {
+    commandAuthorized = params.authorizers.some((entry) => entry.configured && entry.allowed);
+  }
+  return {
+    commandAuthorized,
+    shouldBlock: params.allowTextCommands && params.hasControlCommand && !commandAuthorized
+  };
+}
+function resolveMentionGatingWithBypass(params) {
+  const shouldBypassMention = params.isGroup && params.requireMention && !params.wasMentioned && !(params.hasAnyMention ?? false) && params.allowTextCommands && params.commandAuthorized && params.hasControlCommand;
+  const effectiveWasMentioned = params.wasMentioned || params.implicitMention === true || shouldBypassMention;
+  return {
+    effectiveWasMentioned,
+    shouldSkip: params.requireMention && params.canDetectMention && !effectiveWasMentioned,
+    shouldBypassMention
+  };
+}
+function logInboundDrop(params) {
+  const target = params.target ? ` target=${params.target}` : "";
+  params.log(`${params.channel}: drop ${params.reason}${target}`);
+}
+function resolveChannelMediaMaxBytes(params) {
+  const accountId = normalizeAccountId(params.accountId);
+  const channelLimit = params.resolveChannelLimitMb({
+    cfg: params.cfg,
+    accountId
+  });
+  if (channelLimit) {
+    return channelLimit * MB;
+  }
+  if (params.cfg.agents?.defaults?.mediaMaxMb) {
+    return params.cfg.agents.defaults.mediaMaxMb * MB;
+  }
+  return;
+}
+function createActionGate(actions) {
+  return (key, defaultValue = true) => {
+    const value = actions?.[key];
+    if (value === undefined) {
+      return defaultValue;
+    }
+    return value !== false;
+  };
+}
+function toSnakeCaseKey(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function readSnakeCaseParamRaw(params, key) {
+  if (Object.hasOwn(params, key)) {
+    return params[key];
+  }
+  const snakeKey = toSnakeCaseKey(key);
+  if (snakeKey !== key && Object.hasOwn(params, snakeKey)) {
+    return params[snakeKey];
+  }
+  return;
+}
+
+class ToolInputError extends Error {
+  status = 400;
+  constructor(message) {
+    super(message);
+    this.name = "ToolInputError";
+  }
+}
+function readStringParam(params, key, options = {}) {
+  const { required: required2 = false, trim = true, label = key, allowEmpty = false } = options;
+  const raw = readSnakeCaseParamRaw(params, key);
+  if (typeof raw !== "string") {
+    if (required2) {
+      throw new ToolInputError(`${label} required`);
+    }
+    return;
+  }
+  const value = trim ? raw.trim() : raw;
+  if (!value && !allowEmpty) {
+    if (required2) {
+      throw new ToolInputError(`${label} required`);
+    }
+    return;
+  }
+  return value;
+}
+function readNumberParam(params, key, options = {}) {
+  const { required: required2 = false, label = key, integer: integer2 = false, strict = false } = options;
+  const raw = readSnakeCaseParamRaw(params, key);
+  let value;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    value = raw;
+  } else if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed) {
+      const parsed = strict ? Number(trimmed) : Number.parseFloat(trimmed);
+      if (Number.isFinite(parsed)) {
+        value = parsed;
+      }
+    }
+  }
+  if (value === undefined) {
+    if (required2) {
+      throw new ToolInputError(`${label} required`);
+    }
+    return;
+  }
+  return integer2 ? Math.trunc(value) : value;
+}
+function readReactionParams(params, options) {
+  const emojiKey = options.emojiKey ?? "emoji";
+  const removeKey = options.removeKey ?? "remove";
+  const remove = typeof params[removeKey] === "boolean" ? params[removeKey] : false;
+  const emoji3 = readStringParam(params, emojiKey, {
+    required: true,
+    allowEmpty: true
+  });
+  if (remove && !emoji3) {
+    throw new ToolInputError(options.removeErrorMessage);
+  }
+  return { emoji: emoji3 ?? "", remove, isEmpty: !emoji3 };
 }
-function date4(params) {
-  return _coercedDate(ZodDate, params);
+function jsonResult(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2)
+      }
+    ],
+    details: payload
+  };
 }
 
-// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
-config(en_default());
 // src/inline/config-schema.ts
 var InlineActionsSchema = exports_external.object({
   send: exports_external.boolean().optional(),
@@ -32559,9 +33737,14 @@ var InlineActionsSchema = exports_external.object({
 }).strict();
 var InlineGroupSchema = exports_external.object({
   requireMention: exports_external.boolean().optional(),
+  systemPrompt: exports_external.string().optional(),
   tools: ToolPolicySchema,
   toolsBySender: exports_external.record(exports_external.string(), ToolPolicySchema).optional()
 }).strict();
+var InlineCommandsSchema = exports_external.object({
+  native: exports_external.union([exports_external.boolean(), exports_external.literal("auto")]).optional(),
+  nativeSkills: exports_external.union([exports_external.boolean(), exports_external.literal("auto")]).optional()
+}).strict();
 var InlineAccountSchemaBase = exports_external.object({
   name: exports_external.string().optional(),
   enabled: exports_external.boolean().optional(),
@@ -32570,6 +33753,7 @@ var InlineAccountSchemaBase = exports_external.object({
   tokenFile: exports_external.string().optional(),
   dmPolicy: DmPolicySchema.optional().default("pairing"),
   allowFrom: exports_external.array(exports_external.string()).optional(),
+  systemPrompt: exports_external.string().optional(),
   groupAllowFrom: exports_external.array(exports_external.string()).optional(),
   groupPolicy: GroupPolicySchema.optional().default("allowlist"),
   groups: exports_external.record(exports_external.string(), InlineGroupSchema.optional()).optional(),
@@ -32584,7 +33768,8 @@ var InlineAccountSchemaBase = exports_external.object({
   chunkMode: exports_external.enum(["length", "newline"]).optional(),
   blockStreaming: exports_external.boolean().optional(),
   streamViaEditMessage: exports_external.boolean().optional(),
-  blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional()
+  blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+  commands: InlineCommandsSchema.optional()
 }).strict();
 var InlineRuntimeAccountSchema = InlineAccountSchemaBase.passthrough();
 var InlineAccountSchema = InlineAccountSchemaBase.superRefine((value, ctx) => {
@@ -32612,7 +33797,6 @@ var InlineConfigSchema = InlineAccountSchemaBase.extend({
 });
 
 // src/inline/accounts.ts
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
 import { readFile as readFile2 } from "node:fs/promises";
 var DEFAULT_BASE_URL = "https://api.inline.chat";
 function normalizeInlineAccountId(raw) {
@@ -32718,22 +33902,283 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 // src/inline/monitor.ts
 import { mkdir } from "node:fs/promises";
 import path2 from "node:path";
-import {
-  buildPendingHistoryContextFromMap,
-  clearHistoryEntriesIfEnabled,
-  createReplyPrefixOptions,
-  createTypingCallbacks,
-  logInboundDrop,
-  recordPendingHistoryEntryIfEnabled,
-  resolveChannelMediaMaxBytes as resolveChannelMediaMaxBytes2,
-  resolveControlCommandGate,
-  resolveMentionGatingWithBypass
-} from "openclaw/plugin-sdk";
+
+// src/sdk-runtime-compat.ts
+var HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
+var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
+var MAX_HISTORY_KEYS = 1000;
+var DEFAULT_GROUP_HISTORY_LIMIT = 50;
+function evictOldHistoryKeys(historyMap, maxKeys = MAX_HISTORY_KEYS) {
+  if (historyMap.size <= maxKeys) {
+    return;
+  }
+  const keysToDelete = historyMap.size - maxKeys;
+  const iterator = historyMap.keys();
+  for (let index = 0;index < keysToDelete; index += 1) {
+    const key = iterator.next().value;
+    if (key !== undefined) {
+      historyMap.delete(key);
+    }
+  }
+}
+function buildHistoryContext(params) {
+  const lineBreak = params.lineBreak ?? `
+`;
+  if (!params.historyText.trim()) {
+    return params.currentMessage;
+  }
+  return [
+    HISTORY_CONTEXT_MARKER,
+    params.historyText,
+    "",
+    CURRENT_MESSAGE_MARKER,
+    params.currentMessage
+  ].join(lineBreak);
+}
+function appendHistoryEntry(params) {
+  if (params.limit <= 0) {
+    return [];
+  }
+  const history = params.historyMap.get(params.historyKey) ?? [];
+  history.push(params.entry);
+  while (history.length > params.limit) {
+    history.shift();
+  }
+  if (params.historyMap.has(params.historyKey)) {
+    params.historyMap.delete(params.historyKey);
+  }
+  params.historyMap.set(params.historyKey, history);
+  evictOldHistoryKeys(params.historyMap);
+  return history;
+}
+function buildHistoryContextFromEntries(params) {
+  const lineBreak = params.lineBreak ?? `
+`;
+  const entries = params.excludeLast === false ? params.entries : params.entries.slice(0, -1);
+  if (entries.length === 0) {
+    return params.currentMessage;
+  }
+  return buildHistoryContext({
+    historyText: entries.map(params.formatEntry).join(lineBreak),
+    currentMessage: params.currentMessage,
+    lineBreak
+  });
+}
+function buildPendingHistoryContextFromMap(params) {
+  if (params.limit <= 0) {
+    return params.currentMessage;
+  }
+  const entries = params.historyMap.get(params.historyKey) ?? [];
+  return buildHistoryContextFromEntries({
+    entries,
+    currentMessage: params.currentMessage,
+    formatEntry: params.formatEntry,
+    ...params.lineBreak !== undefined ? { lineBreak: params.lineBreak } : {},
+    excludeLast: false
+  });
+}
+function clearHistoryEntriesIfEnabled(params) {
+  if (params.limit <= 0) {
+    return;
+  }
+  params.historyMap.set(params.historyKey, []);
+}
+function recordPendingHistoryEntryIfEnabled(params) {
+  if (!params.entry || params.limit <= 0) {
+    return [];
+  }
+  return appendHistoryEntry({
+    historyMap: params.historyMap,
+    historyKey: params.historyKey,
+    entry: params.entry,
+    limit: params.limit
+  });
+}
+function createMessageToolButtonsSchemaCompat() {
+  return {
+    type: "array",
+    description: "Button rows for channels that support button-style actions.",
+    items: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["text", "callback_data"],
+        properties: {
+          text: { type: "string" },
+          callback_data: { type: "string" },
+          style: { type: "string", enum: ["danger", "success", "primary"] }
+        }
+      }
+    }
+  };
+}
+function extensionForMimeCompat(mime) {
+  const normalized = mime?.trim().toLowerCase();
+  if (!normalized)
+    return;
+  const directMap = {
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "video/mp4": "mp4",
+    "audio/mpeg": "mp3",
+    "audio/mp4": "m4a",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "application/pdf": "pdf",
+    "text/plain": "txt"
+  };
+  const mapped = directMap[normalized];
+  if (mapped)
+    return mapped;
+  const [, subtype] = normalized.split("/", 2);
+  return subtype?.split("+", 1)[0] || undefined;
+}
+function createInlineTypingCallbacks(params) {
+  const keepaliveIntervalMs = params.keepaliveIntervalMs ?? 3000;
+  const maxConsecutiveFailures = Math.max(1, params.maxConsecutiveFailures ?? 2);
+  const maxDurationMs = params.maxDurationMs ?? 60000;
+  let closed = false;
+  let stopSent = false;
+  let consecutiveFailures = 0;
+  let keepaliveTimer;
+  let ttlTimer;
+  const clearTimers = () => {
+    if (keepaliveTimer) {
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = undefined;
+    }
+    if (ttlTimer) {
+      clearTimeout(ttlTimer);
+      ttlTimer = undefined;
+    }
+  };
+  const fireStop = () => {
+    closed = true;
+    clearTimers();
+    if (!params.stop || stopSent) {
+      return;
+    }
+    stopSent = true;
+    params.stop().catch((err) => (params.onStopError ?? params.onStartError)(err));
+  };
+  const fireStart = async () => {
+    if (closed)
+      return;
+    try {
+      await params.start();
+      consecutiveFailures = 0;
+    } catch (err) {
+      consecutiveFailures += 1;
+      params.onStartError(err);
+      if (consecutiveFailures >= maxConsecutiveFailures) {
+        fireStop();
+      }
+    }
+  };
+  return {
+    onReplyStart: async () => {
+      if (closed)
+        return;
+      stopSent = false;
+      consecutiveFailures = 0;
+      clearTimers();
+      await fireStart();
+      if (closed)
+        return;
+      keepaliveTimer = setInterval(() => {
+        fireStart();
+      }, keepaliveIntervalMs);
+      if (maxDurationMs > 0) {
+        ttlTimer = setTimeout(() => {
+          fireStop();
+        }, maxDurationMs);
+      }
+    },
+    onIdle: fireStop,
+    onCleanup: fireStop
+  };
+}
+async function createChannelReplyPipelineCompat(params) {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/channel-reply-pipeline");
+    return sdk.createChannelReplyPipeline(params);
+  } catch {
+    return {
+      onModelSelected: () => {},
+      ...params.typingCallbacks ? { typingCallbacks: params.typingCallbacks } : params.typing ? { typingCallbacks: createInlineTypingCallbacks(params.typing) } : {}
+    };
+  }
+}
+async function loadNativeCommandHelpersCompat() {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/command-auth");
+    const listNativeCommandSpecsForConfig = typeof sdk.listNativeCommandSpecsForConfig === "function" ? sdk.listNativeCommandSpecsForConfig : null;
+    const listSkillCommandsForAgents = typeof sdk.listSkillCommandsForAgents === "function" ? sdk.listSkillCommandsForAgents : null;
+    if (!listNativeCommandSpecsForConfig || !listSkillCommandsForAgents) {
+      throw new Error("command-auth helpers unavailable");
+    }
+    return {
+      available: true,
+      listNativeCommandSpecsForConfig,
+      listSkillCommandsForAgents
+    };
+  } catch {
+    return {
+      available: false,
+      listNativeCommandSpecsForConfig: () => [],
+      listSkillCommandsForAgents: () => []
+    };
+  }
+}
+async function loadPluginCommandSpecsCompat(provider) {
+  try {
+    const sdk = await import("openclaw/plugin-sdk/plugin-runtime");
+    if (typeof sdk.getPluginCommandSpecs !== "function") {
+      throw new Error("plugin runtime command helper unavailable");
+    }
+    return {
+      available: true,
+      specs: sdk.getPluginCommandSpecs(provider)
+    };
+  } catch {
+    return {
+      available: false,
+      specs: []
+    };
+  }
+}
+
+// src/inline/message-formatting.ts
+var INLINE_FORMATTING_NOTE = "Inline formatting note: prefer bullet lists over markdown tables. If a table is necessary, render it inside a fenced code block. Do not wrap bare URLs in inline code or backticks. Use plain URLs or markdown links. Use inline code only for actual code, commands, file paths, env vars, or identifiers.";
+var INLINE_SYSTEM_PROMPT_BASE = "Format replies for Inline. Prefer bullet lists over markdown tables. If a table is necessary, render it inside a fenced code block. Do not wrap bare URLs in inline code or backticks. Use plain URLs or markdown links. Use inline code only for actual code, commands, file paths, env vars, or identifiers.";
+function isBareHttpUrl(text) {
+  if (!/^https?:\/\/\S+$/i.test(text))
+    return false;
+  try {
+    const url2 = new URL(text);
+    return url2.protocol === "http:" || url2.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function buildInlineSystemPrompt(extraPrompt) {
+  return [INLINE_SYSTEM_PROMPT_BASE, extraPrompt?.trim() || null].filter((entry) => Boolean(entry)).join(`
+
+`);
+}
+function sanitizeInlineOutgoingText(text) {
+  return text.replace(/`([^`\n]+)`/g, (full, content) => {
+    return isBareHttpUrl(content) ? content : full;
+  });
+}
 
 // src/inline/policy.ts
-import { normalizeAccountId as normalizePluginAccountId } from "openclaw/plugin-sdk";
 function normalizeAccountId2(raw) {
-  return normalizePluginAccountId(raw);
+  return normalizeAccountId(raw);
 }
 function resolveInlineGroups(cfg, accountId) {
   const inline = cfg.channels?.inline;
@@ -32851,19 +34296,12 @@ function getInlineRuntime() {
 
 // src/inline/media.ts
 import path from "node:path";
-import {
-  detectMime,
-  extensionForMime,
-  loadWebMedia,
-  resolveChannelMediaMaxBytes
-} from "openclaw/plugin-sdk";
 var DEFAULT_MEDIA_MAX_MB = 300;
 var SUPPORTED_INLINE_PHOTO_MIME = new Set(["image/jpeg", "image/png", "image/gif"]);
 var SUPPORTED_INLINE_VIDEO_MIME = new Set(["video/mp4"]);
 var DEFAULT_VIDEO_WIDTH = 1280;
 var DEFAULT_VIDEO_HEIGHT = 720;
 var DEFAULT_VIDEO_DURATION = 1;
-var loadWebMediaCompat = loadWebMedia;
 function looksLikeLocalMediaSource(mediaUrl) {
   return !/^https?:\/\//i.test(mediaUrl.trim());
 }
@@ -32906,7 +34344,7 @@ function ensureUploadFileName(params) {
     if (ext)
       return baseName;
   }
-  const inferredExt = params.ext ?? extensionForMime(params.mime) ?? undefined;
+  const inferredExt = params.ext ?? extensionForMimeCompat(params.mime) ?? undefined;
   const fallbackExt = inferredExt ?? (params.uploadType === "photo" ? "jpg" : params.uploadType === "video" ? "mp4" : "bin");
   return `attachment.${fallbackExt}`;
 }
@@ -32984,13 +34422,15 @@ async function uploadInlineMediaFromUrl(params) {
     cfg: params.cfg,
     accountId: params.accountId ?? null
   });
+  const runtimeMedia = getInlineRuntime().media;
+  const loadWebMediaCompat = runtimeMedia.loadWebMedia;
   let loaded;
   let detectedMime;
   let uploadType;
   let fileName;
   try {
     try {
-      loaded = await loadWebMedia(params.mediaUrl, maxBytes);
+      loaded = await runtimeMedia.loadWebMedia(params.mediaUrl, maxBytes);
     } catch (error48) {
       const message = String(error48);
       const deniedLocalPath = /not under an allowed directory/i.test(message);
@@ -33004,13 +34444,13 @@ async function uploadInlineMediaFromUrl(params) {
     if (!loaded) {
       throw new Error("inline media upload: media load returned no data");
     }
-    detectedMime = normalizeMime(loaded.contentType ?? await detectMime({
+    detectedMime = normalizeMime(loaded.contentType ?? await runtimeMedia.detectMime({
       buffer: loaded.buffer,
       ...loaded.fileName ? { filePath: loaded.fileName } : {}
     }));
     const normalizedExt = normalizeExt(loaded.fileName);
     uploadType = chooseUploadType({
-      kind: loaded.kind,
+      kind: loaded.kind ?? "unknown",
       ...detectedMime ? { mime: detectedMime } : {},
       ...normalizedExt ? { ext: normalizedExt } : {}
     });
@@ -33354,9 +34794,246 @@ function summarizeInlineMessageContent(message) {
   };
 }
 
+// src/inline/command-menu-compat.ts
+var THINKING_LEVEL_CHOICES = ["off", "minimal", "low", "medium", "high", "xhigh"];
+var COMPAT_COMMANDS = [
+  {
+    key: "tts",
+    nativeName: "tts",
+    args: [
+      {
+        name: "action",
+        description: "TTS action",
+        choices: [
+          { value: "on", label: "On" },
+          { value: "off", label: "Off" },
+          { value: "status", label: "Status" },
+          { value: "provider", label: "Provider" },
+          { value: "limit", label: "Limit" },
+          { value: "summary", label: "Summary" },
+          { value: "audio", label: "Audio" },
+          { value: "help", label: "Help" }
+        ]
+      },
+      { name: "value", description: "Provider, limit, or text" }
+    ],
+    argsMenu: {
+      arg: "action",
+      title: "Choose TTS action:"
+    }
+  },
+  {
+    key: "session",
+    nativeName: "session",
+    args: [
+      { name: "action", description: "idle | max-age", choices: ["idle", "max-age"] },
+      { name: "value", description: "Duration or off" }
+    ],
+    argsMenu: "auto"
+  },
+  {
+    key: "subagents",
+    nativeName: "subagents",
+    args: [
+      {
+        name: "action",
+        description: "list | kill | log | info | send | steer | spawn",
+        choices: ["list", "kill", "log", "info", "send", "steer", "spawn"]
+      },
+      { name: "target", description: "Run id, index, or session key" },
+      { name: "value", description: "Additional input" }
+    ],
+    argsMenu: "auto"
+  },
+  {
+    key: "acp",
+    nativeName: "acp",
+    args: [
+      {
+        name: "action",
+        description: "Action to run",
+        choices: [
+          "spawn",
+          "cancel",
+          "steer",
+          "close",
+          "sessions",
+          "status",
+          "set-mode",
+          "set",
+          "cwd",
+          "permissions",
+          "timeout",
+          "model",
+          "reset-options",
+          "doctor",
+          "install",
+          "help"
+        ]
+      },
+      { name: "value", description: "Action arguments" }
+    ],
+    argsMenu: "auto"
+  },
+  {
+    key: "usage",
+    nativeName: "usage",
+    args: [{ name: "mode", description: "off, tokens, full, or cost", choices: ["off", "tokens", "full", "cost"] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "activation",
+    nativeName: "activation",
+    args: [{ name: "mode", description: "mention or always", choices: ["mention", "always"] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "send",
+    nativeName: "send",
+    args: [{ name: "mode", description: "on, off, or inherit", choices: ["on", "off", "inherit"] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "think",
+    nativeName: "think",
+    args: [{ name: "level", description: "thinking level", choices: [...THINKING_LEVEL_CHOICES] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "verbose",
+    nativeName: "verbose",
+    args: [{ name: "mode", description: "on or off", choices: ["on", "off"] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "fast",
+    nativeName: "fast",
+    args: [{ name: "mode", description: "status, on, or off", choices: ["status", "on", "off"] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "reasoning",
+    nativeName: "reasoning",
+    args: [{ name: "mode", description: "on, off, or stream", choices: ["on", "off", "stream"] }],
+    argsMenu: "auto"
+  },
+  {
+    key: "elevated",
+    nativeName: "elevated",
+    args: [{ name: "mode", description: "on, off, ask, or full", choices: ["on", "off", "ask", "full"] }],
+    argsMenu: "auto"
+  }
+];
+function parsePositionalArgs(definitions, raw) {
+  const values = {};
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return values;
+  const tokens = trimmed.split(/\s+/).filter(Boolean);
+  let index = 0;
+  for (const definition of definitions) {
+    if (index >= tokens.length)
+      break;
+    const token = tokens[index];
+    if (!token)
+      break;
+    values[definition.name] = token;
+    index += 1;
+  }
+  return values;
+}
+function parseCommandArgs(command, raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed)
+    return;
+  if (!command.args || command.argsParsing === "none") {
+    return { raw: trimmed };
+  }
+  return {
+    raw: trimmed,
+    values: parsePositionalArgs(command.args, trimmed)
+  };
+}
+function findCommandByNativeName(name) {
+  const normalized = name.trim().toLowerCase();
+  return COMPAT_COMMANDS.find((command) => command.nativeName.toLowerCase() === normalized);
+}
+function resolveCommandArgChoices(arg) {
+  const raw = arg.choices ?? [];
+  return raw.map((choice) => typeof choice === "string" ? { value: choice, label: choice } : choice);
+}
+function resolveCommandArgMenu(params) {
+  const { command, args } = params;
+  if (!command.args || !command.argsMenu)
+    return null;
+  if (command.argsParsing === "none")
+    return null;
+  const argName = command.argsMenu === "auto" ? command.args.find((arg2) => resolveCommandArgChoices(arg2).length > 0)?.name : command.argsMenu.arg;
+  if (!argName)
+    return null;
+  if (args?.values && args.values[argName] != null)
+    return null;
+  if (args?.raw && !args.values)
+    return null;
+  const arg = command.args.find((entry) => entry.name === argName);
+  if (!arg)
+    return null;
+  const choices = resolveCommandArgChoices(arg);
+  if (choices.length === 0)
+    return null;
+  const title = command.argsMenu !== "auto" ? command.argsMenu.title : undefined;
+  return {
+    arg,
+    choices,
+    ...title ? { title } : {}
+  };
+}
+function buildCommandTextFromArgs(command, args) {
+  const values = args?.values ?? {};
+  const argDefs = command.args ?? [];
+  const renderedArgs = [];
+  for (const argDef of argDefs) {
+    const value = values[argDef.name];
+    if (value == null)
+      continue;
+    const normalized = typeof value === "string" ? value.trim() : String(value);
+    if (!normalized)
+      continue;
+    renderedArgs.push(normalized);
+  }
+  return renderedArgs.length > 0 ? `/${command.nativeName} ${renderedArgs.join(" ")}` : `/${command.nativeName}`;
+}
+function resolveInlineCompatNativeCommandMenu(commandBody) {
+  const normalized = commandBody.trim();
+  const match = normalized.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
+  if (!match?.[1])
+    return null;
+  const command = findCommandByNativeName(match[1]);
+  if (!command)
+    return null;
+  const args = parseCommandArgs(command, match[2]);
+  const menu = resolveCommandArgMenu({
+    command,
+    ...args ? { args } : {}
+  });
+  if (!menu)
+    return null;
+  const title = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${command.nativeName}.`;
+  const rows = [];
+  for (let index = 0;index < menu.choices.length; index += 2) {
+    const slice = menu.choices.slice(index, index + 2);
+    rows.push(slice.map((choice) => ({
+      text: choice.label,
+      callback_data: buildCommandTextFromArgs(command, {
+        values: { [menu.arg.name]: choice.value }
+      })
+    })));
+  }
+  return { title, buttons: rows };
+}
+
 // src/inline/monitor.ts
 var CHANNEL_ID = "inline";
-var DEFAULT_GROUP_HISTORY_LIMIT = 12;
 var DEFAULT_DM_HISTORY_LIMIT = 6;
 var HISTORY_LINE_MAX_CHARS = 280;
 var BOT_MESSAGE_CACHE_LIMIT = 500;
@@ -33364,7 +35041,6 @@ var REACTION_TARGET_LOOKUP_LIMIT = 8;
 var REPLY_TARGET_LOOKUP_LIMIT = 8;
 var ATTACHMENT_CONTEXT_LIMIT = 6;
 var DEFAULT_INLINE_MEDIA_MAX_BYTES = 300 * 1024 * 1024;
-var INLINE_FORMATTING_NOTE = "Inline formatting note: prefer bullet lists over markdown tables. If a table is necessary, render it inside a fenced code block.";
 var GET_MESSAGES_METHOD = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
 function normalizeAllowEntry(raw) {
   return raw.trim().replace(/^inline:/i, "").replace(/^user:/i, "");
@@ -33407,10 +35083,156 @@ function normalizeInlineCommandBody(raw, botUsername) {
   }
   return normalized;
 }
+function callbackDataToBase64(data) {
+  return Buffer.from(data).toString("base64");
+}
+function callbackDataToUtf8(data) {
+  try {
+    const decoded = new TextDecoder("utf-8", { fatal: true }).decode(data).trim();
+    return decoded || undefined;
+  } catch {
+    return;
+  }
+}
+var INLINE_ACTION_MAX_ROWS = 8;
+var INLINE_ACTION_MAX_PER_ROW = 8;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function mapInlineModelPickerCallbackToCommand(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return;
+  if (trimmed === "mdl_prov" || trimmed === "mdl_back") {
+    return "/models";
+  }
+  const listMatch = trimmed.match(/^mdl_list_([a-z0-9_-]+)_(\d+)$/i);
+  if (listMatch?.[1] && listMatch[2]) {
+    const provider = listMatch[1].trim();
+    const page = Number.parseInt(listMatch[2], 10);
+    if (provider && Number.isFinite(page) && page > 0) {
+      return `/models ${provider} ${String(page)}`;
+    }
+  }
+  const standardSelectionMatch = trimmed.match(/^mdl_sel_(.+)$/);
+  if (standardSelectionMatch?.[1]?.trim()) {
+    return `/model ${standardSelectionMatch[1].trim()}`;
+  }
+  const compactSelectionMatch = trimmed.match(/^mdl_sel\/(.+)$/);
+  if (compactSelectionMatch?.[1]?.trim()) {
+    return `/model ${compactSelectionMatch[1].trim()}`;
+  }
+  return;
+}
+function normalizeInlineActionCallbackData(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return "";
+  return mapInlineModelPickerCallbackToCommand(trimmed) ?? trimmed;
+}
+function normalizeReplyMarkupButtonsWith(raw, options) {
+  if (!Array.isArray(raw))
+    return [];
+  const rows = [];
+  for (const candidateRow of raw) {
+    if (!Array.isArray(candidateRow))
+      continue;
+    const row = [];
+    for (const candidateButton of candidateRow) {
+      if (!isRecord3(candidateButton))
+        continue;
+      const text = typeof candidateButton.text === "string" ? candidateButton.text.trim() : "";
+      const callbackDataRaw = typeof candidateButton.callback_data === "string" ? candidateButton.callback_data.trim() : "";
+      const callbackData = options?.mapCallbackData ? options.mapCallbackData(callbackDataRaw) : callbackDataRaw;
+      if (!text || !callbackData)
+        continue;
+      row.push({ text, callback_data: callbackData });
+      if (row.length >= INLINE_ACTION_MAX_PER_ROW)
+        break;
+    }
+    if (row.length === 0)
+      continue;
+    rows.push(row);
+    if (rows.length >= INLINE_ACTION_MAX_ROWS)
+      break;
+  }
+  return rows;
+}
+function resolveInlineReplyActions(payload) {
+  const channelData = isRecord3(payload.channelData) ? payload.channelData : undefined;
+  const inlineData = channelData && isRecord3(channelData.inline) ? channelData.inline : undefined;
+  const telegramData = channelData && isRecord3(channelData.telegram) ? channelData.telegram : undefined;
+  let rawButtons = undefined;
+  let hasExplicitButtons = false;
+  let mapCallbackData;
+  if (inlineData && Object.prototype.hasOwnProperty.call(inlineData, "buttons")) {
+    rawButtons = inlineData.buttons;
+    hasExplicitButtons = true;
+  } else if (telegramData && Object.prototype.hasOwnProperty.call(telegramData, "buttons")) {
+    rawButtons = telegramData.buttons;
+    hasExplicitButtons = true;
+    mapCallbackData = normalizeInlineActionCallbackData;
+  } else if (Object.prototype.hasOwnProperty.call(payload, "buttons")) {
+    rawButtons = payload.buttons;
+    hasExplicitButtons = true;
+  }
+  if (!hasExplicitButtons)
+    return;
+  const rows = normalizeReplyMarkupButtonsWith(rawButtons, {
+    ...mapCallbackData ? { mapCallbackData } : {}
+  });
+  return {
+    rows: rows.map((row, rowIndex) => ({
+      actions: row.map((button, buttonIndex) => ({
+        actionId: `btn_${rowIndex + 1}_${buttonIndex + 1}`,
+        text: button.text,
+        action: {
+          oneofKind: "callback",
+          callback: {
+            data: new TextEncoder().encode(button.callback_data)
+          }
+        }
+      }))
+    }))
+  };
+}
+async function answerInlineMessageAction(client, interactionId) {
+  const withAnswer = client;
+  if (typeof withAnswer.answerMessageAction === "function") {
+    await withAnswer.answerMessageAction({ interactionId });
+    return;
+  }
+  const answerMethod = Method["ANSWER_MESSAGE_ACTION"];
+  if (typeof answerMethod === "number" && typeof withAnswer.invokeUncheckedRaw === "function") {
+    await withAnswer.invokeUncheckedRaw(answerMethod, {
+      oneofKind: "answerMessageAction",
+      answerMessageAction: { interactionId }
+    });
+  }
+}
+function resolveCallbackCommandBodyFromActionData(params) {
+  const decoded = callbackDataToUtf8(params.data);
+  if (!decoded)
+    return;
+  const normalized = normalizeInlineActionCallbackData(decoded);
+  if (!normalized.startsWith("/"))
+    return;
+  return normalizeInlineCommandBody(normalized, params.botUsername);
+}
+function shouldUseTelegramSurfaceForModelCommands(commandBody) {
+  const normalized = commandBody.trim().toLowerCase();
+  return normalized === "/model" || normalized.startsWith("/model ") || normalized === "/models" || normalized.startsWith("/models ");
+}
 function buildInlineSenderName(params) {
   const name = [params.firstName, params.lastName].filter(Boolean).join(" ").trim();
   return name || undefined;
 }
+function resolveInlineSystemPrompt(params) {
+  const groupPrompt = params.groupId ? params.account.config.groups?.[params.groupId]?.systemPrompt?.trim() : undefined;
+  return [buildInlineSystemPrompt(params.account.config.systemPrompt), groupPrompt].filter((entry) => Boolean(entry)).join(`
+
+`);
+}
 function rewriteNumericMentionsToUsernames(text, senderProfilesById) {
   if (!text.includes("@"))
     return text;
@@ -33567,12 +35389,46 @@ function resolveHistorySenderLabel(params) {
 }
 function resolveHistoryLimit(params) {
   if (params.isGroup) {
-    return params.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT;
+    return Math.max(0, params.historyLimit ?? params.cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+  }
+  return Math.max(0, params.dmHistoryLimit ?? params.historyLimit ?? DEFAULT_DM_HISTORY_LIMIT);
+}
+function historyEntryDedupeKey(entry) {
+  if (entry.messageId)
+    return `id:${entry.messageId}`;
+  return `ts:${entry.timestamp ?? "unknown"}:${entry.sender}:${entry.body}`;
+}
+function mergeInboundHistoryEntries(params) {
+  if (params.limit <= 0)
+    return [];
+  const deduped = [];
+  const seen = new Set;
+  for (const entry of [...params.historyContextEntries, ...params.pendingEntries]) {
+    const key = historyEntryDedupeKey(entry);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    deduped.push(entry);
   }
-  return params.dmHistoryLimit ?? params.historyLimit ?? DEFAULT_DM_HISTORY_LIMIT;
+  return deduped.slice(-params.limit).map((entry) => ({
+    sender: entry.sender,
+    body: entry.body,
+    ...entry.timestamp != null ? { timestamp: entry.timestamp } : {}
+  }));
+}
+function buildInlineBodyForAgent(params) {
+  return [
+    params.rawBody,
+    params.currentAttachmentText && params.currentAttachmentText !== params.rawBody ? `Current media/attachments:
+${params.currentAttachmentText}` : null,
+    params.currentEntityText ? `Current message entities:
+${params.currentEntityText}` : null
+  ].filter(Boolean).join(`
+
+`) || params.rawBody;
 }
 function resolveInlineMediaMaxBytes(params) {
-  return resolveChannelMediaMaxBytes2({
+  return resolveChannelMediaMaxBytes({
     cfg: params.cfg,
     accountId: params.account.accountId,
     resolveChannelLimitMb: ({ accountId }) => {
@@ -33663,7 +35519,7 @@ async function resolveInlineInboundMedia(params) {
   }
   return out;
 }
-async function buildHistoryContext(params) {
+async function buildHistoryContext2(params) {
   const cachedReplyToBot = params.replyToMsgId != null && hasBotMessageId(params.botMessageIdsByChat, params.chatId, params.replyToMsgId);
   let repliedToBot = cachedReplyToBot;
   let replyToSenderId = null;
@@ -33671,6 +35527,7 @@ async function buildHistoryContext(params) {
   const lines = [];
   const attachmentLines = [];
   const entityLines = [];
+  const inboundHistory = [];
   if (params.historyLimit > 0) {
     const messages = await loadChatHistoryMessages({
       client: params.client,
@@ -33707,6 +35564,12 @@ async function buildHistoryContext(params) {
           meId: params.meId,
           senderProfilesById: params.senderProfilesById
         });
+        inboundHistory.push({
+          sender: label,
+          body: text,
+          ...item.date != null ? { timestamp: Number(item.date) * 1000 } : {},
+          messageId: String(item.id)
+        });
         const replySuffix = item.replyToMsgId != null ? ` ->${String(item.replyToMsgId)}` : "";
         lines.push(`#${String(item.id)}${replySuffix} ${label}: ${text}`);
         const attachmentText = normalizeHistoryText(content.attachmentText);
@@ -33743,6 +35606,7 @@ async function buildHistoryContext(params) {
 `) : null,
       entityText: entityLines.length ? entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 `) : null,
+      inboundHistory,
       repliedToBot,
       replyToSenderId
     };
@@ -33757,6 +35621,7 @@ ${attachmentLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
     entityText: entityLines.length ? `Recent message entities:
 ${entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 `)}` : null,
+    inboundHistory,
     repliedToBot,
     replyToSenderId
   };
@@ -33843,13 +35708,20 @@ async function monitorInlineProvider(params) {
       for await (const event of client.events()) {
         if (abortSignal.aborted)
           break;
+        const rawEvent = event;
         let msg;
         let rawBody = "";
         let currentAttachmentText = null;
         let currentEntityText = null;
         let reactionEvent = null;
+        let inboundChatId = null;
+        let callbackActionEvent = null;
         if (event.kind === "message.new") {
-          msg = event.message;
+          inboundChatId = event.chatId;
+          msg = {
+            ...event.message,
+            chatId: event.chatId
+          };
           const content = summarizeInlineMessageContent(msg);
           rawBody = buildInlineInboundBodyText(content);
           currentAttachmentText = content.attachmentText || null;
@@ -33859,6 +35731,7 @@ async function monitorInlineProvider(params) {
           if (msg.out || msg.fromId === meId)
             continue;
         } else if (event.kind === "reaction.add") {
+          inboundChatId = event.chatId;
           if (event.reaction.userId === meId)
             continue;
           const onBotMessage = await isReactionTargetBotMessage({
@@ -33889,6 +35762,7 @@ async function monitorInlineProvider(params) {
             replyToMsgId: event.reaction.messageId
           };
         } else if (event.kind === "reaction.delete") {
+          inboundChatId = event.chatId;
           if (event.userId === meId)
             continue;
           const onBotMessage = await isReactionTargetBotMessage({
@@ -33918,10 +35792,42 @@ async function monitorInlineProvider(params) {
             mentioned: false,
             replyToMsgId: event.messageId
           };
+        } else if (rawEvent["kind"] === "message.action.invoke") {
+          const actorUserId = rawEvent["actorUserId"];
+          const interactionId = rawEvent["interactionId"];
+          const actionId = rawEvent["actionId"];
+          const targetMessageId = rawEvent["messageId"];
+          const data = rawEvent["data"];
+          const eventChatId = rawEvent["chatId"];
+          const eventDate = rawEvent["date"];
+          if (!actorUserId || !interactionId || !actionId || !targetMessageId || !eventChatId || !eventDate || !data) {
+            continue;
+          }
+          inboundChatId = eventChatId;
+          if (actorUserId === meId)
+            continue;
+          callbackActionEvent = {
+            interactionId,
+            actionId,
+            targetMessageId,
+            data
+          };
+          msg = {
+            id: targetMessageId,
+            chatId: eventChatId,
+            date: eventDate,
+            fromId: actorUserId,
+            message: "",
+            out: false,
+            mentioned: false,
+            replyToMsgId: targetMessageId
+          };
         } else {
           continue;
         }
-        const chatId = event.chatId;
+        if (!inboundChatId)
+          continue;
+        const chatId = inboundChatId;
         statusSink?.({ lastInboundAt: Date.now() });
         let chatInfo;
         try {
@@ -33945,19 +35851,49 @@ async function monitorInlineProvider(params) {
           } else {
             rawBody = `${actor} removed ${emoji3} from your message #${messageId}`;
           }
+        } else if (callbackActionEvent) {
+          const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
+          const payload = {
+            type: "inline_message_action_callback",
+            interaction_id: String(callbackActionEvent.interactionId),
+            actor_user_id: senderId,
+            chat_id: String(chatId),
+            message_id: String(callbackActionEvent.targetMessageId),
+            action_id: callbackActionEvent.actionId,
+            data_base64: callbackDataToBase64(callbackActionEvent.data),
+            data_utf8: callbackDataToUtf8(callbackActionEvent.data) ?? null
+          };
+          rawBody = `${actor} pressed a button on message #${String(callbackActionEvent.targetMessageId)}
+${JSON.stringify(payload)}`;
         }
         const dmPolicy = account.config.dmPolicy ?? "pairing";
         const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
         const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
         const configAllowFrom = normalizeAllowlist(account.config.allowFrom);
         const configGroupAllowFrom = normalizeAllowlist(account.config.groupAllowFrom);
-        const storeAllowFrom = await core3.channel.pairing.readAllowFromStore(CHANNEL_ID).catch(() => []);
+        const storeAllowFrom = await core3.channel.pairing.readAllowFromStore({
+          channel: CHANNEL_ID,
+          accountId: account.accountId
+        }).catch(() => []);
         const storeAllowList = normalizeAllowlist(storeAllowFrom);
         const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
         const effectiveGroupAllowFrom = [
           ...configGroupAllowFrom.length > 0 ? configGroupAllowFrom : configAllowFrom,
           ...storeAllowList
         ].filter(Boolean);
+        const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
+          data: callbackActionEvent.data,
+          ...botUsername ? { botUsername } : {}
+        }) : undefined;
+        let callbackActionAnswered = false;
+        const answerCallbackIfNeeded = async () => {
+          if (!callbackActionEvent || callbackActionAnswered)
+            return;
+          await answerInlineMessageAction(client, callbackActionEvent.interactionId);
+          callbackActionAnswered = true;
+        };
+        const shouldEditCallbackTargetInPlace = false;
+        const normalizedCommandBody = callbackCommandBody ?? normalizeInlineCommandBody(rawBody, botUsername);
         const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
           cfg,
           surface: CHANNEL_ID
@@ -33965,7 +35901,7 @@ async function monitorInlineProvider(params) {
         const useAccessGroups = cfg.commands?.useAccessGroups !== false;
         const allowForCommands = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
         const senderAllowedForCommands = allowlistMatch({ allowFrom: allowForCommands, senderId });
-        const hasControlCommand = core3.channel.text.hasControlCommand(rawBody, cfg, botUsername ? { botUsername } : undefined);
+        const hasControlCommand = core3.channel.text.hasControlCommand(callbackCommandBody ?? rawBody, cfg, botUsername ? { botUsername } : undefined);
         const commandGate = resolveControlCommandGate({
           useAccessGroups,
           authorizers: [{ configured: allowForCommands.length > 0, allowed: senderAllowedForCommands }],
@@ -33976,18 +35912,27 @@ async function monitorInlineProvider(params) {
         if (isGroup) {
           if (groupPolicy === "disabled") {
             log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
+            await answerCallbackIfNeeded().catch((error48) => {
+              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+            });
             continue;
           }
           if (groupPolicy === "allowlist") {
             const allowed = allowlistMatch({ allowFrom: effectiveGroupAllowFrom, senderId });
             if (!allowed) {
               log?.info(`[${account.accountId}] inline: drop group sender=${senderId} (groupPolicy=allowlist)`);
+              await answerCallbackIfNeeded().catch((error48) => {
+                runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+              });
               continue;
             }
           }
         } else {
           if (dmPolicy === "disabled") {
             log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=disabled)`);
+            await answerCallbackIfNeeded().catch((error48) => {
+              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+            });
             continue;
           }
           if (dmPolicy !== "open") {
@@ -33997,6 +35942,7 @@ async function monitorInlineProvider(params) {
                 const { code, created } = await core3.channel.pairing.upsertPairingRequest({
                   channel: CHANNEL_ID,
                   id: senderId,
+                  accountId: account.accountId,
                   meta: {},
                   pairingAdapter: { idLabel: "inlineUserId", normalizeAllowEntry }
                 });
@@ -34017,17 +35963,23 @@ async function monitorInlineProvider(params) {
                 }
               }
               log?.info(`[${account.accountId}] inline: drop DM sender=${senderId} (dmPolicy=${dmPolicy})`);
+              await answerCallbackIfNeeded().catch((error48) => {
+                runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+              });
               continue;
             }
           }
         }
-        if (commandGate.shouldBlock) {
+        if (isGroup && commandGate.shouldBlock) {
           logInboundDrop({
             log: (m) => runtime2.log?.(m),
             channel: CHANNEL_ID,
             reason: "control command (unauthorized)",
             target: senderId
           });
+          await answerCallbackIfNeeded().catch((error48) => {
+            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+          });
           continue;
         }
         const route = core3.channel.routing.resolveAgentRoute({
@@ -34047,11 +35999,12 @@ async function monitorInlineProvider(params) {
         const groupHistoryKey = isGroup ? route.sessionKey : null;
         const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
         const historyLimit = resolveHistoryLimit({
+          cfg,
           isGroup,
           historyLimit: account.config.historyLimit,
           dmHistoryLimit: account.config.dmHistoryLimit
         });
-        const historyContext = await buildHistoryContext({
+        const historyContext = await buildHistoryContext2({
           client,
           chatId,
           currentMessageId: msg.id,
@@ -34062,9 +36015,16 @@ async function monitorInlineProvider(params) {
           botMessageIdsByChat
         }).catch((err) => {
           statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
-          return { historyText: null, attachmentText: null, entityText: null, repliedToBot: false, replyToSenderId: null };
+          return {
+            historyText: null,
+            attachmentText: null,
+            entityText: null,
+            inboundHistory: [],
+            repliedToBot: false,
+            replyToSenderId: null
+          };
         });
-        const implicitMention = reactionEvent != null && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && historyContext.repliedToBot;
+        const implicitMention = (reactionEvent != null || callbackActionEvent != null) && isGroup || isGroup && (account.config.replyToBotWithoutMention ?? false) && msg.replyToMsgId != null && historyContext.repliedToBot;
         const requireMention = isGroup ? resolveInlineGroupRequireMention({
           cfg,
           groupId: String(chatId),
@@ -34094,6 +36054,33 @@ async function monitorInlineProvider(params) {
               messageId: String(msg.id)
             } : null
           });
+          await answerCallbackIfNeeded().catch((error48) => {
+            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+          });
+          continue;
+        }
+        const parseMarkdown = account.config.parseMarkdown ?? true;
+        const nativeCommandMenu = resolveInlineCompatNativeCommandMenu(normalizedCommandBody);
+        if (nativeCommandMenu) {
+          const menuActions = resolveInlineReplyActions({
+            channelData: {
+              inline: {
+                buttons: nativeCommandMenu.buttons
+              }
+            }
+          });
+          const sent = await client.sendMessage({
+            chatId,
+            text: nativeCommandMenu.title,
+            ...menuActions ? { actions: menuActions } : {}
+          });
+          if (sent.messageId != null) {
+            rememberBotMessageId(botMessageIdsByChat, chatId, sent.messageId);
+          }
+          statusSink?.({ lastOutboundAt: Date.now() });
+          await answerCallbackIfNeeded().catch((error48) => {
+            runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+          });
           continue;
         }
         const inboundMedia = reactionEvent ? [] : await resolveInlineInboundMedia({
@@ -34144,11 +36131,27 @@ ${currentEntityText}` : null
             })
           });
         }
-        const commandBody = normalizeInlineCommandBody(rawBody, botUsername);
+        const inboundHistory = isGroup && groupHistoryKey ? mergeInboundHistoryEntries({
+          historyContextEntries: historyContext.inboundHistory,
+          pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
+          limit: historyLimit
+        }) : [];
+        const bodyForAgent = buildInlineBodyForAgent({
+          rawBody,
+          currentAttachmentText,
+          currentEntityText
+        });
+        const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
+        const systemPrompt = resolveInlineSystemPrompt({
+          account,
+          ...isGroup ? { groupId: String(chatId) } : {}
+        });
         const ctxPayload = core3.channel.reply.finalizeInboundContext({
           Body: body,
+          BodyForAgent: bodyForAgent,
+          ...isGroup ? { InboundHistory: inboundHistory } : {},
           RawBody: rawBody,
-          CommandBody: commandBody,
+          CommandBody: normalizedCommandBody,
           From: isGroup ? `inline:chat:${String(chatId)}` : `inline:${senderId}`,
           To: `inline:${String(chatId)}`,
           SessionKey: route.sessionKey,
@@ -34160,15 +36163,22 @@ ${currentEntityText}` : null
           ...senderName ? { SenderName: senderName } : {},
           ...senderUsername ? { SenderUsername: senderUsername } : {},
           Provider: CHANNEL_ID,
-          Surface: CHANNEL_ID,
+          Surface: effectiveSurface,
           MessageSid: String(msg.id),
           ...msg.replyToMsgId != null ? { ReplyToId: String(msg.replyToMsgId) } : {},
           ...historyContext.replyToSenderId != null ? { ReplyToSenderId: historyContext.replyToSenderId } : {},
           ...msg.replyToMsgId != null ? { ReplyToWasBot: historyContext.repliedToBot } : {},
+          ...callbackActionEvent ? {
+            MessageActionInteractionId: String(callbackActionEvent.interactionId),
+            MessageActionId: callbackActionEvent.actionId,
+            MessageActionDataBase64: callbackDataToBase64(callbackActionEvent.data),
+            ...callbackDataToUtf8(callbackActionEvent.data) ? { MessageActionDataUtf8: callbackDataToUtf8(callbackActionEvent.data) } : {}
+          } : {},
           ...buildInlineInboundMediaPayload(inboundMedia),
           Timestamp: timestamp || Date.now(),
           WasMentioned: mentionGate.effectiveWasMentioned,
           CommandAuthorized: commandAuthorized,
+          GroupSystemPrompt: systemPrompt,
           OriginatingChannel: CHANNEL_ID,
           OriginatingTo: `inline:${String(chatId)}`
         });
@@ -34186,22 +36196,28 @@ ${currentEntityText}` : null
           } : {},
           onRecordError: (err) => runtime2.error?.(`inline: failed updating session meta: ${String(err)}`)
         });
-        const prefixConfig = typeof createReplyPrefixOptions === "function" ? createReplyPrefixOptions({
+        const replyPipeline = await createChannelReplyPipelineCompat({
           cfg,
           agentId: route.agentId,
           channel: CHANNEL_ID,
-          accountId: account.accountId
-        }) : {};
-        const onModelSelected = typeof prefixConfig.onModelSelected === "function" ? prefixConfig.onModelSelected : undefined;
-        const { onModelSelected: _ignoredOnModelSelected, ...prefixOptions } = prefixConfig;
-        const typingCallbacks = typeof createTypingCallbacks === "function" ? createTypingCallbacks({
-          start: () => client.sendTyping({ chatId, typing: true }),
-          stop: () => client.sendTyping({ chatId, typing: false }),
-          onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
-          onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
-        }) : {};
-        const parseMarkdown = account.config.parseMarkdown ?? true;
-        const streamViaEditMessage = account.config.streamViaEditMessage === true;
+          accountId: account.accountId,
+          typing: {
+            start: () => client.sendTyping({ chatId, typing: true }),
+            stop: () => client.sendTyping({ chatId, typing: false }),
+            onStartError: (err) => runtime2.error?.(`inline typing start failed: ${String(err)}`),
+            onStopError: (err) => runtime2.error?.(`inline typing stop failed: ${String(err)}`)
+          }
+        });
+        const onModelSelected = replyPipeline.onModelSelected;
+        const typingCallbacks = replyPipeline.typingCallbacks;
+        const prefixOptions = {
+          ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
+          ...replyPipeline.enableSlackInteractiveReplies !== undefined ? { enableSlackInteractiveReplies: replyPipeline.enableSlackInteractiveReplies } : {},
+          ...replyPipeline.responsePrefixContextProvider ? {
+            responsePrefixContextProvider: replyPipeline.responsePrefixContextProvider
+          } : {}
+        };
+        const streamViaEditMessage = account.config.streamViaEditMessage === true && !shouldEditCallbackTargetInPlace;
         const defaultReplyToMsgId = isGroup && msg.replyToMsgId != null ? msg.id : undefined;
         const disableBlockStreaming = streamViaEditMessage ? true : typeof account.config.blockStreaming === "boolean" ? !account.config.blockStreaming : undefined;
         const editStreamState = {
@@ -34272,118 +36288,142 @@ ${currentEntityText}` : null
           } : {},
           ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
         };
-        await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-          ctx: ctxPayload,
-          cfg,
-          dispatcherOptions: {
-            ...prefixOptions,
-            ...typingCallbacks,
-            deliver: async (payload) => {
-              const rawText = payload.text ?? "";
-              const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
-              const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
-              let replyToMsgId;
-              if (payload.replyToId != null) {
-                try {
-                  replyToMsgId = BigInt(payload.replyToId);
-                } catch {}
-              }
-              if (replyToMsgId == null && isGroup && msg.replyToMsgId != null) {
-                replyToMsgId = msg.id;
-              }
-              const rememberSent = (messageId) => {
-                if (messageId != null) {
-                  rememberBotMessageId(botMessageIdsByChat, chatId, messageId);
-                }
-              };
-              const sendTextFallback = async (text, includeReplyTo) => {
-                if (!text.trim())
-                  return;
-                const sent = await client.sendMessage({
-                  chatId,
-                  text,
-                  ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
-                  parseMarkdown
-                });
-                rememberSent(sent.messageId);
-              };
-              const updateStreamedMessage = async (text) => {
-                await editStreamState.opChain;
-                if (editStreamState.messageId == null)
-                  return false;
-                const nextText = text.trim();
-                if (!nextText)
-                  return true;
-                if (!editStreamState.failed && nextText === editStreamState.accumulatedText)
-                  return true;
-                const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
-                  oneofKind: "editMessage",
-                  editMessage: {
-                    messageId: editStreamState.messageId,
-                    peerId: buildChatPeer(chatId),
-                    text: nextText,
-                    parseMarkdown
-                  }
-                });
-                if (result.oneofKind !== "editMessage") {
-                  throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
+        try {
+          await core3.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg,
+            dispatcherOptions: {
+              ...prefixOptions,
+              ...typingCallbacks ? { typingCallbacks } : {},
+              deliver: async (payload) => {
+                const rawText = payload.text ?? "";
+                const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
+                const outboundText = rewriteNumericMentionsToUsernames(rawText, senderProfilesById);
+                const outboundActions = resolveInlineReplyActions(payload);
+                let replyToMsgId;
+                if (payload.replyToId != null) {
+                  try {
+                    replyToMsgId = BigInt(payload.replyToId);
+                  } catch {}
                 }
-                editStreamState.accumulatedText = nextText;
-                editStreamState.lastPartialText = nextText;
-                editStreamState.failed = false;
-                return true;
-              };
-              if (mediaList.length === 0) {
-                if (!outboundText.trim())
-                  return;
-                if (streamViaEditMessage && editStreamState.messageId != null) {
-                  editStreamState.finalTextAccumulator += outboundText;
-                  await updateStreamedMessage(editStreamState.finalTextAccumulator);
-                  statusSink?.({ lastOutboundAt: Date.now() });
-                  return;
+                if (replyToMsgId == null && isGroup && msg.replyToMsgId != null) {
+                  replyToMsgId = msg.id;
                 }
-                await sendTextFallback(outboundText, true);
-                statusSink?.({ lastOutboundAt: Date.now() });
-                return;
-              }
-              if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
-                await updateStreamedMessage(outboundText);
-              }
-              for (let index = 0;index < mediaList.length; index++) {
-                const mediaUrl = mediaList[index];
-                if (!mediaUrl?.trim())
-                  continue;
-                const isFirst = index === 0;
-                const caption = isFirst && !(streamViaEditMessage && editStreamState.messageId != null) ? outboundText : "";
-                try {
-                  const media = await uploadInlineMediaFromUrl({
-                    client,
-                    cfg,
-                    accountId: account.accountId,
-                    mediaUrl
-                  });
+                const rememberSent = (messageId) => {
+                  if (messageId != null) {
+                    rememberBotMessageId(botMessageIdsByChat, chatId, messageId);
+                  }
+                };
+                const sendTextFallback = async (text, includeReplyTo, includeActions) => {
+                  if (!text.trim())
+                    return;
                   const sent = await client.sendMessage({
                     chatId,
-                    ...caption ? { text: caption } : {},
-                    media,
-                    ...isFirst && replyToMsgId != null ? { replyToMsgId } : {},
-                    ...caption ? { parseMarkdown } : {}
+                    text,
+                    ...includeReplyTo && replyToMsgId != null ? { replyToMsgId } : {},
+                    ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
+                    parseMarkdown
                   });
                   rememberSent(sent.messageId);
-                } catch (error48) {
-                  runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
-                  const fallbackText = caption ? `${caption}
+                };
+                const updateStreamedMessage = async (text, actions) => {
+                  await editStreamState.opChain;
+                  if (editStreamState.messageId == null)
+                    return false;
+                  const nextText = text.trim();
+                  const textForEdit = nextText || editStreamState.accumulatedText;
+                  if (!textForEdit)
+                    return true;
+                  const shouldSkipTextUpdate = !editStreamState.failed && textForEdit === editStreamState.accumulatedText;
+                  if (shouldSkipTextUpdate && actions === undefined)
+                    return true;
+                  const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
+                    oneofKind: "editMessage",
+                    editMessage: {
+                      messageId: editStreamState.messageId,
+                      peerId: buildChatPeer(chatId),
+                      text: textForEdit,
+                      parseMarkdown,
+                      ...actions !== undefined ? { actions } : {}
+                    }
+                  });
+                  if (result.oneofKind !== "editMessage") {
+                    throw new Error(`inline edit stream: expected editMessage result, got ${String(result.oneofKind)}`);
+                  }
+                  if (!shouldSkipTextUpdate) {
+                    editStreamState.accumulatedText = textForEdit;
+                    editStreamState.lastPartialText = textForEdit;
+                  }
+                  editStreamState.failed = false;
+                  return true;
+                };
+                if (mediaList.length === 0) {
+                  if (streamViaEditMessage && editStreamState.messageId != null) {
+                    if (outboundText.trim()) {
+                      editStreamState.finalTextAccumulator += outboundText;
+                    }
+                    if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
+                      return;
+                    }
+                    await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
+                    statusSink?.({ lastOutboundAt: Date.now() });
+                    return;
+                  }
+                  if (!outboundText.trim())
+                    return;
+                  await sendTextFallback(outboundText, true, true);
+                  statusSink?.({ lastOutboundAt: Date.now() });
+                  return;
+                }
+                if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
+                  await updateStreamedMessage(outboundText, outboundActions);
+                }
+                for (let index = 0;index < mediaList.length; index++) {
+                  const mediaUrl = mediaList[index];
+                  if (!mediaUrl?.trim())
+                    continue;
+                  const isFirst = index === 0;
+                  const shouldAttachActionsToMedia = isFirst && (!(streamViaEditMessage && editStreamState.messageId != null) || !outboundText.trim());
+                  const caption = isFirst && !(streamViaEditMessage && editStreamState.messageId != null) ? outboundText : "";
+                  try {
+                    const media = await uploadInlineMediaFromUrl({
+                      client,
+                      cfg,
+                      accountId: account.accountId,
+                      mediaUrl
+                    });
+                    const sent = await client.sendMessage({
+                      chatId,
+                      ...caption ? { text: caption } : {},
+                      media,
+                      ...isFirst && replyToMsgId != null ? { replyToMsgId } : {},
+                      ...shouldAttachActionsToMedia && outboundActions !== undefined ? { actions: outboundActions } : {},
+                      ...caption ? { parseMarkdown } : {}
+                    });
+                    rememberSent(sent.messageId);
+                  } catch (error48) {
+                    runtime2.error?.(`inline media upload failed; falling back to url text (${String(error48)})`);
+                    const fallbackText = caption ? `${caption}
 
 Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
-                  await sendTextFallback(fallbackText, isFirst);
+                    await sendTextFallback(fallbackText, isFirst, isFirst);
+                  }
                 }
-              }
-              statusSink?.({ lastOutboundAt: Date.now() });
+                statusSink?.({ lastOutboundAt: Date.now() });
+              },
+              onError: (err, info) => runtime2.error?.(`inline ${info.kind} reply failed: ${String(err)}`)
             },
-            onError: (err, info) => runtime2.error?.(`inline ${info.kind} reply failed: ${String(err)}`)
-          },
-          replyOptions
-        });
+            replyOptions
+          });
+        } finally {
+          if (callbackActionEvent && !callbackActionAnswered) {
+            try {
+              await answerCallbackIfNeeded();
+            } catch (error48) {
+              runtime2.error?.(`inline callback answer failed: ${String(error48)}`);
+            }
+          }
+        }
         if (isGroup && groupHistoryKey) {
           clearHistoryEntriesIfEnabled({
             historyMap: groupPendingHistories,
@@ -34415,15 +36455,6 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
   return { stop, done: loop.catch(() => {}) };
 }
 
-// src/inline/actions.ts
-import {
-  createActionGate,
-  jsonResult,
-  readReactionParams,
-  readNumberParam,
-  readStringParam
-} from "openclaw/plugin-sdk";
-
 // src/inline/space-members.ts
 function buildInlineUserDisplayName(user) {
   const explicit = [user.firstName?.trim(), user.lastName?.trim()].filter(Boolean).join(" ");
@@ -34519,6 +36550,77 @@ for (const group of ACTION_GROUPS) {
 }
 var SUPPORTED_ACTIONS = Array.from(ACTION_TO_GATE_KEY.keys());
 var GET_MESSAGES_METHOD2 = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : null;
+var INLINE_ACTION_MAX_ROWS2 = 8;
+var INLINE_ACTION_MAX_PER_ROW2 = 8;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function normalizeReplyMarkupButtons(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const rows = [];
+  for (const candidateRow of raw) {
+    if (!Array.isArray(candidateRow))
+      continue;
+    const row = [];
+    for (const candidateButton of candidateRow) {
+      if (!isRecord4(candidateButton))
+        continue;
+      const text = typeof candidateButton.text === "string" ? candidateButton.text.trim() : "";
+      const callbackData = typeof candidateButton.callback_data === "string" ? candidateButton.callback_data.trim() : "";
+      if (!text || !callbackData)
+        continue;
+      row.push({ text, callback_data: callbackData });
+      if (row.length >= INLINE_ACTION_MAX_PER_ROW2)
+        break;
+    }
+    if (row.length === 0)
+      continue;
+    rows.push(row);
+    if (rows.length >= INLINE_ACTION_MAX_ROWS2)
+      break;
+  }
+  return rows;
+}
+function resolveInlineMessageActionsParam(params) {
+  if (!Object.prototype.hasOwnProperty.call(params, "buttons")) {
+    return;
+  }
+  let rawButtons = params.buttons;
+  if (typeof rawButtons === "string") {
+    const trimmed = rawButtons.trim();
+    if (!trimmed) {
+      rawButtons = [];
+    } else {
+      try {
+        rawButtons = JSON.parse(trimmed);
+      } catch {
+        throw new Error("inline action: buttons must be valid JSON");
+      }
+    }
+  }
+  if (rawButtons == null) {
+    rawButtons = [];
+  }
+  if (!Array.isArray(rawButtons)) {
+    throw new Error("inline action: buttons must be an array of button rows");
+  }
+  const rows = normalizeReplyMarkupButtons(rawButtons);
+  return {
+    rows: rows.map((row, rowIndex) => ({
+      actions: row.map((button, buttonIndex) => ({
+        actionId: `btn_${rowIndex + 1}_${buttonIndex + 1}`,
+        text: button.text,
+        action: {
+          oneofKind: "callback",
+          callback: {
+            data: new TextEncoder().encode(button.callback_data)
+          }
+        }
+      }))
+    }))
+  };
+}
 function normalizeChatId(raw) {
   const normalized = normalizeInlineTarget(raw) ?? raw.trim();
   if (!/^[0-9]+$/.test(normalized)) {
@@ -34984,6 +37086,50 @@ function listAllActions() {
   }
   return Array.from(out);
 }
+function listEnabledInlineActions(cfg) {
+  const account = resolveInlineAccount({ cfg, accountId: null });
+  if (!account.enabled || !account.configured)
+    return [];
+  const gate = createActionGate(account.config.actions ?? {});
+  const actions = new Set;
+  for (const group of ACTION_GROUPS) {
+    if (!gate(group.key, group.defaultEnabled))
+      continue;
+    for (const action of group.actions) {
+      actions.add(action);
+    }
+  }
+  return Array.from(actions);
+}
+function supportsInlineMessageButtons(actions) {
+  return actions.some((action) => action === "send" || action === "reply" || action === "thread-reply" || action === "edit");
+}
+function describeInlineMessageTool({
+  cfg
+}) {
+  const actions = listEnabledInlineActions(cfg);
+  if (actions.length === 0) {
+    return {
+      actions: [],
+      capabilities: [],
+      schema: null
+    };
+  }
+  const buttonsEnabled = supportsInlineMessageButtons(actions);
+  const capabilities = buttonsEnabled ? ["interactive", "buttons"] : [];
+  const schema = buttonsEnabled ? [
+    {
+      properties: {
+        buttons: createMessageToolButtonsSchemaCompat()
+      }
+    }
+  ] : [];
+  return {
+    actions,
+    capabilities,
+    schema
+  };
+}
 function isActionEnabled(params) {
   const key = ACTION_TO_GATE_KEY.get(params.action);
   if (!key)
@@ -34999,21 +37145,10 @@ function isActionEnabled(params) {
   return gate(key, group.defaultEnabled);
 }
 var inlineMessageActions = {
-  listActions: ({ cfg }) => {
-    const account = resolveInlineAccount({ cfg, accountId: null });
-    if (!account.enabled || !account.configured)
-      return [];
-    const gate = createActionGate(account.config.actions ?? {});
-    const actions = new Set;
-    for (const group of ACTION_GROUPS) {
-      if (!gate(group.key, group.defaultEnabled))
-        continue;
-      for (const action of group.actions) {
-        actions.add(action);
-      }
-    }
-    return Array.from(actions);
-  },
+  describeMessageTool: describeInlineMessageTool,
+  listActions: ({ cfg }) => listEnabledInlineActions(cfg),
+  supportsButtons: ({ cfg }) => supportsInlineMessageButtons(listEnabledInlineActions(cfg)),
+  supportsCards: () => false,
   supportsAction: ({ action }) => SUPPORTED_ACTIONS.includes(action),
   extractToolSend: ({ args }) => {
     const action = typeof args.action === "string" ? args.action.trim() : "";
@@ -35042,6 +37177,7 @@ var inlineMessageActions = {
         accountId,
         fn: async (client) => {
           const target = resolveMessageSendTargetFromParams(params);
+          const actions = resolveInlineMessageActionsParam(params);
           const sendTarget = target.chatId != null ? { chatId: target.chatId } : target.userId != null ? { userId: target.userId } : null;
           if (!sendTarget) {
             throw new Error("inline action: missing message target");
@@ -35057,6 +37193,7 @@ var inlineMessageActions = {
             const sent = await client.sendMessage({
               ...sendTarget,
               text: message,
+              ...actions !== undefined ? { actions } : {},
               ...replyToMsgId != null ? { replyToMsgId } : {},
               parseMarkdown
             });
@@ -35082,6 +37219,7 @@ var inlineMessageActions = {
               ...sendTarget,
               ...index === 0 && text ? { text } : {},
               media,
+              ...index === 0 && actions !== undefined ? { actions } : {},
               ...index === 0 && replyToMsgId != null ? { replyToMsgId } : {},
               ...index === 0 && text ? { parseMarkdown } : {}
             });
@@ -35102,6 +37240,7 @@ var inlineMessageActions = {
         cfg,
         accountId,
         fn: async (client) => {
+          const actions = resolveInlineMessageActionsParam(params);
           const replyParams = normalizedAction === "thread-reply" && params.threadId != null && params.to == null && params.chatId == null && params.channelId == null ? { ...params, to: params.threadId } : params;
           const chatId = resolveChatIdFromParams(replyParams);
           const replyToMsgId = parseInlineId(readFlexibleId(replyParams, "messageId") ?? readFlexibleId(replyParams, "replyTo") ?? readFlexibleId(replyParams, "replyToId") ?? readStringParam(replyParams, "messageId") ?? readStringParam(replyParams, "replyTo") ?? readStringParam(replyParams, "replyToId", { required: true }), "messageId");
@@ -35109,6 +37248,7 @@ var inlineMessageActions = {
           const sent = await client.sendMessage({
             chatId,
             text,
+            ...actions !== undefined ? { actions } : {},
             replyToMsgId,
             parseMarkdown
           });
@@ -35254,6 +37394,7 @@ var inlineMessageActions = {
         accountId,
         fn: async (client) => {
           const chatId = resolveChatIdFromParams(params);
+          const actions = resolveInlineMessageActionsParam(params);
           const messageId = parseInlineId(readFlexibleId(params, "messageId") ?? readStringParam(params, "messageId", { required: true }), "messageId");
           const text = readStringParam(params, "message", { required: true, allowEmpty: true });
           const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
@@ -35262,6 +37403,7 @@ var inlineMessageActions = {
               messageId,
               peerId: buildChatPeer2(chatId),
               text,
+              ...actions !== undefined ? { actions } : {},
               parseMarkdown
             }
           });
@@ -36178,7 +38320,7 @@ var inlineChannelPlugin = {
     reply: true,
     groupManagement: true,
     threads: false,
-    nativeCommands: false,
+    nativeCommands: true,
     blockStreaming: true
   },
   streaming: {
@@ -36211,7 +38353,7 @@ var inlineChannelPlugin = {
   },
   security: {
     resolveDmPolicy: ({ cfg, accountId, account }) => {
-      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID2;
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
       const useAccountPath = Boolean(cfg.channels?.inline?.accounts?.[resolvedAccountId]);
       const basePath = useAccountPath ? `channels.inline.accounts.${resolvedAccountId}.` : "channels.inline.";
       return {
@@ -36476,7 +38618,7 @@ var inlineChannelPlugin = {
   },
   status: {
     defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID2,
+      accountId: DEFAULT_ACCOUNT_ID,
       running: false,
       lastStartAt: null,
       lastStopAt: null,
@@ -36561,9 +38703,6 @@ var inlineChannelPlugin = {
 };
 
 // src/inline/message-tools.ts
-import {
-  jsonResult as jsonResult2
-} from "openclaw/plugin-sdk";
 var InlineNudgeToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -36875,7 +39014,7 @@ function createInlineNudgeTool(ctx) {
             }
           });
           const messageId = result.oneofKind === "sendMessage" ? extractFirstMessageId2(result.sendMessage.updates) : null;
-          return jsonResult2({
+          return jsonResult({
             ok: true,
             accountId: resolvedAccountId,
             nudged: true,
@@ -36929,7 +39068,7 @@ function createInlineForwardTool(ctx) {
             }
           });
           const forwardedMessageId = result.oneofKind === "forwardMessages" ? extractFirstMessageId2(result.forwardMessages.updates) : null;
-          return jsonResult2({
+          return jsonResult({
             ok: true,
             accountId: resolvedAccountId,
             from: source.normalized,
@@ -37015,7 +39154,7 @@ function filterSpaceMembers(params) {
     target: `user:${member.userId}`
   }));
 }
-function jsonResult3(payload) {
+function jsonResult2(payload) {
   return {
     content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
     details: payload
@@ -37066,7 +39205,7 @@ function createInlineMembersTool(ctx) {
             userId,
             limit
           });
-          return jsonResult3({
+          return jsonResult2({
             ok: true,
             accountId: resolvedAccountId,
             spaceId: String(spaceId),
@@ -37082,10 +39221,6 @@ function createInlineMembersTool(ctx) {
 }
 
 // src/inline/profile-tool.ts
-import {
-  detectMime as detectMime2,
-  loadWebMedia as loadWebMedia2
-} from "openclaw/plugin-sdk";
 var InlineProfileToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -37112,7 +39247,7 @@ var InlineProfileToolParameters = {
     }
   }
 };
-function jsonResult4(payload) {
+function jsonResult3(payload) {
   return {
     content: [
       {
@@ -37149,9 +39284,24 @@ function readTrimmedString(value) {
 function resolvePhotoSource(args) {
   return readTrimmedString(args.photoPath) ?? readTrimmedString(args.photoUrl);
 }
+function looksLikeLocalMediaSource2(mediaUrl) {
+  return !/^https?:\/\//i.test(mediaUrl.trim());
+}
 async function uploadProfilePhoto(client, rawSource) {
-  const loaded = await loadWebMedia2(rawSource);
-  const contentType = loaded.contentType ?? await detectMime2({
+  const runtimeMedia = getInlineRuntime().media;
+  const loadWebMediaCompat = runtimeMedia.loadWebMedia;
+  let loaded;
+  try {
+    loaded = await runtimeMedia.loadWebMedia(rawSource);
+  } catch (error48) {
+    const message = String(error48);
+    const deniedLocalPath = /not under an allowed directory/i.test(message);
+    if (!deniedLocalPath || !looksLikeLocalMediaSource2(rawSource)) {
+      throw error48;
+    }
+    loaded = await loadWebMediaCompat(rawSource, undefined, { localRoots: "any" });
+  }
+  const contentType = loaded.contentType ?? await runtimeMedia.detectMime({
     buffer: loaded.buffer,
     ...loaded.fileName ? { filePath: loaded.fileName } : {}
   }) ?? undefined;
@@ -37201,7 +39351,7 @@ function createInlineProfileTool(ctx) {
           if (result.oneofKind !== "updateBotProfile") {
             throw new Error(`inline_update_profile: expected updateBotProfile result, got ${String(result.oneofKind)}`);
           }
-          return jsonResult4({
+          return jsonResult3({
             ok: true,
             accountId: resolvedAccountId,
             botUserId: String(me.userId),
@@ -37217,6 +39367,364 @@ function createInlineProfileTool(ctx) {
   };
 }
 
+// src/inline/bot-commands-api.ts
+function normalizeInlineBotBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function normalizeInlineBotCommandName(raw) {
+  return raw.trim().replace(/^\/+/, "");
+}
+async function callInlineBotApi(params) {
+  const baseUrl = normalizeInlineBotBaseUrl(params.baseUrl);
+  const invoke = async (authMode) => {
+    const url2 = authMode === "header" ? `${baseUrl}/bot/${params.methodName}` : `${baseUrl}/bot${encodeURIComponent(params.token)}/${params.methodName}`;
+    const request = {
+      method: params.method,
+      headers: {
+        ...authMode === "header" ? { authorization: `Bearer ${params.token}` } : {},
+        ...params.body !== undefined ? { "content-type": "application/json" } : {}
+      }
+    };
+    if (params.body !== undefined) {
+      request.body = JSON.stringify(params.body);
+    }
+    const response = await fetch(url2, request);
+    const payload = await response.json().catch(() => null);
+    return { response, payload };
+  };
+  const resolve = (result) => {
+    if (!result.response.ok) {
+      const message = result.payload?.description ?? `HTTP ${result.response.status}`;
+      throw new Error(`inline_bot_commands: ${message}`);
+    }
+    if (!result.payload || result.payload.ok !== true) {
+      const message = result.payload?.description ?? "bot api call failed";
+      throw new Error(`inline_bot_commands: ${message}`);
+    }
+    return result.payload.result ?? {};
+  };
+  const shouldRetryWithPathToken = (result) => {
+    if (result.response.status === 401)
+      return true;
+    if (result.payload?.error_code === 401)
+      return true;
+    const description = result.payload?.description?.toLowerCase() ?? "";
+    return description.includes("unauthorized");
+  };
+  const headerResult = await invoke("header");
+  if (shouldRetryWithPathToken(headerResult)) {
+    const pathResult = await invoke("path");
+    return resolve(pathResult);
+  }
+  return resolve(headerResult);
+}
+
+// src/inline/bot-commands-tool.ts
+var BOT_COMMAND_LIMIT = 100;
+var BOT_COMMAND_RE = /^[a-z0-9_]+$/;
+var InlineBotCommandsToolParameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    action: {
+      type: "string",
+      enum: ["get", "set", "delete"],
+      description: "Command operation to run (`get`, `set`, or `delete`)."
+    },
+    commands: {
+      type: "array",
+      description: "Required for `set`. Telegram-style command list to register.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          command: {
+            type: "string",
+            description: "Slash command name without leading slash (`a-z`, `0-9`, `_`, max 32)."
+          },
+          description: {
+            type: "string",
+            description: "Human-friendly command description (max 256)."
+          },
+          sort_order: {
+            type: "number",
+            description: "Optional command ordering hint."
+          }
+        },
+        required: ["command", "description"]
+      }
+    },
+    accountId: {
+      type: "string",
+      description: "Optional Inline account id override."
+    }
+  },
+  required: ["action"]
+};
+function parseSortOrder(raw, fallback) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return Math.trunc(raw);
+  }
+  return fallback;
+}
+function normalizeCommands(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("inline_bot_commands: `commands` must be an array");
+  }
+  if (raw.length > BOT_COMMAND_LIMIT) {
+    throw new Error(`inline_bot_commands: too many commands (${raw.length}); max is ${BOT_COMMAND_LIMIT}`);
+  }
+  const seen = new Set;
+  return raw.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`inline_bot_commands: commands[${index}] must be an object`);
+    }
+    const row = entry;
+    const rawCommand = row.command;
+    const rawDescription = row.description;
+    const rawSortOrder = row.sort_order ?? row.sortOrder;
+    if (typeof rawCommand !== "string" || typeof rawDescription !== "string") {
+      throw new Error(`inline_bot_commands: commands[${index}] requires string command and description`);
+    }
+    const command = normalizeInlineBotCommandName(rawCommand);
+    const description = rawDescription.trim();
+    if (command.length < 1 || command.length > 32 || !BOT_COMMAND_RE.test(command)) {
+      throw new Error(`inline_bot_commands: commands[${index}].command must match /^[a-z0-9_]+$/ and be <= 32 chars`);
+    }
+    if (description.length < 1 || description.length > 256) {
+      throw new Error(`inline_bot_commands: commands[${index}].description must be 1..256 chars`);
+    }
+    if (seen.has(command)) {
+      throw new Error(`inline_bot_commands: duplicate command "${command}"`);
+    }
+    seen.add(command);
+    const sortOrder = parseSortOrder(rawSortOrder, index);
+    return {
+      command,
+      description,
+      ...sortOrder !== index ? { sort_order: sortOrder } : {}
+    };
+  });
+}
+function createInlineBotCommandsTool(ctx) {
+  if (!ctx.config) {
+    return null;
+  }
+  return {
+    name: "inline_bot_commands",
+    label: "Inline Bot Commands",
+    description: "Manage Inline bot slash commands via Bot API (`getMyCommands`, `setMyCommands`, `deleteMyCommands`).",
+    parameters: InlineBotCommandsToolParameters,
+    execute: async (_toolCallId, rawArgs) => {
+      const args = rawArgs ?? {};
+      const action = args.action;
+      if (!action) {
+        throw new Error("inline_bot_commands: `action` is required");
+      }
+      const account = resolveInlineAccount({
+        cfg: ctx.config,
+        accountId: args.accountId ?? ctx.agentAccountId ?? null
+      });
+      if (!account.configured || !account.baseUrl) {
+        throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
+      }
+      const token = await resolveInlineToken(account);
+      if (action === "get") {
+        const result = await callInlineBotApi({
+          baseUrl: account.baseUrl,
+          token,
+          methodName: "getMyCommands",
+          method: "GET"
+        });
+        const commands = Array.isArray(result.commands) ? result.commands : [];
+        return jsonResult({
+          ok: true,
+          action,
+          accountId: account.accountId,
+          count: commands.length,
+          commands
+        });
+      }
+      if (action === "set") {
+        const commands = normalizeCommands(args.commands);
+        await callInlineBotApi({
+          baseUrl: account.baseUrl,
+          token,
+          methodName: "setMyCommands",
+          method: "POST",
+          body: { commands }
+        });
+        return jsonResult({
+          ok: true,
+          action,
+          accountId: account.accountId,
+          count: commands.length,
+          commands
+        });
+      }
+      await callInlineBotApi({
+        baseUrl: account.baseUrl,
+        token,
+        methodName: "deleteMyCommands",
+        method: "POST"
+      });
+      return jsonResult({
+        ok: true,
+        action,
+        accountId: account.accountId
+      });
+    }
+  };
+}
+
+// src/inline/bot-commands-sync.ts
+var INLINE_BASE_NATIVE_COMMANDS = [
+  { command: "help", description: "Show available commands." },
+  { command: "commands", description: "List all slash commands." },
+  { command: "skill", description: "Run a skill by name." },
+  { command: "status", description: "Show current status." },
+  { command: "approve", description: "Approve or deny exec requests." },
+  { command: "context", description: "Explain how context is built and used." },
+  { command: "tts", description: "Control text-to-speech (TTS)." },
+  { command: "whoami", description: "Show your sender id." },
+  { command: "subagents", description: "List/stop/log/info subagent runs for this session." },
+  { command: "usage", description: "Usage footer or cost summary." },
+  { command: "stop", description: "Stop the current run." },
+  { command: "restart", description: "Restart OpenClaw." },
+  { command: "activation", description: "Set group activation mode." },
+  { command: "send", description: "Set send policy." },
+  { command: "reset", description: "Reset the current session." },
+  { command: "new", description: "Start a new session." },
+  { command: "compact", description: "Compact the session context." },
+  { command: "think", description: "Set thinking level." },
+  { command: "verbose", description: "Toggle verbose mode." },
+  { command: "reasoning", description: "Toggle reasoning visibility." },
+  { command: "elevated", description: "Toggle elevated mode." },
+  { command: "exec", description: "Set exec defaults for this session." },
+  { command: "model", description: "Show or set the model." },
+  { command: "models", description: "List model providers or provider models." },
+  { command: "queue", description: "Adjust queue settings." }
+];
+var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
+var INLINE_COMMAND_LIMIT = 100;
+var FALLBACK_NATIVE_COMMAND_HELPERS = {
+  available: false,
+  listNativeCommandSpecsForConfig: () => [],
+  listSkillCommandsForAgents: () => []
+};
+var FALLBACK_PLUGIN_COMMAND_SPECS = {
+  available: false,
+  specs: []
+};
+function normalizeDynamicCommandName(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
+  return withoutSlash.trim();
+}
+function appendUniqueCommand(out, seen, command, description) {
+  const normalized = normalizeDynamicCommandName(command);
+  if (!INLINE_COMMAND_NAME_RE.test(normalized) || seen.has(normalized))
+    return;
+  const trimmedDescription = description.trim();
+  if (!trimmedDescription)
+    return;
+  seen.add(normalized);
+  out.push({ command: normalized, description: trimmedDescription });
+}
+function shouldSyncInlineNativeCommands(cfg) {
+  const inlineNativeSetting = cfg.channels?.inline?.commands?.native;
+  const effective = inlineNativeSetting ?? cfg.commands?.native ?? "auto";
+  return effective !== false;
+}
+function shouldSyncInlineNativeSkills(cfg) {
+  const inlineNativeSkillsSetting = cfg.channels?.inline?.commands?.nativeSkills;
+  const effective = inlineNativeSkillsSetting ?? cfg.commands?.nativeSkills ?? "auto";
+  return effective !== false;
+}
+async function buildInlineNativeCommandsForConfig(params) {
+  const commands = [...INLINE_BASE_NATIVE_COMMANDS];
+  if (params.cfg.commands?.config === true) {
+    commands.push({ command: "config", description: "Show or set config values." });
+  }
+  if (params.cfg.commands?.debug === true) {
+    commands.push({ command: "debug", description: "Set runtime debug overrides." });
+  }
+  const { listNativeCommandSpecsForConfig, listSkillCommandsForAgents } = params.nativeHelpers;
+  const skillCommands = shouldSyncInlineNativeSkills(params.cfg) ? listSkillCommandsForAgents({ cfg: params.cfg }) : [];
+  const nativeSpecs = listNativeCommandSpecsForConfig(params.cfg, { skillCommands });
+  const { specs: pluginSpecs } = params.pluginSpecs;
+  const seen = new Set;
+  const resolved = [];
+  for (const base of commands) {
+    appendUniqueCommand(resolved, seen, base.command, base.description);
+  }
+  for (const spec of nativeSpecs) {
+    appendUniqueCommand(resolved, seen, spec.name, spec.description);
+  }
+  for (const spec of pluginSpecs) {
+    appendUniqueCommand(resolved, seen, spec.name, spec.description);
+  }
+  return resolved;
+}
+async function syncInlineNativeCommands(params) {
+  const accountIds = listInlineAccountIds(params.cfg);
+  const nativeEnabled = shouldSyncInlineNativeCommands(params.cfg);
+  const nativeHelpers = nativeEnabled ? await loadNativeCommandHelpersCompat() : FALLBACK_NATIVE_COMMAND_HELPERS;
+  const pluginSpecs = nativeEnabled ? await loadPluginCommandSpecsCompat("inline") : FALLBACK_PLUGIN_COMMAND_SPECS;
+  const usingSdkSource = nativeHelpers.available || pluginSpecs.available;
+  const allCommands = nativeEnabled ? await buildInlineNativeCommandsForConfig({
+    cfg: params.cfg,
+    nativeHelpers,
+    pluginSpecs
+  }) : [];
+  const commands = allCommands.slice(0, INLINE_COMMAND_LIMIT);
+  if (allCommands.length > INLINE_COMMAND_LIMIT) {
+    params.logger?.warn?.(`[inline] native command sync truncating ${allCommands.length} commands to ${INLINE_COMMAND_LIMIT}`);
+  }
+  params.logger?.info?.(`[inline] native command source: ${usingSdkSource ? "plugin-sdk" : "fallback"}`);
+  let synced = 0;
+  let failed = 0;
+  for (const accountId of accountIds) {
+    const account = resolveInlineAccount({ cfg: params.cfg, accountId });
+    if (!account.enabled || !account.configured || !account.baseUrl) {
+      continue;
+    }
+    let token;
+    try {
+      token = await resolveInlineToken(account);
+    } catch (err) {
+      failed += 1;
+      params.logger?.warn?.(`[inline] native command sync skipped for account "${account.accountId}": ${String(err)}`);
+      continue;
+    }
+    try {
+      await callInlineBotApi({
+        baseUrl: account.baseUrl,
+        token,
+        methodName: "deleteMyCommands",
+        method: "POST"
+      });
+      await callInlineBotApi({
+        baseUrl: account.baseUrl,
+        token,
+        methodName: "setMyCommands",
+        method: "POST",
+        body: { commands }
+      });
+      synced += 1;
+      params.logger?.info?.(`[inline] native commands synced for account "${account.accountId}" (${commands.length} command${commands.length === 1 ? "" : "s"})`);
+    } catch (err) {
+      failed += 1;
+      params.logger?.warn?.(`[inline] native command sync failed for account "${account.accountId}": ${String(err)}`);
+    }
+  }
+  return {
+    attempted: accountIds.length,
+    synced,
+    failed
+  };
+}
+
 // src/index.ts
 var plugin = {
   id: "inline",
@@ -37232,9 +39740,26 @@ var plugin = {
     api2.registerTool((ctx) => createInlineProfileTool(ctx), {
       names: ["inline_update_profile"]
     });
+    api2.registerTool((ctx) => createInlineBotCommandsTool(ctx), {
+      names: ["inline_bot_commands"]
+    });
     api2.registerTool((ctx) => createInlineMessageTools(ctx), {
       names: ["inline_nudge", "inline_forward"]
     });
+    api2.on("message_sending", (event, ctx) => {
+      if (ctx.channelId !== "inline")
+        return;
+      const content = sanitizeInlineOutgoingText(event.content);
+      if (content === event.content)
+        return;
+      return { content };
+    });
+    api2.on("gateway_start", async () => {
+      await syncInlineNativeCommands({
+        cfg: api2.config,
+        logger: api2.logger
+      });
+    });
   }
 };
 var src_default = plugin;
@@ -37242,5 +39767,5 @@ export {
   src_default as default
 };
 
-//# debugId=442A6C0FCB2305FD64756E2164756E21
+//# debugId=7535F56BE481336764756E2164756E21
 //# sourceMappingURL=index.js.map