Support reasoning content from DeepSeek

Author: intitni

Core/Sources/ChatService/AllPlugins.swift

@@ -94,6 +94,8 @@ final class LegacyChatPluginWrapper<Plugin: ChatPlugin>: LegacyChatPlugin {
                     break
                 case .startNewMessage:
                     break
+                case .reasoning:
+                    break
                 }
 
                 await chatGPTService.memory.mutateHistory { history in

Tool/Sources/ChatBasic/ChatAgent.swift

@@ -24,6 +24,8 @@ public enum ChatAgentResponse {
     case references([ChatMessage.Reference])
     /// End the current message. The next contents will be sent as a new message.
     case startNewMessage
+    /// Reasoning
+    case reasoning(String)
 }
 
 public struct ChatAgentRequest {

Tool/Sources/OpenAIService/APIs/ChatCompletionsAPIDefinition.swift

@@ -209,6 +209,7 @@ struct ChatCompletionsStreamDataChunk {
 
         var role: ChatCompletionsRequestBody.Message.Role?
         var content: String?
+        var reasoningContent: String?
         var toolCalls: [ToolCall]?
     }
 
@@ -243,6 +244,8 @@ struct ChatCompletionResponseBody: Equatable {
         var role: Role
         /// The content of the message.
         var content: String?
+        /// The reasoning content of the message.
+        var reasoningContent: String?
         /// When we want to reply to a function call with the result, we have to provide the
         /// name of the function call, and include the result in `content`.
         ///

Tool/Sources/OpenAIService/APIs/OpenAIChatCompletionsService.swift

@@ -100,6 +100,8 @@ actor OpenAIChatCompletionsService: ChatCompletionsStreamAPI, ChatCompletionsAPI
             struct Delta: Codable {
                 var role: MessageRole?
                 var content: String?
+                var reasoning_content: String?
+                var reasoning: String?
                 var function_call: RequestBody.MessageFunctionCall?
                 var tool_calls: [RequestBody.MessageToolCall]?
             }
@@ -112,6 +114,8 @@ actor OpenAIChatCompletionsService: ChatCompletionsStreamAPI, ChatCompletionsAPI
             var role: MessageRole
             /// The content of the message.
             var content: String?
+            var reasoning_content: String?
+            var reasoning: String?
             /// When we want to reply to a function call with the result, we have to provide the
             /// name of the function call, and include the result in `content`.
             ///
@@ -482,6 +486,7 @@ extension OpenAIChatCompletionsService.ResponseBody {
             .init(
                 role: message.role.formalized,
                 content: message.content ?? "",
+                reasoningContent: message.reasoning_content ?? message.reasoning ?? "",
                 toolCalls: {
                     if let toolCalls = message.tool_calls {
                         return toolCalls.map { toolCall in
@@ -553,6 +558,8 @@ extension OpenAIChatCompletionsService.StreamDataChunk {
                     return .init(
                         role: choice.delta?.role?.formalized,
                         content: choice.delta?.content,
+                        reasoningContent: choice.delta?.reasoning_content
+                            ?? choice.delta?.reasoning,
                         toolCalls: {
                             if let toolCalls = choice.delta?.tool_calls {
                                 return toolCalls.map {

Tool/Sources/OpenAIService/ChatGPTService.swift

@@ -66,6 +66,7 @@ public struct ChatGPTError: Error, Codable, LocalizedError {
 public enum ChatGPTResponse: Equatable {
     case status([String])
     case partialText(String)
+    case partialReasoning(String)
     case toolCalls([ChatMessage.ToolCall])
 }
 
@@ -195,6 +196,9 @@ public class ChatGPTService: ChatGPTServiceType {
                                 switch content {
                                 case let .partialText(text):
                                     continuation.yield(ChatGPTResponse.partialText(text))
+                                    
+                                case let .partialReasoning(text):
+                                    continuation.yield(ChatGPTResponse.partialReasoning(text))
 
                                 case let .partialToolCalls(toolCalls):
                                     guard configuration.runFunctionsAutomatically else { break }
@@ -250,6 +254,7 @@ public class ChatGPTService: ChatGPTServiceType {
 
 extension ChatGPTService {
     enum StreamContent {
+        case partialReasoning(String)
         case partialText(String)
         case partialToolCalls([Int: ChatMessage.ToolCall])
     }
@@ -340,6 +345,10 @@ extension ChatGPTService {
                         if let content = delta.content {
                             continuation.yield(.partialText(content))
                         }
+                        
+                        if let reasoning = delta.reasoningContent {
+                            continuation.yield(.partialReasoning(reasoning))
+                        }
                     }
 
                     Logger.service.info("ChatGPT usage: \(usage)")