GenerateContentResponse.cs

/*
 * Copyright 2025 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
 *
 * http://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.
 */

usingSystem.Collections.Generic;
usingSystem.Collections.ObjectModel;
usingSystem.Linq;
usingGoogle.MiniJSON;
usingFirebase.VertexAI.Internal;

namespaceFirebase.VertexAI{

/// <summary>
/// The model's response to a generate content request.
/// </summary>
publicreadonlystructGenerateContentResponse{
privatereadonlyReadOnlyCollection<Candidate>_candidates;

/// <summary>
/// A list of candidate response content, ordered from best to worst.
/// </summary>
publicIEnumerable<Candidate>Candidates=>
_candidates??newReadOnlyCollection<Candidate>(newList<Candidate>());

/// <summary>
/// A value containing the safety ratings for the response, or,
/// if the request was blocked, a reason for blocking the request.
/// </summary>
publicPromptFeedback?PromptFeedback{get;}

/// <summary>
/// Token usage metadata for processing the generate content request.
/// </summary>
publicUsageMetadata?UsageMetadata{get;}

/// <summary>
/// The response's content as text, if it exists.
/// </summary>
publicstringText{
get{
// Concatenate all of the text parts from the first candidate.
returnstring.Join(" ",
Candidates.FirstOrDefault().Content.Parts
.OfType<ModelContent.TextPart>().Select(tp =>tp.Text));
}
}

/// <summary>
/// Returns function calls found in any `Part`s of the first candidate of the response, if any.
/// </summary>
publicIEnumerable<ModelContent.FunctionCallPart>FunctionCalls{
get{
returnCandidates.FirstOrDefault().Content.Parts.OfType<ModelContent.FunctionCallPart>();
}
}

// Hidden constructor, users don't need to make this.
privateGenerateContentResponse(List<Candidate>candidates,PromptFeedback?promptFeedback,
UsageMetadata?usageMetadata){
_candidates=newReadOnlyCollection<Candidate>(candidates??newList<Candidate>());
PromptFeedback=promptFeedback;
UsageMetadata=usageMetadata;
}

/// <summary>
/// Intended for internal use only.
/// This method is used for deserializing JSON responses and should not be called directly.
/// </summary>
internalstaticGenerateContentResponseFromJson(stringjsonString,
FirebaseAI.Backend.InternalProviderbackend){
returnFromJson(Json.Deserialize(jsonString)asDictionary<string,object>,backend);
}

/// <summary>
/// Intended for internal use only.
/// This method is used for deserializing JSON responses and should not be called directly.
/// </summary>
internalstaticGenerateContentResponseFromJson(Dictionary<string,object>jsonDict,
FirebaseAI.Backend.InternalProviderbackend){
returnnewGenerateContentResponse(
jsonDict.ParseObjectList("candidates",(d)=>Candidate.FromJson(d,backend)),
jsonDict.ParseNullableObject("promptFeedback",
Firebase.VertexAI.PromptFeedback.FromJson),
jsonDict.ParseNullableObject("usageMetadata",
Firebase.VertexAI.UsageMetadata.FromJson));
}
}

/// <summary>
/// A type describing possible reasons to block a prompt.
/// </summary>
publicenumBlockReason{
/// <summary>
/// A new and not yet supported value.
/// </summary>
Unknown=0,
/// <summary>
/// The prompt was blocked because it was deemed unsafe.
/// </summary>
Safety,
/// <summary>
/// All other block reasons.
/// </summary>
Other,
/// <summary>
/// The prompt was blocked because it contained terms from the terminology blocklist.
/// </summary>
Blocklist,
/// <summary>
/// The prompt was blocked due to prohibited content.
/// </summary>
ProhibitedContent,
}

/// <summary>
/// A metadata struct containing any feedback the model had on the prompt it was provided.
/// </summary>
publicreadonlystructPromptFeedback{
privatereadonlyReadOnlyCollection<SafetyRating>_safetyRatings;

/// <summary>
/// The reason a prompt was blocked, if it was blocked.
/// </summary>
publicBlockReason?BlockReason{get;}
/// <summary>
/// A human-readable description of the `BlockReason`.
/// </summary>
publicstringBlockReasonMessage{get;}
/// <summary>
/// The safety ratings of the prompt.
/// </summary>
publicIEnumerable<SafetyRating>SafetyRatings=>
_safetyRatings??newReadOnlyCollection<SafetyRating>(newList<SafetyRating>());

// Hidden constructor, users don't need to make this.
privatePromptFeedback(BlockReason?blockReason,stringblockReasonMessage,
List<SafetyRating>safetyRatings){
BlockReason=blockReason;
BlockReasonMessage=blockReasonMessage;
_safetyRatings=newReadOnlyCollection<SafetyRating>(safetyRatings??newList<SafetyRating>());
}

privatestaticBlockReasonParseBlockReason(stringstr){
returnstrswitch{
"SAFETY"=>Firebase.VertexAI.BlockReason.Safety,
"OTHER"=>Firebase.VertexAI.BlockReason.Other,
"BLOCKLIST"=>Firebase.VertexAI.BlockReason.Blocklist,
"PROHIBITED_CONTENT"=>Firebase.VertexAI.BlockReason.ProhibitedContent,
 _ =>Firebase.VertexAI.BlockReason.Unknown,
};
}

/// <summary>
/// Intended for internal use only.
/// This method is used for deserializing JSON responses and should not be called directly.
/// </summary>
internalstaticPromptFeedbackFromJson(Dictionary<string,object>jsonDict){
returnnewPromptFeedback(
jsonDict.ParseNullableEnum("blockReason",ParseBlockReason),
jsonDict.ParseValue<string>("blockReasonMessage"),
jsonDict.ParseObjectList("safetyRatings",SafetyRating.FromJson));
}
}

/// <summary>
/// Token usage metadata for processing the generate content request.
/// </summary>
publicreadonlystructUsageMetadata{
/// <summary>
/// The number of tokens in the request prompt.
/// </summary>
publicintPromptTokenCount{get;}
/// <summary>
/// The total number of tokens across the generated response candidates.
/// </summary>
publicintCandidatesTokenCount{get;}
/// <summary>
/// The total number of tokens in both the request and response.
/// </summary>
publicintTotalTokenCount{get;}

privatereadonlyReadOnlyCollection<ModalityTokenCount>_promptTokensDetails;
publicIEnumerable<ModalityTokenCount>PromptTokensDetails=>
_promptTokensDetails??newReadOnlyCollection<ModalityTokenCount>(newList<ModalityTokenCount>());

privatereadonlyReadOnlyCollection<ModalityTokenCount>_candidatesTokensDetails;
publicIEnumerable<ModalityTokenCount>CandidatesTokensDetails=>
_candidatesTokensDetails??newReadOnlyCollection<ModalityTokenCount>(newList<ModalityTokenCount>());

// Hidden constructor, users don't need to make this.
privateUsageMetadata(intpromptTC,intcandidatesTC,inttotalTC,
List<ModalityTokenCount>promptDetails,List<ModalityTokenCount>candidateDetails){
PromptTokenCount=promptTC;
CandidatesTokenCount=candidatesTC;
TotalTokenCount=totalTC;
_promptTokensDetails=
newReadOnlyCollection<ModalityTokenCount>(promptDetails??newList<ModalityTokenCount>());
_candidatesTokensDetails=
newReadOnlyCollection<ModalityTokenCount>(candidateDetails??newList<ModalityTokenCount>());

}

/// <summary>
/// Intended for internal use only.
/// This method is used for deserializing JSON responses and should not be called directly.
/// </summary>
internalstaticUsageMetadataFromJson(Dictionary<string,object>jsonDict){
returnnewUsageMetadata(
jsonDict.ParseValue<int>("promptTokenCount"),
jsonDict.ParseValue<int>("candidatesTokenCount"),
jsonDict.ParseValue<int>("totalTokenCount"),
jsonDict.ParseObjectList("promptTokensDetails",ModalityTokenCount.FromJson),
jsonDict.ParseObjectList("candidatesTokensDetails",ModalityTokenCount.FromJson));
}
}

}