Vertex AI v1beta1 API - Class SessionServiceClient (1.0.0-beta24)

Stay organized with collections Save and categorize content based on your preferences.

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
AppendEventRequest request = new AppendEventRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
    Event = new SessionEvent(),
};
// Make the request
AppendEventResponse response = sessionServiceClient.AppendEvent(request);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
SessionEvent @event = new SessionEvent();
// Make the request
AppendEventResponse response = sessionServiceClient.AppendEvent(name, @event);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
SessionEvent @event = new SessionEvent();
// Make the request
AppendEventResponse response = sessionServiceClient.AppendEvent(name, @event);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
AppendEventRequest request = new AppendEventRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
    Event = new SessionEvent(),
};
// Make the request
AppendEventResponse response = await sessionServiceClient.AppendEventAsync(request);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
AppendEventRequest request = new AppendEventRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
    Event = new SessionEvent(),
};
// Make the request
AppendEventResponse response = await sessionServiceClient.AppendEventAsync(request);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
SessionEvent @event = new SessionEvent();
// Make the request
AppendEventResponse response = await sessionServiceClient.AppendEventAsync(name, @event);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
SessionEvent @event = new SessionEvent();
// Make the request
AppendEventResponse response = await sessionServiceClient.AppendEventAsync(name, @event);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
SessionEvent @event = new SessionEvent();
// Make the request
AppendEventResponse response = await sessionServiceClient.AppendEventAsync(name, @event);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
SessionEvent @event = new SessionEvent();
// Make the request
AppendEventResponse response = await sessionServiceClient.AppendEventAsync(name, @event);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = sessionServiceClient.CreateSession(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceCreateSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
CreateSessionRequest request = new CreateSessionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Session = new Session(),
};
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = sessionServiceClient.CreateSession(request);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceCreateSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
ReasoningEngineName parent = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]");
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = sessionServiceClient.CreateSession(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceCreateSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = sessionServiceClient.CreateSession(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceCreateSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
CreateSessionRequest request = new CreateSessionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Session = new Session(),
};
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(request);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
CreateSessionRequest request = new CreateSessionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Session = new Session(),
};
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(request);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
ReasoningEngineName parent = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]");
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
ReasoningEngineName parent = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]");
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Session session = new Session();
// Make the request
Operation<Session, CreateSessionOperationMetadata> response = await sessionServiceClient.CreateSessionAsync(parent, session);

// Poll until the returned long-running operation is complete
Operation<Session, CreateSessionOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Session 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<Session, CreateSessionOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceCreateSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Session retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
DeleteSessionRequest request = new DeleteSessionRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = sessionServiceClient.DeleteSession(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceDeleteSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = sessionServiceClient.DeleteSession(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceDeleteSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = sessionServiceClient.DeleteSession(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = sessionServiceClient.PollOnceDeleteSession(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteSessionRequest request = new DeleteSessionRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await sessionServiceClient.DeleteSessionAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceDeleteSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteSessionRequest request = new DeleteSessionRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await sessionServiceClient.DeleteSessionAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceDeleteSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await sessionServiceClient.DeleteSessionAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceDeleteSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await sessionServiceClient.DeleteSessionAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceDeleteSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await sessionServiceClient.DeleteSessionAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceDeleteSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await sessionServiceClient.DeleteSessionAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty 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<Empty, DeleteOperationMetadata> retrievedResponse = await sessionServiceClient.PollOnceDeleteSessionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
GetSessionRequest request = new GetSessionRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
Session response = sessionServiceClient.GetSession(request);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
Session response = sessionServiceClient.GetSession(name);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
Session response = sessionServiceClient.GetSession(name);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
GetSessionRequest request = new GetSessionRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
Session response = await sessionServiceClient.GetSessionAsync(request);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
GetSessionRequest request = new GetSessionRequest
{
    SessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
Session response = await sessionServiceClient.GetSessionAsync(request);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
Session response = await sessionServiceClient.GetSessionAsync(name);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName name = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
Session response = await sessionServiceClient.GetSessionAsync(name);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
Session response = await sessionServiceClient.GetSessionAsync(name);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
Session response = await sessionServiceClient.GetSessionAsync(name);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
ListEventsRequest request = new ListEventsRequest
{
    ParentAsSessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
PagedEnumerable<ListEventsResponse, SessionEvent> response = sessionServiceClient.ListEvents(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (SessionEvent item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListEventsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SessionEvent item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<SessionEvent> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEvent item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
SessionName parent = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
PagedEnumerable<ListEventsResponse, SessionEvent> response = sessionServiceClient.ListEvents(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (SessionEvent item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListEventsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SessionEvent item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<SessionEvent> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEvent item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
PagedEnumerable<ListEventsResponse, SessionEvent> response = sessionServiceClient.ListEvents(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (SessionEvent item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListEventsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SessionEvent item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<SessionEvent> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEvent item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
ListEventsRequest request = new ListEventsRequest
{
    ParentAsSessionName = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]"),
};
// Make the request
PagedAsyncEnumerable<ListEventsResponse, SessionEvent> response = sessionServiceClient.ListEventsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((SessionEvent item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListEventsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SessionEvent item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<SessionEvent> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEvent item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
SessionName parent = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
// Make the request
PagedAsyncEnumerable<ListEventsResponse, SessionEvent> response = sessionServiceClient.ListEventsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((SessionEvent item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListEventsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SessionEvent item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<SessionEvent> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEvent item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]";
// Make the request
PagedAsyncEnumerable<ListEventsResponse, SessionEvent> response = sessionServiceClient.ListEventsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((SessionEvent item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListEventsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SessionEvent item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<SessionEvent> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEvent item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessions(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Session item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListSessionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
ListSessionsRequest request = new ListSessionsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessions(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Session item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListSessionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
ReasoningEngineName parent = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]");
// Make the request
PagedEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessions(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Session item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListSessionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessions(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Session item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListSessionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessionsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Session item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListSessionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
ListSessionsRequest request = new ListSessionsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessionsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Session item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListSessionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
ReasoningEngineName parent = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]");
// Make the request
PagedAsyncEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessionsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Session item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListSessionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListSessionsResponse, Session> response = sessionServiceClient.ListSessionsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Session item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListSessionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Session item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Session> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
Session session = new Session();
FieldMask updateMask = new FieldMask();
// Make the request
Session response = sessionServiceClient.UpdateSession(session, updateMask);

// Create client
SessionServiceClient sessionServiceClient = SessionServiceClient.Create();
// Initialize request argument(s)
UpdateSessionRequest request = new UpdateSessionRequest
{
    Session = new Session(),
    UpdateMask = new FieldMask(),
};
// Make the request
Session response = sessionServiceClient.UpdateSession(request);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
Session session = new Session();
FieldMask updateMask = new FieldMask();
// Make the request
Session response = await sessionServiceClient.UpdateSessionAsync(session, updateMask);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
Session session = new Session();
FieldMask updateMask = new FieldMask();
// Make the request
Session response = await sessionServiceClient.UpdateSessionAsync(session, updateMask);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateSessionRequest request = new UpdateSessionRequest
{
    Session = new Session(),
    UpdateMask = new FieldMask(),
};
// Make the request
Session response = await sessionServiceClient.UpdateSessionAsync(request);

// Create client
SessionServiceClient sessionServiceClient = await SessionServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateSessionRequest request = new UpdateSessionRequest
{
    Session = new Session(),
    UpdateMask = new FieldMask(),
};
// Make the request
Session response = await sessionServiceClient.UpdateSessionAsync(request);