From 8b378ff95dfcf5894ae04ae50d9c9d0aea94e662 Mon Sep 17 00:00:00 2001 From: Google Cloud SDK Librarian Date: Fri, 17 Apr 2026 07:09:20 +0000 Subject: [PATCH] regen: Regenerate Google.Cloud.AIPlatform.V1 at API commit 1a00cec feat: Add asyncQueryReasoningEngine to aiplatform v1 API PiperOrigin-RevId: 900907134 Source-Link: https://github.com/googleapis/googleapis/commit/1a00cecd9a90ac056247d5b522e94af5347adc1d --- ...soningEngineRequestObjectAsyncSnippet.g.cs | 66 ++ ...ryReasoningEngineRequestObjectSnippet.g.cs | 65 ++ ...t_metadata_google.cloud.aiplatform.v1.json | 97 +++ ...gEngineExecutionServiceClientSnippets.g.cs | 70 ++ .../ReasoningEngineExecutionService.g.cs | 785 +++++++++++++++++- ...ReasoningEngineExecutionServiceClient.g.cs | 140 ++++ .../ReasoningEngineExecutionServiceGrpc.g.cs | 78 +- ...ngEngineExecutionServiceResourceNames.g.cs | 12 + .../gapic_metadata.json | 6 + generator-input/pipeline-state.json | 2 +- 10 files changed, 1288 insertions(+), 33 deletions(-) create mode 100644 apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs new file mode 100644 index 000000000000..3594ffe6e722 --- /dev/null +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs @@ -0,0 +1,66 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async] + using Google.Cloud.AIPlatform.V1; + using Google.LongRunning; + using System.Threading.Tasks; + + public sealed partial class GeneratedReasoningEngineExecutionServiceClientSnippets + { + /// Snippet for AsyncQueryReasoningEngineAsync + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public async Task AsyncQueryReasoningEngineRequestObjectAsync() + { + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = await ReasoningEngineExecutionServiceClient.CreateAsync(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = await reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngineAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + } + } + // [END aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async] +} diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs new file mode 100644 index 000000000000..d8a5d7938f78 --- /dev/null +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs @@ -0,0 +1,65 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync] + using Google.Cloud.AIPlatform.V1; + using Google.LongRunning; + + public sealed partial class GeneratedReasoningEngineExecutionServiceClientSnippets + { + /// Snippet for AsyncQueryReasoningEngine + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public void AsyncQueryReasoningEngineRequestObject() + { + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = ReasoningEngineExecutionServiceClient.Create(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngine(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + } + } + // [END aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync] +} diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json index 7d3ef4ed2817..c2c4b636bffc 100644 --- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json @@ -72222,6 +72222,103 @@ } ] }, + { + "regionTag": "aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync", + "title": "AsyncQueryReasoningEngineRequestObject", + "description": "Snippet for AsyncQueryReasoningEngine", + "file": "ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "AsyncQueryReasoningEngine", + "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine", + "parameters": [ + { + "type": "Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.LongRunning.Operation", + "client": { + "shortName": "ReasoningEngineExecutionServiceClient", + "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient" + }, + "method": { + "shortName": "AsyncQueryReasoningEngine", + "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine", + "service": { + "shortName": "ReasoningEngineExecutionService", + "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 63, + "type": "FULL" + }, + { + "start": 35, + "end": 61, + "type": "SHORT" + } + ] + }, + { + "regionTag": "aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async", + "title": "AsyncQueryReasoningEngineRequestObjectAsync", + "description": "Snippet for AsyncQueryReasoningEngineAsync", + "file": "ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "AsyncQueryReasoningEngineAsync", + "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "System.Threading.Tasks.Task>", + "client": { + "shortName": "ReasoningEngineExecutionServiceClient", + "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient" + }, + "method": { + "shortName": "AsyncQueryReasoningEngine", + "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine", + "service": { + "shortName": "ReasoningEngineExecutionService", + "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 64, + "type": "FULL" + }, + { + "start": 36, + "end": 62, + "type": "SHORT" + } + ] + }, { "regionTag": "aiplatform_v1_generated_ReasoningEngineService_CreateReasoningEngine_sync", "title": "CreateReasoningEngineRequestObject", diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs index c51cafb1c8a1..bcf1cf51e043 100644 --- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs @@ -19,6 +19,7 @@ namespace GoogleCSharpSnippets using Google.Api; using Google.Api.Gax.Grpc; using Google.Cloud.AIPlatform.V1; + using Google.LongRunning; using Google.Protobuf.WellKnownTypes; using System.Threading.Tasks; @@ -89,5 +90,74 @@ public async Task StreamQueryReasoningEngineRequestObject() // The response stream has completed // End snippet } + + /// Snippet for AsyncQueryReasoningEngine + public void AsyncQueryReasoningEngineRequestObject() + { + // Snippet: AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest, CallSettings) + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = ReasoningEngineExecutionServiceClient.Create(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngine(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for AsyncQueryReasoningEngineAsync + public async Task AsyncQueryReasoningEngineRequestObjectAsync() + { + // Snippet: AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest, CallSettings) + // Additional: AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest, CancellationToken) + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = await ReasoningEngineExecutionServiceClient.CreateAsync(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = await reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngineAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + // End snippet + } } } diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs index 3413125504a3..8771f80695bd 100644 --- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs @@ -29,40 +29,59 @@ static ReasoningEngineExecutionServiceReflection() { "Zm9ybS52MRocZ29vZ2xlL2FwaS9hbm5vdGF0aW9ucy5wcm90bxoXZ29vZ2xl", "L2FwaS9jbGllbnQucHJvdG8aH2dvb2dsZS9hcGkvZmllbGRfYmVoYXZpb3Iu", "cHJvdG8aGWdvb2dsZS9hcGkvaHR0cGJvZHkucHJvdG8aGWdvb2dsZS9hcGkv", - "cmVzb3VyY2UucHJvdG8aHGdvb2dsZS9wcm90b2J1Zi9zdHJ1Y3QucHJvdG8i", - "pgEKG1F1ZXJ5UmVhc29uaW5nRW5naW5lUmVxdWVzdBI/CgRuYW1lGAEgASgJ", - "QjHgQQL6QSsKKWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb20vUmVhc29uaW5n", - "RW5naW5lEisKBWlucHV0GAIgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVj", - "dEID4EEBEhkKDGNsYXNzX21ldGhvZBgDIAEoCUID4EEBIkYKHFF1ZXJ5UmVh", - "c29uaW5nRW5naW5lUmVzcG9uc2USJgoGb3V0cHV0GAEgASgLMhYuZ29vZ2xl", - "LnByb3RvYnVmLlZhbHVlIqwBCiFTdHJlYW1RdWVyeVJlYXNvbmluZ0VuZ2lu", - "ZVJlcXVlc3QSPwoEbmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdv", - "b2dsZWFwaXMuY29tL1JlYXNvbmluZ0VuZ2luZRIrCgVpbnB1dBgCIAEoCzIX", - "Lmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RCA+BBARIZCgxjbGFzc19tZXRob2QY", - "AyABKAlCA+BBATKGBAofUmVhc29uaW5nRW5naW5lRXhlY3V0aW9uU2Vydmlj", - "ZRLQAQoUUXVlcnlSZWFzb25pbmdFbmdpbmUSNy5nb29nbGUuY2xvdWQuYWlw", - "bGF0Zm9ybS52MS5RdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QaOC5nb29n", - "bGUuY2xvdWQuYWlwbGF0Zm9ybS52MS5RdWVyeVJlYXNvbmluZ0VuZ2luZVJl", - "c3BvbnNlIkWC0+STAj8iOi92MS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9u", - "cy8qL3JlYXNvbmluZ0VuZ2luZXMvKn06cXVlcnk6ASoSwAEKGlN0cmVhbVF1", - "ZXJ5UmVhc29uaW5nRW5naW5lEj0uZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0u", - "djEuU3RyZWFtUXVlcnlSZWFzb25pbmdFbmdpbmVSZXF1ZXN0GhQuZ29vZ2xl", - "LmFwaS5IdHRwQm9keSJLgtPkkwJFIkAvdjEve25hbWU9cHJvamVjdHMvKi9s", - "b2NhdGlvbnMvKi9yZWFzb25pbmdFbmdpbmVzLyp9OnN0cmVhbVF1ZXJ5OgEq", - "MAEaTcpBGWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb23SQS5odHRwczovL3d3", - "dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQuIBCh5jb20u", - "Z29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjFCJFJlYXNvbmluZ0VuZ2luZUV4", - "ZWN1dGlvblNlcnZpY2VQcm90b1ABWj5jbG91ZC5nb29nbGUuY29tL2dvL2Fp", - "cGxhdGZvcm0vYXBpdjEvYWlwbGF0Zm9ybXBiO2FpcGxhdGZvcm1wYqoCGkdv", - "b2dsZS5DbG91ZC5BSVBsYXRmb3JtLlYxygIaR29vZ2xlXENsb3VkXEFJUGxh", - "dGZvcm1cVjHqAh1Hb29nbGU6OkNsb3VkOjpBSVBsYXRmb3JtOjpWMWIGcHJv", - "dG8z")); + "cmVzb3VyY2UucHJvdG8aKmdvb2dsZS9jbG91ZC9haXBsYXRmb3JtL3YxL29w", + "ZXJhdGlvbi5wcm90bxojZ29vZ2xlL2xvbmdydW5uaW5nL29wZXJhdGlvbnMu", + "cHJvdG8aHGdvb2dsZS9wcm90b2J1Zi9zdHJ1Y3QucHJvdG8ipgEKG1F1ZXJ5", + "UmVhc29uaW5nRW5naW5lUmVxdWVzdBI/CgRuYW1lGAEgASgJQjHgQQL6QSsK", + "KWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb20vUmVhc29uaW5nRW5naW5lEisK", + "BWlucHV0GAIgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVjdEID4EEBEhkK", + "DGNsYXNzX21ldGhvZBgDIAEoCUID4EEBIkYKHFF1ZXJ5UmVhc29uaW5nRW5n", + "aW5lUmVzcG9uc2USJgoGb3V0cHV0GAEgASgLMhYuZ29vZ2xlLnByb3RvYnVm", + "LlZhbHVlIqwBCiFTdHJlYW1RdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QS", + "PwoEbmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdvb2dsZWFwaXMu", + "Y29tL1JlYXNvbmluZ0VuZ2luZRIrCgVpbnB1dBgCIAEoCzIXLmdvb2dsZS5w", + "cm90b2J1Zi5TdHJ1Y3RCA+BBARIZCgxjbGFzc19tZXRob2QYAyABKAlCA+BB", + "ASKcAQogQXN5bmNRdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QSPwoEbmFt", + "ZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdvb2dsZWFwaXMuY29tL1Jl", + "YXNvbmluZ0VuZ2luZRIaCg1pbnB1dF9nY3NfdXJpGAIgASgJQgPgQQESGwoO", + "b3V0cHV0X2djc191cmkYAyABKAlCA+BBASJ8CipBc3luY1F1ZXJ5UmVhc29u", + "aW5nRW5naW5lT3BlcmF0aW9uTWV0YWRhdGESTgoQZ2VuZXJpY19tZXRhZGF0", + "YRgBIAEoCzI0Lmdvb2dsZS5jbG91ZC5haXBsYXRmb3JtLnYxLkdlbmVyaWNP", + "cGVyYXRpb25NZXRhZGF0YSI7CiFBc3luY1F1ZXJ5UmVhc29uaW5nRW5naW5l", + "UmVzcG9uc2USFgoOb3V0cHV0X2djc191cmkYASABKAkyzwYKH1JlYXNvbmlu", + "Z0VuZ2luZUV4ZWN1dGlvblNlcnZpY2US0AEKFFF1ZXJ5UmVhc29uaW5nRW5n", + "aW5lEjcuZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjEuUXVlcnlSZWFzb25p", + "bmdFbmdpbmVSZXF1ZXN0GjguZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjEu", + "UXVlcnlSZWFzb25pbmdFbmdpbmVSZXNwb25zZSJFgtPkkwI/IjovdjEve25h", + "bWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9yZWFzb25pbmdFbmdpbmVzLyp9", + "OnF1ZXJ5OgEqEsABChpTdHJlYW1RdWVyeVJlYXNvbmluZ0VuZ2luZRI9Lmdv", + "b2dsZS5jbG91ZC5haXBsYXRmb3JtLnYxLlN0cmVhbVF1ZXJ5UmVhc29uaW5n", + "RW5naW5lUmVxdWVzdBoULmdvb2dsZS5hcGkuSHR0cEJvZHkiS4LT5JMCRSJA", + "L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zLyovcmVhc29uaW5nRW5n", + "aW5lcy8qfTpzdHJlYW1RdWVyeToBKjABEsYCChlBc3luY1F1ZXJ5UmVhc29u", + "aW5nRW5naW5lEjwuZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjEuQXN5bmNR", + "dWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5p", + "bmcuT3BlcmF0aW9uIssBykFPCiFBc3luY1F1ZXJ5UmVhc29uaW5nRW5naW5l", + "UmVzcG9uc2USKkFzeW5jUXVlcnlSZWFzb25pbmdFbmdpbmVPcGVyYXRpb25N", + "ZXRhZGF0YYLT5JMCcyI/L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25z", + "LyovcmVhc29uaW5nRW5naW5lcy8qfTphc3luY1F1ZXJ5OgEqWi0iKC92MS97", + "bmFtZT1yZWFzb25pbmdFbmdpbmVzLyp9OmFzeW5jUXVlcnk6ASoaTcpBGWFp", + "cGxhdGZvcm0uZ29vZ2xlYXBpcy5jb23SQS5odHRwczovL3d3dy5nb29nbGVh", + "cGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQuIBCh5jb20uZ29vZ2xlLmNs", + "b3VkLmFpcGxhdGZvcm0udjFCJFJlYXNvbmluZ0VuZ2luZUV4ZWN1dGlvblNl", + "cnZpY2VQcm90b1ABWj5jbG91ZC5nb29nbGUuY29tL2dvL2FpcGxhdGZvcm0v", + "YXBpdjEvYWlwbGF0Zm9ybXBiO2FpcGxhdGZvcm1wYqoCGkdvb2dsZS5DbG91", + "ZC5BSVBsYXRmb3JtLlYxygIaR29vZ2xlXENsb3VkXEFJUGxhdGZvcm1cVjHq", + "Ah1Hb29nbGU6OkNsb3VkOjpBSVBsYXRmb3JtOjpWMWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.HttpbodyReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.HttpbodyReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.AIPlatform.V1.OperationReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse), global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse.Parser, new[]{ "Output" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest.Parser, new[]{ "Name", "InputGcsUri", "OutputGcsUri" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineOperationMetadata), global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineOperationMetadata.Parser, new[]{ "GenericMetadata" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineResponse), global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineResponse.Parser, new[]{ "OutputGcsUri" }, null, null, null, null) })); } #endregion @@ -876,6 +895,712 @@ public void MergeFrom(pb::CodedInputStream input) { } + /// + /// Request message for + /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AsyncQueryReasoningEngineRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AsyncQueryReasoningEngineRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineRequest(AsyncQueryReasoningEngineRequest other) : this() { + name_ = other.name_; + inputGcsUri_ = other.inputGcsUri_; + outputGcsUri_ = other.outputGcsUri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineRequest Clone() { + return new AsyncQueryReasoningEngineRequest(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Required. The name of the ReasoningEngine resource to use. + /// Format: + /// `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "input_gcs_uri" field. + public const int InputGcsUriFieldNumber = 2; + private string inputGcsUri_ = ""; + /// + /// Optional. Input Cloud Storage URI for the Async query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InputGcsUri { + get { return inputGcsUri_; } + set { + inputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "output_gcs_uri" field. + public const int OutputGcsUriFieldNumber = 3; + private string outputGcsUri_ = ""; + /// + /// Optional. Output Cloud Storage URI for the Async query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OutputGcsUri { + get { return outputGcsUri_; } + set { + outputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AsyncQueryReasoningEngineRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AsyncQueryReasoningEngineRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (InputGcsUri != other.InputGcsUri) return false; + if (OutputGcsUri != other.OutputGcsUri) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (InputGcsUri.Length != 0) hash ^= InputGcsUri.GetHashCode(); + if (OutputGcsUri.Length != 0) hash ^= OutputGcsUri.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (InputGcsUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InputGcsUri); + } + if (OutputGcsUri.Length != 0) { + output.WriteRawTag(26); + output.WriteString(OutputGcsUri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (InputGcsUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InputGcsUri); + } + if (OutputGcsUri.Length != 0) { + output.WriteRawTag(26); + output.WriteString(OutputGcsUri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (InputGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InputGcsUri); + } + if (OutputGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputGcsUri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AsyncQueryReasoningEngineRequest other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.InputGcsUri.Length != 0) { + InputGcsUri = other.InputGcsUri; + } + if (other.OutputGcsUri.Length != 0) { + OutputGcsUri = other.OutputGcsUri; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + InputGcsUri = input.ReadString(); + break; + } + case 26: { + OutputGcsUri = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + InputGcsUri = input.ReadString(); + break; + } + case 26: { + OutputGcsUri = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Operation metadata message for + /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AsyncQueryReasoningEngineOperationMetadata : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AsyncQueryReasoningEngineOperationMetadata()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineOperationMetadata() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineOperationMetadata(AsyncQueryReasoningEngineOperationMetadata other) : this() { + genericMetadata_ = other.genericMetadata_ != null ? other.genericMetadata_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineOperationMetadata Clone() { + return new AsyncQueryReasoningEngineOperationMetadata(this); + } + + /// Field number for the "generic_metadata" field. + public const int GenericMetadataFieldNumber = 1; + private global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata genericMetadata_; + /// + /// The common part of the operation metadata. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata GenericMetadata { + get { return genericMetadata_; } + set { + genericMetadata_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AsyncQueryReasoningEngineOperationMetadata); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AsyncQueryReasoningEngineOperationMetadata other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(GenericMetadata, other.GenericMetadata)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (genericMetadata_ != null) hash ^= GenericMetadata.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (genericMetadata_ != null) { + output.WriteRawTag(10); + output.WriteMessage(GenericMetadata); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (genericMetadata_ != null) { + output.WriteRawTag(10); + output.WriteMessage(GenericMetadata); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (genericMetadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(GenericMetadata); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AsyncQueryReasoningEngineOperationMetadata other) { + if (other == null) { + return; + } + if (other.genericMetadata_ != null) { + if (genericMetadata_ == null) { + GenericMetadata = new global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata(); + } + GenericMetadata.MergeFrom(other.GenericMetadata); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (genericMetadata_ == null) { + GenericMetadata = new global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata(); + } + input.ReadMessage(GenericMetadata); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (genericMetadata_ == null) { + GenericMetadata = new global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata(); + } + input.ReadMessage(GenericMetadata); + break; + } + } + } + } + #endif + + } + + /// + /// Response message for + /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AsyncQueryReasoningEngineResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AsyncQueryReasoningEngineResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineResponse(AsyncQueryReasoningEngineResponse other) : this() { + outputGcsUri_ = other.outputGcsUri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineResponse Clone() { + return new AsyncQueryReasoningEngineResponse(this); + } + + /// Field number for the "output_gcs_uri" field. + public const int OutputGcsUriFieldNumber = 1; + private string outputGcsUri_ = ""; + /// + /// Output Cloud Storage URI for the Async query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OutputGcsUri { + get { return outputGcsUri_; } + set { + outputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AsyncQueryReasoningEngineResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AsyncQueryReasoningEngineResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (OutputGcsUri != other.OutputGcsUri) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (OutputGcsUri.Length != 0) hash ^= OutputGcsUri.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (OutputGcsUri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(OutputGcsUri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (OutputGcsUri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(OutputGcsUri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (OutputGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputGcsUri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AsyncQueryReasoningEngineResponse other) { + if (other == null) { + return; + } + if (other.OutputGcsUri.Length != 0) { + OutputGcsUri = other.OutputGcsUri; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + OutputGcsUri = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + OutputGcsUri = input.ReadString(); + break; + } + } + } + } + #endif + + } + #endregion } diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs index 0e191b466d35..3ff9f663c7e8 100644 --- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs @@ -22,6 +22,7 @@ using gcl = Google.Cloud.Location; using grpccore = Grpc.Core; using grpcinter = Grpc.Core.Interceptors; +using lro = Google.LongRunning; using mel = Microsoft.Extensions.Logging; using proto = Google.Protobuf; using scg = System.Collections.Generic; @@ -51,6 +52,8 @@ private ReasoningEngineExecutionServiceSettings(ReasoningEngineExecutionServiceS gax::GaxPreconditions.CheckNotNull(existing, nameof(existing)); QueryReasoningEngineSettings = existing.QueryReasoningEngineSettings; StreamQueryReasoningEngineSettings = existing.StreamQueryReasoningEngineSettings; + AsyncQueryReasoningEngineSettings = existing.AsyncQueryReasoningEngineSettings; + AsyncQueryReasoningEngineOperationsSettings = existing.AsyncQueryReasoningEngineOperationsSettings.Clone(); LocationsSettings = existing.LocationsSettings; IAMPolicySettings = existing.IAMPolicySettings; OnCopy(existing); @@ -84,6 +87,38 @@ private ReasoningEngineExecutionServiceSettings(ReasoningEngineExecutionServiceS /// public gaxgrpc::CallSettings StreamQueryReasoningEngineSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None); + /// + /// for synchronous and asynchronous calls to + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine and + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync. + /// + /// + /// + /// This call will not be retried. + /// No timeout is applied. + /// + /// + public gaxgrpc::CallSettings AsyncQueryReasoningEngineSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None); + + /// + /// Long Running Operation settings for calls to + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine and + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings AsyncQueryReasoningEngineOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + /// /// The settings to use for the associated with the client. /// @@ -288,6 +323,60 @@ public abstract partial class StreamQueryReasoningEngineStream : gaxgrpc::Server /// The server stream. public virtual StreamQueryReasoningEngineStream StreamQueryReasoningEngine(StreamQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException(); + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, st::CancellationToken cancellationToken) => + AsyncQueryReasoningEngineAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// The long-running operations client for AsyncQueryReasoningEngine. + public virtual lro::OperationsClient AsyncQueryReasoningEngineOperationsClient => throw new sys::NotImplementedException(); + + /// + /// Poll an operation once, using an operationName from a previous invocation of + /// AsyncQueryReasoningEngine. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceAsyncQueryReasoningEngine(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), AsyncQueryReasoningEngineOperationsClient, callSettings); + + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// AsyncQueryReasoningEngine. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceAsyncQueryReasoningEngineAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), AsyncQueryReasoningEngineOperationsClient, callSettings); } /// ReasoningEngineExecutionService client wrapper implementation, for convenient use. @@ -300,6 +389,8 @@ public sealed partial class ReasoningEngineExecutionServiceClientImpl : Reasonin private readonly gaxgrpc::ApiServerStreamingCall _callStreamQueryReasoningEngine; + private readonly gaxgrpc::ApiCall _callAsyncQueryReasoningEngine; + /// /// Constructs a client wrapper for the ReasoningEngineExecutionService service, with the specified gRPC client /// and settings. @@ -318,6 +409,7 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService Settings = effectiveSettings, Logger = logger, }); + AsyncQueryReasoningEngineOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.AsyncQueryReasoningEngineOperationsSettings, logger); LocationsClient = new gcl::LocationsClientImpl(grpcClient.CreateLocationsClient(), effectiveSettings.LocationsSettings, logger); IAMPolicyClient = new gciv::IAMPolicyClientImpl(grpcClient.CreateIAMPolicyClient(), effectiveSettings.IAMPolicySettings, logger); _callQueryReasoningEngine = clientHelper.BuildApiCall("QueryReasoningEngine", grpcClient.QueryReasoningEngineAsync, grpcClient.QueryReasoningEngine, effectiveSettings.QueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name); @@ -326,6 +418,9 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService _callStreamQueryReasoningEngine = clientHelper.BuildApiCall("StreamQueryReasoningEngine", grpcClient.StreamQueryReasoningEngine, effectiveSettings.StreamQueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name); Modify_ApiCall(ref _callStreamQueryReasoningEngine); Modify_StreamQueryReasoningEngineApiCall(ref _callStreamQueryReasoningEngine); + _callAsyncQueryReasoningEngine = clientHelper.BuildApiCall("AsyncQueryReasoningEngine", grpcClient.AsyncQueryReasoningEngineAsync, grpcClient.AsyncQueryReasoningEngine, effectiveSettings.AsyncQueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callAsyncQueryReasoningEngine); + Modify_AsyncQueryReasoningEngineApiCall(ref _callAsyncQueryReasoningEngine); OnConstruction(grpcClient, effectiveSettings, clientHelper); } @@ -337,6 +432,8 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService partial void Modify_StreamQueryReasoningEngineApiCall(ref gaxgrpc::ApiServerStreamingCall call); + partial void Modify_AsyncQueryReasoningEngineApiCall(ref gaxgrpc::ApiCall call); + partial void OnConstruction(ReasoningEngineExecutionService.ReasoningEngineExecutionServiceClient grpcClient, ReasoningEngineExecutionServiceSettings effectiveSettings, gaxgrpc::ClientHelper clientHelper); /// The underlying gRPC ReasoningEngineExecutionService client @@ -352,6 +449,8 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService partial void Modify_StreamQueryReasoningEngineRequest(ref StreamQueryReasoningEngineRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_AsyncQueryReasoningEngineRequest(ref AsyncQueryReasoningEngineRequest request, ref gaxgrpc::CallSettings settings); + /// /// Queries using a reasoning engine. /// @@ -396,6 +495,47 @@ public override ReasoningEngineExecutionServiceClient.StreamQueryReasoningEngine Modify_StreamQueryReasoningEngineRequest(ref request, ref callSettings); return new StreamQueryReasoningEngineStreamImpl(_callStreamQueryReasoningEngine.Call(request, callSettings)); } + + /// The long-running operations client for AsyncQueryReasoningEngine. + public override lro::OperationsClient AsyncQueryReasoningEngineOperationsClient { get; } + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_AsyncQueryReasoningEngineRequest(ref request, ref callSettings); + return new lro::Operation(_callAsyncQueryReasoningEngine.Sync(request, callSettings), AsyncQueryReasoningEngineOperationsClient); + } + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_AsyncQueryReasoningEngineRequest(ref request, ref callSettings); + return new lro::Operation(await _callAsyncQueryReasoningEngine.Async(request, callSettings).ConfigureAwait(false), AsyncQueryReasoningEngineOperationsClient); + } + } + + public static partial class ReasoningEngineExecutionService + { + public partial class ReasoningEngineExecutionServiceClient + { + /// + /// Creates a new instance of using the same call invoker as + /// this client. + /// + /// A new Operations client for the same target as this client. + public virtual lro::Operations.OperationsClient CreateOperationsClient() => + new lro::Operations.OperationsClient(CallInvoker); + } } public static partial class ReasoningEngineExecutionService diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs index 6409bc844e31..68dc95fed153 100644 --- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs @@ -3,7 +3,7 @@ // source: google/cloud/aiplatform/v1/reasoning_engine_execution_service.proto // // Original file comments: -// Copyright 2025 Google LLC +// Copyright 2026 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -71,6 +71,10 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl static readonly grpc::Marshaller __Marshaller_google_cloud_aiplatform_v1_StreamQueryReasoningEngineRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_api_HttpBody = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Api.HttpBody.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_aiplatform_v1_AsyncQueryReasoningEngineRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_longrunning_Operation = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.LongRunning.Operation.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Method __Method_QueryReasoningEngine = new grpc::Method( @@ -88,6 +92,14 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl __Marshaller_google_cloud_aiplatform_v1_StreamQueryReasoningEngineRequest, __Marshaller_google_api_HttpBody); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_AsyncQueryReasoningEngine = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "AsyncQueryReasoningEngine", + __Marshaller_google_cloud_aiplatform_v1_AsyncQueryReasoningEngineRequest, + __Marshaller_google_longrunning_Operation); + /// Service descriptor public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor { @@ -123,6 +135,18 @@ public abstract partial class ReasoningEngineExecutionServiceBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Async query using a reasoning engine. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + } /// Client for ReasoningEngineExecutionService @@ -224,6 +248,54 @@ protected ReasoningEngineExecutionServiceClient(ClientBaseConfiguration configur { return CallInvoker.AsyncServerStreamingCall(__Method_StreamQueryReasoningEngine, null, options, request); } + /// + /// Async query using a reasoning engine. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.LongRunning.Operation AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return AsyncQueryReasoningEngine(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Async query using a reasoning engine. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.LongRunning.Operation AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_AsyncQueryReasoningEngine, null, options, request); + } + /// + /// Async query using a reasoning engine. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall AsyncQueryReasoningEngineAsync(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return AsyncQueryReasoningEngineAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Async query using a reasoning engine. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall AsyncQueryReasoningEngineAsync(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_AsyncQueryReasoningEngine, null, options, request); + } /// Creates a new instance of client from given ClientBaseConfiguration. [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] protected override ReasoningEngineExecutionServiceClient NewInstance(ClientBaseConfiguration configuration) @@ -239,7 +311,8 @@ protected override ReasoningEngineExecutionServiceClient NewInstance(ClientBaseC { return grpc::ServerServiceDefinition.CreateBuilder() .AddMethod(__Method_QueryReasoningEngine, serviceImpl.QueryReasoningEngine) - .AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl.StreamQueryReasoningEngine).Build(); + .AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl.StreamQueryReasoningEngine) + .AddMethod(__Method_AsyncQueryReasoningEngine, serviceImpl.AsyncQueryReasoningEngine).Build(); } /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. @@ -251,6 +324,7 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, ReasoningE { serviceBinder.AddMethod(__Method_QueryReasoningEngine, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.QueryReasoningEngine)); serviceBinder.AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod(serviceImpl.StreamQueryReasoningEngine)); + serviceBinder.AddMethod(__Method_AsyncQueryReasoningEngine, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.AsyncQueryReasoningEngine)); } } diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs index c64db83f5ce3..e61fb07050bf 100644 --- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs @@ -42,4 +42,16 @@ public partial class StreamQueryReasoningEngineRequest set => Name = value?.ToString() ?? ""; } } + + public partial class AsyncQueryReasoningEngineRequest + { + /// + /// -typed view over the resource name property. + /// + public gcav::ReasoningEngineName ReasoningEngineName + { + get => string.IsNullOrEmpty(Name) ? null : gcav::ReasoningEngineName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } } diff --git a/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json b/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json index bb28c64bec81..38cc44387eac 100644 --- a/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json +++ b/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json @@ -1765,6 +1765,12 @@ "grpc": { "libraryClient": "ReasoningEngineExecutionServiceClient", "rpcs": { + "AsyncQueryReasoningEngine": { + "methods": [ + "AsyncQueryReasoningEngine", + "AsyncQueryReasoningEngineAsync" + ] + }, "QueryReasoningEngine": { "methods": [ "QueryReasoningEngine", diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json index e9a3a2e47506..87bd49deb866 100644 --- a/generator-input/pipeline-state.json +++ b/generator-input/pipeline-state.json @@ -292,7 +292,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-04-06T14:08:05.688830893Z", - "lastGeneratedCommit": "62e4ecb2f4390728990514fea14aad0431881a52", + "lastGeneratedCommit": "1a00cecd9a90ac056247d5b522e94af5347adc1d", "lastReleasedCommit": "582172de2d9b6443e1fecf696167867c6d8a5fc4", "apiPaths": [ "google/cloud/aiplatform/v1"