Skip to content
TheChatArchiveThe Chat Archive
x-ai/grok-4.5· unknownHugging Face ibragim-bad/swe_rebench_07_2026_trajectories

ISSUE DESCRIPTION [Feature] Map thinkinglevel to DeepSeek thinking fields 🎯 The Goal /…

  1. User

    ISSUE DESCRIPTION

    [Feature] Map thinking_level to DeepSeek thinking fields

    🎯 The Goal / Use Case

    DeepSeek is currently treated as an OpenAI-compatible provider in PicoClaw, but its thinking-mode controls do not match the internal thinking_level abstraction 1:1.

    Please implement correct DeepSeek thinking mapping so that:

    • explicit thinking_level: "off" automatically disables DeepSeek thinking mode
    • thinking-enabled levels are translated to DeepSeek's documented OpenAI-compatible fields
    • DeepSeek users can rely on the same thinking_level config without needing manual extra_body overrides

    💡 Proposed Solution

    Add DeepSeek-specific request shaping on the OpenAI-compatible path.

    Suggested mapping:

    • thinking_level: "off" -> thinking: { "type": "disabled" }
    • thinking_level: "high" -> thinking: { "type": "enabled" } + reasoning_effort: "high"
    • thinking_level: "xhigh" -> thinking: { "type": "enabled" } + reasoning_effort: "max"

    If low / medium are kept as valid internal levels, they can follow DeepSeek's documented compatibility behavior and map to reasoning_effort: "high".

    🛠 Potential Implementation (Optional)

    PR #2898 already introduced explicit thinking_level: "off" handling for several OpenAI-compatible providers and added provider-specific disable-field shaping.

    This issue is to extend that work for DeepSeek specifically:

    • add DeepSeek request shaping on the OpenAI-compatible provider path
    • map internal thinking levels to DeepSeek's thinking and reasoning_effort fields
    • ensure explicit off is sent even when DeepSeek does not advertise generic thinking support via SupportsThinking()
    • add tests covering both request shaping and fallback/rewrite paths if applicable

    🚦 Impact & Roadmap Alignment

    • This is a Core Feature
    • This is a Nice-to-Have / Enhancement
    • This aligns with the current Roadmap

    🔄 Alternatives Considered

    • Ask users to configure DeepSeek manually with extra_body
    • Keep DeepSeek on the generic OpenAI-compatible path without provider-specific thinking mapping

    Both alternatives are weaker because they make DeepSeek behavior inconsistent with the project-wide thinking_level abstraction.

    💬 Additional Context

    https://api-docs.deepseek.com/zh-cn/guides/thinking_mode

    DeepSeek's documented OpenAI-compatible thinking controls use:

    • thinking.type
    • reasoning_effort
    • reasoning_content in responses

    PR #2898 is closely related because it establishes the explicit-off behavior and provider-specific request shaping pattern. DeepSeek appears to still need its own mapping added on top of that work.

    Interface

    Type: Function Name: SupportsThinking Path: pkg/providers/httpapi/http_provider.go Input: () Output: bool Description: Exposes the thinking capability of the underlying provider delegate over the HTTP API. Returns true if the delegate supports thinking; otherwise false.

    ADDITIONAL ADVICE

    Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use git checkout <file> to restore the file to its original state. You can also reset all changes in the repository using git reset --hard command. Additionally, you can use git stash and git stash pop to temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you call submit) using git status or git diff commands. However you don't need to use git add or git commit before submitting your changes. In fact, submit only submits currently unstaged changes because it uses git diff to get the changes that need to be submitted.

    CHECKLIST

    Before submitting your solution, please go over the following checklist and make sure you've done everything:

    • If an error was reported in the issue description, I have successfully reproduced it.
    • If an error was reported in the issue description, I have confirmed that my fix resolves the error.
    • I have thought about edge cases and made sure my fix handles them as well.
    • I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.

    Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!

    (Current directory: /picoclaw, current file: none) bash-$

  2. Assistant

    I'll start by exploring the repository structure and how thinking_level is currently handled for OpenAI-compatible providers, especially around PR #2898 patterns.

  3. Assistant

    Let me search more specifically for thinking-related code.

  4. Assistant

    The rg command only returned directory listing - maybe rg failed. Let me try again.

  5. Assistant

    rg is not available, let me use grep.

  6. Assistant

    I'll inspect the OpenAI-compatible provider thinking handling and related tests.

  7. Assistant

    Let me read the full applyThinkingControl function and related tests.

  8. Assistant

    I'll also check SupportsThinking and how the agent applies thinking_level.

  9. Assistant

    Let me look at the agent thinking.go more carefully, and http_provider SupportsThinking. Also check if openai_compat provider has SupportsThinking.

  10. Assistant

    I'll look for existing SupportsThinking implementations and any DeepSeek-related TODOs.

  11. Assistant

    I'll inspect PR #2898 changes and DeepSeek provider metadata for the thinking mapping pattern.

  12. Assistant

    I'll check the decorators around providers and how provider names are set for DeepSeek detection.

  13. Assistant

    I'll check how DeepSeek is built in the factory.

  14. Assistant

    I'll check the HTTP API facade re-exports and any existing SupportThinking tests.

  15. Assistant

    I'll also check whether the fallback wrapper exposes SupportsThinking.

  16. Assistant

    I have a clear picture. Implementing DeepSeek thinking mapping and SupportsThinking next.

  17. Assistant

    Updating applyThinkingControl and adding DeepSeek-specific mapping plus SupportsThinking.

  18. Assistant

    Checking for duplicate functions after the edit.

  19. Assistant

    Adding SupportsThinking to the HTTP provider facade.

  20. Assistant

    There's a duplicate SupportsNativeSearch line — fixing it now.

  21. Assistant

    Adding DeepSeek thinking mapping tests next to the existing thinking tests.

  22. Assistant

    I'll insert DeepSeek tests after the Doubao preserve test.

  23. Assistant

    There's a duplicate } — fixing it.

  24. Assistant

    Removing the duplicate function declaration.

  25. Assistant

    Adding an HTTPProvider SupportsThinking test.

  26. Assistant

    The create command left an almost empty file — writing it properly now.

  27. Assistant

    Running the related unit tests to verify the changes.

  28. Assistant

    There's a syntax error around line 213 — inspecting that section.

  29. Assistant

    Removing the duplicate function declaration.

  30. Assistant

    Running tests with GOCACHE set.

  31. Assistant

    Tests passed. Running related packages and formatting next.

  32. Assistant

    All related tests passed. Reviewing the final diff.

  33. Assistant

    Untracked files may be missed by submit — checking and ensuring the new test file is included.

  34. Assistant

    Using intent-to-add so the new test file shows up in git diff for submit.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.