@inline-openclaw/inline 0.0.67 → 0.0.69

package/dist/approval-handler.runtime.js

@@ -5844,6 +5844,20 @@ var UploadFailure_Code;
   UploadFailure_Code2[UploadFailure_Code2["UPLOAD_FAILURE_PROCESSING"] = 3] = "UPLOAD_FAILURE_PROCESSING";
   UploadFailure_Code2[UploadFailure_Code2["UPLOAD_FAILURE_STORAGE"] = 4] = "UPLOAD_FAILURE_STORAGE";
 })(UploadFailure_Code || (UploadFailure_Code = {}));
+var RequestBotFilesystemInput_Operation;
+(function(RequestBotFilesystemInput_Operation2) {
+  RequestBotFilesystemInput_Operation2[RequestBotFilesystemInput_Operation2["OPERATION_UNSPECIFIED"] = 0] = "OPERATION_UNSPECIFIED";
+  RequestBotFilesystemInput_Operation2[RequestBotFilesystemInput_Operation2["LIST"] = 1] = "LIST";
+  RequestBotFilesystemInput_Operation2[RequestBotFilesystemInput_Operation2["REGISTER_FOLDER"] = 2] = "REGISTER_FOLDER";
+})(RequestBotFilesystemInput_Operation || (RequestBotFilesystemInput_Operation = {}));
+var BotFilesystemEntry_Kind;
+(function(BotFilesystemEntry_Kind2) {
+  BotFilesystemEntry_Kind2[BotFilesystemEntry_Kind2["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
+  BotFilesystemEntry_Kind2[BotFilesystemEntry_Kind2["FILE"] = 1] = "FILE";
+  BotFilesystemEntry_Kind2[BotFilesystemEntry_Kind2["DIRECTORY"] = 2] = "DIRECTORY";
+  BotFilesystemEntry_Kind2[BotFilesystemEntry_Kind2["SYMLINK"] = 3] = "SYMLINK";
+  BotFilesystemEntry_Kind2[BotFilesystemEntry_Kind2["OTHER"] = 4] = "OTHER";
+})(BotFilesystemEntry_Kind || (BotFilesystemEntry_Kind = {}));
 var DialogFollowMode;
 (function(DialogFollowMode2) {
   DialogFollowMode2[DialogFollowMode2["DIALOG_FOLLOW_MODE_UNSPECIFIED"] = 0] = "DIALOG_FOLLOW_MODE_UNSPECIFIED";
@@ -6042,6 +6056,10 @@ var Method;
   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";
+  Method2[Method2["UPDATE_DIALOG_TRANSLATION"] = 141] = "UPDATE_DIALOG_TRANSLATION";
+  Method2[Method2["TRANSCRIBE_VOICE_DRAFT"] = 142] = "TRANSCRIBE_VOICE_DRAFT";
+  Method2[Method2["REQUEST_BOT_FILESYSTEM"] = 143] = "REQUEST_BOT_FILESYSTEM";
+  Method2[Method2["ANSWER_BOT_FILESYSTEM"] = 144] = "ANSWER_BOT_FILESYSTEM";
 })(Method || (Method = {}));
 var GridConnectionUnavailableReason;
 (function(GridConnectionUnavailableReason2) {
@@ -6510,7 +6528,8 @@ class BotEvent$Type extends import_runtime4.MessageType {
   constructor() {
     super("BotEvent", [
       { no: 1, name: "chat_settings_requested", kind: "message", oneof: "event", T: () => BotChatSettingsRequested },
-      { no: 2, name: "chat_settings_item_invoked", kind: "message", oneof: "event", T: () => BotChatSettingsItemInvoked }
+      { no: 2, name: "chat_settings_item_invoked", kind: "message", oneof: "event", T: () => BotChatSettingsItemInvoked },
+      { no: 3, name: "filesystem_requested", kind: "message", oneof: "event", T: () => BotFilesystemRequested }
     ]);
   }
   create(value) {
@@ -6537,6 +6556,12 @@ class BotEvent$Type extends import_runtime4.MessageType {
             chatSettingsItemInvoked: BotChatSettingsItemInvoked.internalBinaryRead(reader, reader.uint32(), options, message.event.chatSettingsItemInvoked)
           };
           break;
+        case 3:
+          message.event = {
+            oneofKind: "filesystemRequested",
+            filesystemRequested: BotFilesystemRequested.internalBinaryRead(reader, reader.uint32(), options, message.event.filesystemRequested)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -6553,6 +6578,8 @@ class BotEvent$Type extends import_runtime4.MessageType {
       BotChatSettingsRequested.internalBinaryWrite(message.event.chatSettingsRequested, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.event.oneofKind === "chatSettingsItemInvoked")
       BotChatSettingsItemInvoked.internalBinaryWrite(message.event.chatSettingsItemInvoked, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.event.oneofKind === "filesystemRequested")
+      BotFilesystemRequested.internalBinaryWrite(message.event.filesystemRequested, 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);
@@ -7709,7 +7736,8 @@ class Dialog$Type extends import_runtime4.MessageType {
       { no: 15, name: "pinned_order", kind: "scalar", opt: true, T: 9 },
       { no: 16, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] },
       { no: 17, name: "collapsed_max_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 18, name: "folder_id", kind: "scalar", opt: true, T: 3, L: 0 }
+      { no: 18, name: "folder_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 19, name: "translation_enabled", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
@@ -7777,6 +7805,9 @@ class Dialog$Type extends import_runtime4.MessageType {
         case 18:
           message.folderId = reader.int64().toBigInt();
           break;
+        case 19:
+          message.translationEnabled = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -7825,6 +7856,8 @@ class Dialog$Type extends import_runtime4.MessageType {
       writer.tag(17, import_runtime.WireType.Varint).int64(message.collapsedMaxId);
     if (message.folderId !== undefined)
       writer.tag(18, import_runtime.WireType.Varint).int64(message.folderId);
+    if (message.translationEnabled !== undefined)
+      writer.tag(19, import_runtime.WireType.Varint).bool(message.translationEnabled);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -13957,7 +13990,11 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { 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 }
+      { no: 141, name: "getBotConfigurationCatalog", kind: "message", oneof: "input", T: () => GetBotConfigurationCatalogInput },
+      { no: 142, name: "updateDialogTranslation", kind: "message", oneof: "input", T: () => UpdateDialogTranslationInput },
+      { no: 143, name: "transcribeVoiceDraft", kind: "message", oneof: "input", T: () => TranscribeVoiceDraftInput },
+      { no: 144, name: "requestBotFilesystem", kind: "message", oneof: "input", T: () => RequestBotFilesystemInput },
+      { no: 145, name: "answerBotFilesystem", kind: "message", oneof: "input", T: () => AnswerBotFilesystemInput }
     ]);
   }
   create(value) {
@@ -14810,6 +14847,30 @@ class RpcCall$Type extends import_runtime4.MessageType {
             getBotConfigurationCatalog: GetBotConfigurationCatalogInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getBotConfigurationCatalog)
           };
           break;
+        case 142:
+          message.input = {
+            oneofKind: "updateDialogTranslation",
+            updateDialogTranslation: UpdateDialogTranslationInput.internalBinaryRead(reader, reader.uint32(), options, message.input.updateDialogTranslation)
+          };
+          break;
+        case 143:
+          message.input = {
+            oneofKind: "transcribeVoiceDraft",
+            transcribeVoiceDraft: TranscribeVoiceDraftInput.internalBinaryRead(reader, reader.uint32(), options, message.input.transcribeVoiceDraft)
+          };
+          break;
+        case 144:
+          message.input = {
+            oneofKind: "requestBotFilesystem",
+            requestBotFilesystem: RequestBotFilesystemInput.internalBinaryRead(reader, reader.uint32(), options, message.input.requestBotFilesystem)
+          };
+          break;
+        case 145:
+          message.input = {
+            oneofKind: "answerBotFilesystem",
+            answerBotFilesystem: AnswerBotFilesystemInput.internalBinaryRead(reader, reader.uint32(), options, message.input.answerBotFilesystem)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -15102,6 +15163,14 @@ class RpcCall$Type extends import_runtime4.MessageType {
       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();
+    if (message.input.oneofKind === "updateDialogTranslation")
+      UpdateDialogTranslationInput.internalBinaryWrite(message.input.updateDialogTranslation, writer.tag(142, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "transcribeVoiceDraft")
+      TranscribeVoiceDraftInput.internalBinaryWrite(message.input.transcribeVoiceDraft, writer.tag(143, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "requestBotFilesystem")
+      RequestBotFilesystemInput.internalBinaryWrite(message.input.requestBotFilesystem, writer.tag(144, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "answerBotFilesystem")
+      AnswerBotFilesystemInput.internalBinaryWrite(message.input.answerBotFilesystem, writer.tag(145, 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);
@@ -15252,7 +15321,11 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { 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 }
+      { no: 141, name: "getBotConfigurationCatalog", kind: "message", oneof: "result", T: () => GetBotConfigurationCatalogResult },
+      { no: 142, name: "updateDialogTranslation", kind: "message", oneof: "result", T: () => UpdateDialogTranslationResult },
+      { no: 143, name: "transcribeVoiceDraft", kind: "message", oneof: "result", T: () => TranscribeVoiceDraftResult },
+      { no: 144, name: "requestBotFilesystem", kind: "message", oneof: "result", T: () => RequestBotFilesystemResult },
+      { no: 145, name: "answerBotFilesystem", kind: "message", oneof: "result", T: () => AnswerBotFilesystemResult }
     ]);
   }
   create(value) {
@@ -16105,6 +16178,30 @@ class RpcResult$Type extends import_runtime4.MessageType {
             getBotConfigurationCatalog: GetBotConfigurationCatalogResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getBotConfigurationCatalog)
           };
           break;
+        case 142:
+          message.result = {
+            oneofKind: "updateDialogTranslation",
+            updateDialogTranslation: UpdateDialogTranslationResult.internalBinaryRead(reader, reader.uint32(), options, message.result.updateDialogTranslation)
+          };
+          break;
+        case 143:
+          message.result = {
+            oneofKind: "transcribeVoiceDraft",
+            transcribeVoiceDraft: TranscribeVoiceDraftResult.internalBinaryRead(reader, reader.uint32(), options, message.result.transcribeVoiceDraft)
+          };
+          break;
+        case 144:
+          message.result = {
+            oneofKind: "requestBotFilesystem",
+            requestBotFilesystem: RequestBotFilesystemResult.internalBinaryRead(reader, reader.uint32(), options, message.result.requestBotFilesystem)
+          };
+          break;
+        case 145:
+          message.result = {
+            oneofKind: "answerBotFilesystem",
+            answerBotFilesystem: AnswerBotFilesystemResult.internalBinaryRead(reader, reader.uint32(), options, message.result.answerBotFilesystem)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16397,6 +16494,14 @@ class RpcResult$Type extends import_runtime4.MessageType {
       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();
+    if (message.result.oneofKind === "updateDialogTranslation")
+      UpdateDialogTranslationResult.internalBinaryWrite(message.result.updateDialogTranslation, writer.tag(142, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "transcribeVoiceDraft")
+      TranscribeVoiceDraftResult.internalBinaryWrite(message.result.transcribeVoiceDraft, writer.tag(143, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "requestBotFilesystem")
+      RequestBotFilesystemResult.internalBinaryWrite(message.result.requestBotFilesystem, writer.tag(144, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "answerBotFilesystem")
+      AnswerBotFilesystemResult.internalBinaryWrite(message.result.answerBotFilesystem, writer.tag(145, 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);
@@ -19961,6 +20066,153 @@ class UpdateDialogFollowModeResult$Type extends import_runtime4.MessageType {
 }
 var UpdateDialogFollowModeResult = new UpdateDialogFollowModeResult$Type;
 
+class UpdateDialogTranslationInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogTranslationInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "enabled", kind: "scalar", opt: true, T: 8 },
+      { no: 3, name: "import_legacy_enabled", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.importLegacyEnabled = 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.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.enabled = reader.bool();
+          break;
+        case 3:
+          message.importLegacyEnabled = 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.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.enabled !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.enabled);
+    if (message.importLegacyEnabled !== false)
+      writer.tag(3, import_runtime.WireType.Varint).bool(message.importLegacyEnabled);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateDialogTranslationInput = new UpdateDialogTranslationInput$Type;
+
+class UpdateDialogTranslationResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogTranslationResult", [
+      { 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 UpdateDialogTranslationResult = new UpdateDialogTranslationResult$Type;
+
+class UpdateDialogTranslation$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogTranslation", [
+      { no: 1, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 2, name: "enabled", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    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.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          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.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    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 UpdateDialogTranslation = new UpdateDialogTranslation$Type;
+
 class CollapseHistoryInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("CollapseHistoryInput", [
@@ -29487,7 +29739,8 @@ class Update$Type extends import_runtime4.MessageType {
       { 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: 49, name: "acknowledgement", kind: "message", oneof: "update", T: () => ChatAcknowledgement }
+      { no: 49, name: "acknowledgement", kind: "message", oneof: "update", T: () => ChatAcknowledgement },
+      { no: 50, name: "dialog_translation", kind: "message", oneof: "update", T: () => UpdateDialogTranslation }
     ]);
   }
   create(value) {
@@ -29784,6 +30037,12 @@ class Update$Type extends import_runtime4.MessageType {
             acknowledgement: ChatAcknowledgement.internalBinaryRead(reader, reader.uint32(), options, message.update.acknowledgement)
           };
           break;
+        case 50:
+          message.update = {
+            oneofKind: "dialogTranslation",
+            dialogTranslation: UpdateDialogTranslation.internalBinaryRead(reader, reader.uint32(), options, message.update.dialogTranslation)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -29892,6 +30151,8 @@ class Update$Type extends import_runtime4.MessageType {
       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();
+    if (message.update.oneofKind === "dialogTranslation")
+      UpdateDialogTranslation.internalBinaryWrite(message.update.dialogTranslation, writer.tag(50, 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);
@@ -35037,7 +35298,8 @@ class BotChatSettingsFolder$Type extends import_runtime4.MessageType {
       { no: 4, name: "host_label", kind: "scalar", T: 9 },
       { no: 5, name: "allows_local_picker", kind: "scalar", T: 8 },
       { no: 6, name: "local_picker_port", kind: "scalar", opt: true, T: 13 },
-      { no: 7, name: "local_picker_capability", kind: "scalar", opt: true, T: 9 }
+      { no: 7, name: "local_picker_capability", kind: "scalar", opt: true, T: 9 },
+      { no: 8, name: "remote_browser_version", kind: "scalar", opt: true, T: 13 }
     ]);
   }
   create(value) {
@@ -35077,6 +35339,9 @@ class BotChatSettingsFolder$Type extends import_runtime4.MessageType {
         case 7:
           message.localPickerCapability = reader.string();
           break;
+        case 8:
+          message.remoteBrowserVersion = reader.uint32();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -35103,6 +35368,8 @@ class BotChatSettingsFolder$Type extends import_runtime4.MessageType {
       writer.tag(6, import_runtime.WireType.Varint).uint32(message.localPickerPort);
     if (message.localPickerCapability !== undefined)
       writer.tag(7, import_runtime.WireType.LengthDelimited).string(message.localPickerCapability);
+    if (message.remoteBrowserVersion !== undefined)
+      writer.tag(8, import_runtime.WireType.Varint).uint32(message.remoteBrowserVersion);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -38347,6 +38614,542 @@ class ChatAcknowledgements$Type extends import_runtime4.MessageType {
 }
 var ChatAcknowledgements = new ChatAcknowledgements$Type;
 
+class TranscribeVoiceDraftInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("TranscribeVoiceDraftInput", [
+      { no: 1, name: "audio", kind: "scalar", T: 12 },
+      { no: 2, name: "mime_type", kind: "scalar", T: 9 },
+      { no: 3, name: "duration", kind: "scalar", T: 13 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.audio = new Uint8Array(0);
+    message.mimeType = "";
+    message.duration = 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.audio = reader.bytes();
+          break;
+        case 2:
+          message.mimeType = reader.string();
+          break;
+        case 3:
+          message.duration = 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.audio.length)
+      writer.tag(1, import_runtime.WireType.LengthDelimited).bytes(message.audio);
+    if (message.mimeType !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.mimeType);
+    if (message.duration !== 0)
+      writer.tag(3, import_runtime.WireType.Varint).uint32(message.duration);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var TranscribeVoiceDraftInput = new TranscribeVoiceDraftInput$Type;
+
+class TranscribeVoiceDraftResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("TranscribeVoiceDraftResult", [
+      { no: 1, name: "text", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.text = "";
+    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.text = 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.text !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.text);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var TranscribeVoiceDraftResult = new TranscribeVoiceDraftResult$Type;
+
+class RequestBotFilesystemInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RequestBotFilesystemInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "host_installation_id", kind: "scalar", T: 9 },
+      { no: 4, name: "operation", kind: "enum", T: () => ["RequestBotFilesystemInput.Operation", RequestBotFilesystemInput_Operation] },
+      { no: 5, name: "path", kind: "scalar", T: 9 },
+      { no: 6, name: "after", kind: "scalar", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.hostInstallationId = "";
+    message.operation = 0;
+    message.path = "";
+    message.after = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.hostInstallationId = reader.string();
+          break;
+        case 4:
+          message.operation = reader.int32();
+          break;
+        case 5:
+          message.path = reader.string();
+          break;
+        case 6:
+          message.after = 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.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.botUserId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.hostInstallationId !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.hostInstallationId);
+    if (message.operation !== 0)
+      writer.tag(4, import_runtime.WireType.Varint).int32(message.operation);
+    if (message.path !== "")
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.path);
+    if (message.after !== "")
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.after);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RequestBotFilesystemInput = new RequestBotFilesystemInput$Type;
+
+class BotFilesystemEntry$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotFilesystemEntry", [
+      { no: 1, name: "name", kind: "scalar", T: 9 },
+      { no: 2, name: "kind", kind: "enum", T: () => ["BotFilesystemEntry.Kind", BotFilesystemEntry_Kind] },
+      { no: 3, name: "size", kind: "scalar", T: 4, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.name = "";
+    message.kind = 0;
+    message.size = 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.name = reader.string();
+          break;
+        case 2:
+          message.kind = reader.int32();
+          break;
+        case 3:
+          message.size = reader.uint64().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.name !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.kind !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.size !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).uint64(message.size);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotFilesystemEntry = new BotFilesystemEntry$Type;
+
+class BotFilesystemListing$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotFilesystemListing", [
+      { no: 1, name: "path", kind: "scalar", T: 9 },
+      { no: 2, name: "parent_path", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "entries", kind: "message", repeat: 1, T: () => BotFilesystemEntry },
+      { no: 4, name: "next_after", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.path = "";
+    message.entries = [];
+    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.path = reader.string();
+          break;
+        case 2:
+          message.parentPath = reader.string();
+          break;
+        case 3:
+          message.entries.push(BotFilesystemEntry.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case 4:
+          message.nextAfter = 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.path !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.path);
+    if (message.parentPath !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.parentPath);
+    for (let i = 0;i < message.entries.length; i++)
+      BotFilesystemEntry.internalBinaryWrite(message.entries[i], writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.nextAfter !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.nextAfter);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotFilesystemListing = new BotFilesystemListing$Type;
+
+class BotFilesystemResponse$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotFilesystemResponse", [
+      { no: 1, name: "listing", kind: "message", oneof: "result", T: () => BotFilesystemListing },
+      { no: 2, name: "workspace_id", kind: "scalar", oneof: "result", T: 9 },
+      { no: 3, name: "problem", kind: "scalar", oneof: "result", T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.result = { 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.result = {
+            oneofKind: "listing",
+            listing: BotFilesystemListing.internalBinaryRead(reader, reader.uint32(), options, message.result.listing)
+          };
+          break;
+        case 2:
+          message.result = {
+            oneofKind: "workspaceId",
+            workspaceId: reader.string()
+          };
+          break;
+        case 3:
+          message.result = {
+            oneofKind: "problem",
+            problem: 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.result.oneofKind === "listing")
+      BotFilesystemListing.internalBinaryWrite(message.result.listing, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "workspaceId")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.result.workspaceId);
+    if (message.result.oneofKind === "problem")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.result.problem);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotFilesystemResponse = new BotFilesystemResponse$Type;
+
+class RequestBotFilesystemResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RequestBotFilesystemResult", [
+      { no: 1, name: "response", kind: "message", T: () => BotFilesystemResponse }
+    ]);
+  }
+  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.response = BotFilesystemResponse.internalBinaryRead(reader, reader.uint32(), options, message.response);
+          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.response)
+      BotFilesystemResponse.internalBinaryWrite(message.response, 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 RequestBotFilesystemResult = new RequestBotFilesystemResult$Type;
+
+class BotFilesystemRequested$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotFilesystemRequested", [
+      { no: 1, name: "request_id", kind: "scalar", T: 4, L: 0 },
+      { no: 2, name: "actor_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "chat_id", kind: "scalar", T: 3, L: 0 },
+      { no: 4, name: "input", kind: "message", T: () => RequestBotFilesystemInput }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.requestId = 0n;
+    message.actorUserId = 0n;
+    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.requestId = reader.uint64().toBigInt();
+          break;
+        case 2:
+          message.actorUserId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.chatId = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.input = RequestBotFilesystemInput.internalBinaryRead(reader, reader.uint32(), options, message.input);
+          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.requestId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).uint64(message.requestId);
+    if (message.actorUserId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.actorUserId);
+    if (message.chatId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.chatId);
+    if (message.input)
+      RequestBotFilesystemInput.internalBinaryWrite(message.input, 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 BotFilesystemRequested = new BotFilesystemRequested$Type;
+
+class AnswerBotFilesystemInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AnswerBotFilesystemInput", [
+      { no: 1, name: "request_id", kind: "scalar", T: 4, L: 0 },
+      { no: 2, name: "response", kind: "message", T: () => BotFilesystemResponse }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.requestId = 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.requestId = reader.uint64().toBigInt();
+          break;
+        case 2:
+          message.response = BotFilesystemResponse.internalBinaryRead(reader, reader.uint32(), options, message.response);
+          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.requestId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).uint64(message.requestId);
+    if (message.response)
+      BotFilesystemResponse.internalBinaryWrite(message.response, 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 AnswerBotFilesystemInput = new AnswerBotFilesystemInput$Type;
+
+class AnswerBotFilesystemResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AnswerBotFilesystemResult", []);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    return target ?? this.create();
+  }
+  internalBinaryWrite(message, writer, options) {
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AnswerBotFilesystemResult = new AnswerBotFilesystemResult$Type;
+
 // ../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
 /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 function isBytes(a) {
@@ -39125,6 +39928,13 @@ var asInlineId = (value, fieldName = "id") => {
 };
 
 // ../sdk/dist/utils/async-channel.js
+class ChannelConsumerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChannelConsumerError";
+  }
+}
+
 class AsyncChannelOverflowError extends Error {
   capacity;
   constructor(capacity) {
@@ -39234,6 +40044,7 @@ class AcknowledgedAsyncChannel {
   closed = false;
   failure = null;
   iteratorClaimed = false;
+  consumption = null;
   constructor(capacity, byteLimit) {
     this.capacity = capacity;
     this.byteLimit = byteLimit;
@@ -39247,7 +40058,7 @@ class AcknowledgedAsyncChannel {
   send(value) {
     if (this.closed)
       return Promise.resolve(false);
-    if (!this.waiter && this.queue.length >= this.capacity) {
+    if (!this.waiter && this.queue.length + (this.consumption?.active.size ?? 0) >= this.capacity) {
       throw new AsyncChannelOverflowError(this.capacity);
     }
     const bytes = this.byteLimit?.byteLength(value) ?? 0;
@@ -39267,6 +40078,7 @@ class AcknowledgedAsyncChannel {
         waiter.resolve({ value, done: false });
       } else {
         this.queue.push(item);
+        this.pumpConsumption();
       }
     });
   }
@@ -39281,6 +40093,16 @@ class AcknowledgedAsyncChannel {
       return;
     this.closed = true;
     this.failure = error;
+    const consumption = this.consumption;
+    this.consumption = null;
+    if (consumption) {
+      for (const item of consumption.active.keys())
+        item.acknowledge(false);
+      if (error)
+        consumption.reject(error);
+      else
+        consumption.resolve();
+    }
     this.active?.acknowledge(false);
     this.active = null;
     for (const item of this.queue)
@@ -39296,6 +40118,65 @@ class AcknowledgedAsyncChannel {
     else
       waiter.resolve({ value: undefined, done: true });
   }
+  consume(handler, key, concurrency = 8) {
+    if (this.iteratorClaimed)
+      return Promise.reject(new ChannelConsumerError("AcknowledgedAsyncChannel supports one consumer"));
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
+      return Promise.reject(new ChannelConsumerError("Consumer concurrency must be a positive safe integer"));
+    }
+    if (this.closed)
+      return this.failure ? Promise.reject(this.failure) : Promise.resolve();
+    this.iteratorClaimed = true;
+    return new Promise((resolve, reject) => {
+      this.consumption = { handler, key, concurrency, active: new Map, resolve, reject };
+      this.pumpConsumption();
+    });
+  }
+  pumpConsumption() {
+    const owner = this.consumption;
+    if (!owner || this.closed)
+      return;
+    try {
+      while (owner.active.size < owner.concurrency && this.queue.length > 0) {
+        if ([...owner.active.values()].includes(null))
+          return;
+        const keys = new Set(owner.active.values());
+        let index = -1;
+        let key = null;
+        for (let i = 0;i < this.queue.length; i++) {
+          const candidate = this.queue[i];
+          const candidateKey = owner.key(candidate.value);
+          if (candidateKey === null) {
+            if (i === 0 && owner.active.size === 0)
+              index = i;
+            break;
+          }
+          if (!keys.has(candidateKey)) {
+            index = i;
+            key = candidateKey;
+            break;
+          }
+        }
+        if (index < 0)
+          return;
+        const item = this.queue.splice(index, 1)[0];
+        owner.active.set(item, key);
+        Promise.resolve().then(() => owner.handler(item.value)).then(() => {
+          if (this.consumption !== owner)
+            return;
+          owner.active.delete(item);
+          this.bufferedBytes -= item.bytes;
+          item.acknowledge(true);
+          this.pumpConsumption();
+        }, (error) => {
+          if (this.consumption === owner)
+            this.fail(error instanceof Error ? error : new Error("Inbound handler failed"));
+        });
+      }
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new Error("Inbound routing failed"));
+    }
+  }
   [Symbol.asyncIterator]() {
     if (this.iteratorClaimed) {
       return {
@@ -39303,8 +40184,11 @@ class AcknowledgedAsyncChannel {
       };
     }
     this.iteratorClaimed = true;
+    let returned = false;
     return {
       next: () => {
+        if (returned)
+          return Promise.resolve({ value: undefined, done: true });
         if (this.active) {
           this.bufferedBytes -= this.active.bytes;
           this.active.acknowledge(true);
@@ -39328,6 +40212,11 @@ class AcknowledgedAsyncChannel {
         });
       },
       return: () => {
+        if (returned)
+          return Promise.resolve({ value: undefined, done: true });
+        returned = true;
+        this.waiter?.resolve({ value: undefined, done: true });
+        this.waiter = null;
         if (this.active) {
           this.bufferedBytes -= this.active.bytes;
           this.active.acknowledge(false);
@@ -40006,10 +40895,12 @@ var normalizeRpcTimeoutMs = (timeoutMs, fallback) => {
 
 class ProtocolClientError extends Error {
   code;
+  rpcCode;
   constructor(code, details) {
     super(details?.message ?? code);
     this.code = code;
     this.name = `ProtocolClientError:${code}`;
+    this.rpcCode = details?.code;
   }
 }
 var commitOutcomeUnknownError = (message) => new ProtocolClientError("commit-outcome-unknown", { message });
@@ -44832,8 +45723,11 @@ class InlineSdkClient {
   peerResolutionRequestedByChatId = new Map;
   recoveryReconnectInFlight = null;
   degradedUpdateBuckets = new Map;
+  discoveryRetry = null;
+  recoveryRetries = new Map;
   liveCursorFences = new Set;
   liveAdmittedSeqByBucket = new Map;
+  liveDeliveriesByBucket = new Map;
   discoveryRound = null;
   discoveryInFlight = null;
   discoveryCommitInFlight = null;
@@ -44926,12 +45820,14 @@ class InlineSdkClient {
     }
   }
   async close() {
-    if (!this.started)
-      return;
+    const wasStarted = this.started;
     this.closed = true;
     this.started = false;
+    this.cancelRecoveryRetries();
     this.rejectOpen(new Error("closed"));
     this.eventStream.close();
+    if (!wasStarted)
+      return;
     await settleWithin(this.protocol.stopTransport(), closeJoinTimeoutMs, () => this.log.warn?.("Timed out stopping SDK transport during close"));
     await settleWithin(Promise.allSettled([
       ...this.catchUpInFlightByChatId.values(),
@@ -44993,6 +45889,20 @@ class InlineSdkClient {
   events() {
     return this.eventStream;
   }
+  consumeEvents(handler, options) {
+    return this.eventStream.consume(handler, (event) => {
+      const bucket = this.bucketForEvent(event);
+      if (bucket?.kind === "user")
+        return null;
+      if (bucket)
+        return this.updateBucketKey(bucket);
+      return "chatId" in event && typeof event.chatId === "bigint" ? `chat:${event.chatId}` : null;
+    }, options?.concurrency).catch(async (error) => {
+      if (!(error instanceof ChannelConsumerError))
+        await this.close();
+      throw error;
+    });
+  }
   exportState() {
     return {
       version: 1,
@@ -45402,6 +46312,7 @@ class InlineSdkClient {
       this.log.error?.("SDK listener crashed", failure);
       this.started = false;
       this.closed = true;
+      this.cancelRecoveryRetries();
       this.rejectOpen(failure);
       this.eventStream.fail(failure);
       this.protocol.stopTransport().catch((stopError) => {
@@ -45414,6 +46325,7 @@ class InlineSdkClient {
       return;
     this.authenticationError = error;
     this.started = false;
+    this.cancelRecoveryRetries();
     this.rejectOpen(error);
     this.eventStream.close();
     try {
@@ -45423,6 +46335,7 @@ class InlineSdkClient {
     }
   }
   async onOpen() {
+    this.cancelRecoveryRetries();
     this.requestCatchUpUser();
     for (const bucket of this.degradedUpdateBuckets.values()) {
       this.requestCatchUpForDegradedBucket(bucket);
@@ -45473,6 +46386,8 @@ class InlineSdkClient {
       return this.discoveryInFlight;
     if (this.discoveryCommitInFlight)
       return this.discoveryCommitInFlight;
+    if (this.discoveryRetry?.timer)
+      return;
     const round = {
       resultReceived: false,
       collectingHints: true,
@@ -45505,6 +46420,11 @@ class InlineSdkClient {
       this.log.warn?.("GET_UPDATES_STATE failed (continuing without date cursor)", error);
       if (this.discoveryRound === round)
         this.discoveryRound = null;
+      if (error instanceof ProtocolClientError && (error.code === "timeout" || error.code === "not-connected" || error.code === "capacity-exceeded" || error.rpcCode === RpcError_Code.INTERNAL_ERROR || error.rpcCode === 500 || error.rpcCode === RpcError_Code.RATE_LIMIT || error.rpcCode === 429)) {
+        this.scheduleDiscoveryRetry(error.rpcCode === RpcError_Code.RATE_LIMIT || error.rpcCode === 429 ? "rate_limited" : "discovery_failed");
+      } else {
+        this.log.error?.("Sync discovery unavailable", { reason: "request_rejected" });
+      }
     }
   }
   tryCommitDiscoveryRound(round) {
@@ -45529,12 +46449,15 @@ class InlineSdkClient {
         return;
       if (saved) {
         this.discoveryRound = null;
+        clearTimeout(this.discoveryRetry?.timer);
+        this.discoveryRetry = null;
         return;
       }
       this.state.dateCursor = previousDateCursor;
       this.scheduleStateSave();
       this.discoveryRound = null;
       this.log.warn?.("Failed to persist discovery checkpoint; preserving previous date cursor");
+      this.scheduleDiscoveryRetry("checkpoint_write_failed");
     }).finally(() => {
       if (this.discoveryCommitInFlight === commit)
         this.discoveryCommitInFlight = null;
@@ -45869,20 +46792,23 @@ class InlineSdkClient {
     try {
       acknowledged = this.eventStream.send(event);
     } catch (error) {
-      const bucket = this.bucketForEvent(event);
-      if (bucket) {
-        this.fenceLiveCursor(bucket);
-        this.markUpdateBucketDegraded(bucket);
-        this.requestCatchUpAfterEventOverflow(bucket, event);
+      const bucket2 = this.bucketForEvent(event);
+      if (bucket2) {
+        this.fenceLiveCursor(bucket2);
+        this.markUpdateBucketDegraded(bucket2);
+        this.requestCatchUpAfterEventOverflow(bucket2, event);
       }
       this.log.warn?.("Inbound event buffer overflow; durable cursor remains unchanged and transport will recover", {
-        bucket: bucket ? this.updateBucketKey(bucket) : "none",
+        bucket: bucket2 ? this.updateBucketKey(bucket2) : "none",
         error: extractErrorMessage(error)
       });
       this.requestRecoveryReconnect("inbound-event-buffer-overflow");
       return Promise.resolve(false);
     }
-    return acknowledged.then((applied) => {
+    const bucket = source === "live" ? this.sequencedBucketForEvent(event) : undefined;
+    const key = bucket ? this.updateBucketKey(bucket) : undefined;
+    const deliveries = key ? this.liveDeliveriesByBucket.get(key) ?? new Set : undefined;
+    const delivery = acknowledged.then((applied) => {
       if (applied) {
         onApplied?.();
         if (source === "live")
@@ -45890,8 +46816,16 @@ class InlineSdkClient {
       } else if (source === "live" && this.started) {
         this.recoverLiveEvent(event, "consumer-did-not-apply");
       }
+      deliveries?.delete(delivery);
+      if (key && deliveries?.size === 0)
+        this.liveDeliveriesByBucket.delete(key);
       return applied;
     });
+    if (key && deliveries) {
+      deliveries.add(delivery);
+      this.liveDeliveriesByBucket.set(key, deliveries);
+    }
+    return delivery;
   }
   bucketForEvent(event) {
     switch (event.kind) {
@@ -46069,20 +47003,25 @@ class InlineSdkClient {
   }
   requestCatchUpForDegradedBucket(bucket) {
     switch (bucket.kind) {
-      case "chat":
-        if (bucket.peer && this.isReliableChatPeer(bucket.peer)) {
-          this.requestCatchUpChat({ chatId: bucket.chatId, peer: bucket.peer });
+      case "chat": {
+        const request = this.catchUpRequestedByChatId.get(bucket.chatId) ?? this.peerResolutionRequestedByChatId.get(bucket.chatId);
+        const updateSeq = request && !request.toLatest ? request.endSeq : undefined;
+        const peer = bucket.peer ?? this.persistedChatPeer(bucket.chatId);
+        if (peer && this.isReliableChatPeer(peer)) {
+          this.requestCatchUpChat({ chatId: bucket.chatId, peer, updateSeq });
         } else {
-          const persistedPeer = this.persistedChatPeer(bucket.chatId);
-          if (persistedPeer)
-            this.requestCatchUpChat({ chatId: bucket.chatId, peer: persistedPeer });
-          else
-            this.resolvePersistedChatPeer(bucket.chatId);
+          this.resolvePersistedChatPeer(bucket.chatId, updateSeq);
         }
         return;
-      case "space":
-        this.requestCatchUpSpace({ spaceId: bucket.spaceId });
+      }
+      case "space": {
+        const request = this.catchUpRequestedBySpaceId.get(bucket.spaceId);
+        this.requestCatchUpSpace({
+          spaceId: bucket.spaceId,
+          updateSeq: request && !request.toLatest ? request.endSeq : undefined
+        });
         return;
+      }
       case "user":
         this.requestCatchUpUser(true);
         return;
@@ -46267,7 +47206,7 @@ class InlineSdkClient {
   bumpChatSeq(chatId, seq, source) {
     if (source === "user" || source === "space" || source === "chat")
       return;
-    if (source === "live" && this.liveCursorFences.has(`chat:${chatId}`))
+    if (source === "live" && this.liveCursorFences.has(`chat:${chatId}`) && seq !== (this.state.lastSeqByChatId?.[chatId.toString()] ?? 0) + 1)
       return;
     if (!Number.isFinite(seq))
       return;
@@ -46276,6 +47215,7 @@ class InlineSdkClient {
     const key = chatId.toString();
     const prev = this.state.lastSeqByChatId[key] ?? 0;
     if (seq > prev) {
+      this.resetRecoveryBackoff({ kind: "chat", chatId });
       this.state.lastSeqByChatId[key] = seq;
       this.scheduleStateSave();
     }
@@ -46284,7 +47224,7 @@ class InlineSdkClient {
   bumpSpaceSeq(spaceId, seq, source) {
     if (source === "user" || source === "space" || source === "chat")
       return;
-    if (source === "live" && this.liveCursorFences.has(`space:${spaceId}`))
+    if (source === "live" && this.liveCursorFences.has(`space:${spaceId}`) && seq !== (this.state.lastSeqBySpaceId?.[spaceId.toString()] ?? 0) + 1)
       return;
     if (!Number.isFinite(seq))
       return;
@@ -46293,6 +47233,7 @@ class InlineSdkClient {
     const key = spaceId.toString();
     const prev = this.state.lastSeqBySpaceId[key] ?? 0;
     if (seq > prev) {
+      this.resetRecoveryBackoff({ kind: "space", spaceId });
       this.state.lastSeqBySpaceId[key] = seq;
       this.scheduleStateSave();
     }
@@ -46307,12 +47248,13 @@ class InlineSdkClient {
   bumpUserSeq(seq, source) {
     if (source === "user" || source === "space" || source === "chat")
       return;
-    if (source === "live" && this.liveCursorFences.has("user"))
+    if (source === "live" && this.liveCursorFences.has("user") && seq !== (this.state.lastUserSeq ?? 0) + 1)
       return;
     if (!Number.isFinite(seq) || seq <= 0)
       return;
     const prev = this.state.lastUserSeq ?? 0;
     if (seq > prev) {
+      this.resetRecoveryBackoff({ kind: "user" });
       this.state.lastUserSeq = seq;
       this.scheduleStateSave();
     }
@@ -46326,14 +47268,17 @@ class InlineSdkClient {
     if (this.userCatchUpInFlight) {
       return this.userCatchUpInFlight;
     }
+    if (this.recoveryRetries.get("user")?.timer)
+      return null;
     this.fenceLiveCursor({ kind: "user" });
     this.userCatchUpInFlight = this.doCatchUpUser(lastUserSeq ?? 0).catch((error) => {
-      this.markUpdateBucketDegraded({ kind: "user" });
+      this.recordCatchUpFailure({ kind: "user" }, error);
       this.log.warn?.("GET_UPDATES user catch-up failed; bucket remains degraded", {
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.userCatchUpInFlight = null;
+      this.scheduleRecoveryRetry({ kind: "user" });
     });
     return this.userCatchUpInFlight;
   }
@@ -46386,7 +47331,7 @@ class InlineSdkClient {
         });
       }
       if (deliveredSeq <= cursor && !payload.final) {
-        this.markUpdateBucketDegraded({ kind: "user" });
+        this.markUpdateBucketDegraded({ kind: "user" }, "non_progress");
         this.log.warn?.("GET_UPDATES user catch-up made no progress; bucket remains degraded", {
           cursor,
           deliveredSeq
@@ -46422,15 +47367,18 @@ class InlineSdkClient {
     const existing = this.catchUpInFlightByChatId.get(params.chatId);
     if (existing)
       return existing;
+    if (this.recoveryRetries.get(`chat:${params.chatId}`)?.timer)
+      return Promise.resolve();
+    const initialDemand = this.catchUpRequestedByChatId.get(params.chatId);
     const task = this.drainCatchUpChat(params.chatId).catch((error) => {
-      this.catchUpRequestedByChatId.delete(params.chatId);
-      this.markUpdateBucketDegraded({ kind: "chat", chatId: params.chatId, peer: params.peer });
+      this.recordCatchUpFailure({ kind: "chat", chatId: params.chatId, peer: params.peer }, error, this.catchUpRequestedByChatId.get(params.chatId) !== initialDemand);
       this.log.warn?.("GET_UPDATES chat catch-up failed; bucket remains degraded", {
         chatId: params.chatId.toString(),
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.catchUpInFlightByChatId.delete(params.chatId);
+      this.scheduleRecoveryRetry({ kind: "chat", chatId: params.chatId });
     });
     this.catchUpInFlightByChatId.set(params.chatId, task);
     return task;
@@ -46454,12 +47402,8 @@ class InlineSdkClient {
       if (stop) {
         if (this.catchUpRequestedByChatId.get(chatId) !== request)
           continue;
-        this.catchUpRequestedByChatId.delete(chatId);
-        return;
-      }
-      const latest = this.catchUpRequestedByChatId.get(chatId);
-      const syncedSeq = this.state.lastSeqByChatId?.[key] ?? 0;
-      if (!latest || latest.endSeq != null && latest.endSeq <= syncedSeq) {
+        if (this.degradedUpdateBuckets.has(`chat:${chatId}`))
+          return;
         this.catchUpRequestedByChatId.delete(chatId);
         return;
       }
@@ -46526,7 +47470,7 @@ class InlineSdkClient {
         });
       }
       if (deliveredSeq <= cursor && !payload.final) {
-        this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
+        this.markUpdateBucketDegraded({ kind: "chat", chatId, peer }, "non_progress");
         this.log.warn?.("GET_UPDATES made no progress; bucket remains degraded", {
           chatId: chatId.toString(),
           cursor,
@@ -46544,7 +47488,7 @@ class InlineSdkClient {
           continue;
         }
         if (endSeq != null && deliveredSeq < endSeq) {
-          this.markUpdateBucketDegraded({ kind: "chat", chatId, peer });
+          this.markUpdateBucketDegraded({ kind: "chat", chatId, peer }, "target_not_reached");
           this.log.warn?.("GET_UPDATES final chat page remained behind the requested target", {
             chatId: chatId.toString(),
             requestedEndSeq: endSeq,
@@ -46570,15 +47514,18 @@ class InlineSdkClient {
     const existing = this.catchUpInFlightBySpaceId.get(params.spaceId);
     if (existing)
       return existing;
+    if (this.recoveryRetries.get(`space:${params.spaceId}`)?.timer)
+      return Promise.resolve();
+    const initialDemand = this.catchUpRequestedBySpaceId.get(params.spaceId);
     const task = this.drainCatchUpSpace(params.spaceId).catch((error) => {
-      this.catchUpRequestedBySpaceId.delete(params.spaceId);
-      this.markUpdateBucketDegraded({ kind: "space", spaceId: params.spaceId });
+      this.recordCatchUpFailure({ kind: "space", spaceId: params.spaceId }, error, this.catchUpRequestedBySpaceId.get(params.spaceId) !== initialDemand);
       this.log.warn?.("GET_UPDATES space catch-up failed; bucket remains degraded", {
         spaceId: params.spaceId.toString(),
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.catchUpInFlightBySpaceId.delete(params.spaceId);
+      this.scheduleRecoveryRetry({ kind: "space", spaceId: params.spaceId });
     });
     this.catchUpInFlightBySpaceId.set(params.spaceId, task);
     return task;
@@ -46602,12 +47549,8 @@ class InlineSdkClient {
       if (stop) {
         if (this.catchUpRequestedBySpaceId.get(spaceId) !== request)
           continue;
-        this.catchUpRequestedBySpaceId.delete(spaceId);
-        return;
-      }
-      const latest = this.catchUpRequestedBySpaceId.get(spaceId);
-      const syncedSeq = this.state.lastSeqBySpaceId?.[key] ?? 0;
-      if (!latest || latest.endSeq != null && latest.endSeq <= syncedSeq) {
+        if (this.degradedUpdateBuckets.has(`space:${spaceId}`))
+          return;
         this.catchUpRequestedBySpaceId.delete(spaceId);
         return;
       }
@@ -46676,7 +47619,7 @@ class InlineSdkClient {
         });
       }
       if (deliveredSeq <= cursor && !payload.final) {
-        this.markUpdateBucketDegraded({ kind: "space", spaceId });
+        this.markUpdateBucketDegraded({ kind: "space", spaceId }, "non_progress");
         this.log.warn?.("GET_UPDATES space made no progress; bucket remains degraded", {
           spaceId: spaceId.toString(),
           cursor,
@@ -46694,7 +47637,7 @@ class InlineSdkClient {
           continue;
         }
         if (endSeq != null && deliveredSeq < endSeq) {
-          this.markUpdateBucketDegraded({ kind: "space", spaceId });
+          this.markUpdateBucketDegraded({ kind: "space", spaceId }, "target_not_reached");
           this.log.warn?.("GET_UPDATES final space page remained behind the requested target", {
             spaceId: spaceId.toString(),
             requestedEndSeq: endSeq,
@@ -46719,6 +47662,9 @@ class InlineSdkClient {
     const existing = this.peerResolutionInFlightByChatId.get(chatId);
     if (existing)
       return existing;
+    if (this.recoveryRetries.get(`chat:${chatId}`)?.timer)
+      return Promise.resolve();
+    const initialDemand = this.peerResolutionRequestedByChatId.get(chatId);
     const task = this.getChat({ chatId }).then(async (chat) => {
       const peer = chat.peer;
       if (!peer || !this.isReliableChatPeer(peer)) {
@@ -46732,14 +47678,16 @@ class InlineSdkClient {
         ...requested && !requested.toLatest && requested.endSeq != null ? { updateSeq: requested.endSeq } : {}
       });
     }).catch((error) => {
-      this.markUpdateBucketDegraded({ kind: "chat", chatId });
+      this.recordCatchUpFailure({ kind: "chat", chatId }, error, this.peerResolutionRequestedByChatId.get(chatId) !== initialDemand);
       this.log.warn?.("Unable to resolve legacy chat peer; bucket remains degraded", {
         chatId: chatId.toString(),
         error: extractErrorMessage(error)
       });
     }).finally(() => {
       this.peerResolutionInFlightByChatId.delete(chatId);
-      this.peerResolutionRequestedByChatId.delete(chatId);
+      if (!this.degradedUpdateBuckets.has(`chat:${chatId}`))
+        this.peerResolutionRequestedByChatId.delete(chatId);
+      this.scheduleRecoveryRetry({ kind: "chat", chatId });
     });
     this.peerResolutionInFlightByChatId.set(chatId, task);
     return task;
@@ -46792,7 +47740,7 @@ class InlineSdkClient {
   }
   validateCatchUpPage(payload, startSeq, bucket) {
     if (payload.resultType !== GetUpdatesResult_ResultType.SLICE && payload.resultType !== GetUpdatesResult_ResultType.EMPTY) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "invalid_page_type");
       this.log.warn?.("GET_UPDATES returned an invalid page result type; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         resultType: payload.resultType
@@ -46801,7 +47749,7 @@ class InlineSdkClient {
     }
     const deliveredSeq = Number(payload.seq);
     if (!Number.isSafeInteger(deliveredSeq) || deliveredSeq < startSeq) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "invalid_page_cursor");
       this.log.warn?.("GET_UPDATES page moved backwards or returned an invalid seq; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         startSeq,
@@ -46813,7 +47761,7 @@ class InlineSdkClient {
     for (const update of payload.updates) {
       const seq = update.seq;
       if (!Number.isSafeInteger(seq) || seq == null || seq <= startSeq || seq > deliveredSeq || accounted.has(seq)) {
-        this.markUpdateBucketDegraded(bucket);
+        this.markUpdateBucketDegraded(bucket, "invalid_update_sequence");
         this.log.warn?.("GET_UPDATES page included an invalid or duplicate update seq; bucket remains degraded", {
           bucket: this.updateBucketKey(bucket),
           seq
@@ -46826,7 +47774,7 @@ class InlineSdkClient {
     for (const skipped of payload.skippedSequences) {
       const seq = Number(skipped.seq);
       if (!Number.isSafeInteger(seq) || seq <= startSeq || seq > deliveredSeq || accounted.has(seq)) {
-        this.markUpdateBucketDegraded(bucket);
+        this.markUpdateBucketDegraded(bucket, "invalid_skipped_sequence");
         this.log.warn?.("GET_UPDATES page included an invalid or duplicate skipped seq; bucket remains degraded", {
           bucket: this.updateBucketKey(bucket),
           seq
@@ -46842,7 +47790,7 @@ class InlineSdkClient {
           break;
         case SyncSkippedSequence_Reason.REASON_UNSPECIFIED:
         default:
-          this.markUpdateBucketDegraded(bucket);
+          this.markUpdateBucketDegraded(bucket, "unknown_skip_reason");
           this.log.warn?.("GET_UPDATES page included an unsupported skipped-sequence reason; bucket remains degraded", {
             bucket: this.updateBucketKey(bucket),
             reason: skipped.reason
@@ -46851,7 +47799,7 @@ class InlineSdkClient {
       }
     }
     if (accounted.size !== deliveredSeq - startSeq) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "unaccounted_gap");
       this.log.warn?.("GET_UPDATES page did not account for every advanced sequence; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         startSeq,
@@ -46933,7 +47881,7 @@ class InlineSdkClient {
       this.clearUpdateBucketDegraded(bucket);
       return true;
     } catch (error) {
-      this.markUpdateBucketDegraded(bucket);
+      this.markUpdateBucketDegraded(bucket, "repair_failed");
       this.log.warn?.("Authoritative update repair failed; bucket remains degraded", {
         bucket: this.updateBucketKey(bucket),
         error: extractErrorMessage(error)
@@ -46942,7 +47890,17 @@ class InlineSdkClient {
     }
   }
   async acceptCatchUpUpdates(updates, source, bucket) {
+    const liveDeliveries = this.liveDeliveriesByBucket.get(this.updateBucketKey(bucket));
+    if (liveDeliveries && (await Promise.all(liveDeliveries)).some((applied) => !applied)) {
+      this.markUpdateBucketDegraded(bucket, "host_unacknowledged");
+      return false;
+    }
+    if (this.closed)
+      return false;
+    const appliedThrough = this.bucketCursor(bucket);
     for (const update of updates) {
+      if (update.seq != null && update.seq > 0 && update.seq <= appliedThrough)
+        continue;
       if (update.update.oneofKind === "chatSkipPts" && source === "chat") {
         continue;
       }
@@ -46953,7 +47911,7 @@ class InlineSdkClient {
       if (accepted === true)
         continue;
       if (accepted === false) {
-        this.markUpdateBucketDegraded(bucket);
+        this.markUpdateBucketDegraded(bucket, "host_unacknowledged");
         this.log.warn?.("GET_UPDATES event was not acknowledged by the SDK host; cursor remains unchanged", {
           bucket: this.updateBucketKey(bucket),
           updateKind: update.update.oneofKind
@@ -46974,8 +47932,95 @@ class InlineSdkClient {
     }
     return true;
   }
-  markUpdateBucketDegraded(bucket) {
-    this.degradedUpdateBuckets.set(this.updateBucketKey(bucket), bucket);
+  recordCatchUpFailure(bucket, error, hasNewerDemand = false) {
+    const rpcCode = error instanceof ProtocolClientError ? error.rpcCode : undefined;
+    if (!hasNewerDemand && bucket.kind !== "user" && (rpcCode === RpcError_Code.PEER_ID_INVALID || rpcCode === RpcError_Code.CHAT_ID_INVALID || rpcCode === RpcError_Code.SPACE_ID_INVALID)) {
+      this.clearUpdateBucketDegraded(bucket);
+      if (bucket.kind === "chat") {
+        this.catchUpRequestedByChatId.delete(bucket.chatId);
+        this.peerResolutionRequestedByChatId.delete(bucket.chatId);
+      } else
+        this.catchUpRequestedBySpaceId.delete(bucket.spaceId);
+      const round = this.discoveryRound;
+      if (round) {
+        round.targets.delete(this.updateBucketKey(bucket));
+        this.tryCommitDiscoveryRound(round);
+      }
+      this.log.error?.("Sync bucket unavailable", { bucketKind: bucket.kind, reason: "access_rejected" });
+      return;
+    }
+    this.markUpdateBucketDegraded(bucket, rpcCode === RpcError_Code.RATE_LIMIT || rpcCode === 429 ? "rate_limited" : error instanceof ProtocolClientError ? error.code : "request_failed");
+  }
+  markUpdateBucketDegraded(bucket, failure = "incomplete") {
+    const key = this.updateBucketKey(bucket);
+    this.degradedUpdateBuckets.set(key, bucket);
+    const retry = this.recoveryRetries.get(key) ?? { attempt: 0, failure, reported: new Set };
+    retry.failure = failure;
+    this.recoveryRetries.set(key, retry);
+    queueMicrotask(() => this.scheduleRecoveryRetry(bucket));
+  }
+  resetRecoveryBackoff(bucket) {
+    const retry = this.recoveryRetries.get(this.updateBucketKey(bucket));
+    if (retry)
+      retry.attempt = 0;
+  }
+  cancelRecoveryRetries() {
+    clearTimeout(this.discoveryRetry?.timer);
+    this.discoveryRetry = null;
+    for (const retry of this.recoveryRetries.values())
+      clearTimeout(retry.timer);
+    this.recoveryRetries.clear();
+  }
+  scheduleDiscoveryRetry(reason) {
+    if (!this.started || this.closed || this.protocol.getDiagnostics().state !== "open")
+      return;
+    const retry = this.discoveryRetry ?? { attempt: 0, reported: new Set };
+    if (retry.timer)
+      return;
+    if (!retry.reported.has(reason)) {
+      retry.reported.add(reason);
+      this.log.error?.("Sync recovery scheduled", { bucketKind: "discovery", reason });
+    }
+    const delayMs = reason === "rate_limited" ? 60000 : Math.min(30000, 1000 * 2 ** Math.min(retry.attempt, 5));
+    retry.attempt++;
+    retry.timer = setTimeout(() => {
+      retry.timer = undefined;
+      if (this.started && !this.closed && this.protocol.getDiagnostics().state === "open") {
+        this.initializeDateCursor();
+      }
+    }, delayMs);
+    retry.timer.unref?.();
+    this.discoveryRetry = retry;
+  }
+  scheduleRecoveryRetry(bucket) {
+    const key = this.updateBucketKey(bucket);
+    if (!this.started || this.closed || !this.degradedUpdateBuckets.has(key))
+      return;
+    if (bucket.kind === "chat" && (this.catchUpInFlightByChatId.has(bucket.chatId) || this.peerResolutionInFlightByChatId.has(bucket.chatId)))
+      return;
+    if (bucket.kind === "space" && this.catchUpInFlightBySpaceId.has(bucket.spaceId))
+      return;
+    if (bucket.kind === "user" && this.userCatchUpInFlight)
+      return;
+    const retry = this.recoveryRetries.get(key) ?? { attempt: 0, failure: "incomplete", reported: new Set };
+    if (retry.timer || this.protocol.getDiagnostics().state !== "open")
+      return;
+    const delayMs = retry.failure === "rate_limited" ? 60000 : Math.min(5000, 1000 * 2 ** Math.min(retry.attempt, 3));
+    if (!retry.reported.has(retry.failure)) {
+      retry.reported.add(retry.failure);
+      this.log.error?.("Sync recovery scheduled", { bucketKind: bucket.kind, reason: retry.failure });
+    }
+    retry.attempt++;
+    retry.timer = setTimeout(() => {
+      retry.timer = undefined;
+      if (!this.started || this.closed || this.protocol.getDiagnostics().state !== "open")
+        return;
+      const pending = this.degradedUpdateBuckets.get(key);
+      if (pending)
+        this.requestCatchUpForDegradedBucket(pending);
+    }, delayMs);
+    retry.timer.unref?.();
+    this.recoveryRetries.set(key, retry);
   }
   fenceLiveCursor(bucket) {
     this.liveCursorFences.add(this.updateBucketKey(bucket));
@@ -46983,6 +48028,8 @@ class InlineSdkClient {
   clearUpdateBucketDegraded(bucket) {
     const key = this.updateBucketKey(bucket);
     this.degradedUpdateBuckets.delete(key);
+    clearTimeout(this.recoveryRetries.get(key)?.timer);
+    this.recoveryRetries.delete(key);
     this.liveCursorFences.delete(key);
     this.liveAdmittedSeqByBucket.delete(key);
   }
@@ -62938,15 +63985,17 @@ function buildInlineMediaLoadOptions(params) {
   const explicitLocalRoots = params.mediaAccess?.localRoots ?? params.mediaLocalRoots;
   const readFile2 = params.mediaAccess?.readFile ?? params.mediaReadFile;
   const workspaceDir = params.mediaAccess?.workspaceDir;
+  const signal = params.signal;
   const localRoots = explicitLocalRoots === "any" || explicitLocalRoots?.length ? explicitLocalRoots : readFile2 ? "any" : undefined;
-  if (!localRoots && !readFile2 && !workspaceDir) {
+  if (!localRoots && !readFile2 && !workspaceDir && !signal) {
     return params.maxBytes;
   }
   return {
     maxBytes: params.maxBytes,
     ...localRoots ? { localRoots } : {},
     ...readFile2 ? { readFile: readFile2, hostReadCapability: true } : {},
-    ...workspaceDir ? { workspaceDir } : {}
+    ...workspaceDir ? { workspaceDir } : {},
+    ...signal ? { signal } : {}
   };
 }
 function mediaFromUploadResult(params) {
@@ -62973,12 +64022,15 @@ async function uploadInlineMediaFromUrl(params) {
   let uploadType;
   let fileName;
   try {
+    params.signal?.throwIfAborted();
     loaded = await loadWebMediaCompat(params.mediaUrl, buildInlineMediaLoadOptions({
       maxBytes,
       ...params.mediaAccess ? { mediaAccess: params.mediaAccess } : {},
       ...params.mediaLocalRoots ? { mediaLocalRoots: params.mediaLocalRoots } : {},
-      ...params.mediaReadFile ? { mediaReadFile: params.mediaReadFile } : {}
+      ...params.mediaReadFile ? { mediaReadFile: params.mediaReadFile } : {},
+      ...params.signal ? { signal: params.signal } : {}
     }));
+    params.signal?.throwIfAborted();
     if (!loaded) {
       throw new Error("inline media upload: media load returned no data");
     }
@@ -63003,6 +64055,7 @@ async function uploadInlineMediaFromUrl(params) {
       file: loaded.buffer,
       fileName,
       ...detectedMime ? { contentType: detectedMime } : {},
+      ...params.signal ? { signal: params.signal } : {},
       ...uploadType === "video" ? {
         width: DEFAULT_VIDEO_WIDTH,
         height: DEFAULT_VIDEO_HEIGHT,
@@ -63183,6 +64236,12 @@ var INLINE_MESSAGE_ENTITY_TYPE = {
 function compactWhitespace(raw) {
   return (raw ?? "").replace(/\s+/g, " ").trim();
 }
+function normalizeRawMessageText(raw) {
+  return (raw ?? "").replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`).trim();
+}
 function bestPhotoSize(photo) {
   let best = {
     cdnUrl: null,
@@ -63487,7 +64546,7 @@ function formatEntitySummary(entity) {
   }
 }
 function summarizeInlineMessageContent(message) {
-  const rawText = compactWhitespace(message.message);
+  const rawText = normalizeRawMessageText(message.message);
   const media = messageMediaSummary(message);
   const attachments = messageAttachmentSummaries(message);
   const entities = messageEntitySummaries(message);
@@ -68727,6 +69786,9 @@ var inlineMessageActions = {
 };
 var inlineSupportedActions = listAllActions();
 
+// src/inline/approval-contract.ts
+var INLINE_APPROVAL_EVENT_KINDS = ["exec", "plugin", "system-agent"];
+
 // src/inline/exec-approvals.ts
 import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
 import {
@@ -68806,7 +69868,7 @@ function countInlineExecApprovalEligibleAccounts(params) {
   }).length;
 }
 function isExecApprovalRequest(request) {
-  return "command" in request.request;
+  return request.approvalKind != null ? request.approvalKind === "exec" : ("command" in request.request) && !("proposalHash" in request.request);
 }
 function isTargetForwardingMode(mode) {
   return mode === "targets" || mode === "both";
@@ -69092,6 +70154,21 @@ function buildInlineApprovalActions(view) {
   return resolveInlineMessageActionsParam({ buttons }, { owner: "system" });
 }
 function buildPendingPayload(params) {
+  if (String(params.approvalKind) === "system-agent") {
+    const view = params.view;
+    if (String(view.approvalKind) !== "system-agent" || !("operationSummary" in view) || typeof view.operationSummary !== "string") {
+      throw new Error("system-agent approval request and view kinds do not match");
+    }
+    const text2 = sanitizeInlineOutgoingText([
+      "\uD83D\uDD12 OpenClaw change requires approval",
+      `Change: ${view.operationSummary}`,
+      `Agent: ${"agentId" in view ? view.agentId ?? "unknown" : "unknown"}`,
+      `Expires in: ${Math.max(0, Math.ceil((params.request.expiresAtMs - params.nowMs) / 1000))}s`
+    ].join(`
+`));
+    const actions2 = buildInlineApprovalActions(view);
+    return { text: text2, ...actions2 ? { actions: actions2 } : {} };
+  }
   const execView = params.view.approvalKind === "exec" ? params.view : null;
   const payload = params.approvalKind === "plugin" ? buildPluginApprovalPendingReplyPayload({
     request: params.request,
@@ -69120,7 +70197,7 @@ function buildPendingPayload(params) {
   };
 }
 var inlineApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
-  eventKinds: ["exec", "plugin"],
+  eventKinds: INLINE_APPROVAL_EVENT_KINDS,
   availability: {
     isConfigured: (params) => {
       const resolved = resolveHandlerContext(params);
@@ -69251,5 +70328,5 @@ export {
   inlineApprovalNativeRuntime
 };
 
-//# debugId=1D806320E6C7C86164756E2164756E21
+//# debugId=5E1234798083973564756E2164756E21
 //# sourceMappingURL=approval-handler.runtime.js.map