diff --git a/src/libs/Ollama/Generated/AnyOf.2.g.cs b/src/libs/Ollama/Generated/AnyOf.2.g.cs
index 0dceecb..13ee52b 100644
--- a/src/libs/Ollama/Generated/AnyOf.2.g.cs
+++ b/src/libs/Ollama/Generated/AnyOf.2.g.cs
@@ -267,5 +267,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.AnyOf<T1, T2>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.AnyOf<T1, T2>),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.AnyOf<T1, T2>?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.AnyOf<T1, T2>?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.AnyOf<T1, T2>?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/Ollama/Generated/Ollama.Models.CopyModelRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.CopyModelRequest.g.cs
index 40bf7cf..1e826c4 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.CopyModelRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.CopyModelRequest.g.cs
@@ -87,5 +87,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.CopyModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.CopyModelRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.CopyModelRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.CopyModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.CopyModelRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.CreateModelRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.CreateModelRequest.g.cs
index 70cc104..adab7f0 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.CreateModelRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.CreateModelRequest.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.CreateModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.CreateModelRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.CreateModelRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.CreateModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.CreateModelRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.CreateModelResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.CreateModelResponse.g.cs
index b298629..5d6d36e 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.CreateModelResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.CreateModelResponse.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.CreateModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.CreateModelResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.CreateModelResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.CreateModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.CreateModelResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.CreateModelStatus.g.cs b/src/libs/Ollama/Generated/Ollama.Models.CreateModelStatus.g.cs
index fa52ef7..d4fcf5f 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.CreateModelStatus.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.CreateModelStatus.g.cs
@@ -268,5 +268,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.CreateModelStatus?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.CreateModelStatus),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.CreateModelStatus?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.CreateModelStatus?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.CreateModelStatus?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/Ollama/Generated/Ollama.Models.DeleteModelRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.DeleteModelRequest.g.cs
index 358042b..6409ee9 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.DeleteModelRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.DeleteModelRequest.g.cs
@@ -80,5 +80,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.DeleteModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.DeleteModelRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.DeleteModelRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.DeleteModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.DeleteModelRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.DoneReason.g.cs b/src/libs/Ollama/Generated/Ollama.Models.DoneReason.g.cs
index 9c5e8a5..0be0685 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.DoneReason.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.DoneReason.g.cs
@@ -268,5 +268,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.DoneReason?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.DoneReason),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.DoneReason?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.DoneReason?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.DoneReason?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionRequest.g.cs
index 1f690be..88df658 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionRequest.g.cs
@@ -125,5 +125,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.GenerateChatCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.GenerateChatCompletionRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.GenerateChatCompletionRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.GenerateChatCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.GenerateChatCompletionRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionResponse.g.cs
index d2155ae..11803e9 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.GenerateChatCompletionResponse.g.cs
@@ -151,5 +151,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.GenerateChatCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.GenerateChatCompletionResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.GenerateChatCompletionResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.GenerateChatCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.GenerateChatCompletionResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionRequest.g.cs
index 4f0d990..46f52f1 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionRequest.g.cs
@@ -157,5 +157,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.GenerateCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.GenerateCompletionRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.GenerateCompletionRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.GenerateCompletionRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.GenerateCompletionRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionResponse.g.cs
index aa5416c..c628978 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.GenerateCompletionResponse.g.cs
@@ -148,5 +148,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.GenerateCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.GenerateCompletionResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.GenerateCompletionResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.GenerateCompletionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.GenerateCompletionResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingRequest.g.cs
index a311b35..e0aa407 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingRequest.g.cs
@@ -104,5 +104,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.GenerateEmbeddingRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.GenerateEmbeddingRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.GenerateEmbeddingRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.GenerateEmbeddingRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.GenerateEmbeddingRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingResponse.g.cs
index d9fb208..b825e13 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.GenerateEmbeddingResponse.g.cs
@@ -78,5 +78,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.GenerateEmbeddingResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.GenerateEmbeddingResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.GenerateEmbeddingResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.GenerateEmbeddingResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.GenerateEmbeddingResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.Message.g.cs b/src/libs/Ollama/Generated/Ollama.Models.Message.g.cs
index 5f3b7f4..7d43ac4 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.Message.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.Message.g.cs
@@ -99,5 +99,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.Message?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.Message),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.Message;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.Message?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.Message?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.Model.g.cs b/src/libs/Ollama/Generated/Ollama.Models.Model.g.cs
index 3174274..80c934a 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.Model.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.Model.g.cs
@@ -105,5 +105,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.Model?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.Model),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.Model;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.Model?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.Model?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ModelDetails.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ModelDetails.g.cs
index d8a41b8..73faf64 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ModelDetails.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ModelDetails.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ModelDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ModelDetails),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ModelDetails;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ModelDetails?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ModelDetails?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ModelInfo.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ModelInfo.g.cs
index 8d49edc..89cfd0d 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ModelInfo.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ModelInfo.g.cs
@@ -123,5 +123,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ModelInfo?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ModelInfo),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ModelInfo;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ModelInfo?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ModelInfo?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ModelInfoRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ModelInfoRequest.g.cs
index 18f857d..59d04d1 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ModelInfoRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ModelInfoRequest.g.cs
@@ -80,5 +80,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ModelInfoRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ModelInfoRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ModelInfoRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ModelInfoRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ModelInfoRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ModelInformation.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ModelInformation.g.cs
index b896e4c..cda6d53 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ModelInformation.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ModelInformation.g.cs
@@ -95,5 +95,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ModelInformation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ModelInformation),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ModelInformation;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ModelInformation?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ModelInformation?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ModelsResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ModelsResponse.g.cs
index 1e61e82..d08b858 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ModelsResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ModelsResponse.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ModelsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ModelsResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ModelsResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ModelsResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ModelsResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ProcessModel.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ProcessModel.g.cs
index 55d3d12..9b34db1 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ProcessModel.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ProcessModel.g.cs
@@ -112,5 +112,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ProcessModel?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ProcessModel),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ProcessModel;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ProcessModel?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ProcessModel?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ProcessResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ProcessResponse.g.cs
index ebd6142..0024c20 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ProcessResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ProcessResponse.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ProcessResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ProcessResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ProcessResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ProcessResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ProcessResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.PullModelRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.PullModelRequest.g.cs
index fc7122b..909498b 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.PullModelRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.PullModelRequest.g.cs
@@ -107,5 +107,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.PullModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.PullModelRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.PullModelRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.PullModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.PullModelRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.PullModelResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.PullModelResponse.g.cs
index cc1c4a3..4d08867 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.PullModelResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.PullModelResponse.g.cs
@@ -102,5 +102,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.PullModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.PullModelResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.PullModelResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.PullModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.PullModelResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.PullModelStatus.g.cs b/src/libs/Ollama/Generated/Ollama.Models.PullModelStatus.g.cs
index d66e8f5..9d98a48 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.PullModelStatus.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.PullModelStatus.g.cs
@@ -269,5 +269,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.PullModelStatus?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.PullModelStatus),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.PullModelStatus?;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.PullModelStatus?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.PullModelStatus?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
diff --git a/src/libs/Ollama/Generated/Ollama.Models.PushModelRequest.g.cs b/src/libs/Ollama/Generated/Ollama.Models.PushModelRequest.g.cs
index c5296b8..bf3209b 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.PushModelRequest.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.PushModelRequest.g.cs
@@ -106,5 +106,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.PushModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.PushModelRequest),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.PushModelRequest;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.PushModelRequest?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.PushModelRequest?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.PushModelResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.PushModelResponse.g.cs
index 1f0ed42..da5f990 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.PushModelResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.PushModelResponse.g.cs
@@ -101,5 +101,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.PushModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.PushModelResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.PushModelResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.PushModelResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.PushModelResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.RequestOptions.g.cs b/src/libs/Ollama/Generated/Ollama.Models.RequestOptions.g.cs
index 4dd2a5b..bdc8588 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.RequestOptions.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.RequestOptions.g.cs
@@ -272,5 +272,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.RequestOptions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.RequestOptions),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.RequestOptions;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.RequestOptions?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.RequestOptions?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.Tool.g.cs b/src/libs/Ollama/Generated/Ollama.Models.Tool.g.cs
index 501b513..16d7581 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.Tool.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.Tool.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.Tool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.Tool),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.Tool;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.Tool?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.Tool?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ToolCall.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ToolCall.g.cs
index 2b8df7f..417d92b 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ToolCall.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ToolCall.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ToolCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ToolCall),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ToolCall;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ToolCall?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ToolCall?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunction.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunction.g.cs
index 8675b07..70cdce1 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunction.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunction.g.cs
@@ -85,5 +85,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ToolCallFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ToolCallFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ToolCallFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ToolCallFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ToolCallFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunctionArgs.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunctionArgs.g.cs
index 3f165b4..26eae40 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunctionArgs.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ToolCallFunctionArgs.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ToolCallFunctionArgs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ToolCallFunctionArgs),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ToolCallFunctionArgs;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ToolCallFunctionArgs?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ToolCallFunctionArgs?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ToolFunction.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ToolFunction.g.cs
index 0d3b0a7..f1d2078 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ToolFunction.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ToolFunction.g.cs
@@ -92,5 +92,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ToolFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ToolFunction),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ToolFunction;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ToolFunction?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ToolFunction?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.ToolFunctionParams.g.cs b/src/libs/Ollama/Generated/Ollama.Models.ToolFunctionParams.g.cs
index ad24c70..eb5d657 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.ToolFunctionParams.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.ToolFunctionParams.g.cs
@@ -72,5 +72,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.ToolFunctionParams?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.ToolFunctionParams),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.ToolFunctionParams;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.ToolFunctionParams?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.ToolFunctionParams?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/src/libs/Ollama/Generated/Ollama.Models.VersionResponse.g.cs b/src/libs/Ollama/Generated/Ollama.Models.VersionResponse.g.cs
index 19f4eba..d2c1365 100644
--- a/src/libs/Ollama/Generated/Ollama.Models.VersionResponse.g.cs
+++ b/src/libs/Ollama/Generated/Ollama.Models.VersionResponse.g.cs
@@ -77,5 +77,34 @@ public string ToJson(
                 jsonSerializerOptions);
         }
 
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerContext.
+        /// </summary>
+        public static async global::System.Threading.Tasks.ValueTask<global::Ollama.VersionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.Serialization.JsonSerializerContext jsonSerializerContext)
+        {
+            return (await global::System.Text.Json.JsonSerializer.DeserializeAsync(
+                jsonStream,
+                typeof(global::Ollama.VersionResponse),
+                jsonSerializerContext).ConfigureAwait(false)) as global::Ollama.VersionResponse;
+        }
+
+        /// <summary>
+        /// Deserializes a JSON stream using the provided JsonSerializerOptions.
+        /// </summary>
+#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<global::Ollama.VersionResponse?> FromJsonStream(
+            global::System.IO.Stream jsonStream,
+            global::System.Text.Json.JsonSerializerOptions? jsonSerializerOptions = null)
+        {
+            return global::System.Text.Json.JsonSerializer.DeserializeAsync<global::Ollama.VersionResponse?>(
+                jsonStream,
+                jsonSerializerOptions);
+        }
+
     }
 }
\ No newline at end of file