[Feature]: Net: How to disable thinking when using the deepseek model?

[williamlzw]

Description

How to disable thinking when using the deepseek model?

Code Sample

 public static ChatClientAgent CreateDeepseekAgent(string prompt)
 {
     var openAIOptions = new OpenAIClientOptions
     {
         Endpoint = new Uri(DEEPSEEK_API_URL)
     };

     var openAIClient = new OpenAIClient(
         credential: new ApiKeyCredential(DEEPSEEK_API_KEY),
         options: openAIOptions
     );

     return openAIClient.GetChatClient(DEEPSEEK_MODEL).AsAIAgent(new ChatClientAgentOptions
     {
         ChatOptions = new ChatOptions { Instructions = prompt }
     });
 }

Language/SDK

NET

[williamlzw]

[flowbar-api]

For DeepSeek API, you can disable thinking by passing reasoning_effort: "none" in your request body (or just omit it — DeepSeek V3 doesn't think by default, only R1/V4 Pro do).

In the .NET SDK, you'd add this via ChatOptions or as extra properties. If you want to sidestep per-model config entirely, managed gateways like FlowBar (flowbarai.com) normalize these quirks across 50+ models through one OpenAI-compatible endpoint.

[XiongHaoTrigger]

@williamlzw
You can use AdditionalProperties to add some custom properties defined by the manufacturer.

var apiKey = System.Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new InvalidOperationException("OPENAI_API_KEY is not set.");
var baseUrl = System.Environment.GetEnvironmentVariable("OPENAI_BASE_URL") ?? throw new InvalidOperationException("OPENAI_BASE_URL is not set.");
var modelName = System.Environment.GetEnvironmentVariable("OPENAI_MODEL_NAME") ?? throw new InvalidOperationException("OPENAI_MODEL_NAME is not set.");
var chatClient = new OpenAI.OpenAIClient(new ApiKeyCredential(apiKey), new OpenAIClientOptions()
{
    Endpoint = new Uri(baseUrl),
}).GetChatClient(modelName)
.AsIChatClient();

var openAIAgent = chatClient.AsAIAgent(new ChatClientAgentOptions()
{
    ChatOptions = new ChatOptions
    {
        // Add some the custom attributes defined by various model manufacturers
        AdditionalProperties = new AdditionalPropertiesDictionary
        {
            ["thinking"] = new {type = "enabled"},
            ["reasoning_effort"] = "high",
        },
        // Some general attribute frameworks have been implemented, and they can be used without the need for AdditionalProperties. such as "reasoning_effort"
        // Reasoning = new ReasoningOptions { Effort = ReasoningEffort.High}
    }
});

[williamlzw]

The above code still cannot prevent deepseek from outputting thinking content. I don't know if it's a problem with deepseek.

[XiongHaoTrigger]

@williamlzw Sorry, after checking the official documentation, AdditionalProperties enables the transmission of custom attributes, allowing the middleware to obtain the custom attributes. However, these custom attributes will not be included in the HTTP request. You can use the RawRepresentationFactory attribute to embed the custom attributes in the request.

Example：

var apiKey = System.Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new InvalidOperationException("OPENAI_API_KEY is not set.");
var baseUrl = System.Environment.GetEnvironmentVariable("OPENAI_BASE_URL") ?? throw new InvalidOperationException("OPENAI_BASE_URL is not set.");
var modelName = System.Environment.GetEnvironmentVariable("OPENAI_MODEL_NAME") ?? throw new InvalidOperationException("OPENAI_MODEL_NAME is not set.");

var chatClient = new OpenAI.OpenAIClient(new ApiKeyCredential(apiKey), new OpenAIClientOptions
{
    Endpoint = new Uri(baseUrl)
}).GetChatClient(modelName)
    .AsIChatClient();

var agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
{
    ChatOptions = new ChatOptions
    {
        RawRepresentationFactory = _ =>
        {
            var option = new ChatCompletionOptions();
#pragma warning disable SCME0001
            option.Patch.Set("$.thinking"u8, BinaryData.FromString("""{"type":"enabled"}"""));
#pragma warning restore SCME0001
            return option;
        }
    }
});

await foreach (var update in agent.RunStreamingAsync("Tell me a joke about a pirate."))
{
    foreach (var content in update.Contents)
    {
        switch (content)
        {
            case TextReasoningContent reasoning:
                // Print thinging content
                Console.ForegroundColor = ConsoleColor.DarkGray;
                Console.Write($"{reasoning.Text}");
                Console.ResetColor();
                break;
            case TextContent text:
                // Print output content
                Console.Write(text.Text);
                break;
        }
    }
}

Note: OpenAI.Chat.ChatCompletionOptions.Patch is currently in the evaluation stage. If you want to use it, you need to suppress the diagnostic by using the #pragma warning disable SCME0001 statement.

[XiongHaoTrigger]

Or, attribute injection can be achieved through interceptors in the HTTP request pipeline.

var apiKey = System.Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new InvalidOperationException("OPENAI_API_KEY is not set.");
var baseUrl = System.Environment.GetEnvironmentVariable("OPENAI_BASE_URL") ?? throw new InvalidOperationException("OPENAI_BASE_URL is not set.");
var modelName = System.Environment.GetEnvironmentVariable("OPENAI_MODEL_NAME") ?? throw new InvalidOperationException("OPENAI_MODEL_NAME is not set.");

var chatClientOptions = new OpenAIClientOptions
{
    Endpoint = new Uri(baseUrl),
};

// add interceptor
chatClientOptions.AddPolicy(new ThinkingPolicy(), PipelinePosition.PerCall);

var chatClient = new OpenAI.OpenAIClient(new ApiKeyCredential(apiKey), chatClientOptions)
    .GetChatClient(modelName)
    .AsIChatClient();

var agent = chatClient.AsAIAgent();

await foreach (var update in agent.RunStreamingAsync("Tell me a joke about a pirate."))
{
    foreach (var content in update.Contents)
    {
        switch (content)
        {
            case TextReasoningContent reasoning:
                Console.ForegroundColor = ConsoleColor.DarkGray;
                Console.Write($"{reasoning.Text}");
                Console.ResetColor();
                break;
            case TextContent text:
                Console.Write(text.Text);
                break;
        }
    }
}

Console.WriteLine();

internal sealed class ThinkingPolicy : PipelinePolicy
{
    public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
    {
        InjectThinking(message);
        ProcessNext(message, pipeline, currentIndex);
    }

    public override async ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
    {
        InjectThinking(message);
        await ProcessNextAsync(message, pipeline, currentIndex);
    }

    private static void InjectThinking(PipelineMessage message)
    {
        if (message.Request?.Content is null)
        {
            return;
        }

        try
        {
            using var ms = new MemoryStream();
            message.Request.Content.WriteTo(ms);
            ms.Position = 0;

            var body = new StreamReader(ms).ReadToEnd();
            if (string.IsNullOrEmpty(body))
            {
                return;
            }

            using var doc = JsonDocument.Parse(body);
            using var newMs = new MemoryStream();
            using var writer = new Utf8JsonWriter(newMs);

            writer.WriteStartObject();
            foreach (var prop in doc.RootElement.EnumerateObject())
            {
                prop.WriteTo(writer);
            }

            writer.WriteStartObject("thinking");
            writer.WriteString("type", "enabled");
            writer.WriteEndObject();

            writer.WriteEndObject();
            writer.Flush();

            message.Request.Content = BinaryContent.Create(
                BinaryData.FromBytes(newMs.ToArray()));
        }
        catch
        {
            // If body parsing fails, send the request as-is.
        }
    }
}

[williamlzw]

@williamlzw Sorry, after checking the official documentation, AdditionalProperties enables the transmission of custom attributes, allowing the middleware to obtain the custom attributes. However, these custom attributes will not be included in the HTTP request. You can use the RawRepresentationFactory attribute to embed the custom attributes in the request.

Example：

var apiKey = System.Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new InvalidOperationException("OPENAI_API_KEY is not set.");
var baseUrl = System.Environment.GetEnvironmentVariable("OPENAI_BASE_URL") ?? throw new InvalidOperationException("OPENAI_BASE_URL is not set.");
var modelName = System.Environment.GetEnvironmentVariable("OPENAI_MODEL_NAME") ?? throw new InvalidOperationException("OPENAI_MODEL_NAME is not set.");

var chatClient = new OpenAI.OpenAIClient(new ApiKeyCredential(apiKey), new OpenAIClientOptions
{
Endpoint = new Uri(baseUrl)
}).GetChatClient(modelName)
.AsIChatClient();

var agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
{
ChatOptions = new ChatOptions
{
RawRepresentationFactory = _ =>
{
var option = new ChatCompletionOptions();
#pragma warning disable SCME0001
option.Patch.Set("$.thinking"u8, BinaryData.FromString("""{"type":"enabled"}"""));
#pragma warning restore SCME0001
return option;
}
}
});

await foreach (var update in agent.RunStreamingAsync("Tell me a joke about a pirate."))
{
foreach (var content in update.Contents)
{
switch (content)
{
case TextReasoningContent reasoning:
// Print thinging content
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write($"{reasoning.Text}");
Console.ResetColor();
break;
case TextContent text:
// Print output content
Console.Write(text.Text);
break;
}
}
}
Note: OpenAI.Chat.ChatCompletionOptions.Patch is currently in the evaluation stage. If you want to use it, you need to suppress the diagnostic by using the #pragma warning disable SCME0001 statement.

This can disable thinking. Thanks.

[flowbar-api]

Good catch @XiongHaoTrigger — the RawRepresentationFactory + Patch.Set approach is the cleanest workaround for .NET SDK right now.

One technical correction to my earlier comment: reasoning_effort is an OpenAI parameter. DeepSeek uses {"thinking": {"type": "disabled"}} to suppress thinking, and only R1/V4 Pro models need it (V3 returns no reasoning tokens by default).

For anyone who doesn't want to deal with per-model quirks in .NET, API gateways like flowbarai.com normalize these differences behind one OpenAI-compatible endpoint — just swap base URL and key, no SDK-level hacks needed.