Fixing some things left over

app/MindWork AI Studio/Provider/OpenAI/ResponsesToolCallingAdapter.cs

@@ -15,6 +15,8 @@ public sealed class ResponsesToolCallingAdapter(Model chatModel, IList<object> b
     IReadOnlyList<(ToolDefinition Definition, IToolImplementation Implementation)> runnableTools,
     Func<ResponsesAPIRequest, CancellationToken, Task<ResponsesResponse?>> executeRequestAsync) : IToolCallingProviderAdapter
 {
+    private const string ENCRYPTED_REASONING_INCLUDE = "reasoning.encrypted_content";
+
     private readonly List<object> internalItems = [];
     private ResponsesResponse? lastResponse;
 
@@ -48,7 +50,7 @@ public sealed class ResponsesToolCallingAdapter(Model chatModel, IList<object> b
             Stream = false,
             Store = false,
             Tools = includeTools ? this.effectiveProviderTools : [],
-            AdditionalApiParameters = apiParameters,
+            AdditionalApiParameters = IncludeEncryptedReasoning(apiParameters),
         }, token);
 
         if (response is null)
@@ -92,6 +94,37 @@ public sealed class ResponsesToolCallingAdapter(Model chatModel, IList<object> b
         Output = content,
     });
 
+    /// <summary>
+    /// Request encrypted reasoning content without replacing any additional output data selected by the user.
+    /// </summary>
+    /// <remarks>
+    /// Tool rounds use stateless Responses requests. OpenAI requires encrypted reasoning items in that mode
+    /// so that the complete output can be passed back with the tool result on the next round.
+    /// </remarks>
+    private static IDictionary<string, object> IncludeEncryptedReasoning(IDictionary<string, object> apiParameters)
+    {
+        var result = new Dictionary<string, object>(apiParameters);
+        var includeKey = result.Keys.FirstOrDefault(key => key.Equals("include", StringComparison.OrdinalIgnoreCase));
+        if (includeKey is null)
+        {
+            result["include"] = new List<object> { ENCRYPTED_REASONING_INCLUDE };
+            return result;
+        }
+
+        var includedOutput = result[includeKey] switch
+        {
+            IEnumerable<object> values => values.ToList(),
+            string value => new List<object> { value },
+            _ => [],
+        };
+
+        if (!includedOutput.Any(value => string.Equals(value as string, ENCRYPTED_REASONING_INCLUDE, StringComparison.Ordinal)))
+            includedOutput.Add(ENCRYPTED_REASONING_INCLUDE);
+
+        result[includeKey] = includedOutput;
+        return result;
+    }
+
     private static IList<object> BuildEffectiveProviderTools(IList<object> providerTools, IReadOnlyList<(ToolDefinition Definition, IToolImplementation Implementation)> runnableTools)
     {
         var localFunctionNames = runnableTools

app/MindWork AI Studio/Provider/OpenAI/ThinkingContent.cs

@@ -9,10 +9,10 @@ internal static class ThinkingContent
 {
     public static string Get(string? reasoningContent, string? reasoning, IEnumerable<JsonElement>? reasoningDetails)
     {
-        if (!string.IsNullOrWhiteSpace(reasoningContent))
+        if (!string.IsNullOrEmpty(reasoningContent))
             return reasoningContent;
 
-        if (!string.IsNullOrWhiteSpace(reasoning))
+        if (!string.IsNullOrEmpty(reasoning))
             return reasoning;
 
         if (reasoningDetails is null)