@inline-chat/hermes-agent-adapter 0.0.13 → 0.0.15

package/plugin/inline/sidecar/index.mjs

@@ -5570,7 +5570,7 @@ var require_websocket_server = __commonJS((exports, module) => {
 import http from "node:http";
 import { once } from "node:events";
 import { timingSafeEqual } from "node:crypto";
-import { mkdir, readFile as readFile2, stat } from "node:fs/promises";
+import { mkdir, readFile as readFile3, stat } from "node:fs/promises";
 import path from "node:path";
 
 // node_modules/@inline-chat/protocol/dist/core.js
@@ -5603,6 +5603,12 @@ var BotPresenceState_Kind;
   BotPresenceState_Kind2[BotPresenceState_Kind2["RUNNING"] = 8] = "RUNNING";
   BotPresenceState_Kind2[BotPresenceState_Kind2["REVIEW"] = 9] = "REVIEW";
 })(BotPresenceState_Kind || (BotPresenceState_Kind = {}));
+var MessageSubthread_Kind;
+(function(MessageSubthread_Kind2) {
+  MessageSubthread_Kind2[MessageSubthread_Kind2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  MessageSubthread_Kind2[MessageSubthread_Kind2["REPLY"] = 1] = "REPLY";
+  MessageSubthread_Kind2[MessageSubthread_Kind2["SUBTHREAD"] = 2] = "SUBTHREAD";
+})(MessageSubthread_Kind || (MessageSubthread_Kind = {}));
 var BlockList_Kind;
 (function(BlockList_Kind2) {
   BlockList_Kind2[BlockList_Kind2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -5638,6 +5644,10 @@ var MessageEntity_Type;
   MessageEntity_Type2[MessageEntity_Type2["THREAD_TITLE"] = 12] = "THREAD_TITLE";
   MessageEntity_Type2[MessageEntity_Type2["BOT_COMMAND"] = 13] = "BOT_COMMAND";
   MessageEntity_Type2[MessageEntity_Type2["GROUP_MENTION"] = 14] = "GROUP_MENTION";
+  MessageEntity_Type2[MessageEntity_Type2["UNDERLINE"] = 15] = "UNDERLINE";
+  MessageEntity_Type2[MessageEntity_Type2["STRIKETHROUGH"] = 16] = "STRIKETHROUGH";
+  MessageEntity_Type2[MessageEntity_Type2["HIGHLIGHT"] = 17] = "HIGHLIGHT";
+  MessageEntity_Type2[MessageEntity_Type2["MATH"] = 18] = "MATH";
 })(MessageEntity_Type || (MessageEntity_Type = {}));
 var Member_Role;
 (function(Member_Role2) {
@@ -5691,6 +5701,7 @@ var RpcError_Code;
   RpcError_Code2[RpcError_Code2["FIRST_NAME_INVALID"] = 17] = "FIRST_NAME_INVALID";
   RpcError_Code2[RpcError_Code2["URL_PREVIEW_UNAVAILABLE"] = 18] = "URL_PREVIEW_UNAVAILABLE";
   RpcError_Code2[RpcError_Code2["AGENT_SESSION_MESSAGE_IMMUTABLE"] = 19] = "AGENT_SESSION_MESSAGE_IMMUTABLE";
+  RpcError_Code2[RpcError_Code2["SPACE_INVITE_INVALID"] = 20] = "SPACE_INVITE_INVALID";
 })(RpcError_Code || (RpcError_Code = {}));
 var SyncSkippedSequence_Reason;
 (function(SyncSkippedSequence_Reason2) {
@@ -5774,6 +5785,7 @@ var BotCapability_Kind;
 (function(BotCapability_Kind2) {
   BotCapability_Kind2[BotCapability_Kind2["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
   BotCapability_Kind2[BotCapability_Kind2["CHAT_SETTINGS"] = 1] = "CHAT_SETTINGS";
+  BotCapability_Kind2[BotCapability_Kind2["AGENT_CONFIGURATION"] = 2] = "AGENT_CONFIGURATION";
 })(BotCapability_Kind || (BotCapability_Kind = {}));
 var BotChatSettingsInfo_Tone;
 (function(BotChatSettingsInfo_Tone2) {
@@ -5996,6 +6008,14 @@ var Method;
   Method2[Method2["GET_AGENT_SESSION"] = 130] = "GET_AGENT_SESSION";
   Method2[Method2["UPDATE_BOT_AGENT"] = 131] = "UPDATE_BOT_AGENT";
   Method2[Method2["DELETE_BOT_AGENT"] = 132] = "DELETE_BOT_AGENT";
+  Method2[Method2["JOIN_SPACE_BY_INVITE_TOKEN"] = 133] = "JOIN_SPACE_BY_INVITE_TOKEN";
+  Method2[Method2["GET_SPACE_INVITE_LINK"] = 134] = "GET_SPACE_INVITE_LINK";
+  Method2[Method2["SET_SPACE_INVITE_LINK_ENABLED"] = 135] = "SET_SPACE_INVITE_LINK_ENABLED";
+  Method2[Method2["GET_FILE_PART"] = 136] = "GET_FILE_PART";
+  Method2[Method2["ACKNOWLEDGE_MESSAGES"] = 137] = "ACKNOWLEDGE_MESSAGES";
+  Method2[Method2["GET_USERS"] = 138] = "GET_USERS";
+  Method2[Method2["GET_BOT_SKILLS"] = 139] = "GET_BOT_SKILLS";
+  Method2[Method2["GET_BOT_CONFIGURATION_CATALOG"] = 140] = "GET_BOT_CONFIGURATION_CATALOG";
 })(Method || (Method = {}));
 var GridConnectionUnavailableReason;
 (function(GridConnectionUnavailableReason2) {
@@ -7898,6 +7918,115 @@ class ChatPermissions$Type extends import_runtime4.MessageType {
 }
 var ChatPermissions = new ChatPermissions$Type;
 
+class AgentThreadContext$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentThreadContext", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "agent_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 3, name: "configuration", kind: "message", T: () => AgentThreadConfiguration }
+    ]);
+  }
+  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;
+        case 2:
+          message.agentId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.configuration = AgentThreadConfiguration.internalBinaryRead(reader, reader.uint32(), options, message.configuration);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.agentId !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.agentId);
+    if (message.configuration)
+      AgentThreadConfiguration.internalBinaryWrite(message.configuration, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentThreadContext = new AgentThreadContext$Type;
+
+class AgentThreadConfiguration$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentThreadConfiguration", [
+      { no: 1, name: "project_id", kind: "scalar", opt: true, T: 9 },
+      { no: 2, name: "model_id", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "reasoning_effort_id", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  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.projectId = reader.string();
+          break;
+        case 2:
+          message.modelId = reader.string();
+          break;
+        case 3:
+          message.reasoningEffortId = 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.projectId !== undefined)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.projectId);
+    if (message.modelId !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.modelId);
+    if (message.reasoningEffortId !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.reasoningEffortId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentThreadConfiguration = new AgentThreadConfiguration$Type;
+
 class Chat$Type extends import_runtime4.MessageType {
   constructor() {
     super("Chat", [
@@ -7916,7 +8045,9 @@ class Chat$Type extends import_runtime4.MessageType {
       { no: 13, name: "untitled", kind: "scalar", opt: true, T: 8 },
       { no: 14, name: "number", kind: "scalar", opt: true, T: 5 },
       { no: 15, name: "permissions", kind: "message", T: () => ChatPermissions },
-      { no: 16, name: "seq", kind: "scalar", opt: true, T: 5 }
+      { no: 16, name: "seq", kind: "scalar", opt: true, T: 5 },
+      { no: 17, name: "acknowledgements", kind: "message", T: () => ChatAcknowledgements },
+      { no: 18, name: "agent_context", kind: "message", T: () => AgentThreadContext }
     ]);
   }
   create(value) {
@@ -7980,6 +8111,12 @@ class Chat$Type extends import_runtime4.MessageType {
         case 16:
           message.seq = reader.int32();
           break;
+        case 17:
+          message.acknowledgements = ChatAcknowledgements.internalBinaryRead(reader, reader.uint32(), options, message.acknowledgements);
+          break;
+        case 18:
+          message.agentContext = AgentThreadContext.internalBinaryRead(reader, reader.uint32(), options, message.agentContext);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -8024,6 +8161,10 @@ class Chat$Type extends import_runtime4.MessageType {
       ChatPermissions.internalBinaryWrite(message.permissions, writer.tag(15, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.seq !== undefined)
       writer.tag(16, import_runtime.WireType.Varint).int32(message.seq);
+    if (message.acknowledgements)
+      ChatAcknowledgements.internalBinaryWrite(message.acknowledgements, writer.tag(17, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.agentContext)
+      AgentThreadContext.internalBinaryWrite(message.agentContext, writer.tag(18, 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);
@@ -8104,6 +8245,91 @@ class MessageReplies$Type extends import_runtime4.MessageType {
 }
 var MessageReplies = new MessageReplies$Type;
 
+class MessageSubthread$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageSubthread", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "kind", kind: "enum", T: () => ["MessageSubthread.Kind", MessageSubthread_Kind, "KIND_"] },
+      { no: 3, name: "title", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "message_count", kind: "scalar", T: 5 },
+      { no: 5, name: "has_unread", kind: "scalar", T: 8 },
+      { no: 6, name: "recent_author_user_ids", kind: "scalar", repeat: 1, T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chatId = 0n;
+    message.kind = 0;
+    message.messageCount = 0;
+    message.hasUnread = false;
+    message.recentAuthorUserIds = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.kind = reader.int32();
+          break;
+        case 3:
+          message.title = reader.string();
+          break;
+        case 4:
+          message.messageCount = reader.int32();
+          break;
+        case 5:
+          message.hasUnread = reader.bool();
+          break;
+        case 6:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos;reader.pos < e; )
+              message.recentAuthorUserIds.push(reader.int64().toBigInt());
+          else
+            message.recentAuthorUserIds.push(reader.int64().toBigInt());
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.kind !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.title !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.title);
+    if (message.messageCount !== 0)
+      writer.tag(4, import_runtime.WireType.Varint).int32(message.messageCount);
+    if (message.hasUnread !== false)
+      writer.tag(5, import_runtime.WireType.Varint).bool(message.hasUnread);
+    if (message.recentAuthorUserIds.length) {
+      writer.tag(6, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0;i < message.recentAuthorUserIds.length; i++)
+        writer.int64(message.recentAuthorUserIds[i]);
+      writer.join();
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageSubthread = new MessageSubthread$Type;
+
 class MessageActions$Type extends import_runtime4.MessageType {
   constructor() {
     super("MessageActions", [
@@ -8691,7 +8917,8 @@ class Block$Type extends import_runtime4.MessageType {
       { no: 8, name: "disclosure", kind: "message", oneof: "kind", T: () => BlockDisclosure },
       { no: 9, name: "footer", kind: "message", oneof: "kind", T: () => BlockText },
       { no: 10, name: "quote", kind: "message", oneof: "kind", T: () => BlockQuote },
-      { no: 11, name: "table", kind: "message", oneof: "kind", T: () => BlockTable }
+      { no: 11, name: "table", kind: "message", oneof: "kind", T: () => BlockTable },
+      { no: 12, name: "math", kind: "message", oneof: "kind", T: () => BlockText }
     ]);
   }
   create(value) {
@@ -8772,6 +8999,12 @@ class Block$Type extends import_runtime4.MessageType {
             table: BlockTable.internalBinaryRead(reader, reader.uint32(), options, message.kind.table)
           };
           break;
+        case 12:
+          message.kind = {
+            oneofKind: "math",
+            math: BlockText.internalBinaryRead(reader, reader.uint32(), options, message.kind.math)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -8806,6 +9039,8 @@ class Block$Type extends import_runtime4.MessageType {
       BlockQuote.internalBinaryWrite(message.kind.quote, writer.tag(10, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.kind.oneofKind === "table")
       BlockTable.internalBinaryWrite(message.kind.table, writer.tag(11, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.kind.oneofKind === "math")
+      BlockText.internalBinaryWrite(message.kind.math, writer.tag(12, 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);
@@ -9548,7 +9783,8 @@ class Message$Type extends import_runtime4.MessageType {
       { no: 21, name: "rev", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 22, name: "service_message", kind: "message", T: () => MessageService },
       { no: 23, name: "block_content", kind: "message", T: () => BlockContent },
-      { no: 24, name: "agent_session", kind: "message", T: () => AgentSessionMessageInfo }
+      { no: 24, name: "agent_session", kind: "message", T: () => AgentSessionMessageInfo },
+      { no: 25, name: "subthread", kind: "message", T: () => MessageSubthread }
     ]);
   }
   create(value) {
@@ -9642,6 +9878,9 @@ class Message$Type extends import_runtime4.MessageType {
         case 24:
           message.agentSession = AgentSessionMessageInfo.internalBinaryRead(reader, reader.uint32(), options, message.agentSession);
           break;
+        case 25:
+          message.subthread = MessageSubthread.internalBinaryRead(reader, reader.uint32(), options, message.subthread);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -9704,6 +9943,8 @@ class Message$Type extends import_runtime4.MessageType {
       BlockContent.internalBinaryWrite(message.blockContent, writer.tag(23, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.agentSession)
       AgentSessionMessageInfo.internalBinaryWrite(message.agentSession, writer.tag(24, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.subthread)
+      MessageSubthread.internalBinaryWrite(message.subthread, writer.tag(25, 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);
@@ -9887,7 +10128,8 @@ class MessageEntity$Type extends import_runtime4.MessageType {
       { no: 7, name: "thread", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityThread },
       { no: 8, name: "thread_title", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityThreadTitle },
       { no: 9, name: "group_mention", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityGroupMention },
-      { no: 10, name: "bot_command", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityBotCommand }
+      { no: 10, name: "bot_command", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityBotCommand },
+      { no: 11, name: "math", kind: "message", oneof: "entity", T: () => MessageEntity_MessageEntityMath }
     ]);
   }
   create(value) {
@@ -9956,6 +10198,12 @@ class MessageEntity$Type extends import_runtime4.MessageType {
             botCommand: MessageEntity_MessageEntityBotCommand.internalBinaryRead(reader, reader.uint32(), options, message.entity.botCommand)
           };
           break;
+        case 11:
+          message.entity = {
+            oneofKind: "math",
+            math: MessageEntity_MessageEntityMath.internalBinaryRead(reader, reader.uint32(), options, message.entity.math)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -9988,6 +10236,8 @@ class MessageEntity$Type extends import_runtime4.MessageType {
       MessageEntity_MessageEntityGroupMention.internalBinaryWrite(message.entity.groupMention, writer.tag(9, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.entity.oneofKind === "botCommand")
       MessageEntity_MessageEntityBotCommand.internalBinaryWrite(message.entity.botCommand, writer.tag(10, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.entity.oneofKind === "math")
+      MessageEntity_MessageEntityMath.internalBinaryWrite(message.entity.math, writer.tag(11, 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);
@@ -10310,6 +10560,49 @@ class MessageEntity_MessageEntityBotCommand$Type extends import_runtime4.Message
 }
 var MessageEntity_MessageEntityBotCommand = new MessageEntity_MessageEntityBotCommand$Type;
 
+class MessageEntity_MessageEntityMath$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MessageEntity.MessageEntityMath", [
+      { no: 1, name: "display", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.display = false;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.display = 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.display !== false)
+      writer.tag(1, import_runtime.WireType.Varint).bool(message.display);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MessageEntity_MessageEntityMath = new MessageEntity_MessageEntityMath$Type;
+
 class MessageReactions$Type extends import_runtime4.MessageType {
   constructor() {
     super("MessageReactions", [
@@ -10687,7 +10980,8 @@ class AgentSession$Type extends import_runtime4.MessageType {
       { no: 2, name: "peer_id", kind: "message", T: () => Peer },
       { no: 3, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
       { no: 4, name: "provider", kind: "enum", T: () => ["AgentSessionProvider", AgentSessionProvider, "AGENT_SESSION_PROVIDER_"] },
-      { no: 5, name: "status_message_id", kind: "scalar", opt: true, T: 3, L: 0 }
+      { no: 5, name: "status_message_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 6, name: "parent_chat_id", kind: "scalar", opt: true, T: 3, L: 0 }
     ]);
   }
   create(value) {
@@ -10719,6 +11013,9 @@ class AgentSession$Type extends import_runtime4.MessageType {
         case 5:
           message.statusMessageId = reader.int64().toBigInt();
           break;
+        case 6:
+          message.parentChatId = reader.int64().toBigInt();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10741,6 +11038,8 @@ class AgentSession$Type extends import_runtime4.MessageType {
       writer.tag(4, import_runtime.WireType.Varint).int32(message.provider);
     if (message.statusMessageId !== undefined)
       writer.tag(5, import_runtime.WireType.Varint).int64(message.statusMessageId);
+    if (message.parentChatId !== undefined)
+      writer.tag(6, import_runtime.WireType.Varint).int64(message.parentChatId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -11490,6 +11789,330 @@ class JoinPublicSpaceResult$Type extends import_runtime4.MessageType {
 }
 var JoinPublicSpaceResult = new JoinPublicSpaceResult$Type;
 
+class SpaceInviteLink$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SpaceInviteLink", [
+      { no: 1, name: "url", kind: "scalar", T: 9 },
+      { no: 2, name: "expires_at", kind: "scalar", opt: true, T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.url = "";
+    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.url = reader.string();
+          break;
+        case 2:
+          message.expiresAt = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.url !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.url);
+    if (message.expiresAt !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.expiresAt);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SpaceInviteLink = new SpaceInviteLink$Type;
+
+class JoinSpaceByInviteTokenInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("JoinSpaceByInviteTokenInput", [
+      { 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 JoinSpaceByInviteTokenInput = new JoinSpaceByInviteTokenInput$Type;
+
+class JoinSpaceByInviteTokenResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("JoinSpaceByInviteTokenResult", [
+      { no: 1, name: "space", kind: "message", T: () => Space },
+      { no: 2, name: "member", kind: "message", T: () => Member },
+      { no: 3, name: "already_member", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.alreadyMember = false;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.space = Space.internalBinaryRead(reader, reader.uint32(), options, message.space);
+          break;
+        case 2:
+          message.member = Member.internalBinaryRead(reader, reader.uint32(), options, message.member);
+          break;
+        case 3:
+          message.alreadyMember = 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.space)
+      Space.internalBinaryWrite(message.space, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.member)
+      Member.internalBinaryWrite(message.member, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.alreadyMember !== false)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.alreadyMember);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var JoinSpaceByInviteTokenResult = new JoinSpaceByInviteTokenResult$Type;
+
+class GetSpaceInviteLinkInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetSpaceInviteLinkInput", [
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.spaceId = 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;
+        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);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetSpaceInviteLinkInput = new GetSpaceInviteLinkInput$Type;
+
+class GetSpaceInviteLinkResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetSpaceInviteLinkResult", [
+      { no: 1, name: "link", kind: "message", T: () => SpaceInviteLink }
+    ]);
+  }
+  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.link = SpaceInviteLink.internalBinaryRead(reader, reader.uint32(), options, message.link);
+          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.link)
+      SpaceInviteLink.internalBinaryWrite(message.link, 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 GetSpaceInviteLinkResult = new GetSpaceInviteLinkResult$Type;
+
+class SetSpaceInviteLinkEnabledInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetSpaceInviteLinkEnabledInput", [
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "enabled", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.spaceId = 0n;
+    message.enabled = false;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.spaceId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.enabled = 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.spaceId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.enabled !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.enabled);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SetSpaceInviteLinkEnabledInput = new SetSpaceInviteLinkEnabledInput$Type;
+
+class SetSpaceInviteLinkEnabledResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetSpaceInviteLinkEnabledResult", [
+      { no: 1, name: "link", kind: "message", T: () => SpaceInviteLink }
+    ]);
+  }
+  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.link = SpaceInviteLink.internalBinaryRead(reader, reader.uint32(), options, message.link);
+          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.link)
+      SpaceInviteLink.internalBinaryWrite(message.link, 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 SetSpaceInviteLinkEnabledResult = new SetSpaceInviteLinkEnabledResult$Type;
+
 class UserGroup$Type extends import_runtime4.MessageType {
   constructor() {
     super("UserGroup", [
@@ -12668,7 +13291,8 @@ class Video$Type extends import_runtime4.MessageType {
       { no: 7, name: "photo", kind: "message", T: () => Photo },
       { no: 8, name: "cdn_url", kind: "scalar", opt: true, T: 9 },
       { no: 9, name: "is_animated", kind: "scalar", opt: true, T: 8 },
-      { no: 10, name: "has_audio", kind: "scalar", opt: true, T: 8 }
+      { no: 10, name: "has_audio", kind: "scalar", opt: true, T: 8 },
+      { no: 100, name: "file_unique_id", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -12718,6 +13342,9 @@ class Video$Type extends import_runtime4.MessageType {
         case 10:
           message.hasAudio = reader.bool();
           break;
+        case 100:
+          message.fileUniqueId = reader.string();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -12750,6 +13377,8 @@ class Video$Type extends import_runtime4.MessageType {
       writer.tag(9, import_runtime.WireType.Varint).bool(message.isAnimated);
     if (message.hasAudio !== undefined)
       writer.tag(10, import_runtime.WireType.Varint).bool(message.hasAudio);
+    if (message.fileUniqueId !== undefined)
+      writer.tag(100, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -12767,7 +13396,8 @@ class Document$Type extends import_runtime4.MessageType {
       { no: 4, name: "size", kind: "scalar", T: 5 },
       { no: 5, name: "cdn_url", kind: "scalar", opt: true, T: 9 },
       { no: 6, name: "date", kind: "scalar", T: 3, L: 0 },
-      { no: 7, name: "photo", kind: "message", T: () => Photo }
+      { no: 7, name: "photo", kind: "message", T: () => Photo },
+      { no: 100, name: "file_unique_id", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -12807,6 +13437,9 @@ class Document$Type extends import_runtime4.MessageType {
         case 7:
           message.photo = Photo.internalBinaryRead(reader, reader.uint32(), options, message.photo);
           break;
+        case 100:
+          message.fileUniqueId = reader.string();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -12833,6 +13466,8 @@ class Document$Type extends import_runtime4.MessageType {
       writer.tag(6, import_runtime.WireType.Varint).int64(message.date);
     if (message.photo)
       Photo.internalBinaryWrite(message.photo, writer.tag(7, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.fileUniqueId !== undefined)
+      writer.tag(100, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -12850,7 +13485,8 @@ class Voice$Type extends import_runtime4.MessageType {
       { no: 4, name: "size", kind: "scalar", T: 5 },
       { no: 5, name: "mime_type", kind: "scalar", T: 9 },
       { no: 6, name: "cdn_url", kind: "scalar", opt: true, T: 9 },
-      { no: 7, name: "waveform", kind: "scalar", T: 12 }
+      { no: 7, name: "waveform", kind: "scalar", T: 12 },
+      { no: 100, name: "file_unique_id", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -12891,6 +13527,9 @@ class Voice$Type extends import_runtime4.MessageType {
         case 7:
           message.waveform = reader.bytes();
           break;
+        case 100:
+          message.fileUniqueId = reader.string();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -12917,6 +13556,8 @@ class Voice$Type extends import_runtime4.MessageType {
       writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.cdnUrl);
     if (message.waveform.length)
       writer.tag(7, import_runtime.WireType.LengthDelimited).bytes(message.waveform);
+    if (message.fileUniqueId !== undefined)
+      writer.tag(100, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -12998,6 +13639,7 @@ var Photo = new Photo$Type;
 class PhotoSize$Type extends import_runtime4.MessageType {
   constructor() {
     super("PhotoSize", [
+      { no: 100, name: "file_unique_id", kind: "scalar", opt: true, T: 9 },
       { no: 1, name: "type", kind: "scalar", T: 9 },
       { no: 2, name: "w", kind: "scalar", T: 5 },
       { no: 3, name: "h", kind: "scalar", T: 5 },
@@ -13021,6 +13663,9 @@ class PhotoSize$Type extends import_runtime4.MessageType {
     while (reader.pos < end) {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
+        case 100:
+          message.fileUniqueId = reader.string();
+          break;
         case 1:
           message.type = reader.string();
           break;
@@ -13051,6 +13696,8 @@ class PhotoSize$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
+    if (message.fileUniqueId !== undefined)
+      writer.tag(100, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
     if (message.type !== "")
       writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.type);
     if (message.w !== 0)
@@ -13269,7 +13916,15 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { no: 130, name: "syncAgentSessionMessages", kind: "message", oneof: "input", T: () => SyncAgentSessionMessagesInput },
       { no: 131, name: "getAgentSession", kind: "message", oneof: "input", T: () => GetAgentSessionInput },
       { no: 132, name: "updateBotAgent", kind: "message", oneof: "input", T: () => UpdateBotAgentInput },
-      { no: 133, name: "deleteBotAgent", kind: "message", oneof: "input", T: () => DeleteBotAgentInput }
+      { no: 133, name: "deleteBotAgent", kind: "message", oneof: "input", T: () => DeleteBotAgentInput },
+      { no: 134, name: "joinSpaceByInviteToken", kind: "message", oneof: "input", T: () => JoinSpaceByInviteTokenInput },
+      { no: 135, name: "getSpaceInviteLink", kind: "message", oneof: "input", T: () => GetSpaceInviteLinkInput },
+      { no: 136, name: "setSpaceInviteLinkEnabled", kind: "message", oneof: "input", T: () => SetSpaceInviteLinkEnabledInput },
+      { no: 137, name: "getFilePart", kind: "message", oneof: "input", T: () => GetFilePartInput },
+      { no: 138, name: "acknowledgeMessages", kind: "message", oneof: "input", T: () => AcknowledgeMessagesInput },
+      { no: 139, name: "getUsers", kind: "message", oneof: "input", T: () => GetUsersInput },
+      { no: 140, name: "getBotSkills", kind: "message", oneof: "input", T: () => GetBotSkillsInput },
+      { no: 141, name: "getBotConfigurationCatalog", kind: "message", oneof: "input", T: () => GetBotConfigurationCatalogInput }
     ]);
   }
   create(value) {
@@ -14074,6 +14729,54 @@ class RpcCall$Type extends import_runtime4.MessageType {
             deleteBotAgent: DeleteBotAgentInput.internalBinaryRead(reader, reader.uint32(), options, message.input.deleteBotAgent)
           };
           break;
+        case 134:
+          message.input = {
+            oneofKind: "joinSpaceByInviteToken",
+            joinSpaceByInviteToken: JoinSpaceByInviteTokenInput.internalBinaryRead(reader, reader.uint32(), options, message.input.joinSpaceByInviteToken)
+          };
+          break;
+        case 135:
+          message.input = {
+            oneofKind: "getSpaceInviteLink",
+            getSpaceInviteLink: GetSpaceInviteLinkInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getSpaceInviteLink)
+          };
+          break;
+        case 136:
+          message.input = {
+            oneofKind: "setSpaceInviteLinkEnabled",
+            setSpaceInviteLinkEnabled: SetSpaceInviteLinkEnabledInput.internalBinaryRead(reader, reader.uint32(), options, message.input.setSpaceInviteLinkEnabled)
+          };
+          break;
+        case 137:
+          message.input = {
+            oneofKind: "getFilePart",
+            getFilePart: GetFilePartInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getFilePart)
+          };
+          break;
+        case 138:
+          message.input = {
+            oneofKind: "acknowledgeMessages",
+            acknowledgeMessages: AcknowledgeMessagesInput.internalBinaryRead(reader, reader.uint32(), options, message.input.acknowledgeMessages)
+          };
+          break;
+        case 139:
+          message.input = {
+            oneofKind: "getUsers",
+            getUsers: GetUsersInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getUsers)
+          };
+          break;
+        case 140:
+          message.input = {
+            oneofKind: "getBotSkills",
+            getBotSkills: GetBotSkillsInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getBotSkills)
+          };
+          break;
+        case 141:
+          message.input = {
+            oneofKind: "getBotConfigurationCatalog",
+            getBotConfigurationCatalog: GetBotConfigurationCatalogInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getBotConfigurationCatalog)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -14350,6 +15053,22 @@ class RpcCall$Type extends import_runtime4.MessageType {
       UpdateBotAgentInput.internalBinaryWrite(message.input.updateBotAgent, writer.tag(132, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.input.oneofKind === "deleteBotAgent")
       DeleteBotAgentInput.internalBinaryWrite(message.input.deleteBotAgent, writer.tag(133, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "joinSpaceByInviteToken")
+      JoinSpaceByInviteTokenInput.internalBinaryWrite(message.input.joinSpaceByInviteToken, writer.tag(134, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getSpaceInviteLink")
+      GetSpaceInviteLinkInput.internalBinaryWrite(message.input.getSpaceInviteLink, writer.tag(135, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "setSpaceInviteLinkEnabled")
+      SetSpaceInviteLinkEnabledInput.internalBinaryWrite(message.input.setSpaceInviteLinkEnabled, writer.tag(136, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getFilePart")
+      GetFilePartInput.internalBinaryWrite(message.input.getFilePart, writer.tag(137, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "acknowledgeMessages")
+      AcknowledgeMessagesInput.internalBinaryWrite(message.input.acknowledgeMessages, writer.tag(138, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getUsers")
+      GetUsersInput.internalBinaryWrite(message.input.getUsers, writer.tag(139, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getBotSkills")
+      GetBotSkillsInput.internalBinaryWrite(message.input.getBotSkills, writer.tag(140, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getBotConfigurationCatalog")
+      GetBotConfigurationCatalogInput.internalBinaryWrite(message.input.getBotConfigurationCatalog, writer.tag(141, 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);
@@ -14492,7 +15211,15 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { no: 130, name: "syncAgentSessionMessages", kind: "message", oneof: "result", T: () => SyncAgentSessionMessagesResult },
       { no: 131, name: "getAgentSession", kind: "message", oneof: "result", T: () => GetAgentSessionResult },
       { no: 132, name: "updateBotAgent", kind: "message", oneof: "result", T: () => UpdateBotAgentResult },
-      { no: 133, name: "deleteBotAgent", kind: "message", oneof: "result", T: () => DeleteBotAgentResult }
+      { no: 133, name: "deleteBotAgent", kind: "message", oneof: "result", T: () => DeleteBotAgentResult },
+      { no: 134, name: "joinSpaceByInviteToken", kind: "message", oneof: "result", T: () => JoinSpaceByInviteTokenResult },
+      { no: 135, name: "getSpaceInviteLink", kind: "message", oneof: "result", T: () => GetSpaceInviteLinkResult },
+      { no: 136, name: "setSpaceInviteLinkEnabled", kind: "message", oneof: "result", T: () => SetSpaceInviteLinkEnabledResult },
+      { no: 137, name: "getFilePart", kind: "message", oneof: "result", T: () => GetFilePartResult },
+      { no: 138, name: "acknowledgeMessages", kind: "message", oneof: "result", T: () => AcknowledgeMessagesResult },
+      { no: 139, name: "getUsers", kind: "message", oneof: "result", T: () => GetUsersResult },
+      { no: 140, name: "getBotSkills", kind: "message", oneof: "result", T: () => GetBotSkillsResult },
+      { no: 141, name: "getBotConfigurationCatalog", kind: "message", oneof: "result", T: () => GetBotConfigurationCatalogResult }
     ]);
   }
   create(value) {
@@ -15297,6 +16024,54 @@ class RpcResult$Type extends import_runtime4.MessageType {
             deleteBotAgent: DeleteBotAgentResult.internalBinaryRead(reader, reader.uint32(), options, message.result.deleteBotAgent)
           };
           break;
+        case 134:
+          message.result = {
+            oneofKind: "joinSpaceByInviteToken",
+            joinSpaceByInviteToken: JoinSpaceByInviteTokenResult.internalBinaryRead(reader, reader.uint32(), options, message.result.joinSpaceByInviteToken)
+          };
+          break;
+        case 135:
+          message.result = {
+            oneofKind: "getSpaceInviteLink",
+            getSpaceInviteLink: GetSpaceInviteLinkResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getSpaceInviteLink)
+          };
+          break;
+        case 136:
+          message.result = {
+            oneofKind: "setSpaceInviteLinkEnabled",
+            setSpaceInviteLinkEnabled: SetSpaceInviteLinkEnabledResult.internalBinaryRead(reader, reader.uint32(), options, message.result.setSpaceInviteLinkEnabled)
+          };
+          break;
+        case 137:
+          message.result = {
+            oneofKind: "getFilePart",
+            getFilePart: GetFilePartResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getFilePart)
+          };
+          break;
+        case 138:
+          message.result = {
+            oneofKind: "acknowledgeMessages",
+            acknowledgeMessages: AcknowledgeMessagesResult.internalBinaryRead(reader, reader.uint32(), options, message.result.acknowledgeMessages)
+          };
+          break;
+        case 139:
+          message.result = {
+            oneofKind: "getUsers",
+            getUsers: GetUsersResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getUsers)
+          };
+          break;
+        case 140:
+          message.result = {
+            oneofKind: "getBotSkills",
+            getBotSkills: GetBotSkillsResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getBotSkills)
+          };
+          break;
+        case 141:
+          message.result = {
+            oneofKind: "getBotConfigurationCatalog",
+            getBotConfigurationCatalog: GetBotConfigurationCatalogResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getBotConfigurationCatalog)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -15573,6 +16348,22 @@ class RpcResult$Type extends import_runtime4.MessageType {
       UpdateBotAgentResult.internalBinaryWrite(message.result.updateBotAgent, writer.tag(132, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.result.oneofKind === "deleteBotAgent")
       DeleteBotAgentResult.internalBinaryWrite(message.result.deleteBotAgent, writer.tag(133, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "joinSpaceByInviteToken")
+      JoinSpaceByInviteTokenResult.internalBinaryWrite(message.result.joinSpaceByInviteToken, writer.tag(134, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getSpaceInviteLink")
+      GetSpaceInviteLinkResult.internalBinaryWrite(message.result.getSpaceInviteLink, writer.tag(135, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "setSpaceInviteLinkEnabled")
+      SetSpaceInviteLinkEnabledResult.internalBinaryWrite(message.result.setSpaceInviteLinkEnabled, writer.tag(136, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getFilePart")
+      GetFilePartResult.internalBinaryWrite(message.result.getFilePart, writer.tag(137, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "acknowledgeMessages")
+      AcknowledgeMessagesResult.internalBinaryWrite(message.result.acknowledgeMessages, writer.tag(138, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getUsers")
+      GetUsersResult.internalBinaryWrite(message.result.getUsers, writer.tag(139, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getBotSkills")
+      GetBotSkillsResult.internalBinaryWrite(message.result.getBotSkills, writer.tag(140, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getBotConfigurationCatalog")
+      GetBotConfigurationCatalogResult.internalBinaryWrite(message.result.getBotConfigurationCatalog, writer.tag(141, 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);
@@ -16030,13 +16821,15 @@ class DeleteMemberInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("DeleteMemberInput", [
       { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "user_id", kind: "scalar", T: 3, L: 0 }
+      { no: 2, name: "user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "block_join", kind: "scalar", T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
     message.spaceId = 0n;
     message.userId = 0n;
+    message.blockJoin = false;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -16052,6 +16845,9 @@ class DeleteMemberInput$Type extends import_runtime4.MessageType {
         case 2:
           message.userId = reader.int64().toBigInt();
           break;
+        case 3:
+          message.blockJoin = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16068,6 +16864,8 @@ class DeleteMemberInput$Type extends import_runtime4.MessageType {
       writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
     if (message.userId !== 0n)
       writer.tag(2, import_runtime.WireType.Varint).int64(message.userId);
+    if (message.blockJoin !== false)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.blockJoin);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -18525,11 +19323,13 @@ var GetUpdatesStateResult = new GetUpdatesStateResult$Type;
 class GetChatInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("GetChatInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "include_recent_messages", kind: "scalar", T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.includeRecentMessages = false;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -18542,6 +19342,9 @@ class GetChatInput$Type extends import_runtime4.MessageType {
         case 1:
           message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
+        case 2:
+          message.includeRecentMessages = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -18556,6 +19359,8 @@ class GetChatInput$Type extends import_runtime4.MessageType {
   internalBinaryWrite(message, writer, options) {
     if (message.peerId)
       InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.includeRecentMessages !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.includeRecentMessages);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -18571,12 +19376,14 @@ class GetChatResult$Type extends import_runtime4.MessageType {
       { 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 },
-      { no: 5, name: "user", kind: "message", T: () => User }
+      { no: 5, name: "user", kind: "message", T: () => User },
+      { no: 6, name: "messages", kind: "message", repeat: 1, T: () => Message }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
     message.pinnedMessageIds = [];
+    message.messages = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -18605,6 +19412,9 @@ class GetChatResult$Type extends import_runtime4.MessageType {
         case 5:
           message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
           break;
+        case 6:
+          message.messages.push(Message.internalBinaryRead(reader, reader.uint32(), options));
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -18631,6 +19441,8 @@ class GetChatResult$Type extends import_runtime4.MessageType {
       Message.internalBinaryWrite(message.anchorMessage, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.user)
       User.internalBinaryWrite(message.user, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.messages.length; i++)
+      Message.internalBinaryWrite(message.messages[i], writer.tag(6, 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);
@@ -18734,7 +19546,8 @@ class UpdateDialogOpenInput$Type extends import_runtime4.MessageType {
     super("UpdateDialogOpenInput", [
       { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
       { no: 2, name: "open", kind: "scalar", T: 8 },
-      { no: 3, name: "order", kind: "scalar", opt: true, T: 9 }
+      { no: 3, name: "order", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "folder_id", kind: "scalar", opt: true, T: 3, L: 0 }
     ]);
   }
   create(value) {
@@ -18758,6 +19571,9 @@ class UpdateDialogOpenInput$Type extends import_runtime4.MessageType {
         case 3:
           message.order = reader.string();
           break;
+        case 4:
+          message.folderId = reader.int64().toBigInt();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -18776,6 +19592,8 @@ class UpdateDialogOpenInput$Type extends import_runtime4.MessageType {
       writer.tag(2, import_runtime.WireType.Varint).bool(message.open);
     if (message.order !== undefined)
       writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.order);
+    if (message.folderId !== undefined)
+      writer.tag(4, import_runtime.WireType.Varint).int64(message.folderId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -21334,6 +22152,68 @@ class BotCommand$Type extends import_runtime4.MessageType {
 }
 var BotCommand = new BotCommand$Type;
 
+class BotSkill$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotSkill", [
+      { no: 1, name: "key", kind: "scalar", T: 9 },
+      { no: 2, name: "name", kind: "scalar", T: 9 },
+      { no: 3, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "sort_order", kind: "scalar", opt: true, T: 5 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.key = "";
+    message.name = "";
+    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.key = reader.string();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        case 3:
+          message.description = reader.string();
+          break;
+        case 4:
+          message.sortOrder = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.key !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.key);
+    if (message.name !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.description !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.sortOrder !== undefined)
+      writer.tag(4, 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 BotSkill = new BotSkill$Type;
+
 class PeerBotCommands$Type extends import_runtime4.MessageType {
   constructor() {
     super("PeerBotCommands", [
@@ -21562,6 +22442,183 @@ class SetBotCommandsResult$Type extends import_runtime4.MessageType {
 }
 var SetBotCommandsResult = new SetBotCommandsResult$Type;
 
+class GetBotSkillsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotSkillsInput", [
+      { 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 GetBotSkillsInput = new GetBotSkillsInput$Type;
+
+class GetBotSkillsResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotSkillsResult", [
+      { no: 1, name: "skills", kind: "message", repeat: 1, T: () => BotSkill }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.skills = [];
+    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.skills.push(BotSkill.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.skills.length; i++)
+      BotSkill.internalBinaryWrite(message.skills[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 GetBotSkillsResult = new GetBotSkillsResult$Type;
+
+class GetBotConfigurationCatalogInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotConfigurationCatalogInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "peer_id", kind: "message", T: () => InputPeer }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.peerId = 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.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, 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 GetBotConfigurationCatalogInput = new GetBotConfigurationCatalogInput$Type;
+
+class GetBotConfigurationCatalogResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotConfigurationCatalogResult", [
+      { no: 1, name: "catalog", kind: "message", T: () => AgentConfigurationCatalog }
+    ]);
+  }
+  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.catalog = AgentConfigurationCatalog.internalBinaryRead(reader, reader.uint32(), options, message.catalog);
+          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.catalog)
+      AgentConfigurationCatalog.internalBinaryWrite(message.catalog, 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 GetBotConfigurationCatalogResult = new GetBotConfigurationCatalogResult$Type;
+
 class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("GetPeerBotCommandsInput", [
@@ -24964,7 +26021,9 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
       { no: 7, name: "entities", kind: "message", T: () => MessageEntities },
       { no: 8, name: "parse_markdown", kind: "scalar", opt: true, T: 8 },
       { no: 9, name: "send_mode", kind: "enum", opt: true, T: () => ["MessageSendMode", MessageSendMode] },
-      { no: 10, name: "actions", kind: "message", T: () => MessageActions }
+      { no: 10, name: "actions", kind: "message", T: () => MessageActions },
+      { no: 11, name: "initial_agent_context", kind: "message", T: () => AgentThreadContext },
+      { no: 12, name: "source_chat_id", kind: "scalar", opt: true, T: 3, L: 0 }
     ]);
   }
   create(value) {
@@ -25014,6 +26073,12 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
         case 10:
           message.actions = MessageActions.internalBinaryRead(reader, reader.uint32(), options, message.actions);
           break;
+        case 11:
+          message.initialAgentContext = AgentThreadContext.internalBinaryRead(reader, reader.uint32(), options, message.initialAgentContext);
+          break;
+        case 12:
+          message.sourceChatId = reader.int64().toBigInt();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -25050,6 +26115,10 @@ class SendMessageInput$Type extends import_runtime4.MessageType {
       writer.tag(9, import_runtime.WireType.Varint).int32(message.sendMode);
     if (message.actions)
       MessageActions.internalBinaryWrite(message.actions, writer.tag(10, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.initialAgentContext)
+      AgentThreadContext.internalBinaryWrite(message.initialAgentContext, writer.tag(11, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.sourceChatId !== undefined)
+      writer.tag(12, import_runtime.WireType.Varint).int64(message.sourceChatId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -25482,7 +26551,8 @@ var GetChatHistoryInput = new GetChatHistoryInput$Type;
 class GetChatHistoryResult$Type extends import_runtime4.MessageType {
   constructor() {
     super("GetChatHistoryResult", [
-      { no: 1, name: "messages", kind: "message", repeat: 1, T: () => Message }
+      { no: 1, name: "messages", kind: "message", repeat: 1, T: () => Message },
+      { no: 2, name: "acknowledgements", kind: "message", T: () => ChatAcknowledgements }
     ]);
   }
   create(value) {
@@ -25500,6 +26570,9 @@ class GetChatHistoryResult$Type extends import_runtime4.MessageType {
         case 1:
           message.messages.push(Message.internalBinaryRead(reader, reader.uint32(), options));
           break;
+        case 2:
+          message.acknowledgements = ChatAcknowledgements.internalBinaryRead(reader, reader.uint32(), options, message.acknowledgements);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -25514,6 +26587,8 @@ class GetChatHistoryResult$Type extends import_runtime4.MessageType {
   internalBinaryWrite(message, writer, options) {
     for (let i = 0;i < message.messages.length; i++)
       Message.internalBinaryWrite(message.messages[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.acknowledgements)
+      ChatAcknowledgements.internalBinaryWrite(message.acknowledgements, 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);
@@ -27574,7 +28649,8 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
       { no: 5, name: "is_public", kind: "scalar", T: 8 },
       { no: 6, name: "participants", kind: "message", repeat: 1, T: () => InputChatParticipant },
       { no: 7, name: "reserved_chat_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 8, name: "placeholder_title", kind: "scalar", opt: true, T: 9 }
+      { no: 8, name: "placeholder_title", kind: "scalar", opt: true, T: 9 },
+      { no: 9, name: "agent_context", kind: "message", T: () => AgentThreadContext }
     ]);
   }
   create(value) {
@@ -27614,6 +28690,9 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
         case 8:
           message.placeholderTitle = reader.string();
           break;
+        case 9:
+          message.agentContext = AgentThreadContext.internalBinaryRead(reader, reader.uint32(), options, message.agentContext);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -27642,6 +28721,8 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
       writer.tag(7, import_runtime.WireType.Varint).int64(message.reservedChatId);
     if (message.placeholderTitle !== undefined)
       writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.placeholderTitle);
+    if (message.agentContext)
+      AgentThreadContext.internalBinaryWrite(message.agentContext, writer.tag(9, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -27706,7 +28787,8 @@ class CreateSubthreadInput$Type extends import_runtime4.MessageType {
       { no: 3, name: "title", kind: "scalar", opt: true, T: 9 },
       { no: 4, name: "description", kind: "scalar", opt: true, T: 9 },
       { no: 5, name: "emoji", kind: "scalar", opt: true, T: 9 },
-      { no: 6, name: "participants", kind: "message", repeat: 1, T: () => InputChatParticipant }
+      { no: 6, name: "participants", kind: "message", repeat: 1, T: () => InputChatParticipant },
+      { no: 7, name: "agent_context", kind: "message", T: () => AgentThreadContext }
     ]);
   }
   create(value) {
@@ -27740,6 +28822,9 @@ class CreateSubthreadInput$Type extends import_runtime4.MessageType {
         case 6:
           message.participants.push(InputChatParticipant.internalBinaryRead(reader, reader.uint32(), options));
           break;
+        case 7:
+          message.agentContext = AgentThreadContext.internalBinaryRead(reader, reader.uint32(), options, message.agentContext);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -27764,6 +28849,8 @@ class CreateSubthreadInput$Type extends import_runtime4.MessageType {
       writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.emoji);
     for (let i = 0;i < message.participants.length; i++)
       InputChatParticipant.internalBinaryWrite(message.participants[i], writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.agentContext)
+      AgentThreadContext.internalBinaryWrite(message.agentContext, writer.tag(7, 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);
@@ -28366,7 +29453,8 @@ class Update$Type extends import_runtime4.MessageType {
       { no: 45, name: "dialog_collapsed_max_id", kind: "message", oneof: "update", T: () => UpdateDialogCollapsedMaxId },
       { no: 46, name: "dialog_folder", kind: "message", oneof: "update", T: () => UpdateDialogFolder },
       { no: 47, name: "user_added_to_chat", kind: "message", oneof: "update", T: () => UpdateUserAddedToChat },
-      { no: 48, name: "user_removed_from_chat", kind: "message", oneof: "update", T: () => UpdateUserRemovedFromChat }
+      { no: 48, name: "user_removed_from_chat", kind: "message", oneof: "update", T: () => UpdateUserRemovedFromChat },
+      { no: 49, name: "acknowledgement", kind: "message", oneof: "update", T: () => ChatAcknowledgement }
     ]);
   }
   create(value) {
@@ -28657,6 +29745,12 @@ class Update$Type extends import_runtime4.MessageType {
             userRemovedFromChat: UpdateUserRemovedFromChat.internalBinaryRead(reader, reader.uint32(), options, message.update.userRemovedFromChat)
           };
           break;
+        case 49:
+          message.update = {
+            oneofKind: "acknowledgement",
+            acknowledgement: ChatAcknowledgement.internalBinaryRead(reader, reader.uint32(), options, message.update.acknowledgement)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -28763,6 +29857,8 @@ class Update$Type extends import_runtime4.MessageType {
       UpdateUserAddedToChat.internalBinaryWrite(message.update.userAddedToChat, writer.tag(47, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.update.oneofKind === "userRemovedFromChat")
       UpdateUserRemovedFromChat.internalBinaryWrite(message.update.userRemovedFromChat, writer.tag(48, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "acknowledgement")
+      ChatAcknowledgement.internalBinaryWrite(message.update.acknowledgement, writer.tag(49, 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);
@@ -29038,7 +30134,8 @@ class UpdateChatInfo$Type extends import_runtime4.MessageType {
       { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
       { no: 2, name: "title", kind: "scalar", opt: true, T: 9 },
       { no: 3, name: "emoji", kind: "scalar", opt: true, T: 9 },
-      { no: 4, name: "untitled", kind: "scalar", opt: true, T: 8 }
+      { no: 4, name: "untitled", kind: "scalar", opt: true, T: 8 },
+      { no: 5, name: "agent_context", kind: "message", T: () => AgentThreadContext }
     ]);
   }
   create(value) {
@@ -29065,6 +30162,9 @@ class UpdateChatInfo$Type extends import_runtime4.MessageType {
         case 4:
           message.untitled = reader.bool();
           break;
+        case 5:
+          message.agentContext = AgentThreadContext.internalBinaryRead(reader, reader.uint32(), options, message.agentContext);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -29085,6 +30185,8 @@ class UpdateChatInfo$Type extends import_runtime4.MessageType {
       writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.emoji);
     if (message.untitled !== undefined)
       writer.tag(4, import_runtime.WireType.Varint).bool(message.untitled);
+    if (message.agentContext)
+      AgentThreadContext.internalBinaryWrite(message.agentContext, writer.tag(5, 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);
@@ -31743,6 +32845,100 @@ class SearchUsersResult$Type extends import_runtime4.MessageType {
 }
 var SearchUsersResult = new SearchUsersResult$Type;
 
+class GetUsersInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetUsersInput", [
+      { no: 1, name: "user_ids", kind: "scalar", repeat: 1, T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.userIds = [];
+    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:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos;reader.pos < e; )
+              message.userIds.push(reader.int64().toBigInt());
+          else
+            message.userIds.push(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.userIds.length) {
+      writer.tag(1, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0;i < message.userIds.length; i++)
+        writer.int64(message.userIds[i]);
+      writer.join();
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetUsersInput = new GetUsersInput$Type;
+
+class GetUsersResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetUsersResult", [
+      { no: 1, name: "users", kind: "message", repeat: 1, T: () => User }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.users = [];
+    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.users.push(User.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.users.length; i++)
+      User.internalBinaryWrite(message.users[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 GetUsersResult = new GetUsersResult$Type;
+
 class InviteToInlineInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("InviteToInlineInput", [
@@ -32258,19 +33454,214 @@ class UpdateChatVisibilityResult$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var UpdateChatVisibilityResult = new UpdateChatVisibilityResult$Type;
+var UpdateChatVisibilityResult = new UpdateChatVisibilityResult$Type;
+
+class UpdateChatInfoInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateChatInfoInput", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "title", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "emoji", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "agent_context", kind: "message", T: () => AgentThreadContext }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chatId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.title = reader.string();
+          break;
+        case 3:
+          message.emoji = reader.string();
+          break;
+        case 4:
+          message.agentContext = AgentThreadContext.internalBinaryRead(reader, reader.uint32(), options, message.agentContext);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.title !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.title);
+    if (message.emoji !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.emoji);
+    if (message.agentContext)
+      AgentThreadContext.internalBinaryWrite(message.agentContext, 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 UpdateChatInfoInput = new UpdateChatInfoInput$Type;
+
+class UpdateChatInfoResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateChatInfoResult", [
+      { no: 1, name: "chat", kind: "message", T: () => Chat }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          break;
+        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();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateChatInfoResult = new UpdateChatInfoResult$Type;
+
+class MoveThreadInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MoveThreadInput", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "space_id", kind: "scalar", opt: true, T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chatId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.spaceId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.spaceId !== undefined)
+      writer.tag(2, 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 MoveThreadInput = new MoveThreadInput$Type;
+
+class MoveThreadResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("MoveThreadResult", [
+      { no: 1, name: "chat", kind: "message", T: () => Chat }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chat = Chat.internalBinaryRead(reader, reader.uint32(), options, message.chat);
+          break;
+        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();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var MoveThreadResult = new MoveThreadResult$Type;
 
-class UpdateChatInfoInput$Type extends import_runtime4.MessageType {
+class PinMessageInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateChatInfoInput", [
-      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "title", kind: "scalar", opt: true, T: 9 },
-      { no: 3, name: "emoji", kind: "scalar", opt: true, T: 9 }
+    super("PinMessageInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "unpin", kind: "scalar", T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.chatId = 0n;
+    message.messageId = 0n;
+    message.unpin = false;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32281,13 +33672,13 @@ class UpdateChatInfoInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.chatId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         case 2:
-          message.title = reader.string();
+          message.messageId = reader.int64().toBigInt();
           break;
         case 3:
-          message.emoji = reader.string();
+          message.unpin = reader.bool();
           break;
         default:
           let u = options.readUnknownField;
@@ -32301,28 +33692,29 @@ class UpdateChatInfoInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.chatId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
-    if (message.title !== undefined)
-      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.title);
-    if (message.emoji !== undefined)
-      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.emoji);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.messageId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
+    if (message.unpin !== false)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.unpin);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var UpdateChatInfoInput = new UpdateChatInfoInput$Type;
+var PinMessageInput = new PinMessageInput$Type;
 
-class UpdateChatInfoResult$Type extends import_runtime4.MessageType {
+class PinMessageResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateChatInfoResult", [
-      { no: 1, name: "chat", kind: "message", T: () => Chat }
+    super("PinMessageResult", [
+      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.updates = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32333,7 +33725,7 @@ class UpdateChatInfoResult$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.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -32347,26 +33739,26 @@ class UpdateChatInfoResult$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();
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var UpdateChatInfoResult = new UpdateChatInfoResult$Type;
+var PinMessageResult = new PinMessageResult$Type;
 
-class MoveThreadInput$Type extends import_runtime4.MessageType {
+class DraftMessage$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MoveThreadInput", [
-      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "space_id", kind: "scalar", opt: true, T: 3, L: 0 }
+    super("DraftMessage", [
+      { no: 1, name: "text", kind: "scalar", T: 9 },
+      { no: 2, name: "entities", kind: "message", T: () => MessageEntities }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.chatId = 0n;
+    message.text = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32377,10 +33769,10 @@ class MoveThreadInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.chatId = reader.int64().toBigInt();
+          message.text = reader.string();
           break;
         case 2:
-          message.spaceId = reader.int64().toBigInt();
+          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
           break;
         default:
           let u = options.readUnknownField;
@@ -32394,26 +33786,30 @@ class MoveThreadInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.chatId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
-    if (message.spaceId !== undefined)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.text !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.text);
+    if (message.entities)
+      MessageEntities.internalBinaryWrite(message.entities, 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 MoveThreadInput = new MoveThreadInput$Type;
+var DraftMessage = new DraftMessage$Type;
 
-class MoveThreadResult$Type extends import_runtime4.MessageType {
+class AgentProjectOption$Type extends import_runtime4.MessageType {
   constructor() {
-    super("MoveThreadResult", [
-      { no: 1, name: "chat", kind: "message", T: () => Chat }
+    super("AgentProjectOption", [
+      { no: 1, name: "id", kind: "scalar", T: 9 },
+      { no: 2, name: "label", kind: "scalar", T: 9 },
+      { no: 3, name: "description", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.id = "";
+    message.label = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32424,7 +33820,13 @@ class MoveThreadResult$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.id = reader.string();
+          break;
+        case 2:
+          message.label = reader.string();
+          break;
+        case 3:
+          message.description = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -32438,28 +33840,30 @@ class MoveThreadResult$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.id !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.id);
+    if (message.label !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.label);
+    if (message.description !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.description);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var MoveThreadResult = new MoveThreadResult$Type;
+var AgentProjectOption = new AgentProjectOption$Type;
 
-class PinMessageInput$Type extends import_runtime4.MessageType {
+class AgentProjectCatalog$Type extends import_runtime4.MessageType {
   constructor() {
-    super("PinMessageInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
-      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
-      { no: 3, name: "unpin", kind: "scalar", T: 8 }
+    super("AgentProjectCatalog", [
+      { no: 1, name: "options", kind: "message", repeat: 1, T: () => AgentProjectOption },
+      { no: 2, name: "can_select_folder", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.messageId = 0n;
-    message.unpin = false;
+    message.options = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32470,13 +33874,64 @@ class PinMessageInput$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.options.push(AgentProjectOption.internalBinaryRead(reader, reader.uint32(), options));
           break;
         case 2:
-          message.messageId = reader.int64().toBigInt();
+          message.canSelectFolder = 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) {
+    for (let i = 0;i < message.options.length; i++)
+      AgentProjectOption.internalBinaryWrite(message.options[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.canSelectFolder !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.canSelectFolder);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentProjectCatalog = new AgentProjectCatalog$Type;
+
+class AgentReasoningEffortOption$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentReasoningEffortOption", [
+      { no: 1, name: "id", kind: "scalar", T: 9 },
+      { no: 2, name: "label", kind: "scalar", T: 9 },
+      { no: 3, name: "description", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.id = "";
+    message.label = "";
+    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.id = reader.string();
+          break;
+        case 2:
+          message.label = reader.string();
           break;
         case 3:
-          message.unpin = reader.bool();
+          message.description = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -32490,29 +33945,29 @@ class PinMessageInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.peerId)
-      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.messageId !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
-    if (message.unpin !== false)
-      writer.tag(3, import_runtime.WireType.Varint).bool(message.unpin);
+    if (message.id !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.id);
+    if (message.label !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.label);
+    if (message.description !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.description);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var PinMessageInput = new PinMessageInput$Type;
+var AgentReasoningEffortOption = new AgentReasoningEffortOption$Type;
 
-class PinMessageResult$Type extends import_runtime4.MessageType {
+class AgentReasoningCatalog$Type extends import_runtime4.MessageType {
   constructor() {
-    super("PinMessageResult", [
-      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    super("AgentReasoningCatalog", [
+      { no: 1, name: "options", kind: "message", repeat: 1, T: () => AgentReasoningEffortOption }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.updates = [];
+    message.options = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32523,7 +33978,7 @@ class PinMessageResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          message.options.push(AgentReasoningEffortOption.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -32537,26 +33992,30 @@ class PinMessageResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.updates.length; i++)
-      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.options.length; i++)
+      AgentReasoningEffortOption.internalBinaryWrite(message.options[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 PinMessageResult = new PinMessageResult$Type;
+var AgentReasoningCatalog = new AgentReasoningCatalog$Type;
 
-class DraftMessage$Type extends import_runtime4.MessageType {
+class AgentModelOption$Type extends import_runtime4.MessageType {
   constructor() {
-    super("DraftMessage", [
-      { no: 1, name: "text", kind: "scalar", T: 9 },
-      { no: 2, name: "entities", kind: "message", T: () => MessageEntities }
+    super("AgentModelOption", [
+      { no: 1, name: "id", kind: "scalar", T: 9 },
+      { no: 2, name: "label", kind: "scalar", T: 9 },
+      { no: 3, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "reasoning_effort_ids", kind: "scalar", repeat: 2, T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.text = "";
+    message.id = "";
+    message.label = "";
+    message.reasoningEffortIds = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -32567,10 +34026,16 @@ class DraftMessage$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.text = reader.string();
+          message.id = reader.string();
           break;
         case 2:
-          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
+          message.label = reader.string();
+          break;
+        case 3:
+          message.description = reader.string();
+          break;
+        case 4:
+          message.reasoningEffortIds.push(reader.string());
           break;
         default:
           let u = options.readUnknownField;
@@ -32584,23 +34049,125 @@ class DraftMessage$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.text !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.text);
-    if (message.entities)
-      MessageEntities.internalBinaryWrite(message.entities, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.id !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.id);
+    if (message.label !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.label);
+    if (message.description !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.description);
+    for (let i = 0;i < message.reasoningEffortIds.length; i++)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.reasoningEffortIds[i]);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var DraftMessage = new DraftMessage$Type;
+var AgentModelOption = new AgentModelOption$Type;
+
+class AgentModelCatalog$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentModelCatalog", [
+      { no: 1, name: "options", kind: "message", repeat: 1, T: () => AgentModelOption }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.options = [];
+    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.options.push(AgentModelOption.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.options.length; i++)
+      AgentModelOption.internalBinaryWrite(message.options[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 AgentModelCatalog = new AgentModelCatalog$Type;
+
+class AgentConfigurationCatalog$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentConfigurationCatalog", [
+      { no: 1, name: "projects", kind: "message", T: () => AgentProjectCatalog },
+      { no: 2, name: "models", kind: "message", T: () => AgentModelCatalog },
+      { no: 3, name: "reasoning", kind: "message", T: () => AgentReasoningCatalog }
+    ]);
+  }
+  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.projects = AgentProjectCatalog.internalBinaryRead(reader, reader.uint32(), options, message.projects);
+          break;
+        case 2:
+          message.models = AgentModelCatalog.internalBinaryRead(reader, reader.uint32(), options, message.models);
+          break;
+        case 3:
+          message.reasoning = AgentReasoningCatalog.internalBinaryRead(reader, reader.uint32(), options, message.reasoning);
+          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.projects)
+      AgentProjectCatalog.internalBinaryWrite(message.projects, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.models)
+      AgentModelCatalog.internalBinaryWrite(message.models, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.reasoning)
+      AgentReasoningCatalog.internalBinaryWrite(message.reasoning, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentConfigurationCatalog = new AgentConfigurationCatalog$Type;
 
 class BotCapability$Type extends import_runtime4.MessageType {
   constructor() {
     super("BotCapability", [
       { no: 1, name: "kind", kind: "enum", T: () => ["BotCapability.Kind", BotCapability_Kind] },
-      { no: 2, name: "version", kind: "scalar", T: 13 }
+      { no: 2, name: "version", kind: "scalar", T: 13 },
+      { no: 3, name: "agent_configuration", kind: "message", T: () => AgentConfigurationCatalog }
     ]);
   }
   create(value) {
@@ -32622,6 +34189,9 @@ class BotCapability$Type extends import_runtime4.MessageType {
         case 2:
           message.version = reader.uint32();
           break;
+        case 3:
+          message.agentConfiguration = AgentConfigurationCatalog.internalBinaryRead(reader, reader.uint32(), options, message.agentConfiguration);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -32638,6 +34208,8 @@ class BotCapability$Type extends import_runtime4.MessageType {
       writer.tag(1, import_runtime.WireType.Varint).int32(message.kind);
     if (message.version !== 0)
       writer.tag(2, import_runtime.WireType.Varint).uint32(message.version);
+    if (message.agentConfiguration)
+      AgentConfigurationCatalog.internalBinaryWrite(message.agentConfiguration, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -36053,17 +37625,229 @@ class FinishUploadInput$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var FinishUploadInput = new FinishUploadInput$Type;
+var FinishUploadInput = new FinishUploadInput$Type;
+
+class UploadMissingParts$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UploadMissingParts", [
+      { no: 1, name: "part_indices", kind: "scalar", repeat: 1, T: 13 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.partIndices = [];
+    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:
+          if (wireType === import_runtime.WireType.LengthDelimited)
+            for (let e = reader.int32() + reader.pos;reader.pos < e; )
+              message.partIndices.push(reader.uint32());
+          else
+            message.partIndices.push(reader.uint32());
+          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.partIndices.length) {
+      writer.tag(1, import_runtime.WireType.LengthDelimited).fork();
+      for (let i = 0;i < message.partIndices.length; i++)
+        writer.uint32(message.partIndices[i]);
+      writer.join();
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UploadMissingParts = new UploadMissingParts$Type;
+
+class UploadProcessing$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UploadProcessing", [
+      { no: 1, name: "retry_after_seconds", kind: "scalar", T: 13 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.retryAfterSeconds = 0;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.retryAfterSeconds = reader.uint32();
+          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.retryAfterSeconds !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).uint32(message.retryAfterSeconds);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UploadProcessing = new UploadProcessing$Type;
+
+class FinishUploadResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("FinishUploadResult", [
+      { no: 1, name: "missing", kind: "message", oneof: "state", T: () => UploadMissingParts },
+      { no: 2, name: "processing", kind: "message", oneof: "state", T: () => UploadProcessing },
+      { no: 3, name: "complete", kind: "message", oneof: "state", T: () => UploadComplete },
+      { no: 4, name: "failed", kind: "message", oneof: "state", T: () => UploadFailure }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.state = { oneofKind: undefined };
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.state = {
+            oneofKind: "missing",
+            missing: UploadMissingParts.internalBinaryRead(reader, reader.uint32(), options, message.state.missing)
+          };
+          break;
+        case 2:
+          message.state = {
+            oneofKind: "processing",
+            processing: UploadProcessing.internalBinaryRead(reader, reader.uint32(), options, message.state.processing)
+          };
+          break;
+        case 3:
+          message.state = {
+            oneofKind: "complete",
+            complete: UploadComplete.internalBinaryRead(reader, reader.uint32(), options, message.state.complete)
+          };
+          break;
+        case 4:
+          message.state = {
+            oneofKind: "failed",
+            failed: UploadFailure.internalBinaryRead(reader, reader.uint32(), options, message.state.failed)
+          };
+          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.state.oneofKind === "missing")
+      UploadMissingParts.internalBinaryWrite(message.state.missing, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state.oneofKind === "processing")
+      UploadProcessing.internalBinaryWrite(message.state.processing, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state.oneofKind === "complete")
+      UploadComplete.internalBinaryWrite(message.state.complete, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state.oneofKind === "failed")
+      UploadFailure.internalBinaryWrite(message.state.failed, 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 FinishUploadResult = new FinishUploadResult$Type;
+
+class CancelUploadInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("CancelUploadInput", [
+      { no: 1, name: "upload_id", kind: "scalar", T: 12 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.uploadId = new Uint8Array(0);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.uploadId = reader.bytes();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.uploadId.length)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).bytes(message.uploadId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var CancelUploadInput = new CancelUploadInput$Type;
 
-class UploadMissingParts$Type extends import_runtime4.MessageType {
+class CancelUploadResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UploadMissingParts", [
-      { no: 1, name: "part_indices", kind: "scalar", repeat: 1, T: 13 }
+    super("CancelUploadResult", [
+      { no: 1, name: "canceled", kind: "scalar", T: 8 },
+      { no: 2, name: "already_terminal", kind: "scalar", T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.partIndices = [];
+    message.canceled = false;
+    message.alreadyTerminal = false;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -36074,11 +37858,10 @@ class UploadMissingParts$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          if (wireType === import_runtime.WireType.LengthDelimited)
-            for (let e = reader.int32() + reader.pos;reader.pos < e; )
-              message.partIndices.push(reader.uint32());
-          else
-            message.partIndices.push(reader.uint32());
+          message.canceled = reader.bool();
+          break;
+        case 2:
+          message.alreadyTerminal = reader.bool();
           break;
         default:
           let u = options.readUnknownField;
@@ -36092,29 +37875,82 @@ class UploadMissingParts$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.partIndices.length) {
-      writer.tag(1, import_runtime.WireType.LengthDelimited).fork();
-      for (let i = 0;i < message.partIndices.length; i++)
-        writer.uint32(message.partIndices[i]);
-      writer.join();
+    if (message.canceled !== false)
+      writer.tag(1, import_runtime.WireType.Varint).bool(message.canceled);
+    if (message.alreadyTerminal !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.alreadyTerminal);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var CancelUploadResult = new CancelUploadResult$Type;
+
+class FileMessageLocation$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("FileMessageLocation", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chatId = 0n;
+    message.messageId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
     }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.messageId !== 0n)
+      writer.tag(2, 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 UploadMissingParts = new UploadMissingParts$Type;
+var FileMessageLocation = new FileMessageLocation$Type;
 
-class UploadProcessing$Type extends import_runtime4.MessageType {
+class GetFilePartInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UploadProcessing", [
-      { no: 1, name: "retry_after_seconds", kind: "scalar", T: 13 }
+    super("GetFilePartInput", [
+      { no: 1, name: "file_unique_id", kind: "scalar", T: 9 },
+      { no: 2, name: "offset", kind: "scalar", T: 4, L: 0 },
+      { no: 3, name: "limit", kind: "scalar", T: 13 },
+      { no: 4, name: "message", kind: "message", T: () => FileMessageLocation }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.retryAfterSeconds = 0;
+    message.fileUniqueId = "";
+    message.offset = 0n;
+    message.limit = 0;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -36125,7 +37961,16 @@ class UploadProcessing$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.retryAfterSeconds = reader.uint32();
+          message.fileUniqueId = reader.string();
+          break;
+        case 2:
+          message.offset = reader.uint64().toBigInt();
+          break;
+        case 3:
+          message.limit = reader.uint32();
+          break;
+        case 4:
+          message.message = FileMessageLocation.internalBinaryRead(reader, reader.uint32(), options, message.message);
           break;
         default:
           let u = options.readUnknownField;
@@ -36139,28 +37984,37 @@ class UploadProcessing$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.retryAfterSeconds !== 0)
-      writer.tag(1, import_runtime.WireType.Varint).uint32(message.retryAfterSeconds);
+    if (message.fileUniqueId !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
+    if (message.offset !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).uint64(message.offset);
+    if (message.limit !== 0)
+      writer.tag(3, import_runtime.WireType.Varint).uint32(message.limit);
+    if (message.message)
+      FileMessageLocation.internalBinaryWrite(message.message, 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 UploadProcessing = new UploadProcessing$Type;
+var GetFilePartInput = new GetFilePartInput$Type;
 
-class FinishUploadResult$Type extends import_runtime4.MessageType {
+class GetFilePartResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("FinishUploadResult", [
-      { no: 1, name: "missing", kind: "message", oneof: "state", T: () => UploadMissingParts },
-      { no: 2, name: "processing", kind: "message", oneof: "state", T: () => UploadProcessing },
-      { no: 3, name: "complete", kind: "message", oneof: "state", T: () => UploadComplete },
-      { no: 4, name: "failed", kind: "message", oneof: "state", T: () => UploadFailure }
+    super("GetFilePartResult", [
+      { no: 1, name: "offset", kind: "scalar", T: 4, L: 0 },
+      { no: 2, name: "total_size", kind: "scalar", T: 4, L: 0 },
+      { no: 3, name: "data", kind: "scalar", T: 12 },
+      { no: 4, name: "sha256", kind: "scalar", T: 12 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.state = { oneofKind: undefined };
+    message.offset = 0n;
+    message.totalSize = 0n;
+    message.data = new Uint8Array(0);
+    message.sha256 = new Uint8Array(0);
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -36171,28 +38025,16 @@ class FinishUploadResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.state = {
-            oneofKind: "missing",
-            missing: UploadMissingParts.internalBinaryRead(reader, reader.uint32(), options, message.state.missing)
-          };
+          message.offset = reader.uint64().toBigInt();
           break;
         case 2:
-          message.state = {
-            oneofKind: "processing",
-            processing: UploadProcessing.internalBinaryRead(reader, reader.uint32(), options, message.state.processing)
-          };
+          message.totalSize = reader.uint64().toBigInt();
           break;
         case 3:
-          message.state = {
-            oneofKind: "complete",
-            complete: UploadComplete.internalBinaryRead(reader, reader.uint32(), options, message.state.complete)
-          };
+          message.data = reader.bytes();
           break;
         case 4:
-          message.state = {
-            oneofKind: "failed",
-            failed: UploadFailure.internalBinaryRead(reader, reader.uint32(), options, message.state.failed)
-          };
+          message.sha256 = reader.bytes();
           break;
         default:
           let u = options.readUnknownField;
@@ -36206,31 +38048,41 @@ class FinishUploadResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.state.oneofKind === "missing")
-      UploadMissingParts.internalBinaryWrite(message.state.missing, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.state.oneofKind === "processing")
-      UploadProcessing.internalBinaryWrite(message.state.processing, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.state.oneofKind === "complete")
-      UploadComplete.internalBinaryWrite(message.state.complete, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.state.oneofKind === "failed")
-      UploadFailure.internalBinaryWrite(message.state.failed, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.offset !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).uint64(message.offset);
+    if (message.totalSize !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).uint64(message.totalSize);
+    if (message.data.length)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).bytes(message.data);
+    if (message.sha256.length)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).bytes(message.sha256);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var FinishUploadResult = new FinishUploadResult$Type;
+var GetFilePartResult = new GetFilePartResult$Type;
 
-class CancelUploadInput$Type extends import_runtime4.MessageType {
+class ChatAcknowledgement$Type extends import_runtime4.MessageType {
   constructor() {
-    super("CancelUploadInput", [
-      { no: 1, name: "upload_id", kind: "scalar", T: 12 }
+    super("ChatAcknowledgement", [
+      { no: 1, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "max_id", kind: "scalar", T: 3, L: 0 },
+      { no: 4, name: "user", kind: "message", T: () => User },
+      { no: 5, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 6, name: "revision", kind: "scalar", T: 3, L: 0 },
+      { no: 7, name: "cleared", kind: "scalar", T: 8 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.uploadId = new Uint8Array(0);
+    message.chatId = 0n;
+    message.userId = 0n;
+    message.maxId = 0n;
+    message.revision = 0n;
+    message.cleared = false;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -36241,7 +38093,25 @@ class CancelUploadInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.uploadId = reader.bytes();
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.userId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.maxId = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+          break;
+        case 5:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 6:
+          message.revision = reader.int64().toBigInt();
+          break;
+        case 7:
+          message.cleared = reader.bool();
           break;
         default:
           let u = options.readUnknownField;
@@ -36255,27 +38125,42 @@ class CancelUploadInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.uploadId.length)
-      writer.tag(1, import_runtime.WireType.LengthDelimited).bytes(message.uploadId);
+    if (message.chatId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.userId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.userId);
+    if (message.maxId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.maxId);
+    if (message.user)
+      User.internalBinaryWrite(message.user, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(5, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.revision !== 0n)
+      writer.tag(6, import_runtime.WireType.Varint).int64(message.revision);
+    if (message.cleared !== false)
+      writer.tag(7, import_runtime.WireType.Varint).bool(message.cleared);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var CancelUploadInput = new CancelUploadInput$Type;
+var ChatAcknowledgement = new ChatAcknowledgement$Type;
 
-class CancelUploadResult$Type extends import_runtime4.MessageType {
+class AcknowledgeMessagesInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("CancelUploadResult", [
-      { no: 1, name: "canceled", kind: "scalar", T: 8 },
-      { no: 2, name: "already_terminal", kind: "scalar", T: 8 }
+    super("AcknowledgeMessagesInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "max_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "clear", kind: "scalar", T: 8 },
+      { no: 4, name: "expected_revision", kind: "scalar", T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.canceled = false;
-    message.alreadyTerminal = false;
+    message.maxId = 0n;
+    message.clear = false;
+    message.expectedRevision = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -36286,10 +38171,16 @@ class CancelUploadResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.canceled = reader.bool();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         case 2:
-          message.alreadyTerminal = reader.bool();
+          message.maxId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.clear = reader.bool();
+          break;
+        case 4:
+          message.expectedRevision = reader.int64().toBigInt();
           break;
         default:
           let u = options.readUnknownField;
@@ -36303,17 +38194,107 @@ class CancelUploadResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.canceled !== false)
-      writer.tag(1, import_runtime.WireType.Varint).bool(message.canceled);
-    if (message.alreadyTerminal !== false)
-      writer.tag(2, import_runtime.WireType.Varint).bool(message.alreadyTerminal);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.maxId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.maxId);
+    if (message.clear !== false)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.clear);
+    if (message.expectedRevision !== 0n)
+      writer.tag(4, import_runtime.WireType.Varint).int64(message.expectedRevision);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var CancelUploadResult = new CancelUploadResult$Type;
+var AcknowledgeMessagesInput = new AcknowledgeMessagesInput$Type;
+
+class AcknowledgeMessagesResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AcknowledgeMessagesResult", [
+      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.updates = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AcknowledgeMessagesResult = new AcknowledgeMessagesResult$Type;
+
+class ChatAcknowledgements$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ChatAcknowledgements", [
+      { no: 1, name: "cursors", kind: "message", repeat: 1, T: () => ChatAcknowledgement }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.cursors = [];
+    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.cursors.push(ChatAcknowledgement.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.cursors.length; i++)
+      ChatAcknowledgement.internalBinaryWrite(message.cursors[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 ChatAcknowledgements = new ChatAcknowledgements$Type;
 
 // node_modules/@noble/hashes/esm/utils.js
 /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
@@ -36636,23 +38617,37 @@ class SHA256 extends HashMD {
 }
 var sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
 
+// node_modules/@inline-chat/protocol/dist/transfers.js
+var INLINE_TRANSFER_PART_SIZE = 512 * 1024;
+var INLINE_UPLOAD_MAX_PARTS = 1000;
+
 // node_modules/@inline-chat/protocol/dist/uploads.js
 var HASH_READ_SIZE = 1024 * 1024;
-var MAX_NEGOTIATED_PART_SIZE = 16 * 1024 * 1024;
 var DEFAULT_GLOBAL_CONCURRENCY = 3;
 var DEFAULT_UPLOAD_CONCURRENCY = 2;
 var MAX_PART_ATTEMPTS = 2;
 var MAX_FINISH_RECONCILIATION_ATTEMPTS = 3;
 var FINISH_RECONCILIATION_DELAY_SECONDS = 1;
 var MAX_PROCESSING_RETRY_SECONDS = 30;
+var CANCEL_RPC_TIMEOUT_MS = 5000;
+var MAX_UPLOAD_BYTES_BY_KIND = {
+  [UploadKind.PHOTO]: 40000000,
+  [UploadKind.VIDEO]: 200000000,
+  [UploadKind.DOCUMENT]: 200000000,
+  [UploadKind.VOICE]: 20000000
+};
 var boundedUploadProcessingRetrySeconds = (seconds) => Number.isNaN(seconds) ? 1 : Math.min(MAX_PROCESSING_RETRY_SECONDS, Math.max(1, Math.floor(seconds)));
 var randomUploadId = () => {
   const bytes = new Uint8Array(16);
   globalThis.crypto.getRandomValues(bytes);
   return bytes;
 };
-var exactRead = async (source, offset, length) => {
-  const bytes = await source.read(offset, length);
+var exactRead = async (source, offset, length, signal) => {
+  if (signal?.aborted)
+    throw new NativeUploadError("canceled", "Upload was canceled");
+  const bytes = await source.read(offset, length, signal);
+  if (signal?.aborted)
+    throw new NativeUploadError("canceled", "Upload was canceled");
   if (bytes.length !== length)
     throw new NativeUploadError("source_changed", "Upload source changed while it was being read");
   return bytes;
@@ -36663,7 +38658,7 @@ var sourceHash = async (source, signal) => {
     if (signal?.aborted)
       throw new NativeUploadError("canceled", "Upload was canceled");
     const length = Math.min(HASH_READ_SIZE, source.byteCount - offset);
-    const bytes = await exactRead(source, offset, length);
+    const bytes = await exactRead(source, offset, length, signal);
     if (signal?.aborted)
       throw new NativeUploadError("canceled", "Upload was canceled");
     hash.update(bytes);
@@ -36683,12 +38678,18 @@ var validatePartIndices = (indices, partCount) => {
     throw new NativeUploadError("protocol", "Server returned an invalid upload-part index");
   }
 };
+var reportProgress = (job) => {
+  try {
+    job.input.onProgress?.({ acceptedBytes: acceptedBytes(job), totalBytes: job.input.source.byteCount });
+  } catch {}
+};
 var delay = async (seconds, signal) => {
   if (signal?.aborted)
     throw new NativeUploadError("canceled", "Upload was canceled");
   await new Promise((resolve, reject) => {
     const onAbort = () => {
       clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
       reject(new NativeUploadError("canceled", "Upload was canceled"));
     };
     const timeout = setTimeout(() => {
@@ -36696,6 +38697,8 @@ var delay = async (seconds, signal) => {
       resolve();
     }, Math.max(1, seconds) * 1000);
     signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted)
+      onAbort();
   });
 };
 
@@ -36705,6 +38708,7 @@ class NativeUploadClient {
   uploadConcurrency;
   #jobs = [];
   #active = 0;
+  #finishing = 0;
   #cursor = 0;
   constructor(rpc, globalConcurrency = DEFAULT_GLOBAL_CONCURRENCY, uploadConcurrency = DEFAULT_UPLOAD_CONCURRENCY) {
     this.rpc = rpc;
@@ -36718,13 +38722,17 @@ class NativeUploadClient {
     if (!Number.isSafeInteger(input.source.byteCount) || input.source.byteCount <= 0) {
       throw new NativeUploadError("invalid_source", "Upload source must have a positive safe byte count");
     }
+    const maximumByteCount = MAX_UPLOAD_BYTES_BY_KIND[input.kind];
+    if (maximumByteCount === undefined || input.source.byteCount > maximumByteCount) {
+      throw new NativeUploadError("invalid_source", "Upload source exceeds the media size limit");
+    }
     if (input.signal?.aborted)
       throw new NativeUploadError("canceled", "Upload was canceled");
     const clientUploadId = input.clientUploadId?.slice() ?? randomUploadId();
     if (clientUploadId.length !== 16)
       throw new NativeUploadError("invalid_source", "Client upload ID must be 16 bytes");
     const digest = await sourceHash(input.source, input.signal);
-    const created = await this.rpc.create({
+    const createInput = {
       clientUploadId,
       fileName: input.fileName,
       mimeType: input.mimeType,
@@ -36733,8 +38741,24 @@ class NativeUploadClient {
       kind: input.kind,
       thumbnailFileUniqueId: input.thumbnailFileUniqueId,
       metadata: input.metadata?.kind === "video" ? { oneofKind: "video", video: input.metadata.value } : input.metadata?.kind === "voice" ? { oneofKind: "voice", voice: input.metadata.value } : { oneofKind: undefined }
-    });
-    if (created.uploadId.length !== 16 || created.partSize < 1 || created.partSize > MAX_NEGOTIATED_PART_SIZE || created.partCount < 1 || created.partCount !== Math.ceil(input.source.byteCount / created.partSize) || created.acceptedParts.some((index) => !Number.isInteger(index) || index < 0 || index >= created.partCount)) {
+    };
+    let created;
+    try {
+      created = await this.rpc.create(createInput, input.signal);
+    } catch (error) {
+      if (input.signal?.aborted)
+        throw new NativeUploadError("canceled", "Upload was canceled");
+      if (this.rpc.shouldReplayCreate?.(error) === false)
+        throw error;
+      try {
+        created = await this.rpc.create(createInput, input.signal);
+      } catch (replayError) {
+        if (input.signal?.aborted)
+          throw new NativeUploadError("canceled", "Upload was canceled");
+        throw replayError;
+      }
+    }
+    if (created.uploadId.length !== 16 || created.partSize !== INLINE_TRANSFER_PART_SIZE || !Number.isSafeInteger(created.partCount) || created.partCount < 1 || created.partCount > INLINE_UPLOAD_MAX_PARTS || created.partCount !== Math.ceil(input.source.byteCount / created.partSize) || created.acceptedParts.some((index) => !Number.isInteger(index) || index < 0 || index >= created.partCount)) {
       throw new NativeUploadError("protocol", "Server returned invalid upload geometry");
     }
     return await new Promise((resolve, reject) => {
@@ -36759,13 +38783,13 @@ class NativeUploadClient {
         this.#abort(job);
         return;
       }
-      input.onProgress?.({ acceptedBytes: acceptedBytes(job), totalBytes: input.source.byteCount });
+      reportProgress(job);
       if (!job.settled)
         this.#pump();
     });
   }
   #pump() {
-    while (this.#active < this.globalConcurrency) {
+    while (this.#active + this.#finishing < this.globalConcurrency) {
       const selected = this.#nextJob();
       if (!selected)
         break;
@@ -36780,6 +38804,10 @@ class NativeUploadClient {
       this.#active += 1;
       this.#sendPart(selected, partIndex);
     }
+    for (const job of this.#jobs) {
+      if (!job.settled && job.active === 0 && this.#nextPart(job) === undefined)
+        this.#finish(job);
+    }
   }
   #nextJob() {
     for (let offset = 0;offset < this.#jobs.length; offset += 1) {
@@ -36805,14 +38833,14 @@ class NativeUploadClient {
         throw new NativeUploadError("canceled", "Upload was canceled");
       const offset = partIndex * job.upload.partSize;
       const length = Math.min(job.upload.partSize, job.input.source.byteCount - offset);
-      const data = await exactRead(job.input.source, offset, length);
+      const data = await exactRead(job.input.source, offset, length, job.input.signal);
       if (job.settled)
         return;
       await this.#savePart(job, partIndex, data);
       if (job.settled)
         return;
       job.accepted.add(partIndex);
-      job.input.onProgress?.({ acceptedBytes: acceptedBytes(job), totalBytes: job.input.source.byteCount });
+      reportProgress(job);
     } catch (error) {
       if (!job.settled && !job.input.signal?.aborted) {
         this.#reject(job, error);
@@ -36832,7 +38860,7 @@ class NativeUploadClient {
         throw new NativeUploadError("canceled", "Upload was canceled");
       }
       try {
-        await this.rpc.savePart({ uploadId: job.upload.uploadId, partIndex, data });
+        await this.rpc.savePart({ uploadId: job.upload.uploadId, partIndex, data }, job.input.signal);
         return;
       } catch (error) {
         if (job.settled || job.input.signal?.aborted) {
@@ -36840,7 +38868,7 @@ class NativeUploadClient {
         }
         let state;
         try {
-          state = await this.rpc.state({ uploadId: job.upload.uploadId });
+          state = await this.rpc.state({ uploadId: job.upload.uploadId }, job.input.signal);
         } catch {
           throw error;
         }
@@ -36853,8 +38881,9 @@ class NativeUploadClient {
     }
   }
   async#finish(job) {
-    if (job.settled || job.active > 0)
+    if (job.settled || job.active !== 0 || this.#active + this.#finishing >= this.globalConcurrency)
       return;
+    this.#finishing += 1;
     job.active = -1;
     let reconciliationAttempts = 0;
     try {
@@ -36863,7 +38892,7 @@ class NativeUploadClient {
           throw new NativeUploadError("canceled", "Upload was canceled");
         let result;
         try {
-          result = await this.rpc.finish({ uploadId: job.upload.uploadId });
+          result = await this.rpc.finish({ uploadId: job.upload.uploadId }, job.input.signal);
         } catch (error) {
           if (job.input.signal?.aborted)
             throw new NativeUploadError("canceled", "Upload was canceled");
@@ -36871,7 +38900,7 @@ class NativeUploadClient {
             throw error;
           let state;
           try {
-            state = await this.rpc.state({ uploadId: job.upload.uploadId });
+            state = await this.rpc.state({ uploadId: job.upload.uploadId }, job.input.signal);
           } catch {
             throw error;
           }
@@ -36885,8 +38914,8 @@ class NativeUploadClient {
               job.resolve(state.complete);
               return;
             case UploadStatus.PROCESSING:
-              await delay(FINISH_RECONCILIATION_DELAY_SECONDS, job.input.signal);
-              continue;
+              this.#resumeFinishAfter(job, FINISH_RECONCILIATION_DELAY_SECONDS);
+              return;
             case UploadStatus.UPLOADING:
               job.accepted = new Set(state.acceptedParts);
               if (this.#nextPart(job) === undefined)
@@ -36913,6 +38942,9 @@ class NativeUploadClient {
           case "failed":
             throw new NativeUploadError(result.state.failed.retryable ? "retryable" : "rejected", `Upload finalization failed with code ${result.state.failed.code}`);
           case "missing":
+            if (result.state.missing.partIndices.length === 0) {
+              throw new NativeUploadError("protocol", "Server returned an empty missing-parts result");
+            }
             validatePartIndices(result.state.missing.partIndices, job.upload.partCount);
             for (const index of result.state.missing.partIndices)
               job.accepted.delete(index);
@@ -36920,21 +38952,35 @@ class NativeUploadClient {
             this.#pump();
             return;
           case "processing":
-            await delay(boundedUploadProcessingRetrySeconds(result.state.processing.retryAfterSeconds), job.input.signal);
-            break;
+            this.#resumeFinishAfter(job, boundedUploadProcessingRetrySeconds(result.state.processing.retryAfterSeconds));
+            return;
           default:
             throw new NativeUploadError("protocol", "Server returned an empty finish result");
         }
       }
     } catch (error) {
       this.#reject(job, error);
+    } finally {
+      this.#finishing -= 1;
+      this.#pump();
     }
   }
+  #resumeFinishAfter(job, seconds) {
+    delay(seconds, job.input.signal).then(() => {
+      if (job.settled)
+        return;
+      job.active = 0;
+      this.#finish(job);
+    }, (error) => {
+      if (!job.settled)
+        this.#reject(job, error);
+    });
+  }
   #abort(job) {
     if (job.settled)
       return;
     this.#reject(job, new NativeUploadError("canceled", "Upload was canceled"));
-    this.rpc.cancel({ uploadId: job.upload.uploadId }).catch(() => {});
+    this.rpc.cancel({ uploadId: job.upload.uploadId }, AbortSignal.timeout(CANCEL_RPC_TIMEOUT_MS)).catch(() => {});
   }
   #reject(job, error) {
     if (job.settled)
@@ -36965,33 +39011,34 @@ var uploadByteSource = (value) => {
     read: async (offset, length) => bytes.slice(offset, offset + length)
   };
 };
-var rpcUploadTransport = (call) => ({
-  create: async (input) => {
-    const result = await call(Method.CREATE_UPLOAD, { oneofKind: "createUpload", createUpload: input });
+var rpcUploadTransport = (call, shouldReplayCreate) => ({
+  shouldReplayCreate,
+  create: async (input, signal) => {
+    const result = await call(Method.CREATE_UPLOAD, { oneofKind: "createUpload", createUpload: input }, signal);
     if (result.oneofKind !== "createUpload")
       throw new NativeUploadError("protocol", "Unexpected createUpload result");
     return result.createUpload;
   },
-  savePart: async (input) => {
-    const result = await call(Method.SAVE_UPLOAD_PART, { oneofKind: "saveUploadPart", saveUploadPart: input });
+  savePart: async (input, signal) => {
+    const result = await call(Method.SAVE_UPLOAD_PART, { oneofKind: "saveUploadPart", saveUploadPart: input }, signal);
     if (result.oneofKind !== "saveUploadPart")
       throw new NativeUploadError("protocol", "Unexpected saveUploadPart result");
     return result.saveUploadPart;
   },
-  state: async (input) => {
-    const result = await call(Method.GET_UPLOAD_STATE, { oneofKind: "getUploadState", getUploadState: input });
+  state: async (input, signal) => {
+    const result = await call(Method.GET_UPLOAD_STATE, { oneofKind: "getUploadState", getUploadState: input }, signal);
     if (result.oneofKind !== "getUploadState")
       throw new NativeUploadError("protocol", "Unexpected getUploadState result");
     return result.getUploadState;
   },
-  finish: async (input) => {
-    const result = await call(Method.FINISH_UPLOAD, { oneofKind: "finishUpload", finishUpload: input });
+  finish: async (input, signal) => {
+    const result = await call(Method.FINISH_UPLOAD, { oneofKind: "finishUpload", finishUpload: input }, signal);
     if (result.oneofKind !== "finishUpload")
       throw new NativeUploadError("protocol", "Unexpected finishUpload result");
     return result.finishUpload;
   },
-  cancel: async (input) => {
-    const result = await call(Method.CANCEL_UPLOAD, { oneofKind: "cancelUpload", cancelUpload: input });
+  cancel: async (input, signal) => {
+    const result = await call(Method.CANCEL_UPLOAD, { oneofKind: "cancelUpload", cancelUpload: input }, signal);
     if (result.oneofKind !== "cancelUpload")
       throw new NativeUploadError("protocol", "Unexpected cancelUpload result");
     return result.cancelUpload;
@@ -37527,6 +39574,7 @@ class ProtocolClient {
   async callRpc(method, input = emptyRpcInput, options) {
     if (this.terminalAuthenticationError)
       throw this.terminalAuthenticationError;
+    options?.signal?.throwIfAborted();
     assertValidRpcMethod(method);
     if (this.pendingRpcRequests.size >= this.maxPendingRpcRequests) {
       throw new ProtocolClientError("capacity-exceeded", {
@@ -37548,6 +39596,14 @@ class ProtocolClient {
         sending: false
       };
       this.pendingRpcRequests.set(message.id, pending);
+      const onAbort = () => {
+        const reason = options?.signal?.reason;
+        this.failPendingRpcRequest(message.id, reason instanceof Error ? reason : new DOMException("The operation was aborted", "AbortError"));
+      };
+      options?.signal?.addEventListener("abort", onAbort, { once: true });
+      pending.removeAbortListener = () => options?.signal?.removeEventListener("abort", onAbort);
+      if (options?.signal?.aborted)
+        onAbort();
       if (pending.timeoutMs !== null) {
         pending.timeout = setTimeout(() => {
           this.failPendingRpcRequest(message.id, pending.attempted && pending.reconnectPolicy === "never-replay" ? commitOutcomeUnknownError("RPC timed out after dispatch") : new ProtocolClientError("timeout"));
@@ -37796,6 +39852,7 @@ class ProtocolClient {
       return null;
     if (pending.timeout)
       clearTimeout(pending.timeout);
+    pending.removeAbortListener?.();
     this.pendingRpcRequests.delete(msgId);
     return pending;
   }
@@ -37804,6 +39861,7 @@ class ProtocolClient {
       pending.reject(error);
       if (pending.timeout)
         clearTimeout(pending.timeout);
+      pending.removeAbortListener?.();
     }
     this.pendingRpcRequests.clear();
   }
@@ -39929,21 +41987,40 @@ class AcknowledgementQueue {
 
 class PendingMessageCache {
   capacity;
+  byteCapacity;
   #messages = new Map;
-  constructor(capacity = 8192) {
+  #retainedBytes = 0;
+  constructor(capacity = 8192, byteCapacity = 32 * 1024 * 1024) {
     this.capacity = capacity;
+    this.byteCapacity = byteCapacity;
     if (!Number.isSafeInteger(capacity) || capacity < 1 || capacity > 8192)
       throw new RangeError("Invalid pending-message capacity");
+    if (!Number.isSafeInteger(byteCapacity) || byteCapacity < 1)
+      throw new RangeError("Invalid pending-message byte capacity");
+  }
+  get retainedBytes() {
+    return this.#retainedBytes;
   }
   retain(message) {
     if (this.#messages.size >= this.capacity && !this.#messages.has(message.messageId)) {
       throw new RangeError("Pending-message cache is full");
     }
-    this.#messages.set(message.messageId, { ...message, body: message.body.slice() });
+    const previous = this.#messages.get(message.messageId);
+    const nextBytes = this.#retainedBytes - (previous?.body.length ?? 0) + message.body.length;
+    if (nextBytes > this.byteCapacity)
+      throw new RangeError("Pending-message byte capacity exceeded");
+    const body = message.body.slice();
+    this.#messages.set(message.messageId, { ...message, body });
+    this.#retainedBytes = nextBytes;
   }
   acknowledge(messageIds) {
-    for (const messageId of messageIds)
+    for (const messageId of messageIds) {
+      const message = this.#messages.get(messageId);
+      if (!message)
+        continue;
       this.#messages.delete(messageId);
+      this.#retainedBytes -= message.body.length;
+    }
   }
   resend(messageIds) {
     return messageIds.flatMap((messageId) => {
@@ -39962,6 +42039,7 @@ class PendingMessageCache {
       if (view.getUint32(0, true) !== 4082920705 || view.getBigInt64(4, true) !== requestMessageId)
         continue;
       this.#messages.delete(messageId);
+      this.#retainedBytes -= message.body.length;
       return { ...message, body: message.body.slice() };
     }
     return;
@@ -40996,11 +43074,12 @@ class InlineProtocolServerSession {
     try {
       const resultObject = input.dispatched.kind === "result" ? encodeInlineResult(input.dispatched.payload) : encodeRpcError(input.dispatched.code, input.dispatched.message);
       const resultBody = encodeRpcResult(input.messageId, resultObject);
+      const replayResultBody = input.dispatched.kind === "result" && input.dispatched.replayPayload ? encodeRpcResult(input.messageId, encodeInlineResult(input.dispatched.replayPayload)) : resultBody;
       const completion = await this.options.replay.complete({
         authKeyId: input.authKeyId,
         sessionId: input.sessionId,
         messageId: input.messageId,
-        resultBody
+        resultBody: replayResultBody
       });
       const terminateAuthorization = input.dispatched.terminateAuthorization === true;
       if (terminateAuthorization) {
@@ -41344,7 +43423,7 @@ class InlineProtocolV3Connection {
     this.#sessionId = randomInt64(this.#random);
     this.#authorization = options.authorization ? cloneAuthorization(options.authorization) : undefined;
     this.#rsaKeys = options.authorization ? [] : decodePublicKeys(options.rsaPublicKeys);
-    this.#uploads = new NativeUploadClient(rpcUploadTransport((method, input) => this.callRpc({ method, input })));
+    this.#uploads = new NativeUploadClient(rpcUploadTransport((method, input, signal) => this.callRpc({ method, input }, signal), (error) => error instanceof InlineProtocolV3Error && error.code === "commit-outcome-unknown"));
   }
   static async connect(options) {
     const connection = new InlineProtocolV3Connection(options);
@@ -41395,9 +43474,9 @@ class InlineProtocolV3Connection {
   async invoke(request) {
     return await this.#invoke(request);
   }
-  async#invoke(request, onDispatched) {
+  async#invoke(request, onDispatched, signal) {
     const payload = RealtimeV3Request.toBinary(request);
-    const result = await this.#sendContent(encodeInlineInvoke(payload), onDispatched);
+    const result = await this.#sendContent(encodeInlineInvoke(payload), onDispatched, signal);
     let application2;
     try {
       application2 = decodeInlineApplicationObject(result);
@@ -41434,9 +43513,9 @@ class InlineProtocolV3Connection {
       throw new InlineProtocolV3Error("protocol", "Unexpected auth.complete response");
     return response.body.authComplete;
   }
-  async callRpc(rpc) {
+  async callRpc(rpc, signal) {
     const request = { body: { oneofKind: "rpc", rpc } };
-    const response = readOnlyRpcMethods.has(rpc.method) ? await this.#invoke(request) : await this.#invokeMutation(request);
+    const response = readOnlyRpcMethods.has(rpc.method) ? await this.#invoke(request, undefined, signal) : await this.#invokeMutation(request, signal);
     if (response.body.oneofKind === "rpcError")
       throw new InlineProtocolV3Error("protocol", response.body.rpcError.message);
     if (response.body.oneofKind !== "rpcResult")
@@ -41539,12 +43618,12 @@ class InlineProtocolV3Connection {
       throw new InlineProtocolV3Error("protocol", "Unexpected upload response");
     return response.body.finishHttpUpload;
   }
-  async#invokeMutation(request) {
+  async#invokeMutation(request, signal) {
     let dispatched = false;
     try {
       return await this.#invoke(request, () => {
         dispatched = true;
-      });
+      }, signal);
     } catch (error) {
       if (dispatched && error instanceof InlineProtocolV3Error && ["closed", "protocol", "timeout", "unauthorized"].includes(error.code)) {
         throw new InlineProtocolV3Error("commit-outcome-unknown", "Mutation lost its authoritative result after Inline Protocol dispatch; the outcome is unknown", { cause: error });
@@ -41634,12 +43713,13 @@ class InlineProtocolV3Connection {
       return;
     }
   }
-  async#sendContent(body, onDispatched) {
+  async#sendContent(body, onDispatched, signal) {
     const messageId = this.#nextClientMessageId();
     const sequenceNumber = this.#sequenceNumbers.next(true);
-    return (await this.#sendPreparedContent(messageId, sequenceNumber, body, onDispatched)).result;
+    return (await this.#sendPreparedContent(messageId, sequenceNumber, body, onDispatched, signal)).result;
   }
-  async#sendPreparedContent(initialMessageId, sequenceNumber, body, onDispatched) {
+  async#sendPreparedContent(initialMessageId, sequenceNumber, body, onDispatched, signal) {
+    signal?.throwIfAborted();
     this.#admitPending(body);
     return await new Promise((resolve, reject) => {
       let pending;
@@ -41648,6 +43728,7 @@ class InlineProtocolV3Connection {
           return;
         this.#pendingContent.delete(pending.messageId);
         this.#releasePending(body);
+        pending.removeAbortListener?.();
         reject(new InlineProtocolV3Error("timeout", `Inline Protocol response timed out after ${this.#options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS}ms`));
       }, this.#options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS);
       pending = {
@@ -41659,6 +43740,22 @@ class InlineProtocolV3Connection {
         timeout
       };
       this.#pendingContent.set(initialMessageId, pending);
+      const onAbort = () => {
+        if (this.#pendingContent.get(pending.messageId) !== pending)
+          return;
+        this.#pendingContent.delete(pending.messageId);
+        this.#releasePending(body);
+        clearTimeout(pending.timeout);
+        pending.removeAbortListener?.();
+        const reason = signal?.reason;
+        reject(reason instanceof Error ? reason : new DOMException("The operation was aborted", "AbortError"));
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      pending.removeAbortListener = () => signal?.removeEventListener("abort", onAbort);
+      if (signal?.aborted)
+        onAbort();
+      if (this.#pendingContent.get(initialMessageId) !== pending)
+        return;
       try {
         this.#sendEncrypted(initialMessageId, sequenceNumber, body, true);
         onDispatched?.();
@@ -41666,6 +43763,7 @@ class InlineProtocolV3Connection {
         this.#pendingContent.delete(initialMessageId);
         this.#releasePending(body);
         clearTimeout(pending.timeout);
+        pending.removeAbortListener?.();
         reject(error instanceof Error ? error : new Error(String(error)));
       }
     });
@@ -41710,6 +43808,7 @@ class InlineProtocolV3Connection {
         this.#pendingContent.delete(result.requestMessageId);
         this.#releasePending(pending.body);
         clearTimeout(pending.timeout);
+        pending.removeAbortListener?.();
         pending.resolve({ messageId: result.requestMessageId, result: result.result });
         continue;
       }
@@ -41758,6 +43857,8 @@ class InlineProtocolV3Connection {
       const rejected = pending ?? probeEntry[1];
       this.#releasePending(rejected.body);
       clearTimeout(rejected.timeout);
+      if ("removeAbortListener" in rejected)
+        rejected.removeAbortListener?.();
       rejected.reject(new InlineProtocolV3Error("protocol", `Server rejected the outgoing message (${bad.errorCode})`));
       return;
     }
@@ -41774,6 +43875,7 @@ class InlineProtocolV3Connection {
     this.#pendingContent.clear();
     for (const item of pending) {
       clearTimeout(item.timeout);
+      item.removeAbortListener?.();
       item.reject(error);
     }
     const probes = [...this.#pendingProbes.values()];
@@ -42111,6 +44213,7 @@ class InlineProtocolV3Transport {
       throw new Error("Inline Protocol connection attempt was superseded");
     }
     let connection;
+    let openingCloseError;
     const temporary = this.#credentials.temporary;
     if (temporary?.expiresAt !== undefined) {
       try {
@@ -42125,7 +44228,13 @@ class InlineProtocolV3Transport {
               this.#connectionFailed(generation, error instanceof Error ? error : new Error(String(error)));
             });
           },
-          onClose: (error) => this.#connectionFailed(generation, error),
+          onClose: (error) => {
+            if (cachedSource && this.#connection === cachedSource) {
+              this.#connectionFailed(generation, error);
+            } else {
+              openingCloseError ??= error;
+            }
+          },
           onRotationDue: () => {
             setTimeout(() => {
               if (cachedSource)
@@ -42135,11 +44244,14 @@ class InlineProtocolV3Transport {
         });
         cachedSource = connection;
         await connection.probeTemporaryAuthorization();
+        if (openingCloseError)
+          throw openingCloseError;
         this.#requireCurrent(generation);
         if (connection.temporaryAuthorizationNeedsRotation()) {
           this.#log.info?.("Stored Inline Protocol temporary authorization reached its rotation boundary");
           await connection.close();
           connection = undefined;
+          openingCloseError = undefined;
         }
       } catch (error) {
         await connection?.close();
@@ -42147,6 +44259,7 @@ class InlineProtocolV3Transport {
         if (!isAuthenticationInvalidated(error))
           throw error;
         this.#log.warn?.("Stored Inline Protocol temporary authorization was rejected; regenerating once", error);
+        openingCloseError = undefined;
       }
     }
     if (!connection) {
@@ -42167,7 +44280,13 @@ class InlineProtocolV3Transport {
             this.#connectionFailed(generation, error instanceof Error ? error : new Error(String(error)));
           });
         },
-        onClose: (error) => this.#connectionFailed(generation, error),
+        onClose: (error) => {
+          if (replacementSource && this.#connection === replacementSource) {
+            this.#connectionFailed(generation, error);
+          } else {
+            openingCloseError ??= error;
+          }
+        },
         onRotationDue: () => {
           setTimeout(() => {
             if (replacementSource)
@@ -42179,6 +44298,8 @@ class InlineProtocolV3Transport {
       try {
         await replacement.bindTemporary(this.#credentials.permanent);
         await replacement.ping();
+        if (openingCloseError)
+          throw openingCloseError;
         this.#requireCurrent(generation);
         connection = replacement;
       } catch (error) {
@@ -42190,6 +44311,8 @@ class InlineProtocolV3Transport {
     nextCredentials.temporary = connection.authorization;
     try {
       await this.#options.onCredentials?.(cloneCredentials(nextCredentials));
+      if (openingCloseError)
+        throw openingCloseError;
       this.#requireCurrent(generation);
     } catch (error) {
       await connection.close();
@@ -42493,6 +44616,7 @@ var defaultVideoHeight = 720;
 var defaultVideoDuration = 1;
 var defaultCatchUpPageLimit = 100;
 var defaultCatchUpTotalLimit = 1e4;
+var maxDatabaseUpdateSequence = 2147483647;
 var inboundEventCapacity = 256;
 var inboundEventCapacityBytes = 8 * 1024 * 1024;
 var closeJoinTimeoutMs = 2000;
@@ -42637,6 +44761,7 @@ class InlineSdkClient {
     byteLength: inboundEventByteLength
   });
   started = false;
+  closed = false;
   openPromise = null;
   openResolver = null;
   openRejecter = null;
@@ -42700,12 +44825,16 @@ class InlineSdkClient {
       logger: options.logger,
       defaultRpcTimeoutMs: options.rpcTimeoutMs
     });
-    this.uploads = new NativeUploadClient(rpcUploadTransport((method, input) => this.invokeUncheckedRaw(method, input)));
+    this.uploads = new NativeUploadClient(rpcUploadTransport((method, input, signal) => this.invokeUncheckedRaw(method, input, { signal }), (error) => error instanceof ProtocolClientError && (error.code === "commit-outcome-unknown" || error.code === "timeout")));
     this.startListeners();
   }
   async connect(signal) {
     if (this.authenticationError)
       throw this.authenticationError;
+    if (this.logoutInProgress)
+      throw new Error("logout in progress");
+    if (this.closed)
+      throw new Error("SDK client is closed; create a new InlineSdkClient to reconnect");
     if (signal?.aborted)
       throw new Error("aborted");
     if (this.started) {
@@ -42722,11 +44851,14 @@ class InlineSdkClient {
     openPromise.catch(() => {});
     const abortConnect = () => {
       this.rejectOpen(new Error("aborted"));
-      this.close();
+      this.protocol.stopTransport().catch(() => {});
     };
     signal?.addEventListener("abort", abortConnect, { once: true });
     try {
       await this.loadState();
+      if (this.closed || this.logoutInProgress || signal?.aborted) {
+        throw new Error(this.closed ? "closed" : this.logoutInProgress ? "logout in progress" : "aborted");
+      }
       await this.protocol.startTransport();
       await openPromise;
     } catch (error) {
@@ -42745,6 +44877,7 @@ class InlineSdkClient {
   async close() {
     if (!this.started)
       return;
+    this.closed = true;
     this.started = false;
     this.rejectOpen(new Error("closed"));
     this.eventStream.close();
@@ -42766,6 +44899,7 @@ class InlineSdkClient {
     this.logoutInProgress = true;
     try {
       await owner.beginLogout();
+      this.closed = true;
       let remoteOutcome = "notSent";
       if (this.started) {
         try {
@@ -42783,6 +44917,7 @@ class InlineSdkClient {
         }
       }
       await this.close();
+      this.eventStream.close();
       await owner.clearCredentials();
       await owner.finishLogout();
       return { remoteOutcome };
@@ -42840,6 +44975,9 @@ class InlineSdkClient {
     const chat = result.getChat.chat;
     if (!chat)
       throw new Error("getChat: missing chat");
+    if (chat.peerId != null && this.isReliableChatPeer(chat.peerId)) {
+      this.rememberChatPeer(chat.id, chat.peerId);
+    }
     const dialogFollowMode = result.getChat.dialog?.followMode;
     return {
       chatId: chat.id,
@@ -43152,6 +45290,8 @@ class InlineSdkClient {
     return result;
   }
   async callRpcWithSemanticPolicy(method, input, options) {
+    if (this.closed)
+      throw new Error("SDK client is closed; create a new InlineSdkClient to reconnect");
     if (this.logoutInProgress && method !== Method.LOG_OUT) {
       throw new Error("logout in progress");
     }
@@ -43210,6 +45350,7 @@ class InlineSdkClient {
       const failure = error instanceof Error ? error : new Error("listener-crashed");
       this.log.error?.("SDK listener crashed", failure);
       this.started = false;
+      this.closed = true;
       this.rejectOpen(failure);
       this.eventStream.fail(failure);
       this.protocol.stopTransport().catch((stopError) => {
@@ -43439,6 +45580,9 @@ class InlineSdkClient {
         const message = update.update.newMessage.message;
         if (!message)
           return null;
+        if (message.peerId != null && this.isReliableChatPeer(message.peerId)) {
+          this.rememberChatPeer(message.chatId, message.peerId);
+        }
         return deliver({
           kind: "message.new",
           chatId: message.chatId,
@@ -43451,6 +45595,9 @@ class InlineSdkClient {
         const message = update.update.editMessage.message;
         if (!message)
           return null;
+        if (message.peerId != null && this.isReliableChatPeer(message.peerId)) {
+          this.rememberChatPeer(message.chatId, message.peerId);
+        }
         return deliver({
           kind: "message.edit",
           chatId: message.chatId,
@@ -43461,9 +45608,12 @@ class InlineSdkClient {
       }
       case "deleteMessages": {
         const payload = update.update.deleteMessages;
-        const chatId = payload.peerId?.type.oneofKind === "chat" ? payload.peerId.type.chat.chatId : null;
+        const chatId = this.chatIdForPeerScopedUpdate(payload.peerId, options?.bucket);
         if (!chatId) {
-          this.log.warn?.("Skipping deleteMessages update without chat peer", payload.peerId);
+          this.log.warn?.("Unable to resolve deleteMessages update to one chat bucket", {
+            source: options?.source ?? "live",
+            peerKind: payload.peerId?.type.oneofKind ?? "missing"
+          });
           return null;
         }
         return deliver({
@@ -43495,8 +45645,15 @@ class InlineSdkClient {
           }, () => this.bumpSpaceSeq(spaceId, seq, options?.source));
         }
         const peerId = payload.target.oneofKind === "peerId" ? payload.target.peerId : undefined;
-        if (peerId?.type.oneofKind === "chat") {
-          const chatId = peerId.type.chat.chatId;
+        if (peerId) {
+          const chatId = this.chatIdForPeerScopedUpdate(peerId, options?.bucket);
+          if (!chatId) {
+            this.log.warn?.("Unable to resolve clearChatHistory update to one chat bucket", {
+              source: options?.source ?? "live",
+              peerKind: peerId.type.oneofKind ?? "missing"
+            });
+            return null;
+          }
           return deliver({
             kind: "message.history.clear",
             chatId,
@@ -43509,19 +45666,6 @@ class InlineSdkClient {
             date
           }, () => this.bumpChatSeq(chatId, seq, options?.source));
         }
-        if (peerId?.type.oneofKind === "user") {
-          return deliver({
-            kind: "message.history.clear",
-            userId: peerId.type.user.userId,
-            ...payload.beforeDate != null ? { beforeDate: payload.beforeDate } : {},
-            deleteReplyThreads: payload.deleteReplyThreads,
-            deletedChatIds: payload.deletedChatIds,
-            orphanedChatIds: payload.orphanedChatIds,
-            detachedChatIds: payload.detachedChatIds,
-            seq,
-            date
-          }, () => this.bumpUserSeq(seq, options?.source));
-        }
         this.log.warn?.("Skipping clearChatHistory update without peer target", peerId);
         return null;
       }
@@ -43980,6 +46124,16 @@ class InlineSdkClient {
       }
       case "deleteChat":
         return this.chatBucketsForPeer(update.update.deleteChat.peerId);
+      case "deleteMessages":
+        return this.chatBucketsForPeer(update.update.deleteMessages.peerId);
+      case "clearChatHistory": {
+        const target = update.update.clearChatHistory.target;
+        if (target?.oneofKind === "peerId")
+          return this.chatBucketsForPeer(target.peerId);
+        if (target?.oneofKind === "spaceId")
+          return [{ kind: "space", spaceId: target.spaceId }];
+        return [];
+      }
       case "pinnedMessages":
         return this.chatBucketsForPeer(update.update.pinnedMessages.peerId);
       case "chatSkipPts":
@@ -44033,12 +46187,23 @@ class InlineSdkClient {
             matches.push({ kind: "chat", chatId, peer });
           } catch {}
         }
-        return matches;
+        return matches.length === 1 ? matches : [];
       }
       default:
         return [];
     }
   }
+  chatIdForPeerScopedUpdate(peer, catchUpBucket) {
+    if (catchUpBucket) {
+      if (catchUpBucket.kind !== "chat")
+        return null;
+      return catchUpBucket.chatId;
+    }
+    if (peer?.type.oneofKind === "chat")
+      return peer.type.chat.chatId;
+    const matches = this.chatBucketsForPeer(peer);
+    return matches.length === 1 && matches[0]?.kind === "chat" ? matches[0].chatId : null;
+  }
   peerFromEvent(event) {
     switch (event.kind) {
       case "message.new":
@@ -44124,6 +46289,7 @@ class InlineSdkClient {
   async doCatchUpUser(startSeq) {
     let cursor = startSeq;
     while (true) {
+      const requestEndSeq = this.catchUpRequestEndSeq(cursor);
       const result = await this.invoke(Method.GET_UPDATES, {
         oneofKind: "getUpdates",
         getUpdates: GetUpdatesInput.create({
@@ -44134,6 +46300,7 @@ class InlineSdkClient {
             }
           }),
           startSeq: BigInt(cursor),
+          ...requestEndSeq != null ? { seqEnd: BigInt(requestEndSeq) } : {},
           totalLimit: defaultCatchUpTotalLimit,
           limit: defaultCatchUpPageLimit
         })
@@ -44146,15 +46313,26 @@ class InlineSdkClient {
         return;
       }
       if (payload.resultType === GetUpdatesResult_ResultType.TOO_LONG) {
-        await this.repairUpdateBucketAuthoritatively({ kind: "user" }, deliveredSeq, payload.date);
+        const shouldContinue = this.shouldContinueBoundedCatchUp(cursor, deliveredSeq, requestEndSeq);
+        const repaired = await this.repairUpdateBucketAuthoritatively({ kind: "user" }, deliveredSeq, payload.date, !shouldContinue);
+        if (repaired && shouldContinue) {
+          cursor = deliveredSeq;
+          continue;
+        }
         return;
       }
       const requiresSnapshotRepair = this.validateCatchUpPage(payload, cursor, { kind: "user" });
       if (requiresSnapshotRepair == null)
         return;
       if (requiresSnapshotRepair) {
-        await this.repairUpdateBucketAuthoritatively({ kind: "user" }, deliveredSeq, payload.date);
-        return;
+        if (this.options.repairUpdatesBucket) {
+          await this.repairUpdateBucketAuthoritatively({ kind: "user" }, deliveredSeq, payload.date);
+          return;
+        }
+        this.log.warn?.("GET_UPDATES advanced past a snapshot-repair marker without a host snapshot owner", {
+          bucket: "user",
+          deliveredSeq
+        });
       }
       if (deliveredSeq <= cursor && !payload.final) {
         this.markUpdateBucketDegraded({ kind: "user" });
@@ -44169,6 +46347,10 @@ class InlineSdkClient {
       this.bumpUserSeq(deliveredSeq);
       this.scheduleStateSave();
       if (payload.final) {
+        if (this.shouldContinueBoundedCatchUp(cursor, deliveredSeq, requestEndSeq)) {
+          cursor = deliveredSeq;
+          continue;
+        }
         this.satisfyDiscoveryBucket({ kind: "user" }, deliveredSeq);
         this.clearUpdateBucketDegraded({ kind: "user" });
         return;
@@ -44234,8 +46416,8 @@ class InlineSdkClient {
   }
   async doCatchUpChat(chatId, peer, startSeq, endSeq) {
     let cursor = startSeq;
-    let requestEndSeq = endSeq;
-    while (requestEndSeq == null || cursor < requestEndSeq) {
+    while (endSeq == null || cursor < endSeq) {
+      const requestEndSeq = this.catchUpRequestEndSeq(cursor, endSeq);
       const result = await this.invoke(Method.GET_UPDATES, {
         oneofKind: "getUpdates",
         getUpdates: GetUpdatesInput.create({
@@ -44256,7 +46438,21 @@ class InlineSdkClient {
       const payload = result.getUpdates;
       if (payload.resultType === GetUpdatesResult_ResultType.TOO_LONG) {
         const deliveredSeq2 = Number(payload.seq ?? 0n);
-        await this.repairUpdateBucketAuthoritatively({ kind: "chat", chatId, peer }, deliveredSeq2, payload.date);
+        if (endSeq != null && requestEndSeq != null && deliveredSeq2 !== requestEndSeq) {
+          this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
+          this.log.warn?.("GET_UPDATES TOO_LONG pointer did not cover the requested chat target", {
+            chatId: chatId.toString(),
+            requestedEndSeq: requestEndSeq,
+            deliveredSeq: deliveredSeq2
+          });
+          return true;
+        }
+        const shouldContinue = this.shouldContinueBoundedCatchUp(cursor, deliveredSeq2, requestEndSeq, endSeq);
+        const repaired = await this.repairUpdateBucketAuthoritatively({ kind: "chat", chatId, peer }, deliveredSeq2, payload.date, !shouldContinue);
+        if (repaired && shouldContinue) {
+          cursor = deliveredSeq2;
+          continue;
+        }
         return true;
       }
       const deliveredSeq = Number(payload.seq ?? 0n);
@@ -44269,8 +46465,14 @@ class InlineSdkClient {
       if (requiresSnapshotRepair == null)
         return true;
       if (requiresSnapshotRepair) {
-        await this.repairUpdateBucketAuthoritatively({ kind: "chat", chatId, peer }, deliveredSeq, payload.date);
-        return true;
+        if (this.options.repairUpdatesBucket) {
+          await this.repairUpdateBucketAuthoritatively({ kind: "chat", chatId, peer }, deliveredSeq, payload.date);
+          return true;
+        }
+        this.log.warn?.("GET_UPDATES advanced past a snapshot-repair marker without a host snapshot owner", {
+          bucket: this.updateBucketKey({ kind: "chat", chatId }),
+          deliveredSeq
+        });
       }
       if (deliveredSeq <= cursor && !payload.final) {
         this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
@@ -44286,6 +46488,19 @@ class InlineSdkClient {
       this.bumpChatSeq(chatId, deliveredSeq);
       this.scheduleStateSave();
       if (payload.final) {
+        if (this.shouldContinueBoundedCatchUp(cursor, deliveredSeq, requestEndSeq, endSeq)) {
+          cursor = deliveredSeq;
+          continue;
+        }
+        if (endSeq != null && deliveredSeq < endSeq) {
+          this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
+          this.log.warn?.("GET_UPDATES final chat page remained behind the requested target", {
+            chatId: chatId.toString(),
+            requestedEndSeq: endSeq,
+            deliveredSeq
+          });
+          return true;
+        }
         this.satisfyDiscoveryBucket({ kind: "chat", chatId, peer }, deliveredSeq);
         this.clearUpdateBucketDegraded({ kind: "chat", chatId, peer });
         return true;
@@ -44349,8 +46564,8 @@ class InlineSdkClient {
   }
   async doCatchUpSpace(spaceId, startSeq, endSeq) {
     let cursor = startSeq;
-    let requestEndSeq = endSeq;
-    while (requestEndSeq == null || cursor < requestEndSeq) {
+    while (endSeq == null || cursor < endSeq) {
+      const requestEndSeq = this.catchUpRequestEndSeq(cursor, endSeq);
       const result = await this.invoke(Method.GET_UPDATES, {
         oneofKind: "getUpdates",
         getUpdates: GetUpdatesInput.create({
@@ -44371,7 +46586,21 @@ class InlineSdkClient {
       const payload = result.getUpdates;
       if (payload.resultType === GetUpdatesResult_ResultType.TOO_LONG) {
         const deliveredSeq2 = Number(payload.seq ?? 0n);
-        await this.repairUpdateBucketAuthoritatively({ kind: "space", spaceId }, deliveredSeq2, payload.date);
+        if (endSeq != null && requestEndSeq != null && deliveredSeq2 !== requestEndSeq) {
+          this.markUpdateBucketDegraded({ kind: "space", spaceId });
+          this.log.warn?.("GET_UPDATES TOO_LONG pointer did not cover the requested space target", {
+            spaceId: spaceId.toString(),
+            requestedEndSeq: requestEndSeq,
+            deliveredSeq: deliveredSeq2
+          });
+          return true;
+        }
+        const shouldContinue = this.shouldContinueBoundedCatchUp(cursor, deliveredSeq2, requestEndSeq, endSeq);
+        const repaired = await this.repairUpdateBucketAuthoritatively({ kind: "space", spaceId }, deliveredSeq2, payload.date, !shouldContinue);
+        if (repaired && shouldContinue) {
+          cursor = deliveredSeq2;
+          continue;
+        }
         return true;
       }
       const deliveredSeq = Number(payload.seq ?? 0n);
@@ -44386,8 +46615,14 @@ class InlineSdkClient {
       if (requiresSnapshotRepair == null)
         return true;
       if (requiresSnapshotRepair) {
-        await this.repairUpdateBucketAuthoritatively({ kind: "space", spaceId }, deliveredSeq, payload.date);
-        return true;
+        if (this.options.repairUpdatesBucket) {
+          await this.repairUpdateBucketAuthoritatively({ kind: "space", spaceId }, deliveredSeq, payload.date);
+          return true;
+        }
+        this.log.warn?.("GET_UPDATES advanced past a snapshot-repair marker without a host snapshot owner", {
+          bucket: this.updateBucketKey({ kind: "space", spaceId }),
+          deliveredSeq
+        });
       }
       if (deliveredSeq <= cursor && !payload.final) {
         this.markUpdateBucketDegraded({ kind: "space", spaceId });
@@ -44403,6 +46638,19 @@ class InlineSdkClient {
       this.bumpSpaceSeq(spaceId, deliveredSeq);
       this.scheduleStateSave();
       if (payload.final) {
+        if (this.shouldContinueBoundedCatchUp(cursor, deliveredSeq, requestEndSeq, endSeq)) {
+          cursor = deliveredSeq;
+          continue;
+        }
+        if (endSeq != null && deliveredSeq < endSeq) {
+          this.markUpdateBucketDegraded({ kind: "space", spaceId });
+          this.log.warn?.("GET_UPDATES final space page remained behind the requested target", {
+            spaceId: spaceId.toString(),
+            requestedEndSeq: endSeq,
+            deliveredSeq
+          });
+          return true;
+        }
         this.satisfyDiscoveryBucket({ kind: "space", spaceId }, deliveredSeq);
         this.clearUpdateBucketDegraded({ kind: "space", spaceId });
         return true;
@@ -44563,19 +46811,54 @@ class InlineSdkClient {
     }
     return requiresSnapshotRepair;
   }
-  async repairUpdateBucketAuthoritatively(bucket, serverSeq, serverDate) {
+  catchUpRequestEndSeq(cursor, requestedEndSeq) {
+    if (this.options.repairUpdatesBucket)
+      return requestedEndSeq;
+    return Math.min(requestedEndSeq ?? maxDatabaseUpdateSequence, cursor + defaultCatchUpTotalLimit);
+  }
+  shouldContinueBoundedCatchUp(previousCursor, deliveredSeq, requestEndSeq, requestedEndSeq) {
+    if (this.options.repairUpdatesBucket || requestEndSeq == null)
+      return false;
+    if (deliveredSeq <= previousCursor || deliveredSeq !== requestEndSeq)
+      return false;
+    return requestedEndSeq == null ? requestEndSeq < maxDatabaseUpdateSequence : deliveredSeq < requestedEndSeq;
+  }
+  async repairUpdateBucketAuthoritatively(bucket, serverSeq, serverDate, finalize = true) {
     if (!Number.isSafeInteger(serverSeq) || serverSeq < 0) {
       this.markUpdateBucketDegraded(bucket);
       return false;
     }
     const repair = this.options.repairUpdatesBucket;
     if (!repair) {
-      this.markUpdateBucketDegraded(bucket);
-      this.log.warn?.("GET_UPDATES requires authoritative bucket repair; bucket remains degraded", {
+      if (serverSeq <= this.bucketCursor(bucket)) {
+        this.markUpdateBucketDegraded(bucket);
+        this.log.warn?.("GET_UPDATES repair did not advance its bucket; bucket remains degraded", {
+          bucket: this.updateBucketKey(bucket),
+          serverSeq
+        });
+        return false;
+      }
+      switch (bucket.kind) {
+        case "user":
+          this.bumpUserSeq(serverSeq);
+          break;
+        case "chat":
+          this.bumpChatSeq(bucket.chatId, serverSeq);
+          break;
+        case "space":
+          this.bumpSpaceSeq(bucket.spaceId, serverSeq);
+          break;
+      }
+      this.scheduleStateSave();
+      if (finalize) {
+        this.satisfyDiscoveryBucket(bucket, serverSeq);
+        this.clearUpdateBucketDegraded(bucket);
+      }
+      this.log.warn?.("GET_UPDATES could not replay a bounded range; advanced to its server-authoritative cursor", {
         bucket: this.updateBucketKey(bucket),
         serverSeq
       });
-      return false;
+      return true;
     }
     try {
       const request = { bucket, serverSeq, serverDate };
@@ -44615,9 +46898,17 @@ class InlineSdkClient {
       if (update.update.oneofKind === undefined) {
         continue;
       }
-      const accepted = await this.handleUpdate(update, { source });
+      const accepted = await this.handleUpdate(update, { source, bucket });
       if (accepted === true)
         continue;
+      if (accepted === false) {
+        this.markUpdateBucketDegraded(bucket);
+        this.log.warn?.("GET_UPDATES event was not acknowledged by the SDK host; cursor remains unchanged", {
+          bucket: this.updateBucketKey(bucket),
+          updateKind: update.update.oneofKind
+        });
+        return false;
+      }
       if (!this.isProjectedUpdateKind(update)) {
         this.log.debug?.("GET_UPDATES advanced past an update this SDK does not project", {
           bucket: this.updateBucketKey(bucket),
@@ -44625,12 +46916,10 @@ class InlineSdkClient {
         });
         continue;
       }
-      this.markUpdateBucketDegraded(bucket);
-      this.log.warn?.("GET_UPDATES returned an update the SDK could not durably accept; cursor remains unchanged", {
+      this.log.warn?.("GET_UPDATES authoritatively advanced past an update the SDK could not project", {
         bucket: this.updateBucketKey(bucket),
         updateKind: update.update.oneofKind
       });
-      return false;
     }
     return true;
   }
@@ -45757,6 +48046,179 @@ function readUsers(result, kind) {
   return Array.isArray(users) ? users : [];
 }
 
+// src/sidecar/telemetry.ts
+import { randomUUID } from "node:crypto";
+import { readFile as readFile2 } from "node:fs/promises";
+var TELEMETRY_TIMEOUT_MS = 2000;
+var TELEMETRY_DEDUP_MS = 5 * 60000;
+var MAX_ERROR_MESSAGE_LENGTH = 8000;
+var MAX_STACK_FRAMES = 80;
+var SENSITIVE_ENV_NAME = /(?:token|secret|password|api[_-]?key|authorization)/i;
+var lastReports = new Map;
+var releasePromise;
+var HERMES_TELEMETRY_EXIT_TIMEOUT_MS = TELEMETRY_TIMEOUT_MS + 250;
+function telemetryDisabled(env = process.env) {
+  const disabled = (value) => value != null && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+  const optedOut = (value) => value != null && ["0", "false", "off"].includes(value.trim().toLowerCase());
+  return disabled(env.DO_NOT_TRACK) || optedOut(env.INLINE_PLUGIN_TELEMETRY);
+}
+function resolveDsn(env = process.env) {
+  if (telemetryDisabled(env))
+    return "";
+  return env.INLINE_HERMES_SENTRY_DSN?.trim() ?? "";
+}
+function sensitiveValues(env = process.env) {
+  return Object.entries(env).filter(([name, value]) => SENSITIVE_ENV_NAME.test(name) && (value?.length ?? 0) >= 8).map(([, value]) => value);
+}
+function redactHermesTelemetryText(value, env = process.env) {
+  let text = String(value ?? "").replace(/\b(Authorization\s*[:=]\s*)(?:Basic|Bearer)\s+\S+/gi, "$1[REDACTED]").replace(/\b((?:Basic|Bearer)\s+)\S+/gi, "$1[REDACTED]").replace(/(https?:\/\/)[^/\s:@]+:[^@\s/]+@/gi, "$1[REDACTED]@").replace(/([?&](?:access_token|auth|authorization|key|password|secret|token)[^=\s&]*)=([^&\s]+)/gi, "$1=[REDACTED]").replace(/\b([A-Za-z0-9_-]*(?:token|secret|password|api[_-]?key|authorization)[A-Za-z0-9_-]*)\s*([=:])\s*\S+/gi, "$1$2[REDACTED]");
+  for (const secret of sensitiveValues(env)) {
+    text = text.replaceAll(secret, "[REDACTED]");
+  }
+  return text.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+}
+function safeTag(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 && normalized.length <= 80 && /^[a-z0-9._-]+$/.test(normalized) ? normalized : "unknown";
+}
+function parseStack(error, env) {
+  const frames = [];
+  for (const rawLine of (error.stack ?? "").split(`
+`).slice(1)) {
+    const line = redactHermesTelemetryText(rawLine.trim(), env);
+    const match = /^at\s+(?:(.*?)\s+\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
+    if (!match)
+      continue;
+    const filename = match[2];
+    frames.push({
+      filename,
+      abs_path: filename,
+      function: match[1] || "<anonymous>",
+      lineno: Number(match[3]),
+      colno: Number(match[4]),
+      in_app: filename.includes("@inline-chat/hermes-agent-adapter") || filename.includes("/hermes-agent/") || filename.endsWith("/plugin/inline/sidecar/index.mjs")
+    });
+    if (frames.length >= MAX_STACK_FRAMES)
+      break;
+  }
+  return frames.reverse();
+}
+function buildHermesTelemetryEvent(operation, error, options = {}) {
+  const env = options.env ?? process.env;
+  const exception = error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
+  const frames = parseStack(exception, env);
+  return {
+    event_id: randomUUID().replaceAll("-", ""),
+    timestamp: new Date().toISOString(),
+    platform: "javascript",
+    level: "error",
+    logger: "inline.hermes.sidecar",
+    exception: {
+      values: [{
+        type: redactHermesTelemetryText(exception.name || "Error", env),
+        value: redactHermesTelemetryText(exception.message || String(error), env),
+        mechanism: {
+          type: "inline_plugin_boundary",
+          handled: options.handled ?? true
+        },
+        ...frames.length > 0 ? { stacktrace: { frames } } : {}
+      }]
+    },
+    tags: {
+      operation: safeTag(operation),
+      component: "sidecar",
+      runtime: "node",
+      os: process.platform,
+      arch: process.arch
+    },
+    sdk: { name: "inline.plugin.telemetry", version: "1" }
+  };
+}
+async function resolveRelease() {
+  releasePromise ??= (async () => {
+    for (const candidate of [
+      new URL("../../../package.json", import.meta.url),
+      new URL("../../package.json", import.meta.url)
+    ]) {
+      try {
+        const parsed = JSON.parse(await readFile2(candidate, "utf8"));
+        if (typeof parsed.version === "string" && parsed.version.trim()) {
+          return `inline-hermes-plugin@${parsed.version.trim()}`;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return;
+  })();
+  return releasePromise;
+}
+function parseSentryDsn(dsn) {
+  try {
+    const parsed = new URL(dsn);
+    if (!/^https?:$/.test(parsed.protocol) || !parsed.username)
+      return null;
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    const projectId = parts.pop();
+    if (!projectId || !/^\d+$/.test(projectId))
+      return null;
+    const prefix = parts.length > 0 ? `/${parts.join("/")}` : "";
+    return {
+      endpoint: `${parsed.origin}${prefix}/api/${projectId}/envelope/`,
+      publicKey: parsed.username
+    };
+  } catch {
+    return null;
+  }
+}
+async function sendHermesPluginError(operation, error, options = {}) {
+  const env = options.env ?? process.env;
+  const dsn = resolveDsn(env);
+  const target = parseSentryDsn(dsn);
+  if (!target)
+    return false;
+  const event = buildHermesTelemetryEvent(operation, error, options);
+  const release = await resolveRelease();
+  if (release)
+    event.release = release;
+  const envelope = [
+    JSON.stringify({ event_id: event.event_id, dsn, sent_at: event.timestamp }),
+    JSON.stringify({ type: "event", content_type: "application/json" }),
+    JSON.stringify(event)
+  ].join(`
+`);
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+  timeout.unref?.();
+  try {
+    const response = await fetch(target.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/x-sentry-envelope",
+        "x-sentry-auth": `Sentry sentry_version=7, sentry_key=${target.publicKey}, sentry_client=inline.plugin.telemetry/1`
+      },
+      body: envelope,
+      signal: controller.signal
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function reportHermesPluginError(operation, error, options = {}) {
+  try {
+    const exception = error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
+    const key = `${safeTag(operation)}\x00${exception.name}\x00${redactHermesTelemetryText(exception.message)}`;
+    const now = Date.now();
+    if (now - (lastReports.get(key) ?? 0) < TELEMETRY_DEDUP_MS)
+      return;
+    lastReports.set(key, now);
+    sendHermesPluginError(operation, exception, options).catch(() => {});
+  } catch {}
+}
+
 // src/sidecar/index.ts
 var DIALOG_FOLLOW_MODE_UNFOLLOWED = 2;
 var token = process.env.INLINE_TOKEN || process.env.INLINE_BOT_TOKEN || "";
@@ -45789,6 +48251,7 @@ var clientOptions = {
   baseUrl,
   state: new JsonFileStateStore(statePath),
   onAuthenticationError: (error) => {
+    reportHermesPluginError("sdk.authentication", error);
     connected = false;
     connecting = false;
     connectError = redactError(error);
@@ -45826,7 +48289,10 @@ async function connectClientLoop() {
           capabilities: [{ kind: BotCapability_Kind.CHAT_SETTINGS, version: 1 }]
         }),
         isCancelled: () => stopping,
-        onFailure: (error, willRetry) => console.error(`inline-sidecar: capability registration failed: ${redactError(error)}${willRetry ? "; retrying" : ""}`)
+        onFailure: (error, willRetry) => {
+          reportHermesPluginError("sdk.capability_registration", error);
+          console.error(`inline-sidecar: capability registration failed: ${redactError(error)}${willRetry ? "; retrying" : ""}`);
+        }
       });
       connected = true;
       connecting = false;
@@ -45835,6 +48301,7 @@ async function connectClientLoop() {
       console.error(`inline-sidecar: connected as ${meId}`);
       return;
     } catch (error) {
+      reportHermesPluginError("sdk.connect", error);
       connected = false;
       connecting = false;
       connectError = redactError(error);
@@ -45861,6 +48328,7 @@ async function consumeEvents() {
     }
   } catch (error) {
     if (!stopping) {
+      reportHermesPluginError("inbound.loop", error, { handled: false });
       connected = false;
       connecting = false;
       connectError = redactError(error);
@@ -46091,7 +48559,7 @@ async function endpointSendAttachment(res, body) {
   }
   const upload = await client.uploadFile({
     type: kind,
-    file: await readFile2(filePath),
+    file: await readFile3(filePath),
     fileName,
     ...contentType ? { contentType } : {}
   });
@@ -46966,6 +49434,7 @@ function methodName(method) {
 var client = createClient(clientOptions);
 var userDirectory = new InlineUserDirectory(client, {
   onError: (operation, error) => {
+    reportHermesPluginError(`sender_directory.${operation}`, error);
     console.error(`inline-sidecar: ${operation} sender hydration failed: ${redactError(error)}`);
   }
 });
@@ -46974,6 +49443,9 @@ consumeEvents();
 var server = http.createServer((req, res) => {
   handleRequest(req, res).catch((error) => {
     const err = normalizeError(error, redactError);
+    if (err.status >= 500) {
+      reportHermesPluginError("endpoint.request", error);
+    }
     writeJson(res, err.status, {
       ok: false,
       error: err.message,
@@ -47138,7 +49610,7 @@ async function packageVersion() {
   ];
   for (const pkgUrl of candidates) {
     try {
-      const raw = await readFile2(pkgUrl, "utf8");
+      const raw = await readFile3(pkgUrl, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.version)
         return parsed.version;
@@ -47147,7 +49619,7 @@ async function packageVersion() {
     }
   }
   try {
-    const raw = await readFile2(new URL("../plugin.yaml", import.meta.url), "utf8");
+    const raw = await readFile3(new URL("../plugin.yaml", import.meta.url), "utf8");
     const match = /^version:\s*['"]?([^'"\n#]+)['"]?/m.exec(raw);
     return match?.[1]?.trim() || "0.0.0";
   } catch {
@@ -47176,6 +49648,7 @@ async function shutdown(code) {
     server.close();
     await client.close();
   } catch (error) {
+    reportHermesPluginError("sidecar.shutdown", error);
     console.error(`inline-sidecar: shutdown error: ${redactError(error)}`);
   } finally {
     process.exitCode = code;
@@ -47184,8 +49657,13 @@ async function shutdown(code) {
 }
 process.on("uncaughtException", (error) => {
   console.error(`inline-sidecar: uncaught exception: ${redactError(error)}`);
-  process.exit(1);
+  const forcedExit = setTimeout(() => process.exit(1), HERMES_TELEMETRY_EXIT_TIMEOUT_MS);
+  sendHermesPluginError("process.uncaught_exception", error, { handled: false }).catch(() => false).finally(() => {
+    clearTimeout(forcedExit);
+    process.exit(1);
+  });
 });
 process.on("unhandledRejection", (error) => {
+  reportHermesPluginError("process.unhandled_rejection", error, { handled: false });
   console.error(`inline-sidecar: unhandled rejection: ${redactError(error)}`);
 });