@inline-openclaw/inline 0.0.58 → 0.0.60

package/dist/channel-plugin-api.js

@@ -5722,6 +5722,7 @@ var RpcError_Code;
   RpcError_Code2[RpcError_Code2["USERNAME_TAKEN"] = 16] = "USERNAME_TAKEN";
   RpcError_Code2[RpcError_Code2["FIRST_NAME_INVALID"] = 17] = "FIRST_NAME_INVALID";
   RpcError_Code2[RpcError_Code2["URL_PREVIEW_UNAVAILABLE"] = 18] = "URL_PREVIEW_UNAVAILABLE";
+  RpcError_Code2[RpcError_Code2["AGENT_SESSION_MESSAGE_IMMUTABLE"] = 19] = "AGENT_SESSION_MESSAGE_IMMUTABLE";
 })(RpcError_Code || (RpcError_Code = {}));
 var SyncSkippedSequence_Reason;
 (function(SyncSkippedSequence_Reason2) {
@@ -5843,11 +5844,56 @@ var DialogFollowMode;
   DialogFollowMode2[DialogFollowMode2["FOLLOWING"] = 1] = "FOLLOWING";
   DialogFollowMode2[DialogFollowMode2["UNFOLLOWED"] = 2] = "UNFOLLOWED";
 })(DialogFollowMode || (DialogFollowMode = {}));
+var AgentSessionProvider;
+(function(AgentSessionProvider2) {
+  AgentSessionProvider2[AgentSessionProvider2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  AgentSessionProvider2[AgentSessionProvider2["CODEX"] = 1] = "CODEX";
+  AgentSessionProvider2[AgentSessionProvider2["CODEX_CLOUD"] = 2] = "CODEX_CLOUD";
+  AgentSessionProvider2[AgentSessionProvider2["CLAUDE"] = 3] = "CLAUDE";
+  AgentSessionProvider2[AgentSessionProvider2["OPEN_CODE"] = 4] = "OPEN_CODE";
+  AgentSessionProvider2[AgentSessionProvider2["AMP"] = 5] = "AMP";
+})(AgentSessionProvider || (AgentSessionProvider = {}));
+var AgentSessionMessageRole;
+(function(AgentSessionMessageRole2) {
+  AgentSessionMessageRole2[AgentSessionMessageRole2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  AgentSessionMessageRole2[AgentSessionMessageRole2["USER"] = 1] = "USER";
+  AgentSessionMessageRole2[AgentSessionMessageRole2["ASSISTANT"] = 2] = "ASSISTANT";
+})(AgentSessionMessageRole || (AgentSessionMessageRole = {}));
+var AgentSessionMessageRelation;
+(function(AgentSessionMessageRelation2) {
+  AgentSessionMessageRelation2[AgentSessionMessageRelation2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  AgentSessionMessageRelation2[AgentSessionMessageRelation2["IMPORTED"] = 1] = "IMPORTED";
+  AgentSessionMessageRelation2[AgentSessionMessageRelation2["LINKED"] = 2] = "LINKED";
+})(AgentSessionMessageRelation || (AgentSessionMessageRelation = {}));
 var MessageSendMode;
 (function(MessageSendMode2) {
   MessageSendMode2[MessageSendMode2["MODE_UNSPECIFIED"] = 0] = "MODE_UNSPECIFIED";
   MessageSendMode2[MessageSendMode2["MODE_SILENT"] = 1] = "MODE_SILENT";
 })(MessageSendMode || (MessageSendMode = {}));
+var ConnectAgentSessionState;
+(function(ConnectAgentSessionState2) {
+  ConnectAgentSessionState2[ConnectAgentSessionState2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  ConnectAgentSessionState2[ConnectAgentSessionState2["CREATED"] = 1] = "CREATED";
+  ConnectAgentSessionState2[ConnectAgentSessionState2["ALREADY_CONNECTED"] = 2] = "ALREADY_CONNECTED";
+  ConnectAgentSessionState2[ConnectAgentSessionState2["CONNECTED_ELSEWHERE"] = 3] = "CONNECTED_ELSEWHERE";
+})(ConnectAgentSessionState || (ConnectAgentSessionState = {}));
+var AgentSessionSyncMode;
+(function(AgentSessionSyncMode2) {
+  AgentSessionSyncMode2[AgentSessionSyncMode2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  AgentSessionSyncMode2[AgentSessionSyncMode2["HISTORY"] = 1] = "HISTORY";
+  AgentSessionSyncMode2[AgentSessionSyncMode2["LIVE"] = 2] = "LIVE";
+})(AgentSessionSyncMode || (AgentSessionSyncMode = {}));
+var AgentSessionMessageSyncState;
+(function(AgentSessionMessageSyncState2) {
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["CREATED"] = 1] = "CREATED";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["EDITED"] = 2] = "EDITED";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["LINKED"] = 3] = "LINKED";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["UNCHANGED"] = 4] = "UNCHANGED";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["STALE"] = 5] = "STALE";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["TOMBSTONED"] = 6] = "TOMBSTONED";
+  AgentSessionMessageSyncState2[AgentSessionMessageSyncState2["CONFLICT"] = 7] = "CONFLICT";
+})(AgentSessionMessageSyncState || (AgentSessionMessageSyncState = {}));
 var Method;
 (function(Method2) {
   Method2[Method2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -5977,6 +6023,11 @@ var Method;
   Method2[Method2["UPDATE_DIALOG_FOLDER"] = 125] = "UPDATE_DIALOG_FOLDER";
   Method2[Method2["DELETE_DIALOG_FOLDER"] = 126] = "DELETE_DIALOG_FOLDER";
   Method2[Method2["GET_SPACE"] = 127] = "GET_SPACE";
+  Method2[Method2["CONNECT_AGENT_SESSION"] = 128] = "CONNECT_AGENT_SESSION";
+  Method2[Method2["SYNC_AGENT_SESSION_MESSAGES"] = 129] = "SYNC_AGENT_SESSION_MESSAGES";
+  Method2[Method2["GET_AGENT_SESSION"] = 130] = "GET_AGENT_SESSION";
+  Method2[Method2["UPDATE_BOT_AGENT"] = 131] = "UPDATE_BOT_AGENT";
+  Method2[Method2["DELETE_BOT_AGENT"] = 132] = "DELETE_BOT_AGENT";
 })(Method || (Method = {}));
 var GridConnectionUnavailableReason;
 (function(GridConnectionUnavailableReason2) {
@@ -9528,7 +9579,8 @@ class Message$Type extends import_runtime4.MessageType {
       { no: 20, name: "actions", kind: "message", T: () => MessageActions },
       { no: 21, name: "rev", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 22, name: "service_message", kind: "message", T: () => MessageService },
-      { no: 23, name: "block_content", kind: "message", T: () => BlockContent }
+      { no: 23, name: "block_content", kind: "message", T: () => BlockContent },
+      { no: 24, name: "agent_session", kind: "message", T: () => AgentSessionMessageInfo }
     ]);
   }
   create(value) {
@@ -9619,6 +9671,9 @@ class Message$Type extends import_runtime4.MessageType {
         case 23:
           message.blockContent = BlockContent.internalBinaryRead(reader, reader.uint32(), options, message.blockContent);
           break;
+        case 24:
+          message.agentSession = AgentSessionMessageInfo.internalBinaryRead(reader, reader.uint32(), options, message.agentSession);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -9679,6 +9734,8 @@ class Message$Type extends import_runtime4.MessageType {
       MessageService.internalBinaryWrite(message.serviceMessage, writer.tag(22, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.blockContent)
       BlockContent.internalBinaryWrite(message.blockContent, writer.tag(23, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.agentSession)
+      AgentSessionMessageInfo.internalBinaryWrite(message.agentSession, writer.tag(24, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -9687,6 +9744,70 @@ class Message$Type extends import_runtime4.MessageType {
 }
 var Message = new Message$Type;
 
+class AgentSessionMessageInfo$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSessionMessageInfo", [
+      { no: 1, name: "agent_session_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "provider", kind: "enum", T: () => ["AgentSessionProvider", AgentSessionProvider, "AGENT_SESSION_PROVIDER_"] },
+      { no: 3, name: "role", kind: "enum", T: () => ["AgentSessionMessageRole", AgentSessionMessageRole, "AGENT_SESSION_MESSAGE_ROLE_"] },
+      { no: 4, name: "relation", kind: "enum", T: () => ["AgentSessionMessageRelation", AgentSessionMessageRelation, "AGENT_SESSION_MESSAGE_RELATION_"] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.agentSessionId = 0n;
+    message.provider = 0;
+    message.role = 0;
+    message.relation = 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.agentSessionId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.provider = reader.int32();
+          break;
+        case 3:
+          message.role = reader.int32();
+          break;
+        case 4:
+          message.relation = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.agentSessionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.agentSessionId);
+    if (message.provider !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.provider);
+    if (message.role !== 0)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.role);
+    if (message.relation !== 0)
+      writer.tag(4, import_runtime.WireType.Varint).int32(message.relation);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSessionMessageInfo = new AgentSessionMessageInfo$Type;
+
 class MessageFwdHeader$Type extends import_runtime4.MessageType {
   constructor() {
     super("MessageFwdHeader", [
@@ -10591,6 +10712,718 @@ class GetSpaceResult$Type extends import_runtime4.MessageType {
 }
 var GetSpaceResult = new GetSpaceResult$Type;
 
+class AgentSession$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSession", [
+      { no: 1, name: "id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 3, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 4, name: "provider", kind: "enum", T: () => ["AgentSessionProvider", AgentSessionProvider, "AGENT_SESSION_PROVIDER_"] },
+      { no: 5, name: "status_message_id", kind: "scalar", opt: true, T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.id = 0n;
+    message.botUserId = 0n;
+    message.provider = 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.id = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 3:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.provider = reader.int32();
+          break;
+        case 5:
+          message.statusMessageId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.id !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.id);
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.botUserId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.provider !== 0)
+      writer.tag(4, import_runtime.WireType.Varint).int32(message.provider);
+    if (message.statusMessageId !== undefined)
+      writer.tag(5, import_runtime.WireType.Varint).int64(message.statusMessageId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSession = new AgentSession$Type;
+
+class ConnectAgentSessionInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ConnectAgentSessionInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "provider", kind: "enum", T: () => ["AgentSessionProvider", AgentSessionProvider, "AGENT_SESSION_PROVIDER_"] },
+      { no: 4, name: "instance_ref", kind: "scalar", T: 9 },
+      { no: 5, name: "session_ref", kind: "scalar", T: 9 },
+      { no: 6, name: "project_ref", kind: "scalar", opt: true, T: 9 },
+      { no: 7, name: "status_message_id", kind: "scalar", opt: true, T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.provider = 0;
+    message.instanceRef = "";
+    message.sessionRef = "";
+    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.provider = reader.int32();
+          break;
+        case 4:
+          message.instanceRef = reader.string();
+          break;
+        case 5:
+          message.sessionRef = reader.string();
+          break;
+        case 6:
+          message.projectRef = reader.string();
+          break;
+        case 7:
+          message.statusMessageId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.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.provider !== 0)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.provider);
+    if (message.instanceRef !== "")
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.instanceRef);
+    if (message.sessionRef !== "")
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.sessionRef);
+    if (message.projectRef !== undefined)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.projectRef);
+    if (message.statusMessageId !== undefined)
+      writer.tag(7, import_runtime.WireType.Varint).int64(message.statusMessageId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var ConnectAgentSessionInput = new ConnectAgentSessionInput$Type;
+
+class ConnectAgentSessionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("ConnectAgentSessionResult", [
+      { no: 1, name: "agent_session", kind: "message", T: () => AgentSession },
+      { no: 2, name: "state", kind: "enum", T: () => ["ConnectAgentSessionState", ConnectAgentSessionState, "CONNECT_AGENT_SESSION_STATE_"] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.state = 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.agentSession = AgentSession.internalBinaryRead(reader, reader.uint32(), options, message.agentSession);
+          break;
+        case 2:
+          message.state = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.agentSession)
+      AgentSession.internalBinaryWrite(message.agentSession, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.state);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var ConnectAgentSessionResult = new ConnectAgentSessionResult$Type;
+
+class AgentSessionConnection$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSessionConnection", [
+      { no: 1, name: "agent_session", kind: "message", T: () => AgentSession },
+      { no: 2, name: "instance_ref", kind: "scalar", T: 9 },
+      { no: 3, name: "session_ref", kind: "scalar", T: 9 },
+      { no: 4, name: "project_ref", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.instanceRef = "";
+    message.sessionRef = "";
+    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.agentSession = AgentSession.internalBinaryRead(reader, reader.uint32(), options, message.agentSession);
+          break;
+        case 2:
+          message.instanceRef = reader.string();
+          break;
+        case 3:
+          message.sessionRef = reader.string();
+          break;
+        case 4:
+          message.projectRef = 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.agentSession)
+      AgentSession.internalBinaryWrite(message.agentSession, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.instanceRef !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.instanceRef);
+    if (message.sessionRef !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.sessionRef);
+    if (message.projectRef !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.projectRef);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSessionConnection = new AgentSessionConnection$Type;
+
+class GetAgentSessionInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetAgentSessionInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.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);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetAgentSessionInput = new GetAgentSessionInput$Type;
+
+class GetAgentSessionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetAgentSessionResult", [
+      { no: 1, name: "connection", kind: "message", T: () => AgentSessionConnection }
+    ]);
+  }
+  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.connection = AgentSessionConnection.internalBinaryRead(reader, reader.uint32(), options, message.connection);
+          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.connection)
+      AgentSessionConnection.internalBinaryWrite(message.connection, 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 GetAgentSessionResult = new GetAgentSessionResult$Type;
+
+class AgentSessionMessageUpsert$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSessionMessageUpsert", [
+      { no: 1, name: "text", kind: "scalar", T: 9 },
+      { no: 2, name: "entities", kind: "message", T: () => MessageEntities },
+      { no: 3, name: "assistant_random_id", kind: "scalar", opt: true, T: 3, L: 0 }
+    ]);
+  }
+  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;
+        case 2:
+          message.entities = MessageEntities.internalBinaryRead(reader, reader.uint32(), options, message.entities);
+          break;
+        case 3:
+          message.assistantRandomId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.text !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.text);
+    if (message.entities)
+      MessageEntities.internalBinaryWrite(message.entities, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.assistantRandomId !== undefined)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.assistantRandomId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSessionMessageUpsert = new AgentSessionMessageUpsert$Type;
+
+class AgentSessionMessageLink$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSessionMessageLink", [
+      { no: 1, name: "message_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.messageId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.messageId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.messageId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSessionMessageLink = new AgentSessionMessageLink$Type;
+
+class AgentSessionMessageSync$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSessionMessageSync", [
+      { no: 1, name: "role", kind: "enum", T: () => ["AgentSessionMessageRole", AgentSessionMessageRole, "AGENT_SESSION_MESSAGE_ROLE_"] },
+      { no: 2, name: "item_ref", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "correlation_ref", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "source_date", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 5, name: "revision_ref", kind: "scalar", opt: true, T: 9 },
+      { no: 6, name: "base_revision_ref", kind: "scalar", opt: true, T: 9 },
+      { no: 7, name: "complete", kind: "scalar", T: 8 },
+      { no: 8, name: "upsert", kind: "message", oneof: "operation", T: () => AgentSessionMessageUpsert },
+      { no: 9, name: "link", kind: "message", oneof: "operation", T: () => AgentSessionMessageLink }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.role = 0;
+    message.complete = false;
+    message.operation = { 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.role = reader.int32();
+          break;
+        case 2:
+          message.itemRef = reader.string();
+          break;
+        case 3:
+          message.correlationRef = reader.string();
+          break;
+        case 4:
+          message.sourceDate = reader.int64().toBigInt();
+          break;
+        case 5:
+          message.revisionRef = reader.string();
+          break;
+        case 6:
+          message.baseRevisionRef = reader.string();
+          break;
+        case 7:
+          message.complete = reader.bool();
+          break;
+        case 8:
+          message.operation = {
+            oneofKind: "upsert",
+            upsert: AgentSessionMessageUpsert.internalBinaryRead(reader, reader.uint32(), options, message.operation.upsert)
+          };
+          break;
+        case 9:
+          message.operation = {
+            oneofKind: "link",
+            link: AgentSessionMessageLink.internalBinaryRead(reader, reader.uint32(), options, message.operation.link)
+          };
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.role !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.role);
+    if (message.itemRef !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.itemRef);
+    if (message.correlationRef !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.correlationRef);
+    if (message.sourceDate !== undefined)
+      writer.tag(4, import_runtime.WireType.Varint).int64(message.sourceDate);
+    if (message.revisionRef !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.revisionRef);
+    if (message.baseRevisionRef !== undefined)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.baseRevisionRef);
+    if (message.complete !== false)
+      writer.tag(7, import_runtime.WireType.Varint).bool(message.complete);
+    if (message.operation.oneofKind === "upsert")
+      AgentSessionMessageUpsert.internalBinaryWrite(message.operation.upsert, writer.tag(8, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.operation.oneofKind === "link")
+      AgentSessionMessageLink.internalBinaryWrite(message.operation.link, writer.tag(9, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSessionMessageSync = new AgentSessionMessageSync$Type;
+
+class SyncAgentSessionMessagesInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SyncAgentSessionMessagesInput", [
+      { no: 1, name: "agent_session_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "mode", kind: "enum", T: () => ["AgentSessionSyncMode", AgentSessionSyncMode, "AGENT_SESSION_SYNC_MODE_"] },
+      { no: 3, name: "messages", kind: "message", repeat: 1, T: () => AgentSessionMessageSync }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.agentSessionId = 0n;
+    message.mode = 0;
+    message.messages = [];
+    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.agentSessionId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.mode = reader.int32();
+          break;
+        case 3:
+          message.messages.push(AgentSessionMessageSync.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.agentSessionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.agentSessionId);
+    if (message.mode !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.mode);
+    for (let i = 0;i < message.messages.length; i++)
+      AgentSessionMessageSync.internalBinaryWrite(message.messages[i], writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var SyncAgentSessionMessagesInput = new SyncAgentSessionMessagesInput$Type;
+
+class AgentSessionMessageSyncResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("AgentSessionMessageSyncResult", [
+      { no: 1, name: "index", kind: "scalar", T: 5 },
+      { no: 2, name: "state", kind: "enum", T: () => ["AgentSessionMessageSyncState", AgentSessionMessageSyncState, "AGENT_SESSION_MESSAGE_SYNC_STATE_"] },
+      { no: 3, name: "message_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 4, name: "current_revision_ref", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.index = 0;
+    message.state = 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.index = reader.int32();
+          break;
+        case 2:
+          message.state = reader.int32();
+          break;
+        case 3:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        case 4:
+          message.currentRevisionRef = 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.index !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.index);
+    if (message.state !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.state);
+    if (message.messageId !== undefined)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.messageId);
+    if (message.currentRevisionRef !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.currentRevisionRef);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var AgentSessionMessageSyncResult = new AgentSessionMessageSyncResult$Type;
+
+class SyncAgentSessionMessagesResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SyncAgentSessionMessagesResult", [
+      { no: 1, name: "messages", kind: "message", repeat: 1, T: () => AgentSessionMessageSyncResult }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.messages = [];
+    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.messages.push(AgentSessionMessageSyncResult.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.messages.length; i++)
+      AgentSessionMessageSyncResult.internalBinaryWrite(message.messages[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 SyncAgentSessionMessagesResult = new SyncAgentSessionMessagesResult$Type;
+
 class JoinPublicSpaceInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("JoinPublicSpaceInput", [
@@ -12463,7 +13296,12 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { no: 125, name: "createDialogFolder", kind: "message", oneof: "input", T: () => CreateDialogFolderInput },
       { no: 126, name: "updateDialogFolder", kind: "message", oneof: "input", T: () => UpdateDialogFolderInput },
       { no: 127, name: "deleteDialogFolder", kind: "message", oneof: "input", T: () => DeleteDialogFolderInput },
-      { no: 128, name: "getSpace", kind: "message", oneof: "input", T: () => GetSpaceInput }
+      { no: 128, name: "getSpace", kind: "message", oneof: "input", T: () => GetSpaceInput },
+      { no: 129, name: "connectAgentSession", kind: "message", oneof: "input", T: () => ConnectAgentSessionInput },
+      { no: 130, name: "syncAgentSessionMessages", kind: "message", oneof: "input", T: () => SyncAgentSessionMessagesInput },
+      { no: 131, name: "getAgentSession", kind: "message", oneof: "input", T: () => GetAgentSessionInput },
+      { no: 132, name: "updateBotAgent", kind: "message", oneof: "input", T: () => UpdateBotAgentInput },
+      { no: 133, name: "deleteBotAgent", kind: "message", oneof: "input", T: () => DeleteBotAgentInput }
     ]);
   }
   create(value) {
@@ -13238,6 +14076,36 @@ class RpcCall$Type extends import_runtime4.MessageType {
             getSpace: GetSpaceInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getSpace)
           };
           break;
+        case 129:
+          message.input = {
+            oneofKind: "connectAgentSession",
+            connectAgentSession: ConnectAgentSessionInput.internalBinaryRead(reader, reader.uint32(), options, message.input.connectAgentSession)
+          };
+          break;
+        case 130:
+          message.input = {
+            oneofKind: "syncAgentSessionMessages",
+            syncAgentSessionMessages: SyncAgentSessionMessagesInput.internalBinaryRead(reader, reader.uint32(), options, message.input.syncAgentSessionMessages)
+          };
+          break;
+        case 131:
+          message.input = {
+            oneofKind: "getAgentSession",
+            getAgentSession: GetAgentSessionInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getAgentSession)
+          };
+          break;
+        case 132:
+          message.input = {
+            oneofKind: "updateBotAgent",
+            updateBotAgent: UpdateBotAgentInput.internalBinaryRead(reader, reader.uint32(), options, message.input.updateBotAgent)
+          };
+          break;
+        case 133:
+          message.input = {
+            oneofKind: "deleteBotAgent",
+            deleteBotAgent: DeleteBotAgentInput.internalBinaryRead(reader, reader.uint32(), options, message.input.deleteBotAgent)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -13504,6 +14372,16 @@ class RpcCall$Type extends import_runtime4.MessageType {
       DeleteDialogFolderInput.internalBinaryWrite(message.input.deleteDialogFolder, writer.tag(127, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.input.oneofKind === "getSpace")
       GetSpaceInput.internalBinaryWrite(message.input.getSpace, writer.tag(128, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "connectAgentSession")
+      ConnectAgentSessionInput.internalBinaryWrite(message.input.connectAgentSession, writer.tag(129, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "syncAgentSessionMessages")
+      SyncAgentSessionMessagesInput.internalBinaryWrite(message.input.syncAgentSessionMessages, writer.tag(130, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getAgentSession")
+      GetAgentSessionInput.internalBinaryWrite(message.input.getAgentSession, writer.tag(131, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "updateBotAgent")
+      UpdateBotAgentInput.internalBinaryWrite(message.input.updateBotAgent, writer.tag(132, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "deleteBotAgent")
+      DeleteBotAgentInput.internalBinaryWrite(message.input.deleteBotAgent, writer.tag(133, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -13641,7 +14519,12 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { no: 125, name: "createDialogFolder", kind: "message", oneof: "result", T: () => CreateDialogFolderResult },
       { no: 126, name: "updateDialogFolder", kind: "message", oneof: "result", T: () => UpdateDialogFolderResult },
       { no: 127, name: "deleteDialogFolder", kind: "message", oneof: "result", T: () => DeleteDialogFolderResult },
-      { no: 128, name: "getSpace", kind: "message", oneof: "result", T: () => GetSpaceResult }
+      { no: 128, name: "getSpace", kind: "message", oneof: "result", T: () => GetSpaceResult },
+      { no: 129, name: "connectAgentSession", kind: "message", oneof: "result", T: () => ConnectAgentSessionResult },
+      { no: 130, name: "syncAgentSessionMessages", kind: "message", oneof: "result", T: () => SyncAgentSessionMessagesResult },
+      { no: 131, name: "getAgentSession", kind: "message", oneof: "result", T: () => GetAgentSessionResult },
+      { no: 132, name: "updateBotAgent", kind: "message", oneof: "result", T: () => UpdateBotAgentResult },
+      { no: 133, name: "deleteBotAgent", kind: "message", oneof: "result", T: () => DeleteBotAgentResult }
     ]);
   }
   create(value) {
@@ -14416,6 +15299,36 @@ class RpcResult$Type extends import_runtime4.MessageType {
             getSpace: GetSpaceResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getSpace)
           };
           break;
+        case 129:
+          message.result = {
+            oneofKind: "connectAgentSession",
+            connectAgentSession: ConnectAgentSessionResult.internalBinaryRead(reader, reader.uint32(), options, message.result.connectAgentSession)
+          };
+          break;
+        case 130:
+          message.result = {
+            oneofKind: "syncAgentSessionMessages",
+            syncAgentSessionMessages: SyncAgentSessionMessagesResult.internalBinaryRead(reader, reader.uint32(), options, message.result.syncAgentSessionMessages)
+          };
+          break;
+        case 131:
+          message.result = {
+            oneofKind: "getAgentSession",
+            getAgentSession: GetAgentSessionResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getAgentSession)
+          };
+          break;
+        case 132:
+          message.result = {
+            oneofKind: "updateBotAgent",
+            updateBotAgent: UpdateBotAgentResult.internalBinaryRead(reader, reader.uint32(), options, message.result.updateBotAgent)
+          };
+          break;
+        case 133:
+          message.result = {
+            oneofKind: "deleteBotAgent",
+            deleteBotAgent: DeleteBotAgentResult.internalBinaryRead(reader, reader.uint32(), options, message.result.deleteBotAgent)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -14682,6 +15595,16 @@ class RpcResult$Type extends import_runtime4.MessageType {
       DeleteDialogFolderResult.internalBinaryWrite(message.result.deleteDialogFolder, writer.tag(127, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.result.oneofKind === "getSpace")
       GetSpaceResult.internalBinaryWrite(message.result.getSpace, writer.tag(128, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "connectAgentSession")
+      ConnectAgentSessionResult.internalBinaryWrite(message.result.connectAgentSession, writer.tag(129, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "syncAgentSessionMessages")
+      SyncAgentSessionMessagesResult.internalBinaryWrite(message.result.syncAgentSessionMessages, writer.tag(130, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getAgentSession")
+      GetAgentSessionResult.internalBinaryWrite(message.result.getAgentSession, writer.tag(131, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "updateBotAgent")
+      UpdateBotAgentResult.internalBinaryWrite(message.result.updateBotAgent, writer.tag(132, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "deleteBotAgent")
+      DeleteBotAgentResult.internalBinaryWrite(message.result.deleteBotAgent, writer.tag(133, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -16149,7 +17072,8 @@ var GetGridHomeResult = new GetGridHomeResult$Type;
 class CreateGridRoomInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("CreateGridRoomInput", [
-      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 }
+      { no: 1, name: "space_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "microphone_enabled", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
@@ -16167,6 +17091,9 @@ class CreateGridRoomInput$Type extends import_runtime4.MessageType {
         case 1:
           message.spaceId = reader.int64().toBigInt();
           break;
+        case 2:
+          message.microphoneEnabled = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16181,6 +17108,8 @@ class CreateGridRoomInput$Type extends import_runtime4.MessageType {
   internalBinaryWrite(message, writer, options) {
     if (message.spaceId !== 0n)
       writer.tag(1, import_runtime.WireType.Varint).int64(message.spaceId);
+    if (message.microphoneEnabled !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.microphoneEnabled);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -16241,7 +17170,8 @@ var CreateGridRoomResult = new CreateGridRoomResult$Type;
 class JoinGridRoomInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("JoinGridRoomInput", [
-      { no: 1, name: "room_id", kind: "scalar", T: 3, L: 0 }
+      { no: 1, name: "room_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "microphone_enabled", kind: "scalar", opt: true, T: 8 }
     ]);
   }
   create(value) {
@@ -16259,6 +17189,9 @@ class JoinGridRoomInput$Type extends import_runtime4.MessageType {
         case 1:
           message.roomId = reader.int64().toBigInt();
           break;
+        case 2:
+          message.microphoneEnabled = reader.bool();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16273,6 +17206,8 @@ class JoinGridRoomInput$Type extends import_runtime4.MessageType {
   internalBinaryWrite(message, writer, options) {
     if (message.roomId !== 0n)
       writer.tag(1, import_runtime.WireType.Varint).int64(message.roomId);
+    if (message.microphoneEnabled !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.microphoneEnabled);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -18666,6 +19601,81 @@ class BotAgent$Type extends import_runtime4.MessageType {
 }
 var BotAgent = new BotAgent$Type;
 
+class BotAgentProfile$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotAgentProfile", [
+      { no: 1, name: "id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "name", kind: "scalar", T: 9 },
+      { no: 4, name: "handle", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "emoji", kind: "scalar", opt: true, T: 9 },
+      { no: 6, name: "description", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.id = 0n;
+    message.botUserId = 0n;
+    message.name = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.id = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.name = reader.string();
+          break;
+        case 4:
+          message.handle = reader.string();
+          break;
+        case 5:
+          message.emoji = reader.string();
+          break;
+        case 6:
+          message.description = 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.id !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.id);
+    if (message.botUserId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.name !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.handle !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.handle);
+    if (message.emoji !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.emoji);
+    if (message.description !== undefined)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.description);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotAgentProfile = new BotAgentProfile$Type;
+
 class CreateBotAgentInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("CreateBotAgentInput", [
@@ -18965,6 +19975,213 @@ class ListBotAgentsResult$Type extends import_runtime4.MessageType {
 }
 var ListBotAgentsResult = new ListBotAgentsResult$Type;
 
+class UpdateBotAgentInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateBotAgentInput", [
+      { no: 1, name: "agent_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "name", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "handle", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "emoji", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 6, name: "skill_key", kind: "scalar", opt: true, T: 9 },
+      { no: 7, name: "instructions", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.agentId = 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.agentId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        case 3:
+          message.handle = reader.string();
+          break;
+        case 4:
+          message.emoji = reader.string();
+          break;
+        case 5:
+          message.description = reader.string();
+          break;
+        case 6:
+          message.skillKey = reader.string();
+          break;
+        case 7:
+          message.instructions = 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.agentId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.agentId);
+    if (message.name !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.handle !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.handle);
+    if (message.emoji !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.emoji);
+    if (message.description !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.skillKey !== undefined)
+      writer.tag(6, import_runtime.WireType.LengthDelimited).string(message.skillKey);
+    if (message.instructions !== undefined)
+      writer.tag(7, import_runtime.WireType.LengthDelimited).string(message.instructions);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateBotAgentInput = new UpdateBotAgentInput$Type;
+
+class UpdateBotAgentResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateBotAgentResult", [
+      { no: 1, name: "agent", kind: "message", T: () => BotAgent }
+    ]);
+  }
+  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.agent = BotAgent.internalBinaryRead(reader, reader.uint32(), options, message.agent);
+          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.agent)
+      BotAgent.internalBinaryWrite(message.agent, 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 UpdateBotAgentResult = new UpdateBotAgentResult$Type;
+
+class DeleteBotAgentInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("DeleteBotAgentInput", [
+      { no: 1, name: "agent_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.agentId = 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.agentId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.agentId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.agentId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var DeleteBotAgentInput = new DeleteBotAgentInput$Type;
+
+class DeleteBotAgentResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("DeleteBotAgentResult", [
+      { no: 1, name: "agent_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.agentId = 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.agentId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.agentId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.agentId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var DeleteBotAgentResult = new DeleteBotAgentResult$Type;
+
 class ListBotsInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("ListBotsInput", []);
@@ -26388,7 +27605,8 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
       { no: 4, name: "emoji", kind: "scalar", opt: true, T: 9 },
       { no: 5, name: "is_public", kind: "scalar", T: 8 },
       { no: 6, name: "participants", kind: "message", repeat: 1, T: () => InputChatParticipant },
-      { no: 7, name: "reserved_chat_id", kind: "scalar", opt: true, T: 3, L: 0 }
+      { no: 7, name: "reserved_chat_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 8, name: "placeholder_title", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
@@ -26425,6 +27643,9 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
         case 7:
           message.reservedChatId = reader.int64().toBigInt();
           break;
+        case 8:
+          message.placeholderTitle = reader.string();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -26451,6 +27672,8 @@ class CreateChatInput$Type extends import_runtime4.MessageType {
       InputChatParticipant.internalBinaryWrite(message.participants[i], writer.tag(6, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.reservedChatId !== undefined)
       writer.tag(7, import_runtime.WireType.Varint).int64(message.reservedChatId);
+    if (message.placeholderTitle !== undefined)
+      writer.tag(8, import_runtime.WireType.LengthDelimited).string(message.placeholderTitle);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -31459,12 +32682,14 @@ class PeerBot$Type extends import_runtime4.MessageType {
   constructor() {
     super("PeerBot", [
       { no: 1, name: "bot", kind: "message", T: () => User },
-      { no: 2, name: "capabilities", kind: "message", repeat: 1, T: () => BotCapability }
+      { no: 2, name: "capabilities", kind: "message", repeat: 1, T: () => BotCapability },
+      { no: 3, name: "agents", kind: "message", repeat: 1, T: () => BotAgentProfile }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
     message.capabilities = [];
+    message.agents = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -31480,6 +32705,9 @@ class PeerBot$Type extends import_runtime4.MessageType {
         case 2:
           message.capabilities.push(BotCapability.internalBinaryRead(reader, reader.uint32(), options));
           break;
+        case 3:
+          message.agents.push(BotAgentProfile.internalBinaryRead(reader, reader.uint32(), options));
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -31496,6 +32724,8 @@ class PeerBot$Type extends import_runtime4.MessageType {
       User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     for (let i = 0;i < message.capabilities.length; i++)
       BotCapability.internalBinaryWrite(message.capabilities[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.agents.length; i++)
+      BotAgentProfile.internalBinaryWrite(message.agents[i], 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);
@@ -41177,12 +42407,17 @@ var rpcInputKindByMethod = {
   79: "requestBotChatSettings",
   80: "invokeBotChatSettingsItem",
   81: "answerBotChatSettings",
+  106: "createBotAgent",
+  107: "getBotAgent",
+  108: "listBotAgents",
   117: "createUpload",
   118: "saveUploadPart",
   119: "getUploadState",
   120: "finishUpload",
   121: "cancelUpload",
-  127: "getSpace"
+  127: "getSpace",
+  131: "updateBotAgent",
+  132: "deleteBotAgent"
 };
 var rpcResultKindByMethod = {
   0: undefined,
@@ -41241,12 +42476,17 @@ var rpcResultKindByMethod = {
   79: "requestBotChatSettings",
   80: "invokeBotChatSettingsItem",
   81: "answerBotChatSettings",
+  106: "createBotAgent",
+  107: "getBotAgent",
+  108: "listBotAgents",
   117: "createUpload",
   118: "saveUploadPart",
   119: "getUploadState",
   120: "finishUpload",
   121: "cancelUpload",
-  127: "getSpace"
+  127: "getSpace",
+  131: "updateBotAgent",
+  132: "deleteBotAgent"
 };
 
 // ../sdk/dist/sdk/logger.js
@@ -43593,6 +44833,15 @@ function toInputMedia(media) {
           }
         }
       };
+    case "voice":
+      return {
+        media: {
+          oneofKind: "voice",
+          voice: {
+            voiceId: asInlineId(media.voiceId, "voiceId")
+          }
+        }
+      };
   }
 }
 function normalizeHttpBaseUrl(baseUrl) {
@@ -59811,7 +61060,8 @@ async function downloadInlineMediaFromUrl(params) {
 
 // src/inline/message-formatting.ts
 var INLINE_FORMATTING_RULES = [
-  "Use Inline markdown.",
+  "Use Inline's supported Markdown: emphasis, inline or fenced code, links, headings, lists or checklists, quotes, tables, separators, and HTTP(S) images.",
+  "Do not rely on strikethrough, footnotes, or arbitrary HTML; unrecognized or ambiguous incomplete syntax remains visible text.",
   "Use ordinary Markdown tables for genuinely tabular data; never put a table in a fenced code block.",
   'For collapsible work, use <details open> followed by <summary>Title</summary>, body Markdown, and </details>; add kind="progress" to summary only while work is in progress.',
   "Use <footer>Attribution or brief metadata</footer> for a short message footer.",
@@ -60912,6 +62162,42 @@ async function getSpaceMembersWithUsers(params) {
   });
 }
 
+// src/inline/message-actions.ts
+var INLINE_AGENT_ACTION_PREFIX = "agent:";
+var INLINE_SYSTEM_ACTION_PREFIX = "system:";
+function resolveInlineMessageActionOwnership(actionId) {
+  if (actionId.startsWith(INLINE_AGENT_ACTION_PREFIX)) {
+    return { owner: "agent", explicit: true };
+  }
+  if (actionId.startsWith(INLINE_SYSTEM_ACTION_PREFIX)) {
+    return { owner: "system", explicit: true };
+  }
+  return { owner: "agent", explicit: false };
+}
+function buildInlineMessageActionId(owner, rowIndex, actionIndex) {
+  return `${owner}:${rowIndex + 1}:${actionIndex + 1}`;
+}
+function buildInlineAgentActionBody(params) {
+  return `Inline action button pressed on message #${String(params.targetMessageId)} by ${params.actor}.`;
+}
+function buildInlineAgentActionStructuredContext(params) {
+  return {
+    label: "Inline action button press",
+    source: "inline",
+    type: "message_action",
+    payload: {
+      event_kind: "message.action.invoke",
+      actor_user_id: String(params.actorUserId),
+      chat_id: String(params.chatId),
+      target_message_id: String(params.targetMessageId),
+      interaction_id: String(params.interactionId),
+      action_id: params.actionId,
+      callback_data_base64: params.callbackDataBase64,
+      ...params.callbackDataUtf8 ? { callback_data_utf8: params.callbackDataUtf8 } : {}
+    }
+  };
+}
+
 // src/inline/actions.ts
 var ACTION_GROUPS = [
   {
@@ -61769,11 +63055,11 @@ function resolveInlineInteractiveButtonsParam(params) {
   });
   return rows.length > 0 ? rows : undefined;
 }
-function toInlineMessageActions(rows) {
+function toInlineMessageActions(rows, owner) {
   return {
     rows: rows.map((row, rowIndex) => ({
       actions: row.map((button, buttonIndex) => ({
-        actionId: `btn_${rowIndex + 1}_${buttonIndex + 1}`,
+        actionId: buildInlineMessageActionId(owner, rowIndex, buttonIndex),
         text: button.text,
         action: button.kind === "callback" ? {
           oneofKind: "callback",
@@ -61790,10 +63076,11 @@ function toInlineMessageActions(rows) {
     }))
   };
 }
-function resolveInlineMessageActionsParam(params) {
+function resolveInlineMessageActionsParam(params, options) {
+  const owner = options?.owner ?? "agent";
   if (!Object.prototype.hasOwnProperty.call(params, "buttons")) {
     const interactiveRows = resolveInlineInteractiveButtonsParam(params);
-    return interactiveRows ? toInlineMessageActions(interactiveRows) : undefined;
+    return interactiveRows ? toInlineMessageActions(interactiveRows, owner) : undefined;
   }
   let rawButtons = params.buttons;
   if (typeof rawButtons === "string") {
@@ -61815,7 +63102,7 @@ function resolveInlineMessageActionsParam(params) {
     throw new Error("inline action: buttons must be an array of button rows");
   }
   const rows = normalizeReplyMarkupButtons(rawButtons);
-  return toInlineMessageActions(rows);
+  return toInlineMessageActions(rows, owner);
 }
 function normalizeChatId(raw) {
   const normalized = normalizeInlineTarget(raw) ?? raw.trim();
@@ -65410,6 +66697,44 @@ function redactInlineBotApiUrl(raw) {
   }
 }
 
+// src/inline/agent-specialization.ts
+function projectInlineAgentSessionKey(baseSessionKey, agentId, specialization) {
+  return agentId && specialization ? `${baseSessionKey}:inline-agent:${agentId}` : baseSessionKey;
+}
+function createInlineAgentSpecializationResolver(params) {
+  const ttlMs = params.ttlMs ?? 60000;
+  const maxEntries = params.maxEntries ?? 100;
+  const now = params.now ?? Date.now;
+  const cache = new Map;
+  const loads = new Map;
+  return {
+    async resolve(agentId) {
+      const cached3 = cache.get(agentId);
+      if (cached3 && cached3.expiresAt > now())
+        return cached3.value;
+      const existingLoad = loads.get(agentId);
+      if (existingLoad)
+        return existingLoad;
+      const load = params.fetchAgent(agentId).then((value) => {
+        cache.delete(agentId);
+        cache.set(agentId, { value, expiresAt: now() + ttlMs });
+        while (cache.size > maxEntries) {
+          const oldest = cache.keys().next().value;
+          if (oldest === undefined)
+            break;
+          cache.delete(oldest);
+        }
+        return value;
+      }).finally(() => {
+        if (loads.get(agentId) === load)
+          loads.delete(agentId);
+      });
+      loads.set(agentId, load);
+      return load;
+    }
+  };
+}
+
 // src/inline/sender-profile-cache.ts
 var DEFAULT_PROFILE_TTL_MS = 10 * 60000;
 var DEFAULT_MAX_PROFILES = 5000;
@@ -65443,7 +66768,8 @@ class InlineSenderProfileCache {
     const name = [cached3.firstName, cached3.lastName].filter(Boolean).join(" ").trim();
     return {
       ...name ? { name } : {},
-      ...cached3.username ? { username: cached3.username } : {}
+      ...cached3.username ? { username: cached3.username } : {},
+      ...cached3.bot != null ? { bot: cached3.bot } : {}
     };
   }
   remember(users) {
@@ -65457,6 +66783,7 @@ class InlineSenderProfileCache {
         ...readProfileField(user.firstName, previous?.firstName, "firstName"),
         ...readProfileField(user.lastName, previous?.lastName, "lastName"),
         ...readProfileField(normalizeInlineUsername(user.username), previous?.username, "username"),
+        ...readBooleanProfileField(user.bot, previous?.bot, "bot"),
         expiresAt
       };
       this.profiles.delete(userId);
@@ -65476,21 +66803,34 @@ class InlineSenderProfileCache {
     }
   }
   async resolve(params) {
-    await this.hydrateChat(params.chatId);
+    return (await this.resolveWithProvenance(params)).profile;
+  }
+  async resolveWithProvenance(params) {
+    const participantHydrated = await this.hydrateChatResult(params.chatId);
     const participant = this.get(params.userId);
-    if (hasDisplayIdentity(participant))
-      return participant;
-    await this.hydrateDirectory();
+    if (hasDisplayIdentity(participant)) {
+      return {
+        profile: participant,
+        provenanceVerified: participantHydrated || participant.bot != null
+      };
+    }
+    const directoryHydrated = await this.hydrateDirectoryResult();
     const resolved = this.get(params.userId);
-    return hasDisplayIdentity(resolved) ? resolved : undefined;
+    return {
+      ...hasDisplayIdentity(resolved) ? { profile: resolved } : {},
+      provenanceVerified: directoryHydrated && (participantHydrated || hasDisplayIdentity(resolved))
+    };
   }
   async hydrateChat(chatId) {
+    await this.hydrateChatResult(chatId);
+  }
+  async hydrateChatResult(chatId) {
     const chatKey = String(chatId);
     const hydratedUntil = this.hydratedChats.get(chatKey) ?? 0;
     if (hydratedUntil > this.now()) {
       this.hydratedChats.delete(chatKey);
       this.hydratedChats.set(chatKey, hydratedUntil);
-      return;
+      return true;
     }
     this.hydratedChats.delete(chatKey);
     const existing = this.participantFetches.get(chatKey);
@@ -65506,27 +66846,38 @@ class InlineSenderProfileCache {
           break;
         this.hydratedChats.delete(oldest);
       }
-    }).catch((error51) => this.options.onError?.("getChatParticipants", error51)).finally(() => this.participantFetches.delete(chatKey));
+      return true;
+    }).catch((error51) => {
+      this.options.onError?.("getChatParticipants", error51);
+      return false;
+    }).finally(() => this.participantFetches.delete(chatKey));
     this.participantFetches.set(chatKey, run);
-    await run;
+    return await run;
   }
   async hydrateDirectory() {
+    await this.hydrateDirectoryResult();
+  }
+  async hydrateDirectoryResult() {
     if (this.directoryExpiresAt > this.now())
-      return;
+      return true;
     if (this.directoryFetch)
       return this.directoryFetch;
     const run = this.options.fetchDirectoryUsers().then((users) => {
       this.remember(users);
       this.directoryExpiresAt = this.now() + this.ttlMs;
-    }).catch((error51) => this.options.onError?.("getChats", error51)).finally(() => {
+      return true;
+    }).catch((error51) => {
+      this.options.onError?.("getChats", error51);
+      return false;
+    }).finally(() => {
       this.directoryFetch = null;
     });
     this.directoryFetch = run;
-    await run;
+    return await run;
   }
 }
 function hasDisplayIdentity(profile) {
-  return Boolean(profile?.name || profile?.username);
+  return Boolean(profile?.name || profile?.username || profile?.bot != null);
 }
 function normalizeInlineUsername(value) {
   const username = value?.trim().replace(/^@+/u, "");
@@ -65536,6 +66887,10 @@ function readProfileField(value, previous, key) {
   const resolved = value?.trim() || previous;
   return resolved ? { [key]: resolved } : {};
 }
+function readBooleanProfileField(value, previous, key) {
+  const resolved = value ?? previous;
+  return resolved == null ? {} : { [key]: resolved };
+}
 
 // src/inline/command-ui.ts
 var MODEL_LABEL_LIMIT = 38;
@@ -66772,8 +68127,8 @@ async function dispatchInlineReplyWithSessionInitRetry(params) {
   let retries = 0;
   while (true) {
     try {
-      await params.run();
-      return retries;
+      const result = await params.run();
+      return { result, retries };
     } catch (error51) {
       const delayMs = INLINE_REPLY_SESSION_INIT_RETRY_DELAYS_MS[retries];
       if (delayMs == null || !params.shouldRetry() || !INLINE_REPLY_SESSION_INIT_CONFLICT_RE.test(String(error51))) {
@@ -66785,6 +68140,12 @@ async function dispatchInlineReplyWithSessionInitRetry(params) {
     }
   }
 }
+function normalizeInlineDispatchResult(value) {
+  return isRecord6(value) ? value : {};
+}
+function inlineReplyDeliveryResult(visibleReplySent) {
+  return visibleReplySent ? { visibleReplySent: true } : { visibleReplySent: false, suppression: { reason: "no_visible_result" } };
+}
 
 class OpenClawBotChatSettingsMutationError extends Error {
 }
@@ -68097,7 +69458,8 @@ function normalizeReplyMarkupButtonsWith(raw, options) {
   }
   return rows;
 }
-function resolveInlineReplyActions(payload) {
+function resolveInlineReplyActions(payload, options) {
+  const owner = options?.owner ?? "agent";
   const channelData = isRecord6(payload.channelData) ? payload.channelData : undefined;
   const inlineData = channelData && isRecord6(channelData.inline) ? channelData.inline : undefined;
   const telegramData = channelData && isRecord6(channelData.telegram) ? channelData.telegram : undefined;
@@ -68116,13 +69478,13 @@ function resolveInlineReplyActions(payload) {
     hasExplicitButtons = true;
   }
   if (!hasExplicitButtons) {
-    return resolveInlineMessageActionsParam(payload);
+    return resolveInlineMessageActionsParam(payload, { owner });
   }
   const rows = normalizeReplyMarkupButtonsWith(rawButtons, mapCallbackData ? { mapCallbackData } : undefined);
   return {
     rows: rows.map((row, rowIndex) => ({
       actions: row.map((button, buttonIndex) => ({
-        actionId: `btn_${rowIndex + 1}_${buttonIndex + 1}`,
+        actionId: buildInlineMessageActionId(owner, rowIndex, buttonIndex),
         text: button.text,
         action: button.kind === "callback" ? {
           oneofKind: "callback",
@@ -68591,6 +69953,8 @@ function buildInlineUntrustedStructuredContext(params) {
   append("Current Inline message entities", "current_message_entities", params.currentEntityText);
   append("Recent Inline media/attachments", "recent_media_attachments", params.historyAttachmentText);
   append("Recent Inline message entities", "recent_message_entities", params.historyEntityText);
+  if (params.actionContext)
+    entries.push(params.actionContext);
   return entries;
 }
 function resolveInlineMediaMaxBytes(params) {
@@ -69059,6 +70423,25 @@ async function monitorInlineProvider(params) {
   const botMessageIdsByChat = new Map;
   const seenInboundMessageInstances = new Map;
   const groupPendingHistories = new Map;
+  const inlineAgentResolver = createInlineAgentSpecializationResolver({
+    fetchAgent: async (agentId) => {
+      const result = await callInlineBotApi({
+        baseUrl: botApiBaseUrl,
+        token,
+        methodName: "getAgent",
+        method: "GET",
+        query: { agent_id: agentId }
+      });
+      const agent = result.agent;
+      if (!agent?.name)
+        return null;
+      return {
+        name: agent.name,
+        ...agent.skill_key ? { skillKey: agent.skill_key } : {},
+        ...agent.instructions ? { instructions: agent.instructions } : {}
+      };
+    }
+  });
   const inboundMediaMaxBytes = resolveInlineMediaMaxBytes({ cfg, account });
   const hydrateChatParticipants = (chatId) => senderProfilesById.hydrateChat(chatId);
   const resolveInlineSystemEventContext = async (params2) => {
@@ -69395,12 +70778,26 @@ async function monitorInlineProvider(params) {
       defaultLimit: account.config.replyThreadParentHistoryLimit ?? inlineThreadDefaults.replyThreadParentHistoryLimit ?? DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT
     }) : DEFAULT_REPLY_THREAD_PARENT_HISTORY_LIMIT;
     const senderId = String(msg.fromId);
-    const senderProfile = await senderProfilesById.resolve({ userId: senderId, chatId });
+    const senderResolution = await senderProfilesById.resolveWithProvenance({ userId: senderId, chatId });
+    const senderProfile = senderResolution.profile;
+    const explicitlyMentionsThisBot = collectInlineMentionedUserIds(currentContent).includes(String(meId));
+    if (!senderResolution.provenanceVerified && !explicitlyMentionsThisBot) {
+      runtime.log?.(`inline: observe sender with unverified bot provenance chat=${String(chatId)} sender=${senderId}`);
+      return;
+    }
+    if (senderProfile?.bot === true && !explicitlyMentionsThisBot) {
+      runtime.log?.(`inline: observe ambient bot message chat=${String(chatId)} sender=${senderId}`);
+      return;
+    }
     const senderUsername = senderProfile?.username;
     const senderName = isGroup ? senderProfile?.name : resolveInlineDirectSenderName({ profileName: senderProfile?.name, chatTitle: chatInfo.title, senderId });
+    const callbackActionOwnership = callbackActionEvent ? resolveInlineMessageActionOwnership(callbackActionEvent.actionId) : null;
     if (callbackActionEvent) {
       const actor = senderUsername != null && senderUsername.length > 0 ? `@${senderUsername}` : senderName ?? "the sender";
-      rawBody = `${actor} pressed "${callbackActionEvent.actionId}" on message #${String(callbackActionEvent.targetMessageId)}`;
+      rawBody = buildInlineAgentActionBody({
+        actor,
+        targetMessageId: callbackActionEvent.targetMessageId
+      });
     }
     const dmPolicy = account.config.dmPolicy ?? "pairing";
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
@@ -69425,7 +70822,8 @@ async function monitorInlineProvider(params) {
     const effectiveAllowFrom = [...configAllowFrom, ...storeAllowList].filter(Boolean);
     const effectiveGroupAllowFrom = groupSenderAllowlist.expanded.filter(Boolean);
     const effectiveGroupCommandAllowFrom = effectiveGroupAllowFrom;
-    const callbackCommandBody = callbackActionEvent ? resolveCallbackCommandBodyFromActionData({
+    const shouldRouteCallbackThroughSystemHandlers = callbackActionEvent != null && (callbackActionOwnership?.owner === "system" || callbackActionOwnership?.explicit === false);
+    const callbackCommandBody = callbackActionEvent && shouldRouteCallbackThroughSystemHandlers ? resolveCallbackCommandBodyFromActionData({
       data: callbackActionEvent.data,
       ...botUsername ? { botUsername } : {}
     }) : undefined;
@@ -69571,7 +70969,8 @@ async function monitorInlineProvider(params) {
                     channel: CHANNEL_ID,
                     idLine: `Your Inline user id: ${senderId}`,
                     code
-                  })
+                  }),
+                  parseMarkdown: account.config.parseMarkdown ?? true
                 });
                 publishStatus({ lastOutboundAt: Date.now() });
               } catch (err) {
@@ -69776,7 +71175,7 @@ async function monitorInlineProvider(params) {
           getCurrentConversationBinding: async () => null
         });
         const resultRecord = result;
-        const actions = resolveInlineReplyActions(resultRecord);
+        const actions = resolveInlineReplyActions(resultRecord, { owner: "system" });
         const text = typeof result.text === "string" ? sanitizeInlineDeliveryText(result.text) : "";
         if (text || actions) {
           let delivered = false;
@@ -69817,7 +71216,7 @@ async function monitorInlineProvider(params) {
         return;
       }
     }
-    const commandsPageCallback = callbackActionEvent ? parseInlineCommandsPageCallback(callbackDataToUtf8(callbackActionEvent.data)) : null;
+    const commandsPageCallback = callbackActionEvent && shouldRouteCallbackThroughSystemHandlers ? parseInlineCommandsPageCallback(callbackDataToUtf8(callbackActionEvent.data)) : null;
     if (shouldEditCallbackTargetInPlace && callbackActionEvent && commandsPageCallback) {
       if (commandsPageCallback.page === "noop")
         return;
@@ -69836,7 +71235,7 @@ async function monitorInlineProvider(params) {
           totalPages: paginated.totalPages,
           agentId
         }) ?? { inline: { buttons: [] } }
-      }) ?? { rows: [] };
+      }, { owner: "system" }) ?? { rows: [] };
       const text = sanitizeInlineDeliveryText(paginated.text);
       try {
         const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
@@ -69878,7 +71277,7 @@ async function monitorInlineProvider(params) {
             buttons: nativeCommandMenu.buttons
           }
         }
-      });
+      }, { owner: "system" });
       const menuText = sanitizeInlineDeliveryText(nativeCommandMenu.title);
       let deliveredNativeMenu = false;
       if (shouldEditCallbackTargetInPlace && callbackActionEvent) {
@@ -69905,7 +71304,8 @@ async function monitorInlineProvider(params) {
         const sent = await client.sendMessage({
           chatId,
           text: menuText,
-          ...menuActions ? { actions: menuActions } : {}
+          ...menuActions ? { actions: menuActions } : {},
+          parseMarkdown
         });
         rememberSentBotMessage({ chatId, messageId: sent.messageId, replyThreadContext });
       }
@@ -69915,7 +71315,7 @@ async function monitorInlineProvider(params) {
       });
       return;
     }
-    const modelPickerCallbackData = callbackActionEvent ? callbackDataToUtf8(callbackActionEvent.data) : undefined;
+    const modelPickerCallbackData = callbackActionEvent && shouldRouteCallbackThroughSystemHandlers ? callbackDataToUtf8(callbackActionEvent.data) : undefined;
     const modelPickerCallback = modelPickerCallbackData ? parseInlineModelPickerCallback(modelPickerCallbackData) : null;
     if (shouldEditCallbackTargetInPlace && callbackActionEvent && modelPickerCallback?.type === "select") {
       const deliverModelPickerEdit = async (text, buttons) => {
@@ -69926,7 +71326,7 @@ async function monitorInlineProvider(params) {
               buttons
             }
           }
-        }) ?? { rows: [] };
+        }, { owner: "system" }) ?? { rows: [] };
         try {
           const result = await client.invokeRaw(Method.EDIT_MESSAGE, {
             oneofKind: "editMessage",
@@ -70006,6 +71406,10 @@ This model will be used for your next message.`, []);
       });
       return;
     }
+    if (callbackActionEvent && callbackActionOwnership?.owner === "system" && callbackActionOwnership.explicit && callbackCommandBody == null) {
+      runtime.log?.(`inline: drop unhandled system action ${callbackActionEvent.actionId} ` + `message=${String(callbackActionEvent.targetMessageId)}`);
+      return;
+    }
     let deliveryReplyThreadContext = replyThreadContext;
     const explicitReplyThreadIntent = replyThreadsEnabled && !deliveryReplyThreadContext && hasExplicitInlineReplyThreadIntent(rawBody);
     const shouldCreateDeliveryThread = replyThreadsEnabled && !deliveryReplyThreadContext && shouldCreateInlineReplyThreadDelivery({
@@ -70150,27 +71554,13 @@ This model will be used for your next message.`, []);
     let inlineAgent = null;
     if (inlineAgentId) {
       try {
-        const result = await callInlineBotApi({
-          baseUrl: botApiBaseUrl,
-          token,
-          methodName: "getAgent",
-          method: "GET",
-          query: { agent_id: inlineAgentId }
-        });
-        const agent = result.agent;
-        if (agent?.name) {
-          inlineAgent = {
-            name: agent.name,
-            ...agent.skill_key ? { skillKey: agent.skill_key } : {},
-            ...agent.instructions ? { instructions: agent.instructions } : {}
-          };
-        }
+        inlineAgent = await inlineAgentResolver.resolve(inlineAgentId);
       } catch (error51) {
         runtime.error?.(`inline: failed to resolve mentioned Agent ${inlineAgentId}: ${String(error51)}`);
       }
     }
     const baseDeliverySessionKey = deliveryReplyThreadContext && isGroup ? buildInlineReplyThreadSessionKey(route.sessionKey, deliveryReplyThreadContext.childChatId) : route.sessionKey;
-    const deliverySessionKey = inlineAgentId ? `${baseDeliverySessionKey}:inline-agent:${inlineAgentId}` : baseDeliverySessionKey;
+    const deliverySessionKey = projectInlineAgentSessionKey(baseDeliverySessionKey, inlineAgentId, inlineAgent);
     const groupHistoryKey = isGroup ? deliveryReplyThreadContext ? deliverySessionKey : route.sessionKey : null;
     const inboundMedia = await resolveInlineInboundMedia({
       core: core3,
@@ -70195,12 +71585,24 @@ This model will be used for your next message.`, []);
       pendingEntries: groupPendingHistories.get(groupHistoryKey) ?? [],
       limit: historyLimit
     }) : effectiveHistoryContext.inboundHistory;
+    const actionCallbackDataUtf8 = callbackActionEvent ? callbackDataToUtf8(callbackActionEvent.data) : undefined;
     const untrustedStructuredContext = buildInlineUntrustedStructuredContext({
       currentAttachmentText,
       currentEntityText: currentEntityTextForAgent,
       currentBody,
       historyAttachmentText: effectiveHistoryContext.attachmentText,
-      historyEntityText: effectiveHistoryContext.entityText
+      historyEntityText: effectiveHistoryContext.entityText,
+      ...callbackActionEvent ? {
+        actionContext: buildInlineAgentActionStructuredContext({
+          actorUserId: msg.fromId,
+          chatId,
+          targetMessageId: callbackActionEvent.targetMessageId,
+          interactionId: callbackActionEvent.interactionId,
+          actionId: callbackActionEvent.actionId,
+          callbackDataBase64: callbackDataToBase64(callbackActionEvent.data),
+          ...actionCallbackDataUtf8 ? { callbackDataUtf8: actionCallbackDataUtf8 } : {}
+        })
+      } : {}
     });
     const inboundEventKind = classifyChannelInboundEvent({
       conversation: { kind: isGroup ? "group" : "direct" },
@@ -70420,7 +71822,8 @@ This model will be used for your next message.`, []);
           const sent = await client.sendMessage({
             chatId: deliveryChatId,
             text,
-            sendMode: "silent"
+            sendMode: "silent",
+            parseMarkdown
           });
           if (sent.messageId == null) {
             throw new Error("inline progress placeholder: sendMessage returned no messageId");
@@ -70437,7 +71840,8 @@ This model will be used for your next message.`, []);
             editMessage: {
               messageId: progressState.messageId,
               peerId: buildChatPeer3(deliveryChatId),
-              text
+              text,
+              parseMarkdown
             }
           });
           if (result.oneofKind !== "editMessage") {
@@ -70945,16 +72349,16 @@ This model will be used for your next message.`, []);
     };
     try {
       let delivered = false;
-      let deliveryAttempted = false;
       let skippedNonSilent = false;
       let skippedSilently = false;
       let failedNonSilent = false;
       let dispatchError = null;
+      let dispatchResult = {};
       let streamedFinalEditRejected = false;
       let undeliveredFinalText = "";
       let undeliveredFinalActions;
       try {
-        const sessionInitRetries = await dispatchInlineReplyWithSessionInitRetry({
+        const dispatch = await dispatchInlineReplyWithSessionInitRetry({
           shouldRetry: () => !delivered && !skippedNonSilent && !failedNonSilent,
           onRetry: (retry, delayMs) => {
             log?.warn(`[${account.accountId}] AGENT_DISPATCH_TRACE phase=session_init_conflict_retry ` + `retry=${retry} delay_ms=${delayMs}`);
@@ -70966,14 +72370,19 @@ This model will be used for your next message.`, []);
               ...dispatcherPipelineOptions,
               ...buildInlineTypingDispatcherOptions(typingCallbacks),
               deliver: async (payload, info) => {
-                deliveryAttempted = true;
+                let payloadVisible = false;
+                const markPayloadVisible = () => {
+                  delivered = true;
+                  payloadVisible = true;
+                };
+                const finishPayload = () => inlineReplyDeliveryResult(payloadVisible);
                 const presenceSignal = resolveInlineBotPresenceSignal(payload);
                 if (presenceSignal) {
                   botPresenceLifecycle.express(presenceSignal);
                 }
                 const visiblePayload = resolveInlineChatVisibleReplyPayload(payload);
                 if (!visiblePayload)
-                  return;
+                  return finishPayload();
                 await cleanupInlineProgressPlaceholder();
                 const payloadRecord = visiblePayload;
                 const rawText = resolveInlineInteractiveTextFallback({
@@ -71017,7 +72426,7 @@ This model will be used for your next message.`, []);
                       ...includeActions && outboundActions !== undefined ? { actions: outboundActions } : {},
                       parseMarkdown
                     });
-                    delivered = true;
+                    markPayloadVisible();
                     try {
                       rememberSent(sent.messageId);
                     } catch (error51) {
@@ -71026,7 +72435,7 @@ This model will be used for your next message.`, []);
                   } catch (error51) {
                     if (!isInlineSendOutcomeUnknown(error51))
                       throw error51;
-                    delivered = true;
+                    markPayloadVisible();
                     runtime.error?.(`inline text delivery outcome is unknown; suppressing duplicate (${String(error51)})`);
                   }
                 };
@@ -71084,12 +72493,12 @@ This model will be used for your next message.`, []);
                   if (shouldEditCallbackTargetInPlace && editStreamState.messageId != null) {
                     const callbackEditActions = outboundActions ?? { rows: [] };
                     if (!outboundText.trim() && outboundActions === undefined) {
-                      return;
+                      return finishPayload();
                     }
                     await updateStreamedMessage(outboundText, callbackEditActions);
-                    delivered = true;
+                    markPayloadVisible();
                     publishStatus({ lastOutboundAt: Date.now() });
-                    return;
+                    return finishPayload();
                   }
                   if (streamViaEditMessage && infoKind === "final" && finalDeliveredForCurrentAssistantMessage && editStreamState.messageId != null) {
                     await resetEditStreamForAssistantMessage();
@@ -71099,25 +72508,26 @@ This model will be used for your next message.`, []);
                       editStreamState.finalTextAccumulator += outboundText;
                     }
                     if (!editStreamState.finalTextAccumulator.trim() && outboundActions === undefined) {
-                      return;
+                      markPayloadVisible();
+                      return finishPayload();
                     }
                     await updateStreamedMessage(editStreamState.finalTextAccumulator, outboundActions);
-                    delivered = true;
+                    markPayloadVisible();
                     if (infoKind === "final") {
                       finalDeliveredForCurrentAssistantMessage = true;
                     }
                     publishStatus({ lastOutboundAt: Date.now() });
-                    return;
+                    return finishPayload();
                   }
                   if (!outboundText.trim())
-                    return;
+                    return finishPayload();
                   if (streamViaEditMessage && editStreamState.initialSendMayHaveLanded) {
-                    delivered = true;
-                    return;
+                    markPayloadVisible();
+                    return finishPayload();
                   }
                   await sendTextFallback(outboundText, true, true);
                   publishStatus({ lastOutboundAt: Date.now() });
-                  return;
+                  return finishPayload();
                 }
                 if (streamViaEditMessage && editStreamState.messageId != null && outboundText.trim()) {
                   await updateStreamedMessage(outboundText, outboundActions);
@@ -71133,7 +72543,7 @@ This model will be used for your next message.`, []);
                   if (partialDelivery) {
                     const result = await partialDelivery;
                     if (result.sent) {
-                      delivered = true;
+                      markPayloadVisible();
                       if (result.commitOutcomeUnknown) {
                         continue;
                       }
@@ -71193,7 +72603,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
                       ...shouldAttachActionsToMedia && outboundActions !== undefined ? { actions: outboundActions } : {},
                       ...caption ? { parseMarkdown } : {}
                     });
-                    delivered = true;
+                    markPayloadVisible();
                     try {
                       rememberSent(sent.messageId);
                     } catch (error51) {
@@ -71201,7 +72611,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
                     }
                   } catch (error51) {
                     if (isInlineSendOutcomeUnknown(error51)) {
-                      delivered = true;
+                      markPayloadVisible();
                       runtime.error?.(`inline media delivery outcome is unknown; suppressing duplicate (${String(error51)})`);
                       continue;
                     }
@@ -71213,6 +72623,7 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
                   }
                 }
                 publishStatus({ lastOutboundAt: Date.now() });
+                return finishPayload();
               },
               onSkip: (_payload, info) => {
                 if (info?.reason === "silent") {
@@ -71230,8 +72641,9 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
             replyOptions
           })
         });
-        if (sessionInitRetries > 0) {
-          log?.info(`[${account.accountId}] AGENT_DISPATCH_TRACE phase=session_init_conflict_recovered ` + `retries=${sessionInitRetries}`);
+        dispatchResult = normalizeInlineDispatchResult(dispatch.result);
+        if (dispatch.retries > 0) {
+          log?.info(`[${account.accountId}] AGENT_DISPATCH_TRACE phase=session_init_conflict_recovered ` + `retries=${dispatch.retries}`);
         }
       } catch (error51) {
         dispatchError = error51;
@@ -71247,7 +72659,12 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
       if (!delivered && streamViaEditMessage && (editStreamState.messageId != null || editStreamState.initialSendMayHaveLanded) && !streamedFinalEditRejected) {
         delivered = true;
       }
-      if (!delivered && !skippedSilently && (!deliveryAttempted || dispatchError != null || skippedNonSilent || failedNonSilent)) {
+      const hostHandledTurn = dispatchResult.queuedFinal === true || dispatchResult.observedReplyDelivery === true || dispatchResult.noVisibleReplyFallbackDelivered === true;
+      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 && (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({
@@ -71336,7 +72753,8 @@ Attachment: ${mediaUrl}` : `Attachment: ${mediaUrl}`;
         return;
       client.sendMessage({
         chatId,
-        text: INLINE_DEBOUNCE_ERROR_FALLBACK
+        text: INLINE_DEBOUNCE_ERROR_FALLBACK,
+        parseMarkdown: account.config.parseMarkdown ?? true
       }).then(() => {
         publishStatus({ lastOutboundAt: Date.now() });
       }).catch((sendErr) => {
@@ -74550,7 +75968,7 @@ var inlineChannelPlugin = {
       "- Inline discovery: use `channel-list` to discover available chats and users. Use `scope: groups|peers|all` when helpful, and reuse returned `target` values.",
       "- Inline markdown links: in visible replies, link returned users as `[@name](inline://user?id=<userId>)` and returned chats/threads as `[title](inline://chat?id=<chatId>)` or `[title](inline://thread?id=<chatId>)`. Use `target` values only for tool calls.",
       ...supportsInlineMessageButtonsForConfig(cfg, accountId ?? null) ? [
-        "- Prefer Inline buttons/selects for 2-5 discrete choices or parameter picks instead of asking the user to type one. Use `presentation` blocks for shared buttons/selects, or `buttons` rows with `callback_data` for callbacks and `copy_text`/`copyText` for copy buttons. For quick button feedback, JSON `callback_data` can include `callbackToast`/`toast`."
+        "- Prefer Inline buttons/selects for 2-5 discrete choices or parameter picks instead of asking the user to type one. Use `presentation` blocks for shared buttons/selects, or `buttons` rows with `callback_data` for callbacks and `copy_text`/`copyText` for copy buttons. For quick button feedback, JSON `callback_data` can include `callbackToast`/`toast`. A callback turn identifies the source message; your normal response replaces that message, omitting buttons clears them, and returning buttons replaces them."
       ] : [],
       ...supportsInlineReactionsForConfig(cfg, accountId ?? null) ? [
         "- Inline reactions: pass `messageId` for `react` when you have it; on inbound turns, the current inbound message id can be used as fallback."
@@ -74936,5 +76354,5 @@ export {
   inlineChannelPlugin
 };
 
-//# debugId=D5786502DB64433864756E2164756E21
+//# debugId=46E778A45E078CF864756E2164756E21
 //# sourceMappingURL=channel-plugin-api.js.map