alibabacloud-agentrun20250910 5.0.0__py3-none-any.whl → 5.2.0__py3-none-any.whl

alibabacloud_agentrun20250910/client.py

@@ -479,6 +479,146 @@ class Client(OpenApiClient):
         headers = {}
         return await self.create_credential_with_options_async(request, headers, runtime)
 
+    def create_knowledge_base_with_options(
+        self,
+        request: main_models.CreateKnowledgeBaseRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.CreateKnowledgeBaseResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'CreateKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases',
+            method = 'POST',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.CreateKnowledgeBaseResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_knowledge_base_with_options_async(
+        self,
+        request: main_models.CreateKnowledgeBaseRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.CreateKnowledgeBaseResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'CreateKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases',
+            method = 'POST',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.CreateKnowledgeBaseResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_knowledge_base(
+        self,
+        request: main_models.CreateKnowledgeBaseRequest,
+    ) -> main_models.CreateKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.create_knowledge_base_with_options(request, headers, runtime)
+
+    async def create_knowledge_base_async(
+        self,
+        request: main_models.CreateKnowledgeBaseRequest,
+    ) -> main_models.CreateKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        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,
@@ -1093,6 +1233,138 @@ class Client(OpenApiClient):
         headers = {}
         return await self.delete_credential_with_options_async(credential_name, headers, runtime)
 
+    def delete_knowledge_base_with_options(
+        self,
+        knowledge_base_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.DeleteKnowledgeBaseResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'DeleteKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            method = 'DELETE',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.DeleteKnowledgeBaseResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_knowledge_base_with_options_async(
+        self,
+        knowledge_base_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.DeleteKnowledgeBaseResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'DeleteKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            method = 'DELETE',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.DeleteKnowledgeBaseResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_knowledge_base(
+        self,
+        knowledge_base_name: str,
+    ) -> main_models.DeleteKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.delete_knowledge_base_with_options(knowledge_base_name, headers, runtime)
+
+    async def delete_knowledge_base_async(
+        self,
+        knowledge_base_name: str,
+    ) -> main_models.DeleteKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        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,
@@ -1789,6 +2061,138 @@ class Client(OpenApiClient):
         headers = {}
         return await self.get_credential_with_options_async(credential_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_memory_collection_with_options(
+        self,
+        memory_collection_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.GetMemoryCollectionResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'GetMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.GetMemoryCollectionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_memory_collection_with_options_async(
+        self,
+        memory_collection_name: str,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.GetMemoryCollectionResponse:
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers
+        )
+        params = open_api_util_models.Params(
+            action = 'GetMemoryCollection',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/memory-collections/{DaraURL.percent_encode(memory_collection_name)}',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.GetMemoryCollectionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_memory_collection(
+        self,
+        memory_collection_name: str,
+    ) -> main_models.GetMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.get_memory_collection_with_options(memory_collection_name, headers, runtime)
+
+    async def get_memory_collection_async(
+        self,
+        memory_collection_name: str,
+    ) -> main_models.GetMemoryCollectionResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return await self.get_memory_collection_with_options_async(memory_collection_name, headers, runtime)
+
     def get_model_proxy_with_options(
         self,
         model_proxy_name: str,
@@ -2593,6 +2997,182 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_credentials_with_options_async(request, headers, runtime)
 
+    def list_knowledge_bases_with_options(
+        self,
+        request: main_models.ListKnowledgeBasesRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.ListKnowledgeBasesResponse:
+        request.validate()
+        query = {}
+        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.provider):
+            query['provider'] = request.provider
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            query = Utils.query(query)
+        )
+        params = open_api_util_models.Params(
+            action = 'ListKnowledgeBases',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.ListKnowledgeBasesResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_knowledge_bases_with_options_async(
+        self,
+        request: main_models.ListKnowledgeBasesRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.ListKnowledgeBasesResponse:
+        request.validate()
+        query = {}
+        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.provider):
+            query['provider'] = request.provider
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            query = Utils.query(query)
+        )
+        params = open_api_util_models.Params(
+            action = 'ListKnowledgeBases',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases',
+            method = 'GET',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.ListKnowledgeBasesResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_knowledge_bases(
+        self,
+        request: main_models.ListKnowledgeBasesRequest,
+    ) -> main_models.ListKnowledgeBasesResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.list_knowledge_bases_with_options(request, headers, runtime)
+
+    async def list_knowledge_bases_async(
+        self,
+        request: main_models.ListKnowledgeBasesRequest,
+    ) -> main_models.ListKnowledgeBasesResponse:
+        runtime = RuntimeOptions()
+        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,
@@ -3481,6 +4061,154 @@ class Client(OpenApiClient):
         headers = {}
         return await self.update_credential_with_options_async(credential_name, request, headers, runtime)
 
+    def update_knowledge_base_with_options(
+        self,
+        knowledge_base_name: str,
+        request: main_models.UpdateKnowledgeBaseRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.UpdateKnowledgeBaseResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'UpdateKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            method = 'PUT',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.UpdateKnowledgeBaseResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def update_knowledge_base_with_options_async(
+        self,
+        knowledge_base_name: str,
+        request: main_models.UpdateKnowledgeBaseRequest,
+        headers: Dict[str, str],
+        runtime: RuntimeOptions,
+    ) -> main_models.UpdateKnowledgeBaseResponse:
+        request.validate()
+        req = open_api_util_models.OpenApiRequest(
+            headers = headers,
+            body = Utils.parse_to_map(request.body)
+        )
+        params = open_api_util_models.Params(
+            action = 'UpdateKnowledgeBase',
+            version = '2025-09-10',
+            protocol = 'HTTPS',
+            pathname = f'/2025-09-10/agents/knowledgebases/{DaraURL.percent_encode(knowledge_base_name)}',
+            method = 'PUT',
+            auth_type = 'AK',
+            style = 'ROA',
+            req_body_type = 'json',
+            body_type = 'json'
+        )
+        return DaraCore.from_map(
+            main_models.UpdateKnowledgeBaseResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def update_knowledge_base(
+        self,
+        knowledge_base_name: str,
+        request: main_models.UpdateKnowledgeBaseRequest,
+    ) -> main_models.UpdateKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        headers = {}
+        return self.update_knowledge_base_with_options(knowledge_base_name, request, headers, runtime)
+
+    async def update_knowledge_base_async(
+        self,
+        knowledge_base_name: str,
+        request: main_models.UpdateKnowledgeBaseRequest,
+    ) -> main_models.UpdateKnowledgeBaseResponse:
+        runtime = RuntimeOptions()
+        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,