@inline-openclaw/inline 0.0.58 → 0.0.60

package/dist/runtime-register-api.js

@@ -5695,6 +5695,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) {
@@ -5816,11 +5817,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";
@@ -5950,6 +5996,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) {
@@ -9501,7 +9552,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) {
@@ -9592,6 +9644,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")
@@ -9652,6 +9707,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);
@@ -9660,6 +9717,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", [
@@ -10564,6 +10685,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", [
@@ -12436,7 +13269,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) {
@@ -13211,6 +14049,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")
@@ -13477,6 +14345,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);
@@ -13614,7 +14492,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) {
@@ -14389,6 +15272,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")
@@ -14655,6 +15568,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);
@@ -16122,7 +17045,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) {
@@ -16140,6 +17064,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")
@@ -16154,6 +17081,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);
@@ -16214,7 +17143,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) {
@@ -16232,6 +17162,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")
@@ -16246,6 +17179,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);
@@ -18639,6 +19574,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", [
@@ -18938,6 +19948,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", []);
@@ -26361,7 +27578,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) {
@@ -26398,6 +27616,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")
@@ -26424,6 +27645,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);
@@ -31432,12 +32655,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;
@@ -31453,6 +32678,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")
@@ -31469,6 +32697,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);
@@ -41150,12 +42380,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,
@@ -41214,12 +42449,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
@@ -43566,6 +44806,15 @@ function toInputMedia(media) {
           }
         }
       };
+    case "voice":
+      return {
+        media: {
+          oneofKind: "voice",
+          voice: {
+            voiceId: asInlineId(media.voiceId, "voiceId")
+          }
+        }
+      };
   }
 }
 function normalizeHttpBaseUrl(baseUrl) {
@@ -60155,7 +61404,8 @@ function createInlineMembersTool(ctx) {
 
 // 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.",
@@ -61902,8 +63152,8 @@ var parameters = {
   type: "object",
   additionalProperties: false,
   properties: {
-    action: { type: "string", enum: ["create", "get", "list"] },
-    agent_id: { type: "number", description: "Globally unique Inline Agent ID for get." },
+    action: { type: "string", enum: ["create", "get", "list", "update", "delete"] },
+    agent_id: { type: "number", description: "Globally unique Inline Agent ID for get, update, or delete." },
     name: { type: "string", description: "Required Agent name for create." },
     handle: { type: "string" },
     emoji: { type: "string" },
@@ -61920,7 +63170,7 @@ function createInlineAgentsTool(ctx) {
   return {
     name: "inline_agents",
     label: "Inline Agents",
-    description: "Create, inspect, and list named Inline Agents backed by this bot.",
+    description: "Create, inspect, list, update, and delete named Inline Agents backed by this bot.",
     parameters,
     execute: async (_toolCallId, rawArgs) => {
       const args = rawArgs ?? {};
@@ -61964,6 +63214,46 @@ function createInlineAgentsTool(ctx) {
         });
         return jsonResult({ ok: true, action: args.action, accountId: account.accountId, ...result2 });
       }
+      if (args.action === "update") {
+        if (!Number.isSafeInteger(args.agent_id) || Number(args.agent_id) <= 0) {
+          throw new Error("inline_agents: positive `agent_id` is required for update");
+        }
+        const body = { agent_id: args.agent_id };
+        if (args.name !== undefined) {
+          const name = args.name.trim();
+          if (!name)
+            throw new Error("inline_agents: `name` cannot be empty");
+          body.name = name;
+        }
+        for (const key of ["handle", "emoji", "description", "skill_key", "instructions"]) {
+          if (args[key] !== undefined)
+            body[key] = args[key]?.trim() ?? "";
+        }
+        if (Object.keys(body).length === 1) {
+          throw new Error("inline_agents: update requires at least one field");
+        }
+        const result2 = await callInlineBotApi({
+          baseUrl: account.baseUrl,
+          token,
+          methodName: "updateAgent",
+          method: "POST",
+          body
+        });
+        return jsonResult({ ok: true, action: args.action, accountId: account.accountId, agent: result2.agent });
+      }
+      if (args.action === "delete") {
+        if (!Number.isSafeInteger(args.agent_id) || Number(args.agent_id) <= 0) {
+          throw new Error("inline_agents: positive `agent_id` is required for delete");
+        }
+        const result2 = await callInlineBotApi({
+          baseUrl: account.baseUrl,
+          token,
+          methodName: "deleteAgent",
+          method: "POST",
+          body: { agent_id: args.agent_id }
+        });
+        return jsonResult({ ok: true, action: args.action, accountId: account.accountId, ...result2 });
+      }
       const result = await callInlineBotApi({
         baseUrl: account.baseUrl,
         token,
@@ -62927,5 +64217,5 @@ export {
   registerInlinePluginFull
 };
 
-//# debugId=7BFD010A59B3DBDC64756E2164756E21
+//# debugId=1AAD126E4E7F191A64756E2164756E21
 //# sourceMappingURL=runtime-register-api.js.map