alibabacloud-agentrun20250910 5.1.0__py3-none-any.whl → 5.3.0__py3-none-any.whl

alibabacloud_agentrun20250910/client.py

@@ -479,6 +479,76 @@ class Client(OpenApiClient):
         headers = {}
         return await self.create_credential_with_options_async(request, headers, runtime)
 
+    def create_custom_domain_with_options(
+        self,
+        request: main_models.CreateCustomDomainRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.CreateCustomDomainResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'CreateCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains',
+            method = 'POST',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.CreateCustomDomainResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_custom_domain_with_options_async(
+        self,
+        request: main_models.CreateCustomDomainRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.CreateCustomDomainResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'CreateCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains',
+            method = 'POST',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.CreateCustomDomainResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_custom_domain(
+        self,
+        request: main_models.CreateCustomDomainRequest,
+    ) -> main_models.CreateCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.create_custom_domain_with_options(request, headers, runtime)
+
+    async def create_custom_domain_async(
+        self,
+        request: main_models.CreateCustomDomainRequest,
+    ) -> main_models.CreateCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.create_custom_domain_with_options_async(request, headers, runtime)
+
     def create_knowledge_base_with_options(
         self,
         request: main_models.CreateKnowledgeBaseRequest,
@@ -549,6 +619,76 @@ class Client(OpenApiClient):
         headers = {}
         return await self.create_knowledge_base_with_options_async(request, headers, runtime)
 
+    def create_memory_collection_with_options(
+        self,
+        request: main_models.CreateMemoryCollectionRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.CreateMemoryCollectionResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'CreateMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections',
+            method = 'POST',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.CreateMemoryCollectionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_memory_collection_with_options_async(
+        self,
+        request: main_models.CreateMemoryCollectionRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.CreateMemoryCollectionResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'CreateMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections',
+            method = 'POST',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.CreateMemoryCollectionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_memory_collection(
+        self,
+        request: main_models.CreateMemoryCollectionRequest,
+    ) -> main_models.CreateMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.create_memory_collection_with_options(request, headers, runtime)
+
+    async def create_memory_collection_async(
+        self,
+        request: main_models.CreateMemoryCollectionRequest,
+    ) -> main_models.CreateMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.create_memory_collection_with_options_async(request, headers, runtime)
+
     def create_model_proxy_with_options(
         self,
         request: main_models.CreateModelProxyRequest,
@@ -1163,6 +1303,72 @@ class Client(OpenApiClient):
         headers = {}
         return await self.delete_credential_with_options_async(credential_name, headers, runtime)
 
+    def delete_custom_domain_with_options(
+        self,
+        domain_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.DeleteCustomDomainResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'DeleteCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains/{DaraURL.percent_encode(domain_name)}',
+            method = 'DELETE',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.DeleteCustomDomainResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_custom_domain_with_options_async(
+        self,
+        domain_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.DeleteCustomDomainResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'DeleteCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains/{DaraURL.percent_encode(domain_name)}',
+            method = 'DELETE',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.DeleteCustomDomainResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_custom_domain(
+        self,
+        domain_name: str,
+    ) -> main_models.DeleteCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.delete_custom_domain_with_options(domain_name, headers, runtime)
+
+    async def delete_custom_domain_async(
+        self,
+        domain_name: str,
+    ) -> main_models.DeleteCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.delete_custom_domain_with_options_async(domain_name, headers, runtime)
+
     def delete_knowledge_base_with_options(
         self,
         knowledge_base_name: str,
@@ -1229,6 +1435,72 @@ class Client(OpenApiClient):
         headers = {}
         return await self.delete_knowledge_base_with_options_async(knowledge_base_name, headers, runtime)
 
+    def delete_memory_collection_with_options(
+        self,
+        memory_collection_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.DeleteMemoryCollectionResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'DeleteMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
+            method = 'DELETE',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.DeleteMemoryCollectionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_memory_collection_with_options_async(
+        self,
+        memory_collection_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.DeleteMemoryCollectionResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'DeleteMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
+            method = 'DELETE',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.DeleteMemoryCollectionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_memory_collection(
+        self,
+        memory_collection_name: str,
+    ) -> main_models.DeleteMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.delete_memory_collection_with_options(memory_collection_name, headers, runtime)
+
+    async def delete_memory_collection_async(
+        self,
+        memory_collection_name: str,
+    ) -> main_models.DeleteMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.delete_memory_collection_with_options_async(memory_collection_name, headers, runtime)
+
     def delete_model_proxy_with_options(
         self,
         model_proxy_name: str,
@@ -1923,22 +2195,154 @@ class Client(OpenApiClient):
     ) -> main_models.GetCredentialResponse:
         runtime = RuntimeOptions()
         headers = {}
-        return await self.get_credential_with_options_async(credential_name, headers, runtime)
+        return await self.get_credential_with_options_async(credential_name, headers, runtime)
+
+    def get_custom_domain_with_options(
+        self,
+        domain_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.GetCustomDomainResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'GetCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains/{DaraURL.percent_encode(domain_name)}',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.GetCustomDomainResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_custom_domain_with_options_async(
+        self,
+        domain_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.GetCustomDomainResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'GetCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains/{DaraURL.percent_encode(domain_name)}',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.GetCustomDomainResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_custom_domain(
+        self,
+        domain_name: str,
+    ) -> main_models.GetCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.get_custom_domain_with_options(domain_name, headers, runtime)
+
+    async def get_custom_domain_async(
+        self,
+        domain_name: str,
+    ) -> main_models.GetCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.get_custom_domain_with_options_async(domain_name, headers, runtime)
+
+    def get_knowledge_base_with_options(
+        self,
+        knowledge_base_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.GetKnowledgeBaseResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'GetKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.GetKnowledgeBaseResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_knowledge_base_with_options_async(
+        self,
+        knowledge_base_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.GetKnowledgeBaseResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'GetKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.GetKnowledgeBaseResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_knowledge_base(
+        self,
+        knowledge_base_name: str,
+    ) -> main_models.GetKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.get_knowledge_base_with_options(knowledge_base_name, headers, runtime)
+
+    async def get_knowledge_base_async(
+        self,
+        knowledge_base_name: str,
+    ) -> main_models.GetKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.get_knowledge_base_with_options_async(knowledge_base_name, headers, runtime)
 
-    def get_knowledge_base_with_options(
+    def get_memory_collection_with_options(
         self,
-        knowledge_base_name: str,
+        memory_collection_name: str,
         headers: Dict[str, str],
         runtime: RuntimeOptions,
-    ) -> main_models.GetKnowledgeBaseResponse:
+    ) -> main_models.GetMemoryCollectionResponse:
         req = open_api_util_models.OpenApiRequest(
             headers = headers
         )
         params = open_api_util_models.Params(
-            action = 'GetKnowledgeBase',
+            action = 'GetMemoryCollection',
             version = '2025-09-10',
             protocol = 'HTTPS',
-            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
             method = 'GET',
             auth_type = 'AK',
             style = 'ROA',
@@ -1946,24 +2350,24 @@ class Client(OpenApiClient):
             body_type = 'json'
         )
         return DaraCore.from_map(
-            main_models.GetKnowledgeBaseResponse(),
+            main_models.GetMemoryCollectionResponse(),
             self.call_api(params, req, runtime)
         )
 
-    async def get_knowledge_base_with_options_async(
+    async def get_memory_collection_with_options_async(
         self,
-        knowledge_base_name: str,
+        memory_collection_name: str,
         headers: Dict[str, str],
         runtime: RuntimeOptions,
-    ) -> main_models.GetKnowledgeBaseResponse:
+    ) -> main_models.GetMemoryCollectionResponse:
         req = open_api_util_models.OpenApiRequest(
             headers = headers
         )
         params = open_api_util_models.Params(
-            action = 'GetKnowledgeBase',
+            action = 'GetMemoryCollection',
             version = '2025-09-10',
             protocol = 'HTTPS',
-            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
             method = 'GET',
             auth_type = 'AK',
             style = 'ROA',
@@ -1971,25 +2375,25 @@ class Client(OpenApiClient):
             body_type = 'json'
         )
         return DaraCore.from_map(
-            main_models.GetKnowledgeBaseResponse(),
+            main_models.GetMemoryCollectionResponse(),
             await self.call_api_async(params, req, runtime)
         )
 
-    def get_knowledge_base(
+    def get_memory_collection(
         self,
-        knowledge_base_name: str,
-    ) -> main_models.GetKnowledgeBaseResponse:
+        memory_collection_name: str,
+    ) -> main_models.GetMemoryCollectionResponse:
         runtime = RuntimeOptions()
         headers = {}
-        return self.get_knowledge_base_with_options(knowledge_base_name, headers, runtime)
+        return self.get_memory_collection_with_options(memory_collection_name, headers, runtime)
 
-    async def get_knowledge_base_async(
+    async def get_memory_collection_async(
         self,
-        knowledge_base_name: str,
-    ) -> main_models.GetKnowledgeBaseResponse:
+        memory_collection_name: str,
+    ) -> main_models.GetMemoryCollectionResponse:
         runtime = RuntimeOptions()
         headers = {}
-        return await self.get_knowledge_base_with_options_async(knowledge_base_name, headers, runtime)
+        return await self.get_memory_collection_with_options_async(memory_collection_name, headers, runtime)
 
     def get_model_proxy_with_options(
         self,
@@ -2795,6 +3199,98 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_credentials_with_options_async(request, headers, runtime)
 
+    def list_custom_domains_with_options(
+        self,
+        request: main_models.ListCustomDomainsRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.ListCustomDomainsResponse:
+        request.validate()
+        query = {}
+        if not DaraCore.is_null(request.domain_name):
+            query['domainName'] = request.domain_name
+        if not DaraCore.is_null(request.page_number):
+            query['pageNumber'] = request.page_number
+        if not DaraCore.is_null(request.page_size):
+            query['pageSize'] = request.page_size
+        if not DaraCore.is_null(request.resource_name):
+            query['resourceName'] = request.resource_name
+        if not DaraCore.is_null(request.resource_type):
+            query['resourceType'] = request.resource_type
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            query = Utils.query(query)
+        )
+        params = open_api_util_models.Params(
+            action = 'ListCustomDomains',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.ListCustomDomainsResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_custom_domains_with_options_async(
+        self,
+        request: main_models.ListCustomDomainsRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.ListCustomDomainsResponse:
+        request.validate()
+        query = {}
+        if not DaraCore.is_null(request.domain_name):
+            query['domainName'] = request.domain_name
+        if not DaraCore.is_null(request.page_number):
+            query['pageNumber'] = request.page_number
+        if not DaraCore.is_null(request.page_size):
+            query['pageSize'] = request.page_size
+        if not DaraCore.is_null(request.resource_name):
+            query['resourceName'] = request.resource_name
+        if not DaraCore.is_null(request.resource_type):
+            query['resourceType'] = request.resource_type
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            query = Utils.query(query)
+        )
+        params = open_api_util_models.Params(
+            action = 'ListCustomDomains',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.ListCustomDomainsResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_custom_domains(
+        self,
+        request: main_models.ListCustomDomainsRequest,
+    ) -> main_models.ListCustomDomainsResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.list_custom_domains_with_options(request, headers, runtime)
+
+    async def list_custom_domains_async(
+        self,
+        request: main_models.ListCustomDomainsRequest,
+    ) -> main_models.ListCustomDomainsResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.list_custom_domains_with_options_async(request, headers, runtime)
+
     def list_knowledge_bases_with_options(
         self,
         request: main_models.ListKnowledgeBasesRequest,
@@ -2879,6 +3375,98 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_knowledge_bases_with_options_async(request, headers, runtime)
 
+    def list_memory_collections_with_options(
+        self,
+        request: main_models.ListMemoryCollectionsRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.ListMemoryCollectionsResponse:
+        request.validate()
+        query = {}
+        if not DaraCore.is_null(request.memory_collection_name):
+            query['memoryCollectionName'] = request.memory_collection_name
+        if not DaraCore.is_null(request.page_number):
+            query['pageNumber'] = request.page_number
+        if not DaraCore.is_null(request.page_size):
+            query['pageSize'] = request.page_size
+        if not DaraCore.is_null(request.status):
+            query['status'] = request.status
+        if not DaraCore.is_null(request.type):
+            query['type'] = request.type
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            query = Utils.query(query)
+        )
+        params = open_api_util_models.Params(
+            action = 'ListMemoryCollections',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.ListMemoryCollectionsResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_memory_collections_with_options_async(
+        self,
+        request: main_models.ListMemoryCollectionsRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.ListMemoryCollectionsResponse:
+        request.validate()
+        query = {}
+        if not DaraCore.is_null(request.memory_collection_name):
+            query['memoryCollectionName'] = request.memory_collection_name
+        if not DaraCore.is_null(request.page_number):
+            query['pageNumber'] = request.page_number
+        if not DaraCore.is_null(request.page_size):
+            query['pageSize'] = request.page_size
+        if not DaraCore.is_null(request.status):
+            query['status'] = request.status
+        if not DaraCore.is_null(request.type):
+            query['type'] = request.type
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            query = Utils.query(query)
+        )
+        params = open_api_util_models.Params(
+            action = 'ListMemoryCollections',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.ListMemoryCollectionsResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_memory_collections(
+        self,
+        request: main_models.ListMemoryCollectionsRequest,
+    ) -> main_models.ListMemoryCollectionsResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.list_memory_collections_with_options(request, headers, runtime)
+
+    async def list_memory_collections_async(
+        self,
+        request: main_models.ListMemoryCollectionsRequest,
+    ) -> main_models.ListMemoryCollectionsResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.list_memory_collections_with_options_async(request, headers, runtime)
+
     def list_model_providers_with_options(
         self,
         request: main_models.ListModelProvidersRequest,
@@ -3767,6 +4355,80 @@ class Client(OpenApiClient):
         headers = {}
         return await self.update_credential_with_options_async(credential_name, request, headers, runtime)
 
+    def update_custom_domain_with_options(
+        self,
+        domain_name: str,
+        request: main_models.UpdateCustomDomainRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.UpdateCustomDomainResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'UpdateCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains/{DaraURL.percent_encode(domain_name)}',
+            method = 'PUT',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.UpdateCustomDomainResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def update_custom_domain_with_options_async(
+        self,
+        domain_name: str,
+        request: main_models.UpdateCustomDomainRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.UpdateCustomDomainResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'UpdateCustomDomain',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/custom-domains/{DaraURL.percent_encode(domain_name)}',
+            method = 'PUT',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.UpdateCustomDomainResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def update_custom_domain(
+        self,
+        domain_name: str,
+        request: main_models.UpdateCustomDomainRequest,
+    ) -> main_models.UpdateCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.update_custom_domain_with_options(domain_name, request, headers, runtime)
+
+    async def update_custom_domain_async(
+        self,
+        domain_name: str,
+        request: main_models.UpdateCustomDomainRequest,
+    ) -> main_models.UpdateCustomDomainResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.update_custom_domain_with_options_async(domain_name, request, headers, runtime)
+
     def update_knowledge_base_with_options(
         self,
         knowledge_base_name: str,
@@ -3841,6 +4503,80 @@ class Client(OpenApiClient):
         headers = {}
         return await self.update_knowledge_base_with_options_async(knowledge_base_name, request, headers, runtime)
 
+    def update_memory_collection_with_options(
+        self,
+        memory_collection_name: str,
+        request: main_models.UpdateMemoryCollectionRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.UpdateMemoryCollectionResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'UpdateMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
+            method = 'PUT',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.UpdateMemoryCollectionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def update_memory_collection_with_options_async(
+        self,
+        memory_collection_name: str,
+        request: main_models.UpdateMemoryCollectionRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.UpdateMemoryCollectionResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'UpdateMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
+            method = 'PUT',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.UpdateMemoryCollectionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def update_memory_collection(
+        self,
+        memory_collection_name: str,
+        request: main_models.UpdateMemoryCollectionRequest,
+    ) -> main_models.UpdateMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.update_memory_collection_with_options(memory_collection_name, request, headers, runtime)
+
+    async def update_memory_collection_async(
+        self,
+        memory_collection_name: str,
+        request: main_models.UpdateMemoryCollectionRequest,
+    ) -> main_models.UpdateMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.update_memory_collection_with_options_async(memory_collection_name, request, headers, runtime)
+
     def update_model_proxy_with_options(
         self,
         model_proxy_name: str,