@inline-openclaw/inline 0.0.45 → 0.0.46

package/dist/runtime-register-api.js

@@ -5590,6 +5590,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";
@@ -5703,6 +5721,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";
@@ -5766,6 +5789,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) {
@@ -6648,6 +6676,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", [
@@ -6662,7 +6807,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) {
@@ -6713,6 +6859,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")
@@ -6749,6 +6898,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);
@@ -6834,7 +6985,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) {
@@ -6893,6 +7045,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")
@@ -6935,6 +7090,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);
@@ -6958,7 +7115,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) {
@@ -7013,6 +7171,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")
@@ -7051,6 +7212,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);
@@ -9899,7 +10062,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) {
@@ -10248,6 +10416,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")
@@ -10372,6 +10570,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);
@@ -10438,7 +10646,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) {
@@ -10787,6 +11000,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")
@@ -10911,6 +11154,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);
@@ -12002,6 +12255,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", [
@@ -13262,7 +13606,376 @@ class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var UpdateBotProfileResult = new UpdateBotProfileResult$Type;
+var UpdateBotProfileResult = new UpdateBotProfileResult$Type;
+
+class SetBotAvatarInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    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;
+  }
+  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.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;
+          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.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 SetBotAvatarInput = new SetBotAvatarInput$Type;
+
+class SetBotAvatarResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotAvatarResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.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;
+  }
+  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 SetBotAvatarResult = new SetBotAvatarResult$Type;
+
+class ClearBotAvatarInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ClearBotAvatarInput", [
+      { 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 ClearBotAvatarInput = new ClearBotAvatarInput$Type;
+
+class ClearBotAvatarResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ClearBotAvatarResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.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;
+  }
+  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 ClearBotAvatarResult = new ClearBotAvatarResult$Type;
+
+class GetBotPresenceInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotPresenceInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetBotPresenceInput = new GetBotPresenceInput$Type;
+
+class GetBotPresenceResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    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);
+    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.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;
+          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 !== 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 GetBotPresenceResult = new GetBotPresenceResult$Type;
+
+class SetBotPresenceStateInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    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);
+    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.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
+          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.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 SetBotPresenceStateInput = new SetBotPresenceStateInput$Type;
+
+class SetBotPresenceStateResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotPresenceStateResult", []);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    return target ?? this.create();
+  }
+  internalBinaryWrite(message, writer, options) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SetBotPresenceStateResult = new SetBotPresenceStateResult$Type;
 
 class GetUserSettingsInput$Type extends import_runtime4.MessageType {
   constructor() {
@@ -16402,7 +17115,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) {
@@ -16627,6 +17342,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")
@@ -16711,6 +17438,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);
@@ -17571,6 +18302,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", [
@@ -18096,6 +18875,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", [
@@ -37287,6 +38134,17 @@ function readStringCandidate(...values) {
 }
 
 // src/inline/message-tools.ts
+var INLINE_BOT_PRESENCE_COMMENT_MAX_LENGTH = 30;
+var INLINE_BOT_PRESENCE_KINDS = [
+  "idle",
+  "happy",
+  "waving",
+  "jumping",
+  "failed",
+  "waiting",
+  "running",
+  "review"
+];
 var InlineNudgeToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -37387,6 +38245,43 @@ var InlineForwardToolParameters = {
   },
   required: ["to"]
 };
+var InlineBotPresenceToolParameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    kind: {
+      type: "string",
+      enum: INLINE_BOT_PRESENCE_KINDS,
+      description: "Body state for your on-screen Inline character. Use waving for greetings/attention, jumping for delight/completion, review for thinking, waiting for user input, running for active work, failed when blocked/disappointed, happy for positive settled moments, and idle only when neutral is intentionally useful."
+    },
+    comment: {
+      type: "string",
+      maxLength: INLINE_BOT_PRESENCE_COMMENT_MAX_LENGTH,
+      description: "Tiny generated thought bubble from your actual current mood, process, status, request, nudge, or aside. Keep it casual, characterful, and under 30 characters; text or one/two emojis are both fine. It supplements the chat answer and should not replace substantive content."
+    },
+    to: {
+      type: "string",
+      description: "Optional Inline target (`chat:<id>`, bare chat id, or `user:<id>`). Defaults to the current Inline chat when available."
+    },
+    target: {
+      type: "string",
+      description: "Alias for `to`."
+    },
+    chatId: {
+      type: "string",
+      description: "Explicit chat id target alias."
+    },
+    userId: {
+      type: "string",
+      description: "Explicit user id target alias."
+    },
+    accountId: {
+      type: "string",
+      description: "Optional Inline account id override."
+    }
+  },
+  required: ["kind"]
+};
 function resolvePeerTarget(params) {
   if (params.direct) {
     return {
@@ -37467,6 +38362,48 @@ function extractFirstMessageId2(updates) {
   }
   return null;
 }
+function normalizeInlineBotPresenceKind(value) {
+  if (typeof value !== "string") {
+    throw new Error("inline_bot_presence: `kind` is required");
+  }
+  const normalized = value.trim().toLowerCase();
+  for (const kind of INLINE_BOT_PRESENCE_KINDS) {
+    if (kind === normalized)
+      return kind;
+  }
+  throw new Error(`inline_bot_presence: invalid kind "${value}"`);
+}
+function botPresenceStateKind(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 normalizeInlineBotPresenceComment(value) {
+  if (typeof value !== "string")
+    return;
+  const visible = sanitizeInlineVisibleText(value);
+  if (visible.shouldSkip)
+    return;
+  const text = visible.text.replace(/\s+/g, " ").trim();
+  if (!text)
+    return;
+  return Array.from(text).slice(0, INLINE_BOT_PRESENCE_COMMENT_MAX_LENGTH).join("");
+}
 async function withInlineClient(params) {
   const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
   if (!account.configured || !account.baseUrl) {
@@ -37537,6 +38474,54 @@ function createInlineNudgeTool(ctx) {
     }
   };
 }
+function createInlineBotPresenceTool(ctx) {
+  return {
+    name: "inline_bot_presence",
+    label: "Body Cue",
+    description: "Move or emote through your literal on-screen Inline character/body without sending a chat message. This is a cheap body-language/thought-bubble tool: use it during active work when your mood, thought, status, request, or final beat would help the human read you better.",
+    parameters: InlineBotPresenceToolParameters,
+    execute: async (_toolCallId, rawArgs) => {
+      if (!ctx.config) {
+        throw new Error("inline_bot_presence: missing OpenClaw config");
+      }
+      const args = rawArgs;
+      const fallbackTarget = parseCurrentInlineTarget(ctx);
+      const { target, usedFallback } = resolvePeerTarget({
+        label: "target",
+        direct: readStringCandidate(args.to, args.target),
+        chatId: args.chatId,
+        userId: args.userId,
+        fallback: fallbackTarget
+      });
+      const kind = normalizeInlineBotPresenceKind(args.kind);
+      const comment = normalizeInlineBotPresenceComment(args.comment);
+      return await withInlineClient({
+        cfg: ctx.config,
+        accountId: args.accountId ?? ctx.agentAccountId ?? null,
+        fn: async (client, resolvedAccountId) => {
+          await client.invokeRaw(Method.SET_BOT_PRESENCE_STATE, {
+            oneofKind: "setBotPresenceState",
+            setBotPresenceState: {
+              peerId: target.peerId,
+              state: {
+                kind: botPresenceStateKind(kind),
+                ...comment ? { comment } : {}
+              }
+            }
+          });
+          return jsonResult({
+            ok: true,
+            accountId: resolvedAccountId,
+            target: target.normalized,
+            usedCurrentChatDefault: usedFallback,
+            kind,
+            comment: comment ?? null
+          });
+        }
+      });
+    }
+  };
+}
 function createInlineForwardTool(ctx) {
   return {
     name: "inline_forward",
@@ -37595,7 +38580,7 @@ function createInlineForwardTool(ctx) {
 function createInlineMessageTools(ctx) {
   if (!ctx.config)
     return [];
-  return [createInlineNudgeTool(ctx), createInlineForwardTool(ctx)];
+  return [createInlineNudgeTool(ctx), createInlineForwardTool(ctx), createInlineBotPresenceTool(ctx)];
 }
 
 // src/inline/space-members.ts
@@ -37784,6 +38769,80 @@ function createInlineMembersTool(ctx) {
   };
 }
 
+// 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,
@@ -37795,7 +38854,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();
@@ -37963,6 +39024,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";
   }
@@ -38004,6 +39069,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);
   }
@@ -38056,6 +39141,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":
@@ -38329,14 +39421,17 @@ function sortMessages(messages) {
     return a.id < b.id ? -1 : 1;
   });
 }
+function messageDedupeKey(message) {
+  return `${String(message.id)}:${String(message.date)}`;
+}
 function dedupeMessages(messages) {
   const seen = new Set;
   const out = [];
   for (const message of messages) {
-    const id = String(message.id);
-    if (seen.has(id))
+    const key = messageDedupeKey(message);
+    if (seen.has(key))
       continue;
-    seen.add(id);
+    seen.add(key);
     out.push(message);
   }
   return out;
@@ -38465,56 +39560,11 @@ function createInlineParentContextTool(ctx) {
   };
 }
 
-// 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/bot-avatar-tool.ts
+import { inflateRawSync } from "node:zlib";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
 
 // src/runtime.ts
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
@@ -38528,6 +39578,370 @@ var {
   errorMessage: "Inline runtime not initialized"
 });
 
+// src/inline/bot-avatar-tool.ts
+var MAX_PACKAGE_BYTES = 40000000;
+var MAX_MANIFEST_BYTES = 64000;
+var ZIP_EOCD_SIGNATURE = 101010256;
+var ZIP_CENTRAL_SIGNATURE = 33639248;
+var ZIP_LOCAL_SIGNATURE = 67324752;
+var ZIP_METHOD_STORE = 0;
+var ZIP_METHOD_DEFLATE = 8;
+var ZIP_FLAG_ENCRYPTED = 1;
+var CODEX_ATLAS_KIND = "codex_atlas";
+var InlineBotAvatarToolParameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    zipPath: {
+      type: "string",
+      description: "Local path to a .zip avatar package. The archive should contain a Codex atlas manifest and a PNG/WebP spritesheet."
+    },
+    archivePath: {
+      type: "string",
+      description: "Alias for zipPath."
+    },
+    zipUrl: {
+      type: "string",
+      description: "Remote URL to a .zip avatar package."
+    },
+    source: {
+      type: "string",
+      description: "Local path or URL alias for the avatar package .zip."
+    },
+    displayName: {
+      type: "string",
+      description: "Optional display-name override for the uploaded bot avatar."
+    },
+    description: {
+      type: "string",
+      description: "Optional short description override for the uploaded bot avatar."
+    },
+    accountId: {
+      type: "string",
+      description: "Optional Inline account id override."
+    }
+  }
+};
+function readTrimmedString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+function readVisibleString(value, label) {
+  const raw = readTrimmedString(value);
+  if (!raw)
+    return;
+  const visible = sanitizeInlineVisibleText(raw);
+  if (visible.shouldSkip) {
+    throw new Error(`inline_bot_avatar: ${label} contains internal runtime text`);
+  }
+  return readTrimmedString(visible.text);
+}
+function resolvePackageSource(args) {
+  const source = readTrimmedString(args.zipPath) ?? readTrimmedString(args.archivePath) ?? readTrimmedString(args.zipUrl) ?? readTrimmedString(args.source);
+  if (!source) {
+    throw new Error("inline_bot_avatar: provide `zipPath` or `source`");
+  }
+  const sourceWithoutQuery = source.split(/[?#]/, 1)[0] ?? source;
+  if (!sourceWithoutQuery.toLowerCase().endsWith(".zip")) {
+    throw new Error("inline_bot_avatar: source must be a .zip package");
+  }
+  return source;
+}
+function sourceWithoutQuery(raw) {
+  return raw.split(/[?#]/, 1)[0] ?? raw;
+}
+function localPathFromSource(source) {
+  const trimmed = source.trim();
+  if (!trimmed || /^https?:\/\//i.test(trimmed))
+    return;
+  if (trimmed.startsWith("file://")) {
+    try {
+      return fileURLToPath(trimmed);
+    } catch {
+      return;
+    }
+  }
+  const withoutQuery = sourceWithoutQuery(trimmed);
+  if (withoutQuery.startsWith("~/") || withoutQuery === "~") {
+    return path.join(os.homedir(), withoutQuery.slice(2));
+  }
+  if (path.isAbsolute(withoutQuery))
+    return withoutQuery;
+  return;
+}
+function packageLoadOptions(source, ctx) {
+  const options = {
+    maxBytes: MAX_PACKAGE_BYTES,
+    optimizeImages: false,
+    ...ctx.workspaceDir ? { workspaceDir: ctx.workspaceDir } : {}
+  };
+  const localPath = localPathFromSource(source);
+  if (!localPath)
+    return options;
+  if (ctx.fsPolicy?.workspaceOnly === true) {
+    if (ctx.workspaceDir)
+      return { ...options, localRoots: [ctx.workspaceDir] };
+    return options;
+  }
+  return {
+    ...options,
+    localRoots: [path.dirname(localPath)]
+  };
+}
+function sanitizeUploadFileName2(raw) {
+  const normalized = raw.trim().replace(/\\/g, "/");
+  const leaf = normalized.split("/").pop() ?? normalized;
+  const safe = leaf.split(/[?#]/, 1)[0]?.trim();
+  return safe || "bot-avatar.webp";
+}
+function normalizeZipName(raw) {
+  const normalized = raw.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter((part) => part.length > 0);
+  if (normalized.startsWith("/") || parts.some((part) => part === "." || part === "..")) {
+    throw new Error(`inline_bot_avatar: invalid zip entry path "${raw}"`);
+  }
+  return parts.join("/");
+}
+function findEndOfCentralDirectory(data) {
+  const minOffset = Math.max(0, data.length - 65535 - 22);
+  for (let offset = data.length - 22;offset >= minOffset; offset -= 1) {
+    if (data.readUInt32LE(offset) === ZIP_EOCD_SIGNATURE)
+      return offset;
+  }
+  throw new Error("inline_bot_avatar: invalid zip package");
+}
+function readZipEntries(data) {
+  const eocdOffset = findEndOfCentralDirectory(data);
+  const totalEntries = data.readUInt16LE(eocdOffset + 10);
+  const centralSize = data.readUInt32LE(eocdOffset + 12);
+  const centralOffset = data.readUInt32LE(eocdOffset + 16);
+  if (totalEntries === 65535 || centralSize === 4294967295 || centralOffset === 4294967295) {
+    throw new Error("inline_bot_avatar: zip64 packages are not supported");
+  }
+  if (centralOffset + centralSize > data.length) {
+    throw new Error("inline_bot_avatar: invalid zip central directory");
+  }
+  const entries = new Map;
+  let offset = centralOffset;
+  for (let index = 0;index < totalEntries; index += 1) {
+    if (offset + 46 > data.length || data.readUInt32LE(offset) !== ZIP_CENTRAL_SIGNATURE) {
+      throw new Error("inline_bot_avatar: invalid zip central directory entry");
+    }
+    const flags = data.readUInt16LE(offset + 8);
+    const method = data.readUInt16LE(offset + 10);
+    const compressedSize = data.readUInt32LE(offset + 20);
+    const uncompressedSize = data.readUInt32LE(offset + 24);
+    const fileNameLength = data.readUInt16LE(offset + 28);
+    const extraLength = data.readUInt16LE(offset + 30);
+    const commentLength = data.readUInt16LE(offset + 32);
+    const localHeaderOffset = data.readUInt32LE(offset + 42);
+    const fileNameStart = offset + 46;
+    const fileNameEnd = fileNameStart + fileNameLength;
+    if (fileNameEnd > data.length) {
+      throw new Error("inline_bot_avatar: invalid zip file name");
+    }
+    const rawName = data.subarray(fileNameStart, fileNameEnd).toString("utf8");
+    offset = fileNameEnd + extraLength + commentLength;
+    if (!rawName || rawName.endsWith("/"))
+      continue;
+    const name = normalizeZipName(rawName);
+    entries.set(name, {
+      name,
+      method,
+      flags,
+      compressedSize,
+      uncompressedSize,
+      localHeaderOffset
+    });
+  }
+  return entries;
+}
+function readZipEntry(data, entry, maxBytes) {
+  if ((entry.flags & ZIP_FLAG_ENCRYPTED) !== 0) {
+    throw new Error(`inline_bot_avatar: encrypted zip entry is not supported (${entry.name})`);
+  }
+  if (entry.uncompressedSize > maxBytes) {
+    throw new Error(`inline_bot_avatar: zip entry is too large (${entry.name})`);
+  }
+  if (entry.localHeaderOffset + 30 > data.length || data.readUInt32LE(entry.localHeaderOffset) !== ZIP_LOCAL_SIGNATURE) {
+    throw new Error(`inline_bot_avatar: invalid zip local header (${entry.name})`);
+  }
+  const nameLength = data.readUInt16LE(entry.localHeaderOffset + 26);
+  const extraLength = data.readUInt16LE(entry.localHeaderOffset + 28);
+  const dataStart = entry.localHeaderOffset + 30 + nameLength + extraLength;
+  const dataEnd = dataStart + entry.compressedSize;
+  if (dataEnd > data.length) {
+    throw new Error(`inline_bot_avatar: invalid zip entry data (${entry.name})`);
+  }
+  const compressed = data.subarray(dataStart, dataEnd);
+  let bytes;
+  try {
+    bytes = entry.method === ZIP_METHOD_STORE ? Buffer.from(compressed) : entry.method === ZIP_METHOD_DEFLATE ? inflateRawSync(compressed, { maxOutputLength: maxBytes + 1 }) : undefined;
+  } catch (error51) {
+    throw new Error(`inline_bot_avatar: invalid or oversized zip entry (${entry.name})`, {
+      cause: error51
+    });
+  }
+  if (!bytes) {
+    throw new Error(`inline_bot_avatar: unsupported zip compression (${entry.name})`);
+  }
+  if (bytes.length !== entry.uncompressedSize || bytes.length > maxBytes) {
+    throw new Error(`inline_bot_avatar: invalid zip entry size (${entry.name})`);
+  }
+  return bytes;
+}
+function findPackageManifest(entries) {
+  const root = entries.get("pet.json");
+  if (root)
+    return root;
+  for (const entry of entries.values()) {
+    if (entry.name.endsWith("/pet.json"))
+      return entry;
+  }
+  throw new Error("inline_bot_avatar: package is missing avatar manifest");
+}
+function resolveRelativeZipPath(baseEntryName, rawPath) {
+  const baseDir = baseEntryName.includes("/") ? baseEntryName.slice(0, baseEntryName.lastIndexOf("/")) : "";
+  return normalizeZipName(path.posix.normalize(path.posix.join(baseDir, rawPath)));
+}
+function parsePackageManifest(data) {
+  try {
+    const parsed = JSON.parse(data.toString("utf8"));
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  throw new Error("inline_bot_avatar: invalid avatar manifest");
+}
+function contentTypeForSprite(fileName) {
+  const ext = path.extname(fileName).toLowerCase();
+  if (ext === ".png")
+    return "image/png";
+  if (ext === ".webp")
+    return "image/webp";
+  throw new Error("inline_bot_avatar: spritesheet must be PNG or WebP");
+}
+function extractAvatarPackage(params) {
+  const entries = readZipEntries(params.data);
+  const manifestEntry = findPackageManifest(entries);
+  const manifest = parsePackageManifest(readZipEntry(params.data, manifestEntry, MAX_MANIFEST_BYTES));
+  const rawSpritesheetPath = readTrimmedString(manifest.spritesheetPath);
+  if (!rawSpritesheetPath) {
+    throw new Error("inline_bot_avatar: avatar manifest is missing spritesheetPath");
+  }
+  const spritesheetPath = resolveRelativeZipPath(manifestEntry.name, rawSpritesheetPath);
+  const spriteEntry = entries.get(spritesheetPath);
+  if (!spriteEntry) {
+    throw new Error(`inline_bot_avatar: package is missing spritesheet ${rawSpritesheetPath}`);
+  }
+  const id = readTrimmedString(manifest.id);
+  const fallbackName = sanitizeUploadFileName2(params.source).replace(/\.zip$/i, "");
+  const displayName = params.displayName ?? readVisibleString(manifest.displayName, "displayName") ?? id ?? fallbackName;
+  const description = params.description ?? readVisibleString(manifest.description, "description");
+  const fileName = sanitizeUploadFileName2(spritesheetPath);
+  return {
+    ...id ? { id } : {},
+    displayName,
+    ...description ? { description } : {},
+    spritesheetPath,
+    spritesheet: readZipEntry(params.data, spriteEntry, MAX_PACKAGE_BYTES),
+    contentType: contentTypeForSprite(fileName),
+    fileName
+  };
+}
+async function loadPackage(source, ctx) {
+  return await getInlineRuntime().media.loadWebMedia(source, packageLoadOptions(source, ctx));
+}
+async function withInlineClient4(params) {
+  const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
+  if (!account.configured || !account.baseUrl) {
+    throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
+  }
+  const token = await resolveInlineToken(account);
+  const client = new InlineSdkClient({
+    baseUrl: account.baseUrl,
+    token
+  });
+  await client.connect();
+  try {
+    return await params.fn(client, account.accountId);
+  } finally {
+    await client.close().catch(() => {});
+  }
+}
+function createInlineBotAvatarTool(ctx) {
+  if (!ctx.config)
+    return null;
+  return {
+    name: "inline_bot_avatar",
+    label: "Bot Avatar",
+    description: "Upload or replace the authenticated Inline bot's on-screen avatar from a user-provided Codex atlas zip package. Use only when the user explicitly asks to install or change your avatar.",
+    parameters: InlineBotAvatarToolParameters,
+    execute: async (_toolCallId, rawArgs) => {
+      const args = rawArgs;
+      const source = resolvePackageSource(args);
+      const displayName = readVisibleString(args.displayName, "displayName");
+      const description = readVisibleString(args.description, "description");
+      const loaded = await loadPackage(source, ctx);
+      const avatarPackage = extractAvatarPackage({
+        data: Buffer.from(loaded.buffer),
+        source,
+        ...displayName ? { displayName } : {},
+        ...description ? { description } : {}
+      });
+      return await withInlineClient4({
+        cfg: ctx.config,
+        accountId: args.accountId ?? ctx.agentAccountId ?? null,
+        fn: async (client, resolvedAccountId) => {
+          const me = await client.getMe();
+          const uploaded = await client.uploadFile({
+            type: "photo",
+            file: avatarPackage.spritesheet,
+            fileName: avatarPackage.fileName,
+            contentType: avatarPackage.contentType
+          });
+          if (!uploaded.fileUniqueId) {
+            throw new Error("inline_bot_avatar: upload did not return fileUniqueId");
+          }
+          const result = await client.invokeRaw(Method.SET_BOT_AVATAR, {
+            oneofKind: "setBotAvatar",
+            setBotAvatar: {
+              botUserId: me.userId,
+              kind: BotAvatar_Kind.CODEX_ATLAS,
+              displayName: avatarPackage.displayName,
+              ...avatarPackage.description ? { description: avatarPackage.description } : {},
+              fileUniqueId: uploaded.fileUniqueId
+            }
+          });
+          if (result.oneofKind !== "setBotAvatar") {
+            throw new Error(`inline_bot_avatar: expected setBotAvatar result, got ${String(result.oneofKind)}`);
+          }
+          return jsonResult({
+            ok: true,
+            accountId: resolvedAccountId,
+            botUserId: String(me.userId),
+            avatar: {
+              kind: CODEX_ATLAS_KIND,
+              ...avatarPackage.id ? { id: avatarPackage.id } : {},
+              displayName: avatarPackage.displayName,
+              ...avatarPackage.description ? { description: avatarPackage.description } : {},
+              spritesheetPath: avatarPackage.spritesheetPath
+            },
+            uploaded: {
+              fileUniqueId: uploaded.fileUniqueId,
+              fileName: avatarPackage.fileName,
+              contentType: avatarPackage.contentType
+            },
+            bot: result.setBotAvatar.bot ?? null
+          });
+        }
+      });
+    }
+  };
+}
+
 // src/inline/profile-tool.ts
 var InlineProfileToolParameters = {
   type: "object",
@@ -38566,7 +39980,7 @@ function jsonResult3(payload) {
     details: payload
   };
 }
-async function withInlineClient4(params) {
+async function withInlineClient5(params) {
   const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
   if (!account.configured || !account.baseUrl) {
     throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
@@ -38583,14 +39997,14 @@ async function withInlineClient4(params) {
     await client.close().catch(() => {});
   }
 }
-function readTrimmedString(value) {
+function readTrimmedString2(value) {
   if (typeof value !== "string")
     return;
   const trimmed = value.trim();
   return trimmed || undefined;
 }
 function resolvePhotoSource(args) {
-  return readTrimmedString(args.photoPath) ?? readTrimmedString(args.photoUrl);
+  return readTrimmedString2(args.photoPath) ?? readTrimmedString2(args.photoUrl);
 }
 async function uploadProfilePhoto(client, rawSource) {
   const runtimeMedia = getInlineRuntime().media;
@@ -38622,18 +40036,18 @@ function createInlineProfileTool(ctx) {
     parameters: InlineProfileToolParameters,
     execute: async (_toolCallId, rawArgs) => {
       const args = rawArgs;
-      const rawName = readTrimmedString(args.name);
+      const rawName = readTrimmedString2(args.name);
       const visibleName = sanitizeInlineVisibleText(rawName);
       if (visibleName.shouldSkip) {
         throw new Error("inline_update_profile: name contains internal runtime text");
       }
-      const name = readTrimmedString(visibleName.text);
-      const existingPhotoFileUniqueId = readTrimmedString(args.photoFileUniqueId);
+      const name = readTrimmedString2(visibleName.text);
+      const existingPhotoFileUniqueId = readTrimmedString2(args.photoFileUniqueId);
       const photoSource = resolvePhotoSource(args);
       if (!name && !existingPhotoFileUniqueId && !photoSource) {
         throw new Error("inline_update_profile: provide `name` and/or `photo`");
       }
-      return await withInlineClient4({
+      return await withInlineClient5({
         cfg: ctx.config,
         accountId: args.accountId ?? ctx.agentAccountId ?? null,
         fn: async (client, resolvedAccountId) => {
@@ -39559,11 +40973,14 @@ function registerInlinePluginFull(api2) {
   api2.registerTool((ctx) => createInlineProfileTool(ctx), {
     names: ["inline_update_profile"]
   });
+  api2.registerTool((ctx) => createInlineBotAvatarTool(ctx), {
+    names: ["inline_bot_avatar"]
+  });
   api2.registerTool((ctx) => createInlineBotCommandsTool(ctx), {
     names: ["inline_bot_commands"]
   });
   api2.registerTool((ctx) => createInlineMessageTools(ctx), {
-    names: ["inline_nudge", "inline_forward"]
+    names: ["inline_nudge", "inline_forward", "inline_bot_presence"]
   });
   api2.registerTool((ctx) => createInlineParentContextTool(ctx), {
     names: ["inline_parent_context"]
@@ -39599,5 +41016,5 @@ export {
   registerInlinePluginFull
 };
 
-//# debugId=5BA7B51393DC41BD64756E2164756E21
+//# debugId=D10D8C4C3B879C9364756E2164756E21
 //# sourceMappingURL=runtime-register-api.js.map