diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionAnswers.cs b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionAnswers.cs
new file mode 100644
index 00000000000..f4227f9b199
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionAnswers.cs
@@ -0,0 +1,404 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1402 // File may only contain a single type — decision answer types are co-located as one immutable model.
+#pragma warning disable SA1649 // File name should match first type name — decision answer types are co-located as one immutable model.
+#pragma warning disable CA1032 // Implement standard exception constructors — protocol exceptions expose the protocol-specific constructors.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json.Serialization;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.AI;
+
+/// Identifies the precision represented by provider-reported probabilities.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public enum DecisionPrecision
+{
+ /// The provider reports values without a declared decimal rounding.
+ HighPrecision,
+
+ /// The provider reports values rounded to four decimal places.
+ FourDecimalPlaces,
+
+ /// The provider reports values rounded to two decimal places.
+ TwoDecimalPlaces,
+}
+
+/// Represents one named probability observation.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionProbability
+{
+ /// Initializes a new instance of the class.
+ /// The exact opaque candidate or level ID.
+ /// The probability value.
+ [JsonConstructor]
+ public DecisionProbability(string id, double value)
+ {
+ Id = Throw.IfNullOrWhitespace(id);
+ Value = value;
+ }
+
+ /// Gets the exact opaque candidate or level ID.
+ public string Id { get; }
+
+ /// Gets the native double probability value.
+ public double Value { get; }
+}
+
+/// Represents a provider result for one decision question.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "$type")]
+[JsonDerivedType(typeof(BinaryDecisionAnswer), "binary")]
+[JsonDerivedType(typeof(ChoiceDecisionAnswer), "choice")]
+[JsonDerivedType(typeof(ScoreDecisionAnswer), "score")]
+public abstract class DecisionAnswer
+{
+ internal const double DistributionTolerance = 1e-6;
+
+ private protected DecisionAnswer(
+ string questionId,
+ DecisionKind kind,
+ DecisionPrecision precision,
+ object? rawRepresentation,
+ IReadOnlyDictionary? additionalProperties)
+ {
+ QuestionId = Throw.IfNullOrWhitespace(questionId);
+ if (!Enum.IsDefined(typeof(DecisionPrecision), precision))
+ {
+ Throw.ArgumentOutOfRangeException(nameof(precision));
+ }
+
+ Kind = kind;
+ Precision = precision;
+ RawRepresentation = rawRepresentation;
+ AdditionalProperties = DecisionSnapshots.Properties(additionalProperties);
+ }
+
+ /// Gets the exact opaque question ID this answer belongs to.
+ public string QuestionId { get; }
+
+ /// Gets the semantic kind of this answer.
+ public DecisionKind Kind { get; }
+
+ /// Gets the precision declared for the numeric observations.
+ public DecisionPrecision Precision { get; }
+
+ ///
+ /// Gets the provider-owned raw representation, if available.
+ /// This value is not cloned or used for semantic data and must be treated as diagnostic-only.
+ ///
+ [JsonIgnore]
+ public object? RawRepresentation { get; }
+
+ ///
+ /// Gets an owned read-only snapshot of provider extension data.
+ /// Values are shallow-copied references and must be independently safe to share.
+ ///
+ public IReadOnlyDictionary? AdditionalProperties { get; }
+
+ internal static void ValidateProbability(double value)
+ {
+ if (double.IsNaN(value) || double.IsInfinity(value) || value < 0 || value > 1)
+ {
+ throw new DecisionProtocolException("Probability must be finite and in the range [0, 1].");
+ }
+ }
+
+ internal static void ValidateDistribution(
+ IReadOnlyList probabilities,
+ DecisionPrecision precision)
+ {
+ double sum = 0;
+ HashSet ids = new(StringComparer.Ordinal);
+
+ foreach (DecisionProbability probability in probabilities)
+ {
+ if (probability is null)
+ {
+ throw new DecisionProtocolException("A probability distribution cannot contain null entries.");
+ }
+
+ if (!ids.Add(probability.Id))
+ {
+ throw new DecisionProtocolException("A probability distribution contains a duplicate ID.");
+ }
+
+ ValidateProbability(probability.Value);
+ sum += probability.Value;
+ }
+
+ double tolerance = GetDistributionTolerance(precision, probabilities.Count);
+ if (Math.Abs(sum - 1) > tolerance)
+ {
+ throw new DecisionProtocolException(
+ "A probability distribution must sum to 1 within the bound allowed by its declared rounding.");
+ }
+
+ double roundingHalfUnit = GetRoundingHalfUnit(precision);
+ double lowerBound = 0;
+ double upperBound = 0;
+ foreach (DecisionProbability probability in probabilities)
+ {
+ lowerBound += Math.Max(0, probability.Value - roundingHalfUnit);
+ upperBound += Math.Min(1, probability.Value + roundingHalfUnit);
+ }
+
+ if (lowerBound > 1 + DistributionTolerance || upperBound < 1 - DistributionTolerance)
+ {
+ throw new DecisionProtocolException(
+ "A probability distribution has no normalized latent values consistent with its declared rounding.");
+ }
+ }
+
+ internal static double GetDistributionTolerance(DecisionPrecision precision, int count)
+ {
+ return precision switch
+ {
+ DecisionPrecision.HighPrecision => DistributionTolerance,
+ DecisionPrecision.FourDecimalPlaces => (count * 0.00005) + DistributionTolerance,
+ DecisionPrecision.TwoDecimalPlaces => (count * 0.005) + DistributionTolerance,
+ _ => throw new ArgumentOutOfRangeException(nameof(precision)),
+ };
+ }
+
+ internal static (double Minimum, double Maximum) GetFeasibleExpectedScoreBounds(
+ IReadOnlyList probabilities,
+ DecisionPrecision precision)
+ {
+ double roundingHalfUnit = GetRoundingHalfUnit(precision);
+ double lowerMass = 0;
+ double upperMass = 0;
+ for (int i = 0; i < probabilities.Count; i++)
+ {
+ double probability = probabilities[i].Value;
+ lowerMass += Math.Max(0, probability - roundingHalfUnit);
+ upperMass += Math.Min(1, probability + roundingHalfUnit);
+ }
+
+ if (lowerMass > 1 + DistributionTolerance || upperMass < 1 - DistributionTolerance)
+ {
+ throw new DecisionProtocolException(
+ "A probability distribution has no normalized latent values consistent with its declared rounding.");
+ }
+
+ double remaining = Math.Max(0, 1 - lowerMass);
+ double minimum = 0;
+ for (int i = 0; i < probabilities.Count; i++)
+ {
+ double lower = Math.Max(0, probabilities[i].Value - roundingHalfUnit);
+ double capacity = Math.Min(1, probabilities[i].Value + roundingHalfUnit) - lower;
+ double allocated = Math.Min(remaining, capacity);
+ minimum += (lower + allocated) * i;
+ remaining -= allocated;
+ }
+
+ remaining = Math.Max(0, 1 - lowerMass);
+ double maximum = 0;
+ double[] lowerValues = new double[probabilities.Count];
+ for (int i = 0; i < probabilities.Count; i++)
+ {
+ lowerValues[i] = Math.Max(0, probabilities[i].Value - roundingHalfUnit);
+ maximum += lowerValues[i] * i;
+ }
+
+ for (int i = probabilities.Count - 1; i >= 0; i--)
+ {
+ double capacity = Math.Min(1, probabilities[i].Value + roundingHalfUnit) - lowerValues[i];
+ double allocated = Math.Min(remaining, capacity);
+ maximum += allocated * i;
+ remaining -= allocated;
+ }
+
+ if (remaining > DistributionTolerance)
+ {
+ throw new DecisionProtocolException(
+ "A probability distribution has no normalized latent values consistent with its declared rounding.");
+ }
+
+ return (minimum, maximum);
+ }
+
+ internal static double GetRoundingHalfUnit(DecisionPrecision precision) =>
+ precision switch
+ {
+ DecisionPrecision.HighPrecision => 0,
+ DecisionPrecision.FourDecimalPlaces => 0.00005,
+ DecisionPrecision.TwoDecimalPlaces => 0.005,
+ _ => throw new ArgumentOutOfRangeException(nameof(precision)),
+ };
+}
+
+/// Represents the probability that a binary proposition is true.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class BinaryDecisionAnswer : DecisionAnswer
+{
+ /// Initializes a new instance of the class.
+ [JsonConstructor]
+ public BinaryDecisionAnswer(
+ string questionId,
+ double trueProbability,
+ DecisionPrecision precision = DecisionPrecision.HighPrecision,
+ object? rawRepresentation = null,
+ IReadOnlyDictionary? additionalProperties = null)
+ : base(questionId, DecisionKind.Binary, precision, rawRepresentation, additionalProperties)
+ {
+ ValidateProbability(trueProbability);
+ TrueProbability = trueProbability;
+ }
+
+ /// Gets the probability that the proposition is true.
+ public double TrueProbability { get; }
+}
+
+/// Represents a selected candidate and its complete probability distribution.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class ChoiceDecisionAnswer : DecisionAnswer
+{
+ /// Initializes a new instance of the class.
+ [JsonConstructor]
+ public ChoiceDecisionAnswer(
+ string questionId,
+ string selectedCandidateId,
+ IReadOnlyList probabilities,
+ DecisionPrecision precision = DecisionPrecision.HighPrecision,
+ object? rawRepresentation = null,
+ IReadOnlyDictionary? additionalProperties = null)
+ : base(questionId, DecisionKind.Choice, precision, rawRepresentation, additionalProperties)
+ {
+ SelectedCandidateId = Throw.IfNullOrWhitespace(selectedCandidateId);
+ _ = Throw.IfNull(probabilities);
+
+ DecisionProbability[] copy = probabilities.ToArray();
+ if (copy.Length == 0)
+ {
+ throw new DecisionProtocolException("A choice answer requires a complete distribution.");
+ }
+
+ ValidateDistribution(copy, precision);
+ if (!Array.Exists(copy, probability => string.Equals(probability.Id, SelectedCandidateId, StringComparison.Ordinal)))
+ {
+ throw new DecisionProtocolException("The selected candidate is not present in the distribution.");
+ }
+
+ Probabilities = Array.AsReadOnly(copy);
+ }
+
+ /// Gets the exact selected candidate ID.
+ public string SelectedCandidateId { get; }
+
+ /// Gets the complete ordered candidate distribution.
+ public IReadOnlyList Probabilities { get; }
+}
+
+///
+/// Represents an ordinal score and its complete level distribution.
+/// A reported score is checked against normalized latent values within the declared clipped rounding intervals; observed probabilities and the derived expectation are never repaired.
+///
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class ScoreDecisionAnswer : DecisionAnswer
+{
+ /// Initializes a new instance of the class.
+ [JsonConstructor]
+ public ScoreDecisionAnswer(
+ string questionId,
+ double? score,
+ IReadOnlyList probabilities,
+ DecisionPrecision precision = DecisionPrecision.HighPrecision,
+ object? rawRepresentation = null,
+ IReadOnlyDictionary? additionalProperties = null)
+ : base(questionId, DecisionKind.Score, precision, rawRepresentation, additionalProperties)
+ {
+ _ = Throw.IfNull(probabilities);
+
+ DecisionProbability[] copy = probabilities.ToArray();
+ if (copy.Length < 2)
+ {
+ throw new DecisionProtocolException("A score answer requires at least two levels.");
+ }
+
+ ValidateDistribution(copy, precision);
+ if (score is double reportedScore &&
+ (double.IsNaN(reportedScore) || double.IsInfinity(reportedScore) || reportedScore < 0 || reportedScore > copy.Length - 1))
+ {
+ throw new DecisionProtocolException("A score must be finite and within the ordinal level range.");
+ }
+
+ double expectedScore = copy.Select((probability, index) => probability.Value * index).Sum();
+ if (score is double nativeScore)
+ {
+ (double minimum, double maximum) = GetFeasibleExpectedScoreBounds(copy, precision);
+ double scalarHalfUnit = GetRoundingHalfUnit(precision);
+ if (nativeScore + scalarHalfUnit + DistributionTolerance < minimum ||
+ nativeScore - scalarHalfUnit - DistributionTolerance > maximum)
+ {
+ throw new DecisionProtocolException("The score does not agree with its probability distribution.");
+ }
+ }
+
+ Score = score;
+ ExpectedScore = expectedScore;
+ Probabilities = Array.AsReadOnly(copy);
+ }
+
+ /// Gets the provider-reported score, retaining any declared rounding, or when it was not reported.
+ public double? Score { get; }
+
+ /// Gets the score derived from the observed distribution without repairing it, which may fall outside the ordinal level bounds after rounding.
+ public double ExpectedScore { get; }
+
+ /// Gets the complete ordered level distribution.
+ public IReadOnlyList Probabilities { get; }
+}
+
+/// Represents a protocol-invalid provider result.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionProtocolException : Exception
+{
+ /// Initializes a new instance of the class.
+ public DecisionProtocolException()
+ {
+ }
+
+ /// Initializes a new instance of the class with a message.
+ public DecisionProtocolException(string message)
+ : base(message)
+ {
+ }
+
+ /// Initializes a new instance of the class with a message and inner exception.
+ public DecisionProtocolException(string message, Exception innerException)
+ : base(message, innerException)
+ {
+ }
+}
+
+internal static class DecisionSnapshots
+{
+ internal static IReadOnlyDictionary? Properties(
+ IReadOnlyDictionary? entries)
+ {
+ if (entries is null)
+ {
+ return null;
+ }
+
+ Dictionary copy = new(StringComparer.Ordinal);
+ foreach (KeyValuePair property in entries)
+ {
+ if (copy.ContainsKey(property.Key))
+ {
+ Throw.ArgumentException(nameof(entries), "Extension property names must be unique.");
+ }
+
+ copy.Add(property.Key, property.Value);
+ }
+
+ return new ReadOnlyDictionary(copy);
+ }
+}
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionBinding.cs b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionBinding.cs
new file mode 100644
index 00000000000..8c40cd2244d
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionBinding.cs
@@ -0,0 +1,191 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1402 // File may only contain a single type — binding proof types are co-located as one API surface.
+#pragma warning disable SA1649 // File name should match first type name — binding proof types are co-located as one API surface.
+#pragma warning disable SA1204 // Static extension type is intentionally grouped with the binding types.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json.Serialization.Metadata;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.AI;
+
+/// Provides an explicit mapping from a choice candidate ID to an enum value.
+/// The application-owned enum type.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionEnumDefinition
+ where TEnum : struct, Enum
+{
+ private readonly ReadOnlyDictionary _values;
+
+ /// Initializes a new instance of the class.
+ public DecisionEnumDefinition(IEnumerable> values)
+ {
+ _ = Throw.IfNull(values);
+
+ DecisionEnumValue[] copy = values.ToArray();
+ if (copy.Length == 0)
+ {
+ Throw.ArgumentException(nameof(values), "An enum definition requires at least one value.");
+ }
+
+ Dictionary byId = new(StringComparer.Ordinal);
+ HashSet enumValues = new();
+ DecisionCandidate[] candidates = new DecisionCandidate[copy.Length];
+
+ for (int i = 0; i < copy.Length; i++)
+ {
+ DecisionEnumValue value = copy[i];
+ if (!enumValues.Add(value.Value))
+ {
+ Throw.ArgumentException(nameof(values), "Enum aliases or duplicate enum values are not allowed.");
+ }
+
+ if (byId.ContainsKey(value.Id))
+ {
+ Throw.ArgumentException(
+ nameof(values),
+ "Enum candidate IDs must be unique using ordinal comparison.");
+ }
+
+ byId.Add(value.Id, value.Value);
+ candidates[i] = new DecisionCandidate(value.Id, value.Description);
+ }
+
+ _values = new ReadOnlyDictionary(byId);
+ Candidates = Array.AsReadOnly(candidates);
+ }
+
+ /// Gets the ordered candidate snapshot for a choice question.
+ public IReadOnlyList Candidates { get; }
+
+ /// Creates a choice question using this exact enum mapping.
+ /// The choice question with the exact mapped candidate IDs.
+ public ChoiceDecisionQuestion CreateQuestion(string id, string? instructions) =>
+ new(id, instructions, Candidates);
+
+ /// Maps an exact selected candidate ID to its enum value.
+ /// The mapped enum value.
+ public TEnum Parse(string candidateId)
+ {
+ _ = Throw.IfNullOrWhitespace(candidateId);
+ if (_values.TryGetValue(candidateId, out TEnum value))
+ {
+ return value;
+ }
+
+ throw new DecisionProtocolException($"Unknown candidate ID '{candidateId}'.");
+ }
+}
+
+/// Describes one enum mapping entry.
+/// The application-owned enum type.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionEnumValue
+ where TEnum : struct, Enum
+{
+ /// Initializes a new instance of the class.
+ public DecisionEnumValue(TEnum value, string id, string description)
+ {
+ Value = value;
+ Id = Throw.IfNullOrWhitespace(id);
+ Description = Throw.IfNullOrWhitespace(description);
+ }
+
+ /// Gets the application enum value.
+ public TEnum Value { get; }
+
+ /// Gets the exact candidate ID.
+ public string Id { get; }
+
+ /// Gets the candidate description.
+ public string Description { get; }
+}
+
+/// Provides typed access to a complete decision response.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionAnswerSet
+{
+ internal DecisionAnswerSet(DecisionResponse response)
+ {
+ Response = response;
+ }
+
+ /// Gets the complete unmodified response, including probability evidence.
+ public DecisionResponse Response { get; }
+
+ /// Gets a binary answer by exact question ID.
+ /// The complete binary answer.
+ public BinaryDecisionAnswer GetBinary(string questionId) =>
+ Response.GetAnswer(questionId) as BinaryDecisionAnswer ??
+ throw new DecisionProtocolException($"Question '{questionId}' is not binary.");
+
+ /// Gets a choice answer by exact question ID.
+ /// The complete choice answer.
+ public ChoiceDecisionAnswer GetChoice(string questionId) =>
+ Response.GetAnswer(questionId) as ChoiceDecisionAnswer ??
+ throw new DecisionProtocolException($"Question '{questionId}' is not a choice.");
+
+ /// Gets a choice answer and maps its exact selected ID to an enum.
+ /// The application-owned enum type.
+ /// The mapped enum value.
+ public TEnum GetChoice(string questionId, DecisionEnumDefinition definition)
+ where TEnum : struct, Enum
+ {
+ _ = Throw.IfNull(definition);
+ return definition.Parse(GetChoice(questionId).SelectedCandidateId);
+ }
+
+ /// Gets a score answer by exact question ID.
+ /// The complete score answer.
+ public ScoreDecisionAnswer GetScore(string questionId) =>
+ Response.GetAnswer(questionId) as ScoreDecisionAnswer ??
+ throw new DecisionProtocolException($"Question '{questionId}' is not a score.");
+}
+
+/// Maps one complete response to an application-owned result without inference or reflection.
+/// The application-owned result type.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionResultBinding
+{
+ private readonly Func _map;
+
+ /// Initializes a new instance of the class.
+ /// The source-generated JSON contract for the application result.
+ /// The application-owned mapping delegate.
+ public DecisionResultBinding(
+ JsonTypeInfo resultTypeInfo,
+ Func map)
+ {
+ ResultTypeInfo = Throw.IfNull(resultTypeInfo);
+ _map = Throw.IfNull(map);
+ }
+
+ /// Gets the explicit source-generated result contract.
+ public JsonTypeInfo ResultTypeInfo { get; }
+
+ internal TResult Map(DecisionResponse response) => _map(new DecisionAnswerSet(response));
+}
+
+/// Provides response binding extensions.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public static class DecisionBindingExtensions
+{
+ /// Maps a complete response locally using the supplied explicit binding.
+ /// The application-owned result type.
+ /// The application-owned result.
+ public static TResult Bind(
+ this DecisionResponse response,
+ DecisionResultBinding binding)
+ {
+ _ = Throw.IfNull(response);
+ _ = Throw.IfNull(binding);
+ return binding.Map(response);
+ }
+}
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionClient.cs b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionClient.cs
new file mode 100644
index 00000000000..7777cb682f7
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionClient.cs
@@ -0,0 +1,546 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1402 // File may only contain a single type — decision client contracts are co-located as one API surface.
+#pragma warning disable SA1649 // File name should match first type name — decision client contracts are co-located as one API surface.
+#pragma warning disable SA1204 // Static extension types are intentionally grouped with the client contracts.
+#pragma warning disable S1128 // Unused "using" should be removed — ExperimentalAttribute is supplied by the shared API contract.
+#pragma warning disable S2302 // Protocol diagnostics intentionally mention the opaque question concept.
+#pragma warning disable CA1032 // Implement standard exception constructors — client exceptions expose the client-specific constructors.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.AI;
+
+/// Provides provider-neutral decision inference over a heterogeneous question batch.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public interface IDecisionClient : IDisposable
+{
+ /// Evaluates all questions against the same request state.
+ /// The owned decision request.
+ /// Optional per-request options.
+ /// The cancellation token to monitor.
+ /// A complete, correlated decision response or an exception.
+ Task GetResponseAsync(
+ DecisionRequest request,
+ DecisionOptions? options = null,
+ CancellationToken cancellationToken = default);
+
+ /// Retrieves a provider service for the exact requested type and key.
+ /// The requested provider service, or when unavailable.
+ object? GetService(Type serviceType, object? serviceKey = null);
+}
+
+/// Provides per-request decision options.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public class DecisionOptions
+{
+ /// Initializes a new instance of the class.
+ public DecisionOptions()
+ {
+ }
+
+ /// Initializes a new instance of the class by copying another instance.
+ protected DecisionOptions(DecisionOptions? other)
+ {
+ if (other is null)
+ {
+ return;
+ }
+
+ ModelId = other.ModelId;
+ AdditionalProperties = other.AdditionalProperties?.Clone();
+ RawRepresentationFactory = other.RawRepresentationFactory;
+ }
+
+ /// Gets or sets the requested model ID.
+ public string? ModelId { get; set; }
+
+ /// Gets or sets provider-specific extension properties.
+ public AdditionalPropertiesDictionary? AdditionalProperties { get; set; }
+
+ ///
+ /// Gets or sets a callback that creates provider-specific raw options.
+ /// The callback should return a new instance for each invocation; the provider may mutate it.
+ ///
+ [JsonIgnore]
+ public Func? RawRepresentationFactory { get; set; }
+
+ /// Creates a deliberate shallow clone of these options.
+ /// A cloned options instance.
+ public virtual DecisionOptions Clone() => new(this);
+}
+
+/// Provides metadata about an .
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionClientMetadata
+{
+ /// Initializes a new instance of the class.
+ public DecisionClientMetadata(
+ string? providerName = null,
+ Uri? providerUri = null,
+ string? defaultModelId = null,
+ IReadOnlyList? supportedKinds = null)
+ {
+ ProviderName = providerName;
+ ProviderUri = providerUri;
+ DefaultModelId = defaultModelId;
+
+ if (supportedKinds is not null)
+ {
+ DecisionKind[] copy = supportedKinds.Distinct().ToArray();
+ foreach (DecisionKind kind in copy)
+ {
+ if (!Enum.IsDefined(typeof(DecisionKind), kind))
+ {
+ Throw.ArgumentException(nameof(supportedKinds), "Supported kinds must be defined decision kinds.");
+ }
+ }
+
+ SupportedKinds = Array.AsReadOnly(copy);
+ }
+ }
+
+ /// Gets the provider name, when known.
+ public string? ProviderName { get; }
+
+ /// Gets the provider URI, when known.
+ public Uri? ProviderUri { get; }
+
+ /// Gets the default model ID, when known.
+ public string? DefaultModelId { get; }
+
+ /// Gets the owned supported-kind snapshot, or when unknown.
+ public IReadOnlyList? SupportedKinds { get; }
+}
+
+/// Classifies a provider failure without prescribing retry behavior.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionClientException : Exception
+{
+ /// Initializes a new instance of the class.
+ public DecisionClientException()
+ : this(string.Empty, isTransient: false)
+ {
+ }
+
+ /// Initializes a new instance of the class with a message.
+ public DecisionClientException(string message)
+ : this(message, isTransient: false)
+ {
+ }
+
+ /// Initializes a new instance of the class with provider classification.
+ public DecisionClientException(string message, bool isTransient, Exception? innerException = null)
+ : base(message, innerException)
+ {
+ IsTransient = isTransient;
+ }
+
+ /// Initializes a new instance of the class with a message and inner exception.
+ public DecisionClientException(string message, Exception innerException)
+ : this(message, isTransient: false, innerException)
+ {
+ }
+
+ /// Gets a value indicating whether the provider classified the failure as transient.
+ public bool IsTransient { get; }
+}
+
+/// Provides extensions for decision clients.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public static class DecisionClientExtensions
+{
+ /// Gets a typed provider service, or when it is unavailable.
+ /// The provider service type.
+ /// The requested provider service, or when unavailable.
+ public static TService? GetService(this IDecisionClient client, object? serviceKey = null)
+ {
+ _ = Throw.IfNull(client);
+ return client.GetService(typeof(TService), serviceKey) is TService service ? service : default;
+ }
+
+ /// Evaluates typed state using an explicit source-generated JSON contract.
+ /// The application state type.
+ /// A complete, correlated decision response.
+ public static async Task GetResponseAsync(
+ this IDecisionClient client,
+ TState state,
+ JsonTypeInfo stateTypeInfo,
+ IEnumerable questions,
+ DecisionOptions? options = null,
+ CancellationToken cancellationToken = default)
+ {
+ _ = Throw.IfNull(client);
+ _ = Throw.IfNull(stateTypeInfo);
+
+ DecisionRequest request = DecisionRequest.Create(state, stateTypeInfo, questions);
+ DecisionResponse response = await client.GetResponseAsync(request, options, cancellationToken).ConfigureAwait(false);
+ response.ValidateAgainst(request);
+ return response;
+ }
+
+ /// Evaluates a JSON state using a reusable typed decision definition.
+ /// The application-owned result type.
+ /// The decision client.
+ /// The explicit JSON state evaluated by every declared question.
+ /// The immutable typed decision definition.
+ /// Optional per-request options.
+ /// The cancellation token to monitor.
+ /// The typed result and complete neutral evidence.
+ public static async Task> GetResponseAsync(
+ this IDecisionClient client,
+ JsonElement state,
+ DecisionDefinition definition,
+ DecisionOptions? options = null,
+ CancellationToken cancellationToken = default)
+ {
+ _ = Throw.IfNull(client);
+ _ = Throw.IfNull(definition);
+
+ DecisionRequest request = new(state, definition.Questions);
+ DecisionResponse response = await client.GetResponseAsync(
+ request,
+ options,
+ cancellationToken).ConfigureAwait(false);
+ return definition.Bind(response, request);
+ }
+
+ /// Evaluates typed application state using a reusable typed decision definition.
+ /// The application state type.
+ /// The application-owned result type.
+ /// The decision client.
+ /// The application-owned state.
+ /// The immutable typed decision definition.
+ /// Optional per-request options.
+ /// The cancellation token to monitor.
+ /// The typed result and complete neutral evidence.
+ public static Task> GetResponseAsync(
+ this IDecisionClient client,
+ TState state,
+ DecisionDefinition definition,
+ DecisionOptions? options = null,
+ CancellationToken cancellationToken = default)
+ {
+ _ = Throw.IfNull(definition);
+ return GetResponseAsync(
+ client,
+ state,
+ definition,
+ definition.SerializerOptions,
+ options,
+ cancellationToken);
+ }
+
+ /// Evaluates typed application state using explicit source-generated state metadata.
+ /// The application state type.
+ /// The application-owned result type.
+ /// The decision client.
+ /// The application-owned state.
+ /// The JSON contract for .
+ /// The immutable typed decision definition.
+ /// Optional per-request options.
+ /// The cancellation token to monitor.
+ /// The typed result and complete neutral evidence.
+ public static Task> GetResponseAsync(
+ this IDecisionClient client,
+ TState state,
+ JsonTypeInfo stateTypeInfo,
+ DecisionDefinition definition,
+ DecisionOptions? options = null,
+ CancellationToken cancellationToken = default)
+ {
+ _ = Throw.IfNull(stateTypeInfo);
+ return GetResponseAsync(
+ client,
+ state,
+ definition,
+ stateTypeInfo,
+ options,
+ cancellationToken);
+ }
+
+ private static async Task> GetResponseAsync(
+ IDecisionClient client,
+ TState state,
+ DecisionDefinition definition,
+ JsonSerializerOptions serializerOptions,
+ DecisionOptions? options,
+ CancellationToken cancellationToken)
+ {
+ _ = Throw.IfNull(client);
+ _ = Throw.IfNull(definition);
+
+ JsonTypeInfo stateTypeInfo = serializerOptions.GetTypeInfo(typeof(TState));
+ JsonElement stateJson = JsonSerializer.SerializeToElement(state, stateTypeInfo);
+ return await GetResponseAsync(client, stateJson, definition, options, cancellationToken).ConfigureAwait(false);
+ }
+
+ private static async Task> GetResponseAsync(
+ IDecisionClient client,
+ TState state,
+ DecisionDefinition definition,
+ JsonTypeInfo stateTypeInfo,
+ DecisionOptions? options,
+ CancellationToken cancellationToken)
+ {
+ _ = Throw.IfNull(client);
+ _ = Throw.IfNull(definition);
+
+ JsonElement stateJson = JsonSerializer.SerializeToElement(state, stateTypeInfo);
+ return await GetResponseAsync(client, stateJson, definition, options, cancellationToken).ConfigureAwait(false);
+ }
+}
+
+/// Identifies provider/model provenance without inventing missing identity.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionProvenance
+{
+ /// Initializes a new instance of the class.
+ public DecisionProvenance(
+ string? providerName = null,
+ Uri? providerUri = null,
+ string? modelId = null,
+ string? responseId = null,
+ DecisionPrecision? precision = null)
+ {
+ ProviderName = providerName;
+ ProviderUri = providerUri;
+ ModelId = modelId;
+ ResponseId = responseId;
+ Precision = precision;
+ }
+
+ /// Gets the provider name, when reported.
+ public string? ProviderName { get; }
+
+ /// Gets the provider URI, when reported.
+ public Uri? ProviderUri { get; }
+
+ /// Gets the model ID, when reported.
+ public string? ModelId { get; }
+
+ /// Gets the provider response ID, when reported.
+ public string? ResponseId { get; }
+
+ /// Gets the reported probability precision, when available.
+ public DecisionPrecision? Precision { get; }
+}
+
+/// Represents a complete response correlated to one request.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionResponse
+{
+ /// Initializes a new instance of the class and validates it.
+ [JsonConstructor]
+ public DecisionResponse(
+ DecisionRequest request,
+ IReadOnlyList answers,
+ DecisionProvenance? provenance = null,
+ UsageDetails? usage = null,
+ object? rawRepresentation = null,
+ IReadOnlyDictionary? additionalProperties = null)
+ {
+ Request = Throw.IfNull(request);
+ _ = Throw.IfNull(answers);
+
+ DecisionAnswer[] copy = answers.ToArray();
+ if (copy.Length != request.Questions.Count)
+ {
+ throw new DecisionProtocolException("A response must contain one answer for every question.");
+ }
+
+ for (int i = 0; i < copy.Length; i++)
+ {
+ ValidateAnswer(request.Questions[i], copy[i]);
+ }
+
+ Answers = Array.AsReadOnly(copy);
+ Provenance = provenance;
+ Usage = usage;
+ RawRepresentation = rawRepresentation;
+ AdditionalProperties = DecisionSnapshots.Properties(additionalProperties);
+ }
+
+ /// Gets the request snapshot evaluated by the provider.
+ public DecisionRequest Request { get; }
+
+ /// Gets complete answers in the exact request order.
+ public IReadOnlyList Answers { get; }
+
+ /// Gets provider/model provenance, when reported.
+ public DecisionProvenance? Provenance { get; }
+
+ /// Gets usage details reported by the provider.
+ public UsageDetails? Usage { get; }
+
+ ///
+ /// Gets the provider-owned raw response, if available.
+ /// This value is not cloned or used for semantic data and must be treated as diagnostic-only.
+ ///
+ [JsonIgnore]
+ public object? RawRepresentation { get; }
+
+ ///
+ /// Gets an owned read-only snapshot of provider extension data.
+ /// Values are shallow-copied references and must be independently safe to share.
+ ///
+ public IReadOnlyDictionary? AdditionalProperties { get; }
+
+ /// Gets an answer by exact ordinal question ID.
+ /// The answer associated with the exact question ID.
+ public DecisionAnswer GetAnswer(string questionId)
+ {
+ _ = Throw.IfNullOrWhitespace(questionId);
+ foreach (DecisionAnswer answer in Answers)
+ {
+ if (string.Equals(answer.QuestionId, questionId, StringComparison.Ordinal))
+ {
+ return answer;
+ }
+ }
+
+ throw new KeyNotFoundException($"No answer exists for question ID '{questionId}'.");
+ }
+
+ internal void ValidateAgainst(DecisionRequest expectedRequest)
+ {
+ _ = Throw.IfNull(expectedRequest);
+
+ if (!JsonElement.DeepEquals(Request.State, expectedRequest.State) ||
+ Request.Questions.Count != expectedRequest.Questions.Count)
+ {
+ throw new DecisionProtocolException("The response does not correspond to the request sent by the client.");
+ }
+
+ for (int i = 0; i < Request.Questions.Count; i++)
+ {
+ if (!QuestionsAreEquivalent(Request.Questions[i], expectedRequest.Questions[i]))
+ {
+ throw new DecisionProtocolException("The response does not correspond to the request sent by the client.");
+ }
+ }
+ }
+
+ private static bool QuestionsAreEquivalent(DecisionQuestion actual, DecisionQuestion expected)
+ {
+ if (actual.Kind != expected.Kind ||
+ !string.Equals(actual.Id, expected.Id, StringComparison.Ordinal) ||
+ !string.Equals(actual.Instructions, expected.Instructions, StringComparison.Ordinal))
+ {
+ return false;
+ }
+
+ return (actual, expected) switch
+ {
+ (BinaryDecisionQuestion actualBinary, BinaryDecisionQuestion expectedBinary) =>
+ string.Equals(actualBinary.TrueDescription, expectedBinary.TrueDescription, StringComparison.Ordinal) &&
+ string.Equals(actualBinary.FalseDescription, expectedBinary.FalseDescription, StringComparison.Ordinal),
+
+ (ChoiceDecisionQuestion actualChoice, ChoiceDecisionQuestion expectedChoice) =>
+ CandidatesAreEquivalent(actualChoice.Candidates, expectedChoice.Candidates),
+
+ (ScoreDecisionQuestion actualScore, ScoreDecisionQuestion expectedScore) =>
+ LevelsAreEquivalent(actualScore.Levels, expectedScore.Levels),
+
+ _ => false,
+ };
+ }
+
+ private static bool CandidatesAreEquivalent(
+ IReadOnlyList actual,
+ IReadOnlyList expected)
+ {
+ if (actual.Count != expected.Count)
+ {
+ return false;
+ }
+
+ for (int i = 0; i < actual.Count; i++)
+ {
+ if (!string.Equals(actual[i].Id, expected[i].Id, StringComparison.Ordinal) ||
+ !string.Equals(actual[i].Description, expected[i].Description, StringComparison.Ordinal))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private static bool LevelsAreEquivalent(
+ IReadOnlyList actual,
+ IReadOnlyList expected)
+ {
+ if (actual.Count != expected.Count)
+ {
+ return false;
+ }
+
+ for (int i = 0; i < actual.Count; i++)
+ {
+ if (!string.Equals(actual[i].Id, expected[i].Id, StringComparison.Ordinal) ||
+ !string.Equals(actual[i].Description, expected[i].Description, StringComparison.Ordinal))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private static void ValidateAnswer(DecisionQuestion question, DecisionAnswer answer)
+ {
+ if (answer is null ||
+ !string.Equals(question.Id, answer.QuestionId, StringComparison.Ordinal) ||
+ question.Kind != answer.Kind)
+ {
+ throw new DecisionProtocolException("An answer does not exactly match its question.");
+ }
+
+ switch (question)
+ {
+ case BinaryDecisionQuestion when answer is BinaryDecisionAnswer:
+ return;
+
+ case ChoiceDecisionQuestion choice when answer is ChoiceDecisionAnswer choiceAnswer:
+ if (choiceAnswer.Probabilities.Count != choice.Candidates.Count ||
+ !choice.Candidates.Select(static candidate => candidate.Id)
+ .SequenceEqual(
+ choiceAnswer.Probabilities.Select(static probability => probability.Id),
+ StringComparer.Ordinal))
+ {
+ throw new DecisionProtocolException(
+ "Choice probabilities must contain exactly the requested candidate IDs in order.");
+ }
+
+ return;
+
+ case ScoreDecisionQuestion score when answer is ScoreDecisionAnswer scoreAnswer:
+ if (scoreAnswer.Probabilities.Count != score.Levels.Count ||
+ !score.Levels.Select(static level => level.Id)
+ .SequenceEqual(
+ scoreAnswer.Probabilities.Select(static probability => probability.Id),
+ StringComparer.Ordinal))
+ {
+ throw new DecisionProtocolException(
+ "Score probabilities must contain exactly the requested level IDs in order.");
+ }
+
+ return;
+
+ default:
+ throw new DecisionProtocolException("An answer kind does not match its question.");
+ }
+ }
+}
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionDefinitions.cs b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionDefinitions.cs
new file mode 100644
index 00000000000..926f0fa8812
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionDefinitions.cs
@@ -0,0 +1,645 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1402 // Definition and nested builder are one immutable API surface.
+#pragma warning disable SA1649 // File name identifies the primary definition type.
+#pragma warning disable CA1000 // The generic type is the natural home for the typed factory methods.
+#pragma warning disable CA1032 // Decision materialization exposes protocol-specific failures.
+#pragma warning disable S2302 // Protocol exception messages intentionally describe the response and configured options.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.AI;
+
+///
+/// Declares the decision questions and application-owned result properties for a typed decision flow.
+///
+/// The application-owned result type.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionDefinition
+{
+ private readonly ReadOnlyCollection> _questions;
+
+ private DecisionDefinition(
+ JsonTypeInfo resultTypeInfo,
+ JsonSerializerOptions serializerOptions,
+ IReadOnlyList> questions)
+ {
+ ResultTypeInfo = resultTypeInfo;
+ SerializerOptions = serializerOptions;
+ _questions = new ReadOnlyCollection>(questions.ToArray());
+ Questions = new ReadOnlyCollection(_questions.Select(static question => question.Question).ToArray());
+ }
+
+ /// Gets the explicit JSON contract used to materialize the application result.
+ public JsonTypeInfo ResultTypeInfo { get; }
+
+ /// Gets the serializer options associated with this definition.
+ [JsonIgnore]
+ public JsonSerializerOptions SerializerOptions { get; }
+
+ /// Gets the immutable ordered questions declared by this definition.
+ public IReadOnlyList Questions { get; }
+
+ ///
+ /// Creates a typed definition using the configured default JSON contract for .
+ ///
+ /// The explicit question declaration callback.
+ ///
+ /// Optional JSON options used for property and enum metadata. A missing resolver is supplied from the MEAI defaults;
+ /// explicit caller resolvers and converters are preserved without mutating the caller's options.
+ ///
+ /// An immutable decision definition.
+ public static DecisionDefinition Create(
+ Action configure,
+ JsonSerializerOptions? serializerOptions = null)
+ {
+ _ = Throw.IfNull(configure);
+ serializerOptions = new JsonSerializerOptions(serializerOptions ?? AIJsonUtilities.DefaultOptions);
+ serializerOptions.TypeInfoResolver ??= AIJsonUtilities.DefaultOptions.TypeInfoResolver;
+ serializerOptions.MakeReadOnly();
+
+ JsonTypeInfo resultTypeInfo = GetResultTypeInfo(serializerOptions);
+ return Create(resultTypeInfo, configure);
+ }
+
+ /// Creates a typed definition using an application-supplied JSON contract.
+ /// The JSON contract for .
+ /// The explicit question declaration callback.
+ /// An immutable decision definition.
+ public static DecisionDefinition Create(
+ JsonTypeInfo resultTypeInfo,
+ Action configure)
+ {
+ _ = Throw.IfNull(resultTypeInfo);
+ _ = Throw.IfNull(configure);
+
+ Builder builder = new(resultTypeInfo);
+ configure(builder);
+ return builder.Build();
+ }
+
+ internal DecisionResponse Bind(DecisionResponse response, DecisionRequest expectedRequest)
+ {
+ _ = Throw.IfNull(response);
+ response.ValidateAgainst(expectedRequest);
+
+ using MemoryStream stream = new();
+ using (Utf8JsonWriter writer = new(stream))
+ {
+ writer.WriteStartObject();
+
+ foreach (DecisionDefinitionQuestion question in _questions)
+ {
+ DecisionAnswer answer = response.GetAnswer(question.Question.Id);
+ switch (question.Kind)
+ {
+ case DecisionKind.Binary:
+ writer.WriteNumber(question.PropertyName, ((BinaryDecisionAnswer)answer).TrueProbability);
+ break;
+
+ case DecisionKind.Choice:
+ ChoiceDecisionAnswer choice = (ChoiceDecisionAnswer)answer;
+ writer.WriteString(question.PropertyName, choice.SelectedCandidateId);
+ break;
+
+ case DecisionKind.Score:
+ ScoreDecisionAnswer score = (ScoreDecisionAnswer)answer;
+ if (question.UsesExpectedScore)
+ {
+ writer.WriteNumber(question.PropertyName, score.ExpectedScore);
+ }
+ else if (score.Score is double reportedScore)
+ {
+ writer.WriteNumber(question.PropertyName, reportedScore);
+ }
+ else
+ {
+ throw new DecisionProtocolException(
+ $"Question '{question.Question.Id}' does not contain a provider-reported score.");
+ }
+ break;
+
+ default:
+ throw new DecisionProtocolException($"Unsupported decision kind '{question.Kind}'.");
+ }
+ }
+
+ writer.WriteEndObject();
+ }
+
+ byte[] resultJson = stream.ToArray();
+ TResult result;
+ try
+ {
+ result = JsonSerializer.Deserialize(resultJson, ResultTypeInfo)!;
+ }
+ catch (Exception exception) when (exception is JsonException or NotSupportedException)
+ {
+ throw new DecisionProtocolException(
+ "The decision response could not be materialized as the declared result type.",
+ exception);
+ }
+
+ if (result is null)
+ {
+ throw new DecisionProtocolException("The decision response produced a null result.");
+ }
+
+ foreach (DecisionDefinitionQuestion question in _questions)
+ {
+ DecisionAnswer answer = response.GetAnswer(question.Question.Id);
+ object? actualValue = question.ValueAccessor(result);
+ bool preserved = question.Kind switch
+ {
+ DecisionKind.Binary => actualValue is double actualBinary &&
+ actualBinary.Equals(((BinaryDecisionAnswer)answer).TrueProbability),
+ DecisionKind.Choice => question.ChoiceValueMatches is not null &&
+ question.ChoiceValueMatches(actualValue, ((ChoiceDecisionAnswer)answer).SelectedCandidateId),
+ DecisionKind.Score => actualValue is double actualScore &&
+ actualScore.Equals(question.UsesExpectedScore
+ ? ((ScoreDecisionAnswer)answer).ExpectedScore
+ : ((ScoreDecisionAnswer)answer).Score ?? double.NaN),
+ _ => false,
+ };
+
+ if (!preserved)
+ {
+ throw new DecisionProtocolException(
+ $"The decision response value for result property '{question.Property.Name}' was not preserved by the configured JSON contract.");
+ }
+ }
+
+ return new DecisionResponse(result, response, this);
+ }
+
+ internal IReadOnlyDictionary GetDistribution(
+ DecisionResponse response,
+ Expression> selector)
+ where TEnum : struct, Enum
+ {
+ DecisionDefinitionQuestion question = FindQuestion(selector);
+ if (question.Kind != DecisionKind.Choice ||
+ question.EnumDefinition is not DecisionEnumDefinition definition)
+ {
+ throw new DecisionProtocolException("The selected result property is not a choice enum in this definition.");
+ }
+
+ ChoiceDecisionAnswer answer = (ChoiceDecisionAnswer)response.Evidence.GetAnswer(question.Question.Id);
+ Dictionary values = new();
+ foreach (DecisionProbability probability in answer.Probabilities)
+ {
+ values.Add(definition.Parse(probability.Id), probability.Value);
+ }
+
+ return new ReadOnlyDictionary(values);
+ }
+
+ private static JsonTypeInfo GetResultTypeInfo(JsonSerializerOptions options)
+ {
+ if (options.GetTypeInfo(typeof(TResult)) is not JsonTypeInfo resultTypeInfo)
+ {
+ throw new NotSupportedException(
+ $"The configured JSON options do not contain a contract for result type '{typeof(TResult)}'.");
+ }
+
+ return resultTypeInfo;
+ }
+
+ private static PropertyInfo GetDirectProperty(Expression> selector)
+ {
+ _ = Throw.IfNull(selector);
+
+ Expression body = selector.Body;
+ if (body is UnaryExpression { NodeType: ExpressionType.Convert } conversion)
+ {
+ body = conversion.Operand;
+ }
+
+ if (body is not MemberExpression { Member: PropertyInfo property, Expression: ParameterExpression parameter } ||
+ selector.Parameters.Count != 1 ||
+ selector.Parameters[0] != parameter)
+ {
+ Throw.ArgumentException(
+ nameof(selector),
+ "The selector must access one direct instance property of the result type.");
+ return null!;
+ }
+
+ return property;
+ }
+
+ private DecisionDefinitionQuestion FindQuestion(Expression> selector)
+ {
+ PropertyInfo property = GetDirectProperty(selector);
+ return _questions.FirstOrDefault(question => question.Property == property) ??
+ throw new DecisionProtocolException($"The result property '{property.Name}' is not declared in this definition.");
+ }
+
+ /// Builds a through explicit property declarations.
+ [Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+ public sealed class Builder
+ {
+ private readonly JsonTypeInfo _resultTypeInfo;
+ private readonly List> _questions = [];
+
+ private static DecisionEnumDefinition CreateEnumDefinition<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] TEnum>(
+ PropertyInfo property,
+ JsonTypeInfo resultTypeInfo,
+ JsonPropertyInfo jsonProperty)
+ where TEnum : struct, Enum
+ {
+ if (property.PropertyType.IsDefined(typeof(FlagsAttribute), inherit: false))
+ {
+ Throw.ArgumentException("selector", "Flags enums are not supported as closed decision choices.");
+ }
+
+ if (jsonProperty.CustomConverter is not null)
+ {
+ throw new NotSupportedException(
+ $"Property-specific JSON converters are not supported for decision enum property '{property.Name}'. " +
+ "Configure the enum converter at the JSON type/options level so candidate IDs and result materialization share one contract.");
+ }
+
+ JsonTypeInfo enumTypeInfo;
+ try
+ {
+ enumTypeInfo = resultTypeInfo.Options.GetTypeInfo(typeof(TEnum));
+ }
+ catch (Exception exception) when (exception is NotSupportedException or InvalidOperationException)
+ {
+ throw new NotSupportedException(
+ $"The configured JSON options do not contain a contract for enum type '{typeof(TEnum)}'.",
+ exception);
+ }
+
+#if NET5_0_OR_GREATER
+ TEnum[] enumValues = Enum.GetValues();
+#else
+ TEnum[] enumValues = Enum.GetValues(typeof(TEnum)).Cast().ToArray();
+#endif
+ List> values = new(enumValues.Length);
+ foreach (TEnum value in enumValues)
+ {
+ JsonElement serialized = JsonSerializer.SerializeToElement(value, enumTypeInfo);
+ if (serialized.ValueKind != JsonValueKind.String || serialized.GetString() is not string id)
+ {
+ throw new NotSupportedException(
+ $"Enum type '{typeof(TEnum)}' must use string JSON serialization for decision choices.");
+ }
+
+ string enumName = Enum.GetName(typeof(TEnum), value)!;
+ string description = typeof(TEnum).GetField(enumName)?.GetCustomAttribute()?.Description ??
+ enumName;
+
+ values.Add(new DecisionEnumValue(value, id, description));
+ }
+
+ return new DecisionEnumDefinition(values);
+ }
+
+ private static JsonPropertyInfo GetJsonProperty(JsonTypeInfo resultTypeInfo, PropertyInfo property)
+ {
+ JsonPropertyInfo? jsonProperty = resultTypeInfo.Properties.FirstOrDefault(
+ candidate => candidate.AttributeProvider is PropertyInfo propertyInfo && propertyInfo == property);
+
+ if (jsonProperty is null)
+ {
+ string expectedName = property.GetCustomAttribute()?.Name ??
+ resultTypeInfo.Options.PropertyNamingPolicy?.ConvertName(property.Name) ??
+ property.Name;
+ jsonProperty = resultTypeInfo.Properties.FirstOrDefault(
+ candidate => string.Equals(candidate.Name, expectedName, StringComparison.Ordinal));
+ }
+
+ if (jsonProperty is null)
+ {
+ Throw.ArgumentException(
+ nameof(property),
+ $"The selected property '{property.Name}' is not present in the configured JSON contract.");
+ }
+
+ return jsonProperty;
+ }
+
+ private static string GetInstructions(JsonPropertyInfo jsonProperty, PropertyInfo property, string? explicitInstructions)
+ {
+ if (explicitInstructions is not null)
+ {
+ return Throw.IfNullOrWhitespace(explicitInstructions);
+ }
+
+ string? description = (jsonProperty.AttributeProvider as PropertyInfo)?.GetCustomAttribute(inherit: true)?.Description;
+ if (description is not null)
+ {
+ return description;
+ }
+
+#if NET9_0_OR_GREATER
+ description = jsonProperty.AssociatedParameter?.AttributeProvider?.GetCustomAttributes(typeof(DescriptionAttribute), inherit: true)
+ .OfType()
+ .FirstOrDefault()
+ ?.Description;
+#else
+ description = GetConstructorDescription(property);
+#endif
+ if (description is not null)
+ {
+ return description;
+ }
+
+ return property.PropertyType.GetCustomAttribute(inherit: true)?.Description ??
+ property.Name;
+ }
+
+ private static void EnsurePropertyCanBeDeclared(PropertyInfo property, Type expectedType)
+ {
+ if (property.GetMethod is null ||
+ property.GetMethod.IsStatic ||
+ property.PropertyType != expectedType)
+ {
+ Throw.ArgumentException("selector", $"The selected property must be a readable instance property of type '{expectedType}'.");
+ }
+ }
+
+#if !NET9_0_OR_GREATER
+ [UnconditionalSuppressMessage("Trimming", "IL2075", Justification = "The reflection convenience path checks preserved constructor binding metadata; source-generated metadata is used on newer TFMs.")]
+#endif
+ private static void EnsurePropertyCanBeMaterialized(
+ PropertyInfo property,
+ JsonPropertyInfo jsonProperty)
+ {
+ if (jsonProperty.Set is not null)
+ {
+ return;
+ }
+
+#if NET9_0_OR_GREATER
+ if (jsonProperty.AssociatedParameter is not null)
+ {
+ return;
+ }
+#else
+ ConstructorInfo[] constructors = property.DeclaringType?.GetConstructors() ?? [];
+ if (Array.Exists(
+ constructors,
+ candidate => Array.Exists(
+ candidate.GetParameters(),
+ parameter => string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase))))
+ {
+ return;
+ }
+#endif
+
+ Throw.ArgumentException(
+ "selector",
+ $"The selected property '{property.Name}' is not writable or bound to a JSON constructor parameter.");
+ }
+
+#if !NET9_0_OR_GREATER
+ [UnconditionalSuppressMessage("Trimming", "IL2075", Justification = "The reflection convenience path intentionally reads preserved constructor parameter metadata; source-generated metadata is used on newer TFMs.")]
+ private static string? GetConstructorDescription(PropertyInfo property)
+ {
+ ConstructorInfo[] constructors = property.DeclaringType?.GetConstructors() ?? [];
+ ConstructorInfo? constructor = Array.Find(
+ constructors,
+ candidate => Array.Exists(candidate.GetParameters(), parameter =>
+ string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase)));
+ return Array.Find(
+ constructor?.GetParameters() ?? [],
+ parameter => string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase))
+ ?.GetCustomAttribute(inherit: true)
+ ?.Description;
+ }
+#endif
+
+ private static Func CreateValueAccessor(Expression> selector)
+ {
+#if NETFRAMEWORK
+ Func accessor = selector.Compile();
+#else
+ Func accessor = selector.Compile(true);
+#endif
+ return result => accessor(result);
+ }
+
+ private static Func CreateChoiceValueMatcher(
+ DecisionEnumDefinition enumDefinition)
+ where TEnum : struct, Enum =>
+ (actualValue, candidateId) =>
+ actualValue is TEnum actual &&
+ EqualityComparer.Default.Equals(actual, enumDefinition.Parse(candidateId));
+
+ internal Builder(JsonTypeInfo resultTypeInfo)
+ {
+ _resultTypeInfo = resultTypeInfo;
+ }
+
+ /// Declares an enum-backed choice question.
+ /// The result property enum type.
+ /// A direct result property selector.
+ /// Optional explicit question instructions.
+ public void Choice<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] TEnum>(
+ Expression> selector,
+ string? instructions = null)
+ where TEnum : struct, Enum
+ {
+ PropertyInfo property = GetDirectProperty(selector);
+ EnsurePropertyCanBeDeclared(property, typeof(TEnum));
+
+ JsonPropertyInfo jsonProperty = GetJsonProperty(_resultTypeInfo, property);
+ EnsurePropertyCanBeMaterialized(property, jsonProperty);
+ DecisionEnumDefinition enumDefinition = CreateEnumDefinition(property, _resultTypeInfo, jsonProperty);
+ AddQuestion(
+ property,
+ jsonProperty.Name,
+ new ChoiceDecisionQuestion(jsonProperty.Name, GetInstructions(jsonProperty, property, instructions), enumDefinition.Candidates),
+ enumDefinition,
+ DecisionKind.Choice,
+ valueAccessor: CreateValueAccessor(selector),
+ choiceValueMatches: CreateChoiceValueMatcher(enumDefinition));
+ }
+
+ /// Declares a binary probability question backed by a result property.
+ /// A direct result property selector.
+ /// Optional explicit question instructions.
+ public void BinaryProbability(
+ Expression> selector,
+ string? instructions = null)
+ {
+ PropertyInfo property = GetDirectProperty(selector);
+ EnsurePropertyCanBeDeclared(property, typeof(double));
+
+ JsonPropertyInfo jsonProperty = GetJsonProperty(_resultTypeInfo, property);
+ EnsurePropertyCanBeMaterialized(property, jsonProperty);
+ AddQuestion(
+ property,
+ jsonProperty.Name,
+ new BinaryDecisionQuestion(jsonProperty.Name, GetInstructions(jsonProperty, property, instructions)),
+ enumDefinition: null,
+ DecisionKind.Binary,
+ valueAccessor: CreateValueAccessor(selector));
+ }
+
+ /// Declares an ordinal score question with an explicit ordered rubric.
+ /// A direct result property selector.
+ /// The caller-defined ordered score levels.
+ /// Optional explicit question instructions.
+ public void Score(
+ Expression> selector,
+ IReadOnlyList levels,
+ string? instructions = null)
+ {
+ AddScore(selector, levels, instructions, usesExpectedScore: false);
+ }
+
+ /// Declares an ordinal score question projected from the complete observed distribution.
+ /// A direct result property selector.
+ /// The caller-defined ordered score levels.
+ /// Optional explicit question instructions.
+ public void ExpectedScore(
+ Expression> selector,
+ IReadOnlyList levels,
+ string? instructions = null)
+ {
+ AddScore(selector, levels, instructions, usesExpectedScore: true);
+ }
+
+ private void AddScore(
+ Expression> selector,
+ IReadOnlyList levels,
+ string? instructions,
+ bool usesExpectedScore)
+ {
+ PropertyInfo property = GetDirectProperty(selector);
+ EnsurePropertyCanBeDeclared(property, typeof(double));
+ _ = Throw.IfNull(levels);
+
+ JsonPropertyInfo jsonProperty = GetJsonProperty(_resultTypeInfo, property);
+ EnsurePropertyCanBeMaterialized(property, jsonProperty);
+ AddQuestion(
+ property,
+ jsonProperty.Name,
+ new ScoreDecisionQuestion(jsonProperty.Name, GetInstructions(jsonProperty, property, instructions), levels),
+ enumDefinition: null,
+ DecisionKind.Score,
+ usesExpectedScore,
+ valueAccessor: CreateValueAccessor(selector));
+ }
+
+ internal DecisionDefinition Build()
+ {
+ if (_questions.Count == 0)
+ {
+ Throw.ArgumentException("configure", "A decision definition must declare at least one question.");
+ }
+
+ return new DecisionDefinition(
+ _resultTypeInfo,
+ _resultTypeInfo.Options,
+ _questions);
+ }
+
+ private void AddQuestion(
+ PropertyInfo property,
+ string propertyName,
+ DecisionQuestion question,
+ object? enumDefinition,
+ DecisionKind kind,
+ bool usesExpectedScore = false,
+ Func? valueAccessor = null,
+ Func? choiceValueMatches = null)
+ {
+ if (_questions.Exists(existing => existing.Property == property || string.Equals(existing.PropertyName, propertyName, StringComparison.Ordinal)))
+ {
+ Throw.ArgumentException("selector", "A result property or JSON property name can only be declared once.");
+ }
+
+ _questions.Add(new DecisionDefinitionQuestion(
+ property,
+ propertyName,
+ question,
+ enumDefinition,
+ kind,
+ usesExpectedScore,
+ valueAccessor ?? throw new InvalidOperationException("A direct property accessor is required."),
+ choiceValueMatches));
+ }
+ }
+
+}
+
+/// Contains a typed result and the complete neutral evidence that produced it.
+/// The application-owned result type.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionResponse
+{
+ private readonly DecisionDefinition _definition;
+
+ internal DecisionResponse(TResult result, DecisionResponse evidence, DecisionDefinition definition)
+ {
+ Result = result;
+ Evidence = evidence;
+ _definition = definition;
+ }
+
+ /// Gets the application-owned materialized result.
+ public TResult Result { get; }
+
+ /// Gets the complete original response, including distributions and metadata.
+ public DecisionResponse Evidence { get; }
+
+ /// Gets the complete probability distribution for an enum-backed choice property.
+ /// The enum property type.
+ /// The direct result property selector.
+ /// An immutable enum-to-probability snapshot.
+ public IReadOnlyDictionary GetDistribution(
+ Expression> selector)
+ where TEnum : struct, Enum =>
+ _definition.GetDistribution(this, selector);
+}
+
+internal sealed class DecisionDefinitionQuestion
+{
+ internal DecisionDefinitionQuestion(
+ PropertyInfo property,
+ string propertyName,
+ DecisionQuestion question,
+ object? enumDefinition,
+ DecisionKind kind,
+ bool usesExpectedScore,
+ Func valueAccessor,
+ Func? choiceValueMatches)
+ {
+ Property = property;
+ PropertyName = propertyName;
+ Question = question;
+ EnumDefinition = enumDefinition;
+ Kind = kind;
+ UsesExpectedScore = usesExpectedScore;
+ ValueAccessor = valueAccessor;
+ ChoiceValueMatches = choiceValueMatches;
+ }
+
+ internal PropertyInfo Property { get; }
+ internal string PropertyName { get; }
+ internal DecisionQuestion Question { get; }
+ internal object? EnumDefinition { get; }
+ internal DecisionKind Kind { get; }
+ internal bool UsesExpectedScore { get; }
+ internal Func ValueAccessor { get; }
+ internal Func? ChoiceValueMatches { get; }
+}
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionFeatures.cs b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionFeatures.cs
new file mode 100644
index 00000000000..51a4944233f
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionFeatures.cs
@@ -0,0 +1,243 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1402 // File may only contain a single type — feature projection types are co-located as one API surface.
+#pragma warning disable SA1649 // File name should match first type name — feature projection types are co-located as one API surface.
+#pragma warning disable SA1204 // Static projection type is intentionally grouped with the feature model.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.AI;
+
+/// Identifies the semantic value projected by a feature coordinate.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public enum DecisionFeatureValueKind
+{
+ /// The probability that a binary proposition is true.
+ BinaryTrueProbability,
+
+ /// The probability that a binary proposition is false.
+ BinaryFalseProbability,
+
+ /// The probability of one choice candidate.
+ ChoiceProbability,
+
+ /// The probability of one score level.
+ ScoreProbability,
+
+ /// The provider-reported ordinal score.
+ Score,
+
+ /// The ordinal score calculated from the complete observed distribution.
+ ExpectedScore,
+}
+
+/// Names one stable semantic coordinate in a feature schema.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionFeatureCoordinate
+{
+ /// Initializes a new instance of the class.
+ public DecisionFeatureCoordinate(
+ string name,
+ string questionId,
+ DecisionFeatureValueKind valueKind,
+ string? memberId = null)
+ {
+ Name = Throw.IfNullOrWhitespace(name);
+ QuestionId = Throw.IfNullOrWhitespace(questionId);
+ if (!Enum.IsDefined(typeof(DecisionFeatureValueKind), valueKind))
+ {
+ Throw.ArgumentOutOfRangeException(nameof(valueKind));
+ }
+
+ ValueKind = valueKind;
+
+ bool requiresMemberId = valueKind is DecisionFeatureValueKind.ChoiceProbability or DecisionFeatureValueKind.ScoreProbability;
+ if (requiresMemberId != (memberId is not null))
+ {
+ Throw.ArgumentException(
+ nameof(memberId),
+ requiresMemberId ? "This coordinate kind requires a member ID." : "This coordinate kind does not accept a member ID.");
+ }
+
+ if (memberId is not null)
+ {
+ MemberId = Throw.IfNullOrWhitespace(memberId);
+ }
+ }
+
+ /// Gets the stable coordinate name.
+ public string Name { get; }
+
+ /// Gets the exact question ID supplying this coordinate.
+ public string QuestionId { get; }
+
+ /// Gets the coordinate semantic kind.
+ public DecisionFeatureValueKind ValueKind { get; }
+
+ /// Gets the exact candidate or level ID, when applicable.
+ public string? MemberId { get; }
+}
+
+/// Identifies a named feature schema and its version.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionFeatureSchema
+{
+ /// Initializes a new instance of the class.
+ public DecisionFeatureSchema(string id, int version, IEnumerable coordinates)
+ {
+ Id = Throw.IfNullOrWhitespace(id);
+ if (version < 1)
+ {
+ Throw.ArgumentOutOfRangeException(nameof(version));
+ }
+
+ _ = Throw.IfNull(coordinates);
+ DecisionFeatureCoordinate[] copy = coordinates.ToArray();
+ if (copy.Length == 0 || Array.Exists(copy, static coordinate => coordinate is null))
+ {
+ Throw.ArgumentException(nameof(coordinates), "Coordinates must be nonempty.");
+ }
+
+ HashSet names = new(StringComparer.Ordinal);
+ foreach (DecisionFeatureCoordinate coordinate in copy)
+ {
+ if (!names.Add(coordinate.Name))
+ {
+ Throw.ArgumentException(nameof(coordinates), "Feature names must be unique using ordinal comparison.");
+ }
+ }
+
+ Version = version;
+ Coordinates = Array.AsReadOnly(copy);
+ }
+
+ /// Gets the stable schema identity.
+ public string Id { get; }
+
+ /// Gets the schema version.
+ public int Version { get; }
+
+ /// Gets the ordered coordinate snapshot.
+ public IReadOnlyList Coordinates { get; }
+}
+
+/// Represents one named native-double feature value.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionFeatureValue
+{
+ /// Initializes a new instance of the class.
+ public DecisionFeatureValue(string name, double value)
+ {
+ Name = Throw.IfNullOrWhitespace(name);
+ if (double.IsNaN(value) || double.IsInfinity(value))
+ {
+ Throw.ArgumentOutOfRangeException(nameof(value));
+ }
+
+ Value = value;
+ }
+
+ /// Gets the stable coordinate name.
+ public string Name { get; }
+
+ /// Gets the native double value.
+ public double Value { get; }
+}
+
+/// Represents a named feature projection with schema and provenance.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionFeatureVector
+{
+ internal DecisionFeatureVector(
+ DecisionFeatureSchema schema,
+ IEnumerable values,
+ DecisionProvenance? provenance)
+ {
+ Schema = schema;
+ Values = Array.AsReadOnly(values.ToArray());
+ Provenance = provenance;
+ }
+
+ /// Gets the explicit feature schema.
+ public DecisionFeatureSchema Schema { get; }
+
+ /// Gets named values in schema order.
+ public IReadOnlyList Values { get; }
+
+ /// Gets provider/model provenance, when reported by the response.
+ public DecisionProvenance? Provenance { get; }
+}
+
+/// Projects complete decision observations into named native-double coordinates.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public static class DecisionFeatureProjection
+{
+ /// Projects a response without an inference call or probability repair.
+ /// The named feature vector projected from the complete response.
+ public static DecisionFeatureVector Project(
+ DecisionResponse response,
+ DecisionFeatureSchema schema)
+ {
+ _ = Throw.IfNull(response);
+ _ = Throw.IfNull(schema);
+
+ List values = new(schema.Coordinates.Count);
+ foreach (DecisionFeatureCoordinate coordinate in schema.Coordinates)
+ {
+ DecisionAnswer answer = response.GetAnswer(coordinate.QuestionId);
+ double value = coordinate.ValueKind switch
+ {
+ DecisionFeatureValueKind.BinaryTrueProbability =>
+ GetBinary(answer, coordinate).TrueProbability,
+ DecisionFeatureValueKind.BinaryFalseProbability =>
+ 1 - GetBinary(answer, coordinate).TrueProbability,
+ DecisionFeatureValueKind.ChoiceProbability =>
+ GetProbability(GetChoice(answer, coordinate).Probabilities, coordinate.MemberId!),
+ DecisionFeatureValueKind.ScoreProbability =>
+ GetProbability(GetScore(answer, coordinate).Probabilities, coordinate.MemberId!),
+ DecisionFeatureValueKind.Score =>
+ GetScore(answer, coordinate).Score ??
+ throw new DecisionProtocolException(
+ $"Question '{coordinate.QuestionId}' does not contain a provider-reported score."),
+ DecisionFeatureValueKind.ExpectedScore =>
+ GetScore(answer, coordinate).ExpectedScore,
+ _ => throw new ArgumentOutOfRangeException(nameof(schema)),
+ };
+
+ values.Add(new DecisionFeatureValue(coordinate.Name, value));
+ }
+
+ return new DecisionFeatureVector(schema, values, response.Provenance);
+ }
+
+ private static BinaryDecisionAnswer GetBinary(DecisionAnswer answer, DecisionFeatureCoordinate coordinate) =>
+ answer as BinaryDecisionAnswer ??
+ throw new ArgumentException($"Question '{coordinate.QuestionId}' is not binary.", nameof(coordinate));
+
+ private static ChoiceDecisionAnswer GetChoice(DecisionAnswer answer, DecisionFeatureCoordinate coordinate) =>
+ answer as ChoiceDecisionAnswer ??
+ throw new ArgumentException($"Question '{coordinate.QuestionId}' is not a choice.", nameof(coordinate));
+
+ private static ScoreDecisionAnswer GetScore(DecisionAnswer answer, DecisionFeatureCoordinate coordinate) =>
+ answer as ScoreDecisionAnswer ??
+ throw new ArgumentException($"Question '{coordinate.QuestionId}' is not a score.", nameof(coordinate));
+
+ private static double GetProbability(IReadOnlyList probabilities, string memberId)
+ {
+ foreach (DecisionProbability probability in probabilities)
+ {
+ if (string.Equals(probability.Id, memberId, StringComparison.Ordinal))
+ {
+ return probability.Value;
+ }
+ }
+
+ throw new DecisionProtocolException($"Unknown feature member ID '{memberId}'.");
+ }
+}
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionQuestions.cs b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionQuestions.cs
new file mode 100644
index 00000000000..cc37031765c
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/DecisionQuestions.cs
@@ -0,0 +1,281 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1402 // File may only contain a single type — decision question types are co-located as one immutable model.
+#pragma warning disable SA1649 // File name should match first type name — decision question types are co-located as one immutable model.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using Microsoft.Shared.DiagnosticIds;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.AI;
+
+/// Identifies the semantic kind of a decision question or answer.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public enum DecisionKind
+{
+ /// A two-outcome proposition.
+ Binary,
+
+ /// A choice from a caller-defined unordered set.
+ Choice,
+
+ /// A position on a caller-defined ordered scale.
+ Score,
+}
+
+/// Describes a decision question.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "$type")]
+[JsonDerivedType(typeof(BinaryDecisionQuestion), "binary")]
+[JsonDerivedType(typeof(ChoiceDecisionQuestion), "choice")]
+[JsonDerivedType(typeof(ScoreDecisionQuestion), "score")]
+public abstract class DecisionQuestion
+{
+ private protected DecisionQuestion(string id, DecisionKind kind, string? instructions)
+ {
+ Id = Throw.IfNullOrWhitespace(id);
+ Kind = kind;
+ Instructions = instructions ?? string.Empty;
+ }
+
+ /// Gets the opaque, caller-owned correlation ID for this question.
+ public string Id { get; }
+
+ /// Gets the semantic kind of this question.
+ public DecisionKind Kind { get; }
+
+ /// Gets the explicit instructions that define the question.
+ public string Instructions { get; }
+}
+
+/// Describes a binary decision question.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class BinaryDecisionQuestion : DecisionQuestion
+{
+ /// Initializes a new instance of the class.
+ /// The opaque, caller-owned question ID.
+ /// The instructions defining the proposition.
+ /// Optional criteria describing a true result.
+ /// Optional criteria describing a false result.
+ [JsonConstructor]
+ public BinaryDecisionQuestion(
+ string id,
+ string? instructions = null,
+ string? trueDescription = null,
+ string? falseDescription = null)
+ : base(id, DecisionKind.Binary, instructions)
+ {
+ if (string.IsNullOrWhiteSpace(instructions) &&
+ (string.IsNullOrWhiteSpace(trueDescription) || string.IsNullOrWhiteSpace(falseDescription)))
+ {
+ Throw.ArgumentException(
+ nameof(instructions),
+ "Binary questions require instructions or both true and false descriptions.");
+ }
+
+ if (trueDescription is not null)
+ {
+ _ = Throw.IfNullOrWhitespace(trueDescription);
+ }
+
+ if (falseDescription is not null)
+ {
+ _ = Throw.IfNullOrWhitespace(falseDescription);
+ }
+
+ TrueDescription = trueDescription;
+ FalseDescription = falseDescription;
+ }
+
+ /// Gets the optional criteria describing a true result.
+ public string? TrueDescription { get; }
+
+ /// Gets the optional criteria describing a false result.
+ public string? FalseDescription { get; }
+}
+
+/// Describes one caller-defined choice candidate.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionCandidate
+{
+ /// Initializes a new instance of the class.
+ /// The exact opaque candidate ID to round-trip in results.
+ /// The human-readable candidate criteria.
+ [JsonConstructor]
+ public DecisionCandidate(string id, string description)
+ {
+ Id = Throw.IfNullOrWhitespace(id);
+ Description = Throw.IfNullOrWhitespace(description);
+ }
+
+ /// Gets the exact opaque, caller-owned candidate ID.
+ public string Id { get; }
+
+ /// Gets the human-readable candidate criteria.
+ public string Description { get; }
+}
+
+/// Describes a choice decision question.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class ChoiceDecisionQuestion : DecisionQuestion
+{
+ /// Initializes a new instance of the class.
+ /// The opaque, caller-owned question ID.
+ /// The instructions defining the choice.
+ /// The ordered, caller-defined candidates.
+ [JsonConstructor]
+ public ChoiceDecisionQuestion(string id, string? instructions, IReadOnlyList candidates)
+ : base(id, DecisionKind.Choice, instructions)
+ {
+ _ = Throw.IfNull(candidates);
+
+ DecisionCandidate[] copy = candidates.ToArray();
+ if (copy.Length == 0 || Array.Exists(copy, static candidate => candidate is null))
+ {
+ Throw.ArgumentException(nameof(candidates), "Candidates must be nonempty.");
+ }
+
+ HashSet ids = new(StringComparer.Ordinal);
+ foreach (DecisionCandidate candidate in copy)
+ {
+ if (!ids.Add(candidate.Id))
+ {
+ Throw.ArgumentException(
+ nameof(candidates),
+ "Candidate IDs must be unique using ordinal comparison.");
+ }
+ }
+
+ Candidates = Array.AsReadOnly(copy);
+ }
+
+ /// Gets the ordered, owned candidate snapshot.
+ public IReadOnlyList Candidates { get; }
+}
+
+/// Describes one level in an ordered score rubric.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionScoreLevel
+{
+ /// Initializes a new instance of the class.
+ /// The exact opaque, caller-owned level ID.
+ /// The criteria for this level.
+ [JsonConstructor]
+ public DecisionScoreLevel(string id, string description)
+ {
+ Id = Throw.IfNullOrWhitespace(id);
+ Description = Throw.IfNullOrWhitespace(description);
+ }
+
+ /// Gets the exact opaque level ID.
+ public string Id { get; }
+
+ /// Gets the criteria for this level.
+ public string Description { get; }
+}
+
+/// Describes a score decision question.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class ScoreDecisionQuestion : DecisionQuestion
+{
+ /// Initializes a new instance of the class.
+ /// The opaque, caller-owned question ID.
+ /// The instructions defining the score.
+ /// The ordered, caller-defined score levels.
+ [JsonConstructor]
+ public ScoreDecisionQuestion(string id, string? instructions, IReadOnlyList levels)
+ : base(id, DecisionKind.Score, instructions)
+ {
+ _ = Throw.IfNull(levels);
+
+ DecisionScoreLevel[] copy = levels.ToArray();
+ if (copy.Length < 2 || Array.Exists(copy, static level => level is null))
+ {
+ Throw.ArgumentException(nameof(levels), "A score question requires at least two levels.");
+ }
+
+ HashSet ids = new(StringComparer.Ordinal);
+ foreach (DecisionScoreLevel level in copy)
+ {
+ if (!ids.Add(level.Id))
+ {
+ Throw.ArgumentException(
+ nameof(levels),
+ "Score level IDs must be unique using ordinal comparison.");
+ }
+ }
+
+ Levels = Array.AsReadOnly(copy);
+ }
+
+ /// Gets the ordered, owned score-level snapshot.
+ public IReadOnlyList Levels { get; }
+}
+
+/// Represents a state and a nonempty, ordered batch of questions.
+[Experimental(DiagnosticIds.Experiments.AIDecisions, UrlFormat = DiagnosticIds.UrlFormat)]
+public sealed class DecisionRequest
+{
+ /// Initializes a new instance of the class and snapshots its state and questions.
+ /// The explicit JSON state evaluated by every question.
+ /// The ordered heterogeneous question batch.
+ [JsonConstructor]
+ public DecisionRequest(JsonElement state, IReadOnlyList questions)
+ {
+ if (state.ValueKind == JsonValueKind.Undefined)
+ {
+ Throw.ArgumentException(nameof(state), "State must be explicit JSON.");
+ }
+
+ _ = Throw.IfNull(questions);
+
+ DecisionQuestion[] copy = questions.ToArray();
+ if (copy.Length == 0 || Array.Exists(copy, static question => question is null))
+ {
+ Throw.ArgumentException(nameof(questions), "Questions must be nonempty.");
+ }
+
+ HashSet ids = new(StringComparer.Ordinal);
+ foreach (DecisionQuestion question in copy)
+ {
+ if (!ids.Add(question.Id))
+ {
+ Throw.ArgumentException(
+ nameof(questions),
+ "Question IDs must be unique using ordinal comparison.");
+ }
+ }
+
+ State = state.Clone();
+ Questions = Array.AsReadOnly(copy);
+ }
+
+ /// Gets the owned JSON state snapshot.
+ public JsonElement State { get; }
+
+ /// Gets the ordered, owned question snapshot.
+ public IReadOnlyList Questions { get; }
+
+ /// Creates a request from an application-owned state using an explicit source-generated contract.
+ /// The application state type.
+ /// The application-owned state.
+ /// The source-generated JSON contract for .
+ /// The ordered heterogeneous question batch.
+ /// An owned decision request.
+ public static DecisionRequest Create(
+ TState state,
+ JsonTypeInfo stateTypeInfo,
+ IEnumerable questions)
+ {
+ _ = Throw.IfNull(stateTypeInfo);
+ _ = Throw.IfNull(questions);
+ return new(JsonSerializer.SerializeToElement(state, stateTypeInfo), questions.ToArray());
+ }
+}
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/README.md b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/README.md
new file mode 100644
index 00000000000..ca0e7d73916
--- /dev/null
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Decisions/README.md
@@ -0,0 +1,151 @@
+# Experimental decision abstractions
+
+The `Microsoft.Extensions.AI.Abstractions` decision contracts provide a small provider-neutral proposed Layer 1 capability for heterogeneous binary, choice, and ordinal-score questions. Requests preserve caller-owned question and candidate IDs and order; responses preserve complete probability observations, score precision, provenance, usage, and provider extensions without applying thresholds, calibration, probability repair, retry policy, or a joint-distribution promise.
+
+## A business example
+
+Suppose a retailer annotates customer-support tickets. The application wants a normal .NET category, a probability that the ticket is a refund request, and the complete provider evidence for reporting, human review, or downstream training. It is not automatically authorizing a refund, choosing a route, or treating a probability as a calibrated business decision.
+
+The domain types remain ordinary application-owned types. The standard `DescriptionAttribute` on the positional record parameters supplies business instructions for the selected result properties, while the enum members supply separate candidate criteria:
+
+```csharp
+#pragma warning disable MEAI001
+
+using System.ComponentModel;
+
+public sealed record SupportTicket(string Message);
+
+public enum TicketCategory
+{
+ [Description("Payment, invoice, or charge concerns.")]
+ Billing,
+
+ [Description("Product defects, errors, outages, or troubleshooting.")]
+ Technical,
+
+ [Description("Sign-in, profile, or account-access concerns.")]
+ Account,
+}
+
+public sealed record TicketAnalysis(
+ [Description("Classify the customer's main concern.")] TicketCategory Category,
+ [Description("Is the customer requesting a refund or payment reversal?")] double RefundRequestProbability);
+```
+
+The business call is ordinary application code. Assume the host supplies the `IDecisionClient client`; the declaration is reusable and explicit. `Choice` declares the closed enum domain and uses its configured JSON enum names as exact candidate IDs; `BinaryProbability` maps the binary answer's `TrueProbability` to a `double`. No handwritten question IDs, enum dictionary, result mapper, JSON schema, or feature schema is required for this ordinary flow:
+
+```csharp
+using Microsoft.Extensions.AI;
+
+var definition = DecisionDefinition.Create(builder =>
+{
+ builder.Choice(result => result.Category);
+ builder.BinaryProbability(result => result.RefundRequestProbability);
+});
+
+var ticket = new SupportTicket(
+ "I was charged twice. Please refund the duplicate payment.");
+
+var response = await client.GetResponseAsync(ticket, definition);
+
+TicketAnalysis analysis = response.Result;
+DecisionResponse evidence = response.Evidence;
+```
+
+When the complete choice evidence is useful for reporting or review, the typed distribution remains available:
+
+```csharp
+var categoryDistribution = response.GetDistribution(value => value.Category);
+```
+
+The same definition can include an explicitly ordered score rubric, and heterogeneous declarations remain independent:
+
+```csharp
+var definitionWithScore = DecisionDefinition.Create(builder =>
+{
+ builder.Choice(result => result.Category, "Classify the customer's main concern.");
+ builder.BinaryProbability(result => result.RefundRequestProbability);
+ // A score property would be declared with an explicit DecisionScoreLevel list:
+ // builder.Score(result => result.Satisfaction, [new("low", "Low"), new("high", "High")]);
+ // builder.ExpectedScore(result => result.Satisfaction, [new("low", "Low"), new("high", "High")]);
+});
+```
+
+`Score` projects only a provider-reported native ordinal score and fails explicitly when that scalar is absent. `ExpectedScore` projects the unmodified ordinal expectation calculated from the complete observed distribution, so the two choices remain distinguishable; after probability rounding, that observed expectation can fall outside the ordinal bounds and is not repaired. Every probability is conditioned on the full request state and question set; declaring questions independently does not promise marginal invariance, independence, a joint distribution, or calibration.
+
+Reported scalar consistency uses normalized latent feasibility within clipped rounding intervals; the observed probabilities are never normalized or rewritten. Typed binding verifies the actual CLR property values after materialization, independently of write-only JSON formatting. When options omit a resolver, the definition supplies the MEAI default resolver, while explicit caller resolvers and converters remain unchanged.
+
+At an explicit JSON boundary, callers can use source-generated metadata for both state and result contracts. The explicit generic arguments are optional for inference, but make the boundary visible:
+
+```csharp
+var metadataDefinition =
+ DecisionDefinition.Create(TicketJsonContext.Default.TicketAnalysis, builder =>
+ {
+ builder.Choice(result => result.Category);
+ builder.BinaryProbability(result => result.RefundRequestProbability);
+ });
+
+var metadataResponse = await client.GetResponseAsync(
+ ticket,
+ TicketJsonContext.Default.SupportTicket,
+ metadataDefinition);
+```
+
+When the application already has a JSON state snapshot, the result-only overload keeps the same local binding behavior without re-serializing the state:
+
+```csharp
+using System.Text.Json;
+
+JsonElement stateJson = JsonSerializer.SerializeToElement(
+ ticket,
+ TicketJsonContext.Default.SupportTicket);
+var analyzedFromJson = await client.GetResponseAsync(
+ stateJson,
+ metadataDefinition);
+```
+
+Applications that only need the neutral response can keep the no-binding path:
+
+```csharp
+var evidenceOnly = await client.GetResponseAsync(
+ ticket,
+ TicketJsonContext.Default.SupportTicket,
+ metadataDefinition.Questions);
+```
+
+The JSON metadata setup is separate from the business call:
+
+```csharp
+using System.Text.Json.Serialization;
+
+[JsonSourceGenerationOptions(UseStringEnumConverter = true)]
+[JsonSerializable(typeof(SupportTicket))]
+[JsonSerializable(typeof(TicketCategory))]
+[JsonSerializable(typeof(TicketAnalysis))]
+public partial class TicketJsonContext : JsonSerializerContext;
+```
+
+`TicketCategory` is a normal caller-owned enum. `DecisionDefinition` is an explicit declaration of which result members participate; it is not an enum generator, ORM, arbitrary POCO/union inference engine, or LINQ query provider. The candidate IDs come from the configured JSON enum contract and are exact ordinal wire-correlation identities. They are stable simple strings reused through the question definition; no pipe/version syntax is required. If a domain needs dynamic IDs instead of a closed enum, use the lower-level `ChoiceDecisionQuestion` and explicit mapping APIs so stale or unknown IDs remain rejected.
+
+Attributes are an ergonomic fallback for instructions and enum candidate descriptions. A fluent instruction supplied to `Choice`, `BinaryProbability`, or `Score` wins over an attribute. The metadata reader checks an attributed property first, then an associated positional-record constructor parameter, then a type-level fallback. JSON enum serialization controls the candidate IDs, but JSON conversion's permissive/case-insensitive behavior does not replace exact decision correlation validation.
+
+`JsonTypeInfo` describes the serialized shape of state or a result. It may come from source generation or a configured reflection resolver; it is not handwritten JSON schema and it does not replace decision instructions, exact IDs, complete distributions, or stale-domain checks. The older `DecisionResultBinding` API still requires result metadata even though a delegate mapper may not use it; simplifying that requirement is an API review candidate, not an implicit behavior of this convenience layer.
+
+The returned `Evidence` is the complete `DecisionResponse`, including every category probability and the binary observation. The mapped `TicketAnalysis` is therefore not a claim that a hidden threshold or calibration step established a business fact. Applications can retain or inspect the complete evidence for reporting, review, or later training. Feature projection is an optional follow-on: callers may define a versioned `DecisionFeatureSchema` of named native-`double` coordinates over complete observations when a downstream feature export is useful. That schema is a downstream column/coordinate contract, distinct from JSON metadata and not a prerequisite for typed classification.
+
+## .NET platform reuse / ergonomics under review
+
+Layer 1 intentionally reuses existing .NET and MEAI primitives rather than adding `IQueryable`, an ORM, or a new source-generator dependency:
+
+- [`JsonSchemaExporter`](https://learn.microsoft.com/dotnet/standard/serialization/system-text-json/extract-schema) was introduced in .NET 9. The decision contracts use `JsonTypeInfo` and serializer options for explicit metadata; they do not add another schema exporter, and `AIJsonUtilities` provides the existing MEAI compatibility helpers where applicable.
+- [System.Text.Json source generation](https://learn.microsoft.com/dotnet/standard/serialization/system-text-json/source-generation) is the AOT-friendly way to supply `JsonTypeInfo`. `JsonTypeInfo` itself is not synonymous with generated code; ordinary JIT reflection through a configured resolver remains a platform option.
+- [`JsonStringEnumMemberNameAttribute`](https://learn.microsoft.com/dotnet/standard/serialization/system-text-json/customize-properties#custom-enum-member-names) and the generic [`JsonStringEnumConverter`](https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonstringenumconverter-1) are useful for JSON enum representation. They do not replace decision ID validation: enum conversion is case-insensitive and permits integer values by default, while decision IDs are exact ordinal identities.
+- [`AIFunctionFactory`](https://learn.microsoft.com/dotnet/api/microsoft.extensions.ai.aifunctionfactory) remains the existing MEAI primitive for inspecting an explicitly declared delegate, producing a tool schema, and marshalling inputs and outputs. Tool interoperability is a later layer, not a prerequisite for this decision foundation.
+- [Structured output](https://learn.microsoft.com/dotnet/ai/quickstarts/structured-output) already supports enum/record-shaped chat results. If an application only needs a label or JSON result, `IChatClient.GetResponseAsync` may be the simpler choice; that path does not by itself establish a provider-reported probability distribution.
+- [EF Core model conventions and explicit overrides](https://learn.microsoft.com/ef/core/modeling/) are useful precedent for bounded opt-in conventions, not a reason to add an EF dependency or `DbContext`. [EF Core query providers](https://learn.microsoft.com/ef/core/querying/) likewise do not justify an `IQueryable` decision API for explicit paid asynchronous model inference; ordinary LINQ projection over returned probabilities remains appropriate.
+
+Automated arbitrary semantic inference is out. This layer already uses bounded opt-in conventions for JSON enum naming and standard member descriptions; future conventions for known enum/member mappings remain reasonable only when explicit, source-generation/AOT-compatible, and unable to hide provider-facing identities or application-owned result mapping.
+
+Provider evidence for the package-level contract is bounded and documented in the [upstream provider-validation report](https://github.com/luisquintanilla/typesafe-meai/blob/13adb58c7d7479bc8c73bf31960c08349b7c3185/docs/upstream-provider-validation.md): Julia/Laya provide CPU binary/choice/score proof, Qwen provides choice-only proof, and the dedicated `tev1:0.8b` Ollama/OllamaSharp path provides live binary/choice/score proof. Other adapters use native HTTP fixtures rather than live executions; this is not a claim of universal provider accuracy.
+
+This layer intentionally does not define tools, routing composition, MEDI processors, provider adapters, ML.NET or Arrow integrations, or automatic arbitrary POCO/union semantic inference. AIFunction/tool interoperability is a Layer 2 concern and is not implied by these abstractions.
diff --git a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Microsoft.Extensions.AI.Abstractions.json b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Microsoft.Extensions.AI.Abstractions.json
index 8b5f337da10..b422e38fe80 100644
--- a/src/Libraries/Microsoft.Extensions.AI.Abstractions/Microsoft.Extensions.AI.Abstractions.json
+++ b/src/Libraries/Microsoft.Extensions.AI.Abstractions/Microsoft.Extensions.AI.Abstractions.json
@@ -4939,6 +4939,832 @@
"Stage": "Stable"
}
]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.BinaryDecisionAnswer : Microsoft.Extensions.AI.DecisionAnswer",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.BinaryDecisionAnswer.BinaryDecisionAnswer(string questionId, double trueProbability, Microsoft.Extensions.AI.DecisionPrecision precision = Microsoft.Extensions.AI.DecisionPrecision.HighPrecision, object? rawRepresentation = null, System.Collections.Generic.IReadOnlyDictionary? additionalProperties = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "double Microsoft.Extensions.AI.BinaryDecisionAnswer.TrueProbability { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.BinaryDecisionQuestion : Microsoft.Extensions.AI.DecisionQuestion",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.BinaryDecisionQuestion.BinaryDecisionQuestion(string id, string? instructions = null, string? trueDescription = null, string? falseDescription = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string? Microsoft.Extensions.AI.BinaryDecisionQuestion.FalseDescription { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string? Microsoft.Extensions.AI.BinaryDecisionQuestion.TrueDescription { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.ChoiceDecisionAnswer : Microsoft.Extensions.AI.DecisionAnswer",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.ChoiceDecisionAnswer.ChoiceDecisionAnswer(string questionId, string selectedCandidateId, System.Collections.Generic.IReadOnlyList probabilities, Microsoft.Extensions.AI.DecisionPrecision precision = Microsoft.Extensions.AI.DecisionPrecision.HighPrecision, object? rawRepresentation = null, System.Collections.Generic.IReadOnlyDictionary? additionalProperties = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.ChoiceDecisionAnswer.Probabilities { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.ChoiceDecisionAnswer.SelectedCandidateId { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.ChoiceDecisionQuestion : Microsoft.Extensions.AI.DecisionQuestion",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.ChoiceDecisionQuestion.ChoiceDecisionQuestion(string id, string? instructions, System.Collections.Generic.IReadOnlyList candidates);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.ChoiceDecisionQuestion.Candidates { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "abstract class Microsoft.Extensions.AI.DecisionAnswer",
+ "Stage": "Experimental",
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyDictionary? Microsoft.Extensions.AI.DecisionAnswer.AdditionalProperties { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionKind Microsoft.Extensions.AI.DecisionAnswer.Kind { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionPrecision Microsoft.Extensions.AI.DecisionAnswer.Precision { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionAnswer.QuestionId { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "object? Microsoft.Extensions.AI.DecisionAnswer.RawRepresentation { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionAnswerSet",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.BinaryDecisionAnswer Microsoft.Extensions.AI.DecisionAnswerSet.GetBinary(string questionId);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.ChoiceDecisionAnswer Microsoft.Extensions.AI.DecisionAnswerSet.GetChoice(string questionId);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "TEnum Microsoft.Extensions.AI.DecisionAnswerSet.GetChoice(string questionId, Microsoft.Extensions.AI.DecisionEnumDefinition definition);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.ScoreDecisionAnswer Microsoft.Extensions.AI.DecisionAnswerSet.GetScore(string questionId);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionResponse Microsoft.Extensions.AI.DecisionAnswerSet.Response { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "static class Microsoft.Extensions.AI.DecisionBindingExtensions",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "static TResult Microsoft.Extensions.AI.DecisionBindingExtensions.Bind(this Microsoft.Extensions.AI.DecisionResponse response, Microsoft.Extensions.AI.DecisionResultBinding binding);",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionCandidate",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionCandidate.DecisionCandidate(string id, string description);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionCandidate.Description { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionCandidate.Id { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionClientException : System.Exception",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionClientException.DecisionClientException();",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionClientException.DecisionClientException(string message);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionClientException.DecisionClientException(string message, bool isTransient, System.Exception? innerException = null);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionClientException.DecisionClientException(string message, System.Exception innerException);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "bool Microsoft.Extensions.AI.DecisionClientException.IsTransient { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "static class Microsoft.Extensions.AI.DecisionClientExtensions",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "static System.Threading.Tasks.Task Microsoft.Extensions.AI.DecisionClientExtensions.GetResponseAsync(this Microsoft.Extensions.AI.IDecisionClient client, TState state, System.Text.Json.Serialization.Metadata.JsonTypeInfo stateTypeInfo, System.Collections.Generic.IEnumerable questions, Microsoft.Extensions.AI.DecisionOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "static TService? Microsoft.Extensions.AI.DecisionClientExtensions.GetService(this Microsoft.Extensions.AI.IDecisionClient client, object? serviceKey = null);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "static System.Threading.Tasks.Task> Microsoft.Extensions.AI.DecisionClientExtensions.GetResponseAsync(this Microsoft.Extensions.AI.IDecisionClient client, System.Text.Json.JsonElement state, Microsoft.Extensions.AI.DecisionDefinition definition, Microsoft.Extensions.AI.DecisionOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "static System.Threading.Tasks.Task> Microsoft.Extensions.AI.DecisionClientExtensions.GetResponseAsync(this Microsoft.Extensions.AI.IDecisionClient client, TState state, Microsoft.Extensions.AI.DecisionDefinition definition, Microsoft.Extensions.AI.DecisionOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "static System.Threading.Tasks.Task> Microsoft.Extensions.AI.DecisionClientExtensions.GetResponseAsync(this Microsoft.Extensions.AI.IDecisionClient client, TState state, System.Text.Json.Serialization.Metadata.JsonTypeInfo stateTypeInfo, Microsoft.Extensions.AI.DecisionDefinition definition, Microsoft.Extensions.AI.DecisionOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionClientMetadata",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionClientMetadata.DecisionClientMetadata(string? providerName = null, System.Uri? providerUri = null, string? defaultModelId = null, System.Collections.Generic.IReadOnlyList? supportedKinds = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionClientMetadata.DefaultModelId { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionClientMetadata.ProviderName { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Uri? Microsoft.Extensions.AI.DecisionClientMetadata.ProviderUri { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList? Microsoft.Extensions.AI.DecisionClientMetadata.SupportedKinds { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionEnumDefinition where TEnum : struct, System.Enum",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionEnumDefinition.DecisionEnumDefinition(System.Collections.Generic.IEnumerable> values);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.ChoiceDecisionQuestion Microsoft.Extensions.AI.DecisionEnumDefinition.CreateQuestion(string id, string? instructions);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "TEnum Microsoft.Extensions.AI.DecisionEnumDefinition.Parse(string candidateId);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.DecisionEnumDefinition.Candidates { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionEnumValue where TEnum : struct, System.Enum",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionEnumValue.DecisionEnumValue(TEnum value, string id, string description);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionEnumValue.Description { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionEnumValue.Id { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "TEnum Microsoft.Extensions.AI.DecisionEnumValue.Value { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionFeatureCoordinate",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionFeatureCoordinate.DecisionFeatureCoordinate(string name, string questionId, Microsoft.Extensions.AI.DecisionFeatureValueKind valueKind, string? memberId = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionFeatureCoordinate.MemberId { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionFeatureCoordinate.Name { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionFeatureCoordinate.QuestionId { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureCoordinate.ValueKind { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "static class Microsoft.Extensions.AI.DecisionFeatureProjection",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "static Microsoft.Extensions.AI.DecisionFeatureVector Microsoft.Extensions.AI.DecisionFeatureProjection.Project(Microsoft.Extensions.AI.DecisionResponse response, Microsoft.Extensions.AI.DecisionFeatureSchema schema);",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionFeatureSchema",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionFeatureSchema.DecisionFeatureSchema(string id, int version, System.Collections.Generic.IEnumerable coordinates);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.DecisionFeatureSchema.Coordinates { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionFeatureSchema.Id { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "int Microsoft.Extensions.AI.DecisionFeatureSchema.Version { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionFeatureValue",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionFeatureValue.DecisionFeatureValue(string name, double value);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionFeatureValue.Name { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "double Microsoft.Extensions.AI.DecisionFeatureValue.Value { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "enum Microsoft.Extensions.AI.DecisionFeatureValueKind",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionFeatureValueKind.DecisionFeatureValueKind();",
+ "Stage": "Experimental"
+ }
+ ],
+ "Fields": [
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureValueKind.BinaryFalseProbability",
+ "Stage": "Experimental",
+ "Value": "1"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureValueKind.BinaryTrueProbability",
+ "Stage": "Experimental",
+ "Value": "0"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureValueKind.ChoiceProbability",
+ "Stage": "Experimental",
+ "Value": "2"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureValueKind.ExpectedScore",
+ "Stage": "Experimental",
+ "Value": "5"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureValueKind.Score",
+ "Stage": "Experimental",
+ "Value": "4"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionFeatureValueKind Microsoft.Extensions.AI.DecisionFeatureValueKind.ScoreProbability",
+ "Stage": "Experimental",
+ "Value": "3"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionFeatureVector",
+ "Stage": "Experimental",
+ "Properties": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProvenance? Microsoft.Extensions.AI.DecisionFeatureVector.Provenance { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionFeatureSchema Microsoft.Extensions.AI.DecisionFeatureVector.Schema { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.DecisionFeatureVector.Values { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "enum Microsoft.Extensions.AI.DecisionKind",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionKind.DecisionKind();",
+ "Stage": "Experimental"
+ }
+ ],
+ "Fields": [
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionKind Microsoft.Extensions.AI.DecisionKind.Binary",
+ "Stage": "Experimental",
+ "Value": "0"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionKind Microsoft.Extensions.AI.DecisionKind.Choice",
+ "Stage": "Experimental",
+ "Value": "1"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionKind Microsoft.Extensions.AI.DecisionKind.Score",
+ "Stage": "Experimental",
+ "Value": "2"
+ }
+ ]
+ },
+ {
+ "Type": "class Microsoft.Extensions.AI.DecisionOptions",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionOptions.DecisionOptions();",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionOptions.DecisionOptions(Microsoft.Extensions.AI.DecisionOptions? other);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "virtual Microsoft.Extensions.AI.DecisionOptions Microsoft.Extensions.AI.DecisionOptions.Clone();",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "Microsoft.Extensions.AI.AdditionalPropertiesDictionary? Microsoft.Extensions.AI.DecisionOptions.AdditionalProperties { get; set; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionOptions.ModelId { get; set; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Func? Microsoft.Extensions.AI.DecisionOptions.RawRepresentationFactory { get; set; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "enum Microsoft.Extensions.AI.DecisionPrecision",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionPrecision.DecisionPrecision();",
+ "Stage": "Experimental"
+ }
+ ],
+ "Fields": [
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionPrecision Microsoft.Extensions.AI.DecisionPrecision.FourDecimalPlaces",
+ "Stage": "Experimental",
+ "Value": "1"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionPrecision Microsoft.Extensions.AI.DecisionPrecision.HighPrecision",
+ "Stage": "Experimental",
+ "Value": "0"
+ },
+ {
+ "Member": "const Microsoft.Extensions.AI.DecisionPrecision Microsoft.Extensions.AI.DecisionPrecision.TwoDecimalPlaces",
+ "Stage": "Experimental",
+ "Value": "2"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionProbability",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProbability.DecisionProbability(string id, double value);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionProbability.Id { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "double Microsoft.Extensions.AI.DecisionProbability.Value { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionProtocolException : System.Exception",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProtocolException.DecisionProtocolException();",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProtocolException.DecisionProtocolException(string message);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProtocolException.DecisionProtocolException(string message, System.Exception innerException);",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionProvenance",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProvenance.DecisionProvenance(string? providerName = null, System.Uri? providerUri = null, string? modelId = null, string? responseId = null, Microsoft.Extensions.AI.DecisionPrecision? precision = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionProvenance.ModelId { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionPrecision? Microsoft.Extensions.AI.DecisionProvenance.Precision { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionProvenance.ProviderName { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Uri? Microsoft.Extensions.AI.DecisionProvenance.ProviderUri { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string? Microsoft.Extensions.AI.DecisionProvenance.ResponseId { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "abstract class Microsoft.Extensions.AI.DecisionQuestion",
+ "Stage": "Experimental",
+ "Properties": [
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionQuestion.Id { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionQuestion.Instructions { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionKind Microsoft.Extensions.AI.DecisionQuestion.Kind { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionRequest",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionRequest.DecisionRequest(System.Text.Json.JsonElement state, System.Collections.Generic.IReadOnlyList questions);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "static Microsoft.Extensions.AI.DecisionRequest Microsoft.Extensions.AI.DecisionRequest.Create(TState state, System.Text.Json.Serialization.Metadata.JsonTypeInfo stateTypeInfo, System.Collections.Generic.IEnumerable questions);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.DecisionRequest.Questions { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Text.Json.JsonElement Microsoft.Extensions.AI.DecisionRequest.State { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionResponse",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionResponse.DecisionResponse(Microsoft.Extensions.AI.DecisionRequest request, System.Collections.Generic.IReadOnlyList answers, Microsoft.Extensions.AI.DecisionProvenance? provenance = null, Microsoft.Extensions.AI.UsageDetails? usage = null, object? rawRepresentation = null, System.Collections.Generic.IReadOnlyDictionary? additionalProperties = null);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionAnswer Microsoft.Extensions.AI.DecisionResponse.GetAnswer(string questionId);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyDictionary? Microsoft.Extensions.AI.DecisionResponse.AdditionalProperties { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.DecisionResponse.Answers { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionProvenance? Microsoft.Extensions.AI.DecisionResponse.Provenance { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "object? Microsoft.Extensions.AI.DecisionResponse.RawRepresentation { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionRequest Microsoft.Extensions.AI.DecisionResponse.Request { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "Microsoft.Extensions.AI.UsageDetails? Microsoft.Extensions.AI.DecisionResponse.Usage { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionResultBinding",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionResultBinding.DecisionResultBinding(System.Text.Json.Serialization.Metadata.JsonTypeInfo resultTypeInfo, System.Func map);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Text.Json.Serialization.Metadata.JsonTypeInfo Microsoft.Extensions.AI.DecisionResultBinding.ResultTypeInfo { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionScoreLevel",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.DecisionScoreLevel.DecisionScoreLevel(string id, string description);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionScoreLevel.Description { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "string Microsoft.Extensions.AI.DecisionScoreLevel.Id { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "interface Microsoft.Extensions.AI.IDecisionClient : System.IDisposable",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "System.Threading.Tasks.Task Microsoft.Extensions.AI.IDecisionClient.GetResponseAsync(Microsoft.Extensions.AI.DecisionRequest request, Microsoft.Extensions.AI.DecisionOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "object? Microsoft.Extensions.AI.IDecisionClient.GetService(System.Type serviceType, object? serviceKey = null);",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.ScoreDecisionAnswer : Microsoft.Extensions.AI.DecisionAnswer",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.ScoreDecisionAnswer.ScoreDecisionAnswer(string questionId, double? score, System.Collections.Generic.IReadOnlyList probabilities, Microsoft.Extensions.AI.DecisionPrecision precision = Microsoft.Extensions.AI.DecisionPrecision.HighPrecision, object? rawRepresentation = null, System.Collections.Generic.IReadOnlyDictionary? additionalProperties = null);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "double Microsoft.Extensions.AI.ScoreDecisionAnswer.ExpectedScore { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.ScoreDecisionAnswer.Probabilities { get; }",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "double? Microsoft.Extensions.AI.ScoreDecisionAnswer.Score { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.ScoreDecisionQuestion : Microsoft.Extensions.AI.DecisionQuestion",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "Microsoft.Extensions.AI.ScoreDecisionQuestion.ScoreDecisionQuestion(string id, string? instructions, System.Collections.Generic.IReadOnlyList levels);",
+ "Stage": "Experimental"
+ }
+ ],
+ "Properties": [
+ {
+ "Member": "System.Collections.Generic.IReadOnlyList Microsoft.Extensions.AI.ScoreDecisionQuestion.Levels { get; }",
+ "Stage": "Experimental"
+ }
+ ]
+ },
+ {
+ "Type": "sealed class Microsoft.Extensions.AI.DecisionDefinition",
+ "Stage": "Experimental",
+ "Methods": [
+ {
+ "Member": "static Microsoft.Extensions.AI.DecisionDefinition Microsoft.Extensions.AI.DecisionDefinition.Create(System.Action.Builder> configure, System.Text.Json.JsonSerializerOptions? serializerOptions = null);",
+ "Stage": "Experimental"
+ },
+ {
+ "Member": "static Microsoft.Extensions.AI.DecisionDefinition