From a2d163adbf30e58b0ca6e7d8898569135fbea13b Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 29 Jul 2026 09:00:19 +0800 Subject: [PATCH 1/6] feat: add enable_thinking support for OpenAI-compatible providers Closes #2149 Adds enable_thinking configuration parameter for OpenAI-compatible providers (qwen, deepseek, minimax) to control whether the model produces reasoning blocks before the actual response. Changes: - Added enable_thinking field (bool | None) to OpenAILLMConfig - None (default): preserve provider's default behavior - True: explicitly enable thinking mode - False: explicitly disable thinking mode (prevents JSON breaking) - OpenAILLM.generate / generate_stream now pass enable_thinking to API calls when configured, via enable_thinking body param - AzureLLM.generate / generate_stream also support the parameter (gated by getattr for backward compatibility with older configs) - Per-call override supported via kwargs (enable_thinking=True/False) - Added tests covering default, config-level, and kwarg-level enable_thinking behavior in test_enable_thinking.py This is a non-breaking change: when enable_thinking is unset, request bodies are identical to previous versions. Test: python3 -m py_compile src/memos/configs/llm.py Test: python3 -m py_compile src/memos/llms/openai.py Test: python3 -m py_compile tests/llms/test_enable_thinking.py --- src/memos/configs/llm.py | 5 ++ src/memos/llms/openai.py | 73 +++++++++++++++++---------- tests/llms/test_enable_thinking.py | 80 ++++++++++++++++++++++++++++++ 3 files changed, 131 insertions(+), 27 deletions(-) create mode 100644 tests/llms/test_enable_thinking.py diff --git a/src/memos/configs/llm.py b/src/memos/configs/llm.py index 81f7038fa..627a7daed 100644 --- a/src/memos/configs/llm.py +++ b/src/memos/configs/llm.py @@ -28,6 +28,11 @@ class OpenAILLMConfig(BaseLLMConfig): default="https://api.openai.com/v1", description="Base URL for OpenAI API" ) extra_body: Any = Field(default=None, description="extra body") + enable_thinking: bool | None = Field( + default=None, + description="Enable/disable thinking mode for models that support it (e.g. Qwen3, DeepSeek-R1). " + "When None (default), the provider's default behavior is preserved.", + ) backup_client: bool = Field( default=False, description="Whether to enable backup client for fallback on primary failure", diff --git a/src/memos/llms/openai.py b/src/memos/llms/openai.py index 9a29ea68a..e4c45eca3 100644 --- a/src/memos/llms/openai.py +++ b/src/memos/llms/openai.py @@ -61,15 +61,7 @@ def _parse_response(self, response) -> str: return reasoning_content + (response_content or "") return response_content or "" - @timed_with_status( - log_prefix="OpenAI LLM", - log_extra_args=lambda self, messages, **kwargs: { - "model_name_or_path": kwargs.get("model_name_or_path", self.config.model_name_or_path), - "messages": messages, - }, - ) - def generate(self, messages: MessageList, **kwargs) -> str: - """Generate a response from OpenAI LLM, optionally overriding generation params.""" + def _build_request_body(self, messages: MessageList, **kwargs) -> dict: request_body = { "model": kwargs.get("model_name_or_path", self.config.model_name_or_path), "messages": messages, @@ -79,6 +71,21 @@ def generate(self, messages: MessageList, **kwargs) -> str: "extra_body": kwargs.get("extra_body", self.config.extra_body), "tools": kwargs.get("tools", NOT_GIVEN), } + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) + if enable_thinking is not None: + request_body["enable_thinking"] = enable_thinking + return request_body + + @timed_with_status( + log_prefix="OpenAI LLM", + log_extra_args=lambda self, messages, **kwargs: { + "model_name_or_path": kwargs.get("model_name_or_path", self.config.model_name_or_path), + "messages": messages, + }, + ) + def generate(self, messages: MessageList, **kwargs) -> str: + """Generate a response from OpenAI LLM, optionally overriding generation params.""" + request_body = self._build_request_body(messages, **kwargs) start_time = time.perf_counter() logger.info(f"OpenAI LLM Request body: {request_body}") @@ -132,6 +139,10 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non "tools": kwargs.get("tools", NOT_GIVEN), } + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) + if enable_thinking is not None: + request_body["enable_thinking"] = enable_thinking + logger.info(f"OpenAI LLM Stream Request body: {request_body}") response = self.client.chat.completions.create(**request_body) @@ -184,15 +195,19 @@ def __init__(self, config: AzureLLMConfig): def generate(self, messages: MessageList, **kwargs) -> str: """Generate a response from Azure OpenAI LLM.""" - response = self.client.chat.completions.create( - model=self.config.model_name_or_path, - messages=messages, - temperature=kwargs.get("temperature", self.config.temperature), - max_tokens=kwargs.get("max_tokens", self.config.max_tokens), - top_p=kwargs.get("top_p", self.config.top_p), - tools=kwargs.get("tools", NOT_GIVEN), - extra_body=kwargs.get("extra_body", self.config.extra_body), - ) + request_body = { + "model": self.config.model_name_or_path, + "messages": messages, + "temperature": kwargs.get("temperature", self.config.temperature), + "max_tokens": kwargs.get("max_tokens", self.config.max_tokens), + "top_p": kwargs.get("top_p", self.config.top_p), + "tools": kwargs.get("tools", NOT_GIVEN), + "extra_body": kwargs.get("extra_body", self.config.extra_body), + } + enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None)) + if enable_thinking is not None: + request_body["enable_thinking"] = enable_thinking + response = self.client.chat.completions.create(**request_body) logger.info(f"Response from Azure OpenAI: {response.model_dump_json()}") if not response.choices: logger.warning("Azure OpenAI response has no choices") @@ -212,15 +227,19 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non logger.info("stream api not support tools") return - response = self.client.chat.completions.create( - model=self.config.model_name_or_path, - messages=messages, - stream=True, - temperature=kwargs.get("temperature", self.config.temperature), - max_tokens=kwargs.get("max_tokens", self.config.max_tokens), - top_p=kwargs.get("top_p", self.config.top_p), - extra_body=kwargs.get("extra_body", self.config.extra_body), - ) + request_body = { + "model": self.config.model_name_or_path, + "messages": messages, + "stream": True, + "temperature": kwargs.get("temperature", self.config.temperature), + "max_tokens": kwargs.get("max_tokens", self.config.max_tokens), + "top_p": kwargs.get("top_p", self.config.top_p), + "extra_body": kwargs.get("extra_body", self.config.extra_body), + } + enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None)) + if enable_thinking is not None: + request_body["enable_thinking"] = enable_thinking + response = self.client.chat.completions.create(**request_body) reasoning_started = False diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py new file mode 100644 index 000000000..ffe17e5b5 --- /dev/null +++ b/tests/llms/test_enable_thinking.py @@ -0,0 +1,80 @@ +"""Tests for enable_thinking parameter in OpenAILLM.""" + +from types import SimpleNamespace +from unittest.mock import patch + +import pytest + +from memos.configs.llm import OpenAILLMConfig +from memos.llms.openai import AzureLLM, OpenAILLM + + +def _make_config(**overrides): + defaults = { + "provider": "openai", + "api_key": "test-key", + "model_name_or_path": "gpt-4o", + } + defaults.update(overrides) + return OpenAILLMConfig(**defaults) + + +class TestEnableThinkingConfig: + def test_enable_thinking_defaults_to_none(self): + config = _make_config() + assert config.enable_thinking is None + + def test_enable_thinking_can_be_set(self): + config = _make_config(enable_thinking=True) + assert config.enable_thinking is True + + def test_enable_thinking_false(self): + config = _make_config(enable_thinking=False) + assert config.enable_thinking is False + + +class TestEnableThinkingInRequest: + def test_build_request_body_without_enable_thinking(self): + config = _make_config() + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body([{"role": "user", "content": "hi"}]) + assert "enable_thinking" not in body + + def test_build_request_body_with_enable_thinking_from_config(self): + config = _make_config(enable_thinking=True) + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body([{"role": "user", "content": "hi"}]) + assert body["enable_thinking"] is True + + def test_build_request_body_with_enable_thinking_from_kwargs(self): + config = _make_config(enable_thinking=True) + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body( + [{"role": "user", "content": "hi"}], enable_thinking=False + ) + assert body["enable_thinking"] is False + + def test_build_request_body_with_enable_thinking_false(self): + config = _make_config(enable_thinking=False) + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body([{"role": "user", "content": "hi"}]) + assert body["enable_thinking"] is False + + def test_build_request_body_preserves_other_params(self): + config = _make_config(enable_thinking=True, temperature=0.5, max_tokens=100) + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body([{"role": "user", "content": "hi"}]) + assert body["enable_thinking"] is True + assert body["temperature"] == 0.5 + assert body["max_tokens"] == 100 + assert body["model"] == "gpt-4o" From f418e82ef3617b4615f1901c9348a84e00804fc9 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Fri, 31 Jul 2026 10:02:34 +0800 Subject: [PATCH 2/6] style(test): ruff cleanups for enable_thinking tests --- tests/llms/test_enable_thinking.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py index ffe17e5b5..be3441faa 100644 --- a/tests/llms/test_enable_thinking.py +++ b/tests/llms/test_enable_thinking.py @@ -1,12 +1,7 @@ """Tests for enable_thinking parameter in OpenAILLM.""" -from types import SimpleNamespace -from unittest.mock import patch - -import pytest - from memos.configs.llm import OpenAILLMConfig -from memos.llms.openai import AzureLLM, OpenAILLM +from memos.llms.openai import OpenAILLM def _make_config(**overrides): From 4dd095e86cf18aeac62d09dbaf53c71b6f3d003e Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Mon, 3 Aug 2026 11:50:26 +0800 Subject: [PATCH 3/6] style(llm): ruff format openai.py --- src/memos/llms/openai.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/memos/llms/openai.py b/src/memos/llms/openai.py index e4c45eca3..cf5302552 100644 --- a/src/memos/llms/openai.py +++ b/src/memos/llms/openai.py @@ -204,7 +204,9 @@ def generate(self, messages: MessageList, **kwargs) -> str: "tools": kwargs.get("tools", NOT_GIVEN), "extra_body": kwargs.get("extra_body", self.config.extra_body), } - enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None)) + enable_thinking = kwargs.get( + "enable_thinking", getattr(self.config, "enable_thinking", None) + ) if enable_thinking is not None: request_body["enable_thinking"] = enable_thinking response = self.client.chat.completions.create(**request_body) @@ -236,7 +238,9 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non "top_p": kwargs.get("top_p", self.config.top_p), "extra_body": kwargs.get("extra_body", self.config.extra_body), } - enable_thinking = kwargs.get("enable_thinking", getattr(self.config, "enable_thinking", None)) + enable_thinking = kwargs.get( + "enable_thinking", getattr(self.config, "enable_thinking", None) + ) if enable_thinking is not None: request_body["enable_thinking"] = enable_thinking response = self.client.chat.completions.create(**request_body) From 333852d7cee9b9866e12eb66b5181f2ff4a28949 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 5 Aug 2026 13:24:39 +0800 Subject: [PATCH 4/6] test(llm): align enable-thinking config coverage --- tests/configs/test_llm.py | 2 ++ tests/llms/test_enable_thinking.py | 1 - 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/configs/test_llm.py b/tests/configs/test_llm.py index d1507e389..bc036fdb8 100644 --- a/tests/configs/test_llm.py +++ b/tests/configs/test_llm.py @@ -57,6 +57,7 @@ def test_openai_llm_config(): "remove_think_prefix", "extra_body", "default_headers", + "enable_thinking", "backup_client", "backup_api_key", "backup_api_base", @@ -159,6 +160,7 @@ def test_minimax_llm_config(): "remove_think_prefix", "extra_body", "default_headers", + "enable_thinking", "backup_client", "backup_api_key", "backup_api_base", diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py index be3441faa..0ad34e5f3 100644 --- a/tests/llms/test_enable_thinking.py +++ b/tests/llms/test_enable_thinking.py @@ -6,7 +6,6 @@ def _make_config(**overrides): defaults = { - "provider": "openai", "api_key": "test-key", "model_name_or_path": "gpt-4o", } From 355d758335b6e6c2463ac40ecf3841ab4b4ef3d4 Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Tue, 11 Aug 2026 17:24:09 +0800 Subject: [PATCH 5/6] fix(llm): pass thinking flag via extra body --- src/memos/configs/llm.py | 6 ++ src/memos/llms/openai.py | 53 +++++------ tests/llms/test_enable_thinking.py | 143 +++++++++++++++++++++++++++-- 3 files changed, 164 insertions(+), 38 deletions(-) diff --git a/src/memos/configs/llm.py b/src/memos/configs/llm.py index 627a7daed..ef441b37f 100644 --- a/src/memos/configs/llm.py +++ b/src/memos/configs/llm.py @@ -96,6 +96,12 @@ class AzureLLMConfig(BaseLLMConfig): description="API version for Azure OpenAI", ) api_key: str = Field(..., description="API key for Azure OpenAI") + extra_body: Any = Field(default=None, description="Extra request body parameters") + enable_thinking: bool | None = Field( + default=None, + description="Enable/disable thinking mode for models that support it. " + "When None (default), the provider's default behavior is preserved.", + ) class AzureResponsesLLMConfig(BaseLLMConfig): diff --git a/src/memos/llms/openai.py b/src/memos/llms/openai.py index cf5302552..d01c56726 100644 --- a/src/memos/llms/openai.py +++ b/src/memos/llms/openai.py @@ -2,6 +2,7 @@ import time from collections.abc import Generator +from typing import Any import openai @@ -19,6 +20,13 @@ logger = get_logger(__name__) +def _merge_enable_thinking(extra_body: Any, enable_thinking: bool | None) -> Any: + """Merge provider-specific thinking control into the SDK's extra request body.""" + if enable_thinking is None: + return extra_body + return {**(extra_body or {}), "enable_thinking": enable_thinking} + + class OpenAILLM(BaseLLM): """OpenAI LLM class via openai.chat.completions.create.""" @@ -62,18 +70,19 @@ def _parse_response(self, response) -> str: return response_content or "" def _build_request_body(self, messages: MessageList, **kwargs) -> dict: + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) + extra_body = _merge_enable_thinking( + kwargs.get("extra_body", self.config.extra_body), enable_thinking + ) request_body = { "model": kwargs.get("model_name_or_path", self.config.model_name_or_path), "messages": messages, "temperature": kwargs.get("temperature", self.config.temperature), "max_tokens": kwargs.get("max_tokens", self.config.max_tokens), "top_p": kwargs.get("top_p", self.config.top_p), - "extra_body": kwargs.get("extra_body", self.config.extra_body), + "extra_body": extra_body, "tools": kwargs.get("tools", NOT_GIVEN), } - enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) - if enable_thinking is not None: - request_body["enable_thinking"] = enable_thinking return request_body @timed_with_status( @@ -128,20 +137,8 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non logger.info("stream api not support tools") return - request_body = { - "model": self.config.model_name_or_path, - "messages": messages, - "stream": True, - "temperature": kwargs.get("temperature", self.config.temperature), - "max_tokens": kwargs.get("max_tokens", self.config.max_tokens), - "top_p": kwargs.get("top_p", self.config.top_p), - "extra_body": kwargs.get("extra_body", self.config.extra_body), - "tools": kwargs.get("tools", NOT_GIVEN), - } - - enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) - if enable_thinking is not None: - request_body["enable_thinking"] = enable_thinking + request_body = self._build_request_body(messages, **kwargs) + request_body["stream"] = True logger.info(f"OpenAI LLM Stream Request body: {request_body}") response = self.client.chat.completions.create(**request_body) @@ -195,6 +192,7 @@ def __init__(self, config: AzureLLMConfig): def generate(self, messages: MessageList, **kwargs) -> str: """Generate a response from Azure OpenAI LLM.""" + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) request_body = { "model": self.config.model_name_or_path, "messages": messages, @@ -202,13 +200,10 @@ def generate(self, messages: MessageList, **kwargs) -> str: "max_tokens": kwargs.get("max_tokens", self.config.max_tokens), "top_p": kwargs.get("top_p", self.config.top_p), "tools": kwargs.get("tools", NOT_GIVEN), - "extra_body": kwargs.get("extra_body", self.config.extra_body), + "extra_body": _merge_enable_thinking( + kwargs.get("extra_body", self.config.extra_body), enable_thinking + ), } - enable_thinking = kwargs.get( - "enable_thinking", getattr(self.config, "enable_thinking", None) - ) - if enable_thinking is not None: - request_body["enable_thinking"] = enable_thinking response = self.client.chat.completions.create(**request_body) logger.info(f"Response from Azure OpenAI: {response.model_dump_json()}") if not response.choices: @@ -229,6 +224,7 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non logger.info("stream api not support tools") return + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) request_body = { "model": self.config.model_name_or_path, "messages": messages, @@ -236,13 +232,10 @@ def generate_stream(self, messages: MessageList, **kwargs) -> Generator[str, Non "temperature": kwargs.get("temperature", self.config.temperature), "max_tokens": kwargs.get("max_tokens", self.config.max_tokens), "top_p": kwargs.get("top_p", self.config.top_p), - "extra_body": kwargs.get("extra_body", self.config.extra_body), + "extra_body": _merge_enable_thinking( + kwargs.get("extra_body", self.config.extra_body), enable_thinking + ), } - enable_thinking = kwargs.get( - "enable_thinking", getattr(self.config, "enable_thinking", None) - ) - if enable_thinking is not None: - request_body["enable_thinking"] = enable_thinking response = self.client.chat.completions.create(**request_body) reasoning_started = False diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py index 0ad34e5f3..46f3c5063 100644 --- a/tests/llms/test_enable_thinking.py +++ b/tests/llms/test_enable_thinking.py @@ -1,7 +1,12 @@ -"""Tests for enable_thinking parameter in OpenAILLM.""" +"""Tests for enable_thinking parameter in OpenAI-compatible LLMs.""" -from memos.configs.llm import OpenAILLMConfig -from memos.llms.openai import OpenAILLM +import json + +import httpx +import openai + +from memos.configs.llm import AzureLLMConfig, OpenAILLMConfig +from memos.llms.openai import AzureLLM, OpenAILLM def _make_config(**overrides): @@ -26,6 +31,14 @@ def test_enable_thinking_false(self): config = _make_config(enable_thinking=False) assert config.enable_thinking is False + def test_azure_enable_thinking_can_be_set(self): + config = AzureLLMConfig( + api_key="test-key", + model_name_or_path="test-model", + enable_thinking=True, + ) + assert config.enable_thinking is True + class TestEnableThinkingInRequest: def test_build_request_body_without_enable_thinking(self): @@ -34,7 +47,7 @@ def test_build_request_body_without_enable_thinking(self): embedder.config = config body = embedder._build_request_body([{"role": "user", "content": "hi"}]) - assert "enable_thinking" not in body + assert body["extra_body"] is None def test_build_request_body_with_enable_thinking_from_config(self): config = _make_config(enable_thinking=True) @@ -42,7 +55,7 @@ def test_build_request_body_with_enable_thinking_from_config(self): embedder.config = config body = embedder._build_request_body([{"role": "user", "content": "hi"}]) - assert body["enable_thinking"] is True + assert body["extra_body"]["enable_thinking"] is True def test_build_request_body_with_enable_thinking_from_kwargs(self): config = _make_config(enable_thinking=True) @@ -52,7 +65,7 @@ def test_build_request_body_with_enable_thinking_from_kwargs(self): body = embedder._build_request_body( [{"role": "user", "content": "hi"}], enable_thinking=False ) - assert body["enable_thinking"] is False + assert body["extra_body"]["enable_thinking"] is False def test_build_request_body_with_enable_thinking_false(self): config = _make_config(enable_thinking=False) @@ -60,7 +73,7 @@ def test_build_request_body_with_enable_thinking_false(self): embedder.config = config body = embedder._build_request_body([{"role": "user", "content": "hi"}]) - assert body["enable_thinking"] is False + assert body["extra_body"]["enable_thinking"] is False def test_build_request_body_preserves_other_params(self): config = _make_config(enable_thinking=True, temperature=0.5, max_tokens=100) @@ -68,7 +81,121 @@ def test_build_request_body_preserves_other_params(self): embedder.config = config body = embedder._build_request_body([{"role": "user", "content": "hi"}]) - assert body["enable_thinking"] is True + assert body["extra_body"]["enable_thinking"] is True assert body["temperature"] == 0.5 assert body["max_tokens"] == 100 assert body["model"] == "gpt-4o" + + def test_build_request_body_preserves_existing_extra_body(self): + config = _make_config( + enable_thinking=False, + extra_body={"chat_template_kwargs": {"foo": "bar"}}, + ) + llm = OpenAILLM.__new__(OpenAILLM) + llm.config = config + + body = llm._build_request_body([{"role": "user", "content": "hi"}]) + + assert body["extra_body"] == { + "chat_template_kwargs": {"foo": "bar"}, + "enable_thinking": False, + } + + +class TestEnableThinkingWithRealSDK: + @staticmethod + def _make_llm(handler, *, enable_thinking): + config = _make_config( + api_base="http://test.local/v1", + enable_thinking=enable_thinking, + ) + llm = OpenAILLM(config) + llm.client = openai.Client( + api_key="test-key", + base_url="http://test.local/v1", + http_client=httpx.Client(transport=httpx.MockTransport(handler)), + ) + return llm + + def test_generate_serializes_enable_thinking_in_http_body(self): + captured_body = {} + + def handler(request): + captured_body.update(json.loads(request.content)) + return httpx.Response( + 200, + json={ + "id": "chatcmpl-test", + "object": "chat.completion", + "created": 0, + "model": "test-model", + "choices": [ + { + "index": 0, + "finish_reason": "stop", + "message": {"role": "assistant", "content": "ok"}, + } + ], + }, + ) + + llm = self._make_llm(handler, enable_thinking=True) + + assert llm.generate([{"role": "user", "content": "hi"}]) == "ok" + assert captured_body["enable_thinking"] is True + + def test_generate_stream_serializes_override_in_http_body(self): + captured_body = {} + + def handler(request): + captured_body.update(json.loads(request.content)) + return httpx.Response( + 200, + headers={"content-type": "text/event-stream"}, + content=b"data: [DONE]\n\n", + ) + + llm = self._make_llm(handler, enable_thinking=True) + + assert ( + list(llm.generate_stream([{"role": "user", "content": "hi"}], enable_thinking=False)) + == [] + ) + assert captured_body["enable_thinking"] is False + + def test_azure_generate_serializes_enable_thinking_in_http_body(self): + captured_body = {} + + def handler(request): + captured_body.update(json.loads(request.content)) + return httpx.Response( + 200, + json={ + "id": "chatcmpl-test", + "object": "chat.completion", + "created": 0, + "model": "test-model", + "choices": [ + { + "index": 0, + "finish_reason": "stop", + "message": {"role": "assistant", "content": "ok"}, + } + ], + }, + ) + + llm = AzureLLM.__new__(AzureLLM) + llm.config = AzureLLMConfig( + api_key="test-key", + model_name_or_path="test-model", + enable_thinking=False, + ) + llm.client = openai.Client( + api_key="test-key", + base_url="http://test.local/v1", + http_client=httpx.Client(transport=httpx.MockTransport(handler)), + ) + + assert llm.generate([{"role": "user", "content": "hi"}]) == "ok" + assert captured_body["enable_thinking"] is False From 1e3411f7b1e59e77381149135e6b63d6a6ade076 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 12 Aug 2026 10:17:29 +0800 Subject: [PATCH 6/6] test(llm): cover Azure thinking stream body Exercise the independent Azure streaming request-body path with a per-call enable_thinking override and an existing vendor extra_body option. Test: .venv/bin/python -m pytest tests/llms/test_enable_thinking.py tests/configs/test_llm.py -q\nTest: .venv/bin/python -m pytest tests/llms -q --ignore=tests/llms/test_hf.py\nTest: .venv/bin/python -m pytest tests/configs -q --- tests/llms/test_enable_thinking.py | 36 ++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/tests/llms/test_enable_thinking.py b/tests/llms/test_enable_thinking.py index 46f3c5063..7b7e42402 100644 --- a/tests/llms/test_enable_thinking.py +++ b/tests/llms/test_enable_thinking.py @@ -199,3 +199,39 @@ def handler(request): assert llm.generate([{"role": "user", "content": "hi"}]) == "ok" assert captured_body["enable_thinking"] is False + + def test_azure_generate_stream_serializes_override_in_http_body(self): + captured_body = {} + + def handler(request): + captured_body.update(json.loads(request.content)) + return httpx.Response( + 200, + headers={"content-type": "text/event-stream"}, + content=b"data: [DONE]\n\n", + ) + + llm = AzureLLM.__new__(AzureLLM) + llm.config = AzureLLMConfig( + api_key="test-key", + model_name_or_path="test-model", + enable_thinking=True, + ) + llm.client = openai.Client( + api_key="test-key", + base_url="http://test.local/v1", + http_client=httpx.Client(transport=httpx.MockTransport(handler)), + ) + + assert ( + list( + llm.generate_stream( + [{"role": "user", "content": "hi"}], + enable_thinking=False, + extra_body={"vendor_option": "keep"}, + ) + ) + == [] + ) + assert captured_body["enable_thinking"] is False + assert captured_body["vendor_option"] == "keep"