diff --git a/src/memos/configs/llm.py b/src/memos/configs/llm.py index 81f7038fa..ef441b37f 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", @@ -91,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 9a29ea68a..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.""" @@ -61,6 +69,22 @@ def _parse_response(self, response) -> str: return reasoning_content + (response_content or "") 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": extra_body, + "tools": kwargs.get("tools", NOT_GIVEN), + } + return request_body + @timed_with_status( log_prefix="OpenAI LLM", log_extra_args=lambda self, messages, **kwargs: { @@ -70,15 +94,7 @@ def _parse_response(self, response) -> str: ) def generate(self, messages: MessageList, **kwargs) -> str: """Generate a response from OpenAI LLM, optionally overriding generation params.""" - 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), - "tools": kwargs.get("tools", NOT_GIVEN), - } + request_body = self._build_request_body(messages, **kwargs) start_time = time.perf_counter() logger.info(f"OpenAI LLM Request body: {request_body}") @@ -121,16 +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), - } + 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) @@ -184,15 +192,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), - ) + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) + 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": _merge_enable_thinking( + kwargs.get("extra_body", self.config.extra_body), 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 +224,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), - ) + enable_thinking = kwargs.get("enable_thinking", self.config.enable_thinking) + 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": _merge_enable_thinking( + kwargs.get("extra_body", self.config.extra_body), enable_thinking + ), + } + response = self.client.chat.completions.create(**request_body) reasoning_started = False 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 new file mode 100644 index 000000000..7b7e42402 --- /dev/null +++ b/tests/llms/test_enable_thinking.py @@ -0,0 +1,237 @@ +"""Tests for enable_thinking parameter in OpenAI-compatible LLMs.""" + +import json + +import httpx +import openai + +from memos.configs.llm import AzureLLMConfig, OpenAILLMConfig +from memos.llms.openai import AzureLLM, OpenAILLM + + +def _make_config(**overrides): + defaults = { + "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 + + 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): + config = _make_config() + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body([{"role": "user", "content": "hi"}]) + assert body["extra_body"] is None + + 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["extra_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["extra_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["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) + embedder = OpenAILLM.__new__(OpenAILLM) + embedder.config = config + + body = embedder._build_request_body([{"role": "user", "content": "hi"}]) + 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 + + 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"