feat: disable reasoning/thinking mode by default for hybrid-thinking models

Hybrid-thinking models such as Qwen3 emit <think>...</think> preambles that
corrupt tool-call output and make agentic runs fail. This turns thinking off
by default by injecting chat_template_kwargs.enable_thinking=false (plus a
top-level enable_thinking for DashScope-style servers) via extra_body on both
the agentic and single-shot LLM paths.

- Config.disable_thinking (backend) + Configuration.disable_thinking (CLI),
  default True; DISABLE_THINKING env var (default true) for web-app mode
- Provider guard: injection is skipped for first-party APIs that reject
  unknown fields and don't serve such models (OpenAI, Azure OpenAI, Bedrock,
  Anthropic); local/self-hosted OpenAI-compatible servers ignore or honor it
- `codewiki config set --disable-thinking/--enable-thinking` and
  `codewiki generate --disable-thinking/--enable-thinking`; escape hatch is
  --enable-thinking / DISABLE_THINKING=false

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: bmolodan

codewiki/cli/adapters/doc_generator.py

@@ -151,6 +151,7 @@ def generate(self) -> DocumentationJob:
                 use_gitignore=self.config.get('use_gitignore', True),
                 prompt_caching=self.config.get('prompt_caching', True),
                 max_retries=self.config.get('max_retries', 3),
+                disable_thinking=self.config.get('disable_thinking', True),
             )
 
             # Run backend documentation generation

codewiki/cli/commands/config.py

@@ -128,6 +128,14 @@ def config_group():
     help="Tool-call retries allowed per agent before giving up. Raise this for "
          "weaker/local models that emit malformed tool arguments (default: 3)",
 )
+@click.option(
+    "--disable-thinking/--enable-thinking",
+    "disable_thinking",
+    default=None,
+    help="Turn off reasoning/thinking mode for hybrid-thinking models such as "
+         "Qwen3 (sends chat_template_kwargs.enable_thinking=false; default: "
+         "disabled). Use --enable-thinking to leave it under provider control.",
+)
 def config_set(
     api_key: Optional[str],
     base_url: Optional[str],
@@ -145,6 +153,7 @@ def config_set(
     use_gitignore: Optional[bool] = None,
     prompt_caching: Optional[bool] = None,
     max_retries: Optional[int] = None,
+    disable_thinking: Optional[bool] = None,
 ):
     """
     Set configuration values for CodeWiki.
@@ -197,7 +206,7 @@ def config_set(
     """
     try:
         # Check if at least one option is provided
-        if not any([api_key, base_url, main_model, cluster_model, fallback_model, max_tokens, max_token_per_module, max_token_per_leaf_module, max_depth, provider, aws_region, api_version, azure_deployment, use_gitignore is not None, prompt_caching is not None, max_retries is not None]):
+        if not any([api_key, base_url, main_model, cluster_model, fallback_model, max_tokens, max_token_per_module, max_token_per_leaf_module, max_depth, provider, aws_region, api_version, azure_deployment, use_gitignore is not None, prompt_caching is not None, max_retries is not None, disable_thinking is not None]):
             click.echo("No options provided. Use --help for usage information.")
             sys.exit(EXIT_CONFIG_ERROR)
 
@@ -271,6 +280,8 @@ def config_set(
             if max_retries < 1:
                 raise ConfigurationError("max_retries must be a positive integer")
             validated_data['max_retries'] = max_retries
+        if disable_thinking is not None:
+            validated_data['disable_thinking'] = disable_thinking
 
         # Create config manager and save
         manager = ConfigManager()
@@ -293,6 +304,7 @@ def config_set(
             use_gitignore=validated_data.get('use_gitignore'),
             prompt_caching=validated_data.get('prompt_caching'),
             max_retries=validated_data.get('max_retries'),
+            disable_thinking=validated_data.get('disable_thinking'),
         )
 
         # Display success messages
@@ -361,6 +373,8 @@ def config_set(
 
         if max_retries is not None:
             click.secho(f"✓ Max retries: {max_retries}", fg="green")
+        if disable_thinking is not None:
+            click.secho(f"✓ Disable thinking: {disable_thinking}", fg="green")
 
         click.echo("\n" + click.style("Configuration updated successfully.", fg="green", bold=True))
 
@@ -425,6 +439,7 @@ def config_show(output_json: bool):
                 "use_gitignore": config.use_gitignore if config else True,
                 "prompt_caching": config.prompt_caching if config else True,
                 "max_retries": config.max_retries if config else 3,
+                "disable_thinking": config.disable_thinking if config else True,
                 "agent_instructions": config.agent_instructions.to_dict() if config and config.agent_instructions else {},
                 "config_file": str(manager.config_file_path)
             }
@@ -482,6 +497,7 @@ def config_show(output_json: bool):
                 click.echo(f"  Max Token/Leaf Module:   {config.max_token_per_leaf_module}")
                 click.echo(f"  Prompt Caching:          {config.prompt_caching}")
                 click.echo(f"  Max Retries:             {config.max_retries}")
+                click.echo(f"  Disable Thinking:        {config.disable_thinking}")
 
             click.echo()
             click.secho("Decomposition Settings", fg="cyan", bold=True)

codewiki/cli/commands/generate.py

@@ -313,6 +313,13 @@ def _find_affected(tree, parent_names=None):
     default=None,
     help="Tool-call retries allowed per agent before giving up (overrides config)",
 )
+@click.option(
+    "--disable-thinking/--enable-thinking",
+    "disable_thinking",
+    default=None,
+    help="Turn off reasoning/thinking mode for hybrid-thinking models such as "
+         "Qwen3 (overrides config)",
+)
 @click.option(
     "--update",
     is_flag=True,
@@ -344,6 +351,7 @@ def generate_command(
     max_depth: Optional[int],
     prompt_caching: Optional[bool],
     max_retries: Optional[int],
+    disable_thinking: Optional[bool],
     update: bool = False,
     compare_to: Optional[str] = None
 ):
@@ -548,13 +556,15 @@ def generate_command(
             effective_use_gitignore = use_gitignore if use_gitignore is not None else config.use_gitignore
             effective_prompt_caching = prompt_caching if prompt_caching is not None else config.prompt_caching
             effective_max_retries = max_retries if max_retries is not None else config.max_retries
+            effective_disable_thinking = disable_thinking if disable_thinking is not None else config.disable_thinking
             logger.debug(f"Max tokens: {effective_max_tokens}")
             logger.debug(f"Max token/module: {effective_max_token_per_module}")
             logger.debug(f"Max token/leaf module: {effective_max_token_per_leaf}")
             logger.debug(f"Max depth: {effective_max_depth}")
             logger.debug(f"Use gitignore: {effective_use_gitignore}")
             logger.debug(f"Prompt caching: {effective_prompt_caching}")
             logger.debug(f"Max retries: {effective_max_retries}")
+            logger.debug(f"Disable thinking: {effective_disable_thinking}")
 
         # Get agent instructions (merge runtime with persistent)
         agent_instructions_dict = None
@@ -598,6 +608,8 @@ def generate_command(
                 'prompt_caching': prompt_caching if prompt_caching is not None else config.prompt_caching,
                 # Tool-call retry setting (runtime override takes precedence)
                 'max_retries': max_retries if max_retries is not None else config.max_retries,
+                # Thinking-mode setting (runtime override takes precedence)
+                'disable_thinking': disable_thinking if disable_thinking is not None else config.disable_thinking,
             },
             verbose=verbose,
             generate_html=github_pages,

codewiki/cli/config_manager.py

@@ -139,6 +139,7 @@ def save(
         use_gitignore: Optional[bool] = None,
         prompt_caching: Optional[bool] = None,
         max_retries: Optional[int] = None,
+        disable_thinking: Optional[bool] = None,
     ):
         """
         Save configuration to file and keyring.
@@ -161,6 +162,7 @@ def save(
             use_gitignore: Apply Git ignore rules during repository analysis
             prompt_caching: Add prompt-cache breakpoints to agentic LLM calls
             max_retries: Tool-call retries allowed per agent before giving up
+            disable_thinking: Turn off reasoning/thinking mode for the model
         """
         # Ensure config directory exists
         try:
@@ -216,6 +218,8 @@ def save(
             self._config.prompt_caching = prompt_caching
         if max_retries is not None:
             self._config.max_retries = max_retries
+        if disable_thinking is not None:
+            self._config.disable_thinking = disable_thinking
 
         # Validate configuration whenever the minimum required fields are set.
         # Caw providers only need main_model; API providers need base_url +

codewiki/cli/models/config.py

@@ -124,6 +124,8 @@ class Configuration:
         use_gitignore: Apply Git ignore rules during repository analysis
         prompt_caching: Add prompt-cache breakpoints to agentic LLM calls (default: True)
         max_retries: Tool-call retries allowed per agent before giving up (default: 3)
+        disable_thinking: Turn off reasoning/thinking mode for hybrid-thinking
+            models such as Qwen3 (default: True)
         agent_instructions: Custom agent instructions for documentation generation
     """
     base_url: str
@@ -142,6 +144,7 @@ class Configuration:
     use_gitignore: bool = True
     prompt_caching: bool = True
     max_retries: int = 3
+    disable_thinking: bool = True
     agent_instructions: AgentInstructions = field(default_factory=AgentInstructions)
 
     def validate(self):
@@ -181,6 +184,7 @@ def to_dict(self) -> dict:
             'use_gitignore': self.use_gitignore,
             'prompt_caching': self.prompt_caching,
             'max_retries': self.max_retries,
+            'disable_thinking': self.disable_thinking,
             'fallback_model': self.fallback_model,
         }
         if self.agent_instructions and not self.agent_instructions.is_empty():
@@ -219,6 +223,7 @@ def from_dict(cls, data: dict) -> 'Configuration':
             use_gitignore=data.get('use_gitignore', True),
             prompt_caching=data.get('prompt_caching', True),
             max_retries=data.get('max_retries', 3),
+            disable_thinking=data.get('disable_thinking', True),
             agent_instructions=agent_instructions,
         )
 
@@ -289,4 +294,5 @@ def to_backend_config(self, repo_path: str, output_dir: str, api_key: str, runti
             use_gitignore=self.use_gitignore,
             prompt_caching=self.prompt_caching,
             max_retries=self.max_retries,
+            disable_thinking=self.disable_thinking,
         )

codewiki/src/be/llm_services.py

@@ -72,6 +72,37 @@ def _should_use_max_completion_tokens(model_name: str, base_url: str) -> bool:
     return False
 
 
+def _thinking_disabled_extra_body() -> dict:
+    """Request-body fields that ask the server to turn off reasoning/thinking.
+
+    ``chat_template_kwargs.enable_thinking`` is the switch honored by hybrid
+    thinking models (e.g. Qwen3) served via vLLM, SGLang, llama.cpp and
+    LM Studio; the top-level ``enable_thinking`` covers DashScope-style
+    endpoints. Servers that don't recognize these fields ignore them.
+    """
+    return {
+        "chat_template_kwargs": {"enable_thinking": False},
+        "enable_thinking": False,
+    }
+
+
+def _thinking_toggle_supported(config: Config) -> bool:
+    """Whether it's safe to send the thinking-off ``extra_body`` for this config.
+
+    First-party APIs (OpenAI, Azure OpenAI, Bedrock, Anthropic) reject unknown
+    request fields, and none of them serve hybrid Qwen-style thinking models, so
+    injection is skipped there. Local / self-hosted OpenAI-compatible servers
+    and proxies (vLLM, SGLang, llama.cpp, LiteLLM, Ollama, etc.) either honor or
+    ignore the fields.
+    """
+    if config.provider in ("azure-openai", "bedrock", "anthropic"):
+        return False
+    base_url = (config.llm_base_url or "").lower()
+    if "api.openai.com" in base_url or ".openai.azure.com" in base_url:
+        return False
+    return True
+
+
 def _build_model_settings(config: Config, model_name: str) -> OpenAIChatModelSettings:
     """Build model settings with the correct token parameter.
 
@@ -80,12 +111,16 @@ def _build_model_settings(config: Config, model_name: str) -> OpenAIChatModelSet
     provider default.
     """
     if _should_use_max_completion_tokens(model_name, config.llm_base_url):
-        return OpenAIChatModelSettings(
+        settings = OpenAIChatModelSettings(
             max_completion_tokens=config.max_tokens
         )
-    return OpenAIChatModelSettings(
-        max_tokens=config.max_tokens
-    )
+    else:
+        settings = OpenAIChatModelSettings(
+            max_tokens=config.max_tokens
+        )
+    if getattr(config, "disable_thinking", False) and _thinking_toggle_supported(config):
+        settings["extra_body"] = _thinking_disabled_extra_body()
+    return settings
 
 
 def _get_litellm_model_name(model_name: str, provider: str) -> str:
@@ -346,6 +381,8 @@ def call_llm(
         "model": model,
         "messages": [{"role": "user", "content": prompt}],
     }
+    if getattr(config, "disable_thinking", False) and _thinking_toggle_supported(config):
+        base_kwargs["extra_body"] = _thinking_disabled_extra_body()
 
     try:
         response = client.chat.completions.create(

codewiki/src/config.py

@@ -50,6 +50,10 @@ def is_cli_context() -> bool:
 CLUSTER_MODEL = os.getenv('CLUSTER_MODEL', MAIN_MODEL)
 LLM_BASE_URL = os.getenv('LLM_BASE_URL', 'http://0.0.0.0:4000/')
 LLM_API_KEY = os.getenv('LLM_API_KEY', 'sk-1234')
+# Disable reasoning/thinking mode by default (hybrid-thinking models like Qwen3
+# emit <think> blocks that corrupt tool-call output). Set DISABLE_THINKING=false
+# to leave thinking under provider control.
+DISABLE_THINKING = os.getenv('DISABLE_THINKING', 'true').lower() not in ('0', 'false', 'no')
 
 # Atlas Cloud default endpoint (OpenAI-compatible). Used to auto-fill the base URL
 # when the user selects the `atlas-cloud` provider without passing --base-url.
@@ -87,6 +91,10 @@ class Config:
     # validation before giving up. Higher values help weaker/local models that
     # frequently emit malformed tool arguments (default: 3).
     max_retries: int = 3
+    # Ask the provider to disable reasoning/thinking mode (hybrid models like
+    # Qwen3). Sent as chat_template_kwargs.enable_thinking=false via extra_body;
+    # skipped for first-party APIs that reject unknown fields. Default: True.
+    disable_thinking: bool = True
     # Agent instructions for customization
     agent_instructions: Optional[Dict[str, Any]] = None
     # Apply Git ignore rules before dependency analysis
@@ -172,6 +180,7 @@ def from_args(cls, args: argparse.Namespace) -> 'Config':
             cluster_model=CLUSTER_MODEL,
             fallback_model=FALLBACK_MODEL_1,
             use_gitignore=getattr(args, "use_gitignore", True),
+            disable_thinking=DISABLE_THINKING,
         )
 
     @classmethod
@@ -198,6 +207,7 @@ def from_cli(
         use_gitignore: bool = True,
         prompt_caching: bool = True,
         max_retries: int = 3,
+        disable_thinking: bool = True,
     ) -> 'Config':
         """
         Create configuration for CLI context.
@@ -227,6 +237,7 @@ def from_cli(
             use_gitignore: Whether to apply Git ignore rules
             prompt_caching: Whether to add prompt-cache breakpoints to agentic calls
             max_retries: Tool-call retries allowed per agent before giving up
+            disable_thinking: Ask the provider to turn off reasoning/thinking mode
 
         Returns:
             Config instance
@@ -258,4 +269,5 @@ def from_cli(
             use_gitignore=use_gitignore,
             prompt_caching=prompt_caching,
             max_retries=max_retries,
+            disable_thinking=disable_thinking,
         )