diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPart.g.cs index 10620f9..bd8eed9 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolApprovalRequestedPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: approval-requested /// @@ -41,6 +47,12 @@ public sealed partial class DynamicToolApprovalRequestedPart [global::System.Text.Json.Serialization.JsonRequired] public required object Input { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -69,9 +81,11 @@ public sealed partial class DynamicToolApprovalRequestedPart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: approval-requested /// + /// /// /// #if NET7_0_OR_GREATER @@ -82,15 +96,19 @@ public DynamicToolApprovalRequestedPart( string toolCallId, object input, string? type, + string? title, string? state, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, global::Phoenix.AnyOf? approval) { this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input ?? throw new global::System.ArgumentNullException(nameof(input)); + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Approval = approval; } diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..0a750a1 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolApprovalRequestedPartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolApprovalRequestedPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolApprovalRequestedPartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolApprovalRequestedPartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolApprovalRequestedPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolApprovalRequestedPartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolApprovalRequestedPartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartProviderExecuted.g.cs new file mode 100644 index 0000000..c98743c --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolApprovalRequestedPartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartTitle.Json.g.cs new file mode 100644 index 0000000..8fda111 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolApprovalRequestedPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolApprovalRequestedPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolApprovalRequestedPartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolApprovalRequestedPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolApprovalRequestedPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolApprovalRequestedPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolApprovalRequestedPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartTitle.g.cs new file mode 100644 index 0000000..d88419f --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRequestedPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolApprovalRequestedPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPart.g.cs index e6c8ced..9af2f01 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolApprovalRespondedPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: approval-responded /// @@ -41,6 +47,12 @@ public sealed partial class DynamicToolApprovalRespondedPart [global::System.Text.Json.Serialization.JsonRequired] public required object Input { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -69,9 +81,11 @@ public sealed partial class DynamicToolApprovalRespondedPart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: approval-responded /// + /// /// /// #if NET7_0_OR_GREATER @@ -82,15 +96,19 @@ public DynamicToolApprovalRespondedPart( string toolCallId, object input, string? type, + string? title, string? state, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, global::Phoenix.AnyOf? approval) { this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input ?? throw new global::System.ArgumentNullException(nameof(input)); + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Approval = approval; } diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..d567894 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolApprovalRespondedPartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolApprovalRespondedPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolApprovalRespondedPartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolApprovalRespondedPartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolApprovalRespondedPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolApprovalRespondedPartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolApprovalRespondedPartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartProviderExecuted.g.cs new file mode 100644 index 0000000..d8c2e47 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolApprovalRespondedPartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartTitle.Json.g.cs new file mode 100644 index 0000000..67cdc55 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolApprovalRespondedPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolApprovalRespondedPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolApprovalRespondedPartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolApprovalRespondedPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolApprovalRespondedPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolApprovalRespondedPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolApprovalRespondedPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartTitle.g.cs new file mode 100644 index 0000000..b4e8b96 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolApprovalRespondedPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolApprovalRespondedPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePart.g.cs index 67a0e6b..da6be31 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolInputAvailablePart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: input-available /// @@ -41,6 +47,12 @@ public sealed partial class DynamicToolInputAvailablePart [global::System.Text.Json.Serialization.JsonRequired] public required object Input { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -69,9 +81,11 @@ public sealed partial class DynamicToolInputAvailablePart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: input-available /// + /// /// /// #if NET7_0_OR_GREATER @@ -82,15 +96,19 @@ public DynamicToolInputAvailablePart( string toolCallId, object input, string? type, + string? title, string? state, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, global::Phoenix.AnyOf? approval) { this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input ?? throw new global::System.ArgumentNullException(nameof(input)); + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Approval = approval; } diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..cd0de96 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolInputAvailablePartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolInputAvailablePartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolInputAvailablePartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolInputAvailablePartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolInputAvailablePartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolInputAvailablePartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolInputAvailablePartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartProviderExecuted.g.cs new file mode 100644 index 0000000..0d2157d --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolInputAvailablePartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartTitle.Json.g.cs new file mode 100644 index 0000000..cd203ed --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolInputAvailablePartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolInputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolInputAvailablePartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolInputAvailablePartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolInputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolInputAvailablePartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolInputAvailablePartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartTitle.g.cs new file mode 100644 index 0000000..d2779f2 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputAvailablePartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolInputAvailablePartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPart.g.cs index 985a4e4..61b21bc 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolInputStreamingPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: input-streaming /// @@ -40,6 +46,12 @@ public sealed partial class DynamicToolInputStreamingPart [global::System.Text.Json.Serialization.JsonPropertyName("input")] public object? Input { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -67,10 +79,12 @@ public sealed partial class DynamicToolInputStreamingPart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: input-streaming /// /// + /// /// /// #if NET7_0_OR_GREATER @@ -80,16 +94,20 @@ public DynamicToolInputStreamingPart( string toolName, string toolCallId, string? type, + string? title, string? state, object? input, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, global::Phoenix.AnyOf? approval) { this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Approval = approval; } diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..72fb431 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolInputStreamingPartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolInputStreamingPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolInputStreamingPartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolInputStreamingPartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolInputStreamingPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolInputStreamingPartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolInputStreamingPartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartProviderExecuted.g.cs new file mode 100644 index 0000000..64dea34 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolInputStreamingPartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartTitle.Json.g.cs new file mode 100644 index 0000000..0e84a73 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolInputStreamingPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolInputStreamingPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolInputStreamingPartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolInputStreamingPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolInputStreamingPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolInputStreamingPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolInputStreamingPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartTitle.g.cs new file mode 100644 index 0000000..5999fcf --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolInputStreamingPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolInputStreamingPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePart.g.cs index eb34581..5d43b19 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolOutputAvailablePart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: output-available /// @@ -48,6 +54,12 @@ public sealed partial class DynamicToolOutputAvailablePart [global::System.Text.Json.Serialization.JsonRequired] public required object Output { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -83,9 +95,11 @@ public sealed partial class DynamicToolOutputAvailablePart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: output-available /// + /// /// /// /// @@ -98,7 +112,9 @@ public DynamicToolOutputAvailablePart( object input, object output, string? type, + string? title, string? state, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, bool? preliminary, global::Phoenix.AnyOf? approval) @@ -106,9 +122,11 @@ public DynamicToolOutputAvailablePart( this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input ?? throw new global::System.ArgumentNullException(nameof(input)); this.Output = output ?? throw new global::System.ArgumentNullException(nameof(output)); + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Preliminary = preliminary; this.Approval = approval; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..9aef7f3 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolOutputAvailablePartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolOutputAvailablePartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolOutputAvailablePartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolOutputAvailablePartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolOutputAvailablePartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolOutputAvailablePartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolOutputAvailablePartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartProviderExecuted.g.cs new file mode 100644 index 0000000..d3e6a03 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolOutputAvailablePartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartTitle.Json.g.cs new file mode 100644 index 0000000..738028e --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolOutputAvailablePartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolOutputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolOutputAvailablePartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolOutputAvailablePartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolOutputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolOutputAvailablePartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolOutputAvailablePartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartTitle.g.cs new file mode 100644 index 0000000..9b2251f --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputAvailablePartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolOutputAvailablePartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPart.g.cs index bb1fe26..4a5a49b 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolOutputDeniedPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: output-denied /// @@ -41,6 +47,12 @@ public sealed partial class DynamicToolOutputDeniedPart [global::System.Text.Json.Serialization.JsonRequired] public required object Input { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -69,9 +81,11 @@ public sealed partial class DynamicToolOutputDeniedPart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: output-denied /// + /// /// /// #if NET7_0_OR_GREATER @@ -82,15 +96,19 @@ public DynamicToolOutputDeniedPart( string toolCallId, object input, string? type, + string? title, string? state, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, global::Phoenix.AnyOf? approval) { this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input ?? throw new global::System.ArgumentNullException(nameof(input)); + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Approval = approval; } diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..e20ca3c --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolOutputDeniedPartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolOutputDeniedPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolOutputDeniedPartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolOutputDeniedPartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolOutputDeniedPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolOutputDeniedPartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolOutputDeniedPartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartProviderExecuted.g.cs new file mode 100644 index 0000000..9046c0d --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolOutputDeniedPartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartTitle.Json.g.cs new file mode 100644 index 0000000..c09a6dd --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolOutputDeniedPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolOutputDeniedPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolOutputDeniedPartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolOutputDeniedPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolOutputDeniedPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolOutputDeniedPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolOutputDeniedPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartTitle.g.cs new file mode 100644 index 0000000..12495bb --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputDeniedPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolOutputDeniedPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPart.g.cs index ca95677..6d84103 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPart.g.cs @@ -28,6 +28,12 @@ public sealed partial class DynamicToolOutputErrorPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: output-error /// @@ -48,6 +54,12 @@ public sealed partial class DynamicToolOutputErrorPart [global::System.Text.Json.Serialization.JsonRequired] public required string ErrorText { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("providerExecuted")] + public bool? ProviderExecuted { get; set; } + /// /// /// @@ -77,9 +89,11 @@ public sealed partial class DynamicToolOutputErrorPart /// /// Default Value: dynamic-tool /// + /// /// /// Default Value: output-error /// + /// /// /// #if NET7_0_OR_GREATER @@ -91,16 +105,20 @@ public DynamicToolOutputErrorPart( object input, string errorText, string? type, + string? title, string? state, + bool? providerExecuted, global::System.Collections.Generic.Dictionary? callProviderMetadata, global::Phoenix.AnyOf? approval) { this.Type = type; this.ToolName = toolName ?? throw new global::System.ArgumentNullException(nameof(toolName)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input ?? throw new global::System.ArgumentNullException(nameof(input)); this.ErrorText = errorText ?? throw new global::System.ArgumentNullException(nameof(errorText)); + this.ProviderExecuted = providerExecuted; this.CallProviderMetadata = callProviderMetadata; this.Approval = approval; } diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartProviderExecuted.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartProviderExecuted.Json.g.cs new file mode 100644 index 0000000..5117952 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartProviderExecuted.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolOutputErrorPartProviderExecuted + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolOutputErrorPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolOutputErrorPartProviderExecuted), + jsonSerializerContext) as global::Phoenix.DynamicToolOutputErrorPartProviderExecuted; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolOutputErrorPartProviderExecuted? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolOutputErrorPartProviderExecuted), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolOutputErrorPartProviderExecuted; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartProviderExecuted.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartProviderExecuted.g.cs new file mode 100644 index 0000000..d338bf4 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartProviderExecuted.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolOutputErrorPartProviderExecuted + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartTitle.Json.g.cs new file mode 100644 index 0000000..12d4c27 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class DynamicToolOutputErrorPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.DynamicToolOutputErrorPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.DynamicToolOutputErrorPartTitle), + jsonSerializerContext) as global::Phoenix.DynamicToolOutputErrorPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.DynamicToolOutputErrorPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.DynamicToolOutputErrorPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.DynamicToolOutputErrorPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartTitle.g.cs new file mode 100644 index 0000000..777a5aa --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.DynamicToolOutputErrorPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class DynamicToolOutputErrorPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPart.g.cs index 3524042..3a43540 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolApprovalRequestedPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: approval-requested /// @@ -64,6 +70,7 @@ public sealed partial class ToolApprovalRequestedPart /// /// /// + /// /// /// Default Value: approval-requested /// @@ -77,6 +84,7 @@ public sealed partial class ToolApprovalRequestedPart public ToolApprovalRequestedPart( string type, string toolCallId, + string? title, string? state, object? input, bool? providerExecuted, @@ -85,6 +93,7 @@ public ToolApprovalRequestedPart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.ProviderExecuted = providerExecuted; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPartTitle.Json.g.cs new file mode 100644 index 0000000..a8eca42 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolApprovalRequestedPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolApprovalRequestedPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolApprovalRequestedPartTitle), + jsonSerializerContext) as global::Phoenix.ToolApprovalRequestedPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolApprovalRequestedPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolApprovalRequestedPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolApprovalRequestedPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPartTitle.g.cs new file mode 100644 index 0000000..52f4fdd --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRequestedPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolApprovalRequestedPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPart.g.cs index e586488..280a657 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolApprovalRespondedPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: approval-responded /// @@ -64,6 +70,7 @@ public sealed partial class ToolApprovalRespondedPart /// /// /// + /// /// /// Default Value: approval-responded /// @@ -77,6 +84,7 @@ public sealed partial class ToolApprovalRespondedPart public ToolApprovalRespondedPart( string type, string toolCallId, + string? title, string? state, object? input, bool? providerExecuted, @@ -85,6 +93,7 @@ public ToolApprovalRespondedPart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.ProviderExecuted = providerExecuted; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPartTitle.Json.g.cs new file mode 100644 index 0000000..658bf0c --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolApprovalRespondedPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolApprovalRespondedPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolApprovalRespondedPartTitle), + jsonSerializerContext) as global::Phoenix.ToolApprovalRespondedPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolApprovalRespondedPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolApprovalRespondedPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolApprovalRespondedPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPartTitle.g.cs new file mode 100644 index 0000000..b4fd0a7 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolApprovalRespondedPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolApprovalRespondedPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePart.g.cs index e979bd1..c632cf6 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolInputAvailablePart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: input-available /// @@ -64,6 +70,7 @@ public sealed partial class ToolInputAvailablePart /// /// /// + /// /// /// Default Value: input-available /// @@ -77,6 +84,7 @@ public sealed partial class ToolInputAvailablePart public ToolInputAvailablePart( string type, string toolCallId, + string? title, string? state, object? input, bool? providerExecuted, @@ -85,6 +93,7 @@ public ToolInputAvailablePart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.ProviderExecuted = providerExecuted; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePartTitle.Json.g.cs new file mode 100644 index 0000000..886aa64 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolInputAvailablePartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolInputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolInputAvailablePartTitle), + jsonSerializerContext) as global::Phoenix.ToolInputAvailablePartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolInputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolInputAvailablePartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolInputAvailablePartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePartTitle.g.cs new file mode 100644 index 0000000..2eaeba8 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputAvailablePartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolInputAvailablePartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPart.g.cs index bdf89b7..e787d49 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolInputStreamingPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: input-streaming /// @@ -64,6 +70,7 @@ public sealed partial class ToolInputStreamingPart /// /// /// + /// /// /// Default Value: input-streaming /// @@ -77,6 +84,7 @@ public sealed partial class ToolInputStreamingPart public ToolInputStreamingPart( string type, string toolCallId, + string? title, string? state, object? input, bool? providerExecuted, @@ -85,6 +93,7 @@ public ToolInputStreamingPart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.ProviderExecuted = providerExecuted; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPartTitle.Json.g.cs new file mode 100644 index 0000000..b45543e --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolInputStreamingPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolInputStreamingPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolInputStreamingPartTitle), + jsonSerializerContext) as global::Phoenix.ToolInputStreamingPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolInputStreamingPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolInputStreamingPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolInputStreamingPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPartTitle.g.cs new file mode 100644 index 0000000..b493e86 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolInputStreamingPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolInputStreamingPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePart.g.cs index cda924b..a5173a3 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolOutputAvailablePart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: output-available /// @@ -76,6 +82,7 @@ public sealed partial class ToolOutputAvailablePart /// /// /// + /// /// /// Default Value: output-available /// @@ -91,6 +98,7 @@ public sealed partial class ToolOutputAvailablePart public ToolOutputAvailablePart( string type, string toolCallId, + string? title, string? state, object? input, object? output, @@ -101,6 +109,7 @@ public ToolOutputAvailablePart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.Output = output; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePartTitle.Json.g.cs new file mode 100644 index 0000000..6f2d4bb --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolOutputAvailablePartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolOutputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolOutputAvailablePartTitle), + jsonSerializerContext) as global::Phoenix.ToolOutputAvailablePartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolOutputAvailablePartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolOutputAvailablePartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolOutputAvailablePartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePartTitle.g.cs new file mode 100644 index 0000000..fa25d98 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputAvailablePartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolOutputAvailablePartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPart.g.cs index 99572c1..ebbaab4 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolOutputDeniedPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: output-denied /// @@ -64,6 +70,7 @@ public sealed partial class ToolOutputDeniedPart /// /// /// + /// /// /// Default Value: output-denied /// @@ -77,6 +84,7 @@ public sealed partial class ToolOutputDeniedPart public ToolOutputDeniedPart( string type, string toolCallId, + string? title, string? state, object? input, bool? providerExecuted, @@ -85,6 +93,7 @@ public ToolOutputDeniedPart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.ProviderExecuted = providerExecuted; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPartTitle.Json.g.cs new file mode 100644 index 0000000..7eca656 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolOutputDeniedPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolOutputDeniedPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolOutputDeniedPartTitle), + jsonSerializerContext) as global::Phoenix.ToolOutputDeniedPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolOutputDeniedPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolOutputDeniedPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolOutputDeniedPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPartTitle.g.cs new file mode 100644 index 0000000..c366d49 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputDeniedPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolOutputDeniedPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPart.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPart.g.cs index d8d56ec..3bb1a9b 100644 --- a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPart.g.cs +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPart.g.cs @@ -22,6 +22,12 @@ public sealed partial class ToolOutputErrorPart [global::System.Text.Json.Serialization.JsonRequired] public required string ToolCallId { get; set; } + /// + /// + /// + [global::System.Text.Json.Serialization.JsonPropertyName("title")] + public string? Title { get; set; } + /// /// Default Value: output-error /// @@ -78,6 +84,7 @@ public sealed partial class ToolOutputErrorPart /// /// /// + /// /// /// Default Value: output-error /// @@ -93,6 +100,7 @@ public ToolOutputErrorPart( string type, string toolCallId, string errorText, + string? title, string? state, object? input, object? rawInput, @@ -102,6 +110,7 @@ public ToolOutputErrorPart( { this.Type = type ?? throw new global::System.ArgumentNullException(nameof(type)); this.ToolCallId = toolCallId ?? throw new global::System.ArgumentNullException(nameof(toolCallId)); + this.Title = title; this.State = state; this.Input = input; this.RawInput = rawInput; diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPartTitle.Json.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPartTitle.Json.g.cs new file mode 100644 index 0000000..3c946d0 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPartTitle.Json.g.cs @@ -0,0 +1,92 @@ +#nullable enable + +namespace Phoenix +{ + public sealed partial class ToolOutputErrorPartTitle + { + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerContext. + /// + public string ToJson( + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + this.GetType(), + jsonSerializerContext); + } + + /// + /// Serializes the current instance to a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public string ToJson( + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Serialize( + this, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerContext. + /// + public static global::Phoenix.ToolOutputErrorPartTitle? FromJson( + string json, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + typeof(global::Phoenix.ToolOutputErrorPartTitle), + jsonSerializerContext) as global::Phoenix.ToolOutputErrorPartTitle; + } + + /// + /// Deserializes a JSON string using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::Phoenix.ToolOutputErrorPartTitle? FromJson( + string json, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.Deserialize( + json, + jsonSerializerOptions); + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerContext. + /// + public static async global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext) + { + return (await global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + typeof(global::Phoenix.ToolOutputErrorPartTitle), + jsonSerializerContext).ConfigureAwait(false)) as global::Phoenix.ToolOutputErrorPartTitle; + } + + /// + /// Deserializes a JSON stream using the provided JsonSerializerOptions. + /// +#if NET8_0_OR_GREATER + [global::System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] + [global::System.Diagnostics.CodeAnalysis.RequiresDynamicCode("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] +#endif + public static global::System.Threading.Tasks.ValueTask FromJsonStreamAsync( + global::System.IO.Stream jsonStream, + global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null) + { + return global::System.Text.Json.JsonSerializer.DeserializeAsync( + jsonStream, + jsonSerializerOptions); + } + } +} diff --git a/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPartTitle.g.cs b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPartTitle.g.cs new file mode 100644 index 0000000..871fd83 --- /dev/null +++ b/src/libs/Phoenix/Generated/Phoenix.Models.ToolOutputErrorPartTitle.g.cs @@ -0,0 +1,19 @@ + +#nullable enable + +namespace Phoenix +{ + /// + /// + /// + public sealed partial class ToolOutputErrorPartTitle + { + + /// + /// Additional properties that are not explicitly defined in the schema + /// + [global::System.Text.Json.Serialization.JsonExtensionData] + public global::System.Collections.Generic.IDictionary AdditionalProperties { get; set; } = new global::System.Collections.Generic.Dictionary(); + + } +} \ No newline at end of file diff --git a/src/libs/Phoenix/openapi.json b/src/libs/Phoenix/openapi.json index c29cf5e..2292447 100644 --- a/src/libs/Phoenix/openapi.json +++ b/src/libs/Phoenix/openapi.json @@ -8380,6 +8380,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "approval-requested", @@ -8389,6 +8400,17 @@ "input": { "title": "Input" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -8445,6 +8467,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "approval-responded", @@ -8454,6 +8487,17 @@ "input": { "title": "Input" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -8510,6 +8554,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "input-available", @@ -8519,6 +8574,17 @@ "input": { "title": "Input" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -8575,6 +8641,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "input-streaming", @@ -8590,6 +8667,17 @@ ], "title": "Input" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -8645,6 +8733,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "output-available", @@ -8657,6 +8756,17 @@ "output": { "title": "Output" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -8725,6 +8835,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "output-denied", @@ -8734,6 +8855,17 @@ "input": { "title": "Input" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -8790,6 +8922,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "output-error", @@ -8803,6 +8946,17 @@ "type": "string", "title": "Errortext" }, + "providerExecuted": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Providerexecuted" + }, "callProviderMetadata": { "anyOf": [ { @@ -13997,6 +14151,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "approval-requested", @@ -14104,6 +14269,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "approval-responded", @@ -14240,6 +14416,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "input-available", @@ -14316,6 +14503,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "input-streaming", @@ -14392,6 +14590,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "output-available", @@ -14488,6 +14697,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "output-denied", @@ -14564,6 +14784,17 @@ "type": "string", "title": "Toolcallid" }, + "title": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "title": "Title" + }, "state": { "type": "string", "const": "output-error",