@inline-openclaw/inline 0.0.46 → 0.0.47

package/dist/runtime-register-api.js

@@ -5623,6 +5623,7 @@ var MessageEntity_Type;
   MessageEntity_Type2[MessageEntity_Type2["PHONE_NUMBER"] = 10] = "PHONE_NUMBER";
   MessageEntity_Type2[MessageEntity_Type2["THREAD"] = 11] = "THREAD";
   MessageEntity_Type2[MessageEntity_Type2["THREAD_TITLE"] = 12] = "THREAD_TITLE";
+  MessageEntity_Type2[MessageEntity_Type2["BOT_COMMAND"] = 13] = "BOT_COMMAND";
 })(MessageEntity_Type || (MessageEntity_Type = {}));
 var Member_Role;
 (function(Member_Role2) {
@@ -5671,6 +5672,9 @@ var RpcError_Code;
   RpcError_Code2[RpcError_Code2["PHONE_NUMBER_INVALID"] = 12] = "PHONE_NUMBER_INVALID";
   RpcError_Code2[RpcError_Code2["SPACE_ADMIN_REQUIRED"] = 13] = "SPACE_ADMIN_REQUIRED";
   RpcError_Code2[RpcError_Code2["SPACE_OWNER_REQUIRED"] = 14] = "SPACE_OWNER_REQUIRED";
+  RpcError_Code2[RpcError_Code2["USERNAME_INVALID"] = 15] = "USERNAME_INVALID";
+  RpcError_Code2[RpcError_Code2["USERNAME_TAKEN"] = 16] = "USERNAME_TAKEN";
+  RpcError_Code2[RpcError_Code2["FIRST_NAME_INVALID"] = 17] = "FIRST_NAME_INVALID";
 })(RpcError_Code || (RpcError_Code = {}));
 var GetUpdatesResult_ResultType;
 (function(GetUpdatesResult_ResultType2) {
@@ -5794,7 +5798,23 @@ var Method;
   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";
+  Method2[Method2["GET_SESSIONS"] = 61] = "GET_SESSIONS";
+  Method2[Method2["CHECK_USERNAME"] = 62] = "CHECK_USERNAME";
+  Method2[Method2["CHANGE_USERNAME"] = 63] = "CHANGE_USERNAME";
+  Method2[Method2["UPDATE_PROFILE"] = 64] = "UPDATE_PROFILE";
+  Method2[Method2["GET_SPACE_URL_PREVIEW_EXCLUSIONS"] = 65] = "GET_SPACE_URL_PREVIEW_EXCLUSIONS";
+  Method2[Method2["ADD_SPACE_URL_PREVIEW_EXCLUSION"] = 66] = "ADD_SPACE_URL_PREVIEW_EXCLUSION";
+  Method2[Method2["REMOVE_SPACE_URL_PREVIEW_EXCLUSION"] = 67] = "REMOVE_SPACE_URL_PREVIEW_EXCLUSION";
 })(Method || (Method = {}));
+var UsernameAvailability;
+(function(UsernameAvailability2) {
+  UsernameAvailability2[UsernameAvailability2["USERNAME_AVAILABILITY_UNSPECIFIED"] = 0] = "USERNAME_AVAILABILITY_UNSPECIFIED";
+  UsernameAvailability2[UsernameAvailability2["USERNAME_AVAILABLE"] = 1] = "USERNAME_AVAILABLE";
+  UsernameAvailability2[UsernameAvailability2["USERNAME_CURRENT"] = 2] = "USERNAME_CURRENT";
+  UsernameAvailability2[UsernameAvailability2["USERNAME_TAKEN"] = 3] = "USERNAME_TAKEN";
+  UsernameAvailability2[UsernameAvailability2["USERNAME_RESERVED"] = 4] = "USERNAME_RESERVED";
+  UsernameAvailability2[UsernameAvailability2["USERNAME_INVALID"] = 5] = "USERNAME_INVALID";
+})(UsernameAvailability || (UsernameAvailability = {}));
 var PushNotificationProvider;
 (function(PushNotificationProvider2) {
   PushNotificationProvider2[PushNotificationProvider2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -6808,7 +6828,8 @@ class User$Type extends import_runtime4.MessageType {
       { 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: 14, name: "bot_avatar", kind: "message", T: () => BotAvatar }
+      { no: 14, name: "bot_avatar", kind: "message", T: () => BotAvatar },
+      { no: 15, name: "bio", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -6862,6 +6883,9 @@ class User$Type extends import_runtime4.MessageType {
         case 14:
           message.botAvatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.botAvatar);
           break;
+        case 15:
+          message.bio = reader.string();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -6900,6 +6924,8 @@ class User$Type extends import_runtime4.MessageType {
       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();
+    if (message.bio !== undefined)
+      writer.tag(15, import_runtime.WireType.LengthDelimited).string(message.bio);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -10067,7 +10093,14 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { 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 }
+      { no: 61, name: "updateDialogFollowMode", kind: "message", oneof: "input", T: () => UpdateDialogFollowModeInput },
+      { no: 62, name: "getSessions", kind: "message", oneof: "input", T: () => GetSessionsInput },
+      { no: 63, name: "checkUsername", kind: "message", oneof: "input", T: () => CheckUsernameInput },
+      { no: 64, name: "changeUsername", kind: "message", oneof: "input", T: () => ChangeUsernameInput },
+      { no: 65, name: "updateProfile", kind: "message", oneof: "input", T: () => UpdateProfileInput },
+      { no: 66, name: "getSpaceUrlPreviewExclusions", kind: "message", oneof: "input", T: () => GetSpaceUrlPreviewExclusionsInput },
+      { no: 67, name: "addSpaceUrlPreviewExclusion", kind: "message", oneof: "input", T: () => AddSpaceUrlPreviewExclusionInput },
+      { no: 68, name: "removeSpaceUrlPreviewExclusion", kind: "message", oneof: "input", T: () => RemoveSpaceUrlPreviewExclusionInput }
     ]);
   }
   create(value) {
@@ -10446,6 +10479,48 @@ class RpcCall$Type extends import_runtime4.MessageType {
             updateDialogFollowMode: UpdateDialogFollowModeInput.internalBinaryRead(reader, reader.uint32(), options, message.input.updateDialogFollowMode)
           };
           break;
+        case 62:
+          message.input = {
+            oneofKind: "getSessions",
+            getSessions: GetSessionsInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getSessions)
+          };
+          break;
+        case 63:
+          message.input = {
+            oneofKind: "checkUsername",
+            checkUsername: CheckUsernameInput.internalBinaryRead(reader, reader.uint32(), options, message.input.checkUsername)
+          };
+          break;
+        case 64:
+          message.input = {
+            oneofKind: "changeUsername",
+            changeUsername: ChangeUsernameInput.internalBinaryRead(reader, reader.uint32(), options, message.input.changeUsername)
+          };
+          break;
+        case 65:
+          message.input = {
+            oneofKind: "updateProfile",
+            updateProfile: UpdateProfileInput.internalBinaryRead(reader, reader.uint32(), options, message.input.updateProfile)
+          };
+          break;
+        case 66:
+          message.input = {
+            oneofKind: "getSpaceUrlPreviewExclusions",
+            getSpaceUrlPreviewExclusions: GetSpaceUrlPreviewExclusionsInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getSpaceUrlPreviewExclusions)
+          };
+          break;
+        case 67:
+          message.input = {
+            oneofKind: "addSpaceUrlPreviewExclusion",
+            addSpaceUrlPreviewExclusion: AddSpaceUrlPreviewExclusionInput.internalBinaryRead(reader, reader.uint32(), options, message.input.addSpaceUrlPreviewExclusion)
+          };
+          break;
+        case 68:
+          message.input = {
+            oneofKind: "removeSpaceUrlPreviewExclusion",
+            removeSpaceUrlPreviewExclusion: RemoveSpaceUrlPreviewExclusionInput.internalBinaryRead(reader, reader.uint32(), options, message.input.removeSpaceUrlPreviewExclusion)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10580,6 +10655,20 @@ class RpcCall$Type extends import_runtime4.MessageType {
       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();
+    if (message.input.oneofKind === "getSessions")
+      GetSessionsInput.internalBinaryWrite(message.input.getSessions, writer.tag(62, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "checkUsername")
+      CheckUsernameInput.internalBinaryWrite(message.input.checkUsername, writer.tag(63, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "changeUsername")
+      ChangeUsernameInput.internalBinaryWrite(message.input.changeUsername, writer.tag(64, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "updateProfile")
+      UpdateProfileInput.internalBinaryWrite(message.input.updateProfile, writer.tag(65, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getSpaceUrlPreviewExclusions")
+      GetSpaceUrlPreviewExclusionsInput.internalBinaryWrite(message.input.getSpaceUrlPreviewExclusions, writer.tag(66, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "addSpaceUrlPreviewExclusion")
+      AddSpaceUrlPreviewExclusionInput.internalBinaryWrite(message.input.addSpaceUrlPreviewExclusion, writer.tag(67, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "removeSpaceUrlPreviewExclusion")
+      RemoveSpaceUrlPreviewExclusionInput.internalBinaryWrite(message.input.removeSpaceUrlPreviewExclusion, writer.tag(68, 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);
@@ -10651,7 +10740,14 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { 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 }
+      { no: 61, name: "updateDialogFollowMode", kind: "message", oneof: "result", T: () => UpdateDialogFollowModeResult },
+      { no: 62, name: "getSessions", kind: "message", oneof: "result", T: () => GetSessionsResult },
+      { no: 63, name: "checkUsername", kind: "message", oneof: "result", T: () => CheckUsernameResult },
+      { no: 64, name: "changeUsername", kind: "message", oneof: "result", T: () => ChangeUsernameResult },
+      { no: 65, name: "updateProfile", kind: "message", oneof: "result", T: () => UpdateProfileResult },
+      { no: 66, name: "getSpaceUrlPreviewExclusions", kind: "message", oneof: "result", T: () => GetSpaceUrlPreviewExclusionsResult },
+      { no: 67, name: "addSpaceUrlPreviewExclusion", kind: "message", oneof: "result", T: () => AddSpaceUrlPreviewExclusionResult },
+      { no: 68, name: "removeSpaceUrlPreviewExclusion", kind: "message", oneof: "result", T: () => RemoveSpaceUrlPreviewExclusionResult }
     ]);
   }
   create(value) {
@@ -11030,6 +11126,48 @@ class RpcResult$Type extends import_runtime4.MessageType {
             updateDialogFollowMode: UpdateDialogFollowModeResult.internalBinaryRead(reader, reader.uint32(), options, message.result.updateDialogFollowMode)
           };
           break;
+        case 62:
+          message.result = {
+            oneofKind: "getSessions",
+            getSessions: GetSessionsResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getSessions)
+          };
+          break;
+        case 63:
+          message.result = {
+            oneofKind: "checkUsername",
+            checkUsername: CheckUsernameResult.internalBinaryRead(reader, reader.uint32(), options, message.result.checkUsername)
+          };
+          break;
+        case 64:
+          message.result = {
+            oneofKind: "changeUsername",
+            changeUsername: ChangeUsernameResult.internalBinaryRead(reader, reader.uint32(), options, message.result.changeUsername)
+          };
+          break;
+        case 65:
+          message.result = {
+            oneofKind: "updateProfile",
+            updateProfile: UpdateProfileResult.internalBinaryRead(reader, reader.uint32(), options, message.result.updateProfile)
+          };
+          break;
+        case 66:
+          message.result = {
+            oneofKind: "getSpaceUrlPreviewExclusions",
+            getSpaceUrlPreviewExclusions: GetSpaceUrlPreviewExclusionsResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getSpaceUrlPreviewExclusions)
+          };
+          break;
+        case 67:
+          message.result = {
+            oneofKind: "addSpaceUrlPreviewExclusion",
+            addSpaceUrlPreviewExclusion: AddSpaceUrlPreviewExclusionResult.internalBinaryRead(reader, reader.uint32(), options, message.result.addSpaceUrlPreviewExclusion)
+          };
+          break;
+        case 68:
+          message.result = {
+            oneofKind: "removeSpaceUrlPreviewExclusion",
+            removeSpaceUrlPreviewExclusion: RemoveSpaceUrlPreviewExclusionResult.internalBinaryRead(reader, reader.uint32(), options, message.result.removeSpaceUrlPreviewExclusion)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -11164,6 +11302,20 @@ class RpcResult$Type extends import_runtime4.MessageType {
       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();
+    if (message.result.oneofKind === "getSessions")
+      GetSessionsResult.internalBinaryWrite(message.result.getSessions, writer.tag(62, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "checkUsername")
+      CheckUsernameResult.internalBinaryWrite(message.result.checkUsername, writer.tag(63, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "changeUsername")
+      ChangeUsernameResult.internalBinaryWrite(message.result.changeUsername, writer.tag(64, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "updateProfile")
+      UpdateProfileResult.internalBinaryWrite(message.result.updateProfile, writer.tag(65, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getSpaceUrlPreviewExclusions")
+      GetSpaceUrlPreviewExclusionsResult.internalBinaryWrite(message.result.getSpaceUrlPreviewExclusions, writer.tag(66, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "addSpaceUrlPreviewExclusion")
+      AddSpaceUrlPreviewExclusionResult.internalBinaryWrite(message.result.addSpaceUrlPreviewExclusion, writer.tag(67, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "removeSpaceUrlPreviewExclusion")
+      RemoveSpaceUrlPreviewExclusionResult.internalBinaryWrite(message.result.removeSpaceUrlPreviewExclusion, writer.tag(68, 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);
@@ -11745,14 +11897,23 @@ class UpdateMemberAccessResult$Type extends import_runtime4.MessageType {
 }
 var UpdateMemberAccessResult = new UpdateMemberAccessResult$Type;
 
-class GetUpdatesStateInput$Type extends import_runtime4.MessageType {
+class SpaceUrlPreviewExclusion$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetUpdatesStateInput", [
-      { no: 2, name: "date", kind: "scalar", T: 3, L: 0 }
+    super("SpaceUrlPreviewExclusion", [
+      { no: 1, name: "id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "space_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "host", kind: "scalar", T: 9 },
+      { no: 4, name: "path_prefix", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "created_by", kind: "scalar", T: 3, L: 0 },
+      { no: 6, name: "date", kind: "scalar", T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.id = 0n;
+    message.spaceId = 0n;
+    message.host = "";
+    message.createdBy = 0n;
     message.date = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
@@ -11763,7 +11924,22 @@ class GetUpdatesStateInput$Type extends import_runtime4.MessageType {
     while (reader.pos < end) {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
+        case 1:
+          message.id = reader.int64().toBigInt();
+          break;
         case 2:
+          message.spaceId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.host = reader.string();
+          break;
+        case 4:
+          message.pathPrefix = reader.string();
+          break;
+        case 5:
+          message.createdBy = reader.int64().toBigInt();
+          break;
+        case 6:
           message.date = reader.int64().toBigInt();
           break;
         default:
@@ -11778,25 +11954,35 @@ class GetUpdatesStateInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
+    if (message.id !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.id);
+    if (message.spaceId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.host !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.host);
+    if (message.pathPrefix !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.pathPrefix);
+    if (message.createdBy !== 0n)
+      writer.tag(5, import_runtime.WireType.Varint).int64(message.createdBy);
     if (message.date !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.date);
+      writer.tag(6, import_runtime.WireType.Varint).int64(message.date);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetUpdatesStateInput = new GetUpdatesStateInput$Type;
+var SpaceUrlPreviewExclusion = new SpaceUrlPreviewExclusion$Type;
 
-class GetUpdatesStateResult$Type extends import_runtime4.MessageType {
+class GetSpaceUrlPreviewExclusionsInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetUpdatesStateResult", [
-      { no: 1, name: "date", kind: "scalar", T: 3, L: 0 }
+    super("GetSpaceUrlPreviewExclusionsInput", [
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.date = 0n;
+    message.spaceId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -11807,7 +11993,7 @@ class GetUpdatesStateResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.date = reader.int64().toBigInt();
+          message.spaceId = reader.int64().toBigInt();
           break;
         default:
           let u = options.readUnknownField;
@@ -11821,24 +12007,25 @@ class GetUpdatesStateResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.date !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.date);
+    if (message.spaceId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetUpdatesStateResult = new GetUpdatesStateResult$Type;
+var GetSpaceUrlPreviewExclusionsInput = new GetSpaceUrlPreviewExclusionsInput$Type;
 
-class GetChatInput$Type extends import_runtime4.MessageType {
+class GetSpaceUrlPreviewExclusionsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetChatInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    super("GetSpaceUrlPreviewExclusionsResult", [
+      { no: 1, name: "exclusions", kind: "message", repeat: 1, T: () => SpaceUrlPreviewExclusion }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.exclusions = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -11849,7 +12036,7 @@ class GetChatInput$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.exclusions.push(SpaceUrlPreviewExclusion.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -11863,28 +12050,30 @@ class GetChatInput$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();
+    for (let i = 0;i < message.exclusions.length; i++)
+      SpaceUrlPreviewExclusion.internalBinaryWrite(message.exclusions[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 GetChatInput = new GetChatInput$Type;
+var GetSpaceUrlPreviewExclusionsResult = new GetSpaceUrlPreviewExclusionsResult$Type;
 
-class GetChatResult$Type extends import_runtime4.MessageType {
+class AddSpaceUrlPreviewExclusionInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetChatResult", [
-      { no: 1, name: "chat", kind: "message", T: () => Chat },
-      { no: 2, name: "dialog", kind: "message", T: () => Dialog },
-      { no: 3, name: "pinned_message_ids", kind: "scalar", repeat: 1, T: 3, L: 0 },
-      { no: 4, name: "anchor_message", kind: "message", T: () => Message }
+    super("AddSpaceUrlPreviewExclusionInput", [
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "host", kind: "scalar", T: 9 },
+      { no: 3, name: "path_prefix", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 5, name: "message_id", kind: "scalar", opt: true, T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.pinnedMessageIds = [];
+    message.spaceId = 0n;
+    message.host = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -11895,20 +12084,19 @@ class GetChatResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          message.spaceId = reader.int64().toBigInt();
           break;
         case 2:
-          message.dialog = Dialog.internalBinaryRead(reader, reader.uint32(), options, message.dialog);
+          message.host = reader.string();
           break;
         case 3:
-          if (wireType === import_runtime.WireType.LengthDelimited)
-            for (let e = reader.int32() + reader.pos;reader.pos < e; )
-              message.pinnedMessageIds.push(reader.int64().toBigInt());
-          else
-            message.pinnedMessageIds.push(reader.int64().toBigInt());
+          message.pathPrefix = reader.string();
           break;
         case 4:
-          message.anchorMessage = Message.internalBinaryRead(reader, reader.uint32(), options, message.anchorMessage);
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 5:
+          message.messageId = reader.int64().toBigInt();
           break;
         default:
           let u = options.readUnknownField;
@@ -11922,29 +12110,351 @@ class GetChatResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.chat)
-      Chat.internalBinaryWrite(message.chat, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.dialog)
-      Dialog.internalBinaryWrite(message.dialog, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.pinnedMessageIds.length) {
-      writer.tag(3, import_runtime.WireType.LengthDelimited).fork();
-      for (let i = 0;i < message.pinnedMessageIds.length; i++)
-        writer.int64(message.pinnedMessageIds[i]);
-      writer.join();
+    if (message.spaceId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.host !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.host);
+    if (message.pathPrefix !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.pathPrefix);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.messageId !== undefined)
+      writer.tag(5, import_runtime.WireType.Varint).int64(message.messageId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AddSpaceUrlPreviewExclusionInput = new AddSpaceUrlPreviewExclusionInput$Type;
+
+class AddSpaceUrlPreviewExclusionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AddSpaceUrlPreviewExclusionResult", [
+      { no: 1, name: "exclusion", kind: "message", T: () => SpaceUrlPreviewExclusion },
+      { no: 2, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.updates = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.exclusion = SpaceUrlPreviewExclusion.internalBinaryRead(reader, reader.uint32(), options, message.exclusion);
+          break;
+        case 2:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
     }
-    if (message.anchorMessage)
-      Message.internalBinaryWrite(message.anchorMessage, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.exclusion)
+      SpaceUrlPreviewExclusion.internalBinaryWrite(message.exclusion, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetChatResult = new GetChatResult$Type;
+var AddSpaceUrlPreviewExclusionResult = new AddSpaceUrlPreviewExclusionResult$Type;
 
-class ShowInChatListInput$Type extends import_runtime4.MessageType {
+class RemoveSpaceUrlPreviewExclusionInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("ShowInChatListInput", [
+    super("RemoveSpaceUrlPreviewExclusionInput", [
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "exclusion_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.spaceId = 0n;
+    message.exclusionId = 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.spaceId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.exclusionId = 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.spaceId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.exclusionId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.exclusionId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RemoveSpaceUrlPreviewExclusionInput = new RemoveSpaceUrlPreviewExclusionInput$Type;
+
+class RemoveSpaceUrlPreviewExclusionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RemoveSpaceUrlPreviewExclusionResult", []);
+  }
+  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 RemoveSpaceUrlPreviewExclusionResult = new RemoveSpaceUrlPreviewExclusionResult$Type;
+
+class GetUpdatesStateInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetUpdatesStateInput", [
+      { no: 2, name: "date", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.date = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 2:
+          message.date = 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.date !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.date);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetUpdatesStateInput = new GetUpdatesStateInput$Type;
+
+class GetUpdatesStateResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetUpdatesStateResult", [
+      { no: 1, name: "date", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "updates_found", kind: "scalar", opt: true, T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.date = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.date = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.updatesFound = 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.date !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.date);
+    if (message.updatesFound !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.updatesFound);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetUpdatesStateResult = new GetUpdatesStateResult$Type;
+
+class GetChatInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetChatInput", [
+      { 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 GetChatInput = new GetChatInput$Type;
+
+class GetChatResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetChatResult", [
+      { no: 1, name: "chat", kind: "message", T: () => Chat },
+      { no: 2, name: "dialog", kind: "message", T: () => Dialog },
+      { no: 3, name: "pinned_message_ids", kind: "scalar", repeat: 1, T: 3, L: 0 },
+      { no: 4, name: "anchor_message", kind: "message", T: () => Message }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.pinnedMessageIds = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          break;
+        case 2:
+          message.dialog = Dialog.internalBinaryRead(reader, reader.uint32(), options, message.dialog);
+          break;
+        case 3:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos;reader.pos < e; )
+              message.pinnedMessageIds.push(reader.int64().toBigInt());
+          else
+            message.pinnedMessageIds.push(reader.int64().toBigInt());
+          break;
+        case 4:
+          message.anchorMessage = Message.internalBinaryRead(reader, reader.uint32(), options, message.anchorMessage);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chat)
+      Chat.internalBinaryWrite(message.chat, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.dialog)
+      Dialog.internalBinaryWrite(message.dialog, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.pinnedMessageIds.length) {
+      writer.tag(3, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0;i < message.pinnedMessageIds.length; i++)
+        writer.int64(message.pinnedMessageIds[i]);
+      writer.join();
+    }
+    if (message.anchorMessage)
+      Message.internalBinaryWrite(message.anchorMessage, 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 GetChatResult = new GetChatResult$Type;
+
+class ShowInChatListInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ShowInChatListInput", [
       { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
     ]);
   }
@@ -12970,18 +13480,53 @@ class RevokeSessionResult$Type extends import_runtime4.MessageType {
 }
 var RevokeSessionResult = new RevokeSessionResult$Type;
 
-class BotCommand$Type extends import_runtime4.MessageType {
+class GetSessionsInput$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("GetSessionsInput", []);
+  }
+  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 GetSessionsInput = new GetSessionsInput$Type;
+
+class AccountSession$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AccountSession", [
+      { no: 1, name: "id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "client_type", kind: "scalar", T: 9 },
+      { no: 3, name: "client_version", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "os_version", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "device_name", kind: "scalar", opt: true, T: 9 },
+      { no: 6, name: "city", kind: "scalar", opt: true, T: 9 },
+      { no: 7, name: "country", kind: "scalar", opt: true, T: 9 },
+      { no: 8, name: "timezone", kind: "scalar", opt: true, T: 9 },
+      { no: 9, name: "created_at", kind: "scalar", T: 3, L: 0 },
+      { no: 10, name: "last_active_at", kind: "scalar", T: 3, L: 0 },
+      { no: 11, name: "active", kind: "scalar", T: 8 },
+      { no: 12, name: "current", kind: "scalar", T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.command = "";
-    message.description = "";
+    message.id = 0n;
+    message.clientType = "";
+    message.createdAt = 0n;
+    message.lastActiveAt = 0n;
+    message.active = false;
+    message.current = false;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12992,13 +13537,40 @@ class BotCommand$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.command = reader.string();
+          message.id = reader.int64().toBigInt();
           break;
         case 2:
-          message.description = reader.string();
+          message.clientType = reader.string();
           break;
         case 3:
-          message.sortOrder = reader.int32();
+          message.clientVersion = reader.string();
+          break;
+        case 4:
+          message.osVersion = reader.string();
+          break;
+        case 5:
+          message.deviceName = reader.string();
+          break;
+        case 6:
+          message.city = reader.string();
+          break;
+        case 7:
+          message.country = reader.string();
+          break;
+        case 8:
+          message.timezone = reader.string();
+          break;
+        case 9:
+          message.createdAt = reader.int64().toBigInt();
+          break;
+        case 10:
+          message.lastActiveAt = reader.int64().toBigInt();
+          break;
+        case 11:
+          message.active = reader.bool();
+          break;
+        case 12:
+          message.current = reader.bool();
           break;
         default:
           let u = options.readUnknownField;
@@ -13012,30 +13584,47 @@ 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.id !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.id);
+    if (message.clientType !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.clientType);
+    if (message.clientVersion !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.clientVersion);
+    if (message.osVersion !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.osVersion);
+    if (message.deviceName !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.deviceName);
+    if (message.city !== undefined)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.city);
+    if (message.country !== undefined)
+      writer.tag(7, import_runtime.WireType.LengthDelimited).string(message.country);
+    if (message.timezone !== undefined)
+      writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.timezone);
+    if (message.createdAt !== 0n)
+      writer.tag(9, import_runtime.WireType.Varint).int64(message.createdAt);
+    if (message.lastActiveAt !== 0n)
+      writer.tag(10, import_runtime.WireType.Varint).int64(message.lastActiveAt);
+    if (message.active !== false)
+      writer.tag(11, import_runtime.WireType.Varint).bool(message.active);
+    if (message.current !== false)
+      writer.tag(12, import_runtime.WireType.Varint).bool(message.current);
     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 AccountSession = new AccountSession$Type;
 
-class PeerBotCommands$Type extends import_runtime4.MessageType {
+class GetSessionsResult$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("GetSessionsResult", [
+      { no: 1, name: "sessions", kind: "message", repeat: 1, T: () => AccountSession }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
+    message.sessions = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13046,10 +13635,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.sessions.push(AccountSession.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -13063,27 +13649,25 @@ 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();
+    for (let i = 0;i < message.sessions.length; i++)
+      AccountSession.internalBinaryWrite(message.sessions[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 PeerBotCommands = new PeerBotCommands$Type;
+var GetSessionsResult = new GetSessionsResult$Type;
 
-class GetBotCommandsInput$Type extends import_runtime4.MessageType {
+class CheckUsernameInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetBotCommandsInput", [
-      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    super("CheckUsernameInput", [
+      { no: 1, name: "username", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.botUserId = 0n;
+    message.username = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13094,7 +13678,7 @@ class GetBotCommandsInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
+          message.username = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -13108,25 +13692,27 @@ class GetBotCommandsInput$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.username !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.username);
     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;
+var CheckUsernameInput = new CheckUsernameInput$Type;
 
-class GetBotCommandsResult$Type extends import_runtime4.MessageType {
+class CheckUsernameResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetBotCommandsResult", [
-      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("CheckUsernameResult", [
+      { no: 1, name: "username", kind: "scalar", T: 9 },
+      { no: 2, name: "availability", kind: "enum", T: () => ["UsernameAvailability", UsernameAvailability] }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
+    message.username = "";
+    message.availability = 0;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13137,7 +13723,10 @@ 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.username = reader.string();
+          break;
+        case 2:
+          message.availability = reader.int32();
           break;
         default:
           let u = options.readUnknownField;
@@ -13151,27 +13740,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.username !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.username);
+    if (message.availability !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.availability);
     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 CheckUsernameResult = new CheckUsernameResult$Type;
 
-class SetBotCommandsInput$Type extends import_runtime4.MessageType {
+class ChangeUsernameInput$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 }
+    super("ChangeUsernameInput", [
+      { no: 1, name: "username", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.botUserId = 0n;
-    message.commands = [];
+    message.username = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13182,10 +13771,7 @@ class SetBotCommandsInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
-          break;
-        case 2:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.username = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -13199,27 +13785,26 @@ class SetBotCommandsInput$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);
-    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.username !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.username);
     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 ChangeUsernameInput = new ChangeUsernameInput$Type;
 
-class SetBotCommandsResult$Type extends import_runtime4.MessageType {
+class ChangeUsernameResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SetBotCommandsResult", [
-      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("ChangeUsernameResult", [
+      { no: 1, name: "user", kind: "message", T: () => User },
+      { no: 2, name: "updates", kind: "message", repeat: 1, T: () => Update }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
+    message.updates = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13230,7 +13815,10 @@ 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.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          break;
+        case 2:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -13244,20 +13832,24 @@ 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.user)
+      User.internalBinaryWrite(message.user, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SetBotCommandsResult = new SetBotCommandsResult$Type;
+var ChangeUsernameResult = new ChangeUsernameResult$Type;
 
-class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
+class UpdateProfileInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetPeerBotCommandsInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    super("UpdateProfileInput", [
+      { no: 1, name: "first_name", kind: "scalar", opt: true, T: 9 },
+      { no: 2, name: "last_name", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "bio", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -13272,7 +13864,13 @@ 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.firstName = reader.string();
+          break;
+        case 2:
+          message.lastName = reader.string();
+          break;
+        case 3:
+          message.bio = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -13286,25 +13884,30 @@ 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.firstName !== undefined)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.firstName);
+    if (message.lastName !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.lastName);
+    if (message.bio !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.bio);
     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 UpdateProfileInput = new UpdateProfileInput$Type;
 
-class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
+class UpdateProfileResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetPeerBotCommandsResult", [
-      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
+    super("UpdateProfileResult", [
+      { no: 1, name: "user", kind: "message", T: () => User },
+      { no: 2, name: "updates", kind: "message", repeat: 1, T: () => Update }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.bots = [];
+    message.updates = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13315,7 +13918,10 @@ 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.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          break;
+        case 2:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -13329,25 +13935,30 @@ 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.user)
+      User.internalBinaryWrite(message.user, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
+var UpdateProfileResult = new UpdateProfileResult$Type;
 
-class RevealBotTokenInput$Type extends import_runtime4.MessageType {
+class BotCommand$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevealBotTokenInput", [
-      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    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.botUserId = 0n;
+    message.command = "";
+    message.description = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13358,7 +13969,13 @@ class RevealBotTokenInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
+          message.command = reader.string();
+          break;
+        case 2:
+          message.description = reader.string();
+          break;
+        case 3:
+          message.sortOrder = reader.int32();
           break;
         default:
           let u = options.readUnknownField;
@@ -13372,25 +13989,30 @@ class RevealBotTokenInput$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.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 RevealBotTokenInput = new RevealBotTokenInput$Type;
+var BotCommand = new BotCommand$Type;
 
-class RevealBotTokenResult$Type extends import_runtime4.MessageType {
+class PeerBotCommands$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevealBotTokenResult", [
-      { no: 1, name: "token", kind: "scalar", T: 9 }
+    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.token = "";
+    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13401,7 +14023,10 @@ 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;
+        case 2:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -13415,19 +14040,371 @@ 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();
+    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 RevealBotTokenResult = new RevealBotTokenResult$Type;
+var PeerBotCommands = new PeerBotCommands$Type;
 
-class RotateBotTokenInput$Type extends import_runtime4.MessageType {
+class GetBotCommandsInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RotateBotTokenInput", [
+    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 GetBotCommandsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.commands = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetBotCommandsResult = new GetBotCommandsResult$Type;
+
+class SetBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotCommandsInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.commands = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SetBotCommandsInput = new SetBotCommandsInput$Type;
+
+class SetBotCommandsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.commands = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SetBotCommandsResult = new SetBotCommandsResult$Type;
+
+class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetPeerBotCommandsInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetPeerBotCommandsInput = new GetPeerBotCommandsInput$Type;
+
+class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetPeerBotCommandsResult", [
+      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.bots = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.bots.push(PeerBotCommands.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.bots.length; i++)
+      PeerBotCommands.internalBinaryWrite(message.bots[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
+
+class RevealBotTokenInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevealBotTokenInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevealBotTokenInput = new RevealBotTokenInput$Type;
+
+class RevealBotTokenResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevealBotTokenResult", [
+      { no: 1, name: "token", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.token = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.token = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.token !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevealBotTokenResult = new RevealBotTokenResult$Type;
+
+class RotateBotTokenInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RotateBotTokenInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
@@ -17117,7 +18094,8 @@ class Update$Type extends import_runtime4.MessageType {
       { 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: 38, name: "bot_presence", kind: "message", oneof: "update", T: () => UpdateBotPresence },
-      { no: 39, name: "dialog_follow_mode", kind: "message", oneof: "update", T: () => UpdateDialogFollowMode }
+      { no: 39, name: "dialog_follow_mode", kind: "message", oneof: "update", T: () => UpdateDialogFollowMode },
+      { no: 40, name: "updated_user", kind: "message", oneof: "update", T: () => UpdateUpdatedUser }
     ]);
   }
   create(value) {
@@ -17354,6 +18332,12 @@ class Update$Type extends import_runtime4.MessageType {
             dialogFollowMode: UpdateDialogFollowMode.internalBinaryRead(reader, reader.uint32(), options, message.update.dialogFollowMode)
           };
           break;
+        case 40:
+          message.update = {
+            oneofKind: "updatedUser",
+            updatedUser: UpdateUpdatedUser.internalBinaryRead(reader, reader.uint32(), options, message.update.updatedUser)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -17442,6 +18426,8 @@ class Update$Type extends import_runtime4.MessageType {
       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();
+    if (message.update.oneofKind === "updatedUser")
+      UpdateUpdatedUser.internalBinaryWrite(message.update.updatedUser, writer.tag(40, 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);
@@ -17912,6 +18898,48 @@ class UpdateUserSettings$Type extends import_runtime4.MessageType {
 }
 var UpdateUserSettings = new UpdateUserSettings$Type;
 
+class UpdateUpdatedUser$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateUpdatedUser", [
+      { no: 1, name: "user", kind: "message", T: () => User }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.user)
+      User.internalBinaryWrite(message.user, 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 UpdateUpdatedUser = new UpdateUpdatedUser$Type;
+
 class UpdateSpaceMemberAdd$Type extends import_runtime4.MessageType {
   constructor() {
     super("UpdateSpaceMemberAdd", [
@@ -21376,9 +22404,17 @@ var rpcInputKindByMethod = {
   36: "rotateBotToken",
   37: "updateBotProfile",
   38: "getMessages",
+  56: "setBotAvatar",
+  57: "clearBotAvatar",
+  58: "getBotPresence",
+  59: "setBotPresenceState",
   48: "invokeMessageAction",
   49: "answerMessageAction",
-  53: "clearChatHistory"
+  53: "clearChatHistory",
+  61: "getSessions",
+  62: "checkUsername",
+  63: "changeUsername",
+  64: "updateProfile"
 };
 var rpcResultKindByMethod = {
   0: undefined,
@@ -21420,9 +22456,17 @@ var rpcResultKindByMethod = {
   36: "rotateBotToken",
   37: "updateBotProfile",
   38: "getMessages",
+  56: "setBotAvatar",
+  57: "clearBotAvatar",
+  58: "getBotPresence",
+  59: "setBotPresenceState",
   48: "invokeMessageAction",
   49: "answerMessageAction",
-  53: "clearChatHistory"
+  53: "clearChatHistory",
+  61: "getSessions",
+  62: "checkUsername",
+  63: "changeUsername",
+  64: "updateProfile"
 };
 
 // ../sdk/dist/sdk/logger.js
@@ -21472,6 +22516,26 @@ function extractFirstMessageId(updates) {
   }
   return null;
 }
+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;
+  }
+}
 
 class InlineSdkClient {
   options;
@@ -21766,6 +22830,19 @@ class InlineSdkClient {
       }
     });
   }
+  async setBotPresenceState(params) {
+    const peerId = this.inputPeerFromTarget(params, "setBotPresenceState");
+    await this.invoke(Method.SET_BOT_PRESENCE_STATE, {
+      oneofKind: "setBotPresenceState",
+      setBotPresenceState: {
+        peerId,
+        state: {
+          kind: botPresenceStateKind(params.kind),
+          ...params.comment ? { comment: params.comment } : {}
+        }
+      }
+    });
+  }
   async invokeMessageAction(params) {
     const peerId = this.inputPeerFromTarget(params, "invokeMessageAction");
     const actionId = params.actionId.trim();
@@ -21872,8 +22949,11 @@ class InlineSdkClient {
         oneofKind: "getUpdatesState",
         getUpdatesState: GetUpdatesStateInput.create({ date })
       }, { timeoutMs: 1500 });
-      this.state.dateCursor = result.getUpdatesState.date;
-      this.scheduleStateSave();
+      const state = result.getUpdatesState;
+      if (state.updatesFound === false) {
+        this.state.dateCursor = state.date;
+        this.scheduleStateSave();
+      }
     } catch (error) {
       this.log.warn?.("GET_UPDATES_STATE failed (continuing without date cursor)", error);
     }
@@ -37289,6 +38369,7 @@ var InlineActionsSchema = exports_external.object({
   reactions: exports_external.boolean().optional(),
   read: exports_external.boolean().optional(),
   search: exports_external.boolean().optional(),
+  translate: exports_external.boolean().optional(),
   edit: exports_external.boolean().optional(),
   channels: exports_external.boolean().optional(),
   participants: exports_external.boolean().optional(),
@@ -37412,6 +38493,8 @@ var InlineAccountSchemaBase = exports_external.object({
   dmHistoryLimit: exports_external.number().int().min(0).optional(),
   parseMarkdown: exports_external.boolean().optional(),
   mediaMaxMb: exports_external.number().positive().optional(),
+  debounceMs: exports_external.number().int().min(0).optional(),
+  voiceTranscriptWaitMs: exports_external.number().int().min(0).max(60000).optional(),
   actions: InlineActionsSchema.optional(),
   reactionNotifications: InlineReactionNotificationsSchema.optional(),
   reactionAllowlist: exports_external.array(InlineAllowEntrySchema).optional(),
@@ -37785,6 +38868,7 @@ var OPENCLAW_LEGACY_UNTRUSTED_RESULT_BEGIN = "<<<BEGIN_UNTRUSTED_CHILD_RESULT>>>
 var OPENCLAW_LEGACY_UNTRUSTED_RESULT_END = "<<<END_UNTRUSTED_CHILD_RESULT>>>";
 var INLINE_ACTION_LABEL_MAX_LENGTH = 64;
 var INLINE_ACTION_CALLBACK_DATA_MAX_BYTES = 1024;
+var INLINE_ACTION_COPY_TEXT_MAX_LENGTH = 4096;
 var utf8Encoder = new TextEncoder;
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -38003,6 +39087,14 @@ function sanitizeInlineActionCallbackData(raw) {
     return null;
   return text;
 }
+function sanitizeInlineActionCopyText(raw) {
+  const text = raw?.trim();
+  if (!text)
+    return null;
+  if (text.length > INLINE_ACTION_COPY_TEXT_MAX_LENGTH)
+    return null;
+  return text;
+}
 
 // src/inline/normalize.ts
 function normalizeInlineTarget(raw) {
@@ -38249,6 +39341,11 @@ var InlineBotPresenceToolParameters = {
   type: "object",
   additionalProperties: false,
   properties: {
+    action: {
+      type: "string",
+      enum: ["set", "get"],
+      description: "Presence operation. Defaults to `set`; use `get` to read the current bot avatar/state for a peer."
+    },
     kind: {
       type: "string",
       enum: INLINE_BOT_PRESENCE_KINDS,
@@ -38279,9 +39376,10 @@ var InlineBotPresenceToolParameters = {
       type: "string",
       description: "Optional Inline account id override."
     }
-  },
-  required: ["kind"]
+  }
 };
+var GET_BOT_PRESENCE_METHOD = typeof Method.GET_BOT_PRESENCE === "number" && Number.isInteger(Method.GET_BOT_PRESENCE) && Method.GET_BOT_PRESENCE > 0 ? Method.GET_BOT_PRESENCE : 58;
+var SET_BOT_PRESENCE_STATE_METHOD = typeof Method.SET_BOT_PRESENCE_STATE === "number" && Number.isInteger(Method.SET_BOT_PRESENCE_STATE) && Method.SET_BOT_PRESENCE_STATE > 0 ? Method.SET_BOT_PRESENCE_STATE : 59;
 function resolvePeerTarget(params) {
   if (params.direct) {
     return {
@@ -38373,7 +39471,15 @@ function normalizeInlineBotPresenceKind(value) {
   }
   throw new Error(`inline_bot_presence: invalid kind "${value}"`);
 }
-function botPresenceStateKind(kind) {
+function resolveInlineBotPresenceAction(args) {
+  const action = typeof args.action === "string" ? args.action.trim().toLowerCase() : "";
+  if (!action || action === "set" || action === "update")
+    return "set";
+  if (action === "get" || action === "read" || action === "status")
+    return "get";
+  throw new Error(`inline_bot_presence: invalid action "${args.action}"`);
+}
+function botPresenceStateKind2(kind) {
   switch (kind) {
     case "idle":
       return BotPresenceState_Kind.IDLE;
@@ -38393,6 +39499,28 @@ function botPresenceStateKind(kind) {
       return BotPresenceState_Kind.REVIEW;
   }
 }
+function botPresenceKindFromState(kind) {
+  switch (kind) {
+    case BotPresenceState_Kind.IDLE:
+      return "idle";
+    case BotPresenceState_Kind.HAPPY:
+      return "happy";
+    case BotPresenceState_Kind.WAVING:
+      return "waving";
+    case BotPresenceState_Kind.JUMPING:
+      return "jumping";
+    case BotPresenceState_Kind.FAILED:
+      return "failed";
+    case BotPresenceState_Kind.WAITING:
+      return "waiting";
+    case BotPresenceState_Kind.RUNNING:
+      return "running";
+    case BotPresenceState_Kind.REVIEW:
+      return "review";
+    default:
+      return null;
+  }
+}
 function normalizeInlineBotPresenceComment(value) {
   if (typeof value !== "string")
     return;
@@ -38485,6 +39613,7 @@ function createInlineBotPresenceTool(ctx) {
         throw new Error("inline_bot_presence: missing OpenClaw config");
       }
       const args = rawArgs;
+      const action = resolveInlineBotPresenceAction(args);
       const fallbackTarget = parseCurrentInlineTarget(ctx);
       const { target, usedFallback } = resolvePeerTarget({
         label: "target",
@@ -38493,24 +39622,56 @@ function createInlineBotPresenceTool(ctx) {
         userId: args.userId,
         fallback: fallbackTarget
       });
+      if (action === "get") {
+        return await withInlineClient({
+          cfg: ctx.config,
+          accountId: args.accountId ?? ctx.agentAccountId ?? null,
+          fn: async (client, resolvedAccountId) => {
+            const result = await client.invokeRaw(GET_BOT_PRESENCE_METHOD, {
+              oneofKind: "getBotPresence",
+              getBotPresence: {
+                peerId: target.peerId
+              }
+            });
+            if (result.oneofKind !== "getBotPresence") {
+              throw new Error(`inline_bot_presence: expected getBotPresence result, got ${String(result.oneofKind)}`);
+            }
+            const state = result.getBotPresence.state ?? null;
+            return jsonResult({
+              ok: true,
+              action,
+              accountId: resolvedAccountId,
+              target: target.normalized,
+              usedCurrentChatDefault: usedFallback,
+              botUserId: result.getBotPresence.botUserId != null ? String(result.getBotPresence.botUserId) : null,
+              avatar: result.getBotPresence.avatar ?? null,
+              state,
+              kind: state ? botPresenceKindFromState(state.kind) : null,
+              comment: typeof state?.comment === "string" ? state.comment : null,
+              peerId: result.getBotPresence.peerId ?? null
+            });
+          }
+        });
+      }
       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, {
+          await client.invokeRaw(SET_BOT_PRESENCE_STATE_METHOD, {
             oneofKind: "setBotPresenceState",
             setBotPresenceState: {
               peerId: target.peerId,
               state: {
-                kind: botPresenceStateKind(kind),
+                kind: botPresenceStateKind2(kind),
                 ...comment ? { comment } : {}
               }
             }
           });
           return jsonResult({
             ok: true,
+            action,
             accountId: resolvedAccountId,
             target: target.normalized,
             usedCurrentChatDefault: usedFallback,
@@ -38645,7 +39806,11 @@ var InlineMembersToolParameters = {
   properties: {
     spaceId: {
       type: "string",
-      description: "Inline space id whose members should be listed."
+      description: "Inline space id whose members should be listed. Optional inside an Inline space chat/reply thread."
+    },
+    space: {
+      type: "string",
+      description: "Alias for spaceId."
     },
     query: {
       type: "string",
@@ -38663,9 +39828,9 @@ var InlineMembersToolParameters = {
       type: "string",
       description: "Optional Inline account id override."
     }
-  },
-  required: ["spaceId"]
+  }
 };
+var GET_CHAT_METHOD = typeof Method.GET_CHAT === "number" && Number.isInteger(Method.GET_CHAT) && Method.GET_CHAT > 0 ? Method.GET_CHAT : 25;
 function parseRequiredId(raw, label) {
   const trimmed = raw.trim();
   if (!trimmed) {
@@ -38676,6 +39841,11 @@ function parseRequiredId(raw, label) {
   }
   return BigInt(trimmed);
 }
+function parseOptionalId(raw, label) {
+  if (raw == null || !raw.trim())
+    return;
+  return parseRequiredId(raw, label);
+}
 function resolveLimit(raw) {
   const parsed = typeof raw === "number" && Number.isFinite(raw) ? Math.trunc(raw) : 100;
   return Math.max(1, Math.min(200, parsed));
@@ -38726,6 +39896,70 @@ async function withInlineClient2(params) {
     await client.close().catch(() => {});
   }
 }
+function buildChatPeer(chatId) {
+  return {
+    type: {
+      oneofKind: "chat",
+      chat: { chatId }
+    }
+  };
+}
+async function loadChatSpaceId(params) {
+  const result = await params.client.invokeRaw(GET_CHAT_METHOD, {
+    oneofKind: "getChat",
+    getChat: {
+      peerId: buildChatPeer(params.chatId)
+    }
+  });
+  if (result.oneofKind !== "getChat") {
+    throw new Error(`inline_members: expected getChat result, got ${String(result.oneofKind)}`);
+  }
+  return result.getChat.chat?.spaceId ?? result.getChat.dialog?.spaceId;
+}
+async function resolveMembersSpaceId(params) {
+  const explicitSpaceId = parseOptionalId(params.args.spaceId?.trim() ? params.args.spaceId : params.args.space, "spaceId");
+  if (explicitSpaceId != null) {
+    return {
+      spaceId: explicitSpaceId,
+      inferred: false,
+      source: "explicit",
+      chatId: null
+    };
+  }
+  const session = parseCurrentInlineSession(params.ctx);
+  const peer = session?.target.peerId.type;
+  if (peer?.oneofKind !== "chat") {
+    throw new Error("inline_members: spaceId is required outside an Inline space chat or reply thread");
+  }
+  const currentChatId = peer.chat.chatId;
+  const currentSpaceId = await loadChatSpaceId({
+    client: params.client,
+    chatId: currentChatId
+  });
+  if (currentSpaceId != null) {
+    return {
+      spaceId: currentSpaceId,
+      inferred: true,
+      source: "current-chat",
+      chatId: String(currentChatId)
+    };
+  }
+  if (session?.parentChatId != null && session.parentChatId !== currentChatId) {
+    const parentSpaceId = await loadChatSpaceId({
+      client: params.client,
+      chatId: session.parentChatId
+    });
+    if (parentSpaceId != null) {
+      return {
+        spaceId: parentSpaceId,
+        inferred: true,
+        source: "parent-chat",
+        chatId: String(session.parentChatId)
+      };
+    }
+  }
+  throw new Error("inline_members: current Inline chat is not part of a space; pass spaceId explicitly");
+}
 function createInlineMembersTool(ctx) {
   if (!ctx.config) {
     return null;
@@ -38733,20 +39967,24 @@ function createInlineMembersTool(ctx) {
   return {
     name: "inline_members",
     label: "Inline Members",
-    description: "List or search Inline space members by space id so the agent can identify who to DM or manage.",
+    description: "List or search Inline space members by space id, or infer the current space when invoked from an Inline space chat/reply thread.",
     parameters: InlineMembersToolParameters,
     execute: async (_toolCallId, rawArgs) => {
       const args = rawArgs;
-      const spaceId = parseRequiredId(args.spaceId, "spaceId");
       const userId = args.userId ? parseRequiredId(args.userId, "userId") : undefined;
       const limit = resolveLimit(args.limit);
       return await withInlineClient2({
         cfg: ctx.config,
         accountId: args.accountId ?? ctx.agentAccountId ?? null,
         fn: async (client, resolvedAccountId) => {
+          const resolvedSpace = await resolveMembersSpaceId({
+            args,
+            client,
+            ctx
+          });
           const members = await getSpaceMembersWithUsers({
             client,
-            spaceId
+            spaceId: resolvedSpace.spaceId
           });
           const filteredMembers = filterSpaceMembers({
             members,
@@ -38757,7 +39995,10 @@ function createInlineMembersTool(ctx) {
           return jsonResult2({
             ok: true,
             accountId: resolvedAccountId,
-            spaceId: String(spaceId),
+            spaceId: String(resolvedSpace.spaceId),
+            inferredSpaceId: resolvedSpace.inferred,
+            spaceIdSource: resolvedSpace.source,
+            sourceChatId: resolvedSpace.chatId,
             query: args.query ?? null,
             userId: userId != null ? String(userId) : null,
             count: filteredMembers.length,
@@ -38950,7 +40191,8 @@ function messageAttachmentSummaries(message) {
       const previewPhoto = preview.photo ? bestPhotoSize(preview.photo).cdnUrl : null;
       attachments.push({
         kind: "urlPreview",
-        id: preview.id?.toString() ?? null,
+        id: item.id?.toString() ?? null,
+        urlPreviewId: preview.id?.toString() ?? null,
         url: preview.url ?? null,
         siteName: preview.siteName ?? null,
         title: preview.title ?? null,
@@ -38963,7 +40205,8 @@ function messageAttachmentSummaries(message) {
       const task = item.attachment.externalTask;
       attachments.push({
         kind: "externalTask",
-        id: task.id?.toString() ?? null,
+        id: item.id?.toString() ?? null,
+        externalTaskId: task.id?.toString() ?? null,
         url: task.url ?? null,
         application: task.application ?? null,
         title: task.title ?? null,
@@ -39193,11 +40436,11 @@ function summarizeInlineMessageContent(message) {
 }
 
 // src/inline/reply-threads.ts
-var GET_CHAT_METHOD = typeof Method.GET_CHAT === "number" && Number.isInteger(Method.GET_CHAT) && Method.GET_CHAT > 0 ? Method.GET_CHAT : 25;
+var GET_CHAT_METHOD2 = typeof Method.GET_CHAT === "number" && Number.isInteger(Method.GET_CHAT) && Method.GET_CHAT > 0 ? Method.GET_CHAT : 25;
 var GET_CHAT_HISTORY_METHOD = typeof Method.GET_CHAT_HISTORY === "number" && Number.isInteger(Method.GET_CHAT_HISTORY) && Method.GET_CHAT_HISTORY > 0 ? Method.GET_CHAT_HISTORY : 5;
 var GET_MESSAGES_METHOD = typeof Method.GET_MESSAGES === "number" && Number.isInteger(Method.GET_MESSAGES) && Method.GET_MESSAGES > 0 ? Method.GET_MESSAGES : 38;
 var CREATE_SUBTHREAD_METHOD = typeof Method.CREATE_SUBTHREAD === "number" && Number.isInteger(Method.CREATE_SUBTHREAD) && Method.CREATE_SUBTHREAD > 0 ? Method.CREATE_SUBTHREAD : 42;
-function buildChatPeer(chatId) {
+function buildChatPeer2(chatId) {
   return {
     type: {
       oneofKind: "chat",
@@ -39230,9 +40473,9 @@ function resolveInlineReplyThreadChatId(params) {
   return normalized ?? params.parentChatId;
 }
 async function loadInlineReplyThreadMetadata(params) {
-  const result = await params.client.invokeRaw(GET_CHAT_METHOD, {
+  const result = await params.client.invokeRaw(GET_CHAT_METHOD2, {
     oneofKind: "getChat",
-    getChat: { peerId: buildChatPeer(params.chatId) }
+    getChat: { peerId: buildChatPeer2(params.chatId) }
   }).catch(() => null);
   if (result?.oneofKind !== "getChat") {
     return null;
@@ -39253,7 +40496,7 @@ async function loadInlineReplyThreadAnchorMessage(params) {
   const directResult = await params.client.invokeRaw(GET_MESSAGES_METHOD, {
     oneofKind: "getMessages",
     getMessages: {
-      peerId: buildChatPeer(params.parentChatId),
+      peerId: buildChatPeer2(params.parentChatId),
       messageIds: [params.parentMessageId]
     }
   }).catch(() => null);
@@ -39266,7 +40509,7 @@ async function loadInlineReplyThreadAnchorMessage(params) {
   const historyResult = await params.client.invokeRaw(GET_CHAT_HISTORY_METHOD, {
     oneofKind: "getChatHistory",
     getChatHistory: {
-      peerId: buildChatPeer(params.parentChatId),
+      peerId: buildChatPeer2(params.parentChatId),
       offsetId: params.parentMessageId + 1n,
       limit: 8
     }
@@ -39303,6 +40546,10 @@ async function createInlineReplyThreadForMessage(params) {
 
 // src/inline/parent-context-tool.ts
 var GET_CHAT_HISTORY_METHOD2 = typeof Method.GET_CHAT_HISTORY === "number" && Number.isInteger(Method.GET_CHAT_HISTORY) && Method.GET_CHAT_HISTORY > 0 ? Method.GET_CHAT_HISTORY : 5;
+var HISTORY_MODE_LATEST = 1;
+var HISTORY_MODE_OLDER = 2;
+var HISTORY_MODE_NEWER = 3;
+var HISTORY_MODE_AROUND = 4;
 var InlineParentContextToolParameters = {
   type: "object",
   additionalProperties: false,
@@ -39331,10 +40578,39 @@ var InlineParentContextToolParameters = {
       type: "string",
       description: "Optional message id to page older parent-chat context before. Defaults to the reply-thread anchor when known."
     },
+    afterMessageId: {
+      type: "string",
+      description: "Optional message id to page newer parent-chat context after."
+    },
+    messageId: {
+      type: "string",
+      description: "Optional parent-chat message id to fetch context around."
+    },
+    aroundMessageId: {
+      type: "string",
+      description: "Alias for `messageId` when fetching context around a parent-chat message."
+    },
+    aroundId: {
+      type: "string",
+      description: "Alias for `messageId`."
+    },
+    mode: {
+      type: "string",
+      enum: ["latest", "older", "newer", "around"],
+      description: "Optional history mode. Defaults to around the reply-thread anchor when known, otherwise latest; explicit ids infer older/newer/around."
+    },
     limit: {
       type: "number",
       description: "Number of parent-chat messages to return, clamped to 1..100. Defaults to 50."
     },
+    beforeLimit: {
+      type: "number",
+      description: "Around mode count for messages before the anchor, clamped to 0..100."
+    },
+    afterLimit: {
+      type: "number",
+      description: "Around mode count for messages after the anchor, clamped to 0..100."
+    },
     includeAnchor: {
       type: "boolean",
       description: "Whether to include the reply-thread anchor/root message when parentMessageId is known. Defaults to true."
@@ -39345,7 +40621,7 @@ var InlineParentContextToolParameters = {
     }
   }
 };
-function buildChatPeer2(chatId) {
+function buildChatPeer3(chatId) {
   return {
     type: {
       oneofKind: "chat",
@@ -39362,6 +40638,38 @@ function readLimit(raw, fallback) {
   }
   return Math.max(1, Math.min(100, value));
 }
+function readWindowLimit(raw, label) {
+  if (raw == null)
+    return;
+  const value = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw.trim()) : Number.NaN;
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    throw new Error(`inline_parent_context: ${label} must be an integer`);
+  }
+  return Math.max(0, Math.min(100, value));
+}
+function readMode(raw) {
+  if (raw == null)
+    return null;
+  if (typeof raw !== "string") {
+    throw new Error("inline_parent_context: mode must be latest, older, newer, or around");
+  }
+  switch (raw.trim().toLowerCase()) {
+    case "":
+      return null;
+    case "latest":
+      return "latest";
+    case "older":
+    case "before":
+      return "older";
+    case "newer":
+    case "after":
+      return "newer";
+    case "around":
+      return "around";
+    default:
+      throw new Error("inline_parent_context: mode must be latest, older, newer, or around");
+  }
+}
 function readIdCandidate(...values) {
   for (const value of values) {
     if (value == null)
@@ -39391,7 +40699,7 @@ function parseOptionalChatId(raw, label) {
   }
   return parseOptionalInlineId(raw, label);
 }
-function mapContextMessage(message, parentMessageId) {
+function mapContextMessage(message, anchorMessageId) {
   const content = summarizeInlineMessageContent(message);
   return {
     id: String(message.id),
@@ -39403,7 +40711,7 @@ function mapContextMessage(message, parentMessageId) {
     entityText: content.entityText,
     out: Boolean(message.out),
     replyToId: message.replyToMsgId != null ? String(message.replyToMsgId) : undefined,
-    isAnchor: parentMessageId != null && message.id === parentMessageId,
+    isAnchor: anchorMessageId != null && message.id === anchorMessageId,
     attachmentUrls: content.attachmentUrls,
     links: content.links,
     media: content.media,
@@ -39421,21 +40729,6 @@ 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 key = messageDedupeKey(message);
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    out.push(message);
-  }
-  return out;
-}
 async function withInlineClient3(params) {
   const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
   if (!account.configured || !account.baseUrl) {
@@ -39454,14 +40747,13 @@ async function withInlineClient3(params) {
   }
 }
 async function loadParentHistory(params) {
-  if (params.limit <= 0)
+  if (params.input.limit <= 0)
     return [];
   const result = await params.client.invokeRaw(GET_CHAT_HISTORY_METHOD2, {
     oneofKind: "getChatHistory",
     getChatHistory: {
-      peerId: buildChatPeer2(params.parentChatId),
-      ...params.offsetId != null ? { offsetId: params.offsetId } : {},
-      limit: params.limit
+      peerId: buildChatPeer3(params.parentChatId),
+      ...params.input
     }
   });
   if (result.oneofKind !== "getChatHistory") {
@@ -39469,36 +40761,96 @@ async function loadParentHistory(params) {
   }
   return result.getChatHistory.messages ?? [];
 }
-async function loadParentContextMessages(params) {
-  if (params.beforeMessageId != null) {
-    return sortMessages(await loadParentHistory({
-      client: params.client,
-      parentChatId: params.parentChatId,
-      offsetId: params.beforeMessageId,
-      limit: params.limit
-    }));
+function resolveParentContextHistoryRequest(params) {
+  if (params.aroundMessageId != null && (params.beforeMessageId != null || params.afterMessageId != null)) {
+    throw new Error("inline_parent_context: messageId/aroundMessageId cannot be combined with before or after");
   }
-  if (params.parentMessageId == null) {
-    return sortMessages(await loadParentHistory({
-      client: params.client,
-      parentChatId: params.parentChatId,
-      offsetId: null,
-      limit: params.limit
-    }));
+  if (params.beforeMessageId != null && params.afterMessageId != null) {
+    throw new Error("inline_parent_context: pass only one of beforeMessageId or afterMessageId");
   }
-  const anchor = params.includeAnchor ? await loadInlineReplyThreadAnchorMessage({
-    client: params.client,
-    parentChatId: params.parentChatId,
-    parentMessageId: params.parentMessageId
-  }) : null;
-  const historyLimit = Math.max(0, params.limit - (anchor ? 1 : 0));
-  const history = await loadParentHistory({
-    client: params.client,
-    parentChatId: params.parentChatId,
-    offsetId: params.parentMessageId,
-    limit: historyLimit
-  });
-  return sortMessages(dedupeMessages([...history, ...anchor ? [anchor] : []]));
+  const mode = params.explicitMode ?? (params.aroundMessageId != null ? "around" : params.afterMessageId != null ? "newer" : params.beforeMessageId != null ? "older" : params.parentMessageId != null ? "around" : "latest");
+  if (mode !== "around" && (params.beforeLimit !== undefined || params.afterLimit !== undefined)) {
+    throw new Error("inline_parent_context: beforeLimit and afterLimit are only valid with around mode");
+  }
+  if (mode === "latest") {
+    if (params.aroundMessageId != null || params.beforeMessageId != null || params.afterMessageId != null) {
+      throw new Error("inline_parent_context: latest mode cannot be combined with message cursors");
+    }
+    return {
+      mode,
+      input: {
+        mode: HISTORY_MODE_LATEST,
+        limit: params.limit
+      },
+      anchorMessageId: null,
+      beforeMessageId: null,
+      afterMessageId: null,
+      beforeLimit: null,
+      afterLimit: null
+    };
+  }
+  if (mode === "newer") {
+    if (params.afterMessageId == null) {
+      throw new Error("inline_parent_context: newer mode requires afterMessageId");
+    }
+    return {
+      mode,
+      input: {
+        mode: HISTORY_MODE_NEWER,
+        afterId: params.afterMessageId,
+        limit: params.limit
+      },
+      anchorMessageId: null,
+      beforeMessageId: null,
+      afterMessageId: params.afterMessageId,
+      beforeLimit: null,
+      afterLimit: null
+    };
+  }
+  if (mode === "older") {
+    const beforeMessageId = params.beforeMessageId ?? params.parentMessageId;
+    if (beforeMessageId == null) {
+      throw new Error("inline_parent_context: older mode requires beforeMessageId outside a known reply thread");
+    }
+    return {
+      mode,
+      input: {
+        mode: HISTORY_MODE_OLDER,
+        beforeId: beforeMessageId,
+        offsetId: beforeMessageId,
+        limit: params.limit
+      },
+      anchorMessageId: null,
+      beforeMessageId,
+      afterMessageId: null,
+      beforeLimit: null,
+      afterLimit: null
+    };
+  }
+  const anchorMessageId = params.aroundMessageId ?? params.parentMessageId;
+  if (anchorMessageId == null) {
+    throw new Error("inline_parent_context: around mode requires messageId outside a known reply thread");
+  }
+  const defaultBeforeLimit = params.aroundMessageId == null && params.parentMessageId != null ? Math.max(0, params.limit - (params.includeAnchor ? 1 : 0)) : undefined;
+  const defaultAfterLimit = params.aroundMessageId == null && params.parentMessageId != null ? 0 : undefined;
+  const beforeLimit = params.beforeLimit ?? defaultBeforeLimit;
+  const afterLimit = params.afterLimit ?? defaultAfterLimit;
+  return {
+    mode,
+    input: {
+      mode: HISTORY_MODE_AROUND,
+      anchorId: anchorMessageId,
+      limit: params.limit,
+      ...beforeLimit !== undefined ? { beforeLimit } : {},
+      ...afterLimit !== undefined ? { afterLimit } : {},
+      includeAnchor: params.includeAnchor
+    },
+    anchorMessageId,
+    beforeMessageId: null,
+    afterMessageId: null,
+    beforeLimit: beforeLimit ?? null,
+    afterLimit: afterLimit ?? null
+  };
 }
 function createInlineParentContextTool(ctx) {
   if (!ctx.config)
@@ -39516,7 +40868,12 @@ function createInlineParentContextTool(ctx) {
       let parentChatId = parseOptionalChatId(readIdCandidate(args.parentChatId, args.chatId), "parentChatId") ?? currentSession?.parentChatId ?? null;
       let parentMessageId = parseOptionalInlineId(readIdCandidate(args.parentMessageId, args.anchorMessageId), "parentMessageId");
       const beforeMessageId = parseOptionalInlineId(readIdCandidate(args.beforeMessageId), "beforeMessageId");
+      const afterMessageId = parseOptionalInlineId(readIdCandidate(args.afterMessageId), "afterMessageId");
+      const aroundMessageId = parseOptionalInlineId(readIdCandidate(args.messageId, args.aroundMessageId, args.aroundId), "messageId");
+      const explicitMode = readMode(args.mode);
       const limit = readLimit(args.limit, 50);
+      const beforeLimit = readWindowLimit(args.beforeLimit, "beforeLimit");
+      const afterLimit = readWindowLimit(args.afterLimit, "afterLimit");
       const includeAnchor = args.includeAnchor !== false;
       return await withInlineClient3({
         cfg: ctx.config,
@@ -39532,15 +40889,24 @@ function createInlineParentContextTool(ctx) {
           if (parentChatId == null) {
             throw new Error("inline_parent_context: parentChatId is required outside an Inline reply-thread session");
           }
-          const messages = (await loadParentContextMessages({
-            client,
-            parentChatId,
+          const history = resolveParentContextHistoryRequest({
             parentMessageId,
             beforeMessageId,
+            afterMessageId,
+            aroundMessageId,
+            explicitMode,
             includeAnchor,
-            limit
-          })).map((message) => mapContextMessage(message, parentMessageId));
+            limit,
+            ...beforeLimit !== undefined ? { beforeLimit } : {},
+            ...afterLimit !== undefined ? { afterLimit } : {}
+          });
+          const messages = sortMessages(await loadParentHistory({
+            client,
+            parentChatId,
+            input: history.input
+          })).map((message) => mapContextMessage(message, history.anchorMessageId));
           const oldest = messages[0];
+          const newest = messages[messages.length - 1];
           return jsonResult({
             ok: true,
             accountId: resolvedAccountId,
@@ -39548,10 +40914,17 @@ function createInlineParentContextTool(ctx) {
             threadId: threadId != null ? String(threadId) : null,
             threadTitle,
             parentMessageId: parentMessageId != null ? String(parentMessageId) : null,
+            mode: history.mode,
+            beforeMessageId: history.beforeMessageId != null ? String(history.beforeMessageId) : null,
+            afterMessageId: history.afterMessageId != null ? String(history.afterMessageId) : null,
+            aroundMessageId: history.anchorMessageId != null ? String(history.anchorMessageId) : null,
+            beforeLimit: history.beforeLimit,
+            afterLimit: history.afterLimit,
             limit,
             includeAnchor,
             usedCurrentThreadDefault: explicitThreadId == null && currentSession?.threadId != null,
             nextBeforeMessageId: oldest?.id ?? null,
+            nextAfterMessageId: newest?.id ?? null,
             messages
           });
         }
@@ -39588,10 +40961,21 @@ var ZIP_METHOD_STORE = 0;
 var ZIP_METHOD_DEFLATE = 8;
 var ZIP_FLAG_ENCRYPTED = 1;
 var CODEX_ATLAS_KIND = "codex_atlas";
+var SET_BOT_AVATAR_METHOD = typeof Method.SET_BOT_AVATAR === "number" && Number.isInteger(Method.SET_BOT_AVATAR) && Method.SET_BOT_AVATAR > 0 ? Method.SET_BOT_AVATAR : 56;
+var CLEAR_BOT_AVATAR_METHOD = typeof Method.CLEAR_BOT_AVATAR === "number" && Number.isInteger(Method.CLEAR_BOT_AVATAR) && Method.CLEAR_BOT_AVATAR > 0 ? Method.CLEAR_BOT_AVATAR : 57;
 var InlineBotAvatarToolParameters = {
   type: "object",
   additionalProperties: false,
   properties: {
+    action: {
+      type: "string",
+      enum: ["set", "clear"],
+      description: "Avatar operation. Defaults to `set`; use `clear` to remove the current bot avatar."
+    },
+    clear: {
+      type: "boolean",
+      description: "Boolean alias for action: clear."
+    },
     zipPath: {
       type: "string",
       description: "Local path to a .zip avatar package. The archive should contain a Codex atlas manifest and a PNG/WebP spritesheet."
@@ -39649,6 +41033,21 @@ function resolvePackageSource(args) {
   }
   return source;
 }
+function resolveAvatarAction(args) {
+  if (args.clear === true)
+    return "clear";
+  const action = readTrimmedString(args.action)?.toLowerCase();
+  if (!action || action === "set" || action === "install" || action === "replace")
+    return "set";
+  if (action === "clear" || action === "remove" || action === "delete")
+    return "clear";
+  throw new Error(`inline_bot_avatar: invalid action "${args.action}"`);
+}
+function assertClearArgs(args) {
+  if (readTrimmedString(args.zipPath) || readTrimmedString(args.archivePath) || readTrimmedString(args.zipUrl) || readTrimmedString(args.source) || readTrimmedString(args.displayName) || readTrimmedString(args.description)) {
+    throw new Error("inline_bot_avatar: clear action must not include avatar package or display metadata");
+  }
+}
 function sourceWithoutQuery(raw) {
   return raw.split(/[?#]/, 1)[0] ?? raw;
 }
@@ -39877,10 +41276,39 @@ function createInlineBotAvatarTool(ctx) {
   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.",
+    description: "Install, replace, or clear the authenticated Inline bot's on-screen avatar. Zip package installs require a user-provided Codex atlas package. Use only when the user explicitly asks to manage your avatar.",
     parameters: InlineBotAvatarToolParameters,
     execute: async (_toolCallId, rawArgs) => {
       const args = rawArgs;
+      const action = resolveAvatarAction(args);
+      if (action === "clear") {
+        assertClearArgs(args);
+        return await withInlineClient4({
+          cfg: ctx.config,
+          accountId: args.accountId ?? ctx.agentAccountId ?? null,
+          fn: async (client, resolvedAccountId) => {
+            const me = await client.getMe();
+            const result = await client.invokeRaw(CLEAR_BOT_AVATAR_METHOD, {
+              oneofKind: "clearBotAvatar",
+              clearBotAvatar: {
+                botUserId: me.userId
+              }
+            });
+            if (result.oneofKind !== "clearBotAvatar") {
+              throw new Error(`inline_bot_avatar: expected clearBotAvatar result, got ${String(result.oneofKind)}`);
+            }
+            return jsonResult({
+              ok: true,
+              action,
+              accountId: resolvedAccountId,
+              botUserId: String(me.userId),
+              cleared: true,
+              avatar: null,
+              bot: result.clearBotAvatar.bot ?? null
+            });
+          }
+        });
+      }
       const source = resolvePackageSource(args);
       const displayName = readVisibleString(args.displayName, "displayName");
       const description = readVisibleString(args.description, "description");
@@ -39905,7 +41333,7 @@ function createInlineBotAvatarTool(ctx) {
           if (!uploaded.fileUniqueId) {
             throw new Error("inline_bot_avatar: upload did not return fileUniqueId");
           }
-          const result = await client.invokeRaw(Method.SET_BOT_AVATAR, {
+          const result = await client.invokeRaw(SET_BOT_AVATAR_METHOD, {
             oneofKind: "setBotAvatar",
             setBotAvatar: {
               botUserId: me.userId,
@@ -39920,6 +41348,7 @@ function createInlineBotAvatarTool(ctx) {
           }
           return jsonResult({
             ok: true,
+            action,
             accountId: resolvedAccountId,
             botUserId: String(me.userId),
             avatar: {
@@ -40815,6 +42244,7 @@ function createInlineThreadReplyCommand(api2) {
 var INLINE_COMMAND_NAME_RE = /^[a-z0-9_]{1,32}$/;
 var INLINE_COMMAND_LIMIT = 100;
 var INLINE_COMMAND_DESCRIPTION_LIMIT = 256;
+var INLINE_COMMAND_RETRY_RATIO = 0.8;
 var INLINE_NATIVE_COMMAND_PROVIDER = "inline";
 function resolveInlineChannelCommands(cfg) {
   const inline = cfg.channels?.inline;
@@ -40828,6 +42258,55 @@ function normalizeDynamicCommandName(raw) {
   const withoutSlash = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
   return withoutSlash.trim();
 }
+function readErrorTextField(value, key) {
+  if (!value || typeof value !== "object" || !(key in value))
+    return;
+  const raw = value[key];
+  return typeof raw === "string" ? raw : undefined;
+}
+function isInlineBotCommandsTooMuchError(err) {
+  const pattern = /\bBOT_COMMANDS_TOO_MUCH\b/i;
+  if (typeof err === "string")
+    return pattern.test(err);
+  if (err instanceof Error && pattern.test(err.message))
+    return true;
+  const description = readErrorTextField(err, "description");
+  if (description && pattern.test(description))
+    return true;
+  const message = readErrorTextField(err, "message");
+  return Boolean(message && pattern.test(message));
+}
+async function setInlineBotCommandsWithRetry(params) {
+  try {
+    await callInlineBotApi({
+      baseUrl: params.baseUrl,
+      token: params.token,
+      methodName: "setMyCommands",
+      method: "POST",
+      body: { commands: params.commands }
+    });
+    return params.commands;
+  } catch (err) {
+    if (!isInlineBotCommandsTooMuchError(err) || params.commands.length <= 1) {
+      throw err;
+    }
+    const retryCount = Math.max(1, Math.floor(params.commands.length * INLINE_COMMAND_RETRY_RATIO));
+    if (retryCount >= params.commands.length) {
+      throw err;
+    }
+    const retryCommands = params.commands.slice(0, retryCount);
+    params.logger?.warn?.(`[inline] bot command sync rejected ${params.commands.length} commands for account "${params.accountId}" (BOT_COMMANDS_TOO_MUCH); retrying with ${retryCommands.length}`);
+    await callInlineBotApi({
+      baseUrl: params.baseUrl,
+      token: params.token,
+      methodName: "setMyCommands",
+      method: "POST",
+      body: { commands: retryCommands }
+    });
+    params.logger?.warn?.(`[inline] bot command sync accepted ${retryCommands.length} commands for account "${params.accountId}" after BOT_COMMANDS_TOO_MUCH (started with ${params.commands.length}; omitted ${params.commands.length - retryCommands.length}). Reduce plugin/skill/custom commands to expose more menu entries.`);
+    return retryCommands;
+  }
+}
 function appendUniqueCommand(out, seen, command, description, logger) {
   const normalized = normalizeDynamicCommandName(command);
   if (!INLINE_COMMAND_NAME_RE.test(normalized) || seen.has(normalized))
@@ -40944,15 +42423,15 @@ async function syncInlineNativeCommands(params) {
       continue;
     }
     try {
-      await callInlineBotApi({
+      const syncedCommands = await setInlineBotCommandsWithRetry({
         baseUrl: account.baseUrl,
         token,
-        methodName: "setMyCommands",
-        method: "POST",
-        body: { commands }
+        accountId: account.accountId,
+        commands,
+        ...params.logger ? { logger: params.logger } : {}
       });
       synced += 1;
-      params.logger?.info?.(`[inline] bot commands synced for account "${account.accountId}" (${commands.length} command${commands.length === 1 ? "" : "s"})`);
+      params.logger?.info?.(`[inline] bot commands synced for account "${account.accountId}" (${syncedCommands.length} command${syncedCommands.length === 1 ? "" : "s"})`);
     } catch (err) {
       failed += 1;
       params.logger?.warn?.(`[inline] bot command sync failed for account "${account.accountId}": ${String(err)}`);
@@ -41016,5 +42495,5 @@ export {
   registerInlinePluginFull
 };
 
-//# debugId=D10D8C4C3B879C9364756E2164756E21
+//# debugId=D4479BF9BA38C09864756E2164756E21
 //# sourceMappingURL=runtime-register-api.js.map