@inline-openclaw/inline 0.0.67 → 0.0.69

package/dist/channel-plugin-api.js

@@ -5585,6 +5585,7 @@ function hasInlineConfiguredState(params) {
 }
 
 // src/inline/channel.ts
+import { createHash } from "node:crypto";
 import { unlink } from "node:fs/promises";
 import path4 from "node:path";
 import {
@@ -5593,7 +5594,11 @@ import {
   resolveThreadSessionKeys
 } from "openclaw/plugin-sdk/core";
 import { parseAgentSessionKey, parseThreadSessionSuffix } from "openclaw/plugin-sdk/routing";
-import { createChannelMessageAdapterFromOutbound } from "openclaw/plugin-sdk/channel-outbound";
+import {
+  createChannelMessageAdapterFromOutbound,
+  createMessageReceiptFromOutboundResults
+} from "openclaw/plugin-sdk/channel-outbound";
+import { PlatformMessageNotDispatchedError } from "openclaw/plugin-sdk/error-runtime";
 import {
   presentationToInteractiveReply,
   renderMessagePresentationFallbackText as renderMessagePresentationFallbackText2
@@ -5863,6 +5868,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";
@@ -6061,6 +6080,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) {
@@ -6529,7 +6552,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) {
@@ -6556,6 +6580,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")
@@ -6572,6 +6602,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);
@@ -7728,7 +7760,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) {
@@ -7796,6 +7829,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")
@@ -7844,6 +7880,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);
@@ -13976,7 +14014,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) {
@@ -14829,6 +14871,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")
@@ -15121,6 +15187,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);
@@ -15271,7 +15345,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) {
@@ -16124,6 +16202,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")
@@ -16416,6 +16518,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);
@@ -19980,6 +20090,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", [
@@ -29506,7 +29763,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) {
@@ -29803,6 +30061,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")
@@ -29911,6 +30175,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);
@@ -35056,7 +35322,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) {
@@ -35096,6 +35363,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")
@@ -35122,6 +35392,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);
@@ -38366,6 +38638,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) {
@@ -39144,6 +39952,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) {
@@ -39253,6 +40068,7 @@ class AcknowledgedAsyncChannel {
   closed = false;
   failure = null;
   iteratorClaimed = false;
+  consumption = null;
   constructor(capacity, byteLimit) {
     this.capacity = capacity;
     this.byteLimit = byteLimit;
@@ -39266,7 +40082,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;
@@ -39286,6 +40102,7 @@ class AcknowledgedAsyncChannel {
         waiter.resolve({ value, done: false });
       } else {
         this.queue.push(item);
+        this.pumpConsumption();
       }
     });
   }
@@ -39300,6 +40117,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)
@@ -39315,6 +40142,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 {
@@ -39322,8 +40208,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);
@@ -39347,6 +40236,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);
@@ -40025,10 +40919,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 });
@@ -44851,8 +45747,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;
@@ -44945,12 +45844,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(),
@@ -45012,6 +45913,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,
@@ -45421,6 +46336,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) => {
@@ -45433,6 +46349,7 @@ class InlineSdkClient {
       return;
     this.authenticationError = error;
     this.started = false;
+    this.cancelRecoveryRetries();
     this.rejectOpen(error);
     this.eventStream.close();
     try {
@@ -45442,6 +46359,7 @@ class InlineSdkClient {
     }
   }
   async onOpen() {
+    this.cancelRecoveryRetries();
     this.requestCatchUpUser();
     for (const bucket of this.degradedUpdateBuckets.values()) {
       this.requestCatchUpForDegradedBucket(bucket);
@@ -45492,6 +46410,8 @@ class InlineSdkClient {
       return this.discoveryInFlight;
     if (this.discoveryCommitInFlight)
       return this.discoveryCommitInFlight;
+    if (this.discoveryRetry?.timer)
+      return;
     const round = {
       resultReceived: false,
       collectingHints: true,
@@ -45524,6 +46444,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) {
@@ -45548,12 +46473,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;
@@ -45888,20 +46816,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")
@@ -45909,8 +46840,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) {
@@ -46088,20 +47027,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;
@@ -46286,7 +47230,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;
@@ -46295,6 +47239,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();
     }
@@ -46303,7 +47248,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;
@@ -46312,6 +47257,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();
     }
@@ -46326,12 +47272,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();
     }
@@ -46345,14 +47292,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;
   }
@@ -46405,7 +47355,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
@@ -46441,15 +47391,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;
@@ -46473,12 +47426,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;
       }
@@ -46545,7 +47494,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,
@@ -46563,7 +47512,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,
@@ -46589,15 +47538,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;
@@ -46621,12 +47573,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;
       }
@@ -46695,7 +47643,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,
@@ -46713,7 +47661,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,
@@ -46738,6 +47686,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)) {
@@ -46751,14 +47702,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;
@@ -46811,7 +47764,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
@@ -46820,7 +47773,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,
@@ -46832,7 +47785,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
@@ -46845,7 +47798,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
@@ -46861,7 +47814,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
@@ -46870,7 +47823,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,
@@ -46952,7 +47905,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)
@@ -46961,7 +47914,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;
       }
@@ -46972,7 +47935,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
@@ -46993,8 +47956,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));
@@ -47002,6 +48052,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);
   }
@@ -62906,6 +63958,275 @@ function looksLikeInlineTargetId(raw, normalizedInput) {
   return /^[0-9]+$/.test(normalized);
 }
 
+// src/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;
+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_OPENCLAW_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 redactOpenClawTelemetryText(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(error51, env) {
+  const stack = error51.stack ?? "";
+  const frames = [];
+  for (const rawLine of stack.split(`
+`).slice(1)) {
+    const line = redactOpenClawTelemetryText(rawLine.trim(), env);
+    const match = /^at\s+(?:(.*?)\s+\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
+    if (!match)
+      continue;
+    const filename = match[2];
+    const frame = {
+      filename,
+      abs_path: filename,
+      function: match[1] || "<anonymous>",
+      lineno: Number(match[3]),
+      colno: Number(match[4]),
+      in_app: filename.includes("@inline-openclaw/inline") || filename.includes("/openclaw/") || /\/(?:channel-plugin-api|runtime-register-api|index)\.js$/.test(filename)
+    };
+    frames.push(frame);
+    if (frames.length >= MAX_STACK_FRAMES)
+      break;
+  }
+  return frames.reverse();
+}
+function buildOpenClawTelemetryEvent(operation, error51, options = {}) {
+  const env = options.env ?? process.env;
+  const exception = error51 instanceof Error ? error51 : new Error(String(error51 ?? "Unknown error"));
+  const frames = parseStack(exception, env);
+  return {
+    event_id: randomUUID().replaceAll("-", ""),
+    timestamp: new Date().toISOString(),
+    platform: "javascript",
+    level: "error",
+    logger: "inline.openclaw.plugin",
+    exception: {
+      values: [{
+        type: redactOpenClawTelemetryText(exception.name || "Error", env),
+        value: redactOpenClawTelemetryText(exception.message || String(error51), env),
+        mechanism: {
+          type: "inline_plugin_boundary",
+          handled: options.handled ?? true
+        },
+        ...frames.length > 0 ? { stacktrace: { frames } } : {}
+      }]
+    },
+    tags: {
+      operation: safeTag(operation),
+      runtime: "node",
+      os: process.platform,
+      arch: process.arch
+    },
+    sdk: { name: "inline.plugin.telemetry", version: "1" }
+  };
+}
+async function resolveRelease() {
+  releasePromise ??= (async () => {
+    try {
+      const parsed = JSON.parse(await readFile2(new URL("../package.json", import.meta.url), "utf8"));
+      if (typeof parsed.version === "string" && parsed.version.trim()) {
+        return `inline-openclaw-plugin@${parsed.version.trim()}`;
+      }
+    } catch {}
+    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 sendOpenClawPluginError(operation, error51, options = {}) {
+  const env = options.env ?? process.env;
+  const dsn = resolveDsn(env);
+  const target = parseSentryDsn(dsn);
+  if (!target)
+    return false;
+  const event = buildOpenClawTelemetryEvent(operation, error51, 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 reportOpenClawPluginError(operation, error51, options = {}) {
+  try {
+    const exception = error51 instanceof Error ? error51 : new Error(String(error51 ?? "Unknown error"));
+    const key = `${safeTag(operation)}\x00${exception.name}\x00${redactOpenClawTelemetryText(exception.message)}`;
+    const now = Date.now();
+    if (now - (lastReports.get(key) ?? 0) < TELEMETRY_DEDUP_MS)
+      return;
+    lastReports.set(key, now);
+    sendOpenClawPluginError(operation, exception, options).catch(() => {});
+  } catch {}
+}
+function wrapCallback(operation, callback) {
+  return function(...args) {
+    try {
+      const result = Reflect.apply(callback, this, args);
+      if (result && typeof result.then === "function") {
+        return Promise.resolve(result).catch((error51) => {
+          reportOpenClawPluginError(operation, error51);
+          throw error51;
+        });
+      }
+      return result;
+    } catch (error51) {
+      reportOpenClawPluginError(operation, error51);
+      throw error51;
+    }
+  };
+}
+function wrapSurface(prefix, surface) {
+  const wrapped = { ...surface };
+  for (const [name, member] of Object.entries(wrapped)) {
+    if (typeof member === "function") {
+      wrapped[name] = wrapCallback(`${prefix}.${name}`, member);
+    }
+  }
+  return wrapped;
+}
+function instrumentToolValue(value) {
+  if (Array.isArray(value))
+    return value.map(instrumentToolValue);
+  if (!value || typeof value !== "object")
+    return value;
+  const tool = value;
+  const execute = tool.execute;
+  if (typeof execute !== "function")
+    return value;
+  const name = typeof tool.name === "string" ? safeTag(tool.name) : "unknown";
+  return new Proxy(tool, {
+    get(target, property, receiver) {
+      if (property === "execute") {
+        return wrapCallback(`tool.${name}`, execute);
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
+function instrumentOpenClawPluginApi(value) {
+  const api2 = value;
+  return new Proxy(api2, {
+    get(target, property, receiver) {
+      const member = Reflect.get(target, property, receiver);
+      if (property === "registerTool" && typeof member === "function") {
+        return (toolOrFactory, options) => {
+          const wrapped = typeof toolOrFactory === "function" ? wrapCallback("tool.factory", (...args) => instrumentToolValue(Reflect.apply(toolOrFactory, undefined, args))) : instrumentToolValue(toolOrFactory);
+          return Reflect.apply(member, target, [wrapped, options]);
+        };
+      }
+      if (property === "registerCommand" && typeof member === "function") {
+        return (command) => {
+          const handler = command.handler;
+          const name = typeof command.name === "string" ? safeTag(command.name) : "unknown";
+          const wrapped = typeof handler === "function" ? { ...command, handler: wrapCallback(`command.${name}`, handler) } : command;
+          return Reflect.apply(member, target, [wrapped]);
+        };
+      }
+      if (property === "on" && typeof member === "function") {
+        return (event, handler) => Reflect.apply(member, target, [event, wrapCallback(`hook.${safeTag(event)}`, handler)]);
+      }
+      return member;
+    }
+  });
+}
+function instrumentOpenClawChannelPlugin(value) {
+  const plugin = { ...value };
+  for (const name of [
+    "lifecycle",
+    "pairing",
+    "outbound",
+    "heartbeat",
+    "directory",
+    "resolver",
+    "allowlist",
+    "status",
+    "gateway"
+  ]) {
+    const surface = plugin[name];
+    if (surface && typeof surface === "object") {
+      plugin[name] = wrapSurface(name, surface);
+    }
+  }
+  const message = plugin.message;
+  if (message && typeof message === "object") {
+    const wrappedMessage = { ...message };
+    const send = wrappedMessage.send;
+    if (send && typeof send === "object") {
+      wrappedMessage.send = wrapSurface("message.send", send);
+    }
+    plugin.message = wrappedMessage;
+  }
+  return plugin;
+}
+function reportOpenClawRegistrationError(error51) {
+  reportOpenClawPluginError("plugin.register", error51, { handled: false });
+}
+
 // src/inline/monitor.ts
 import { mkdir as mkdir2, stat } from "node:fs/promises";
 import path3 from "node:path";
@@ -62976,6 +64297,8 @@ import {
   createTransportActivityStatusPatch
 } from "openclaw/plugin-sdk/gateway-runtime";
 import {
+  hasFinalInboundReplyDispatch,
+  hasVisibleInboundReplyDispatch,
   classifyChannelInboundEvent,
   createChannelInboundDebouncer,
   resolveUnmentionedGroupInboundPolicy,
@@ -63174,7 +64497,7 @@ import {
 } from "openclaw/plugin-sdk/interactive-runtime";
 
 // src/inline/media.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir, writeFile as writeFile2 } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -63309,17 +64632,19 @@ function resolveMediaMaxBytes(params) {
 }
 function buildInlineMediaLoadOptions(params) {
   const explicitLocalRoots = params.mediaAccess?.localRoots ?? params.mediaLocalRoots;
-  const readFile2 = params.mediaAccess?.readFile ?? params.mediaReadFile;
+  const readFile3 = params.mediaAccess?.readFile ?? params.mediaReadFile;
   const workspaceDir = params.mediaAccess?.workspaceDir;
-  const localRoots = explicitLocalRoots === "any" || explicitLocalRoots?.length ? explicitLocalRoots : readFile2 ? "any" : undefined;
-  if (!localRoots && !readFile2 && !workspaceDir) {
+  const signal = params.signal;
+  const localRoots = explicitLocalRoots === "any" || explicitLocalRoots?.length ? explicitLocalRoots : readFile3 ? "any" : undefined;
+  if (!localRoots && !readFile3 && !workspaceDir && !signal) {
     return params.maxBytes;
   }
   return {
     maxBytes: params.maxBytes,
     ...localRoots ? { localRoots } : {},
-    ...readFile2 ? { readFile: readFile2, hostReadCapability: true } : {},
-    ...workspaceDir ? { workspaceDir } : {}
+    ...readFile3 ? { readFile: readFile3, hostReadCapability: true } : {},
+    ...workspaceDir ? { workspaceDir } : {},
+    ...signal ? { signal } : {}
   };
 }
 function mediaFromUploadResult(params) {
@@ -63346,12 +64671,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");
     }
@@ -63376,6 +64704,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,
@@ -63434,7 +64763,7 @@ async function downloadInlineMediaFromUrl(params) {
     });
     const dir = path.join(os.tmpdir(), "openclaw-inline-downloads");
     await mkdir(dir, { recursive: true });
-    const filePath = path.join(dir, `${randomUUID()}-${fileName}`);
+    const filePath = path.join(dir, `${randomUUID2()}-${fileName}`);
     await writeFile2(filePath, loaded.buffer, { flag: "wx" });
     return {
       path: filePath,
@@ -63556,6 +64885,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,
@@ -63860,7 +65195,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);
@@ -69028,7 +70363,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";
@@ -72682,31 +74017,20 @@ function resolveInlineMediaMaxBytes(params) {
 }
 function buildInlineInboundMediaFacts(media) {
   return toInboundMediaFacts(media.map((item) => ({
-    path: item.path,
-    ...item.contentType?.trim() ? { contentType: item.contentType.trim() } : {}
+    ...item.path ? { path: item.path } : {},
+    ...item.contentType?.trim() ? { contentType: item.contentType.trim() } : {},
+    ...item.fileName?.trim() ? { fileName: item.fileName.trim() } : {},
+    ...item.kind ? { kind: item.kind } : {},
+    ...item.messageId ? { messageId: item.messageId } : {}
   })));
 }
-function buildInlineAttachmentPlaceholder(content) {
-  const media = content.media;
-  if (!media)
-    return "";
-  switch (media.kind) {
-    case "photo":
-      return "<media:image>";
-    case "video":
-      return "<media:video>";
-    case "document":
-      return "<media:document>";
-    case "voice":
-      return "<media:audio>";
-    default:
-      return "";
-  }
-}
 function buildInlineInboundBodyText(content) {
-  const textWithPlaceholder = [content.rawText, buildInlineAttachmentPlaceholder(content)].filter(Boolean).join(`
-`).trim();
-  return textWithPlaceholder || content.text;
+  if (content.rawText)
+    return content.rawText;
+  if (content.media?.kind === "nudge" || !content.media && content.attachmentText) {
+    return content.text;
+  }
+  return "";
 }
 function resolveFilePathHint(params) {
   const preferred = params.preferredName?.trim();
@@ -72723,20 +74047,31 @@ function resolveFilePathHint(params) {
 async function resolveInlineInboundMedia(params) {
   const content = summarizeInlineMessageContent(params.message);
   const candidates = new Map;
+  const out = [];
+  const messageId = String(params.message.id);
+  const inlineMediaKind = content.media?.kind === "photo" ? "image" : content.media?.kind === "video" ? "video" : content.media?.kind === "voice" ? "audio" : content.media?.kind === "document" ? "document" : null;
   if (content.media?.url) {
     candidates.set(content.media.url, {
       fileName: content.media.fileName ?? null,
-      mimeType: content.media.mimeType ?? null
+      mimeType: content.media.mimeType ?? null,
+      kind: inlineMediaKind ?? "document"
+    });
+  } else if (inlineMediaKind) {
+    out.push({
+      kind: inlineMediaKind,
+      ...content.media?.fileName ? { fileName: content.media.fileName } : {},
+      ...content.media?.mimeType ? { contentType: content.media.mimeType } : {},
+      messageId
     });
   }
   for (const attachment of content.attachments) {
     if (attachment.kind !== "urlPreview" || !attachment.previewImageUrl)
       continue;
     candidates.set(attachment.previewImageUrl, {
-      mimeType: null
+      mimeType: null,
+      kind: "image"
     });
   }
-  const out = [];
   for (const [url2, candidate] of candidates.entries()) {
     try {
       const filePathHint = resolveFilePathHint({ sourceUrl: url2, preferredName: candidate.fileName });
@@ -72748,12 +74083,22 @@ async function resolveInlineInboundMedia(params) {
       const fetchedContentType = fetched.contentType ?? candidate.mimeType ?? undefined;
       const saved = await params.core.channel.media.saveMediaBuffer(fetched.buffer, fetchedContentType, "inbound", params.maxBytes, fetched.fileName ?? candidate.fileName ?? undefined);
       const contentType = saved.contentType ?? fetchedContentType;
+      const fileName = fetched.fileName ?? candidate.fileName;
       out.push({
         path: saved.path,
-        ...contentType ? { contentType } : {}
+        ...contentType ? { contentType } : {},
+        ...fileName ? { fileName } : {},
+        ...candidate.kind !== "document" ? { kind: candidate.kind } : {},
+        messageId
       });
     } catch (err) {
       params.log?.warn?.(`inline: failed to download inbound media ${url2}: ${String(err)}`);
+      out.push({
+        kind: candidate.kind,
+        ...candidate.fileName ? { fileName: candidate.fileName } : {},
+        ...candidate.mimeType ? { contentType: candidate.mimeType } : {},
+        messageId
+      });
     }
   }
   return out;
@@ -72948,7 +74293,9 @@ ${entityLines.slice(-ATTACHMENT_CONTEXT_LIMIT).join(`
 }
 async function monitorInlineProvider(params) {
   let { cfg } = params;
-  const { account, runtime, abortSignal, log, statusSink } = params;
+  const { account, runtime, log, statusSink } = params;
+  const shutdown = new AbortController;
+  const abortSignal = AbortSignal.any([params.abortSignal, shutdown.signal]);
   const core3 = getInlineRuntime();
   if (!account.configured || !account.baseUrl) {
     throw new Error(`Inline not configured for account "${account.accountId}" (missing baseUrl or token)`);
@@ -73000,6 +74347,9 @@ async function monitorInlineProvider(params) {
     },
     error: (msg, meta3) => {
       const line = formatSdkLogLine(msg, meta3);
+      if (msg === "Sync recovery scheduled" || msg === "Sync bucket unavailable" || msg === "Sync discovery unavailable") {
+        reportOpenClawPluginError("sdk.sync_recovery", new Error(line));
+      }
       log?.error(line);
       if (isRecoverableInlineConnectionError(line)) {
         recoverableConnectionError = line;
@@ -73032,7 +74382,7 @@ async function monitorInlineProvider(params) {
     const meResult = await client.invokeRaw(Method.GET_ME, {
       oneofKind: "getMe",
       getMe: {}
-    });
+    }, { signal: abortSignal });
     if (meResult.oneofKind !== "getMe" || !meResult.getMe.user) {
       throw new Error("missing user");
     }
@@ -73438,6 +74788,8 @@ async function monitorInlineProvider(params) {
     });
   };
   const handleInboundNow = async (input) => {
+    if (abortSignal.aborted)
+      return;
     const chatId = input.chatId;
     const msg = input.msg;
     const rawBodyOverride = input.rawBodyOverride ?? null;
@@ -73456,7 +74808,7 @@ async function monitorInlineProvider(params) {
         currentAttachmentText = currentContent.attachmentText || null;
         currentEntityText = currentContent.entityText || null;
       }
-      if (!rawBody)
+      if (!rawBody && !currentContent?.media && !currentContent?.attachments.length)
         return;
       commandTarget = resolveInlineCommandTarget(rawBody, botUsername);
       if (commandTarget.targeted && !commandTarget.addressedToMe) {
@@ -74585,7 +75937,7 @@ This model will be used for your next message.`, []);
       closing: false
     };
     const renderInlineProgressPlaceholder = async () => {
-      if (!progressPlaceholderEnabled || progressState.closing || adoptingThread)
+      if (abortSignal.aborted || !progressPlaceholderEnabled || progressState.closing || adoptingThread)
         return;
       const text = sanitizeInlineDeliveryText(formatChannelProgressDraftText({
         entry: account.config,
@@ -74595,7 +75947,7 @@ This model will be used for your next message.`, []);
       if (!text || text === progressState.text)
         return;
       progressState.opChain = progressState.opChain.then(async () => {
-        if (progressState.closing || text === progressState.text)
+        if (abortSignal.aborted || progressState.closing || text === progressState.text)
           return;
         if (progressState.messageId == null) {
           const sent = await client.sendMessage({
@@ -74698,6 +76050,8 @@ This model will be used for your next message.`, []);
     };
     const nextEditStreamInterval = (requestDurationMs) => Math.min(INLINE_EDIT_STREAM_MAX_INTERVAL_MS, Math.max(INLINE_EDIT_STREAM_MIN_INTERVAL_MS, Math.ceil(requestDurationMs * 1.25)));
     const sendEditStreamSnapshot = async (snapshot) => {
+      if (abortSignal.aborted)
+        return;
       try {
         if (editStreamState.messageId == null) {
           let sent;
@@ -74753,6 +76107,11 @@ This model will be used for your next message.`, []);
       }
     };
     const scheduleEditStreamDrain = () => {
+      if (abortSignal.aborted) {
+        editStreamState.pendingSnapshot = null;
+        clearEditStreamTimer();
+        return;
+      }
       if (editStreamState.failed || editStreamState.inFlight != null || editStreamState.timer != null || editStreamState.pendingSnapshot == null) {
         return;
       }
@@ -74962,7 +76321,7 @@ This model will be used for your next message.`, []);
       await resetEditStreamForAssistantMessage();
     };
     const handlePartialStreamPayload = (payload) => {
-      if (adoptingThread)
+      if (abortSignal.aborted || adoptingThread)
         return;
       const visiblePayload = resolveInlineChatVisibleReplyPayload(payload);
       if (!visiblePayload)
@@ -75048,6 +76407,10 @@ This model will be used for your next message.`, []);
       }
     };
     const replyOptions = {
+      abortSignal,
+      onObservedReplyDelivery: async () => {
+        delivered = true;
+      },
       ...onModelSelected ? { onModelSelected } : {},
       blockReplyTimeoutMs: 25000,
       ...streamViaEditMessage ? {
@@ -75187,7 +76550,7 @@ This model will be used for your next message.`, []);
       let undeliveredFinalActions;
       try {
         const dispatch = await dispatchInlineReplyWithSessionInitRetry({
-          shouldRetry: () => !delivered && !skippedNonSilent && !failedNonSilent,
+          shouldRetry: () => !abortSignal.aborted && !delivered && !skippedNonSilent && !failedNonSilent,
           onRetry: (retry, delayMs) => {
             log?.warn(`[${account.accountId}] AGENT_DISPATCH_TRACE phase=session_init_conflict_retry ` + `retry=${retry} delay_ms=${delayMs}`);
           },
@@ -75198,6 +76561,8 @@ This model will be used for your next message.`, []);
               ...dispatcherPipelineOptions,
               ...buildInlineTypingDispatcherOptions(typingCallbacks),
               deliver: async (payload, info) => {
+                if (abortSignal.aborted)
+                  return inlineReplyDeliveryResult(false);
                 let payloadVisible = false;
                 const markPayloadVisible = () => {
                   delivered = true;
@@ -75492,12 +76857,14 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       if (!delivered && streamViaEditMessage && (editStreamState.messageId != null || editStreamState.initialSendMayHaveLanded) && !streamedFinalEditRejected) {
         delivered = true;
       }
-      const hostHandledTurn = dispatchResult.queuedFinal === true || dispatchResult.observedReplyDelivery === true || dispatchResult.noVisibleReplyFallbackDelivered === true;
+      const hostDeliveredReply = hasVisibleInboundReplyDispatch({ ...dispatchResult, queuedFinal: false }, { fallbackDelivered: dispatchResult.noVisibleReplyFallbackDelivered === true });
+      const hostHandledTurn = hasFinalInboundReplyDispatch(dispatchResult) || hostDeliveredReply;
+      const deferredToActiveRun = dispatchResult.deferredToActiveRun != null;
       const deliberateSilence = skippedSilently || dispatchResult.deliberateSilentTerminalReply === true;
       const skipFallbackSuppressed = dispatchResult.sourceReplyDeliveryMode === "message_tool_only";
       const hostRequestedNoVisibleRecovery = dispatchResult.noVisibleReplyFallbackEligible === true;
       const explicitFailure = dispatchError != null || failedNonSilent;
-      if (!delivered && !adoptingThread && (explicitFailure || !hostHandledTurn && !deliberateSilence && (skippedNonSilent && !skipFallbackSuppressed || hostRequestedNoVisibleRecovery))) {
+      if (!abortSignal.aborted && !delivered && !hostDeliveredReply && !deferredToActiveRun && !adoptingThread && (explicitFailure || !hostHandledTurn && !deliberateSilence && (skippedNonSilent && !skipFallbackSuppressed || hostRequestedNoVisibleRecovery))) {
         botPresenceLifecycle.fail();
         const fallbackText = undeliveredFinalText.trim() ? undeliveredFinalText : dispatchError != null ? INLINE_REQUEST_ERROR_FALLBACK : EMPTY_RESPONSE_FALLBACK;
         const sent = await client.sendMessage({
@@ -75516,12 +76883,16 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       }
     } finally {
       endActiveThreadRoute();
+      if (abortSignal.aborted) {
+        runTypingCleanup();
+        botPresenceLifecycle.cleanup();
+      }
       if (adoptedThreadThisTurn) {
         await sendDeliveryTyping(deliveryChatId, false).catch((error51) => runtime.error?.(`inline adopted thread typing cleanup failed: ${String(error51)}`));
         botPresenceLifecycle.cleanup();
       }
       await setParentThreadCreationTyping(false);
-      if (callbackActionEvent && !callbackActionAnswered) {
+      if (!abortSignal.aborted && callbackActionEvent && !callbackActionAnswered) {
         try {
           await answerCallbackIfNeeded();
         } catch (error51) {
@@ -76107,6 +77478,8 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
     });
   };
   const scheduleInboundTask = (label, run, options) => {
+    if (abortSignal.aborted)
+      return;
     let task;
     try {
       if (options?.serialKey) {
@@ -76114,7 +77487,10 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         const previous = inboundTaskChains.get(serialKey) ?? Promise.resolve();
         task = previous.catch(() => {
           return;
-        }).then(run);
+        }).then(() => {
+          if (!abortSignal.aborted)
+            return run();
+        });
         const settled = task.catch(() => {
           return;
         });
@@ -76263,23 +77639,50 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
     suppressedVoiceMessageEditTimeouts.clear();
   };
   const drainInboundTasks = async () => {
-    while (pendingInboundTasks.size > 0) {
-      await Promise.allSettled(pendingInboundTasks);
+    let timer;
+    const drained = (async () => {
+      while (pendingInboundTasks.size > 0) {
+        await Promise.allSettled(pendingInboundTasks);
+      }
+    })();
+    let onAbort;
+    try {
+      await Promise.race([
+        drained,
+        new Promise((resolve) => {
+          onAbort = () => {
+            timer = setTimeout(() => {
+              log?.warn(`[${account.accountId}] inline shutdown grace expired with pending inbound work`);
+              resolve();
+            }, 15000);
+          };
+          if (abortSignal.aborted)
+            onAbort();
+          else
+            abortSignal.addEventListener("abort", onAbort, { once: true });
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      if (onAbort)
+        abortSignal.removeEventListener("abort", onAbort);
     }
   };
   const loop = (async () => {
     try {
-      for await (const event of client.events()) {
-        if (abortSignal.aborted)
-          break;
+      await client.consumeEvents(async (event) => {
+        if (abortSignal.aborted) {
+          await client.close();
+          return;
+        }
         const rawEvent = event;
         if (event.kind === "bot.chatSettings.request") {
           scheduleInboundTask("agent settings request", () => answerOpenClawBotSettingsRequest(event));
-          continue;
+          return;
         }
         if (event.kind === "bot.chatSettings.item.invoke") {
           scheduleInboundTask("agent settings update", () => answerOpenClawBotSettingsMutation(event), { serialKey: `agent-settings:${String(event.chatId)}` });
-          continue;
+          return;
         }
         if (event.kind === "message.new") {
           const msg = {
@@ -76287,31 +77690,31 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             chatId: event.chatId
           };
           if (msg.out || msg.fromId === meId)
-            continue;
+            return;
           if (!claimInlineInboundMessageInstance({
             seen: seenInboundMessageInstances,
             chatId: event.chatId,
             message: msg
           }))
-            continue;
+            return;
           if (isInlineAbortRequestMessage(msg, botUsername) && await isAuthorizedInlineAbortMessage({ chatId: event.chatId, msg })) {
             cancelPendingInlineDebounce({ chatId: event.chatId, msg });
             cancelPendingInlineVoiceMessages({ chatId: event.chatId, msg });
             scheduleImmediateInboundMessage({ chatId: event.chatId, msg }, "priority abort dispatch");
-            continue;
+            return;
           }
           if (voiceTranscriptWaitMs > 0 && shouldWaitForInlineVoiceTranscript(msg)) {
             holdInlineVoiceMessage({
               chatId: event.chatId,
               msg
             });
-            continue;
+            return;
           }
           scheduleInboundMessage({
             chatId: event.chatId,
             msg
           });
-          continue;
+          return;
         }
         if (event.kind === "message.edit") {
           const msg = {
@@ -76319,9 +77722,9 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             chatId: event.chatId
           };
           if (msg.out || msg.fromId === meId)
-            continue;
+            return;
           if (await handlePendingInlineVoiceEdit({ chatId: event.chatId, msg })) {
-            continue;
+            return;
           }
           await queueInlineMessageLifecycleSystemEvent({
             action: "edited",
@@ -76329,7 +77732,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             messageIds: [msg.id],
             senderId: msg.fromId
           });
-          continue;
+          return;
         }
         if (event.kind === "message.delete") {
           await queueInlineMessageLifecycleSystemEvent({
@@ -76337,18 +77740,18 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             chatId: event.chatId,
             messageIds: event.messageIds
           });
-          continue;
+          return;
         }
         if (event.kind === "reaction.add") {
           if (event.reaction.userId === meId)
-            continue;
+            return;
           const shouldQueue = await shouldQueueInlineReactionSystemEvent({
             chatId: event.chatId,
             messageId: event.reaction.messageId,
             senderId: event.reaction.userId
           });
           if (!shouldQueue)
-            continue;
+            return;
           await queueInlineReactionSystemEvent({
             action: "added",
             chatId: event.chatId,
@@ -76356,18 +77759,18 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             senderId: event.reaction.userId,
             emoji: event.reaction.emoji
           });
-          continue;
+          return;
         }
         if (event.kind === "reaction.delete") {
           if (event.userId === meId)
-            continue;
+            return;
           const shouldQueue = await shouldQueueInlineReactionSystemEvent({
             chatId: event.chatId,
             messageId: event.messageId,
             senderId: event.userId
           });
           if (!shouldQueue)
-            continue;
+            return;
           await queueInlineReactionSystemEvent({
             action: "removed",
             chatId: event.chatId,
@@ -76375,12 +77778,12 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             senderId: event.userId,
             emoji: event.emoji
           });
-          continue;
+          return;
         }
         if (rawEvent["kind"] === "chat.participant.add") {
           const eventChatId = rawEvent["chatId"];
           if (!eventChatId)
-            continue;
+            return;
           const participant = rawEvent["participant"];
           const eventDate = rawEvent["date"];
           const recovered = await recoverInlineJoinMentions({
@@ -76400,7 +77803,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
               msg: { ...msg, mentioned: true }
             }, "inline join mention recovery", { serializeWithChat: true });
           }
-          continue;
+          return;
         }
         if (rawEvent["kind"] === "message.action.invoke") {
           const actorUserId = rawEvent["actorUserId"];
@@ -76411,10 +77814,10 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
           const eventChatId = rawEvent["chatId"];
           const eventDate = rawEvent["date"];
           if (!actorUserId || !interactionId || !actionId || !targetMessageId || !eventChatId || !eventDate || !data) {
-            continue;
+            return;
           }
           if (actorUserId === meId)
-            continue;
+            return;
           scheduleImmediateInboundMessage({
             chatId: eventChatId,
             msg: {
@@ -76434,9 +77837,9 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
               data
             }
           }, "inline action dispatch", { serializeWithChat: true });
-          continue;
+          return;
         }
-      }
+      });
     } catch (err) {
       publishStatus({ connected: false, lastError: String(err) });
       runtime.error?.(`inline monitor loop crashed: ${String(err)}`);
@@ -76455,6 +77858,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       return;
     }
     stopPromise = (async () => {
+      shutdown.abort();
       clearInterval(diagnosticsTimer);
       clearPendingInlineVoiceMessages();
       await client.close().catch(() => {});
@@ -76463,11 +77867,13 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
     })();
     await stopPromise;
   };
-  abortSignal.addEventListener("abort", () => {
+  params.abortSignal.addEventListener("abort", () => {
     stop();
   }, { once: true });
+  if (params.abortSignal.aborted)
+    stop();
   const done = loop.then(drainInboundTasks, async (error51) => {
-    await drainInboundTasks();
+    await stop();
     throw error51;
   });
   return { stop, done };
@@ -77471,6 +78877,11 @@ import {
   normalizeLowercaseStringOrEmpty as normalizeLowercaseStringOrEmpty3,
   normalizeOptionalString as normalizeOptionalString4
 } from "openclaw/plugin-sdk/string-coerce-runtime";
+
+// src/inline/approval-contract.ts
+var INLINE_APPROVAL_EVENT_KINDS = ["exec", "plugin", "system-agent"];
+
+// src/inline/approval-native.ts
 function accountParams(params) {
   return {
     cfg: params.cfg,
@@ -77609,7 +79020,7 @@ var inlineNativeApprovalCapability = createApproverRestrictedNativeApprovalCapab
   resolveApproverDmTargets: resolveInlineApproverDmTargets,
   notifyOriginWhenDmOnly: true,
   nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
-    eventKinds: ["exec", "plugin"],
+    eventKinds: INLINE_APPROVAL_EVENT_KINDS,
     isConfigured: ({ cfg, accountId }) => isInlineExecApprovalClientEnabled(accountParams({ cfg, accountId })),
     shouldHandle: ({ cfg, accountId, request }) => shouldHandleInlineExecApprovalRequest(requestParams({ cfg, accountId, request })),
     load: async () => loadBundledEntryExportSync(import.meta.url, {
@@ -77664,6 +79075,22 @@ var inlineNativeApprovalAdapter = splitChannelApprovalCapability(inlineApprovalC
 
 // src/inline/channel.ts
 var activeMonitors = new Map;
+function inlineErrorMessage(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+function asInlinePlatformNotDispatched(error51) {
+  if (error51 instanceof PlatformMessageNotDispatchedError)
+    return error51;
+  return new PlatformMessageNotDispatchedError(inlineErrorMessage(error51), { cause: error51 });
+}
+function deriveInlineDeliveryRandomId(context) {
+  const queueId = context.deliveryQueueId?.trim();
+  if (!queueId)
+    return;
+  const digest = createHash("sha256").update("openclaw:inline:delivery:v1\x00").update(queueId).update("\x00").update(String(context.deliveryPartIndex ?? 0)).update("\x00").update(String(context.deliverySubpartIndex ?? 0)).digest();
+  const value = digest.readBigInt64BE(0);
+  return value === 0n ? 1n : value;
+}
 function resolveInlineStatePath(accountId) {
   return path4.join(getInlineRuntime().state.resolveStateDir(), "channels", "inline", `${accountId}.json`);
 }
@@ -77955,7 +79382,7 @@ function resolveInlineSessionTarget(params) {
   const raw = params.id.trim().replace(/^inline:/i, "").trim();
   if (!raw)
     return;
-  const target = /^chat:/i.test(raw) ? raw : `chat:${raw}`;
+  const target = /^(?:chat|user):/i.test(raw) ? raw : `chat:${raw}`;
   try {
     return parseInlineExplicitTarget(target)?.to;
   } catch {
@@ -78285,29 +79712,32 @@ async function notifyPairingApprovedInline(params) {
   }
 }
 async function sendMessageInline(params) {
-  const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
-  if (!account.configured || !account.baseUrl) {
-    throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
-  }
-  const token = await resolveInlineToken(account);
-  const target = parseInlineOutboundTarget({
-    raw: params.to,
-    context: "sendText"
-  });
-  const visibleText = sanitizeInlineVisibleText(params.text);
-  if (visibleText.shouldSkip) {
-    return {
-      messageId: "",
-      chatId: target.kind === "user" ? `user:${target.normalizedNumeric}` : target.normalizedNumeric
-    };
-  }
-  const text = sanitizeInlineOutgoingText(visibleText.text);
-  const client = new InlineSdkClient({
-    baseUrl: account.baseUrl,
-    token
-  });
-  await client.connect();
+  let platformSendStarted = false;
+  let client = null;
   try {
+    const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
+    if (!account.configured || !account.baseUrl) {
+      throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
+    }
+    const token = await resolveInlineToken(account);
+    const target = parseInlineOutboundTarget({
+      raw: params.to,
+      context: "sendText"
+    });
+    const visibleText = sanitizeInlineVisibleText(params.text);
+    if (visibleText.shouldSkip) {
+      return {
+        outcome: "not_sent",
+        messageId: "",
+        chatId: target.kind === "user" ? `user:${target.normalizedNumeric}` : target.normalizedNumeric
+      };
+    }
+    const text = sanitizeInlineOutgoingText(visibleText.text);
+    client = new InlineSdkClient({
+      baseUrl: account.baseUrl,
+      token
+    });
+    await client.connect(params.signal);
     const replyToMsgId = parseInlineId2(params.replyToId);
     const resolvedTarget = await resolveInlineOutboundTarget({
       client,
@@ -78320,12 +79750,20 @@ async function sendMessageInline(params) {
       parentChatId: resolvedTarget.targetId,
       threadId: params.threadId ?? null
     }) : null;
+    const randomId = deriveInlineDeliveryRandomId(params);
+    params.signal?.throwIfAborted();
+    await params.onPlatformSendDispatch?.();
+    params.signal?.throwIfAborted();
+    params.assertDirectAdapterHandoff?.();
+    platformSendStarted = true;
     const result = await client.sendMessage({
       ...effectiveChatId != null ? { chatId: effectiveChatId } : buildInlineSendTarget(resolvedTarget),
       text,
+      ...randomId != null ? { randomId } : {},
       ...params.actions !== undefined ? { actions: params.actions } : {},
       ...replyToMsgId != null ? { replyToMsgId } : {},
-      parseMarkdown: account.config.parseMarkdown ?? true
+      parseMarkdown: account.config.parseMarkdown ?? true,
+      ...params.silent ? { sendMode: "silent" } : {}
     }).catch((error51) => {
       throw wrapInlineTargetError({
         error: error51,
@@ -78334,7 +79772,6 @@ async function sendMessageInline(params) {
         resolvedTarget
       });
     });
-    const bestEffort = result.messageId != null ? String(result.messageId) : BigInt(Date.now()).toString();
     if (resolvedTarget.kind === "chat") {
       recordInlineOutboundThreadParticipation({
         accountId: account.accountId,
@@ -78344,32 +79781,38 @@ async function sendMessageInline(params) {
       });
     }
     return {
-      messageId: bestEffort,
+      messageId: result.messageId != null ? String(result.messageId) : "",
       chatId: effectiveChatId != null ? String(effectiveChatId) : formatInlineResultChatId(resolvedTarget)
     };
+  } catch (error51) {
+    if (!platformSendStarted)
+      throw asInlinePlatformNotDispatched(error51);
+    throw error51;
   } finally {
-    await client.close().catch(() => {});
+    await client?.close().catch(() => {});
   }
 }
 async function sendMediaInline(params) {
-  const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
-  if (!account.configured || !account.baseUrl) {
-    throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
-  }
-  const token = await resolveInlineToken(account);
-  const target = parseInlineOutboundTarget({
-    raw: params.to,
-    context: "sendMedia"
-  });
-  const replyToMsgId = parseInlineId2(params.replyToId);
-  const visibleText = sanitizeInlineVisibleText(params.text);
-  const caption = visibleText.shouldSkip ? "" : sanitizeInlineOutgoingText(visibleText.text).trim();
-  const client = new InlineSdkClient({
-    baseUrl: account.baseUrl,
-    token
-  });
-  await client.connect();
+  let platformSendStarted = false;
+  let client = null;
   try {
+    const account = resolveInlineAccount({ cfg: params.cfg, accountId: params.accountId ?? null });
+    if (!account.configured || !account.baseUrl) {
+      throw new Error(`Inline not configured for account "${account.accountId}" (missing token or baseUrl)`);
+    }
+    const token = await resolveInlineToken(account);
+    const target = parseInlineOutboundTarget({
+      raw: params.to,
+      context: "sendMedia"
+    });
+    const replyToMsgId = parseInlineId2(params.replyToId);
+    const visibleText = sanitizeInlineVisibleText(params.text);
+    const caption = visibleText.shouldSkip ? "" : sanitizeInlineOutgoingText(visibleText.text).trim();
+    client = new InlineSdkClient({
+      baseUrl: account.baseUrl,
+      token
+    });
+    await client.connect(params.signal);
     const resolvedTarget = await resolveInlineOutboundTarget({
       client,
       context: "sendMedia",
@@ -78388,15 +79831,24 @@ async function sendMediaInline(params) {
       mediaUrl: params.mediaUrl,
       ...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 } : {}
     });
+    const randomId = deriveInlineDeliveryRandomId(params);
+    params.signal?.throwIfAborted();
+    await params.onPlatformSendDispatch?.();
+    params.signal?.throwIfAborted();
+    params.assertDirectAdapterHandoff?.();
+    platformSendStarted = true;
     const result = await client.sendMessage({
       ...effectiveChatId != null ? { chatId: effectiveChatId } : buildInlineSendTarget(resolvedTarget),
       ...caption ? { text: caption } : {},
       media,
+      ...randomId != null ? { randomId } : {},
       ...params.actions !== undefined ? { actions: params.actions } : {},
       ...replyToMsgId != null ? { replyToMsgId } : {},
-      ...caption ? { parseMarkdown: account.config.parseMarkdown ?? true } : {}
+      ...caption ? { parseMarkdown: account.config.parseMarkdown ?? true } : {},
+      ...params.silent ? { sendMode: "silent" } : {}
     }).catch((error51) => {
       throw wrapInlineTargetError({
         error: error51,
@@ -78405,7 +79857,6 @@ async function sendMediaInline(params) {
         resolvedTarget
       });
     });
-    const bestEffort = result.messageId != null ? String(result.messageId) : BigInt(Date.now()).toString();
     if (resolvedTarget.kind === "chat") {
       recordInlineOutboundThreadParticipation({
         accountId: account.accountId,
@@ -78415,11 +79866,15 @@ async function sendMediaInline(params) {
       });
     }
     return {
-      messageId: bestEffort,
+      messageId: result.messageId != null ? String(result.messageId) : "",
       chatId: effectiveChatId != null ? String(effectiveChatId) : formatInlineResultChatId(resolvedTarget)
     };
+  } catch (error51) {
+    if (!platformSendStarted)
+      throw asInlinePlatformNotDispatched(error51);
+    throw error51;
   } finally {
-    await client.close().catch(() => {});
+    await client?.close().catch(() => {});
   }
 }
 function resolveDirectoryLimit(limit) {
@@ -78523,8 +79978,22 @@ var resolveInlineAllowlistGroupOverrides = createFlatAllowlistOverrideResolver({
   label: (key2) => key2,
   resolveEntries: (value) => value?.allowFrom
 });
+var inlineDurableFinalDeliveryCapabilities = {
+  text: true,
+  media: true,
+  payload: true,
+  silent: true,
+  replyTo: true,
+  thread: true,
+  nativeQuote: false,
+  messageSendingHooks: true,
+  batch: true
+};
 var inlineOutbound = {
   deliveryMode: "direct",
+  deliveryCapabilities: {
+    durableFinal: inlineDurableFinalDeliveryCapabilities
+  },
   targetsMatchForReplySuppression: ({ originTarget, targetKey, targetThreadId }) => {
     const origin = resolveInlineSessionTarget({ id: originTarget });
     const destination = resolveInlineSessionTarget({ id: targetThreadId ?? targetKey });
@@ -78557,17 +80026,25 @@ var inlineOutbound = {
       ...interactive ? { interactive } : {}
     };
   },
-  sendPayload: async ({
-    cfg,
-    to,
-    payload,
-    accountId,
-    replyToId,
-    threadId,
-    mediaAccess,
-    mediaLocalRoots,
-    mediaReadFile
-  }) => {
+  sendPayload: async (context) => {
+    const {
+      cfg,
+      to,
+      payload,
+      accountId,
+      replyToId,
+      threadId,
+      mediaAccess,
+      mediaLocalRoots,
+      mediaReadFile,
+      silent,
+      deliveryQueueId,
+      deliveryPartIndex,
+      onPlatformSendDispatch,
+      assertDirectAdapterHandoff,
+      onDeliveryResult
+    } = context;
+    const { signal } = context;
     const text = resolveInlineInteractiveTextFallback({
       text: payload.text ?? undefined,
       interactive: payload.interactive,
@@ -78576,7 +80053,7 @@ var inlineOutbound = {
     const payloadReplyToId = typeof payload.replyToId === "string" ? payload.replyToId.trim() : null;
     const effectiveReplyToId = payloadReplyToId || replyToId || null;
     const actions = resolveInlinePayloadActions(payload);
-    const mediaUrls = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
+    const mediaUrls = ((payload.mediaUrls?.length) ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : []).map((url2) => url2.trim()).filter(Boolean);
     if (mediaUrls.length === 0) {
       const result = await sendMessageInline({
         cfg,
@@ -78585,17 +80062,32 @@ var inlineOutbound = {
         actions,
         accountId: accountId ?? null,
         replyToId: effectiveReplyToId,
-        threadId: threadId ?? null
+        threadId: threadId ?? null,
+        silent,
+        signal,
+        deliveryQueueId,
+        deliveryPartIndex,
+        onPlatformSendDispatch,
+        assertDirectAdapterHandoff
       });
-      return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
+      const delivery = {
+        ...result.outcome ? { outcome: result.outcome } : {},
+        channel: "inline",
+        to,
+        messageId: result.messageId,
+        chatId: result.chatId
+      };
+      if (result.outcome !== "not_sent")
+        await onDeliveryResult?.(delivery);
+      return delivery;
     }
-    let finalResult = null;
+    const deliveries = [];
     for (let index = 0;index < mediaUrls.length; index += 1) {
       const mediaUrl = mediaUrls[index];
-      if (!mediaUrl?.trim())
+      if (!mediaUrl)
         continue;
       const isFirst = index === 0;
-      finalResult = await sendMediaInline({
+      const result = await sendMediaInline({
         cfg,
         to,
         text: isFirst ? text : "",
@@ -78606,9 +80098,25 @@ var inlineOutbound = {
         threadId: threadId ?? null,
         ...mediaAccess ? { mediaAccess } : {},
         ...mediaLocalRoots ? { mediaLocalRoots } : {},
-        ...mediaReadFile ? { mediaReadFile } : {}
+        ...mediaReadFile ? { mediaReadFile } : {},
+        silent,
+        signal,
+        deliveryQueueId,
+        deliveryPartIndex,
+        deliverySubpartIndex: index,
+        onPlatformSendDispatch,
+        assertDirectAdapterHandoff
       });
+      const delivery = {
+        channel: "inline",
+        to,
+        messageId: result.messageId,
+        chatId: result.chatId
+      };
+      deliveries.push(delivery);
+      await onDeliveryResult?.(delivery);
     }
+    const finalResult = deliveries.at(-1);
     if (!finalResult) {
       const result = await sendMessageInline({
         cfg,
@@ -78617,35 +80125,98 @@ var inlineOutbound = {
         actions,
         accountId: accountId ?? null,
         replyToId: effectiveReplyToId,
-        threadId: threadId ?? null
+        threadId: threadId ?? null,
+        silent,
+        signal,
+        deliveryQueueId,
+        deliveryPartIndex,
+        onPlatformSendDispatch,
+        assertDirectAdapterHandoff
       });
-      return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
-    }
-    return { channel: "inline", to, messageId: finalResult.messageId, chatId: finalResult.chatId };
+      const delivery = {
+        ...result.outcome ? { outcome: result.outcome } : {},
+        channel: "inline",
+        to,
+        messageId: result.messageId,
+        chatId: result.chatId
+      };
+      if (result.outcome !== "not_sent")
+        await onDeliveryResult?.(delivery);
+      return delivery;
+    }
+    const receipt = createMessageReceiptFromOutboundResults({
+      results: deliveries,
+      kind: "media",
+      ...threadId != null ? { threadId: String(threadId) } : {},
+      ...effectiveReplyToId ? { replyToId: effectiveReplyToId } : {}
+    });
+    return {
+      ...finalResult,
+      messageId: receipt.primaryPlatformMessageId ?? finalResult.messageId,
+      receipt
+    };
   },
-  sendText: async ({ cfg, to, text, accountId, replyToId, threadId }) => {
+  sendText: async (context) => {
+    const {
+      cfg,
+      to,
+      text,
+      accountId,
+      replyToId,
+      threadId,
+      silent,
+      deliveryQueueId,
+      deliveryPartIndex,
+      onPlatformSendDispatch,
+      assertDirectAdapterHandoff,
+      onDeliveryResult
+    } = context;
+    const { signal } = context;
     const result = await sendMessageInline({
       cfg,
       to,
       text,
       accountId: accountId ?? null,
       replyToId: replyToId ?? null,
-      threadId: threadId ?? null
+      threadId: threadId ?? null,
+      silent,
+      signal,
+      deliveryQueueId,
+      deliveryPartIndex,
+      onPlatformSendDispatch,
+      assertDirectAdapterHandoff
     });
-    return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
+    const delivery = {
+      ...result.outcome ? { outcome: result.outcome } : {},
+      channel: "inline",
+      to,
+      messageId: result.messageId,
+      chatId: result.chatId
+    };
+    if (result.outcome !== "not_sent")
+      await onDeliveryResult?.(delivery);
+    return delivery;
   },
-  sendMedia: async ({
-    cfg,
-    to,
-    text,
-    mediaUrl,
-    accountId,
-    replyToId,
-    threadId,
-    mediaAccess,
-    mediaLocalRoots,
-    mediaReadFile
-  }) => {
+  sendMedia: async (context) => {
+    const {
+      cfg,
+      to,
+      text,
+      mediaUrl,
+      accountId,
+      replyToId,
+      threadId,
+      mediaAccess,
+      mediaLocalRoots,
+      mediaReadFile,
+      silent,
+      deliveryQueueId,
+      deliveryPartIndex,
+      onPlatformSendDispatch,
+      assertDirectAdapterHandoff,
+      onDeliveryResult
+    } = context;
+    const { signal } = context;
     if (!mediaUrl) {
       const result2 = await sendMessageInline({
         cfg,
@@ -78653,9 +80224,24 @@ var inlineOutbound = {
         text,
         accountId: accountId ?? null,
         replyToId: replyToId ?? null,
-        threadId: threadId ?? null
+        threadId: threadId ?? null,
+        silent,
+        signal,
+        deliveryQueueId,
+        deliveryPartIndex,
+        onPlatformSendDispatch,
+        assertDirectAdapterHandoff
       });
-      return { channel: "inline", to, messageId: result2.messageId, chatId: result2.chatId };
+      const delivery2 = {
+        ...result2.outcome ? { outcome: result2.outcome } : {},
+        channel: "inline",
+        to,
+        messageId: result2.messageId,
+        chatId: result2.chatId
+      };
+      if (result2.outcome !== "not_sent")
+        await onDeliveryResult?.(delivery2);
+      return delivery2;
     }
     const result = await sendMediaInline({
       cfg,
@@ -78667,9 +80253,22 @@ var inlineOutbound = {
       threadId: threadId ?? null,
       ...mediaAccess ? { mediaAccess } : {},
       ...mediaLocalRoots ? { mediaLocalRoots } : {},
-      ...mediaReadFile ? { mediaReadFile } : {}
+      ...mediaReadFile ? { mediaReadFile } : {},
+      silent,
+      signal,
+      deliveryQueueId,
+      deliveryPartIndex,
+      onPlatformSendDispatch,
+      assertDirectAdapterHandoff
     });
-    return { channel: "inline", to, messageId: result.messageId, chatId: result.chatId };
+    const delivery = {
+      channel: "inline",
+      to,
+      messageId: result.messageId,
+      chatId: result.chatId
+    };
+    await onDeliveryResult?.(delivery);
+    return delivery;
   }
 };
 function toInlineMessageBridgeResult(result) {
@@ -78688,21 +80287,31 @@ function toInlineMessageBridgeResult(result) {
 var inlineMessageAdapter = createChannelMessageAdapterFromOutbound({
   id: "inline",
   outbound: {
-    sendText: async ({ onDeliveryResult, ...ctx }) => {
-      const result = toInlineMessageBridgeResult(await inlineOutbound.sendText(ctx));
-      await onDeliveryResult?.(result);
-      return result;
-    },
-    sendMedia: async ({ onDeliveryResult, ...ctx }) => {
-      const result = toInlineMessageBridgeResult(await inlineOutbound.sendMedia(ctx));
-      await onDeliveryResult?.(result);
-      return result;
-    },
-    sendPayload: async ({ onDeliveryResult, ...ctx }) => {
-      const result = toInlineMessageBridgeResult(await inlineOutbound.sendPayload(ctx));
-      await onDeliveryResult?.(result);
-      return result;
-    }
+    deliveryCapabilities: { durableFinal: inlineDurableFinalDeliveryCapabilities },
+    sendText: async ({ onDeliveryResult, ...ctx }) => toInlineMessageBridgeResult(await inlineOutbound.sendText({
+      ...ctx,
+      ...onDeliveryResult ? {
+        onDeliveryResult: async (result) => {
+          await onDeliveryResult(toInlineMessageBridgeResult(result));
+        }
+      } : {}
+    })),
+    sendMedia: async ({ onDeliveryResult, ...ctx }) => toInlineMessageBridgeResult(await inlineOutbound.sendMedia({
+      ...ctx,
+      ...onDeliveryResult ? {
+        onDeliveryResult: async (result) => {
+          await onDeliveryResult(toInlineMessageBridgeResult(result));
+        }
+      } : {}
+    })),
+    sendPayload: async ({ onDeliveryResult, ...ctx }) => toInlineMessageBridgeResult(await inlineOutbound.sendPayload({
+      ...ctx,
+      ...onDeliveryResult ? {
+        onDeliveryResult: async (result) => {
+          await onDeliveryResult(toInlineMessageBridgeResult(result));
+        }
+      } : {}
+    }))
   },
   live: {
     capabilities: {
@@ -79269,280 +80878,11 @@ var inlineChannelPlugin = {
   }
 };
 
-// src/telemetry.ts
-import { randomUUID as randomUUID2 } 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;
-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_OPENCLAW_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 redactOpenClawTelemetryText(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(error51, env) {
-  const stack = error51.stack ?? "";
-  const frames = [];
-  for (const rawLine of stack.split(`
-`).slice(1)) {
-    const line = redactOpenClawTelemetryText(rawLine.trim(), env);
-    const match = /^at\s+(?:(.*?)\s+\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
-    if (!match)
-      continue;
-    const filename = match[2];
-    const frame = {
-      filename,
-      abs_path: filename,
-      function: match[1] || "<anonymous>",
-      lineno: Number(match[3]),
-      colno: Number(match[4]),
-      in_app: filename.includes("@inline-openclaw/inline") || filename.includes("/openclaw/") || /\/(?:channel-plugin-api|runtime-register-api|index)\.js$/.test(filename)
-    };
-    frames.push(frame);
-    if (frames.length >= MAX_STACK_FRAMES)
-      break;
-  }
-  return frames.reverse();
-}
-function buildOpenClawTelemetryEvent(operation, error51, options = {}) {
-  const env = options.env ?? process.env;
-  const exception = error51 instanceof Error ? error51 : new Error(String(error51 ?? "Unknown error"));
-  const frames = parseStack(exception, env);
-  return {
-    event_id: randomUUID2().replaceAll("-", ""),
-    timestamp: new Date().toISOString(),
-    platform: "javascript",
-    level: "error",
-    logger: "inline.openclaw.plugin",
-    exception: {
-      values: [{
-        type: redactOpenClawTelemetryText(exception.name || "Error", env),
-        value: redactOpenClawTelemetryText(exception.message || String(error51), env),
-        mechanism: {
-          type: "inline_plugin_boundary",
-          handled: options.handled ?? true
-        },
-        ...frames.length > 0 ? { stacktrace: { frames } } : {}
-      }]
-    },
-    tags: {
-      operation: safeTag(operation),
-      runtime: "node",
-      os: process.platform,
-      arch: process.arch
-    },
-    sdk: { name: "inline.plugin.telemetry", version: "1" }
-  };
-}
-async function resolveRelease() {
-  releasePromise ??= (async () => {
-    try {
-      const parsed = JSON.parse(await readFile2(new URL("../package.json", import.meta.url), "utf8"));
-      if (typeof parsed.version === "string" && parsed.version.trim()) {
-        return `inline-openclaw-plugin@${parsed.version.trim()}`;
-      }
-    } catch {}
-    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 sendOpenClawPluginError(operation, error51, options = {}) {
-  const env = options.env ?? process.env;
-  const dsn = resolveDsn(env);
-  const target = parseSentryDsn(dsn);
-  if (!target)
-    return false;
-  const event = buildOpenClawTelemetryEvent(operation, error51, 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 reportOpenClawPluginError(operation, error51, options = {}) {
-  try {
-    const exception = error51 instanceof Error ? error51 : new Error(String(error51 ?? "Unknown error"));
-    const key2 = `${safeTag(operation)}\x00${exception.name}\x00${redactOpenClawTelemetryText(exception.message)}`;
-    const now = Date.now();
-    if (now - (lastReports.get(key2) ?? 0) < TELEMETRY_DEDUP_MS)
-      return;
-    lastReports.set(key2, now);
-    sendOpenClawPluginError(operation, exception, options).catch(() => {});
-  } catch {}
-}
-function wrapCallback(operation, callback) {
-  return function(...args) {
-    try {
-      const result = Reflect.apply(callback, this, args);
-      if (result && typeof result.then === "function") {
-        return Promise.resolve(result).catch((error51) => {
-          reportOpenClawPluginError(operation, error51);
-          throw error51;
-        });
-      }
-      return result;
-    } catch (error51) {
-      reportOpenClawPluginError(operation, error51);
-      throw error51;
-    }
-  };
-}
-function wrapSurface(prefix, surface) {
-  const wrapped = { ...surface };
-  for (const [name, member] of Object.entries(wrapped)) {
-    if (typeof member === "function") {
-      wrapped[name] = wrapCallback(`${prefix}.${name}`, member);
-    }
-  }
-  return wrapped;
-}
-function instrumentToolValue(value) {
-  if (Array.isArray(value))
-    return value.map(instrumentToolValue);
-  if (!value || typeof value !== "object")
-    return value;
-  const tool = value;
-  const execute = tool.execute;
-  if (typeof execute !== "function")
-    return value;
-  const name = typeof tool.name === "string" ? safeTag(tool.name) : "unknown";
-  return new Proxy(tool, {
-    get(target, property, receiver) {
-      if (property === "execute") {
-        return wrapCallback(`tool.${name}`, execute);
-      }
-      return Reflect.get(target, property, receiver);
-    }
-  });
-}
-function instrumentOpenClawPluginApi(value) {
-  const api2 = value;
-  return new Proxy(api2, {
-    get(target, property, receiver) {
-      const member = Reflect.get(target, property, receiver);
-      if (property === "registerTool" && typeof member === "function") {
-        return (toolOrFactory, options) => {
-          const wrapped = typeof toolOrFactory === "function" ? wrapCallback("tool.factory", (...args) => instrumentToolValue(Reflect.apply(toolOrFactory, undefined, args))) : instrumentToolValue(toolOrFactory);
-          return Reflect.apply(member, target, [wrapped, options]);
-        };
-      }
-      if (property === "registerCommand" && typeof member === "function") {
-        return (command) => {
-          const handler = command.handler;
-          const name = typeof command.name === "string" ? safeTag(command.name) : "unknown";
-          const wrapped = typeof handler === "function" ? { ...command, handler: wrapCallback(`command.${name}`, handler) } : command;
-          return Reflect.apply(member, target, [wrapped]);
-        };
-      }
-      if (property === "on" && typeof member === "function") {
-        return (event, handler) => Reflect.apply(member, target, [event, wrapCallback(`hook.${safeTag(event)}`, handler)]);
-      }
-      return member;
-    }
-  });
-}
-function instrumentOpenClawChannelPlugin(value) {
-  const plugin = { ...value };
-  for (const name of [
-    "lifecycle",
-    "pairing",
-    "outbound",
-    "heartbeat",
-    "directory",
-    "resolver",
-    "allowlist",
-    "status",
-    "gateway"
-  ]) {
-    const surface = plugin[name];
-    if (surface && typeof surface === "object") {
-      plugin[name] = wrapSurface(name, surface);
-    }
-  }
-  const message = plugin.message;
-  if (message && typeof message === "object") {
-    const wrappedMessage = { ...message };
-    const send = wrappedMessage.send;
-    if (send && typeof send === "object") {
-      wrappedMessage.send = wrapSurface("message.send", send);
-    }
-    plugin.message = wrappedMessage;
-  }
-  return plugin;
-}
-function reportOpenClawRegistrationError(error51) {
-  reportOpenClawPluginError("plugin.register", error51, { handled: false });
-}
-
 // src/channel-plugin-api.ts
 var inlineChannelPlugin2 = instrumentOpenClawChannelPlugin(inlineChannelPlugin);
 export {
   inlineChannelPlugin2 as inlineChannelPlugin
 };
 
-//# debugId=0CD7141E321D85A264756E2164756E21
+//# debugId=EEDCDD547EBF16D364756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map