diff --git a/TelegramSearchBot.Common/Model/AI/LlmContinuationSnapshot.cs b/TelegramSearchBot.Common/Model/AI/LlmContinuationSnapshot.cs
index ddec625f..5c678fd3 100644
--- a/TelegramSearchBot.Common/Model/AI/LlmContinuationSnapshot.cs
+++ b/TelegramSearchBot.Common/Model/AI/LlmContinuationSnapshot.cs
@@ -16,6 +16,12 @@ public class SerializedChatMessage {
         /// The text content of the message
         /// </summary>
         public string Content { get; set; } = null!;
+
+        /// <summary>
+        /// The reasoning content for thinking mode models (e.g., Kimi-thinking-preview, QwQ).
+        /// This field must be passed back to the API in subsequent requests to avoid HTTP 400 errors.
+        /// </summary>
+        public string? ReasoningContent { get; set; }
     }
 
     /// <summary>
diff --git a/TelegramSearchBot.LLM/Service/AI/LLM/OpenAIService.cs b/TelegramSearchBot.LLM/Service/AI/LLM/OpenAIService.cs
index 8044cda4..ab34380a 100644
--- a/TelegramSearchBot.LLM/Service/AI/LLM/OpenAIService.cs
+++ b/TelegramSearchBot.LLM/Service/AI/LLM/OpenAIService.cs
@@ -967,6 +967,7 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                     if (cancellationToken.IsCancellationRequested) throw new TaskCanceledException();
 
                     var contentBuilder = new StringBuilder();
+                    var reasoningContentBuilder = new StringBuilder();
                     var toolCallAccumulators = new Dictionary<int, ToolCallAccumulator>();
                     ChatFinishReason? finishReason = null;
 
@@ -985,6 +986,12 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                             }
                         }
 
+                        // Accumulate reasoning content for thinking mode models (e.g., Kimi-thinking-preview)
+                        var reasoningUpdate = GetStreamingReasoningContent(update);
+                        if (!string.IsNullOrEmpty(reasoningUpdate)) {
+                            reasoningContentBuilder.Append(reasoningUpdate);
+                        }
+
                         // Accumulate tool call updates
                         foreach (var toolCallUpdate in update.ToolCallUpdates ?? Enumerable.Empty<StreamingChatToolCallUpdate>()) {
                             int index = toolCallUpdate.Index;
@@ -1006,6 +1013,7 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                     }
 
                     string responseText = contentBuilder.ToString().Trim();
+                    string reasoningContent = reasoningContentBuilder.ToString().Trim();
 
                     // Check if this is a tool call response
                     if (finishReason == ChatFinishReason.ToolCalls && toolCallAccumulators.Any()) {
@@ -1025,6 +1033,10 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                         if (!string.IsNullOrWhiteSpace(responseText)) {
                             assistantMessage = new AssistantChatMessage(chatToolCalls) { Content = { ChatMessageContentPart.CreateTextPart(responseText) } };
                         }
+                        // Set reasoning content for thinking mode models
+                        if (!string.IsNullOrEmpty(reasoningContent)) {
+                            SetAssistantReasoningContent(assistantMessage, reasoningContent);
+                        }
                         providerHistory.Add(assistantMessage);
 
                         var toolIndicators = new StringBuilder();
@@ -1066,7 +1078,11 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                     } else {
                         // Not a tool call - regular text response
                         if (!string.IsNullOrWhiteSpace(responseText)) {
-                            providerHistory.Add(new AssistantChatMessage(responseText));
+                            var assistantMsg = new AssistantChatMessage(responseText);
+                            if (!string.IsNullOrEmpty(reasoningContent)) {
+                                SetAssistantReasoningContent(assistantMsg, reasoningContent);
+                            }
+                            providerHistory.Add(assistantMsg);
                         }
                         yield break;
                     }
@@ -1328,6 +1344,7 @@ public static List<SerializedChatMessage> SerializeProviderHistory(List<ChatMess
             foreach (var msg in history) {
                 string role;
                 string content = "";
+                string? reasoningContent = null;
 
                 if (msg is SystemChatMessage systemMsg) {
                     role = "system";
@@ -1335,6 +1352,9 @@ public static List<SerializedChatMessage> SerializeProviderHistory(List<ChatMess
                 } else if (msg is AssistantChatMessage assistantMsg) {
                     role = "assistant";
                     content = string.Join("", assistantMsg.Content?.Select(p => p.Text) ?? Enumerable.Empty<string>());
+                    // Try to get reasoning content from the assistant message
+                    // OpenAI SDK stores reasoning content in a separate property
+                    reasoningContent = GetAssistantReasoningContent(assistantMsg);
                 } else if (msg is UserChatMessage userMsg) {
                     role = "user";
                     content = string.Join("", userMsg.Content?.Select(p => p.Text) ?? Enumerable.Empty<string>());
@@ -1343,11 +1363,61 @@ public static List<SerializedChatMessage> SerializeProviderHistory(List<ChatMess
                     content = msg.ToString();
                 }
 
-                result.Add(new SerializedChatMessage { Role = role, Content = content });
+                result.Add(new SerializedChatMessage { Role = role, Content = content, ReasoningContent = reasoningContent });
             }
             return result;
         }
 
+        /// <summary>
+        /// Extract reasoning_content from AssistantChatMessage if available.
+        /// For thinking mode models, the reasoning process is returned separately.
+        /// </summary>
+        private static string? GetAssistantReasoningContent(AssistantChatMessage assistantMsg) {
+            // Try to access reasoning content - OpenAI Chat SDK may store it in various ways
+            // The reasoning_content is typically available via reflection or specific properties
+            try {
+                // Check for Reasoning property via reflection
+                var reasoningProp = assistantMsg.GetType().GetProperty("Reasoning");
+                if (reasoningProp != null) {
+                    var value = reasoningProp.GetValue(assistantMsg);
+                    if (value is string reasoning && !string.IsNullOrEmpty(reasoning)) {
+                        return reasoning;
+                    }
+                }
+            } catch {
+                // Reflection failed, return null
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Extract reasoning_content from streaming update for thinking mode models.
+        /// Uses reflection to access SDK internals.
+        /// </summary>
+        private static string? GetStreamingReasoningContent(StreamingChatCompletionUpdate update) {
+            try {
+                // Try ReasoningContentUpdate property (OpenAI SDK for thinking models)
+                var reasoningProp = update.GetType().GetProperty("ReasoningContentUpdate");
+                if (reasoningProp != null) {
+                    var value = reasoningProp.GetValue(update);
+                    if (value is string reasoning && !string.IsNullOrEmpty(reasoning)) {
+                        return reasoning;
+                    }
+                }
+                // Fallback: try Reasoning property
+                var fallbackProp = update.GetType().GetProperty("Reasoning");
+                if (fallbackProp != null) {
+                    var value = fallbackProp.GetValue(update);
+                    if (value is string fallback && !string.IsNullOrEmpty(fallback)) {
+                        return fallback;
+                    }
+                }
+            } catch {
+                // Reflection failed
+            }
+            return null;
+        }
+
         /// <summary>
         /// Deserialize portable format back to OpenAI ChatMessage list.
         /// </summary>
@@ -1361,7 +1431,12 @@ public static List<ChatMessage> DeserializeProviderHistory(List<SerializedChatMe
                         result.Add(new SystemChatMessage(msg.Content ?? ""));
                         break;
                     case "assistant":
-                        result.Add(new AssistantChatMessage(msg.Content ?? ""));
+                        var assistantMsg = new AssistantChatMessage(msg.Content ?? "");
+                        // Set reasoning content if available (for thinking mode models)
+                        if (!string.IsNullOrEmpty(msg.ReasoningContent)) {
+                            SetAssistantReasoningContent(assistantMsg, msg.ReasoningContent);
+                        }
+                        result.Add(assistantMsg);
                         break;
                     case "user":
                     default:
@@ -1372,6 +1447,21 @@ public static List<ChatMessage> DeserializeProviderHistory(List<SerializedChatMe
             return result;
         }
 
+        /// <summary>
+        /// Set reasoning_content on AssistantChatMessage for thinking mode models.
+        /// Uses reflection since OpenAI SDK doesn't have a public setter.
+        /// </summary>
+        private static void SetAssistantReasoningContent(AssistantChatMessage msg, string reasoningContent) {
+            try {
+                var prop = msg.GetType().GetProperty("Reasoning");
+                if (prop != null && prop.CanWrite) {
+                    prop.SetValue(msg, reasoningContent);
+                }
+            } catch {
+                // Reflection failed, ignore
+            }
+        }
+
         public async Task<float[]> GenerateEmbeddingsAsync(string text, string modelName, LLMChannel channel) {