@inline-openclaw/inline 0.0.44 → 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);
@@ -11192,7 +11445,8 @@ class UpdateSidecars$Type extends import_runtime4.MessageType {
     super("UpdateSidecars", [
       { no: 1, name: "users", kind: "message", repeat: 1, T: () => User },
       { no: 2, name: "chats", kind: "message", repeat: 1, T: () => Chat },
-      { no: 3, name: "dialogs", kind: "message", repeat: 1, T: () => Dialog }
+      { no: 3, name: "dialogs", kind: "message", repeat: 1, T: () => Dialog },
+      { no: 4, name: "spaces", kind: "message", repeat: 1, T: () => Space }
     ]);
   }
   create(value) {
@@ -11200,6 +11454,7 @@ class UpdateSidecars$Type extends import_runtime4.MessageType {
     message.users = [];
     message.chats = [];
     message.dialogs = [];
+    message.spaces = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -11218,6 +11473,9 @@ class UpdateSidecars$Type extends import_runtime4.MessageType {
         case 3:
           message.dialogs.push(Dialog.internalBinaryRead(reader, reader.uint32(), options));
           break;
+        case 4:
+          message.spaces.push(Space.internalBinaryRead(reader, reader.uint32(), options));
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -11236,6 +11494,8 @@ class UpdateSidecars$Type extends import_runtime4.MessageType {
       Chat.internalBinaryWrite(message.chats[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     for (let i = 0;i < message.dialogs.length; i++)
       Dialog.internalBinaryWrite(message.dialogs[i], writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.spaces.length; i++)
+      Space.internalBinaryWrite(message.spaces[i], 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);
@@ -12022,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", [
@@ -12452,20 +12803,357 @@ class DeleteBotResult$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var DeleteBotResult = new DeleteBotResult$Type;
+var DeleteBotResult = new DeleteBotResult$Type;
+
+class DeleteMessageAttachmentInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("DeleteMessageAttachmentInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "attachment_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.messageId = 0n;
+    message.attachmentId = 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.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.attachmentId = 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.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.messageId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
+    if (message.attachmentId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.attachmentId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var DeleteMessageAttachmentInput = new DeleteMessageAttachmentInput$Type;
+
+class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("DeleteMessageAttachmentResult", [
+      { 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 DeleteMessageAttachmentResult = new DeleteMessageAttachmentResult$Type;
+
+class RevokeSessionInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevokeSessionInput", [
+      { no: 1, name: "session_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.sessionId = 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.sessionId = 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.sessionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.sessionId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevokeSessionInput = new RevokeSessionInput$Type;
+
+class RevokeSessionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevokeSessionResult", [
+      { no: 1, name: "revoked", kind: "scalar", T: 8 },
+      { no: 2, name: "already_revoked", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.revoked = false;
+    message.alreadyRevoked = 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.revoked = reader.bool();
+          break;
+        case 2:
+          message.alreadyRevoked = 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.revoked !== false)
+      writer.tag(1, import_runtime.WireType.Varint).bool(message.revoked);
+    if (message.alreadyRevoked !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.alreadyRevoked);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevokeSessionResult = new RevokeSessionResult$Type;
+
+class BotCommand$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotCommand", [
+      { no: 1, name: "command", kind: "scalar", T: 9 },
+      { no: 2, name: "description", kind: "scalar", T: 9 },
+      { no: 3, name: "sort_order", kind: "scalar", opt: true, T: 5 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.command = "";
+    message.description = "";
+    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.command = reader.string();
+          break;
+        case 2:
+          message.description = reader.string();
+          break;
+        case 3:
+          message.sortOrder = 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.command !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.command);
+    if (message.description !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.sortOrder !== undefined)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.sortOrder);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotCommand = new BotCommand$Type;
+
+class PeerBotCommands$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("PeerBotCommands", [
+      { no: 1, name: "bot", kind: "message", T: () => User },
+      { no: 2, 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.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
+          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.bot)
+      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    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 PeerBotCommands = new PeerBotCommands$Type;
+
+class GetBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotCommandsInput", [
+      { 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 GetBotCommandsInput = new GetBotCommandsInput$Type;
 
-class DeleteMessageAttachmentInput$Type extends import_runtime4.MessageType {
+class GetBotCommandsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("DeleteMessageAttachmentInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
-      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
-      { no: 3, name: "attachment_id", kind: "scalar", T: 3, L: 0 }
+    super("GetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.messageId = 0n;
-    message.attachmentId = 0n;
+    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12476,13 +13164,55 @@ class DeleteMessageAttachmentInput$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.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
-        case 2:
-          message.messageId = reader.int64().toBigInt();
+        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 3:
-          message.attachmentId = reader.int64().toBigInt();
+        case 2:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -12496,29 +13226,27 @@ class DeleteMessageAttachmentInput$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.messageId !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
-    if (message.attachmentId !== 0n)
-      writer.tag(3, import_runtime.WireType.Varint).int64(message.attachmentId);
+    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 DeleteMessageAttachmentInput = new DeleteMessageAttachmentInput$Type;
+var SetBotCommandsInput = new SetBotCommandsInput$Type;
 
-class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
+class SetBotCommandsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("DeleteMessageAttachmentResult", [
-      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    super("SetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.updates = [];
+    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12529,7 +13257,7 @@ class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -12543,25 +13271,24 @@ class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.updates.length; i++)
-      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    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 DeleteMessageAttachmentResult = new DeleteMessageAttachmentResult$Type;
+var SetBotCommandsResult = new SetBotCommandsResult$Type;
 
-class RevokeSessionInput$Type extends import_runtime4.MessageType {
+class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevokeSessionInput", [
-      { no: 1, name: "session_id", kind: "scalar", T: 3, L: 0 }
+    super("GetPeerBotCommandsInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.sessionId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12572,7 +13299,7 @@ class RevokeSessionInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.sessionId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         default:
           let u = options.readUnknownField;
@@ -12586,27 +13313,25 @@ class RevokeSessionInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.sessionId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.sessionId);
+    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 RevokeSessionInput = new RevokeSessionInput$Type;
+var GetPeerBotCommandsInput = new GetPeerBotCommandsInput$Type;
 
-class RevokeSessionResult$Type extends import_runtime4.MessageType {
+class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevokeSessionResult", [
-      { no: 1, name: "revoked", kind: "scalar", T: 8 },
-      { no: 2, name: "already_revoked", kind: "scalar", T: 8 }
+    super("GetPeerBotCommandsResult", [
+      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.revoked = false;
-    message.alreadyRevoked = false;
+    message.bots = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12617,10 +13342,7 @@ class RevokeSessionResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.revoked = reader.bool();
-          break;
-        case 2:
-          message.alreadyRevoked = reader.bool();
+          message.bots.push(PeerBotCommands.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -12634,30 +13356,25 @@ class RevokeSessionResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.revoked !== false)
-      writer.tag(1, import_runtime.WireType.Varint).bool(message.revoked);
-    if (message.alreadyRevoked !== false)
-      writer.tag(2, import_runtime.WireType.Varint).bool(message.alreadyRevoked);
+    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 RevokeSessionResult = new RevokeSessionResult$Type;
+var GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
 
-class BotCommand$Type extends import_runtime4.MessageType {
+class RevealBotTokenInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("BotCommand", [
-      { no: 1, name: "command", kind: "scalar", T: 9 },
-      { no: 2, name: "description", kind: "scalar", T: 9 },
-      { no: 3, name: "sort_order", kind: "scalar", opt: true, T: 5 }
+    super("RevealBotTokenInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.command = "";
-    message.description = "";
+    message.botUserId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12668,13 +13385,7 @@ class BotCommand$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.command = reader.string();
-          break;
-        case 2:
-          message.description = reader.string();
-          break;
-        case 3:
-          message.sortOrder = reader.int32();
+          message.botUserId = reader.int64().toBigInt();
           break;
         default:
           let u = options.readUnknownField;
@@ -12688,30 +13399,25 @@ class BotCommand$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.command !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.command);
-    if (message.description !== "")
-      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.description);
-    if (message.sortOrder !== undefined)
-      writer.tag(3, import_runtime.WireType.Varint).int32(message.sortOrder);
+    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 BotCommand = new BotCommand$Type;
+var RevealBotTokenInput = new RevealBotTokenInput$Type;
 
-class PeerBotCommands$Type extends import_runtime4.MessageType {
+class RevealBotTokenResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("PeerBotCommands", [
-      { no: 1, name: "bot", kind: "message", T: () => User },
-      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("RevealBotTokenResult", [
+      { 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;
@@ -12722,10 +13428,7 @@ class PeerBotCommands$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
-          break;
-        case 2:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.token = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12739,21 +13442,19 @@ class PeerBotCommands$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.bot)
-      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    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.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 PeerBotCommands = new PeerBotCommands$Type;
+var RevealBotTokenResult = new RevealBotTokenResult$Type;
 
-class GetBotCommandsInput$Type extends import_runtime4.MessageType {
+class RotateBotTokenInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetBotCommandsInput", [
+    super("RotateBotTokenInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
@@ -12792,17 +13493,17 @@ class GetBotCommandsInput$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var GetBotCommandsInput = new GetBotCommandsInput$Type;
+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;
@@ -12813,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;
@@ -12827,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;
@@ -12861,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;
@@ -12877,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;
@@ -12906,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;
@@ -12920,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;
@@ -12948,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;
@@ -12962,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;
@@ -12991,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;
@@ -13005,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 }
     ]);
   }
@@ -13056,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;
@@ -13077,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;
@@ -13091,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;
@@ -13120,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;
@@ -13134,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;
@@ -13163,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;
@@ -13177,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;
@@ -13208,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;
@@ -13228,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);
@@ -13255,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() {
@@ -16422,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) {
@@ -16647,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")
@@ -16731,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);
@@ -17591,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", [
@@ -18116,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", [
@@ -21056,7 +21910,7 @@ class InlineSdkClient {
       await this.handleUpdate(update);
     }
   }
-  async handleUpdate(update) {
+  async handleUpdate(update, options) {
     const seq = update.seq ?? 0;
     const date = update.date ?? 0n;
     switch (update.update.oneofKind) {
@@ -21188,6 +22042,34 @@ class InlineSdkClient {
         });
         return;
       }
+      case "participantAdd": {
+        const payload = update.update.participantAdd;
+        if (options?.source !== "user" && options?.source !== "space") {
+          this.bumpChatSeq(payload.chatId, seq);
+        }
+        await this.eventStream.send({
+          kind: "chat.participant.add",
+          chatId: payload.chatId,
+          ...payload.participant ? { participant: payload.participant } : {},
+          seq,
+          date
+        });
+        return;
+      }
+      case "participantDelete": {
+        const payload = update.update.participantDelete;
+        if (options?.source !== "user" && options?.source !== "space") {
+          this.bumpChatSeq(payload.chatId, seq);
+        }
+        await this.eventStream.send({
+          kind: "chat.participant.delete",
+          chatId: payload.chatId,
+          userId: payload.userId,
+          seq,
+          date
+        });
+        return;
+      }
       case "messageActionInvoked": {
         const payload = update.update.messageActionInvoked;
         if (this.shouldSkipUserSeq(seq)) {
@@ -21288,14 +22170,14 @@ class InlineSdkClient {
     }
   }
   requestCatchUpUser() {
-    const lastUserSeq = this.state.lastUserSeq ?? 0;
-    if (lastUserSeq <= 0) {
+    const lastUserSeq = this.state.lastUserSeq;
+    if (lastUserSeq == null && !this.options.catchUpUserFromStart) {
       return;
     }
     if (this.userCatchUpInFlight) {
       return;
     }
-    this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq).catch((error) => {
+    this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq ?? 0).catch((error) => {
       this.log.warn?.("GET_UPDATES user catch-up failed; continuing live delivery", {
         error: extractErrorMessage(error)
       });
@@ -21336,7 +22218,7 @@ class InlineSdkClient {
         return;
       }
       for (const update of payload.updates) {
-        await this.handleUpdate(update);
+        await this.handleUpdate(update, { source: "user" });
       }
       this.bumpUserSeq(deliveredSeq);
       if (payload.date !== 0n) {
@@ -21435,7 +22317,7 @@ class InlineSdkClient {
       }
       this.bumpChatSeq(chatId, deliveredSeq);
       for (const update of payload.updates) {
-        await this.handleUpdate(update);
+        await this.handleUpdate(update, { source: "chat" });
       }
       if (payload.date !== 0n) {
         this.state.dateCursor = payload.date;
@@ -21537,7 +22419,7 @@ class InlineSdkClient {
       }
       this.bumpSpaceSeq(spaceId, deliveredSeq);
       for (const update of payload.updates) {
-        await this.handleUpdate(update);
+        await this.handleUpdate(update, { source: "space" });
       }
       if (payload.date !== 0n) {
         this.state.dateCursor = payload.date;
@@ -36472,6 +37354,8 @@ var InlineExecApprovalsSchema = exports_external.object({
 var InlineReactionNotificationsSchema = exports_external.enum(["off", "own", "all", "allowlist"]);
 var InlineStreamingModeSchema = exports_external.enum(["off", "partial", "block", "progress"]);
 var InlineStreamingCommandTextSchema = exports_external.enum(["raw", "status"]);
+var INLINE_DEFAULT_GROUP_POLICY = "open";
+var INLINE_DEFAULT_REQUIRE_MENTION = true;
 var InlineStreamingChunkSchema = exports_external.object({
   minChars: exports_external.number().int().positive().optional(),
   maxChars: exports_external.number().int().positive().optional(),
@@ -36543,7 +37427,7 @@ var InlineAccountSchemaBase = exports_external.object({
   defaultTo: InlineTargetSchema.optional(),
   systemPrompt: exports_external.string().optional(),
   groupAllowFrom: exports_external.array(InlineAllowEntrySchema).optional(),
-  groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+  groupPolicy: GroupPolicySchema.optional().default(INLINE_DEFAULT_GROUP_POLICY),
   groups: exports_external.record(exports_external.string(), InlineGroupSchema.optional()).optional(),
   requireMention: exports_external.boolean().optional(),
   replyThreadMode: InlineReplyThreadModeSchema.optional(),
@@ -37042,7 +37926,7 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
 }
 
 // src/inline/monitor.ts
-import { mkdir } from "node:fs/promises";
+import { mkdir, stat } from "node:fs/promises";
 import path4 from "node:path";
 import {
   buildCommandTextFromArgs,
@@ -37480,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,
@@ -37491,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();
@@ -37659,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";
   }
@@ -37700,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);
   }
@@ -37752,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":
@@ -37796,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";
@@ -38533,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,
@@ -39289,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,
@@ -40897,11 +41887,339 @@ function redactInlineBotApiUrl(raw) {
   }
 }
 
+// src/inline/threadreply-command.ts
+var MODE_LABELS = {
+  auto: "auto",
+  thread: "thread",
+  main: "main"
+};
+var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES = 50;
+var INLINE_THREADREPLY_NATIVE_NAME = "threadreply";
+var INLINE_THREADREPLY_COMMAND_SPEC = {
+  name: "threadreply",
+  nativeNames: { inline: INLINE_THREADREPLY_NATIVE_NAME },
+  description: "Set Inline reply-thread mode for this chat.",
+  channels: ["inline"],
+  acceptsArgs: true
+};
+function listInlineBuiltinCommandSpecs() {
+  return [
+    {
+      name: INLINE_THREADREPLY_COMMAND_SPEC.nativeNames.inline ?? INLINE_THREADREPLY_COMMAND_SPEC.name,
+      description: INLINE_THREADREPLY_COMMAND_SPEC.description,
+      acceptsArgs: INLINE_THREADREPLY_COMMAND_SPEC.acceptsArgs
+    }
+  ];
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asInlineConfig(value) {
+  return isRecord5(value) ? value : undefined;
+}
+function normalizeMode(raw) {
+  if (typeof raw !== "string")
+    return null;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "on" || normalized === "threads")
+    return "thread";
+  if (normalized === "off" || normalized === "parent" || normalized === "parentchat")
+    return "main";
+  if (normalized === "auto" || normalized === "thread" || normalized === "main")
+    return normalized;
+  return null;
+}
+function normalizeMin(raw) {
+  if (typeof raw !== "number")
+    return null;
+  if (!Number.isInteger(raw) || raw < 0)
+    return null;
+  return raw;
+}
+function parseMinArg(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (!value)
+    return null;
+  if (value === "inherit" || value === "default" || value === "unset")
+    return "inherit";
+  if (!/^\d+$/.test(value))
+    return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function resolveInlineGroupId(ctx) {
+  const raw = ctx.from?.trim() ?? "";
+  if (!/(^|:)chat:/i.test(raw))
+    return null;
+  const normalized = normalizeInlineTarget(raw);
+  return normalized && /^[0-9]+$/.test(normalized) ? normalized : null;
+}
+function resolveInlineConfigForAccount(inline, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  const accounts = isRecord5(inline.accounts) ? inline.accounts : undefined;
+  const accountKey = accounts ? Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized) : undefined;
+  if (accountKey && accounts?.[accountKey]) {
+    return accounts[accountKey];
+  }
+  if (normalized !== DEFAULT_ACCOUNT_ID) {
+    return {};
+  }
+  return inline;
+}
+function resolveCurrentMode(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline) ?? {};
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  return resolveInlineGroupReplyThreadMode({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null,
+    groupId: params.groupId,
+    defaultMode: normalizeMode(accountConfig.replyThreadMode) ?? "auto"
+  });
+}
+function resolveCurrentMinMessages(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline) ?? {};
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  return resolveInlineGroupReplyThreadAutoCreateMinMessages({
+    cfg: params.cfg,
+    accountId: params.accountId ?? null,
+    groupId: params.groupId,
+    defaultMinMessages: normalizeMin(accountConfig.replyThreadAutoCreateMinMessages) ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
+  });
+}
+function readExplicitMode(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline);
+  if (!inline)
+    return null;
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  const group = accountConfig.groups?.[params.groupId];
+  return normalizeMode(group?.replyThreadMode);
+}
+function readExplicitMinMessages(params) {
+  const inline = asInlineConfig(params.cfg.channels?.inline);
+  if (!inline)
+    return null;
+  const accountConfig = resolveInlineConfigForAccount(inline, params.accountId);
+  const group = accountConfig.groups?.[params.groupId];
+  return normalizeMin(group?.replyThreadAutoCreateMinMessages);
+}
+function ensureRecordField(parent, key) {
+  const current = parent[key];
+  if (isRecord5(current))
+    return current;
+  const next = {};
+  parent[key] = next;
+  return next;
+}
+function resolveMutableInlineConfigForAccount(inline, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  if (normalized === DEFAULT_ACCOUNT_ID) {
+    const accounts2 = isRecord5(inline.accounts) ? inline.accounts : undefined;
+    const defaultKey = accounts2 ? Object.keys(accounts2).find((key) => normalizeAccountId(key) === DEFAULT_ACCOUNT_ID) : undefined;
+    const defaultAccount = defaultKey ? accounts2?.[defaultKey] : undefined;
+    return defaultAccount ?? inline;
+  }
+  const accounts = ensureRecordField(inline, "accounts");
+  const accountKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized) ?? normalized;
+  const account = asInlineConfig(accounts[accountKey]) ?? {};
+  accounts[accountKey] = account;
+  return account;
+}
+function setGroupMode(params) {
+  const root = params.draft;
+  const channels = root.channels ?? {};
+  root.channels = channels;
+  const inline = asInlineConfig(channels.inline) ?? {};
+  channels.inline = inline;
+  const accountConfig = resolveMutableInlineConfigForAccount(inline, params.accountId);
+  const groups = ensureRecordField(accountConfig, "groups");
+  const group = isRecord5(groups[params.groupId]) ? groups[params.groupId] : {};
+  groups[params.groupId] = group;
+  if (params.mode === "inherit") {
+    delete group.replyThreadMode;
+    return;
+  }
+  group.replyThreadMode = params.mode;
+}
+function setGroupMinMessages(params) {
+  const root = params.draft;
+  const channels = root.channels ?? {};
+  root.channels = channels;
+  const inline = asInlineConfig(channels.inline) ?? {};
+  channels.inline = inline;
+  const accountConfig = resolveMutableInlineConfigForAccount(inline, params.accountId);
+  const groups = ensureRecordField(accountConfig, "groups");
+  const group = isRecord5(groups[params.groupId]) ? groups[params.groupId] : {};
+  groups[params.groupId] = group;
+  if (params.minMessages === "inherit") {
+    delete group.replyThreadAutoCreateMinMessages;
+    return;
+  }
+  group.replyThreadAutoCreateMinMessages = params.minMessages;
+}
+function buildStatusText(params) {
+  const explicit = readExplicitMode(params);
+  const current = resolveCurrentMode(params);
+  const explicitMin = readExplicitMinMessages(params);
+  const currentMin = resolveCurrentMinMessages(params);
+  return [
+    `Thread reply mode for chat ${params.groupId}: ${MODE_LABELS[current]}.`,
+    explicit ? `Explicit chat override: ${MODE_LABELS[explicit]}.` : "Explicit chat override: inherit.",
+    `Auto-create minimum messages: ${currentMin}.`,
+    explicitMin != null ? `Explicit minimum override: ${explicitMin}.` : "Explicit minimum override: inherit."
+  ].join(`
+`);
+}
+function buildMenuText(params) {
+  return [
+    buildStatusText(params),
+    "",
+    "Choose where automatic replies for this group should go."
+  ].join(`
+`);
+}
+function buildModeButtons() {
+  return {
+    inline: {
+      buttons: [
+        [
+          { text: "Thread", callback_data: "/threadreply thread" },
+          { text: "Main", callback_data: "/threadreply main" },
+          { text: "Auto", callback_data: "/threadreply auto" }
+        ],
+        [{ text: "Inherit Mode", callback_data: "/threadreply inherit" }],
+        [
+          { text: "Min 0", callback_data: "/threadreply min 0" },
+          { text: "Min 50", callback_data: "/threadreply min 50" },
+          { text: "Inherit Min", callback_data: "/threadreply min inherit" }
+        ]
+      ]
+    }
+  };
+}
+function normalizeAction(args) {
+  const [first = ""] = args.split(/\s+/).filter(Boolean);
+  const normalized = first.trim().toLowerCase();
+  if (!normalized || normalized === "help" || normalized === "options")
+    return "help";
+  if (normalized === "status" || normalized === "show")
+    return "status";
+  if (normalized === "inherit" || normalized === "default" || normalized === "unset")
+    return "inherit";
+  return normalizeMode(normalized);
+}
+async function handleInlineThreadReplyCommand(api2, ctx) {
+  return await handleInlineThreadReplyCommandWithConfigRuntime(api2.runtime.config, ctx);
+}
+async function handleInlineThreadReplyCommandWithConfigRuntime(configRuntime, ctx) {
+  if (!ctx.isAuthorizedSender) {
+    return { text: "This command requires authorization." };
+  }
+  const groupId = resolveInlineGroupId(ctx);
+  if (!groupId) {
+    return { text: "/threadreply is only available in Inline group chats." };
+  }
+  const currentConfig = configRuntime.current();
+  const args = ctx.args?.trim() ?? "";
+  const [first = "", second, ...rest] = args.split(/\s+/).filter(Boolean);
+  if (["min", "minimum", "threshold", "limit"].includes(first.trim().toLowerCase())) {
+    const minMessages = parseMinArg(second);
+    if (minMessages == null || rest.length > 0) {
+      return { text: "Usage: /threadreply min <0-or-greater>|inherit" };
+    }
+    const committed2 = await configRuntime.mutateConfigFile({
+      afterWrite: { mode: "auto" },
+      mutate: (draft) => {
+        setGroupMinMessages({
+          draft,
+          accountId: ctx.accountId,
+          groupId,
+          minMessages
+        });
+      }
+    });
+    const nextConfig2 = committed2.nextConfig;
+    return {
+      text: buildStatusText({
+        cfg: nextConfig2,
+        accountId: ctx.accountId,
+        groupId
+      })
+    };
+  }
+  const action = normalizeAction(args);
+  if (action === "help") {
+    return {
+      text: buildMenuText({
+        cfg: currentConfig,
+        accountId: ctx.accountId,
+        groupId
+      }),
+      channelData: buildModeButtons()
+    };
+  }
+  if (action === "status") {
+    return {
+      text: buildStatusText({
+        cfg: currentConfig,
+        accountId: ctx.accountId,
+        groupId
+      })
+    };
+  }
+  if (!action) {
+    return {
+      text: [
+        "Usage: /threadreply thread|main|auto|inherit|status",
+        "       /threadreply min <0-or-greater>|inherit",
+        "",
+        "- thread: auto-route parent-chat replies into per-message Inline reply threads once the minimum is reached.",
+        "- main: keep automatic replies in the parent chat.",
+        "- auto: use Inline's automatic default behavior for this chat.",
+        "- inherit: remove this chat override and use account/default config.",
+        "- min: set how many parent-chat messages must exist before automatic thread creation."
+      ].join(`
+`)
+    };
+  }
+  const committed = await configRuntime.mutateConfigFile({
+    afterWrite: { mode: "auto" },
+    mutate: (draft) => {
+      setGroupMode({
+        draft,
+        accountId: ctx.accountId,
+        groupId,
+        mode: action
+      });
+    }
+  });
+  const nextConfig = committed.nextConfig;
+  return {
+    text: buildStatusText({
+      cfg: nextConfig,
+      accountId: ctx.accountId,
+      groupId
+    })
+  };
+}
+function createInlineThreadReplyCommand(api2) {
+  return {
+    ...INLINE_THREADREPLY_COMMAND_SPEC,
+    handler: async (ctx) => await handleInlineThreadReplyCommand(api2, ctx)
+  };
+}
+
 // src/inline/bot-commands-sync.ts
 var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
 var INLINE_COMMAND_LIMIT = 100;
 var INLINE_COMMAND_DESCRIPTION_LIMIT = 256;
 var INLINE_NATIVE_COMMAND_PROVIDER = "inline";
+function resolveInlineChannelCommands(cfg) {
+  const inline = cfg.channels?.inline;
+  if (typeof inline !== "object" || inline === null || Array.isArray(inline))
+    return;
+  const commands = inline.commands;
+  return typeof commands === "object" && commands !== null && !Array.isArray(commands) ? commands : undefined;
+}
 function normalizeDynamicCommandName(raw) {
   const trimmed = raw.trim().toLowerCase();
   const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
@@ -40922,11 +42240,11 @@ function appendUniqueCommand(out, seen, command, description, logger) {
   out.push({ command: normalized, description: trimmedDescription });
 }
 function shouldSyncInlineNativeCommandsForAccount(params) {
-  const effective = params.account.config.commands?.native ?? params.cfg.commands?.native ?? "auto";
+  const effective = params.account.config.commands?.native ?? resolveInlineChannelCommands(params.cfg)?.native ?? params.cfg.commands?.native ?? "auto";
   return effective !== false;
 }
 function shouldSyncInlineNativeSkillsForAccount(params) {
-  const effective = params.account.config.commands?.nativeSkills ?? params.cfg.commands?.nativeSkills ?? "auto";
+  const effective = params.account.config.commands?.nativeSkills ?? resolveInlineChannelCommands(params.cfg)?.nativeSkills ?? params.cfg.commands?.nativeSkills ?? "auto";
   return effective !== false;
 }
 async function buildInlineNativeCommandsForConfig(params) {
@@ -40943,7 +42261,10 @@ async function buildInlineNativeCommandsForConfig(params) {
     skillCommands,
     provider: INLINE_NATIVE_COMMAND_PROVIDER
   });
-  const pluginSpecs = getPluginCommandSpecs("inline", { config: params.cfg });
+  const pluginSpecs = [
+    ...getPluginCommandSpecs("inline", { config: params.cfg }),
+    ...listInlineBuiltinCommandSpecs()
+  ];
   const seen = new Set;
   const resolved = [];
   for (const spec of nativeSpecs) {
@@ -41047,9 +42368,17 @@ var INLINE_NATIVE_COMMAND_PROVIDER2 = CHANNEL_ID;
 var INLINE_NATIVE_COMMAND_CALLBACK_PREFIX = "icmd:";
 var INLINE_REQUEST_ERROR_FALLBACK = "OpenClaw could not process that request. Please try again.";
 var INLINE_DEBOUNCE_ERROR_FALLBACK = "OpenClaw could not process those messages. Please try again.";
-var DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES = 50;
+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 {};
@@ -41095,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}`;
@@ -41362,6 +42951,23 @@ function buildInlineReactionContextKey(params) {
   const emoji3 = params.emoji.trim() || "emoji";
   return `inline:reaction:${params.action}:${String(params.chatId)}:${String(params.messageId)}:${String(params.senderId)}:${emoji3}`;
 }
+function describeInlineParticipantAddSystemEvent(params) {
+  const header = `Inline bot was added as a participant in ${params.channelLabel}.`;
+  if (params.recentLines.length === 0)
+    return header;
+  return `${header}
+Recent messages before join:
+${params.recentLines.join(`
+`)}`;
+}
+function buildInlineParticipantAddContextKey(params) {
+  return [
+    "inline:participant:added",
+    String(params.chatId),
+    String(params.userId),
+    params.participantDate != null ? String(params.participantDate) : String(params.seq ?? 0)
+  ].join(":");
+}
 function normalizeInlineUsername(raw) {
   const trimmed = raw?.trim();
   if (!trimmed)
@@ -41403,6 +43009,28 @@ function parseInlineNativeCommandCallbackData(raw) {
   const commandText = trimmed.slice(INLINE_NATIVE_COMMAND_CALLBACK_PREFIX.length).trim();
   return commandText.startsWith("/") ? commandText : null;
 }
+function listHostInlinePluginCommandSpecs(cfg) {
+  return getPluginCommandSpecs2("inline", { config: cfg });
+}
+function listInlinePluginCommandSpecs(cfg) {
+  return [
+    ...listHostInlinePluginCommandSpecs(cfg),
+    ...listInlineBuiltinCommandSpecs()
+  ];
+}
+function hasInlineCommandSpec(specs, commandName) {
+  const normalized = commandName.trim().toLowerCase();
+  if (!normalized)
+    return false;
+  return specs.some((spec) => spec.name.trim().toLowerCase() === normalized);
+}
+function isInlineThreadReplyCommandBody(commandBody) {
+  return resolveInlineCommandNameFromBody(commandBody) === "threadreply";
+}
+function parseInlineCommandArgs(commandBody) {
+  const match = commandBody.trim().match(/^\/[^\s]+(?:\s+([\s\S]*))?$/);
+  return match?.[1]?.trim() ?? "";
+}
 function isInlineNativeCommandBody(params) {
   if (!shouldSyncInlineNativeCommandsForAccount({ cfg: params.cfg, account: params.account })) {
     return false;
@@ -41425,7 +43053,7 @@ function isInlineNativeCommandBody(params) {
     if (spec.name.trim().toLowerCase() === commandName)
       return true;
   }
-  for (const spec of getPluginCommandSpecs2("inline", { config: params.cfg })) {
+  for (const spec of listInlinePluginCommandSpecs(params.cfg)) {
     if (spec.name.trim().toLowerCase() === commandName)
       return true;
   }
@@ -41506,7 +43134,7 @@ function buildSyntheticInlineTextMessage(params) {
 }
 var INLINE_ACTION_MAX_ROWS2 = 8;
 var INLINE_ACTION_MAX_PER_ROW2 = 8;
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeOptionalString2(value) {
@@ -41527,7 +43155,7 @@ function normalizeInlineStreamingMode(value) {
   }
 }
 function resolveExplicitInlineStreamingMode(config2) {
-  const streaming = isRecord5(config2.streaming) ? config2.streaming : null;
+  const streaming = isRecord6(config2.streaming) ? config2.streaming : null;
   return normalizeInlineStreamingMode(streaming?.mode) ?? normalizeInlineStreamingMode(config2.streaming) ?? normalizeInlineStreamingMode(config2.streamMode);
 }
 function resolveInlineStreamingMode(config2) {
@@ -41547,14 +43175,14 @@ function resolveInlineProgressPlaceholderEnabled(config2) {
     return true;
   if (config2.streaming === false)
     return false;
-  if (isRecord5(config2.streaming) && isRecord5(config2.streaming.progress))
+  if (isRecord6(config2.streaming) && isRecord6(config2.streaming.progress))
     return true;
   return config2.streaming === undefined && config2.streamMode === undefined && config2.streamViaEditMessage !== true;
 }
 function resolveInlineBlockStreamingEnabled(config2) {
   const mode = resolveInlineStreamingMode(config2);
-  const streaming = isRecord5(config2.streaming) ? config2.streaming : null;
-  const block = streaming && isRecord5(streaming.block) ? streaming.block : null;
+  const streaming = isRecord6(config2.streaming) ? config2.streaming : null;
+  const block = streaming && isRecord6(streaming.block) ? streaming.block : null;
   if (typeof block?.enabled === "boolean")
     return block.enabled;
   if (typeof config2.blockStreaming === "boolean")
@@ -41778,7 +43406,7 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
       continue;
     const row = [];
     for (const candidateButton of candidateRow) {
-      if (!isRecord5(candidateButton))
+      if (!isRecord6(candidateButton))
         continue;
       const text = sanitizeInlineActionLabel(typeof candidateButton.text === "string" ? candidateButton.text : "");
       const callbackDataRaw = typeof candidateButton.callback_data === "string" ? candidateButton.callback_data.trim() : "";
@@ -41799,9 +43427,9 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
   return rows;
 }
 function resolveInlineReplyActions(payload) {
-  const channelData = isRecord5(payload.channelData) ? payload.channelData : undefined;
-  const inlineData = channelData && isRecord5(channelData.inline) ? channelData.inline : undefined;
-  const telegramData = channelData && isRecord5(channelData.telegram) ? channelData.telegram : undefined;
+  const channelData = isRecord6(payload.channelData) ? payload.channelData : undefined;
+  const inlineData = channelData && isRecord6(channelData.inline) ? channelData.inline : undefined;
+  const telegramData = channelData && isRecord6(channelData.telegram) ? channelData.telegram : undefined;
   let rawButtons = undefined;
   let hasExplicitButtons = false;
   let mapCallbackData;
@@ -41875,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;
@@ -42092,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) {
@@ -42550,6 +44196,34 @@ ${entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
     hasBotMessage
   };
 }
+function buildInlineRecentHistoryLines(params) {
+  if (params.maxLines <= 0)
+    return [];
+  return params.messages.slice().sort((a, b) => {
+    const byDate = Number(a.date - b.date);
+    if (byDate !== 0)
+      return byDate;
+    if (a.id === b.id)
+      return 0;
+    return a.id < b.id ? -1 : 1;
+  }).map((message) => buildInlineHistoryEntryPayload({
+    message,
+    senderProfilesById: params.senderProfilesById,
+    meId: params.meId
+  })).map((entry) => entry.line ?? entry.attachmentLine ?? entry.entityLine).filter((line) => Boolean(line)).slice(-params.maxLines);
+}
+function buildInlineParticipantAddReadyText(botUsername) {
+  const mention = botUsername ? `@${botUsername}` : "me";
+  return `I'm here and ready. Mention ${mention} to ask me something.`;
+}
+function shouldSendInlineParticipantAddReadyMessage(participantDate, now = Date.now()) {
+  if (participantDate == null)
+    return true;
+  const eventMs = Number(participantDate) * 1000;
+  if (!Number.isFinite(eventMs) || eventMs <= 0)
+    return true;
+  return now - eventMs <= INLINE_PARTICIPANT_ADD_READY_MAX_EVENT_AGE_MS;
+}
 async function monitorInlineProvider(params) {
   const { cfg, account, runtime, abortSignal, log, statusSink } = params;
   const core3 = getInlineRuntime();
@@ -42559,6 +44233,7 @@ async function monitorInlineProvider(params) {
   const token = await resolveInlineToken(account);
   const stateDir = core3.state.resolveStateDir();
   const statePath = path4.join(stateDir, "channels", "inline", `${account.accountId}.json`);
+  const hasExistingState = await stat(statePath).then(() => true).catch(() => false);
   await mkdir(path4.dirname(statePath), { recursive: true });
   let client = null;
   const pushDiagnostics = (patch) => {
@@ -42585,7 +44260,8 @@ async function monitorInlineProvider(params) {
     baseUrl: account.baseUrl,
     token,
     logger: sdkLog,
-    state: new JsonFileStateStore(statePath)
+    state: new JsonFileStateStore(statePath),
+    catchUpUserFromStart: hasExistingState
   });
   await client.connect(abortSignal);
   pushDiagnostics();
@@ -42687,7 +44363,7 @@ async function monitorInlineProvider(params) {
     const senderId = params2.senderId != null ? String(params2.senderId) : null;
     const dmPolicy = account.config.dmPolicy ?? "pairing";
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     if (isGroup) {
       if (groupPolicy === "disabled") {
         log?.info(`[${account.accountId}] inline: drop ${params2.eventKind} chat=${String(params2.chatId)} (groupPolicy=disabled)`);
@@ -42700,6 +44376,7 @@ async function monitorInlineProvider(params) {
         senderId
       });
       if (groupPolicy === "allowlist") {
+        const shouldBypassGroupAccess = params2.eventKind === "participant.add";
         const groupAccess = resolveInlineGroupAccessPolicy({
           cfg,
           accountId: account.accountId,
@@ -42707,11 +44384,11 @@ async function monitorInlineProvider(params) {
           hasGroupAllowFrom: groupSenderAllowlist.raw.length > 0,
           groupPolicy
         });
-        if (groupAccess.allowlistEnabled && !groupAccess.allowed) {
+        if (groupAccess.allowlistEnabled && !groupAccess.allowed && !shouldBypassGroupAccess) {
           log?.info(`[${account.accountId}] inline: drop ${params2.eventKind} chat=${String(effectiveChatId)} (groupPolicy=allowlist)`);
           return null;
         }
-        if (groupSenderAllowlist.raw.length > 0) {
+        if (groupSenderAllowlist.raw.length > 0 && !shouldBypassGroupAccess) {
           if (senderId == null && !groupSenderAllowlist.raw.includes("*")) {
             log?.info(`[${account.accountId}] inline: drop ${params2.eventKind} chat=${String(effectiveChatId)} (sender unknown)`);
             return null;
@@ -42850,6 +44527,74 @@ async function monitorInlineProvider(params) {
       messageId: params2.messageId
     }), eventOptions);
   };
+  const queueInlineParticipantAddSystemEvent = async (params2) => {
+    if (params2.participant?.userId !== meId)
+      return;
+    const inboundAt = Date.now();
+    statusSink?.({
+      lastInboundAt: inboundAt,
+      lastEventAt: inboundAt,
+      ...createTransportActivityStatusPatch(inboundAt)
+    });
+    const ingress = await resolveInlineSystemEventContext({
+      chatId: params2.chatId,
+      senderId: null,
+      eventKind: "participant.add"
+    });
+    if (!ingress)
+      return;
+    await hydrateChatParticipants(params2.chatId);
+    const chatInfo = chatCache.get(params2.chatId);
+    const isGroup = chatInfo?.kind !== "direct";
+    const historyLimit = resolveHistoryLimit({
+      cfg,
+      isGroup,
+      historyLimit: account.config.historyLimit,
+      dmHistoryLimit: account.config.dmHistoryLimit
+    });
+    const recentMessages = historyLimit > 0 ? await loadChatHistoryMessages({
+      client,
+      chatId: params2.chatId,
+      limit: Math.min(historyLimit, 10)
+    }).catch((err) => {
+      statusSink?.({ lastError: `getChatHistory (participant add) failed: ${String(err)}` });
+      return null;
+    }) : null;
+    const recentLines = recentMessages ? buildInlineRecentHistoryLines({
+      messages: recentMessages,
+      senderProfilesById,
+      meId,
+      maxLines: Math.min(historyLimit, 10)
+    }) : [];
+    const contextKey = buildInlineParticipantAddContextKey({
+      chatId: params2.chatId,
+      userId: meId,
+      ...params2.participant.date != null ? { participantDate: params2.participant.date } : {},
+      ...params2.seq != null ? { seq: params2.seq } : {}
+    });
+    core3.system.enqueueSystemEvent(describeInlineParticipantAddSystemEvent({
+      channelLabel: ingress.channelLabel,
+      recentLines
+    }), {
+      sessionKey: ingress.sessionKey,
+      contextKey,
+      forceSenderIsOwnerFalse: true,
+      trusted: false
+    });
+    if (shouldSendInlineParticipantAddReadyMessage(params2.participant.date)) {
+      try {
+        await client.sendMessage({
+          chatId: params2.chatId,
+          text: buildInlineParticipantAddReadyText(botUsername),
+          parseMarkdown: account.config.parseMarkdown ?? true
+        });
+        statusSink?.({ lastOutboundAt: Date.now() });
+      } catch (err) {
+        runtime.error?.(`inline participant-add ready message failed: ${String(err)}`);
+        statusSink?.({ lastError: `participant-add ready message failed: ${String(err)}` });
+      }
+    }
+  };
   const shouldQueueInlineReactionSystemEvent = async (params2) => {
     const mode = account.config.reactionNotifications ?? "own";
     if (mode === "off")
@@ -42935,8 +44680,8 @@ async function monitorInlineProvider(params) {
       cfg,
       accountId: account.accountId,
       groupId: String(effectiveChatId),
-      defaultMinMessages: account.config.replyThreadAutoCreateMinMessages ?? inlineThreadDefaults.replyThreadAutoCreateMinMessages ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
-    }) : DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES;
+      defaultMinMessages: account.config.replyThreadAutoCreateMinMessages ?? inlineThreadDefaults.replyThreadAutoCreateMinMessages ?? DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES2
+    }) : DEFAULT_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES2;
     const replyThreadRequireExplicitMention = isGroup && replyThreadsEnabled ? resolveInlineGroupReplyThreadRequireExplicitMention({
       cfg,
       accountId: account.accountId,
@@ -42960,7 +44705,7 @@ async function monitorInlineProvider(params) {
     }
     const dmPolicy = account.config.dmPolicy ?? "pairing";
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     const configAllowFrom = await resolveInlineAllowlist({
       cfg,
       accountId: account.accountId,
@@ -43040,6 +44785,8 @@ async function monitorInlineProvider(params) {
     });
     const hasControlCommand = hasTextControlCommand || isRegisteredNativeCommand;
     const commandSource = hasControlCommand ? isRegisteredNativeCommand ? "native" : "text" : undefined;
+    const normalizedCommandName = resolveInlineCommandNameFromBody(normalizedCommandBody);
+    const hostInlinePluginCommandRegistered = normalizedCommandName ? hasInlineCommandSpec(listHostInlinePluginCommandSpecs(cfg), normalizedCommandName) : false;
     const allowTextCommands = core3.channel.commands.shouldHandleTextCommands({
       cfg,
       surface: CHANNEL_ID,
@@ -43063,6 +44810,7 @@ async function monitorInlineProvider(params) {
       commandAuthorized: commandGate.commandAuthorized
     });
     const shouldBlockControlCommand = allowTextCommands && hasControlCommand && !commandAuthorized;
+    const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
     if (isGroup) {
       if (groupPolicy === "disabled") {
         log?.info(`[${account.accountId}] inline: drop group chat=${String(chatId)} (groupPolicy=disabled)`);
@@ -43079,7 +44827,7 @@ async function monitorInlineProvider(params) {
           hasGroupAllowFrom: groupSenderAllowlist.raw.length > 0,
           groupPolicy
         });
-        if (groupAccess.allowlistEnabled && !groupAccess.allowed) {
+        if (groupAccess.allowlistEnabled && !groupAccess.allowed && !nativeMentioned) {
           log?.info(`[${account.accountId}] inline: drop group chat=${String(effectiveChatId)} (groupPolicy=allowlist)`);
           await answerCallbackIfNeeded().catch((error51) => {
             runtime.error?.(`inline callback answer failed: ${String(error51)}`);
@@ -43151,7 +44899,6 @@ async function monitorInlineProvider(params) {
       return;
     }
     const mentionRegexes = core3.channel.mentions.buildMentionRegexes(cfg, route.agentId);
-    const nativeMentioned = typeof msg.mentioned === "boolean" ? msg.mentioned : false;
     const patternMentioned = mentionRegexes.length ? core3.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) : false;
     const wasMentioned = nativeMentioned || patternMentioned;
     const messageTimestamp = Number(msg.date) * 1000;
@@ -43209,7 +44956,7 @@ async function monitorInlineProvider(params) {
       cfg,
       groupId: String(effectiveChatId),
       accountId: account.accountId,
-      requireMentionDefault: account.config.requireMention ?? false
+      requireMentionDefault: account.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION
     }) : false;
     const mentionGate = resolveMentionGatingWithBypass({
       isGroup,
@@ -43254,6 +45001,74 @@ async function monitorInlineProvider(params) {
       return;
     }
     const parseMarkdown = account.config.parseMarkdown ?? true;
+    if (isInlineThreadReplyCommandBody(normalizedCommandBody) && !hostInlinePluginCommandRegistered) {
+      const configRuntime = core3.config;
+      if (typeof configRuntime?.current !== "function" || typeof configRuntime.mutateConfigFile !== "function") {
+        runtime.error?.("inline /threadreply fallback unavailable: runtime config API missing");
+      } else {
+        const result = await handleInlineThreadReplyCommandWithConfigRuntime(configRuntime, {
+          senderId,
+          channel: CHANNEL_ID,
+          channelId: CHANNEL_ID,
+          isAuthorizedSender: commandAuthorized,
+          senderIsOwner: commandAuthorized,
+          sessionKey: inboundSessionKey,
+          args: parseInlineCommandArgs(normalizedCommandBody),
+          commandBody: normalizedCommandBody,
+          config: cfg,
+          from: isGroup ? `inline:chat:${String(effectiveChatId)}` : `inline:${senderId}`,
+          to: `inline:${String(effectiveChatId)}`,
+          accountId: account.accountId,
+          ...replyThreadContext ? {
+            messageThreadId: String(replyThreadContext.childChatId),
+            threadParentId: String(replyThreadContext.parentChatId)
+          } : {},
+          requestConversationBinding: async () => ({ ok: false }),
+          detachConversationBinding: async () => ({ removed: false }),
+          getCurrentConversationBinding: async () => null
+        });
+        const resultRecord = result;
+        const actions = resolveInlineReplyActions(resultRecord);
+        const text = typeof result.text === "string" ? sanitizeInlineDeliveryText(result.text) : "";
+        if (text || actions) {
+          let delivered = false;
+          if (shouldEditCallbackTargetInPlace && callbackActionEvent) {
+            try {
+              const editResult = await client.invokeRaw(Method.EDIT_MESSAGE, {
+                oneofKind: "editMessage",
+                editMessage: {
+                  messageId: callbackActionEvent.targetMessageId,
+                  peerId: buildChatPeer3(chatId),
+                  text,
+                  ...actions ? { actions } : {},
+                  parseMarkdown
+                }
+              });
+              if (editResult.oneofKind !== "editMessage") {
+                throw new Error(`inline /threadreply edit: expected editMessage result, got ${String(editResult.oneofKind)}`);
+              }
+              delivered = true;
+            } catch (error51) {
+              runtime.error?.(`inline /threadreply edit failed; falling back to send (${String(error51)})`);
+            }
+          }
+          if (!delivered) {
+            const sent = await client.sendMessage({
+              chatId,
+              text,
+              ...actions ? { actions } : {},
+              parseMarkdown
+            });
+            rememberSentBotMessage({ chatId, messageId: sent.messageId, replyThreadContext });
+          }
+          statusSink?.({ lastOutboundAt: Date.now() });
+        }
+        await answerCallbackIfNeeded().catch((error51) => {
+          runtime.error?.(`inline callback answer failed: ${String(error51)}`);
+        });
+        return;
+      }
+    }
     const commandsPageCallback = callbackActionEvent ? parseInlineCommandsPageCallback(callbackDataToUtf8(callbackActionEvent.data)) : null;
     if (shouldEditCallbackTargetInPlace && callbackActionEvent && commandsPageCallback) {
       if (commandsPageCallback.page === "noop")
@@ -43448,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;
@@ -43457,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);
@@ -43726,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 ? {
@@ -43964,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({
@@ -44008,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;
@@ -44047,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 } : {}
@@ -44080,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;
@@ -44234,6 +46100,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             },
             onError: (err, info) => {
               failedNonSilent = true;
+              botPresenceLifecycle.fail();
               runtime.error?.(`inline ${info?.kind ?? "final"} reply failed: ${String(err)}`);
             }
           },
@@ -44241,6 +46108,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         });
       } catch (error51) {
         dispatchError = error51;
+        botPresenceLifecycle.fail();
         runtime.error?.(`inline dispatch failed: ${String(error51)}`);
       }
       await cleanupInlineProgressPlaceholder();
@@ -44248,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,
@@ -44418,6 +46287,19 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
           });
           continue;
         }
+        if (rawEvent["kind"] === "chat.participant.add") {
+          const eventChatId = rawEvent["chatId"];
+          if (!eventChatId)
+            continue;
+          const participant = rawEvent["participant"];
+          const seq = rawEvent["seq"];
+          await queueInlineParticipantAddSystemEvent({
+            chatId: eventChatId,
+            ...participant ? { participant } : {},
+            ...seq != null ? { seq } : {}
+          });
+          continue;
+        }
         if (rawEvent["kind"] === "message.action.invoke") {
           const actorUserId = rawEvent["actorUserId"];
           const interactionId = rawEvent["interactionId"];
@@ -44482,7 +46364,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
 }
 
 // src/inline/doctor.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function readInherited(account, parent, key) {
@@ -44493,18 +46375,18 @@ function hasEntries(value) {
 }
 function hasConfiguredGroups(account, parent) {
   const groups = readInherited(account, parent, "groups");
-  return isRecord6(groups) && Object.keys(groups).length > 0;
+  return isRecord7(groups) && Object.keys(groups).length > 0;
 }
 function hasGroupScopedSenders(groups) {
-  if (!isRecord6(groups))
+  if (!isRecord7(groups))
     return false;
-  return Object.values(groups).some((group) => isRecord6(group) && hasEntries(group.allowFrom));
+  return Object.values(groups).some((group) => isRecord7(group) && hasEntries(group.allowFrom));
 }
 function hasGroupSenders(account, parent) {
   return hasEntries(readInherited(account, parent, "groupAllowFrom")) || hasGroupScopedSenders(readInherited(account, parent, "groups"));
 }
 function getGroupPolicy(account, parent) {
-  return String(readInherited(account, parent, "groupPolicy") ?? "allowlist");
+  return String(readInherited(account, parent, "groupPolicy") ?? INLINE_DEFAULT_GROUP_POLICY);
 }
 function collectInlineEmptyAllowlistWarnings(params) {
   if (params.channelName !== "inline")
@@ -44661,7 +46543,8 @@ var INLINE_USER_ID_HELP_LINES = [
   "Docs: https://inline.chat/docs/openclaw"
 ];
 var INLINE_GROUP_HELP_LINES = [
-  "Allowlist Inline group chats by numeric chat id.",
+  "Inline groups are open by default and require a bot mention by default.",
+  "Optionally allowlist Inline group chats by numeric chat id.",
   "Accepted forms: 123456789, chat:123456789, inline:123456789, *.",
   "Use * for every group chat; the setup keeps requireMention=true for broad group access.",
   "Use /whoami in a group and copy the Chat line to get the Inline chat id.",
@@ -44808,7 +46691,7 @@ function buildInlineDmAccessWarningLines(accountId) {
 function buildInlineGroupAccessWarningLines(params) {
   const resolved = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId });
   const configBase = formatInlineConfigBase(params.accountId);
-  const policy = resolved.config.groupPolicy ?? "allowlist";
+  const policy = resolved.config.groupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
   const groups = resolved.config.groups ?? {};
   const hasGroups = Object.keys(groups).length > 0;
   const hasGroupAllowFrom = (resolved.config.groupAllowFrom ?? []).some((entry) => String(entry).trim());
@@ -44821,7 +46704,8 @@ function buildInlineGroupAccessWarningLines(params) {
     ];
   }
   const wildcard = groups["*"];
-  if (policy === "open" && wildcard?.requireMention !== true) {
+  const requireMention = wildcard?.requireMention ?? resolved.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION;
+  if (policy === "open" && requireMention !== true) {
     return [
       "Inline groups are open to every group chat without a default mention requirement.",
       "For safer broad group access, require bot mentions or switch to an explicit group allowlist:",
@@ -45085,11 +46969,11 @@ async function probeInlineAccount(account, timeoutMs) {
 }
 
 // src/inline/status-issues.ts
-import { asString, isRecord as isRecord7 } from "openclaw/plugin-sdk/status-helpers";
+import { asString, isRecord as isRecord8 } from "openclaw/plugin-sdk/status-helpers";
 var RECENT_RUNTIME_ISSUE_MS = 30 * 60 * 1000;
 var INLINE_CONNECT_GRACE_MS = 120 * 1000;
 function readInlineProbeSummary(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return {};
   }
   const summary = {};
@@ -45106,12 +46990,12 @@ function looksLikeAuthError(text) {
   return /(401|403|unauth|forbidden|invalid token|token invalid|unauthorized)/i.test(text);
 }
 function readInlineDiagnosticsSummary(value) {
-  if (!isRecord7(value)) {
+  if (!isRecord8(value)) {
     return {};
   }
-  const protocolValue = isRecord7(value.protocol) ? value.protocol : undefined;
-  const transportValue = (protocolValue && isRecord7(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord7(value.transport) ? value.transport : undefined);
-  const pingValue = protocolValue && isRecord7(protocolValue.ping) ? protocolValue.ping : undefined;
+  const protocolValue = isRecord8(value.protocol) ? value.protocol : undefined;
+  const transportValue = (protocolValue && isRecord8(protocolValue.transport) ? protocolValue.transport : undefined) ?? (isRecord8(value.transport) ? value.transport : undefined);
+  const pingValue = protocolValue && isRecord8(protocolValue.ping) ? protocolValue.ping : undefined;
   return {
     ...protocolValue ? {
       protocol: {
@@ -45143,7 +47027,7 @@ function asFiniteNumber(value) {
 function collectInlineStatusIssues(accounts) {
   const issues = [];
   for (const entry of accounts) {
-    if (!isRecord7(entry)) {
+    if (!isRecord8(entry)) {
       continue;
     }
     const accountId = asString(entry.accountId);
@@ -45279,6 +47163,14 @@ function hasInlineCommandAllowFrom(cfg) {
   const byProvider = allowFrom;
   return hasEntries2(byProvider.inline) || hasEntries2(byProvider["*"]);
 }
+function groupDefaultRequiresMention(account) {
+  const groups = account.config.groups;
+  const wildcard = groups && typeof groups === "object" && !Array.isArray(groups) ? groups["*"] : undefined;
+  const wildcardRequireMention = wildcard && typeof wildcard === "object" && !Array.isArray(wildcard) ? wildcard.requireMention : undefined;
+  if (typeof wildcardRequireMention === "boolean")
+    return wildcardRequireMention;
+  return account.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION;
+}
 function collectInvalidAllowFromEntries(params) {
   if (!Array.isArray(params.entries))
     return;
@@ -45335,7 +47227,7 @@ var inlineSecurityAdapter = {
   },
   collectWarnings: ({ account, cfg }) => {
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     const groupRulesConfigured = Boolean(account.config.groups) && Object.keys(account.config.groups ?? {}).length > 0;
     const groupSendersConfigured = hasGroupSenderEntries(account);
     if (groupPolicy === "allowlist" && !groupRulesConfigured && !groupSendersConfigured) {
@@ -45346,14 +47238,12 @@ var inlineSecurityAdapter = {
     if (groupPolicy !== "open") {
       return [];
     }
-    if (groupRulesConfigured) {
+    if (!groupDefaultRequiresMention(account)) {
       return [
-        '- Inline groups: groupPolicy="open" allows any group message to reach the agent (subject to mention policy). Set channels.inline.groupPolicy="allowlist" for stricter routing.'
+        '- Inline groups: groupPolicy="open" allows every group message to trigger replies because requireMention is disabled. Set channels.inline.requireMention=true or channels.inline.groups."*".requireMention=true.'
       ];
     }
-    return [
-      '- Inline groups: groupPolicy="open" with no group rules means every group can trigger replies. Consider channels.inline.groupPolicy="allowlist".'
-    ];
+    return [];
   },
   collectAuditFindings: ({ account, cfg }) => {
     const findings = [];
@@ -45378,7 +47268,7 @@ var inlineSecurityAdapter = {
     });
     appendInvalidReactionAllowlistFinding(findings, invalidReactionAllowlistEntries);
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? INLINE_DEFAULT_GROUP_POLICY;
     const groupsConfigured = Boolean(account.config.groups) && Object.keys(account.config.groups ?? {}).length > 0;
     const groupSendersConfigured = hasGroupSenderEntries(account);
     const groupAccessEnabled = groupPolicy === "open" || groupPolicy === "allowlist" && (groupsConfigured || groupSendersConfigured);
@@ -46711,7 +48601,7 @@ var inlineChannelPlugin = {
         cfg,
         groupId,
         accountId,
-        requireMentionDefault: resolved.config.requireMention ?? false
+        requireMentionDefault: resolved.config.requireMention ?? INLINE_DEFAULT_REQUIRE_MENTION
       });
     },
     resolveToolPolicy: ({ cfg, accountId, groupId, senderId, senderName, senderUsername, senderE164 }) => resolveInlineGroupToolPolicy({
@@ -46760,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."
       ] : [],
@@ -46767,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.",
@@ -47135,5 +49033,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=C3CE4C015D5193F764756E2164756E21
+//# debugId=3B872041BDFC897564756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map