@inline-openclaw/inline 0.0.19 → 0.0.21

package/dist/index.js

@@ -5711,6 +5711,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,6 +7016,336 @@ class MessageReplies$Type extends import_runtime4.MessageType {
 }
 var MessageReplies = new MessageReplies$Type;
 
+class MessageActions$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageActions", [
+      { no: 1, name: "rows", kind: "message", repeat: 1, T: () => MessageActionRow }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.rows = [];
+    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.rows.push(MessageActionRow.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.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 MessageActions = new MessageActions$Type;
+
+class MessageActionRow$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageActionRow", [
+      { no: 1, name: "actions", kind: "message", repeat: 1, T: () => MessageAction }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.actions = [];
+    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.actions.push(MessageAction.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.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 MessageActionRow = new MessageActionRow$Type;
+
+class MessageAction$Type extends import_runtime4.MessageType {
+  constructor() {
+    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.actionId = "";
+    message.text = "";
+    message.action = { 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.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;
+          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.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 MessageAction = new MessageAction$Type;
+
+class MessageActionCallback$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageActionCallback", [
+      { no: 1, name: "data", kind: "scalar", T: 12 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    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.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.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 MessageActionCallback = new MessageActionCallback$Type;
+
+class MessageActionCopyText$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageActionCopyText", [
+      { no: 1, name: "text", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.text = "";
+    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.text = 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.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 MessageActionCopyText = new MessageActionCopyText$Type;
+
+class MessageActionResponseUi$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageActionResponseUi", [
+      { no: 1, name: "toast", kind: "message", oneof: "kind", T: () => MessageActionToast }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = { 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.kind = {
+            oneofKind: "toast",
+            toast: MessageActionToast.internalBinaryRead(reader, reader.uint32(), options, message.kind.toast)
+          };
+          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.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 MessageActionResponseUi = new MessageActionResponseUi$Type;
+
+class MessageActionToast$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageActionToast", [
+      { no: 1, name: "text", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.text = "";
+    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.text = 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.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 MessageActionToast = new MessageActionToast$Type;
+
 class Message$Type extends import_runtime4.MessageType {
   constructor() {
     super("Message", [
@@ -7035,7 +7368,8 @@ class Message$Type extends import_runtime4.MessageType {
       { 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: 19, name: "replies", kind: "message", T: () => MessageReplies },
+      { no: 20, name: "actions", kind: "message", T: () => MessageActions }
     ]);
   }
   create(value) {
@@ -7114,6 +7448,9 @@ class Message$Type extends import_runtime4.MessageType {
         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")
@@ -7166,6 +7503,8 @@ class Message$Type extends import_runtime4.MessageType {
       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);
@@ -9011,7 +9350,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 +9648,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 +9772,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 +9835,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 +10133,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 +10257,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 +13323,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 +13355,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 +13380,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);
@@ -13323,7 +13722,8 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
       { 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: 9, name: "send_mode", kind: "enum", opt: true, T: () => ["MessageSendMode", MessageSendMode] },
+      { no: 10, name: "actions", kind: "message", T: () => MessageActions }
     ]);
   }
   create(value) {
@@ -13370,6 +13770,9 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
         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")
@@ -13404,23 +13807,168 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
       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;
+          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.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 InvokeMessageActionInput = new InvokeMessageActionInput$Type;
+
+class InvokeMessageActionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("InvokeMessageActionResult", [
+      { no: 1, name: "interaction_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  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;
+        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);
     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 InvokeMessageActionResult = new InvokeMessageActionResult$Type;
 
-class SendMessageResult$Type extends import_runtime4.MessageType {
+class AnswerMessageActionInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SendMessageResult", [
-      { no: 2, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    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.updates = [];
+    message.interactionId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13430,8 +13978,11 @@ class SendMessageResult$Type extends import_runtime4.MessageType {
     while (reader.pos < end) {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
+        case 1:
+          message.interactionId = reader.int64().toBigInt();
+          break;
         case 2:
-          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          message.ui = MessageActionResponseUi.internalBinaryRead(reader, reader.uint32(), options, message.ui);
           break;
         default:
           let u = options.readUnknownField;
@@ -13445,15 +13996,39 @@ class SendMessageResult$Type extends import_runtime4.MessageType {
     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();
+    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 SendMessageResult = new SendMessageResult$Type;
+var AnswerMessageActionInput = new AnswerMessageActionInput$Type;
+
+class AnswerMessageActionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AnswerMessageActionResult", []);
+  }
+  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 AnswerMessageActionResult = new AnswerMessageActionResult$Type;
 
 class ForwardMessagesInput$Type extends import_runtime4.MessageType {
   constructor() {
@@ -13959,6 +14534,142 @@ class InputChatParticipant$Type extends import_runtime4.MessageType {
 }
 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 ReservedChatId = new ReservedChatId$Type;
+
+class ReserveChatIdsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ReserveChatIdsResult", [
+      { no: 1, name: "reservations", kind: "message", repeat: 1, T: () => ReservedChatId }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.reservations = [];
+    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.reservations.push(ReservedChatId.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.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 ReserveChatIdsResult = new ReserveChatIdsResult$Type;
+
 class CreateChatInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("CreateChatInput", [
@@ -13967,7 +14678,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 +14714,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 +14741,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 +15055,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 +15264,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 +15354,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);
@@ -15496,10 +16231,134 @@ class UpdateNewChat$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          break;
+        case 3:
+          message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          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.chat)
+      Chat.internalBinaryWrite(message.chat, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.user)
+      User.internalBinaryWrite(message.user, writer.tag(3, 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 UpdateNewChat = new UpdateNewChat$Type;
+
+class UpdateChatOpen$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateChatOpen", [
+      { no: 1, name: "chat", kind: "message", T: () => Chat },
+      { no: 2, name: "dialog", kind: "message", T: () => Dialog },
+      { no: 3, name: "user", kind: "message", T: () => User }
+    ]);
+  }
+  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.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          break;
+        case 2:
+          message.dialog = Dialog.internalBinaryRead(reader, reader.uint32(), options, message.dialog);
+          break;
+        case 3:
+          message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          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.chat)
+      Chat.internalBinaryWrite(message.chat, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.dialog)
+      Dialog.internalBinaryWrite(message.dialog, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.user)
+      User.internalBinaryWrite(message.user, writer.tag(3, 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 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.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          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;
@@ -15513,28 +16372,36 @@ class UpdateNewChat$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.chat)
-      Chat.internalBinaryWrite(message.chat, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.user)
-      User.internalBinaryWrite(message.user, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    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 UpdateNewChat = new UpdateNewChat$Type;
+var UpdateMessageActionInvoked = new UpdateMessageActionInvoked$Type;
 
-class UpdateChatOpen$Type extends import_runtime4.MessageType {
+class UpdateMessageActionAnswered$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateChatOpen", [
-      { no: 1, name: "chat", kind: "message", T: () => Chat },
-      { no: 2, name: "dialog", kind: "message", T: () => Dialog },
-      { no: 3, name: "user", kind: "message", T: () => User }
+    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;
@@ -15545,13 +16412,10 @@ class UpdateChatOpen$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          message.interactionId = reader.int64().toBigInt();
           break;
         case 2:
-          message.dialog = Dialog.internalBinaryRead(reader, reader.uint32(), options, message.dialog);
-          break;
-        case 3:
-          message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          message.ui = MessageActionResponseUi.internalBinaryRead(reader, reader.uint32(), options, message.ui);
           break;
         default:
           let u = options.readUnknownField;
@@ -15565,19 +16429,17 @@ class UpdateChatOpen$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.chat)
-      Chat.internalBinaryWrite(message.chat, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.dialog)
-      Dialog.internalBinaryWrite(message.dialog, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.user)
-      User.internalBinaryWrite(message.user, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    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 UpdateChatOpen = new UpdateChatOpen$Type;
+var UpdateMessageActionAnswered = new UpdateMessageActionAnswered$Type;
 
 class UpdateDeleteChat$Type extends import_runtime4.MessageType {
   constructor() {
@@ -18052,7 +18914,9 @@ var rpcInputKindByMethod = {
   35: "moveThread",
   36: "rotateBotToken",
   37: "updateBotProfile",
-  38: "getMessages"
+  38: "getMessages",
+  48: "invokeMessageAction",
+  49: "answerMessageAction"
 };
 var rpcResultKindByMethod = {
   0: undefined,
@@ -18093,7 +18957,9 @@ var rpcResultKindByMethod = {
   35: "moveThread",
   36: "rotateBotToken",
   37: "updateBotProfile",
-  38: "getMessages"
+  38: "getMessages",
+  48: "invokeMessageAction",
+  49: "answerMessageAction"
 };
 
 // ../sdk/dist/sdk/logger.js
@@ -18103,19 +18969,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 +18996,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 +19025,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 +19033,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 +19166,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 +19274,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 +19467,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 +19501,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 +19530,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 +19591,7 @@ class InlineSdkClient {
           }),
           startSeq: BigInt(cursor),
           seqEnd: BigInt(endSeq),
-          totalLimit: 1000
+          totalLimit: defaultCatchUpTotalLimit
         })
       });
       const payload = result.getUpdates;
@@ -18645,12 +19602,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 +19618,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) {
@@ -32559,9 +33517,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 +33533,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 +33548,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) => {
@@ -32719,14 +33684,41 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 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/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) {
@@ -33007,7 +33999,7 @@ async function uploadInlineMediaFromUrl(params) {
     }));
     const normalizedExt = normalizeExt(loaded.fileName);
     uploadType = chooseUploadType({
-      kind: loaded.kind,
+      kind: loaded.kind ?? "unknown",
       ...detectedMime ? { mime: detectedMime } : {},
       ...normalizedExt ? { ext: normalizedExt } : {}
     });
@@ -33351,6 +34343,244 @@ 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;
@@ -33361,7 +34591,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, "");
@@ -33404,10 +34633,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;
@@ -33794,6 +35169,7 @@ async function monitorInlineProvider(params) {
   const chatCache = new Map;
   const senderProfilesById = new Map;
   const botMessageIdsByChat = new Map;
+  const groupPendingHistories = new Map;
   const hydratedParticipantChats = new Set;
   const participantFetches = new Map;
   const inboundMediaMaxBytes = resolveInlineMediaMaxBytes({ cfg, account });
@@ -33839,13 +35215,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;
@@ -33855,6 +35238,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({
@@ -33885,6 +35269,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({
@@ -33914,10 +35299,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 {
@@ -33941,19 +35358,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
@@ -33961,7 +35408,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 }],
@@ -33972,18 +35419,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") {
@@ -33993,6 +35449,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 }
                 });
@@ -34013,6 +35470,9 @@ 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;
             }
           }
@@ -34024,6 +35484,9 @@ async function monitorInlineProvider(params) {
             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({
@@ -34036,7 +35499,12 @@ async function monitorInlineProvider(params) {
           }
         });
         const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
-        const wasMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
+        const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
+        const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
+        const wasMentioned = nativeMentioned || patternMentioned;
+        const messageTimestamp = Number(msg.date) * 1000;
+        const groupHistoryKey = isGroup ? route.sessionKey : null;
+        const pendingHistorySender = senderUsername ? `@${senderUsername}` : senderName ?? `user:${senderId}`;
         const historyLimit = resolveHistoryLimit({
           isGroup,
           historyLimit: account.config.historyLimit,
@@ -34055,7 +35523,7 @@ async function monitorInlineProvider(params) {
           statusSink?.({ lastError: `getChatHistory failed: ${String(err)}` });
           return { historyText: null, attachmentText: null, entityText: null, 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),
@@ -34074,6 +35542,44 @@ async function monitorInlineProvider(params) {
         });
         if (isGroup && mentionGate.shouldSkip) {
           runtime2.log?.(`inline: drop group chat ${String(chatId)} (no mention)`);
+          recordPendingHistoryEntryIfEnabled({
+            historyMap: groupPendingHistories,
+            historyKey: groupHistoryKey ?? "",
+            limit: historyLimit,
+            entry: groupHistoryKey && rawBody.trim() ? {
+              sender: pendingHistorySender,
+              body: rawBody.trim(),
+              timestamp: messageTimestamp || Date.now(),
+              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({
@@ -34082,7 +35588,7 @@ async function monitorInlineProvider(params) {
           maxBytes: inboundMediaMaxBytes,
           ...log ? { log } : {}
         });
-        const timestamp = Number(msg.date) * 1000;
+        const timestamp = messageTimestamp;
         const fromLabel = isGroup ? `chat:${chatInfo.title ?? String(chatId)}` : `user:${senderId}`;
         const storePath = core3.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
         const envelopeOptions = core3.channel.reply.resolveEnvelopeFormatOptions(cfg);
@@ -34101,7 +35607,7 @@ ${currentEntityText}` : null
         ].filter(Boolean).join(`
 
 `);
-        const body = core3.channel.reply.formatAgentEnvelope({
+        let body = core3.channel.reply.formatAgentEnvelope({
           channel: "Inline",
           from: fromLabel,
           timestamp,
@@ -34109,11 +35615,30 @@ ${currentEntityText}` : null
           envelope: envelopeOptions,
           body: combinedBody || rawBody
         });
-        const commandBody = normalizeInlineCommandBody(rawBody, botUsername);
+        if (isGroup && groupHistoryKey) {
+          body = buildPendingHistoryContextFromMap({
+            historyMap: groupPendingHistories,
+            historyKey: groupHistoryKey,
+            limit: historyLimit,
+            currentMessage: body,
+            formatEntry: (entry) => core3.channel.reply.formatAgentEnvelope({
+              channel: "Inline",
+              from: fromLabel,
+              ...entry.timestamp != null ? { timestamp: entry.timestamp } : {},
+              envelope: envelopeOptions,
+              body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} chat:${String(chatId)}]` : ""}`
+            })
+          });
+        }
+        const effectiveSurface = shouldUseTelegramSurfaceForModelCommands(normalizedCommandBody) ? "telegram" : CHANNEL_ID;
+        const systemPrompt = resolveInlineSystemPrompt({
+          account,
+          ...isGroup ? { groupId: String(chatId) } : {}
+        });
         const ctxPayload = core3.channel.reply.finalizeInboundContext({
           Body: body,
           RawBody: rawBody,
-          CommandBody: commandBody,
+          CommandBody: normalizedCommandBody,
           From: isGroup ? `inline:chat:${String(chatId)}` : `inline:${senderId}`,
           To: `inline:${String(chatId)}`,
           SessionKey: route.sessionKey,
@@ -34125,15 +35650,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)}`
         });
@@ -34165,8 +35697,7 @@ ${currentEntityText}` : null
           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;
+        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 = {
@@ -34237,118 +35768,149 @@ ${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,
+              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,
+            historyKey: groupHistoryKey,
+            limit: historyLimit
+          });
+        }
       }
     } catch (err) {
       statusSink?.({ lastError: String(err) });
@@ -34477,6 +36039,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)) {
@@ -35000,6 +36633,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");
@@ -35015,6 +36649,7 @@ var inlineMessageActions = {
             const sent = await client.sendMessage({
               ...sendTarget,
               text: message,
+              ...actions !== undefined ? { actions } : {},
               ...replyToMsgId != null ? { replyToMsgId } : {},
               parseMarkdown
             });
@@ -35040,6 +36675,7 @@ var inlineMessageActions = {
               ...sendTarget,
               ...index === 0 && text ? { text } : {},
               media,
+              ...index === 0 && actions !== undefined ? { actions } : {},
               ...index === 0 && replyToMsgId != null ? { replyToMsgId } : {},
               ...index === 0 && text ? { parseMarkdown } : {}
             });
@@ -35060,6 +36696,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");
@@ -35067,6 +36704,7 @@ var inlineMessageActions = {
           const sent = await client.sendMessage({
             chatId,
             text,
+            ...actions !== undefined ? { actions } : {},
             replyToMsgId,
             parseMarkdown
           });
@@ -35212,6 +36850,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, {
@@ -35220,6 +36859,7 @@ var inlineMessageActions = {
               messageId,
               peerId: buildChatPeer2(chatId),
               text,
+              ...actions !== undefined ? { actions } : {},
               parseMarkdown
             }
           });
@@ -36136,7 +37776,7 @@ var inlineChannelPlugin = {
     reply: true,
     groupManagement: true,
     threads: false,
-    nativeCommands: false,
+    nativeCommands: true,
     blockStreaming: true
   },
   streaming: {
@@ -37039,6 +38679,500 @@ 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,
+  properties: {
+    name: {
+      type: "string",
+      description: "Optional new display name for the authenticated Inline bot."
+    },
+    photoUrl: {
+      type: "string",
+      description: "Optional remote image URL to upload as the bot profile photo."
+    },
+    photoPath: {
+      type: "string",
+      description: "Optional local image path to upload as the bot profile photo."
+    },
+    photoFileUniqueId: {
+      type: "string",
+      description: "Optional existing Inline file unique id to use as the bot profile photo."
+    },
+    accountId: {
+      type: "string",
+      description: "Optional Inline account id override."
+    }
+  }
+};
+function jsonResult4(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2)
+      }
+    ],
+    details: payload
+  };
+}
+async function withInlineClient5(params) {
+  const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? 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);
+  const client = new InlineSdkClient({
+    baseUrl: account.baseUrl,
+    token
+  });
+  await client.connect();
+  try {
+    return await params.fn(client, account.accountId);
+  } finally {
+    await client.close().catch(() => {});
+  }
+}
+function readTrimmedString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+function resolvePhotoSource(args) {
+  return readTrimmedString(args.photoPath) ?? readTrimmedString(args.photoUrl);
+}
+async function uploadProfilePhoto(client, rawSource) {
+  const loaded = await loadWebMedia2(rawSource);
+  const contentType = loaded.contentType ?? await detectMime2({
+    buffer: loaded.buffer,
+    ...loaded.fileName ? { filePath: loaded.fileName } : {}
+  }) ?? undefined;
+  const fileName = loaded.fileName?.trim() || "profile-photo.png";
+  const uploaded = await client.uploadFile({
+    type: "photo",
+    file: loaded.buffer,
+    fileName,
+    ...contentType ? { contentType } : {}
+  });
+  if (!uploaded.fileUniqueId) {
+    throw new Error("inline_update_profile: upload did not return fileUniqueId");
+  }
+  return uploaded.fileUniqueId;
+}
+function createInlineProfileTool(ctx) {
+  if (!ctx.config) {
+    return null;
+  }
+  return {
+    name: "inline_update_profile",
+    label: "Inline Update Profile",
+    description: "Update the authenticated Inline bot profile name and/or profile photo.",
+    parameters: InlineProfileToolParameters,
+    execute: async (_toolCallId, rawArgs) => {
+      const args = rawArgs;
+      const name = readTrimmedString(args.name);
+      const existingPhotoFileUniqueId = readTrimmedString(args.photoFileUniqueId);
+      const photoSource = resolvePhotoSource(args);
+      if (!name && !existingPhotoFileUniqueId && !photoSource) {
+        throw new Error("inline_update_profile: provide `name` and/or `photo`");
+      }
+      return await withInlineClient5({
+        cfg: ctx.config,
+        accountId: args.accountId ?? ctx.agentAccountId ?? null,
+        fn: async (client, resolvedAccountId) => {
+          const me = await client.getMe();
+          const photoFileUniqueId = existingPhotoFileUniqueId ?? (photoSource ? await uploadProfilePhoto(client, photoSource) : undefined);
+          const result = await client.invokeRaw(Method.UPDATE_BOT_PROFILE, {
+            oneofKind: "updateBotProfile",
+            updateBotProfile: {
+              botUserId: me.userId,
+              ...name ? { name } : {},
+              ...photoFileUniqueId ? { photoFileUniqueId } : {}
+            }
+          });
+          if (result.oneofKind !== "updateBotProfile") {
+            throw new Error(`inline_update_profile: expected updateBotProfile result, got ${String(result.oneofKind)}`);
+          }
+          return jsonResult4({
+            ok: true,
+            accountId: resolvedAccountId,
+            botUserId: String(me.userId),
+            updated: {
+              ...name ? { name } : {},
+              photo: photoFileUniqueId != null
+            },
+            bot: result.updateBotProfile.bot ?? null
+          });
+        }
+      });
+    }
+  };
+}
+
+// src/inline/bot-commands-tool.ts
+import { jsonResult as jsonResult5 } from "openclaw/plugin-sdk";
+
+// 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 jsonResult5({
+          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 jsonResult5({
+          ok: true,
+          action,
+          accountId: account.accountId,
+          count: commands.length,
+          commands
+        });
+      }
+      await callInlineBotApi({
+        baseUrl: account.baseUrl,
+        token,
+        methodName: "deleteMyCommands",
+        method: "POST"
+      });
+      return jsonResult5({
+        ok: true,
+        action,
+        accountId: account.accountId
+      });
+    }
+  };
+}
+
+// src/inline/bot-commands-sync.ts
+import * as pluginSdk from "openclaw/plugin-sdk";
+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;
+function getPluginSdkFunction(name) {
+  const raw = pluginSdk[name];
+  if (typeof raw !== "function")
+    return null;
+  return raw;
+}
+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;
+}
+function buildInlineNativeCommandsForConfig(cfg) {
+  const listNativeCommandSpecsForConfig = getPluginSdkFunction("listNativeCommandSpecsForConfig");
+  const listSkillCommandsForAgents = getPluginSdkFunction("listSkillCommandsForAgents");
+  const getPluginCommandSpecs = getPluginSdkFunction("getPluginCommandSpecs");
+  if (!listNativeCommandSpecsForConfig) {
+    const commands2 = [...INLINE_BASE_NATIVE_COMMANDS];
+    if (cfg.commands?.config === true) {
+      commands2.push({ command: "config", description: "Show or set config values." });
+    }
+    if (cfg.commands?.debug === true) {
+      commands2.push({ command: "debug", description: "Set runtime debug overrides." });
+    }
+    return commands2;
+  }
+  const skillCommands = shouldSyncInlineNativeSkills(cfg) && listSkillCommandsForAgents ? listSkillCommandsForAgents({ cfg }) : [];
+  const nativeSpecs = listNativeCommandSpecsForConfig(cfg, { skillCommands });
+  const pluginSpecs = getPluginCommandSpecs?.() ?? [];
+  const commands = [];
+  const seen = new Set;
+  for (const spec of nativeSpecs) {
+    appendUniqueCommand(commands, seen, spec.name, spec.description);
+  }
+  for (const spec of pluginSpecs) {
+    appendUniqueCommand(commands, seen, spec.name, spec.description);
+  }
+  return commands;
+}
+function isSdkNativeCommandSourceAvailable() {
+  return Boolean(getPluginSdkFunction("listNativeCommandSpecsForConfig"));
+}
+async function syncInlineNativeCommands(params) {
+  const accountIds = listInlineAccountIds(params.cfg);
+  const nativeEnabled = shouldSyncInlineNativeCommands(params.cfg);
+  const usingSdkSource = isSdkNativeCommandSourceAvailable();
+  const allCommands = nativeEnabled ? buildInlineNativeCommandsForConfig(params.cfg) : [];
+  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",
@@ -37051,9 +39185,29 @@ var plugin = {
     api2.registerTool((ctx) => createInlineMembersTool(ctx), {
       names: ["inline_members"]
     });
+    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;
@@ -37061,5 +39215,5 @@ export {
   src_default as default
 };
 
-//# debugId=ADE72751DC5C086C64756E2164756E21
+//# debugId=ECFAEB3746DF293B64756E2164756E21
 //# sourceMappingURL=index.js.map