alibabacloud-agentrun20250910 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

alibabacloud_agentrun20250910/models.py

@@ -6589,20 +6589,26 @@ class CreateCodeInterpreterResponse(TeaModel):
         return self
 
 
-class DeleteAgentRuntimeResponse(TeaModel):
+class CreateMemoryRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: AgentRuntimeResult = None,
+        long_ttl: int = None,
+        name: str = None,
+        permanent: bool = None,
+        short_ttl: int = None,
+        strategy: List[str] = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        # This parameter is required.
+        self.long_ttl = long_ttl
+        # This parameter is required.
+        self.name = name
+        self.permanent = permanent
+        # This parameter is required.
+        self.short_ttl = short_ttl
+        self.strategy = strategy
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -6610,40 +6616,42 @@ class DeleteAgentRuntimeResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.long_ttl is not None:
+            result['longTtl'] = self.long_ttl
+        if self.name is not None:
+            result['name'] = self.name
+        if self.permanent is not None:
+            result['permanent'] = self.permanent
+        if self.short_ttl is not None:
+            result['shortTtl'] = self.short_ttl
+        if self.strategy is not None:
+            result['strategy'] = self.strategy
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
-        if m.get('body') is not None:
-            temp_model = AgentRuntimeResult()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('longTtl') is not None:
+            self.long_ttl = m.get('longTtl')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('permanent') is not None:
+            self.permanent = m.get('permanent')
+        if m.get('shortTtl') is not None:
+            self.short_ttl = m.get('shortTtl')
+        if m.get('strategy') is not None:
+            self.strategy = m.get('strategy')
         return self
 
 
-class DeleteAgentRuntimeEndpointResponse(TeaModel):
+class CreateMemoryResponseBodyData(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: AgentRuntimeEndpointResult = None,
+        cms_workspace_name: str = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        self.cms_workspace_name = cms_workspace_name
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -6651,40 +6659,32 @@ class DeleteAgentRuntimeEndpointResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.cms_workspace_name is not None:
+            result['cmsWorkspaceName'] = self.cms_workspace_name
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
-        if m.get('body') is not None:
-            temp_model = AgentRuntimeEndpointResult()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('cmsWorkspaceName') is not None:
+            self.cms_workspace_name = m.get('cmsWorkspaceName')
         return self
 
 
-class DeleteBrowserResponse(TeaModel):
+class CreateMemoryResponseBody(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: DeleteBrowserResult = None,
+        code: str = None,
+        data: CreateMemoryResponseBodyData = None,
+        request_id: str = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        if self.data:
+            self.data.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6692,32 +6692,32 @@ class DeleteBrowserResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
-        if m.get('body') is not None:
-            temp_model = DeleteBrowserResult()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = CreateMemoryResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
         return self
 
 
-class DeleteCodeInterpreterResponse(TeaModel):
+class CreateMemoryResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteCodeInterpreterResult = None,
+        body: CreateMemoryResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6748,18 +6748,28 @@ class DeleteCodeInterpreterResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = DeleteCodeInterpreterResult()
+            temp_model = CreateMemoryResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetAgentRuntimeRequest(TeaModel):
+class CreateMemoryEventRequestEvents(TeaModel):
     def __init__(
         self,
-        agent_runtime_version: str = None,
+        event_id: str = None,
+        message: List[Dict[str, str]] = None,
+        metadata: Dict[str, Any] = None,
+        session_id: str = None,
+        user_id: str = None,
     ):
-        # 指定要获取的智能体运行时版本，如果不指定则返回最新版本
-        self.agent_runtime_version = agent_runtime_version
+        # This parameter is required.
+        self.event_id = event_id
+        self.message = message
+        self.metadata = metadata
+        # This parameter is required.
+        self.session_id = session_id
+        # This parameter is required.
+        self.user_id = user_id
 
     def validate(self):
         pass
@@ -6770,31 +6780,46 @@ class GetAgentRuntimeRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.agent_runtime_version is not None:
-            result['agentRuntimeVersion'] = self.agent_runtime_version
+        if self.event_id is not None:
+            result['eventId'] = self.event_id
+        if self.message is not None:
+            result['message'] = self.message
+        if self.metadata is not None:
+            result['metadata'] = self.metadata
+        if self.session_id is not None:
+            result['sessionId'] = self.session_id
+        if self.user_id is not None:
+            result['userId'] = self.user_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('agentRuntimeVersion') is not None:
-            self.agent_runtime_version = m.get('agentRuntimeVersion')
+        if m.get('eventId') is not None:
+            self.event_id = m.get('eventId')
+        if m.get('message') is not None:
+            self.message = m.get('message')
+        if m.get('metadata') is not None:
+            self.metadata = m.get('metadata')
+        if m.get('sessionId') is not None:
+            self.session_id = m.get('sessionId')
+        if m.get('userId') is not None:
+            self.user_id = m.get('userId')
         return self
 
 
-class GetAgentRuntimeResponse(TeaModel):
+class CreateMemoryEventRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: AgentRuntimeResult = None,
+        events: List[CreateMemoryEventRequestEvents] = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        # This parameter is required.
+        self.events = events
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        if self.events:
+            for k in self.events:
+                if k:
+                    k.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6802,32 +6827,62 @@ class GetAgentRuntimeResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        result['events'] = []
+        if self.events is not None:
+            for k in self.events:
+                result['events'].append(k.to_map() if k else None)
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
-        if m.get('body') is not None:
-            temp_model = AgentRuntimeResult()
-            self.body = temp_model.from_map(m['body'])
+        self.events = []
+        if m.get('events') is not None:
+            for k in m.get('events'):
+                temp_model = CreateMemoryEventRequestEvents()
+                self.events.append(temp_model.from_map(k))
         return self
 
 
-class GetAgentRuntimeEndpointResponse(TeaModel):
+class CreateMemoryEventResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class CreateMemoryEventResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeEndpointResult = None,
+        body: CreateMemoryEventResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6858,17 +6913,17 @@ class GetAgentRuntimeEndpointResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = AgentRuntimeEndpointResult()
+            temp_model = CreateMemoryEventResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetBrowserResponse(TeaModel):
+class DeleteAgentRuntimeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: BrowserResult = None,
+        body: AgentRuntimeResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6899,17 +6954,17 @@ class GetBrowserResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = BrowserResult()
+            temp_model = AgentRuntimeResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetCodeInterpreterResponse(TeaModel):
+class DeleteAgentRuntimeEndpointResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: CodeInterpreterResult = None,
+        body: AgentRuntimeEndpointResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -6940,27 +6995,25 @@ class GetCodeInterpreterResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = CodeInterpreterResult()
+            temp_model = AgentRuntimeEndpointResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListAgentRuntimeEndpointsRequest(TeaModel):
+class DeleteBrowserResponse(TeaModel):
     def __init__(
         self,
-        endpoint_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteBrowserResult = None,
     ):
-        # 根据端点名称进行模糊匹配过滤
-        self.endpoint_name = endpoint_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        pass
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -6968,31 +7021,32 @@ class ListAgentRuntimeEndpointsRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.endpoint_name is not None:
-            result['endpointName'] = self.endpoint_name
-        if self.page_number is not None:
-            result['pageNumber'] = self.page_number
-        if self.page_size is not None:
-            result['pageSize'] = self.page_size
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('endpointName') is not None:
-            self.endpoint_name = m.get('endpointName')
-        if m.get('pageNumber') is not None:
-            self.page_number = m.get('pageNumber')
-        if m.get('pageSize') is not None:
-            self.page_size = m.get('pageSize')
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = DeleteBrowserResult()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListAgentRuntimeEndpointsResponse(TeaModel):
+class DeleteCodeInterpreterResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListAgentRuntimeEndpointsResult = None,
+        body: DeleteCodeInterpreterResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7023,21 +7077,20 @@ class ListAgentRuntimeEndpointsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListAgentRuntimeEndpointsResult()
+            temp_model = DeleteCodeInterpreterResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListAgentRuntimeVersionsRequest(TeaModel):
+class DeleteMemoryResponseBody(TeaModel):
     def __init__(
         self,
-        page_number: int = None,
-        page_size: int = None,
+        code: str = None,
+        request_id: str = None,
     ):
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
+        self.code = code
+        # Id of the request
+        self.request_id = request_id
 
     def validate(self):
         pass
@@ -7048,27 +7101,1657 @@ class ListAgentRuntimeVersionsRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.page_number is not None:
+        if self.code is not None:
+            result['code'] = self.code
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class DeleteMemoryResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteMemoryResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = DeleteMemoryResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetAgentRuntimeRequest(TeaModel):
+    def __init__(
+        self,
+        agent_runtime_version: str = None,
+    ):
+        # 指定要获取的智能体运行时版本，如果不指定则返回最新版本
+        self.agent_runtime_version = agent_runtime_version
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.agent_runtime_version is not None:
+            result['agentRuntimeVersion'] = self.agent_runtime_version
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('agentRuntimeVersion') is not None:
+            self.agent_runtime_version = m.get('agentRuntimeVersion')
+        return self
+
+
+class GetAgentRuntimeResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: AgentRuntimeResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = AgentRuntimeResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetAgentRuntimeEndpointResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: AgentRuntimeEndpointResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = AgentRuntimeEndpointResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetBrowserResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: BrowserResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = BrowserResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetCodeInterpreterResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CodeInterpreterResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = CodeInterpreterResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetMemoryResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        cms_workspace_name: str = None,
+        create_time: int = None,
+        long_ttl: int = None,
+        name: str = None,
+        permanent: bool = None,
+        short_ttl: int = None,
+        strategy: List[str] = None,
+    ):
+        self.cms_workspace_name = cms_workspace_name
+        self.create_time = create_time
+        self.long_ttl = long_ttl
+        self.name = name
+        self.permanent = permanent
+        self.short_ttl = short_ttl
+        self.strategy = strategy
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.cms_workspace_name is not None:
+            result['cmsWorkspaceName'] = self.cms_workspace_name
+        if self.create_time is not None:
+            result['createTime'] = self.create_time
+        if self.long_ttl is not None:
+            result['longTtl'] = self.long_ttl
+        if self.name is not None:
+            result['name'] = self.name
+        if self.permanent is not None:
+            result['permanent'] = self.permanent
+        if self.short_ttl is not None:
+            result['shortTtl'] = self.short_ttl
+        if self.strategy is not None:
+            result['strategy'] = self.strategy
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('cmsWorkspaceName') is not None:
+            self.cms_workspace_name = m.get('cmsWorkspaceName')
+        if m.get('createTime') is not None:
+            self.create_time = m.get('createTime')
+        if m.get('longTtl') is not None:
+            self.long_ttl = m.get('longTtl')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('permanent') is not None:
+            self.permanent = m.get('permanent')
+        if m.get('shortTtl') is not None:
+            self.short_ttl = m.get('shortTtl')
+        if m.get('strategy') is not None:
+            self.strategy = m.get('strategy')
+        return self
+
+
+class GetMemoryResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: GetMemoryResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = GetMemoryResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GetMemoryResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetMemoryResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetMemoryResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetMemoryEventRequest(TeaModel):
+    def __init__(
+        self,
+        from_: int = None,
+        to: int = None,
+    ):
+        self.from_ = from_
+        self.to = to
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.from_ is not None:
+            result['from'] = self.from_
+        if self.to is not None:
+            result['to'] = self.to
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('from') is not None:
+            self.from_ = m.get('from')
+        if m.get('to') is not None:
+            self.to = m.get('to')
+        return self
+
+
+class GetMemoryEventResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        event: Dict[str, Any] = None,
+    ):
+        self.event = event
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.event is not None:
+            result['event'] = self.event
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('event') is not None:
+            self.event = m.get('event')
+        return self
+
+
+class GetMemoryEventResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: GetMemoryEventResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = GetMemoryEventResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GetMemoryEventResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetMemoryEventResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetMemoryEventResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetMemorySessionRequest(TeaModel):
+    def __init__(
+        self,
+        from_: int = None,
+        size: int = None,
+        to: int = None,
+    ):
+        self.from_ = from_
+        self.size = size
+        self.to = to
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.from_ is not None:
+            result['from'] = self.from_
+        if self.size is not None:
+            result['size'] = self.size
+        if self.to is not None:
+            result['to'] = self.to
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('from') is not None:
+            self.from_ = m.get('from')
+        if m.get('size') is not None:
+            self.size = m.get('size')
+        if m.get('to') is not None:
+            self.to = m.get('to')
+        return self
+
+
+class GetMemorySessionResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        events: List[Dict[str, Any]] = None,
+    ):
+        self.events = events
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.events is not None:
+            result['events'] = self.events
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('events') is not None:
+            self.events = m.get('events')
+        return self
+
+
+class GetMemorySessionResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: GetMemorySessionResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = GetMemorySessionResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class GetMemorySessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: GetMemorySessionResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = GetMemorySessionResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListAgentRuntimeEndpointsRequest(TeaModel):
+    def __init__(
+        self,
+        endpoint_name: str = None,
+        page_number: int = None,
+        page_size: int = None,
+    ):
+        # 根据端点名称进行模糊匹配过滤
+        self.endpoint_name = endpoint_name
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.endpoint_name is not None:
+            result['endpointName'] = self.endpoint_name
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('endpointName') is not None:
+            self.endpoint_name = m.get('endpointName')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        return self
+
+
+class ListAgentRuntimeEndpointsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListAgentRuntimeEndpointsResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListAgentRuntimeEndpointsResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListAgentRuntimeVersionsRequest(TeaModel):
+    def __init__(
+        self,
+        page_number: int = None,
+        page_size: int = None,
+    ):
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        return self
+
+
+class ListAgentRuntimeVersionsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListAgentRuntimeVersionsResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListAgentRuntimeVersionsResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListAgentRuntimesRequest(TeaModel):
+    def __init__(
+        self,
+        agent_runtime_name: str = None,
+        page_number: int = None,
+        page_size: int = None,
+    ):
+        # 根据智能体运行时名称进行模糊匹配过滤
+        self.agent_runtime_name = agent_runtime_name
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.agent_runtime_name is not None:
+            result['agentRuntimeName'] = self.agent_runtime_name
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('agentRuntimeName') is not None:
+            self.agent_runtime_name = m.get('agentRuntimeName')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        return self
+
+
+class ListAgentRuntimesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListAgentRuntimesResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListAgentRuntimesResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListBrowsersRequest(TeaModel):
+    def __init__(
+        self,
+        browser_name: str = None,
+        page_number: int = None,
+        page_size: int = None,
+        status: str = None,
+    ):
+        # 根据浏览器实例名称进行模糊匹配过滤
+        self.browser_name = browser_name
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+        # 根据浏览器实例的运行状态进行过滤，可选值：CREATING、READY、DELETING等
+        self.status = status
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.browser_name is not None:
+            result['browserName'] = self.browser_name
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        if self.status is not None:
+            result['status'] = self.status
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('browserName') is not None:
+            self.browser_name = m.get('browserName')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        return self
+
+
+class ListBrowsersResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListBrowsersResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListBrowsersResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListCodeInterpretersRequest(TeaModel):
+    def __init__(
+        self,
+        code_interpreter_name: str = None,
+        page_number: int = None,
+        page_size: int = None,
+    ):
+        # 根据代码解释器实例名称进行模糊匹配过滤
+        self.code_interpreter_name = code_interpreter_name
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code_interpreter_name is not None:
+            result['codeInterpreterName'] = self.code_interpreter_name
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('codeInterpreterName') is not None:
+            self.code_interpreter_name = m.get('codeInterpreterName')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        return self
+
+
+class ListCodeInterpretersResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListCodeInterpretersResult = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListCodeInterpretersResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListMemoryRequest(TeaModel):
+    def __init__(
+        self,
+        name_prefix: str = None,
+        page_number: int = None,
+        page_size: int = None,
+    ):
+        self.name_prefix = name_prefix
+        # This parameter is required.
+        self.page_number = page_number
+        # This parameter is required.
+        self.page_size = page_size
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.name_prefix is not None:
+            result['namePrefix'] = self.name_prefix
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('namePrefix') is not None:
+            self.name_prefix = m.get('namePrefix')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        return self
+
+
+class ListMemoryResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        items: List[str] = None,
+        page_number: int = None,
+        page_size: int = None,
+        total: int = None,
+    ):
+        self.items = items
+        self.page_number = page_number
+        self.page_size = page_size
+        self.total = total
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.items is not None:
+            result['items'] = self.items
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        if self.total is not None:
+            result['total'] = self.total
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('items') is not None:
+            self.items = m.get('items')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        if m.get('total') is not None:
+            self.total = m.get('total')
+        return self
+
+
+class ListMemoryResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: ListMemoryResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = ListMemoryResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class ListMemoryResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListMemoryResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListMemoryResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListMemoryEventRequest(TeaModel):
+    def __init__(
+        self,
+        from_: int = None,
+        page_number: int = None,
+        page_size: int = None,
+        to: int = None,
+    ):
+        self.from_ = from_
+        self.page_number = page_number
+        self.page_size = page_size
+        self.to = to
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.from_ is not None:
+            result['from'] = self.from_
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        if self.to is not None:
+            result['to'] = self.to
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('from') is not None:
+            self.from_ = m.get('from')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        if m.get('to') is not None:
+            self.to = m.get('to')
+        return self
+
+
+class ListMemoryEventResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        items: List[str] = None,
+        page_number: int = None,
+        page_size: int = None,
+        total: int = None,
+    ):
+        self.items = items
+        self.page_number = page_number
+        self.page_size = page_size
+        self.total = total
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.items is not None:
+            result['items'] = self.items
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        if self.total is not None:
+            result['total'] = self.total
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('items') is not None:
+            self.items = m.get('items')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        if m.get('total') is not None:
+            self.total = m.get('total')
+        return self
+
+
+class ListMemoryEventResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: ListMemoryEventResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = ListMemoryEventResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class ListMemoryEventResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListMemoryEventResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListMemoryEventResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListMemorySessionsRequest(TeaModel):
+    def __init__(
+        self,
+        from_: int = None,
+        page_number: int = None,
+        page_size: int = None,
+        to: int = None,
+    ):
+        self.from_ = from_
+        self.page_number = page_number
+        self.page_size = page_size
+        self.to = to
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.from_ is not None:
+            result['from'] = self.from_
+        if self.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        if self.to is not None:
+            result['to'] = self.to
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('from') is not None:
+            self.from_ = m.get('from')
+        if m.get('pageNumber') is not None:
+            self.page_number = m.get('pageNumber')
+        if m.get('pageSize') is not None:
+            self.page_size = m.get('pageSize')
+        if m.get('to') is not None:
+            self.to = m.get('to')
+        return self
+
+
+class ListMemorySessionsResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        items: List[str] = None,
+        page_number: int = None,
+        page_size: int = None,
+        total: int = None,
+    ):
+        self.items = items
+        self.page_number = page_number
+        self.page_size = page_size
+        self.total = total
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.items is not None:
+            result['items'] = self.items
+        if self.page_number is not None:
             result['pageNumber'] = self.page_number
         if self.page_size is not None:
             result['pageSize'] = self.page_size
+        if self.total is not None:
+            result['total'] = self.total
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('items') is not None:
+            self.items = m.get('items')
         if m.get('pageNumber') is not None:
             self.page_number = m.get('pageNumber')
         if m.get('pageSize') is not None:
             self.page_size = m.get('pageSize')
+        if m.get('total') is not None:
+            self.total = m.get('total')
+        return self
+
+
+class ListMemorySessionsResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: ListMemorySessionsResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = ListMemorySessionsResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class ListMemorySessionsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListMemorySessionsResponseBody = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListMemorySessionsResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class PublishRuntimeVersionRequest(TeaModel):
+    def __init__(
+        self,
+        body: PublishRuntimeVersionInput = None,
+    ):
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('body') is not None:
+            temp_model = PublishRuntimeVersionInput()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListAgentRuntimeVersionsResponse(TeaModel):
+class PublishRuntimeVersionResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListAgentRuntimeVersionsResult = None,
+        body: AgentRuntimeVersionResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7099,24 +8782,24 @@ class ListAgentRuntimeVersionsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListAgentRuntimeVersionsResult()
+            temp_model = AgentRuntimeVersionResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListAgentRuntimesRequest(TeaModel):
+class RetrieveMemoryRequestQuery(TeaModel):
     def __init__(
         self,
-        agent_runtime_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
+        memory: str = None,
+        metadata: Dict[str, str] = None,
+        namespace: str = None,
+        user_id: str = None,
     ):
-        # 根据智能体运行时名称进行模糊匹配过滤
-        self.agent_runtime_name = agent_runtime_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
+        self.memory = memory
+        self.metadata = metadata
+        self.namespace = namespace
+        # This parameter is required.
+        self.user_id = user_id
 
     def validate(self):
         pass
@@ -7127,39 +8810,48 @@ class ListAgentRuntimesRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.agent_runtime_name is not None:
-            result['agentRuntimeName'] = self.agent_runtime_name
-        if self.page_number is not None:
-            result['pageNumber'] = self.page_number
-        if self.page_size is not None:
-            result['pageSize'] = self.page_size
+        if self.memory is not None:
+            result['memory'] = self.memory
+        if self.metadata is not None:
+            result['metadata'] = self.metadata
+        if self.namespace is not None:
+            result['namespace'] = self.namespace
+        if self.user_id is not None:
+            result['userId'] = self.user_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('agentRuntimeName') is not None:
-            self.agent_runtime_name = m.get('agentRuntimeName')
-        if m.get('pageNumber') is not None:
-            self.page_number = m.get('pageNumber')
-        if m.get('pageSize') is not None:
-            self.page_size = m.get('pageSize')
+        if m.get('memory') is not None:
+            self.memory = m.get('memory')
+        if m.get('metadata') is not None:
+            self.metadata = m.get('metadata')
+        if m.get('namespace') is not None:
+            self.namespace = m.get('namespace')
+        if m.get('userId') is not None:
+            self.user_id = m.get('userId')
         return self
 
 
-class ListAgentRuntimesResponse(TeaModel):
+class RetrieveMemoryRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: ListAgentRuntimesResult = None,
+        from_: int = None,
+        query: RetrieveMemoryRequestQuery = None,
+        store: str = None,
+        to: int = None,
+        topk: int = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        self.from_ = from_
+        # This parameter is required.
+        self.query = query
+        self.store = store
+        self.to = to
+        self.topk = topk
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        if self.query:
+            self.query.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -7167,42 +8859,42 @@ class ListAgentRuntimesResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.from_ is not None:
+            result['from'] = self.from_
+        if self.query is not None:
+            result['query'] = self.query.to_map()
+        if self.store is not None:
+            result['store'] = self.store
+        if self.to is not None:
+            result['to'] = self.to
+        if self.topk is not None:
+            result['topk'] = self.topk
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
-        if m.get('body') is not None:
-            temp_model = ListAgentRuntimesResult()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('from') is not None:
+            self.from_ = m.get('from')
+        if m.get('query') is not None:
+            temp_model = RetrieveMemoryRequestQuery()
+            self.query = temp_model.from_map(m['query'])
+        if m.get('store') is not None:
+            self.store = m.get('store')
+        if m.get('to') is not None:
+            self.to = m.get('to')
+        if m.get('topk') is not None:
+            self.topk = m.get('topk')
         return self
 
 
-class ListBrowsersRequest(TeaModel):
+class RetrieveMemoryResponseBodyData(TeaModel):
     def __init__(
         self,
-        browser_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
-        status: str = None,
+        events: List[Dict[str, str]] = None,
+        memories: List[Dict[str, str]] = None,
     ):
-        # 根据浏览器实例名称进行模糊匹配过滤
-        self.browser_name = browser_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
-        # 根据浏览器实例的运行状态进行过滤，可选值：CREATING、READY、DELETING等
-        self.status = status
+        self.events = events
+        self.memories = memories
 
     def validate(self):
         pass
@@ -7213,35 +8905,69 @@ class ListBrowsersRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.browser_name is not None:
-            result['browserName'] = self.browser_name
-        if self.page_number is not None:
-            result['pageNumber'] = self.page_number
-        if self.page_size is not None:
-            result['pageSize'] = self.page_size
-        if self.status is not None:
-            result['status'] = self.status
+        if self.events is not None:
+            result['events'] = self.events
+        if self.memories is not None:
+            result['memories'] = self.memories
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('browserName') is not None:
-            self.browser_name = m.get('browserName')
-        if m.get('pageNumber') is not None:
-            self.page_number = m.get('pageNumber')
-        if m.get('pageSize') is not None:
-            self.page_size = m.get('pageSize')
-        if m.get('status') is not None:
-            self.status = m.get('status')
+        if m.get('events') is not None:
+            self.events = m.get('events')
+        if m.get('memories') is not None:
+            self.memories = m.get('memories')
         return self
 
 
-class ListBrowsersResponse(TeaModel):
+class RetrieveMemoryResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: RetrieveMemoryResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
+
+    def validate(self):
+        if self.data:
+            self.data.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = RetrieveMemoryResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class RetrieveMemoryResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListBrowsersResult = None,
+        body: RetrieveMemoryResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7272,27 +8998,24 @@ class ListBrowsersResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListBrowsersResult()
+            temp_model = RetrieveMemoryResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListCodeInterpretersRequest(TeaModel):
+class UpdateAgentRuntimeRequest(TeaModel):
     def __init__(
         self,
-        code_interpreter_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
+        body: UpdateAgentRuntimeInput = None,
     ):
-        # 根据代码解释器实例名称进行模糊匹配过滤
-        self.code_interpreter_name = code_interpreter_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
+        # 包含要更新的智能体运行时配置信息的请求体
+        # 
+        # This parameter is required.
+        self.body = body
 
     def validate(self):
-        pass
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -7300,31 +9023,24 @@ class ListCodeInterpretersRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.code_interpreter_name is not None:
-            result['codeInterpreterName'] = self.code_interpreter_name
-        if self.page_number is not None:
-            result['pageNumber'] = self.page_number
-        if self.page_size is not None:
-            result['pageSize'] = self.page_size
+        if self.body is not None:
+            result['body'] = self.body.to_map()
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('codeInterpreterName') is not None:
-            self.code_interpreter_name = m.get('codeInterpreterName')
-        if m.get('pageNumber') is not None:
-            self.page_number = m.get('pageNumber')
-        if m.get('pageSize') is not None:
-            self.page_size = m.get('pageSize')
+        if m.get('body') is not None:
+            temp_model = UpdateAgentRuntimeInput()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListCodeInterpretersResponse(TeaModel):
+class UpdateAgentRuntimeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListCodeInterpretersResult = None,
+        body: AgentRuntimeResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7355,16 +9071,19 @@ class ListCodeInterpretersResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListCodeInterpretersResult()
+            temp_model = AgentRuntimeResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class PublishRuntimeVersionRequest(TeaModel):
+class UpdateAgentRuntimeEndpointRequest(TeaModel):
     def __init__(
         self,
-        body: PublishRuntimeVersionInput = None,
+        body: UpdateAgentRuntimeEndpointInput = None,
     ):
+        # 包含要更新的智能体运行时端点配置信息的请求体
+        # 
+        # This parameter is required.
         self.body = body
 
     def validate(self):
@@ -7384,17 +9103,17 @@ class PublishRuntimeVersionRequest(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('body') is not None:
-            temp_model = PublishRuntimeVersionInput()
+            temp_model = UpdateAgentRuntimeEndpointInput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class PublishRuntimeVersionResponse(TeaModel):
+class UpdateAgentRuntimeEndpointResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeVersionResult = None,
+        body: AgentRuntimeEndpointResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7425,24 +9144,26 @@ class PublishRuntimeVersionResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = AgentRuntimeVersionResult()
+            temp_model = AgentRuntimeEndpointResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class UpdateAgentRuntimeRequest(TeaModel):
+class UpdateMemoryRequest(TeaModel):
     def __init__(
         self,
-        body: UpdateAgentRuntimeInput = None,
+        long_ttl: int = None,
+        permanent: bool = None,
+        short_ttl: int = None,
+        strategy: List[str] = None,
     ):
-        # 包含要更新的智能体运行时配置信息的请求体
-        # 
-        # This parameter is required.
-        self.body = body
+        self.long_ttl = long_ttl
+        self.permanent = permanent
+        self.short_ttl = short_ttl
+        self.strategy = strategy
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -7450,32 +9171,38 @@ class UpdateAgentRuntimeRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.long_ttl is not None:
+            result['longTtl'] = self.long_ttl
+        if self.permanent is not None:
+            result['permanent'] = self.permanent
+        if self.short_ttl is not None:
+            result['shortTtl'] = self.short_ttl
+        if self.strategy is not None:
+            result['strategy'] = self.strategy
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('body') is not None:
-            temp_model = UpdateAgentRuntimeInput()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('longTtl') is not None:
+            self.long_ttl = m.get('longTtl')
+        if m.get('permanent') is not None:
+            self.permanent = m.get('permanent')
+        if m.get('shortTtl') is not None:
+            self.short_ttl = m.get('shortTtl')
+        if m.get('strategy') is not None:
+            self.strategy = m.get('strategy')
         return self
 
 
-class UpdateAgentRuntimeResponse(TeaModel):
+class UpdateMemoryResponseBodyData(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: AgentRuntimeResult = None,
+        cms_workspace_name: str = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
-        self.body = body
+        self.cms_workspace_name = cms_workspace_name
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -7483,39 +9210,32 @@ class UpdateAgentRuntimeResponse(TeaModel):
             return _map
 
         result = dict()
-        if self.headers is not None:
-            result['headers'] = self.headers
-        if self.status_code is not None:
-            result['statusCode'] = self.status_code
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.cms_workspace_name is not None:
+            result['cmsWorkspaceName'] = self.cms_workspace_name
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('headers') is not None:
-            self.headers = m.get('headers')
-        if m.get('statusCode') is not None:
-            self.status_code = m.get('statusCode')
-        if m.get('body') is not None:
-            temp_model = AgentRuntimeResult()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('cmsWorkspaceName') is not None:
+            self.cms_workspace_name = m.get('cmsWorkspaceName')
         return self
 
 
-class UpdateAgentRuntimeEndpointRequest(TeaModel):
+class UpdateMemoryResponseBody(TeaModel):
     def __init__(
         self,
-        body: UpdateAgentRuntimeEndpointInput = None,
+        code: str = None,
+        data: UpdateMemoryResponseBodyData = None,
+        request_id: str = None,
     ):
-        # 包含要更新的智能体运行时端点配置信息的请求体
-        # 
-        # This parameter is required.
-        self.body = body
+        self.code = code
+        self.data = data
+        # Id of the request
+        self.request_id = request_id
 
     def validate(self):
-        if self.body:
-            self.body.validate()
+        if self.data:
+            self.data.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -7523,24 +9243,32 @@ class UpdateAgentRuntimeEndpointRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.body is not None:
-            result['body'] = self.body.to_map()
+        if self.code is not None:
+            result['code'] = self.code
+        if self.data is not None:
+            result['data'] = self.data.to_map()
+        if self.request_id is not None:
+            result['requestId'] = self.request_id
         return result
 
     def from_map(self, m: dict = None):
         m = m or dict()
-        if m.get('body') is not None:
-            temp_model = UpdateAgentRuntimeEndpointInput()
-            self.body = temp_model.from_map(m['body'])
+        if m.get('code') is not None:
+            self.code = m.get('code')
+        if m.get('data') is not None:
+            temp_model = UpdateMemoryResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
         return self
 
 
-class UpdateAgentRuntimeEndpointResponse(TeaModel):
+class UpdateMemoryResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeEndpointResult = None,
+        body: UpdateMemoryResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -7571,7 +9299,7 @@ class UpdateAgentRuntimeEndpointResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = AgentRuntimeEndpointResult()
+            temp_model = UpdateMemoryResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self