@inline-openclaw/inline 0.0.45 → 0.0.46

package/dist/channel-plugin-api.js

@@ -5617,6 +5617,24 @@ var ConnectionError_Reason;
   ConnectionError_Reason2[ConnectionError_Reason2["INVALID_AUTH"] = 2] = "INVALID_AUTH";
   ConnectionError_Reason2[ConnectionError_Reason2["SESSION_REVOKED"] = 3] = "SESSION_REVOKED";
 })(ConnectionError_Reason || (ConnectionError_Reason = {}));
+var BotAvatar_Kind;
+(function(BotAvatar_Kind2) {
+  BotAvatar_Kind2[BotAvatar_Kind2["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
+  BotAvatar_Kind2[BotAvatar_Kind2["CODEX_ATLAS"] = 1] = "CODEX_ATLAS";
+})(BotAvatar_Kind || (BotAvatar_Kind = {}));
+var BotPresenceState_Kind;
+(function(BotPresenceState_Kind2) {
+  BotPresenceState_Kind2[BotPresenceState_Kind2["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["HIDDEN"] = 1] = "HIDDEN";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["IDLE"] = 2] = "IDLE";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["HAPPY"] = 3] = "HAPPY";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["WAVING"] = 4] = "WAVING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["JUMPING"] = 5] = "JUMPING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["FAILED"] = 6] = "FAILED";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["WAITING"] = 7] = "WAITING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["RUNNING"] = 8] = "RUNNING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["REVIEW"] = 9] = "REVIEW";
+})(BotPresenceState_Kind || (BotPresenceState_Kind = {}));
 var MessageEntity_Type;
 (function(MessageEntity_Type2) {
   MessageEntity_Type2[MessageEntity_Type2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -5730,6 +5748,11 @@ var UserStatus_Status;
   UserStatus_Status2[UserStatus_Status2["ONLINE"] = 1] = "ONLINE";
   UserStatus_Status2[UserStatus_Status2["OFFLINE"] = 2] = "OFFLINE";
 })(UserStatus_Status || (UserStatus_Status = {}));
+var DialogFollowMode;
+(function(DialogFollowMode2) {
+  DialogFollowMode2[DialogFollowMode2["DIALOG_FOLLOW_MODE_UNSPECIFIED"] = 0] = "DIALOG_FOLLOW_MODE_UNSPECIFIED";
+  DialogFollowMode2[DialogFollowMode2["FOLLOWING"] = 1] = "FOLLOWING";
+})(DialogFollowMode || (DialogFollowMode = {}));
 var MessageSendMode;
 (function(MessageSendMode2) {
   MessageSendMode2[MessageSendMode2["MODE_UNSPECIFIED"] = 0] = "MODE_UNSPECIFIED";
@@ -5793,6 +5816,11 @@ var Method;
   Method2[Method2["CLEAR_CHAT_HISTORY"] = 53] = "CLEAR_CHAT_HISTORY";
   Method2[Method2["DELETE_BOT"] = 54] = "DELETE_BOT";
   Method2[Method2["DELETE_MESSAGE_ATTACHMENT"] = 55] = "DELETE_MESSAGE_ATTACHMENT";
+  Method2[Method2["SET_BOT_AVATAR"] = 56] = "SET_BOT_AVATAR";
+  Method2[Method2["CLEAR_BOT_AVATAR"] = 57] = "CLEAR_BOT_AVATAR";
+  Method2[Method2["GET_BOT_PRESENCE"] = 58] = "GET_BOT_PRESENCE";
+  Method2[Method2["SET_BOT_PRESENCE_STATE"] = 59] = "SET_BOT_PRESENCE_STATE";
+  Method2[Method2["UPDATE_DIALOG_FOLLOW_MODE"] = 60] = "UPDATE_DIALOG_FOLLOW_MODE";
 })(Method || (Method = {}));
 var PushNotificationProvider;
 (function(PushNotificationProvider2) {
@@ -6675,6 +6703,123 @@ class PeerUser$Type extends import_runtime4.MessageType {
 }
 var PeerUser = new PeerUser$Type;
 
+class BotAvatar$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotAvatar", [
+      { no: 1, name: "kind", kind: "enum", T: () => ["BotAvatar.Kind", BotAvatar_Kind] },
+      { no: 2, name: "display_name", kind: "scalar", T: 9 },
+      { no: 3, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "cdn_url", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "file_unique_id", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = 0;
+    message.displayName = "";
+    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 = reader.int32();
+          break;
+        case 2:
+          message.displayName = reader.string();
+          break;
+        case 3:
+          message.description = reader.string();
+          break;
+        case 4:
+          message.cdnUrl = reader.string();
+          break;
+        case 5:
+          message.fileUniqueId = 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.kind !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.displayName !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.displayName);
+    if (message.description !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.cdnUrl !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.cdnUrl);
+    if (message.fileUniqueId !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotAvatar = new BotAvatar$Type;
+
+class BotPresenceState$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotPresenceState", [
+      { no: 1, name: "kind", kind: "enum", T: () => ["BotPresenceState.Kind", BotPresenceState_Kind] },
+      { no: 2, name: "comment", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = 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.kind = reader.int32();
+          break;
+        case 2:
+          message.comment = 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.kind !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.comment !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.comment);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotPresenceState = new BotPresenceState$Type;
+
 class User$Type extends import_runtime4.MessageType {
   constructor() {
     super("User", [
@@ -6689,7 +6834,8 @@ class User$Type extends import_runtime4.MessageType {
       { no: 9, name: "profile_photo", kind: "message", T: () => UserProfilePhoto },
       { no: 11, name: "pending_setup", kind: "scalar", opt: true, T: 8 },
       { no: 12, name: "time_zone", kind: "scalar", opt: true, T: 9 },
-      { no: 13, name: "bot", kind: "scalar", opt: true, T: 8 }
+      { no: 13, name: "bot", kind: "scalar", opt: true, T: 8 },
+      { no: 14, name: "bot_avatar", kind: "message", T: () => BotAvatar }
     ]);
   }
   create(value) {
@@ -6740,6 +6886,9 @@ class User$Type extends import_runtime4.MessageType {
         case 13:
           message.bot = reader.bool();
           break;
+        case 14:
+          message.botAvatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.botAvatar);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -6776,6 +6925,8 @@ class User$Type extends import_runtime4.MessageType {
       writer.tag(12, import_runtime.WireType.LengthDelimited).string(message.timeZone);
     if (message.bot !== undefined)
       writer.tag(13, import_runtime.WireType.Varint).bool(message.bot);
+    if (message.botAvatar)
+      BotAvatar.internalBinaryWrite(message.botAvatar, writer.tag(14, 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);
@@ -6861,7 +7012,8 @@ class Dialog$Type extends import_runtime4.MessageType {
       { no: 11, name: "open", kind: "scalar", opt: true, T: 8 },
       { no: 12, name: "opened_date", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 14, name: "order", kind: "scalar", opt: true, T: 9 },
-      { no: 15, name: "pinned_order", kind: "scalar", opt: true, T: 9 }
+      { no: 15, name: "pinned_order", kind: "scalar", opt: true, T: 9 },
+      { no: 16, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] }
     ]);
   }
   create(value) {
@@ -6920,6 +7072,9 @@ class Dialog$Type extends import_runtime4.MessageType {
         case 15:
           message.pinnedOrder = reader.string();
           break;
+        case 16:
+          message.followMode = reader.int32();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -6962,6 +7117,8 @@ class Dialog$Type extends import_runtime4.MessageType {
       writer.tag(14, import_runtime.WireType.LengthDelimited).string(message.order);
     if (message.pinnedOrder !== undefined)
       writer.tag(15, import_runtime.WireType.LengthDelimited).string(message.pinnedOrder);
+    if (message.followMode !== undefined)
+      writer.tag(16, import_runtime.WireType.Varint).int32(message.followMode);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -6985,7 +7142,8 @@ class Chat$Type extends import_runtime4.MessageType {
       { no: 10, name: "created_by", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 11, name: "parent_chat_id", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 12, name: "parent_message_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 13, name: "untitled", kind: "scalar", opt: true, T: 8 }
+      { no: 13, name: "untitled", kind: "scalar", opt: true, T: 8 },
+      { no: 14, name: "number", kind: "scalar", opt: true, T: 5 }
     ]);
   }
   create(value) {
@@ -7040,6 +7198,9 @@ class Chat$Type extends import_runtime4.MessageType {
         case 13:
           message.untitled = reader.bool();
           break;
+        case 14:
+          message.number = reader.int32();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -7078,6 +7239,8 @@ class Chat$Type extends import_runtime4.MessageType {
       writer.tag(12, import_runtime.WireType.Varint).int64(message.parentMessageId);
     if (message.untitled !== undefined)
       writer.tag(13, import_runtime.WireType.Varint).bool(message.untitled);
+    if (message.number !== undefined)
+      writer.tag(14, import_runtime.WireType.Varint).int32(message.number);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -9926,7 +10089,12 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { no: 53, name: "updateDialogOrder", kind: "message", oneof: "input", T: () => UpdateDialogOrderInput },
       { no: 54, name: "clearChatHistory", kind: "message", oneof: "input", T: () => ClearChatHistoryInput },
       { no: 55, name: "deleteBot", kind: "message", oneof: "input", T: () => DeleteBotInput },
-      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "input", T: () => DeleteMessageAttachmentInput }
+      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "input", T: () => DeleteMessageAttachmentInput },
+      { no: 57, name: "setBotAvatar", kind: "message", oneof: "input", T: () => SetBotAvatarInput },
+      { no: 58, name: "clearBotAvatar", kind: "message", oneof: "input", T: () => ClearBotAvatarInput },
+      { no: 59, name: "getBotPresence", kind: "message", oneof: "input", T: () => GetBotPresenceInput },
+      { no: 60, name: "setBotPresenceState", kind: "message", oneof: "input", T: () => SetBotPresenceStateInput },
+      { no: 61, name: "updateDialogFollowMode", kind: "message", oneof: "input", T: () => UpdateDialogFollowModeInput }
     ]);
   }
   create(value) {
@@ -10275,6 +10443,36 @@ class RpcCall$Type extends import_runtime4.MessageType {
             deleteMessageAttachment: DeleteMessageAttachmentInput.internalBinaryRead(reader, reader.uint32(), options, message.input.deleteMessageAttachment)
           };
           break;
+        case 57:
+          message.input = {
+            oneofKind: "setBotAvatar",
+            setBotAvatar: SetBotAvatarInput.internalBinaryRead(reader, reader.uint32(), options, message.input.setBotAvatar)
+          };
+          break;
+        case 58:
+          message.input = {
+            oneofKind: "clearBotAvatar",
+            clearBotAvatar: ClearBotAvatarInput.internalBinaryRead(reader, reader.uint32(), options, message.input.clearBotAvatar)
+          };
+          break;
+        case 59:
+          message.input = {
+            oneofKind: "getBotPresence",
+            getBotPresence: GetBotPresenceInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getBotPresence)
+          };
+          break;
+        case 60:
+          message.input = {
+            oneofKind: "setBotPresenceState",
+            setBotPresenceState: SetBotPresenceStateInput.internalBinaryRead(reader, reader.uint32(), options, message.input.setBotPresenceState)
+          };
+          break;
+        case 61:
+          message.input = {
+            oneofKind: "updateDialogFollowMode",
+            updateDialogFollowMode: UpdateDialogFollowModeInput.internalBinaryRead(reader, reader.uint32(), options, message.input.updateDialogFollowMode)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10399,6 +10597,16 @@ class RpcCall$Type extends import_runtime4.MessageType {
       DeleteBotInput.internalBinaryWrite(message.input.deleteBot, writer.tag(55, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.input.oneofKind === "deleteMessageAttachment")
       DeleteMessageAttachmentInput.internalBinaryWrite(message.input.deleteMessageAttachment, writer.tag(56, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "setBotAvatar")
+      SetBotAvatarInput.internalBinaryWrite(message.input.setBotAvatar, writer.tag(57, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "clearBotAvatar")
+      ClearBotAvatarInput.internalBinaryWrite(message.input.clearBotAvatar, writer.tag(58, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getBotPresence")
+      GetBotPresenceInput.internalBinaryWrite(message.input.getBotPresence, writer.tag(59, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "setBotPresenceState")
+      SetBotPresenceStateInput.internalBinaryWrite(message.input.setBotPresenceState, writer.tag(60, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "updateDialogFollowMode")
+      UpdateDialogFollowModeInput.internalBinaryWrite(message.input.updateDialogFollowMode, writer.tag(61, 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);
@@ -10465,7 +10673,12 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { no: 53, name: "updateDialogOrder", kind: "message", oneof: "result", T: () => UpdateDialogOrderResult },
       { no: 54, name: "clearChatHistory", kind: "message", oneof: "result", T: () => ClearChatHistoryResult },
       { no: 55, name: "deleteBot", kind: "message", oneof: "result", T: () => DeleteBotResult },
-      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "result", T: () => DeleteMessageAttachmentResult }
+      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "result", T: () => DeleteMessageAttachmentResult },
+      { no: 57, name: "setBotAvatar", kind: "message", oneof: "result", T: () => SetBotAvatarResult },
+      { no: 58, name: "clearBotAvatar", kind: "message", oneof: "result", T: () => ClearBotAvatarResult },
+      { no: 59, name: "getBotPresence", kind: "message", oneof: "result", T: () => GetBotPresenceResult },
+      { no: 60, name: "setBotPresenceState", kind: "message", oneof: "result", T: () => SetBotPresenceStateResult },
+      { no: 61, name: "updateDialogFollowMode", kind: "message", oneof: "result", T: () => UpdateDialogFollowModeResult }
     ]);
   }
   create(value) {
@@ -10814,6 +11027,36 @@ class RpcResult$Type extends import_runtime4.MessageType {
             deleteMessageAttachment: DeleteMessageAttachmentResult.internalBinaryRead(reader, reader.uint32(), options, message.result.deleteMessageAttachment)
           };
           break;
+        case 57:
+          message.result = {
+            oneofKind: "setBotAvatar",
+            setBotAvatar: SetBotAvatarResult.internalBinaryRead(reader, reader.uint32(), options, message.result.setBotAvatar)
+          };
+          break;
+        case 58:
+          message.result = {
+            oneofKind: "clearBotAvatar",
+            clearBotAvatar: ClearBotAvatarResult.internalBinaryRead(reader, reader.uint32(), options, message.result.clearBotAvatar)
+          };
+          break;
+        case 59:
+          message.result = {
+            oneofKind: "getBotPresence",
+            getBotPresence: GetBotPresenceResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getBotPresence)
+          };
+          break;
+        case 60:
+          message.result = {
+            oneofKind: "setBotPresenceState",
+            setBotPresenceState: SetBotPresenceStateResult.internalBinaryRead(reader, reader.uint32(), options, message.result.setBotPresenceState)
+          };
+          break;
+        case 61:
+          message.result = {
+            oneofKind: "updateDialogFollowMode",
+            updateDialogFollowMode: UpdateDialogFollowModeResult.internalBinaryRead(reader, reader.uint32(), options, message.result.updateDialogFollowMode)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10938,6 +11181,16 @@ class RpcResult$Type extends import_runtime4.MessageType {
       DeleteBotResult.internalBinaryWrite(message.result.deleteBot, writer.tag(55, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.result.oneofKind === "deleteMessageAttachment")
       DeleteMessageAttachmentResult.internalBinaryWrite(message.result.deleteMessageAttachment, writer.tag(56, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "setBotAvatar")
+      SetBotAvatarResult.internalBinaryWrite(message.result.setBotAvatar, writer.tag(57, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "clearBotAvatar")
+      ClearBotAvatarResult.internalBinaryWrite(message.result.clearBotAvatar, writer.tag(58, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getBotPresence")
+      GetBotPresenceResult.internalBinaryWrite(message.result.getBotPresence, writer.tag(59, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "setBotPresenceState")
+      SetBotPresenceStateResult.internalBinaryWrite(message.result.setBotPresenceState, writer.tag(60, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "updateDialogFollowMode")
+      UpdateDialogFollowModeResult.internalBinaryWrite(message.result.updateDialogFollowMode, writer.tag(61, 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);
@@ -12029,6 +12282,97 @@ class UpdateDialogOrderResult$Type extends import_runtime4.MessageType {
 }
 var UpdateDialogOrderResult = new UpdateDialogOrderResult$Type;
 
+class UpdateDialogFollowModeInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogFollowModeInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.followMode = 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.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.followMode !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.followMode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateDialogFollowModeInput = new UpdateDialogFollowModeInput$Type;
+
+class UpdateDialogFollowModeResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogFollowModeResult", [
+      { no: 1, 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 1:
+          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(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 UpdateDialogFollowModeResult = new UpdateDialogFollowModeResult$Type;
+
 class MarkAsUnreadInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("MarkAsUnreadInput", [
@@ -12799,17 +13143,367 @@ class GetBotCommandsInput$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var GetBotCommandsInput = new GetBotCommandsInput$Type;
+var GetBotCommandsInput = new GetBotCommandsInput$Type;
+
+class GetBotCommandsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.commands = [];
+    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.commands.push(BotCommand.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.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[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 GetBotCommandsResult = new GetBotCommandsResult$Type;
+
+class SetBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotCommandsInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.commands = [];
+    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.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.commands.push(BotCommand.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) {
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[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 SetBotCommandsInput = new SetBotCommandsInput$Type;
+
+class SetBotCommandsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.commands = [];
+    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.commands.push(BotCommand.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.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[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 SetBotCommandsResult = new SetBotCommandsResult$Type;
+
+class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetPeerBotCommandsInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        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();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetPeerBotCommandsInput = new GetPeerBotCommandsInput$Type;
+
+class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetPeerBotCommandsResult", [
+      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.bots = [];
+    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.bots.push(PeerBotCommands.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.bots.length; i++)
+      PeerBotCommands.internalBinaryWrite(message.bots[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 GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
+
+class RevealBotTokenInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevealBotTokenInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 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.botUserId = 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.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevealBotTokenInput = new RevealBotTokenInput$Type;
+
+class RevealBotTokenResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevealBotTokenResult", [
+      { no: 1, name: "token", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.token = "";
+    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.token = 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.token !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevealBotTokenResult = new RevealBotTokenResult$Type;
+
+class RotateBotTokenInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RotateBotTokenInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 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.botUserId = 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.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RotateBotTokenInput = new RotateBotTokenInput$Type;
 
-class GetBotCommandsResult$Type extends import_runtime4.MessageType {
+class RotateBotTokenResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetBotCommandsResult", [
-      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("RotateBotTokenResult", [
+      { no: 1, name: "token", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
+    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12820,7 +13514,7 @@ class GetBotCommandsResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.token = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12834,27 +13528,27 @@ class GetBotCommandsResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.token !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetBotCommandsResult = new GetBotCommandsResult$Type;
+var RotateBotTokenResult = new RotateBotTokenResult$Type;
 
-class SetBotCommandsInput$Type extends import_runtime4.MessageType {
+class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SetBotCommandsInput", [
+    super("UpdateBotProfileInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+      { no: 2, name: "name", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "photo_file_unique_id", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
     message.botUserId = 0n;
-    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12868,7 +13562,10 @@ class SetBotCommandsInput$Type extends import_runtime4.MessageType {
           message.botUserId = reader.int64().toBigInt();
           break;
         case 2:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.name = reader.string();
+          break;
+        case 3:
+          message.photoFileUniqueId = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12884,25 +13581,26 @@ class SetBotCommandsInput$Type extends import_runtime4.MessageType {
   internalBinaryWrite(message, writer, options) {
     if (message.botUserId !== 0n)
       writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.name !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.photoFileUniqueId !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.photoFileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SetBotCommandsInput = new SetBotCommandsInput$Type;
+var UpdateBotProfileInput = new UpdateBotProfileInput$Type;
 
-class SetBotCommandsResult$Type extends import_runtime4.MessageType {
+class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SetBotCommandsResult", [
-      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("UpdateBotProfileResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12913,7 +13611,7 @@ class SetBotCommandsResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
           break;
         default:
           let u = options.readUnknownField;
@@ -12927,24 +13625,32 @@ class SetBotCommandsResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, 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 SetBotCommandsResult = new SetBotCommandsResult$Type;
+var UpdateBotProfileResult = new UpdateBotProfileResult$Type;
 
-class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
+class SetBotAvatarInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetPeerBotCommandsInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    super("SetBotAvatarInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "kind", kind: "enum", T: () => ["BotAvatar.Kind", BotAvatar_Kind] },
+      { no: 3, name: "display_name", kind: "scalar", T: 9 },
+      { no: 4, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "file_unique_id", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.kind = 0;
+    message.displayName = "";
+    message.fileUniqueId = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12955,7 +13661,19 @@ class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.kind = reader.int32();
+          break;
+        case 3:
+          message.displayName = reader.string();
+          break;
+        case 4:
+          message.description = reader.string();
+          break;
+        case 5:
+          message.fileUniqueId = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12969,25 +13687,32 @@ class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.peerId)
-      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.kind !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.displayName !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.displayName);
+    if (message.description !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.fileUniqueId !== "")
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetPeerBotCommandsInput = new GetPeerBotCommandsInput$Type;
+var SetBotAvatarInput = new SetBotAvatarInput$Type;
 
-class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
+class SetBotAvatarResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetPeerBotCommandsResult", [
-      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
+    super("SetBotAvatarResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.bots = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12998,7 +13723,7 @@ class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.bots.push(PeerBotCommands.internalBinaryRead(reader, reader.uint32(), options));
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
           break;
         default:
           let u = options.readUnknownField;
@@ -13012,19 +13737,19 @@ class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.bots.length; i++)
-      PeerBotCommands.internalBinaryWrite(message.bots[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, 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 GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
+var SetBotAvatarResult = new SetBotAvatarResult$Type;
 
-class RevealBotTokenInput$Type extends import_runtime4.MessageType {
+class ClearBotAvatarInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevealBotTokenInput", [
+    super("ClearBotAvatarInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
@@ -13063,17 +13788,16 @@ class RevealBotTokenInput$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var RevealBotTokenInput = new RevealBotTokenInput$Type;
+var ClearBotAvatarInput = new ClearBotAvatarInput$Type;
 
-class RevealBotTokenResult$Type extends import_runtime4.MessageType {
+class ClearBotAvatarResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevealBotTokenResult", [
-      { no: 1, name: "token", kind: "scalar", T: 9 }
+    super("ClearBotAvatarResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13084,7 +13808,7 @@ class RevealBotTokenResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.token = reader.string();
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
           break;
         default:
           let u = options.readUnknownField;
@@ -13098,25 +13822,24 @@ class RevealBotTokenResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.token !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, 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 RevealBotTokenResult = new RevealBotTokenResult$Type;
+var ClearBotAvatarResult = new ClearBotAvatarResult$Type;
 
-class RotateBotTokenInput$Type extends import_runtime4.MessageType {
+class GetBotPresenceInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RotateBotTokenInput", [
-      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    super("GetBotPresenceInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.botUserId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13127,7 +13850,7 @@ class RotateBotTokenInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         default:
           let u = options.readUnknownField;
@@ -13141,25 +13864,27 @@ class RotateBotTokenInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.botUserId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, 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 RotateBotTokenInput = new RotateBotTokenInput$Type;
+var GetBotPresenceInput = new GetBotPresenceInput$Type;
 
-class RotateBotTokenResult$Type extends import_runtime4.MessageType {
+class GetBotPresenceResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RotateBotTokenResult", [
-      { no: 1, name: "token", kind: "scalar", T: 9 }
+    super("GetBotPresenceResult", [
+      { no: 1, name: "bot_user_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 2, name: "avatar", kind: "message", T: () => BotAvatar },
+      { no: 3, name: "state", kind: "message", T: () => BotPresenceState },
+      { no: 4, name: "peer_id", kind: "message", T: () => Peer }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13170,7 +13895,16 @@ class RotateBotTokenResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.token = reader.string();
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.avatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.avatar);
+          break;
+        case 3:
+          message.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
+          break;
+        case 4:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         default:
           let u = options.readUnknownField;
@@ -13184,27 +13918,31 @@ class RotateBotTokenResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.token !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
+    if (message.botUserId !== undefined)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.avatar)
+      BotAvatar.internalBinaryWrite(message.avatar, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state)
+      BotPresenceState.internalBinaryWrite(message.state, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, 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 RotateBotTokenResult = new RotateBotTokenResult$Type;
+var GetBotPresenceResult = new GetBotPresenceResult$Type;
 
-class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
+class SetBotPresenceStateInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateBotProfileInput", [
-      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "name", kind: "scalar", opt: true, T: 9 },
-      { no: 3, name: "photo_file_unique_id", kind: "scalar", opt: true, T: 9 }
+    super("SetBotPresenceStateInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "state", kind: "message", T: () => BotPresenceState }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.botUserId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13215,13 +13953,10 @@ class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         case 2:
-          message.name = reader.string();
-          break;
-        case 3:
-          message.photoFileUniqueId = reader.string();
+          message.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
           break;
         default:
           let u = options.readUnknownField;
@@ -13235,25 +13970,21 @@ class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.botUserId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
-    if (message.name !== undefined)
-      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.name);
-    if (message.photoFileUniqueId !== undefined)
-      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.photoFileUniqueId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state)
+      BotPresenceState.internalBinaryWrite(message.state, 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 UpdateBotProfileInput = new UpdateBotProfileInput$Type;
+var SetBotPresenceStateInput = new SetBotPresenceStateInput$Type;
 
-class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
+class SetBotPresenceStateResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateBotProfileResult", [
-      { no: 1, name: "bot", kind: "message", T: () => User }
-    ]);
+    super("SetBotPresenceStateResult", []);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
@@ -13262,34 +13993,16 @@ class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
     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.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
+    return target ?? this.create();
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.bot)
-      User.internalBinaryWrite(message.bot, 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 UpdateBotProfileResult = new UpdateBotProfileResult$Type;
+var SetBotPresenceStateResult = new SetBotPresenceStateResult$Type;
 
 class GetUserSettingsInput$Type extends import_runtime4.MessageType {
   constructor() {
@@ -16429,7 +17142,9 @@ class Update$Type extends import_runtime4.MessageType {
       { 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 },
-      { no: 37, name: "clear_chat_history", kind: "message", oneof: "update", T: () => UpdateClearChatHistory }
+      { no: 37, name: "clear_chat_history", kind: "message", oneof: "update", T: () => UpdateClearChatHistory },
+      { no: 38, name: "bot_presence", kind: "message", oneof: "update", T: () => UpdateBotPresence },
+      { no: 39, name: "dialog_follow_mode", kind: "message", oneof: "update", T: () => UpdateDialogFollowMode }
     ]);
   }
   create(value) {
@@ -16654,6 +17369,18 @@ class Update$Type extends import_runtime4.MessageType {
             clearChatHistory: UpdateClearChatHistory.internalBinaryRead(reader, reader.uint32(), options, message.update.clearChatHistory)
           };
           break;
+        case 38:
+          message.update = {
+            oneofKind: "botPresence",
+            botPresence: UpdateBotPresence.internalBinaryRead(reader, reader.uint32(), options, message.update.botPresence)
+          };
+          break;
+        case 39:
+          message.update = {
+            oneofKind: "dialogFollowMode",
+            dialogFollowMode: UpdateDialogFollowMode.internalBinaryRead(reader, reader.uint32(), options, message.update.dialogFollowMode)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16738,6 +17465,10 @@ class Update$Type extends import_runtime4.MessageType {
       UpdateMessageActionAnswered.internalBinaryWrite(message.update.messageActionAnswered, writer.tag(36, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.update.oneofKind === "clearChatHistory")
       UpdateClearChatHistory.internalBinaryWrite(message.update.clearChatHistory, writer.tag(37, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "botPresence")
+      UpdateBotPresence.internalBinaryWrite(message.update.botPresence, writer.tag(38, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "dialogFollowMode")
+      UpdateDialogFollowMode.internalBinaryWrite(message.update.dialogFollowMode, writer.tag(39, 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);
@@ -17598,6 +18329,54 @@ class UpdateDialogNotificationSettings$Type extends import_runtime4.MessageType
 }
 var UpdateDialogNotificationSettings = new UpdateDialogNotificationSettings$Type;
 
+class UpdateDialogFollowMode$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogFollowMode", [
+      { no: 1, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 2, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.followMode = 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.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.followMode !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.followMode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateDialogFollowMode = new UpdateDialogFollowMode$Type;
+
 class UpdateNewChat$Type extends import_runtime4.MessageType {
   constructor() {
     super("UpdateNewChat", [
@@ -18123,6 +18902,74 @@ class UpdateClearChatHistory$Type extends import_runtime4.MessageType {
 }
 var UpdateClearChatHistory = new UpdateClearChatHistory$Type;
 
+class UpdateBotPresence$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateBotPresence", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 3, name: "state", kind: "message", T: () => BotPresenceState },
+      { no: 4, name: "avatar", kind: "message", T: () => BotAvatar },
+      { no: 5, name: "avatar_changed", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.avatarChanged = false;
+    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.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 3:
+          message.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
+          break;
+        case 4:
+          message.avatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.avatar);
+          break;
+        case 5:
+          message.avatarChanged = reader.bool();
+          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.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state)
+      BotPresenceState.internalBinaryWrite(message.state, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.avatar)
+      BotAvatar.internalBinaryWrite(message.avatar, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.avatarChanged !== false)
+      writer.tag(5, import_runtime.WireType.Varint).bool(message.avatarChanged);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateBotPresence = new UpdateBotPresence$Type;
+
 class UpdateMessageId$Type extends import_runtime4.MessageType {
   constructor() {
     super("UpdateMessageId", [
@@ -37517,6 +38364,80 @@ async function uploadInlineMediaFromUrl(params) {
   }
 }
 
+// src/inline/message-formatting.ts
+var INLINE_FORMATTING_RULES = [
+  "Use Inline markdown.",
+  "Prefer bullet lists over markdown tables.",
+  "If a table is necessary, render it inside a fenced code block.",
+  "Use plain URLs or markdown links; do not wrap bare URLs in inline code or backticks.",
+  "Mention Inline users with markdown links like [@FirstName](inline://user?id=123); use inline://user?username=username only when the user id is unavailable.",
+  "Link Inline chats/threads with markdown links like [Planning](inline://chat?id=123) or [Planning](inline://thread?id=123); use inline://thread?space_id=7 when only the title and space are known.",
+  "Use inline code only for actual code, commands, file paths, env vars, or identifiers."
+];
+var INLINE_COPY_REPLACEMENTS = [
+  [
+    /Bind this (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) to a session target\.?/gi,
+    "Bind this Inline conversation to a session target."
+  ],
+  [
+    /Remove the current (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) binding\.?/gi,
+    "Remove the current Inline conversation binding."
+  ]
+];
+function normalizeInlineMarkdownLabel(raw, fallback) {
+  return (raw ?? "").replace(/\s+/g, " ").trim() || fallback;
+}
+function escapeInlineMarkdownLabel(raw) {
+  return raw.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+function encodeInlineMarkdownValue(raw) {
+  return encodeURIComponent(String(raw).trim());
+}
+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 adaptInlineVisibleCopy(text) {
+  let result = text;
+  for (const [from, to] of INLINE_COPY_REPLACEMENTS) {
+    result = result.replace(from, to);
+  }
+  return result;
+}
+function buildInlineSystemPrompt(extraPrompt) {
+  return extraPrompt?.trim() || "";
+}
+function buildInlineInboundFormattingHints() {
+  return {
+    text_markup: "inline_markdown",
+    rules: [...INLINE_FORMATTING_RULES]
+  };
+}
+function buildInlineThreadMarkdownLink(params) {
+  const title = normalizeInlineMarkdownLabel(params.title, `thread:${String(params.threadId)}`);
+  return `[${escapeInlineMarkdownLabel(title)}](inline://thread?id=${encodeInlineMarkdownValue(params.threadId)})`;
+}
+function buildInlineThreadTitleMarkdownLink(params) {
+  const title = normalizeInlineMarkdownLabel(params.title, `space:${String(params.spaceId)}`);
+  const label = normalizeInlineMarkdownLabel(params.label, title);
+  const query = [`space_id=${encodeInlineMarkdownValue(params.spaceId)}`];
+  if (label !== title) {
+    query.push(`title=${encodeInlineMarkdownValue(title)}`);
+  }
+  return `[${escapeInlineMarkdownLabel(label)}](inline://thread?${query.join("&")})`;
+}
+function sanitizeInlineOutgoingText(text) {
+  return adaptInlineVisibleCopy(text).replace(/`([^`\n]+)`/g, (full, content) => {
+    return isBareHttpUrl(content) ? content : full;
+  });
+}
+
 // src/inline/message-content.ts
 var INLINE_MESSAGE_ENTITY_TYPE = {
   MENTION: 1,
@@ -37528,7 +38449,9 @@ var INLINE_MESSAGE_ENTITY_TYPE = {
   USERNAME_MENTION: 7,
   CODE: 8,
   PRE: 9,
-  PHONE_NUMBER: 10
+  PHONE_NUMBER: 10,
+  THREAD: 11,
+  THREAD_TITLE: 12
 };
 function compactWhitespace(raw) {
   return (raw ?? "").replace(/\s+/g, " ").trim();
@@ -37696,6 +38619,10 @@ function mapEntityType(type) {
       return "pre";
     case INLINE_MESSAGE_ENTITY_TYPE.PHONE_NUMBER:
       return "phone_number";
+    case INLINE_MESSAGE_ENTITY_TYPE.THREAD:
+      return "thread";
+    case INLINE_MESSAGE_ENTITY_TYPE.THREAD_TITLE:
+      return "thread_title";
     default:
       return "unknown";
   }
@@ -37737,6 +38664,26 @@ function messageEntitySummaries(message) {
       const language = compactWhitespace(entity.entity.pre.language);
       if (language)
         summary.language = language;
+    } else if (entity.entity.oneofKind === "thread") {
+      const chatId = entity.entity.thread.chatId.toString();
+      summary.chatId = chatId;
+      summary.markdownLink = buildInlineThreadMarkdownLink({
+        threadId: chatId,
+        ...summary.text ? { title: summary.text } : {}
+      });
+    } else if (entity.entity.oneofKind === "threadTitle") {
+      const spaceId = entity.entity.threadTitle.spaceId.toString();
+      const title = compactWhitespace(entity.entity.threadTitle.title);
+      summary.spaceId = spaceId;
+      if (title)
+        summary.title = title;
+      if (title || summary.text) {
+        summary.markdownLink = buildInlineThreadTitleMarkdownLink({
+          spaceId,
+          title: title || summary.text || `space:${spaceId}`,
+          label: summary.text || title
+        });
+      }
     }
     entities.push(summary);
   }
@@ -37789,6 +38736,13 @@ function formatEntitySummary(entity) {
       return entity.userId ? `mention${quotedText} -> user:${entity.userId}` : `mention${quotedText}`;
     case "text_link":
       return entity.url ? `text link${quotedText} -> ${entity.url}` : `text link${quotedText}`;
+    case "thread":
+      return entity.chatId ? `thread link${quotedText} -> thread:${entity.chatId}` : `thread link${quotedText}`;
+    case "thread_title":
+      if (entity.spaceId && entity.title) {
+        return `thread title link${quotedText} -> space:${entity.spaceId} title:"${entity.title}"`;
+      }
+      return entity.spaceId ? `thread title link${quotedText} -> space:${entity.spaceId}` : `thread title link${quotedText}`;
     case "pre":
       return entity.language ? `preformatted block${quotedText} (language: ${entity.language})` : `preformatted block${quotedText}`;
     case "username_mention":
@@ -37833,57 +38787,6 @@ function summarizeInlineMessageContent(message) {
   };
 }
 
-// src/inline/message-formatting.ts
-var INLINE_FORMATTING_RULES = [
-  "Use Inline markdown.",
-  "Prefer bullet lists over markdown tables.",
-  "If a table is necessary, render it inside a fenced code block.",
-  "Use plain URLs or markdown links; do not wrap bare URLs in inline code or backticks.",
-  "Mention Inline users with markdown links like [@FirstName](inline://user?id=123); use inline://user?username=username only when the user id is unavailable.",
-  "Use inline code only for actual code, commands, file paths, env vars, or identifiers."
-];
-var INLINE_COPY_REPLACEMENTS = [
-  [
-    /Bind this (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) to a session target\.?/gi,
-    "Bind this Inline conversation to a session target."
-  ],
-  [
-    /Remove the current (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) binding\.?/gi,
-    "Remove the current Inline conversation binding."
-  ]
-];
-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 adaptInlineVisibleCopy(text) {
-  let result = text;
-  for (const [from, to] of INLINE_COPY_REPLACEMENTS) {
-    result = result.replace(from, to);
-  }
-  return result;
-}
-function buildInlineSystemPrompt(extraPrompt) {
-  return extraPrompt?.trim() || "";
-}
-function buildInlineInboundFormattingHints() {
-  return {
-    text_markup: "inline_markdown",
-    rules: [...INLINE_FORMATTING_RULES]
-  };
-}
-function sanitizeInlineOutgoingText(text) {
-  return adaptInlineVisibleCopy(text).replace(/`([^`\n]+)`/g, (full, content) => {
-    return isBareHttpUrl(content) ? content : full;
-  });
-}
-
 // src/inline/thread-routes.ts
 import path2 from "node:path";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
@@ -38570,6 +39473,46 @@ var GET_MESSAGES_METHOD2 = typeof Method.GET_MESSAGES === "number" && Number.isI
 var CREATE_SUBTHREAD_METHOD2 = typeof Method.CREATE_SUBTHREAD === "number" && Number.isInteger(Method.CREATE_SUBTHREAD) && Method.CREATE_SUBTHREAD > 0 ? Method.CREATE_SUBTHREAD : 42;
 var INLINE_ACTION_MAX_ROWS = 8;
 var INLINE_ACTION_MAX_PER_ROW = 8;
+var INLINE_BOT_PRESENCE_KINDS = [
+  "idle",
+  "happy",
+  "waving",
+  "jumping",
+  "failed",
+  "waiting",
+  "running",
+  "review"
+];
+var inlineBotPresenceChannelDataSchema = {
+  type: "object",
+  description: "Inline-specific metadata for a send. Use inline.botPresence for the bot's on-screen body.",
+  additionalProperties: true,
+  properties: {
+    inline: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        botPresence: {
+          type: "object",
+          description: "Optional Inline bot presence state generated from your current mood or process.",
+          additionalProperties: true,
+          properties: {
+            kind: {
+              type: "string",
+              enum: INLINE_BOT_PRESENCE_KINDS,
+              description: "Emotion/state for the on-screen bot presence."
+            },
+            comment: {
+              type: "string",
+              maxLength: 30,
+              description: "Optional short expression from your actual current thought, status, mood, request, or aside. Text or one/two emoji."
+            }
+          }
+        }
+      }
+    }
+  }
+};
 function suppressedInternalTextResult() {
   return jsonResult({
     ok: false,
@@ -39326,14 +40269,24 @@ function describeInlineMessageTool({
     };
   }
   const buttonsEnabled = supportsInlineMessageButtons(actions);
+  const sendEnabled = actions.includes("send");
   const capabilities = buttonsEnabled ? ["presentation"] : [];
-  const schema = buttonsEnabled ? [
-    {
+  const schema = [];
+  if (buttonsEnabled) {
+    schema.push({
       properties: {
         buttons: createMessageToolButtonsSchema()
       }
-    }
-  ] : [];
+    });
+  }
+  if (sendEnabled) {
+    schema.push({
+      actions: ["send"],
+      properties: {
+        channelData: inlineBotPresenceChannelDataSchema
+      }
+    });
+  }
   return {
     actions,
     capabilities,
@@ -41418,7 +42371,14 @@ var INLINE_DEBOUNCE_ERROR_FALLBACK = "OpenClaw could not process those messages.
 var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES2 = 50;
 var DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT = 10;
 var INLINE_PARTICIPANT_ADD_READY_MAX_EVENT_AGE_MS = 10 * 60 * 1000;
+var INLINE_BOT_PRESENCE_IDLE_DELAY_MS = 8000;
+var INLINE_BOT_PRESENCE_FINISH_IDLE_DELAY_MS = 8000;
+var INLINE_BOT_PRESENCE_GESTURE_MS = 1400;
+var INLINE_BOT_PRESENCE_FAILED_MS = 8000;
+var INLINE_BOT_PRESENCE_COMMENT_MAX_LENGTH = 30;
 var INLINE_REPLY_THREAD_SYSTEM_PROMPT = "Inline reply threads are scoped conversations: answer only the current reply-thread message and this thread's own history; use parent-chat context only as background, and do not answer unrelated questions from the parent chat or other reply threads.";
+var INLINE_REPLY_THREAD_NEGATION_RE = /\b(?:do\s+not|don't|dont|please\s+don't|please\s+dont|no\s+need\s+to)\s+(?:create|start|open|make|use|move|take|reply|respond|answer|send|thread)\b[^.!?\n]*\bthread\b|\b(?:reply|respond|answer|keep)\s+(?:here|in\s+the\s+main\s+chat|in\s+main\s+chat|in\s+the\s+parent\s+chat|in\s+parent\s+chat)\b/u;
+var INLINE_REPLY_THREAD_INTENT_RE = /\b(?:reply|respond|answer|send)\s+(?:in|inside|into|to)\s+(?:a\s+)?(?:(?:new|child|reply)\s+)?thread\b|\b(?:create|start|open|make|use)\s+(?:a\s+)?(?:(?:new|child|reply)\s+)?thread\b|\b(?:move|take)\s+(?:(?:this|it|the\s+answer|the\s+reply|the\s+response)\s+)?(?:to|into)\s+(?:a\s+)?(?:(?:new|child|reply)\s+)?thread\b|\bthread\s+(?:this|the\s+answer|the\s+reply|the\s+response)\b|\b(?:threaded\s+(?:reply|response)|(?:reply|respond|answer)\s+threaded)\b/u;
 function buildInlineTypingDispatcherOptions(typingCallbacks) {
   if (!typingCallbacks) {
     return {};
@@ -41464,6 +42424,266 @@ async function sendInlineTypingToChats(params) {
     params.onPartialError?.(failure.chatId, failure.error);
   }
 }
+function inlineBotPresenceStateKind(kind) {
+  switch (kind) {
+    case "idle":
+      return BotPresenceState_Kind.IDLE;
+    case "happy":
+      return BotPresenceState_Kind.HAPPY;
+    case "waving":
+      return BotPresenceState_Kind.WAVING;
+    case "jumping":
+      return BotPresenceState_Kind.JUMPING;
+    case "failed":
+      return BotPresenceState_Kind.FAILED;
+    case "waiting":
+      return BotPresenceState_Kind.WAITING;
+    case "running":
+      return BotPresenceState_Kind.RUNNING;
+    case "review":
+      return BotPresenceState_Kind.REVIEW;
+  }
+}
+function normalizeInlineBotPresenceKind(value) {
+  if (typeof value !== "string")
+    return;
+  switch (value.trim().toLowerCase()) {
+    case "idle":
+    case "happy":
+    case "waving":
+    case "jumping":
+    case "failed":
+    case "waiting":
+    case "running":
+    case "review":
+      return value.trim().toLowerCase();
+    default:
+      return;
+  }
+}
+function normalizeInlineBotPresenceComment(value) {
+  if (typeof value !== "string")
+    return;
+  const text = value.replace(/\s+/g, " ").trim();
+  if (!text)
+    return;
+  return Array.from(text).slice(0, INLINE_BOT_PRESENCE_COMMENT_MAX_LENGTH).join("");
+}
+function resolveInlineBotPresenceSignal(payload) {
+  const channelData = isRecord6(payload.channelData) ? payload.channelData : undefined;
+  const inlineData = channelData && isRecord6(channelData.inline) ? channelData.inline : undefined;
+  const rawPresence = inlineData && isRecord6(inlineData.botPresence) ? inlineData.botPresence : undefined;
+  if (!rawPresence)
+    return null;
+  const kind = normalizeInlineBotPresenceKind(rawPresence.kind) ?? "happy";
+  const comment = normalizeInlineBotPresenceComment(rawPresence.comment);
+  return comment ? { kind, comment } : { kind };
+}
+async function sendInlineBotPresenceToChats(params) {
+  if (params.chatIds.length === 0)
+    return;
+  const failures = [];
+  await Promise.all(params.chatIds.map(async (chatId) => {
+    try {
+      await params.client.invokeRaw(Method.SET_BOT_PRESENCE_STATE, {
+        oneofKind: "setBotPresenceState",
+        setBotPresenceState: {
+          peerId: {
+            type: {
+              oneofKind: "chat",
+              chat: { chatId }
+            }
+          },
+          state: {
+            kind: inlineBotPresenceStateKind(params.kind),
+            ...params.comment ? { comment: params.comment } : {}
+          }
+        }
+      });
+    } catch (error51) {
+      failures.push({ chatId, error: error51 });
+    }
+  }));
+  if (failures.length === 0)
+    return;
+  if (failures.length === params.chatIds.length) {
+    throw failures[0]?.error ?? new Error("inline bot presence failed");
+  }
+  for (const failure of failures) {
+    params.onPartialError?.(failure.chatId, failure.error);
+  }
+}
+async function sendInlineTypingAndBotPresenceToChats(params) {
+  let typingError = null;
+  await Promise.all([
+    sendInlineTypingToChats({
+      client: params.client,
+      chatIds: params.chatIds,
+      typing: params.typing,
+      ...params.onTypingPartialError ? { onPartialError: params.onTypingPartialError } : {}
+    }).catch((error51) => {
+      typingError = error51;
+    }),
+    sendInlineBotPresenceToChats({
+      client: params.client,
+      chatIds: params.chatIds,
+      kind: params.presenceKind,
+      ...params.onPresencePartialError ? { onPartialError: params.onPresencePartialError } : {}
+    }).catch((error51) => {
+      params.onPresenceError?.(error51);
+    })
+  ]);
+  if (typingError != null) {
+    throw typingError;
+  }
+}
+function createInlineBotPresenceLifecycle(params) {
+  let active = false;
+  let finishing = false;
+  let idleTimer;
+  let gestureTimer;
+  let currentKind;
+  let currentComment;
+  let busyKind = "running";
+  let busyComment;
+  let sendChain = Promise.resolve();
+  const clearIdleTimer = () => {
+    if (!idleTimer)
+      return;
+    clearTimeout(idleTimer);
+    idleTimer = undefined;
+  };
+  const clearGestureTimer = () => {
+    if (!gestureTimer)
+      return;
+    clearTimeout(gestureTimer);
+    gestureTimer = undefined;
+  };
+  const send = (kind, comment) => {
+    if (currentKind === kind && currentComment === comment)
+      return Promise.resolve();
+    currentKind = kind;
+    currentComment = comment;
+    sendChain = sendChain.catch(() => {}).then(() => sendInlineBotPresenceToChats({
+      client: params.client,
+      chatIds: params.chatIds,
+      kind,
+      ...comment ? { comment } : {},
+      onPartialError: params.onPartialError
+    }).catch(params.onError));
+    return sendChain;
+  };
+  const scheduleIdle = (delayMs = INLINE_BOT_PRESENCE_IDLE_DELAY_MS) => {
+    clearIdleTimer();
+    idleTimer = setTimeout(() => {
+      idleTimer = undefined;
+      active = false;
+      finishing = false;
+      busyKind = "running";
+      busyComment = undefined;
+      send("idle");
+    }, delayMs);
+    idleTimer.unref?.();
+  };
+  const showBusy = async (kind, comment) => {
+    if (!active || finishing)
+      return;
+    clearIdleTimer();
+    clearGestureTimer();
+    busyKind = kind;
+    busyComment = comment;
+    await send(kind, comment);
+  };
+  const gesture = (kind, resumeKind = busyKind, comment, resumeComment = busyComment) => {
+    if (params.chatIds.length === 0)
+      return;
+    clearIdleTimer();
+    clearGestureTimer();
+    active = true;
+    send(kind, comment);
+    gestureTimer = setTimeout(() => {
+      gestureTimer = undefined;
+      if (!active || finishing)
+        return;
+      send(resumeKind, resumeComment);
+    }, INLINE_BOT_PRESENCE_GESTURE_MS);
+    gestureTimer.unref?.();
+  };
+  return {
+    start: async (cue) => {
+      if (params.chatIds.length === 0)
+        return;
+      clearIdleTimer();
+      if (active && !finishing)
+        return;
+      active = true;
+      finishing = false;
+      const cueKind = cue?.kind;
+      busyKind = cueKind === "review" ? "review" : "running";
+      busyComment = undefined;
+      if (cueKind === "waving") {
+        gesture("waving", busyKind);
+        return;
+      }
+      await send(busyKind, busyComment);
+    },
+    busy: (kind, comment) => {
+      showBusy(kind, comment);
+    },
+    gesture: (kind, comment) => {
+      gesture(kind, busyKind, comment);
+    },
+    express: (signal) => {
+      if (signal.kind === "failed") {
+        if (params.chatIds.length === 0)
+          return;
+        clearIdleTimer();
+        clearGestureTimer();
+        active = true;
+        finishing = true;
+        send("failed", signal.comment).finally(() => scheduleIdle(INLINE_BOT_PRESENCE_FAILED_MS));
+        return;
+      }
+      if (params.chatIds.length === 0)
+        return;
+      clearIdleTimer();
+      clearGestureTimer();
+      active = true;
+      finishing = true;
+      send(signal.kind, signal.comment).finally(() => scheduleIdle());
+    },
+    finish: () => {
+      if (!active || finishing)
+        return;
+      finishing = true;
+      clearGestureTimer();
+      scheduleIdle(INLINE_BOT_PRESENCE_FINISH_IDLE_DELAY_MS);
+    },
+    fail: (comment) => {
+      if (params.chatIds.length === 0)
+        return;
+      clearIdleTimer();
+      clearGestureTimer();
+      active = true;
+      finishing = true;
+      send("failed", comment).finally(() => scheduleIdle(INLINE_BOT_PRESENCE_FAILED_MS));
+    },
+    cleanup: () => {
+      if (!active)
+        return;
+      if (finishing)
+        return;
+      clearIdleTimer();
+      clearGestureTimer();
+      active = false;
+      send("idle").finally(() => {
+        finishing = false;
+        busyKind = "running";
+        busyComment = undefined;
+      });
+    }
+  };
+}
 function buildInlineReplyThreadSessionKey(parentSessionKey, threadChatId) {
   const suffix = `:thread:${String(threadChatId)}`;
   return parentSessionKey.endsWith(suffix) ? parentSessionKey : `${parentSessionKey}${suffix}`;
@@ -42283,6 +43503,24 @@ function resolveInlineSystemPrompt(params) {
 
 `);
 }
+function hasExplicitInlineReplyThreadIntent(raw) {
+  const text = normalizeLowercaseStringOrEmpty2(raw).replace(/\s+/g, " ").trim();
+  if (!text)
+    return false;
+  if (INLINE_REPLY_THREAD_NEGATION_RE.test(text))
+    return false;
+  return INLINE_REPLY_THREAD_INTENT_RE.test(text);
+}
+function shouldCreateInlineReplyThreadDelivery(params) {
+  if (params.mode === "main")
+    return false;
+  if (params.explicitThreadIntent)
+    return true;
+  return params.mode === "thread" && shouldAutoCreateInlineReplyThread({
+    messageId: params.messageId,
+    minMessages: params.minMessages
+  });
+}
 function rewriteNumericMentionsToUsernames(text, senderProfilesById) {
   if (!text.includes("@"))
     return text;
@@ -42500,7 +43738,7 @@ function resolveHistoryLimit(params) {
 }
 function historyEntryDedupeKey(entry) {
   if (entry.messageId)
-    return `id:${entry.messageId}`;
+    return `id:${entry.messageId}:ts:${entry.timestamp ?? "unknown"}`;
   return `ts:${entry.timestamp ?? "unknown"}:${entry.sender}:${entry.body}`;
 }
 function mergeInboundHistoryEntries(params) {
@@ -44025,7 +45263,10 @@ This model will be used for your next message.`, []);
       return;
     }
     let deliveryReplyThreadContext = replyThreadContext;
-    const shouldCreateDeliveryThread = isGroup && replyThreadsEnabled && replyThreadMode === "thread" && !deliveryReplyThreadContext && shouldAutoCreateInlineReplyThread({
+    const explicitReplyThreadIntent = isGroup && replyThreadsEnabled && !deliveryReplyThreadContext && hasExplicitInlineReplyThreadIntent(rawBody);
+    const shouldCreateDeliveryThread = isGroup && replyThreadsEnabled && !deliveryReplyThreadContext && shouldCreateInlineReplyThreadDelivery({
+      mode: replyThreadMode,
+      explicitThreadIntent: explicitReplyThreadIntent,
       messageId: msg.id,
       minMessages: replyThreadAutoCreateMinMessages
     }) && !shouldEditCallbackTargetInPlace;
@@ -44034,7 +45275,15 @@ This model will be used for your next message.`, []);
       if (!shouldCreateDeliveryThread || parentThreadCreationTyping === typing)
         return;
       parentThreadCreationTyping = typing;
-      await client.sendTyping({ chatId: effectiveChatId, typing }).catch((error51) => runtime.error?.(`inline parent reply-thread typing failed: ${String(error51)}`));
+      await sendInlineTypingAndBotPresenceToChats({
+        client,
+        chatIds: [effectiveChatId],
+        typing,
+        presenceKind: typing ? "running" : "idle",
+        onTypingPartialError: (chatId2, error51) => runtime.error?.(`inline parent reply-thread typing failed for chat ${String(chatId2)}: ${String(error51)}`),
+        onPresencePartialError: (chatId2, error51) => runtime.error?.(`inline parent reply-thread bot presence failed for chat ${String(chatId2)}: ${String(error51)}`),
+        onPresenceError: (error51) => runtime.error?.(`inline parent reply-thread bot presence failed: ${String(error51)}`)
+      }).catch((error51) => runtime.error?.(`inline parent reply-thread typing failed: ${String(error51)}`));
     };
     if (shouldCreateDeliveryThread) {
       await setParentThreadCreationTyping(true);
@@ -44303,7 +45552,33 @@ This model will be used for your next message.`, []);
       }
     });
     const onModelSelected = replyPipeline.onModelSelected;
-    const typingCallbacks = replyPipeline.typingCallbacks;
+    const rawTypingCallbacks = replyPipeline.typingCallbacks;
+    const botPresenceLifecycle = createInlineBotPresenceLifecycle({
+      client,
+      chatIds: typingChatIds,
+      onPartialError: (chatId2, error51) => runtime.error?.(`inline bot presence failed for chat ${String(chatId2)}: ${String(error51)}`),
+      onError: (error51) => runtime.error?.(`inline bot presence failed: ${String(error51)}`)
+    });
+    const typingCallbacks = rawTypingCallbacks ? {
+      onReplyStart: async () => {
+        await Promise.all([
+          rawTypingCallbacks.onReplyStart(),
+          botPresenceLifecycle.start()
+        ]);
+      },
+      ...rawTypingCallbacks.onIdle ? {
+        onIdle: () => {
+          rawTypingCallbacks.onIdle?.();
+          botPresenceLifecycle.finish();
+        }
+      } : {},
+      ...rawTypingCallbacks.onCleanup ? {
+        onCleanup: () => {
+          rawTypingCallbacks.onCleanup?.();
+          botPresenceLifecycle.cleanup();
+        }
+      } : {}
+    } : undefined;
     const dispatcherPipelineOptions = {
       ...replyPipeline.responsePrefix !== undefined ? { responsePrefix: replyPipeline.responsePrefix } : {},
       ...replyPipeline.responsePrefixContextProvider ? {
@@ -44541,24 +45816,44 @@ This model will be used for your next message.`, []);
       } : {},
       ...progressPlaceholderEnabled ? {
         onReasoningStream: async () => {
+          botPresenceLifecycle.busy("review");
           await pushInlineProgressPlaceholder();
         }
       } : {},
-      ...streamViaEditMessage || progressPlaceholderEnabled ? {
-        onToolStart: async (payload) => {
-          await resetEditStreamOnBoundary();
-          const toolName = payload.name?.trim();
-          await pushInlineProgressPlaceholder(buildInlineProgressLineForEntry({
-            event: "tool",
-            ...toolName ? { name: toolName } : {},
-            ...payload.phase !== undefined ? { phase: payload.phase } : {},
-            ...payload.args !== undefined ? { args: payload.args } : {}
-          }, payload.detailMode ? { detailMode: payload.detailMode } : undefined), {
-            ...toolName ? { toolName } : {},
-            startImmediately: true
-          });
+      onToolStart: async (payload) => {
+        const toolName = payload.name?.trim();
+        if (toolName === "inline_bot_presence") {
+          return;
         }
-      } : {},
+        botPresenceLifecycle.busy("running");
+        if (!(streamViaEditMessage || progressPlaceholderEnabled))
+          return;
+        await resetEditStreamOnBoundary();
+        await pushInlineProgressPlaceholder(buildInlineProgressLineForEntry({
+          event: "tool",
+          ...toolName ? { name: toolName } : {},
+          ...payload.phase !== undefined ? { phase: payload.phase } : {},
+          ...payload.args !== undefined ? { args: payload.args } : {}
+        }, payload.detailMode ? { detailMode: payload.detailMode } : undefined), {
+          ...toolName ? { toolName } : {},
+          startImmediately: true
+        });
+      },
+      onApprovalEvent: async (payload) => {
+        if (payload.phase !== "requested")
+          return;
+        botPresenceLifecycle.busy("waiting");
+        if (!progressPlaceholderEnabled)
+          return;
+        await pushInlineProgressPlaceholder(buildChannelProgressDraftLine({
+          event: "approval",
+          ...payload.phase !== undefined ? { phase: payload.phase } : {},
+          ...payload.title !== undefined ? { title: payload.title } : {},
+          ...payload.command !== undefined ? { command: payload.command } : {},
+          ...payload.reason !== undefined ? { reason: payload.reason } : {},
+          ...payload.message !== undefined ? { message: payload.message } : {}
+        }), { startImmediately: true });
+      },
       ...progressPlaceholderEnabled ? {
         onItemEvent: async (payload) => {
           await pushInlineProgressPlaceholder(buildInlineProgressLineForEntry({
@@ -44585,18 +45880,6 @@ This model will be used for your next message.`, []);
             ...payload.steps !== undefined ? { steps: payload.steps } : {}
           }));
         },
-        onApprovalEvent: async (payload) => {
-          if (payload.phase !== "requested")
-            return;
-          await pushInlineProgressPlaceholder(buildChannelProgressDraftLine({
-            event: "approval",
-            ...payload.phase !== undefined ? { phase: payload.phase } : {},
-            ...payload.title !== undefined ? { title: payload.title } : {},
-            ...payload.command !== undefined ? { command: payload.command } : {},
-            ...payload.reason !== undefined ? { reason: payload.reason } : {},
-            ...payload.message !== undefined ? { message: payload.message } : {}
-          }), { startImmediately: true });
-        },
         onCommandOutput: async (payload) => {
           if (payload.phase !== "end")
             return;
@@ -44624,22 +45907,24 @@ This model will be used for your next message.`, []);
           }));
         }
       } : {},
-      ...streamViaEditMessage || progressPlaceholderEnabled ? {
-        onCompactionStart: async () => {
-          await resetEditStreamOnBoundary();
-          await pushInlineProgressPlaceholder("Compacting context", {
-            startImmediately: true
-          });
-        }
-      } : {},
-      ...streamViaEditMessage || progressPlaceholderEnabled ? {
-        onCompactionEnd: async () => {
-          await resetEditStreamOnBoundary();
-          await pushInlineProgressPlaceholder("Resuming", {
-            startImmediately: true
-          });
-        }
-      } : {},
+      onCompactionStart: async () => {
+        botPresenceLifecycle.busy("review");
+        if (!(streamViaEditMessage || progressPlaceholderEnabled))
+          return;
+        await resetEditStreamOnBoundary();
+        await pushInlineProgressPlaceholder("Compacting context", {
+          startImmediately: true
+        });
+      },
+      onCompactionEnd: async () => {
+        botPresenceLifecycle.busy("running");
+        if (!(streamViaEditMessage || progressPlaceholderEnabled))
+          return;
+        await resetEditStreamOnBoundary();
+        await pushInlineProgressPlaceholder("Resuming", {
+          startImmediately: true
+        });
+      },
       ...suppressDefaultToolProgressMessages ? { suppressDefaultToolProgressMessages: true } : {},
       ...progressPlaceholderEnabled ? { allowProgressCallbacksWhenSourceDeliverySuppressed: true } : {},
       ...typeof disableBlockStreaming === "boolean" ? { disableBlockStreaming } : {}
@@ -44657,6 +45942,10 @@ This model will be used for your next message.`, []);
             ...dispatcherPipelineOptions,
             ...buildInlineTypingDispatcherOptions(typingCallbacks),
             deliver: async (payload, info) => {
+              const presenceSignal = resolveInlineBotPresenceSignal(payload);
+              if (presenceSignal) {
+                botPresenceLifecycle.express(presenceSignal);
+              }
               const visiblePayload = resolveInlineChatVisibleReplyPayload(payload);
               if (!visiblePayload)
                 return;
@@ -44811,6 +46100,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             },
             onError: (err, info) => {
               failedNonSilent = true;
+              botPresenceLifecycle.fail();
               runtime.error?.(`inline ${info?.kind ?? "final"} reply failed: ${String(err)}`);
             }
           },
@@ -44818,6 +46108,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         });
       } catch (error51) {
         dispatchError = error51;
+        botPresenceLifecycle.fail();
         runtime.error?.(`inline dispatch failed: ${String(error51)}`);
       }
       await cleanupInlineProgressPlaceholder();
@@ -44825,6 +46116,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         delivered = true;
       }
       if (!delivered && (dispatchError != null || skippedNonSilent || failedNonSilent)) {
+        botPresenceLifecycle.fail();
         const fallbackText = dispatchError != null ? INLINE_REQUEST_ERROR_FALLBACK : EMPTY_RESPONSE_FALLBACK;
         const sent = await client.sendMessage({
           chatId: deliveryChatId,
@@ -47358,6 +48650,7 @@ var inlineChannelPlugin = {
       "- Inline targeting: omit `target` to reply in the current chat.",
       "- Inline explicit targets: `chat:<chatId>` for chats and `user:<userId>` for direct users. Prefer `user:` for DM user targets.",
       "- Inline discovery: use `channel-list` to discover available chats and users. Use `scope: groups|peers|all` when helpful, and reuse returned `target` values.",
+      "- Inline markdown links: in visible replies, link returned users as `[@name](inline://user?id=<userId>)` and returned chats/threads as `[title](inline://chat?id=<chatId>)` or `[title](inline://thread?id=<chatId>)`. Use `target` values only for tool calls.",
       ...supportsInlineMessageButtonsForConfig(cfg, accountId ?? null) ? [
         "- Prefer Inline buttons/selects for 2-5 discrete choices or parameter picks instead of asking the user to type one. Use `presentation` blocks for shared buttons/selects, or `buttons` rows for simple callback buttons."
       ] : [],
@@ -47365,7 +48658,14 @@ var inlineChannelPlugin = {
         "- Inline reactions: pass `messageId` for `react` when you have it; on inbound turns, the current inbound message id can be used as fallback."
       ] : [],
       "- Inline history tools: `read` and `search` return media-aware message payloads (`media`, `attachments`, `attachmentUrls`) so image-only history remains discoverable. `search` is chat-scoped; run it per chat.",
-      "- Inline special tools: use `inline_nudge` to send a nudge, and `inline_forward` to forward message ids between chats or users.",
+      "- Inline special tools: use `inline_nudge` to send a nudge, `inline_forward` to forward message ids between chats or users, and `inline_bot_presence` to move or emote through your on-screen body without sending a chat message.",
+      "- Inline bot avatar setup: use `inline_bot_avatar` only when the user explicitly asks you to install or replace your on-screen avatar from a provided local/remote zip package. Do not call it during ordinary chat, do not invent file paths, and do not use it for mood/state changes.",
+      "- Inline botPresence is your literal on-screen character/body in Inline, not another answer channel. Treat `kind` as your body pose/mood and `comment` as a tiny thought bubble or body-language caption.",
+      "- Inline botPresence states: use `waving` for greetings/attention, `jumping` for delight or completion, `review` for inspecting/thinking, `waiting` when asking the human, `failed` when blocked or disappointed, `running` for active focused work, `happy` for positive/settled moments, and `idle` only when neutral is intentionally useful. Do not use it to hide yourself.",
+      "- Inline botPresence comments: include a generated `comment` when it helps the human understand your current mood, thought, status, request, nudge, or small aside. Keep it casual, short, characterful, and true to what you are doing or feeling; under 30 characters. Text or one/two emoji characters are both fine. It should supplement the full chat answer, not replace substantive answers.",
+      "- Inline botPresence is cheap to call during active work. Use it when your thought/body state changes or when a tiny status would make you easier to read; avoid repeated identical updates, fixed-timer filler, or static comments.",
+      "- Inline botPresence final beat: before your final chat message in active Inline chats, make one last `inline_bot_presence` call whenever there is a real final expression to show. Do this for greetings (`waving`, `hey \uD83D\uDC4B` or `\uD83D\uDC4B`), weather/status answers (`happy`, `☀️ 72°` or `rainy ☔️`), completed longer work (`jumping`, `phew, done!`), blockers (`failed`, short reason), or requests for user input (`waiting`, short ask). Then send the normal full chat answer. Do not send `idle` just to clean up; the client quiets the presence later.",
+      "- Inline botPresence in messages: when you are already sending a message, you may also set `channelData.inline.botPresence` with the same `kind` and `comment` fields.",
       "- Inline reply threads: use normal `reply` for short or newly started parent-chat conversations unless the user asks for a thread.",
       "- Inline reply threads: use `thread-create` to create or reuse a real reply thread under the current/target chat. On parent-chat inbound turns, omit `messageId` to anchor it to the current message, or pass `messageId`/`parentMessageId` explicitly.",
       "- Inline reply threads: use `thread-reply` to send into a real reply thread, with `threadId` set to the reply-thread chat id returned by `thread-create`. Reuse that `threadId` only for the same reply-thread session; unrelated parent-chat messages need separate parent-message anchors.",
@@ -47733,5 +49033,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=93A450B5B900350964756E2164756E21
+//# debugId=3B872041BDFC897564756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map