alibabacloud-agentrun20250910 3.0.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

alibabacloud_agentrun20250910/models.py

@@ -4132,9 +4132,11 @@ class CreateModelServiceInput(TeaModel):
 class CreateSandboxInput(TeaModel):
     def __init__(
         self,
+        sandbox_id: str = None,
         sandbox_idle_timeout_seconds: int = None,
         template_name: str = None,
     ):
+        self.sandbox_id = sandbox_id
         # 沙箱空闲超时时间（秒）
         self.sandbox_idle_timeout_seconds = sandbox_idle_timeout_seconds
         # 模板名称（系统内部通过 templateName 查询 template_id）
@@ -4151,6 +4153,8 @@ class CreateSandboxInput(TeaModel):
             return _map
 
         result = dict()
+        if self.sandbox_id is not None:
+            result['sandboxId'] = self.sandbox_id
         if self.sandbox_idle_timeout_seconds is not None:
             result['sandboxIdleTimeoutSeconds'] = self.sandbox_idle_timeout_seconds
         if self.template_name is not None:
@@ -4159,6 +4163,8 @@ class CreateSandboxInput(TeaModel):
 
     def from_map(self, m: dict = None):
         m = m or dict()
+        if m.get('sandboxId') is not None:
+            self.sandbox_id = m.get('sandboxId')
         if m.get('sandboxIdleTimeoutSeconds') is not None:
             self.sandbox_idle_timeout_seconds = m.get('sandboxIdleTimeoutSeconds')
         if m.get('templateName') is not None:
@@ -5310,10 +5316,12 @@ class Sandbox(TeaModel):
     def __init__(
         self,
         created_at: str = None,
+        ended_at: str = None,
         last_updated_at: str = None,
         metadata: Dict[str, Any] = None,
         sandbox_arn: str = None,
         sandbox_id: str = None,
+        sandbox_idle_ttlin_seconds: int = None,
         sandbox_idle_timeout_seconds: int = None,
         status: str = None,
         template_id: str = None,
@@ -5323,12 +5331,14 @@ class Sandbox(TeaModel):
         # 
         # This parameter is required.
         self.created_at = created_at
+        self.ended_at = ended_at
         # 最后更新时间
         self.last_updated_at = last_updated_at
         self.metadata = metadata
         self.sandbox_arn = sandbox_arn
         # This parameter is required.
         self.sandbox_id = sandbox_id
+        self.sandbox_idle_ttlin_seconds = sandbox_idle_ttlin_seconds
         # 沙箱空闲超时时间（秒）
         self.sandbox_idle_timeout_seconds = sandbox_idle_timeout_seconds
         # This parameter is required.
@@ -5348,6 +5358,8 @@ class Sandbox(TeaModel):
         result = dict()
         if self.created_at is not None:
             result['createdAt'] = self.created_at
+        if self.ended_at is not None:
+            result['endedAt'] = self.ended_at
         if self.last_updated_at is not None:
             result['lastUpdatedAt'] = self.last_updated_at
         if self.metadata is not None:
@@ -5356,6 +5368,8 @@ class Sandbox(TeaModel):
             result['sandboxArn'] = self.sandbox_arn
         if self.sandbox_id is not None:
             result['sandboxId'] = self.sandbox_id
+        if self.sandbox_idle_ttlin_seconds is not None:
+            result['sandboxIdleTTLInSeconds'] = self.sandbox_idle_ttlin_seconds
         if self.sandbox_idle_timeout_seconds is not None:
             result['sandboxIdleTimeoutSeconds'] = self.sandbox_idle_timeout_seconds
         if self.status is not None:
@@ -5370,6 +5384,8 @@ class Sandbox(TeaModel):
         m = m or dict()
         if m.get('createdAt') is not None:
             self.created_at = m.get('createdAt')
+        if m.get('endedAt') is not None:
+            self.ended_at = m.get('endedAt')
         if m.get('lastUpdatedAt') is not None:
             self.last_updated_at = m.get('lastUpdatedAt')
         if m.get('metadata') is not None:
@@ -5378,6 +5394,8 @@ class Sandbox(TeaModel):
             self.sandbox_arn = m.get('sandboxArn')
         if m.get('sandboxId') is not None:
             self.sandbox_id = m.get('sandboxId')
+        if m.get('sandboxIdleTTLInSeconds') is not None:
+            self.sandbox_idle_ttlin_seconds = m.get('sandboxIdleTTLInSeconds')
         if m.get('sandboxIdleTimeoutSeconds') is not None:
             self.sandbox_idle_timeout_seconds = m.get('sandboxIdleTimeoutSeconds')
         if m.get('status') is not None:
@@ -8867,6 +8885,47 @@ class StopCodeInterpreterSessionResult(TeaModel):
         return self
 
 
+class StopSandboxResult(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: Sandbox = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        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 = Sandbox()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
 class Target(TeaModel):
     def __init__(
         self,
@@ -9937,6 +9996,80 @@ class UpdateToolOutput(TeaModel):
         return self
 
 
+class ActivateTemplateMCPRequest(TeaModel):
+    def __init__(
+        self,
+        enabled_tools: List[str] = None,
+        transport: str = None,
+    ):
+        self.enabled_tools = enabled_tools
+        self.transport = transport
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.enabled_tools is not None:
+            result['enabledTools'] = self.enabled_tools
+        if self.transport is not None:
+            result['transport'] = self.transport
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('enabledTools') is not None:
+            self.enabled_tools = m.get('enabledTools')
+        if m.get('transport') is not None:
+            self.transport = m.get('transport')
+        return self
+
+
+class ActivateTemplateMCPResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: TemplateResult = 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 = TemplateResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateAgentRuntimeRequest(TeaModel):
     def __init__(
         self,
@@ -10225,6 +10358,76 @@ class CreateCodeInterpreterResponse(TeaModel):
         return self
 
 
+class CreateCredentialRequest(TeaModel):
+    def __init__(
+        self,
+        body: CreateCredentialInput = 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 = CreateCredentialInput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class CreateCredentialResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CredentialResult = 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 = CredentialResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateMemoryRequest(TeaModel):
     def __init__(
         self,
@@ -10548,15 +10751,11 @@ class CreateMemoryEventResponse(TeaModel):
         return self
 
 
-class DeleteAgentRuntimeResponse(TeaModel):
+class CreateModelProxyRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: AgentRuntimeResult = None,
+        body: CreateModelProxyInput = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
         self.body = body
 
     def validate(self):
@@ -10569,32 +10768,24 @@ 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()
         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()
+            temp_model = CreateModelProxyInput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteAgentRuntimeEndpointResponse(TeaModel):
+class CreateModelProxyResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeEndpointResult = None,
+        body: ModelProxyResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10625,20 +10816,16 @@ class DeleteAgentRuntimeEndpointResponse(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 = ModelProxyResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteBrowserResponse(TeaModel):
+class CreateModelServiceRequest(TeaModel):
     def __init__(
         self,
-        headers: Dict[str, str] = None,
-        status_code: int = None,
-        body: DeleteBrowserResult = None,
+        body: CreateModelServiceInput = None,
     ):
-        self.headers = headers
-        self.status_code = status_code
         self.body = body
 
     def validate(self):
@@ -10651,32 +10838,24 @@ 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()
         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()
+            temp_model = CreateModelServiceInput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteCodeInterpreterResponse(TeaModel):
+class CreateModelServiceResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteCodeInterpreterResult = None,
+        body: ModelServiceResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10707,23 +10886,24 @@ 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 = ModelServiceResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteMemoryResponseBody(TeaModel):
+class CreateSandboxRequest(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        request_id: str = None,
+        body: CreateSandboxInput = None,
     ):
-        self.code = code
-        # Id of the request
-        self.request_id = request_id
+        # 创建沙箱所需的配置信息，包括模板名称、沙箱名称等
+        # 
+        # 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()
@@ -10731,27 +10911,24 @@ class DeleteMemoryResponseBody(TeaModel):
             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
+        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('code') is not None:
-            self.code = m.get('code')
-        if m.get('requestId') is not None:
-            self.request_id = m.get('requestId')
+        if m.get('body') is not None:
+            temp_model = CreateSandboxInput()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class DeleteMemoryResponse(TeaModel):
+class CreateSandboxResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: DeleteMemoryResponseBody = None,
+        body: SandboxResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10782,21 +10959,24 @@ class DeleteMemoryResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = DeleteMemoryResponseBody()
+            temp_model = SandboxResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetAgentRuntimeRequest(TeaModel):
+class CreateTemplateRequest(TeaModel):
     def __init__(
         self,
-        agent_runtime_version: str = None,
+        body: CreateTemplateInput = None,
     ):
-        # 指定要获取的智能体运行时版本，如果不指定则返回最新版本
-        self.agent_runtime_version = agent_runtime_version
+        # 创建模板所需的完整配置信息，包括模板名称、类型、资源规格、网络配置等
+        # 
+        # 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()
@@ -10804,18 +10984,60 @@ class GetAgentRuntimeRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.agent_runtime_version is not None:
-            result['agentRuntimeVersion'] = self.agent_runtime_version
-        return result
+        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('agentRuntimeVersion') is not None:
-            self.agent_runtime_version = m.get('agentRuntimeVersion')
+        if m.get('body') is not None:
+            temp_model = CreateTemplateInput()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetAgentRuntimeResponse(TeaModel):
+class CreateTemplateResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: TemplateResult = 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 = TemplateResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class DeleteAgentRuntimeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -10856,7 +11078,7 @@ class GetAgentRuntimeResponse(TeaModel):
         return self
 
 
-class GetAgentRuntimeEndpointResponse(TeaModel):
+class DeleteAgentRuntimeEndpointResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
@@ -10897,12 +11119,12 @@ class GetAgentRuntimeEndpointResponse(TeaModel):
         return self
 
 
-class GetBrowserResponse(TeaModel):
+class DeleteBrowserResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: BrowserResult = None,
+        body: DeleteBrowserResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10933,17 +11155,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 = DeleteBrowserResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetCodeInterpreterResponse(TeaModel):
+class DeleteCodeInterpreterResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: CodeInterpreterResult = None,
+        body: DeleteCodeInterpreterResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -10974,30 +11196,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 = DeleteCodeInterpreterResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemoryResponseBodyData(TeaModel):
+class DeleteCredentialResponse(TeaModel):
     def __init__(
         self,
-        cms_workspace_name: str = None,
-        create_time: int = None,
-        long_ttl: int = None,
-        name: str = None,
-        short_ttl: int = None,
-        strategy: List[str] = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CredentialResult = None,
     ):
-        self.cms_workspace_name = cms_workspace_name
-        self.create_time = create_time
-        self.long_ttl = long_ttl
-        self.name = name
-        self.short_ttl = short_ttl
-        self.strategy = strategy
+        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()
@@ -11005,52 +11222,38 @@ class GetMemoryResponseBodyData(TeaModel):
             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.short_ttl is not None:
-            result['shortTtl'] = self.short_ttl
-        if self.strategy is not None:
-            result['strategy'] = self.strategy
+        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('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('shortTtl') is not None:
-            self.short_ttl = m.get('shortTtl')
-        if m.get('strategy') is not None:
-            self.strategy = m.get('strategy')
+        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 = CredentialResult()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemoryResponseBody(TeaModel):
+class DeleteMemoryResponseBody(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()
+        pass
 
     def to_map(self):
         _map = super().to_map()
@@ -11060,8 +11263,6 @@ class GetMemoryResponseBody(TeaModel):
         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
@@ -11070,20 +11271,17 @@ class GetMemoryResponseBody(TeaModel):
         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):
+class DeleteMemoryResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetMemoryResponseBody = None,
+        body: DeleteMemoryResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11114,22 +11312,25 @@ class GetMemoryResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetMemoryResponseBody()
+            temp_model = DeleteMemoryResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemoryEventRequest(TeaModel):
+class DeleteModelProxyResponse(TeaModel):
     def __init__(
         self,
-        from_: int = None,
-        to: int = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteModelProxyResult = None,
     ):
-        self.from_ = from_
-        self.to = to
+        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()
@@ -11137,30 +11338,40 @@ class GetMemoryEventRequest(TeaModel):
             return _map
 
         result = dict()
-        if self.from_ is not None:
-            result['from'] = self.from_
-        if self.to is not None:
-            result['to'] = self.to
+        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('from') is not None:
-            self.from_ = m.get('from')
-        if m.get('to') is not None:
-            self.to = m.get('to')
+        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 = DeleteModelProxyResult()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemoryEventResponseBodyData(TeaModel):
+class DeleteModelServiceResponse(TeaModel):
     def __init__(
         self,
-        event: Dict[str, Any] = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteModelServiceResult = None,
     ):
-        self.event = event
+        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()
@@ -11168,32 +11379,40 @@ class GetMemoryEventResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.event is not None:
-            result['event'] = self.event
+        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('event') is not None:
-            self.event = m.get('event')
+        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 = DeleteModelServiceResult()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemoryEventResponseBody(TeaModel):
+class DeleteSandboxResponse(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        data: GetMemoryEventResponseBodyData = None,
-        request_id: str = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: DeleteSandboxResult = None,
     ):
-        self.code = code
-        self.data = data
-        # Id of the request
-        self.request_id = request_id
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        if self.data:
-            self.data.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -11201,32 +11420,32 @@ class GetMemoryEventResponseBody(TeaModel):
             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
+        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('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')
+        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 = DeleteSandboxResult()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemoryEventResponse(TeaModel):
+class DeleteTemplateResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetMemoryEventResponseBody = None,
+        body: DeleteTemplateResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11257,21 +11476,21 @@ class GetMemoryEventResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetMemoryEventResponseBody()
+            temp_model = DeleteTemplateResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class GetMemorySessionRequest(TeaModel):
+class GetAccessTokenRequest(TeaModel):
     def __init__(
         self,
-        from_: int = None,
-        size: int = None,
-        to: int = None,
+        resource_id: str = None,
+        resource_name: str = None,
+        resource_type: str = None,
     ):
-        self.from_ = from_
-        self.size = size
-        self.to = to
+        self.resource_id = resource_id
+        self.resource_name = resource_name
+        self.resource_type = resource_type
 
     def validate(self):
         pass
@@ -11282,31 +11501,31 @@ class GetMemorySessionRequest(TeaModel):
             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
+        if self.resource_id is not None:
+            result['resourceId'] = self.resource_id
+        if self.resource_name is not None:
+            result['resourceName'] = self.resource_name
+        if self.resource_type is not None:
+            result['resourceType'] = self.resource_type
         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')
+        if m.get('resourceId') is not None:
+            self.resource_id = m.get('resourceId')
+        if m.get('resourceName') is not None:
+            self.resource_name = m.get('resourceName')
+        if m.get('resourceType') is not None:
+            self.resource_type = m.get('resourceType')
         return self
 
 
-class GetMemorySessionResponseBodyData(TeaModel):
+class GetAccessTokenResponseBodyData(TeaModel):
     def __init__(
         self,
-        events: List[Dict[str, Any]] = None,
+        access_token: str = None,
     ):
-        self.events = events
+        self.access_token = access_token
 
     def validate(self):
         pass
@@ -11317,27 +11536,26 @@ class GetMemorySessionResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.events is not None:
-            result['events'] = self.events
+        if self.access_token is not None:
+            result['accessToken'] = self.access_token
         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')
+        if m.get('accessToken') is not None:
+            self.access_token = m.get('accessToken')
         return self
 
 
-class GetMemorySessionResponseBody(TeaModel):
+class GetAccessTokenResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: GetMemorySessionResponseBodyData = None,
+        data: GetAccessTokenResponseBodyData = None,
         request_id: str = None,
     ):
         self.code = code
         self.data = data
-        # Id of the request
         self.request_id = request_id
 
     def validate(self):
@@ -11363,19 +11581,19 @@ class GetMemorySessionResponseBody(TeaModel):
         if m.get('code') is not None:
             self.code = m.get('code')
         if m.get('data') is not None:
-            temp_model = GetMemorySessionResponseBodyData()
+            temp_model = GetAccessTokenResponseBodyData()
             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):
+class GetAccessTokenResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: GetMemorySessionResponseBody = None,
+        body: GetAccessTokenResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11406,27 +11624,18 @@ class GetMemorySessionResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = GetMemorySessionResponseBody()
+            temp_model = GetAccessTokenResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListAgentRuntimeEndpointsRequest(TeaModel):
+class GetAgentRuntimeRequest(TeaModel):
     def __init__(
         self,
-        endpoint_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
-        search_mode: str = None,
+        agent_runtime_version: str = None,
     ):
-        # 根据端点名称进行模糊匹配过滤
-        self.endpoint_name = endpoint_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
-        # 查询模式，支持精确查询和模糊查询
-        self.search_mode = search_mode
+        # 指定要获取的智能体运行时版本，如果不指定则返回最新版本
+        self.agent_runtime_version = agent_runtime_version
 
     def validate(self):
         pass
@@ -11437,35 +11646,23 @@ 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.search_mode is not None:
-            result['searchMode'] = self.search_mode
+        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('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('searchMode') is not None:
-            self.search_mode = m.get('searchMode')
+        if m.get('agentRuntimeVersion') is not None:
+            self.agent_runtime_version = m.get('agentRuntimeVersion')
         return self
 
 
-class ListAgentRuntimeEndpointsResponse(TeaModel):
+class GetAgentRuntimeResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListAgentRuntimeEndpointsResult = None,
+        body: AgentRuntimeResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11496,52 +11693,17 @@ 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 = AgentRuntimeResult()
             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):
+class GetAgentRuntimeEndpointResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListAgentRuntimeVersionsResult = None,
+        body: AgentRuntimeEndpointResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11572,66 +11734,17 @@ 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 = AgentRuntimeEndpointResult()
             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,
-        search_mode: str = None,
-    ):
-        # 根据智能体运行时名称进行模糊匹配过滤
-        self.agent_runtime_name = agent_runtime_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
-        # 查询模式，支持精确查询和模糊查询
-        self.search_mode = search_mode
-
-    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
-        if self.search_mode is not None:
-            result['searchMode'] = self.search_mode
-        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('searchMode') is not None:
-            self.search_mode = m.get('searchMode')
-        return self
-
-
-class ListAgentRuntimesResponse(TeaModel):
+class GetBrowserResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListAgentRuntimesResult = None,
+        body: BrowserResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11662,30 +11775,25 @@ class ListAgentRuntimesResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListAgentRuntimesResult()
+            temp_model = BrowserResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListBrowsersRequest(TeaModel):
+class GetCodeInterpreterResponse(TeaModel):
     def __init__(
         self,
-        browser_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
-        status: str = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: CodeInterpreterResult = None,
     ):
-        # 根据浏览器实例名称进行模糊匹配过滤
-        self.browser_name = browser_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
-        # 根据浏览器实例的运行状态进行过滤，可选值：CREATING、READY、DELETING等
-        self.status = status
+        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()
@@ -11693,35 +11801,32 @@ 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.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('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('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 ListBrowsersResponse(TeaModel):
+class GetCredentialResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListBrowsersResult = None,
+        body: CredentialResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11752,24 +11857,27 @@ 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 = CredentialResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListCodeInterpretersRequest(TeaModel):
+class GetMemoryResponseBodyData(TeaModel):
     def __init__(
         self,
-        code_interpreter_name: str = None,
-        page_number: int = None,
-        page_size: int = None,
+        cms_workspace_name: str = None,
+        create_time: int = None,
+        long_ttl: int = None,
+        name: str = None,
+        short_ttl: int = None,
+        strategy: List[str] = None,
     ):
-        # 根据代码解释器实例名称进行模糊匹配过滤
-        self.code_interpreter_name = code_interpreter_name
-        # 当前页码，从1开始计数
-        self.page_number = page_number
-        # 每页返回的记录数量
-        self.page_size = page_size
+        self.cms_workspace_name = cms_workspace_name
+        self.create_time = create_time
+        self.long_ttl = long_ttl
+        self.name = name
+        self.short_ttl = short_ttl
+        self.strategy = strategy
 
     def validate(self):
         pass
@@ -11780,31 +11888,85 @@ 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.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.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('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('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('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 ListCodeInterpretersResponse(TeaModel):
+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: ListCodeInterpretersResult = None,
+        body: GetMemoryResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -11835,23 +11997,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 = GetMemoryResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListMemoryRequest(TeaModel):
+class GetMemoryEventRequest(TeaModel):
     def __init__(
         self,
-        page_number: int = None,
-        page_size: int = None,
-        pattern: str = None,
+        from_: int = None,
+        to: int = None,
     ):
-        # This parameter is required.
-        self.page_number = page_number
-        # This parameter is required.
-        self.page_size = page_size
-        self.pattern = pattern
+        self.from_ = from_
+        self.to = to
 
     def validate(self):
         pass
@@ -11862,37 +12020,27 @@ class ListMemoryRequest(TeaModel):
             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
-        if self.pattern is not None:
-            result['pattern'] = self.pattern
+        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('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('pattern') is not None:
-            self.pattern = m.get('pattern')
+        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 ListMemoryResponseBodyData(TeaModel):
+class GetMemoryEventResponseBodyData(TeaModel):
     def __init__(
         self,
-        items: List[str] = None,
-        page_number: int = None,
-        page_size: int = None,
-        total: int = None,
+        event: Dict[str, Any] = None,
     ):
-        self.items = items
-        self.page_number = page_number
-        self.page_size = page_size
-        self.total = total
+        self.event = event
 
     def validate(self):
         pass
@@ -11903,34 +12051,22 @@ class ListMemoryResponseBodyData(TeaModel):
             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
+        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('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')
+        if m.get('event') is not None:
+            self.event = m.get('event')
         return self
 
 
-class ListMemoryResponseBody(TeaModel):
+class GetMemoryEventResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: ListMemoryResponseBodyData = None,
+        data: GetMemoryEventResponseBodyData = None,
         request_id: str = None,
     ):
         self.code = code
@@ -11961,19 +12097,19 @@ class ListMemoryResponseBody(TeaModel):
         if m.get('code') is not None:
             self.code = m.get('code')
         if m.get('data') is not None:
-            temp_model = ListMemoryResponseBodyData()
+            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 ListMemoryResponse(TeaModel):
+class GetMemoryEventResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListMemoryResponseBody = None,
+        body: GetMemoryEventResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12004,22 +12140,20 @@ class ListMemoryResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListMemoryResponseBody()
+            temp_model = GetMemoryEventResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListMemoryEventRequest(TeaModel):
+class GetMemorySessionRequest(TeaModel):
     def __init__(
         self,
         from_: int = None,
-        page_number: int = None,
-        page_size: int = None,
+        size: int = None,
         to: int = None,
     ):
         self.from_ = from_
-        self.page_number = page_number
-        self.page_size = page_size
+        self.size = size
         self.to = to
 
     def validate(self):
@@ -12033,10 +12167,8 @@ class ListMemoryEventRequest(TeaModel):
         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.size is not None:
+            result['size'] = self.size
         if self.to is not None:
             result['to'] = self.to
         return result
@@ -12045,27 +12177,19 @@ class ListMemoryEventRequest(TeaModel):
         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('size') is not None:
+            self.size = m.get('size')
         if m.get('to') is not None:
             self.to = m.get('to')
         return self
 
 
-class ListMemoryEventResponseBodyData(TeaModel):
+class GetMemorySessionResponseBodyData(TeaModel):
     def __init__(
         self,
-        items: List[str] = None,
-        page_number: int = None,
-        page_size: int = None,
-        total: int = None,
+        events: List[Dict[str, Any]] = None,
     ):
-        self.items = items
-        self.page_number = page_number
-        self.page_size = page_size
-        self.total = total
+        self.events = events
 
     def validate(self):
         pass
@@ -12076,34 +12200,22 @@ class ListMemoryEventResponseBodyData(TeaModel):
             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
+        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('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')
+        if m.get('events') is not None:
+            self.events = m.get('events')
         return self
 
 
-class ListMemoryEventResponseBody(TeaModel):
+class GetMemorySessionResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: ListMemoryEventResponseBodyData = None,
+        data: GetMemorySessionResponseBodyData = None,
         request_id: str = None,
     ):
         self.code = code
@@ -12134,19 +12246,19 @@ class ListMemoryEventResponseBody(TeaModel):
         if m.get('code') is not None:
             self.code = m.get('code')
         if m.get('data') is not None:
-            temp_model = ListMemoryEventResponseBodyData()
+            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 ListMemoryEventResponse(TeaModel):
+class GetMemorySessionResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: ListMemoryEventResponseBody = None,
+        body: GetMemorySessionResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12177,26 +12289,25 @@ class ListMemoryEventResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListMemoryEventResponseBody()
+            temp_model = GetMemorySessionResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListMemorySessionsRequest(TeaModel):
+class GetModelProxyResponse(TeaModel):
     def __init__(
         self,
-        from_: int = None,
-        page_number: int = None,
-        page_size: int = None,
-        to: int = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ModelProxyResult = None,
     ):
-        self.from_ = from_
-        self.page_number = page_number
-        self.page_size = page_size
-        self.to = to
+        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()
@@ -12204,41 +12315,165 @@ class ListMemorySessionsRequest(TeaModel):
             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
+        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('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')
+        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 = ModelProxyResult()
+            self.body = temp_model.from_map(m['body'])
         return self
 
 
-class ListMemorySessionsResponseBodyData(TeaModel):
+class GetModelServiceResponse(TeaModel):
     def __init__(
         self,
-        items: List[str] = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ModelServiceResult = 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 = ModelServiceResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetSandboxResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: SandboxResult = 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 = SandboxResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class GetTemplateResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: TemplateResult = 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 = TemplateResult()
+            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,
-        total: int = None,
+        search_mode: str = None,
     ):
-        self.items = items
+        # 根据端点名称进行模糊匹配过滤
+        self.endpoint_name = endpoint_name
+        # 当前页码，从1开始计数
         self.page_number = page_number
+        # 每页返回的记录数量
         self.page_size = page_size
-        self.total = total
+        # 查询模式，支持精确查询和模糊查询
+        self.search_mode = search_mode
 
     def validate(self):
         pass
@@ -12249,44 +12484,43 @@ class ListMemorySessionsResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.items is not None:
-            result['items'] = self.items
+        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.total is not None:
-            result['total'] = self.total
+        if self.search_mode is not None:
+            result['searchMode'] = self.search_mode
         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('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('total') is not None:
-            self.total = m.get('total')
+        if m.get('searchMode') is not None:
+            self.search_mode = m.get('searchMode')
         return self
 
 
-class ListMemorySessionsResponseBody(TeaModel):
+class ListAgentRuntimeEndpointsResponse(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        data: ListMemorySessionsResponseBodyData = None,
-        request_id: str = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListAgentRuntimeEndpointsResult = None,
     ):
-        self.code = code
-        self.data = data
-        # Id of the request
-        self.request_id = request_id
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
 
     def validate(self):
-        if self.data:
-            self.data.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -12294,32 +12528,67 @@ class ListMemorySessionsResponseBody(TeaModel):
             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
+        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('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')
+        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 ListMemorySessionsResponse(TeaModel):
+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: ListMemorySessionsResponseBody = None,
+        body: ListAgentRuntimeVersionsResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12350,15 +12619,2024 @@ class ListMemorySessionsResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = ListMemorySessionsResponseBody()
+            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,
+        search_mode: str = None,
+    ):
+        # 根据智能体运行时名称进行模糊匹配过滤
+        self.agent_runtime_name = agent_runtime_name
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+        # 查询模式，支持精确查询和模糊查询
+        self.search_mode = search_mode
+
+    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
+        if self.search_mode is not None:
+            result['searchMode'] = self.search_mode
+        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('searchMode') is not None:
+            self.search_mode = m.get('searchMode')
+        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 ListCredentialsRequest(TeaModel):
+    def __init__(
+        self,
+        credential_auth_type: str = None,
+        credential_name: str = None,
+        credential_source_type: str = None,
+        enabled: bool = None,
+        page_number: int = None,
+        page_size: int = None,
+        provider: str = None,
+    ):
+        # credentialAuthType
+        self.credential_auth_type = credential_auth_type
+        # credentialName
+        self.credential_name = credential_name
+        # credentialSourceType
+        self.credential_source_type = credential_source_type
+        self.enabled = enabled
+        self.page_number = page_number
+        self.page_size = page_size
+        self.provider = provider
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.credential_auth_type is not None:
+            result['credentialAuthType'] = self.credential_auth_type
+        if self.credential_name is not None:
+            result['credentialName'] = self.credential_name
+        if self.credential_source_type is not None:
+            result['credentialSourceType'] = self.credential_source_type
+        if self.enabled is not None:
+            result['enabled'] = self.enabled
+        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.provider is not None:
+            result['provider'] = self.provider
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('credentialAuthType') is not None:
+            self.credential_auth_type = m.get('credentialAuthType')
+        if m.get('credentialName') is not None:
+            self.credential_name = m.get('credentialName')
+        if m.get('credentialSourceType') is not None:
+            self.credential_source_type = m.get('credentialSourceType')
+        if m.get('enabled') is not None:
+            self.enabled = m.get('enabled')
+        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('provider') is not None:
+            self.provider = m.get('provider')
+        return self
+
+
+class ListCredentialsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListCredentialsResult = 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 = ListCredentialsResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListMemoryRequest(TeaModel):
+    def __init__(
+        self,
+        page_number: int = None,
+        page_size: int = None,
+        pattern: str = None,
+    ):
+        # This parameter is required.
+        self.page_number = page_number
+        # This parameter is required.
+        self.page_size = page_size
+        self.pattern = pattern
+
+    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
+        if self.pattern is not None:
+            result['pattern'] = self.pattern
+        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')
+        if m.get('pattern') is not None:
+            self.pattern = m.get('pattern')
+        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 ListModelProvidersRequest(TeaModel):
+    def __init__(
+        self,
+        model_name: str = None,
+        model_type: str = None,
+        page_number: str = None,
+        page_size: str = None,
+        provider: str = None,
+    ):
+        self.model_name = model_name
+        self.model_type = model_type
+        self.page_number = page_number
+        self.page_size = page_size
+        self.provider = provider
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.model_name is not None:
+            result['modelName'] = self.model_name
+        if self.model_type is not None:
+            result['modelType'] = self.model_type
+        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.provider is not None:
+            result['provider'] = self.provider
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('modelName') is not None:
+            self.model_name = m.get('modelName')
+        if m.get('modelType') is not None:
+            self.model_type = m.get('modelType')
+        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('provider') is not None:
+            self.provider = m.get('provider')
+        return self
+
+
+class ListModelProvidersResponseBodyDataItems(TeaModel):
+    def __init__(
+        self,
+        base_url: str = None,
+        model_info_config: ModelInfoConfig = None,
+        model_type: str = None,
+        models: List[str] = None,
+        provider_name: str = None,
+    ):
+        # baseUrl
+        self.base_url = base_url
+        # modelInfoConfig
+        self.model_info_config = model_info_config
+        self.model_type = model_type
+        self.models = models
+        self.provider_name = provider_name
+
+    def validate(self):
+        if self.model_info_config:
+            self.model_info_config.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.base_url is not None:
+            result['baseUrl'] = self.base_url
+        if self.model_info_config is not None:
+            result['modelInfoConfig'] = self.model_info_config.to_map()
+        if self.model_type is not None:
+            result['modelType'] = self.model_type
+        if self.models is not None:
+            result['models'] = self.models
+        if self.provider_name is not None:
+            result['providerName'] = self.provider_name
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('baseUrl') is not None:
+            self.base_url = m.get('baseUrl')
+        if m.get('modelInfoConfig') is not None:
+            temp_model = ModelInfoConfig()
+            self.model_info_config = temp_model.from_map(m['modelInfoConfig'])
+        if m.get('modelType') is not None:
+            self.model_type = m.get('modelType')
+        if m.get('models') is not None:
+            self.models = m.get('models')
+        if m.get('providerName') is not None:
+            self.provider_name = m.get('providerName')
+        return self
+
+
+class ListModelProvidersResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        items: List[ListModelProvidersResponseBodyDataItems] = 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):
+        if self.items:
+            for k in self.items:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        result['items'] = []
+        if self.items is not None:
+            for k in self.items:
+                result['items'].append(k.to_map() if k else None)
+        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()
+        self.items = []
+        if m.get('items') is not None:
+            for k in m.get('items'):
+                temp_model = ListModelProvidersResponseBodyDataItems()
+                self.items.append(temp_model.from_map(k))
+        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 ListModelProvidersResponseBody(TeaModel):
+    def __init__(
+        self,
+        code: str = None,
+        data: ListModelProvidersResponseBodyData = None,
+        request_id: str = None,
+    ):
+        self.code = code
+        self.data = data
+        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 = ListModelProvidersResponseBodyData()
+            self.data = temp_model.from_map(m['data'])
+        if m.get('requestId') is not None:
+            self.request_id = m.get('requestId')
+        return self
+
+
+class ListModelProvidersResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListModelProvidersResponseBody = 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 = ListModelProvidersResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListModelProxiesRequest(TeaModel):
+    def __init__(
+        self,
+        page_number: int = None,
+        page_size: int = None,
+        proxy_mode: str = None,
+        status: str = None,
+    ):
+        self.page_number = page_number
+        self.page_size = page_size
+        # proxyMode
+        self.proxy_mode = proxy_mode
+        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.page_number is not None:
+            result['pageNumber'] = self.page_number
+        if self.page_size is not None:
+            result['pageSize'] = self.page_size
+        if self.proxy_mode is not None:
+            result['proxyMode'] = self.proxy_mode
+        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('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('proxyMode') is not None:
+            self.proxy_mode = m.get('proxyMode')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        return self
+
+
+class ListModelProxiesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListModelProxiesResult = 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 = ListModelProxiesResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListModelServicesRequest(TeaModel):
+    def __init__(
+        self,
+        model_type: str = None,
+        page_number: int = None,
+        page_size: int = None,
+        provider: str = None,
+        provider_type: str = None,
+    ):
+        # This parameter is required.
+        self.model_type = model_type
+        self.page_number = page_number
+        self.page_size = page_size
+        self.provider = provider
+        self.provider_type = provider_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.model_type is not None:
+            result['modelType'] = self.model_type
+        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.provider is not None:
+            result['provider'] = self.provider
+        if self.provider_type is not None:
+            result['providerType'] = self.provider_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('modelType') is not None:
+            self.model_type = m.get('modelType')
+        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('provider') is not None:
+            self.provider = m.get('provider')
+        if m.get('providerType') is not None:
+            self.provider_type = m.get('providerType')
+        return self
+
+
+class ListModelServicesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListModelServicesResult = 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 = ListModelServicesResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListSandboxesRequest(TeaModel):
+    def __init__(
+        self,
+        max_results: int = None,
+        next_token: str = None,
+        status: str = None,
+        template_name: str = None,
+        template_type: str = None,
+    ):
+        # 当前页码，从1开始计数
+        self.max_results = max_results
+        self.next_token = next_token
+        self.status = status
+        # 按模板名称过滤
+        self.template_name = template_name
+        self.template_type = template_type
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.max_results is not None:
+            result['maxResults'] = self.max_results
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        if self.status is not None:
+            result['status'] = self.status
+        if self.template_name is not None:
+            result['templateName'] = self.template_name
+        if self.template_type is not None:
+            result['templateType'] = self.template_type
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('maxResults') is not None:
+            self.max_results = m.get('maxResults')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        if m.get('templateName') is not None:
+            self.template_name = m.get('templateName')
+        if m.get('templateType') is not None:
+            self.template_type = m.get('templateType')
+        return self
+
+
+class ListSandboxesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListSandboxesResult = 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 = ListSandboxesResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class ListTemplatesRequest(TeaModel):
+    def __init__(
+        self,
+        page_number: int = None,
+        page_size: int = None,
+        status: str = None,
+        template_name: str = None,
+        template_type: str = None,
+    ):
+        # 当前页码，从1开始计数
+        self.page_number = page_number
+        # 每页返回的记录数量
+        self.page_size = page_size
+        self.status = status
+        self.template_name = template_name
+        # 按模板类型过滤
+        self.template_type = template_type
+
+    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
+        if self.status is not None:
+            result['status'] = self.status
+        if self.template_name is not None:
+            result['templateName'] = self.template_name
+        if self.template_type is not None:
+            result['templateType'] = self.template_type
+        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')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        if m.get('templateName') is not None:
+            self.template_name = m.get('templateName')
+        if m.get('templateType') is not None:
+            self.template_type = m.get('templateType')
+        return self
+
+
+class ListTemplatesResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListTemplatesResult = 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 = ListTemplatesResult()
+            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 PublishRuntimeVersionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: AgentRuntimeVersionResult = 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 = AgentRuntimeVersionResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class RetrieveMemoryRequestQuery(TeaModel):
+    def __init__(
+        self,
+        memory: str = None,
+        metadata: Dict[str, str] = None,
+        namespace: str = None,
+        user_id: str = None,
+    ):
+        self.memory = memory
+        self.metadata = metadata
+        self.namespace = namespace
+        # This parameter is required.
+        self.user_id = user_id
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        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('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 RetrieveMemoryRequest(TeaModel):
+    def __init__(
+        self,
+        from_: int = None,
+        query: RetrieveMemoryRequestQuery = None,
+        store: str = None,
+        to: int = None,
+        topk: int = None,
+    ):
+        self.from_ = from_
+        # This parameter is required.
+        self.query = query
+        self.store = store
+        self.to = to
+        self.topk = topk
+
+    def validate(self):
+        if self.query:
+            self.query.validate()
+
+    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.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('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 RetrieveMemoryResponseBodyData(TeaModel):
+    def __init__(
+        self,
+        events: List[Dict[str, str]] = None,
+        memories: List[Dict[str, str]] = None,
+    ):
+        self.events = events
+        self.memories = memories
+
+    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
+        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('events') is not None:
+            self.events = m.get('events')
+        if m.get('memories') is not None:
+            self.memories = m.get('memories')
+        return self
+
+
+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: RetrieveMemoryResponseBody = 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 = RetrieveMemoryResponseBody()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class StopSandboxResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: StopSandboxResult = 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 = StopSandboxResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class StopTemplateMCPResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: TemplateResult = 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 = TemplateResult()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class UpdateAgentRuntimeRequest(TeaModel):
+    def __init__(
+        self,
+        body: UpdateAgentRuntimeInput = None,
+    ):
+        # 包含要更新的智能体运行时配置信息的请求体
+        # 
+        # This parameter is required.
+        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 = UpdateAgentRuntimeInput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class UpdateAgentRuntimeResponse(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 UpdateAgentRuntimeEndpointRequest(TeaModel):
+    def __init__(
+        self,
+        body: UpdateAgentRuntimeEndpointInput = None,
+    ):
+        # 包含要更新的智能体运行时端点配置信息的请求体
+        # 
+        # This parameter is required.
+        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 = UpdateAgentRuntimeEndpointInput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
+class UpdateAgentRuntimeEndpointResponse(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 PublishRuntimeVersionRequest(TeaModel):
+class UpdateCredentialRequest(TeaModel):
     def __init__(
         self,
-        body: PublishRuntimeVersionInput = None,
+        body: UpdateCredentialInput = None,
     ):
         self.body = body
 
@@ -12379,17 +14657,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 = UpdateCredentialInput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class PublishRuntimeVersionResponse(TeaModel):
+class UpdateCredentialResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeVersionResult = None,
+        body: CredentialResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12420,24 +14698,21 @@ 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 = CredentialResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class RetrieveMemoryRequestQuery(TeaModel):
+class UpdateMemoryRequest(TeaModel):
     def __init__(
         self,
-        memory: str = None,
-        metadata: Dict[str, str] = None,
-        namespace: str = None,
-        user_id: str = None,
+        long_ttl: int = None,
+        short_ttl: int = None,
+        strategy: List[str] = None,
     ):
-        self.memory = memory
-        self.metadata = metadata
-        self.namespace = namespace
-        # This parameter is required.
-        self.user_id = user_id
+        self.long_ttl = long_ttl
+        self.short_ttl = short_ttl
+        self.strategy = strategy
 
     def validate(self):
         pass
@@ -12448,91 +14723,31 @@ class RetrieveMemoryRequestQuery(TeaModel):
             return _map
 
         result = dict()
-        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('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 RetrieveMemoryRequest(TeaModel):
-    def __init__(
-        self,
-        from_: int = None,
-        query: RetrieveMemoryRequestQuery = None,
-        store: str = None,
-        to: int = None,
-        topk: int = None,
-    ):
-        self.from_ = from_
-        # This parameter is required.
-        self.query = query
-        self.store = store
-        self.to = to
-        self.topk = topk
-
-    def validate(self):
-        if self.query:
-            self.query.validate()
-
-    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.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
+        if self.long_ttl is not None:
+            result['longTtl'] = self.long_ttl
+        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('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')
+        if m.get('longTtl') is not None:
+            self.long_ttl = m.get('longTtl')
+        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 RetrieveMemoryResponseBodyData(TeaModel):
+class UpdateMemoryResponseBodyData(TeaModel):
     def __init__(
         self,
-        events: List[Dict[str, str]] = None,
-        memories: List[Dict[str, str]] = None,
+        cms_workspace_name: str = None,
     ):
-        self.events = events
-        self.memories = memories
+        self.cms_workspace_name = cms_workspace_name
 
     def validate(self):
         pass
@@ -12543,26 +14758,22 @@ class RetrieveMemoryResponseBodyData(TeaModel):
             return _map
 
         result = dict()
-        if self.events is not None:
-            result['events'] = self.events
-        if self.memories is not None:
-            result['memories'] = self.memories
+        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('events') is not None:
-            self.events = m.get('events')
-        if m.get('memories') is not None:
-            self.memories = m.get('memories')
+        if m.get('cmsWorkspaceName') is not None:
+            self.cms_workspace_name = m.get('cmsWorkspaceName')
         return self
 
 
-class RetrieveMemoryResponseBody(TeaModel):
+class UpdateMemoryResponseBody(TeaModel):
     def __init__(
         self,
         code: str = None,
-        data: RetrieveMemoryResponseBodyData = None,
+        data: UpdateMemoryResponseBodyData = None,
         request_id: str = None,
     ):
         self.code = code
@@ -12593,19 +14804,19 @@ class RetrieveMemoryResponseBody(TeaModel):
         if m.get('code') is not None:
             self.code = m.get('code')
         if m.get('data') is not None:
-            temp_model = RetrieveMemoryResponseBodyData()
+            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 RetrieveMemoryResponse(TeaModel):
+class UpdateMemoryResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: RetrieveMemoryResponseBody = None,
+        body: UpdateMemoryResponseBody = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12636,19 +14847,16 @@ class RetrieveMemoryResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = RetrieveMemoryResponseBody()
+            temp_model = UpdateMemoryResponseBody()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class UpdateAgentRuntimeRequest(TeaModel):
+class UpdateModelProxyRequest(TeaModel):
     def __init__(
         self,
-        body: UpdateAgentRuntimeInput = None,
+        body: UpdateModelProxyInput = None,
     ):
-        # 包含要更新的智能体运行时配置信息的请求体
-        # 
-        # This parameter is required.
         self.body = body
 
     def validate(self):
@@ -12668,17 +14876,17 @@ class UpdateAgentRuntimeRequest(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('body') is not None:
-            temp_model = UpdateAgentRuntimeInput()
+            temp_model = UpdateModelProxyInput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class UpdateAgentRuntimeResponse(TeaModel):
+class UpdateModelProxyResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeResult = None,
+        body: ModelProxyResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12709,19 +14917,16 @@ class UpdateAgentRuntimeResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = AgentRuntimeResult()
+            temp_model = ModelProxyResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class UpdateAgentRuntimeEndpointRequest(TeaModel):
+class UpdateModelServiceRequest(TeaModel):
     def __init__(
         self,
-        body: UpdateAgentRuntimeEndpointInput = None,
+        body: UpdateModelServiceInput = None,
     ):
-        # 包含要更新的智能体运行时端点配置信息的请求体
-        # 
-        # This parameter is required.
         self.body = body
 
     def validate(self):
@@ -12741,17 +14946,17 @@ class UpdateAgentRuntimeEndpointRequest(TeaModel):
     def from_map(self, m: dict = None):
         m = m or dict()
         if m.get('body') is not None:
-            temp_model = UpdateAgentRuntimeEndpointInput()
+            temp_model = UpdateModelServiceInput()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class UpdateAgentRuntimeEndpointResponse(TeaModel):
+class UpdateModelServiceResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: AgentRuntimeEndpointResult = None,
+        body: ModelServiceResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12782,92 +14987,27 @@ 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 = ModelServiceResult()
             self.body = temp_model.from_map(m['body'])
         return self
 
 
-class UpdateMemoryRequest(TeaModel):
-    def __init__(
-        self,
-        long_ttl: int = None,
-        short_ttl: int = None,
-        strategy: List[str] = None,
-    ):
-        self.long_ttl = long_ttl
-        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.long_ttl is not None:
-            result['longTtl'] = self.long_ttl
-        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('longTtl') is not None:
-            self.long_ttl = m.get('longTtl')
-        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 UpdateMemoryResponseBodyData(TeaModel):
-    def __init__(
-        self,
-        cms_workspace_name: str = None,
-    ):
-        self.cms_workspace_name = cms_workspace_name
-
-    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
-        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')
-        return self
-
-
-class UpdateMemoryResponseBody(TeaModel):
+class UpdateTemplateRequest(TeaModel):
     def __init__(
         self,
-        code: str = None,
-        data: UpdateMemoryResponseBodyData = None,
-        request_id: str = None,
+        body: UpdateTemplateInput = None,
+        client_token: str = None,
     ):
-        self.code = code
-        self.data = data
-        # Id of the request
-        self.request_id = request_id
+        # 更新模板所需的配置信息
+        # 
+        # This parameter is required.
+        self.body = body
+        # 用于确保请求幂等性的唯一标识符
+        self.client_token = client_token
 
     def validate(self):
-        if self.data:
-            self.data.validate()
+        if self.body:
+            self.body.validate()
 
     def to_map(self):
         _map = super().to_map()
@@ -12875,32 +15015,28 @@ class UpdateMemoryResponseBody(TeaModel):
             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
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        if self.client_token is not None:
+            result['clientToken'] = self.client_token
         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 = UpdateMemoryResponseBodyData()
-            self.data = temp_model.from_map(m['data'])
-        if m.get('requestId') is not None:
-            self.request_id = m.get('requestId')
+        if m.get('body') is not None:
+            temp_model = UpdateTemplateInput()
+            self.body = temp_model.from_map(m['body'])
+        if m.get('clientToken') is not None:
+            self.client_token = m.get('clientToken')
         return self
 
 
-class UpdateMemoryResponse(TeaModel):
+class UpdateTemplateResponse(TeaModel):
     def __init__(
         self,
         headers: Dict[str, str] = None,
         status_code: int = None,
-        body: UpdateMemoryResponseBody = None,
+        body: TemplateResult = None,
     ):
         self.headers = headers
         self.status_code = status_code
@@ -12931,7 +15067,7 @@ class UpdateMemoryResponse(TeaModel):
         if m.get('statusCode') is not None:
             self.status_code = m.get('statusCode')
         if m.get('body') is not None:
-            temp_model = UpdateMemoryResponseBody()
+            temp_model = TemplateResult()
             self.body = temp_model.from_map(m['body'])
         return self