@inline-openclaw/inline 0.0.58 → 0.0.59

package/dist/approval-handler.runtime.js

@@ -5705,6 +5705,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) {
@@ -5826,11 +5827,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";
@@ -5960,6 +6006,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) {
@@ -9511,7 +9562,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) {
@@ -9602,6 +9654,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")
@@ -9662,6 +9717,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);
@@ -9670,6 +9727,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", [
@@ -10574,6 +10695,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", [
@@ -12446,7 +13279,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) {
@@ -13221,6 +14059,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")
@@ -13487,6 +14355,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);
@@ -13624,7 +14502,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) {
@@ -14399,6 +15282,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")
@@ -14665,6 +15578,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);
@@ -16132,7 +17055,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) {
@@ -16150,6 +17074,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")
@@ -16164,6 +17091,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);
@@ -16224,7 +17153,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) {
@@ -16242,6 +17172,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")
@@ -16256,6 +17189,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);
@@ -18649,6 +19584,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", [
@@ -18948,6 +19958,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", []);
@@ -26371,7 +27588,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) {
@@ -26408,6 +27626,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")
@@ -26434,6 +27655,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);
@@ -31442,12 +32665,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;
@@ -31463,6 +32688,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")
@@ -31479,6 +32707,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);
@@ -41160,12 +42390,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,
@@ -41224,12 +42459,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
@@ -43576,6 +44816,15 @@ function toInputMedia(media) {
           }
         }
       };
+    case "voice":
+      return {
+        media: {
+          oneofKind: "voice",
+          voice: {
+            voiceId: asInlineId(media.voiceId, "voiceId")
+          }
+        }
+      };
   }
 }
 function normalizeHttpBaseUrl(baseUrl) {
@@ -59466,7 +60715,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.",
@@ -60720,6 +61970,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 = [
   {
@@ -61577,11 +62863,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",
@@ -61598,10 +62884,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") {
@@ -61623,7 +62910,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();
@@ -65171,7 +66458,7 @@ function buildInlineApprovalActions(view) {
       callback_data: action.command
     }))
   ];
-  return resolveInlineMessageActionsParam({ buttons });
+  return resolveInlineMessageActionsParam({ buttons }, { owner: "system" });
 }
 function buildPendingPayload(params) {
   const execView = params.view.approvalKind === "exec" ? params.view : null;
@@ -65333,5 +66620,5 @@ export {
   inlineApprovalNativeRuntime
 };
 
-//# debugId=852E7EF19A0D965E64756E2164756E21
+//# debugId=08750D122B834F1564756E2164756E21
 //# sourceMappingURL=approval-handler.runtime.js.map