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 01/17] 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 02/17] 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 03/17] 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 04/17] 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 ca3c2332d4b6b12f22784d05d37ed4ac9c8add9c Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Tue, 28 Jul 2026 23:06:28 +0800 Subject: [PATCH 05/17] fix: UniversalAPIEmbedder now passes embedding_dims to API calls Closes #2177 The UniversalAPIEmbedder previously silently ignored the embedding_dims config field when making embeddings.create() calls. This caused models like text-embedding-3-large to always return the full default dimension embedding, making it impossible to use the dimensions parameter for reduced-dimensional embeddings. Changes: - Added _build_embedding_kwargs() helper that conditionally includes the 'dimensions' parameter when embedding_dims is set - Extracted _call_embeddings_api() method that handles both primary and backup client paths with unified dimension support - Added graceful fallback: if the API rejects the dimensions parameter (e.g. older model versions), automatically retries without it - Both primary and backup client paths now use the same dimensions-aware calling logic - Added comprehensive unit tests in test_universal_api.py Test: python3 -m py_compile src/memos/embedders/universal_api.py Test: python3 -m py_compile tests/embedders/test_universal_api.py --- src/memos/embedders/universal_api.py | 87 ++++++++----- tests/embedders/test_universal_api.py | 172 ++++++++++++++++++-------- 2 files changed, 170 insertions(+), 89 deletions(-) diff --git a/src/memos/embedders/universal_api.py b/src/memos/embedders/universal_api.py index 24a022eae..579b9bc93 100644 --- a/src/memos/embedders/universal_api.py +++ b/src/memos/embedders/universal_api.py @@ -56,29 +56,56 @@ def __init__(self, config: UniversalAPIEmbedderConfig): else None, ) + @staticmethod + def _build_embedding_kwargs(model: str, texts: list[str], embedding_dims: int | None) -> dict: + kwargs = {"model": model, "input": texts} + if embedding_dims is not None: + kwargs["dimensions"] = embedding_dims + return kwargs + + def _call_embeddings_api( + self, client, model: str, texts: list[str], timeout: int + ) -> list[list[float]]: + embedding_dims = getattr(self.config, "embedding_dims", None) + kwargs = self._build_embedding_kwargs(model, texts, embedding_dims) + + try: + response = asyncio.run( + asyncio.wait_for( + client.embeddings.create(**kwargs), + timeout=timeout, + ) + ) + return [r.embedding for r in response.data] + except Exception as e: + if embedding_dims is not None: + logger.warning( + "Embeddings request with dimensions=%d failed error_type=%s; " + "retrying without dimensions", + embedding_dims, + type(e).__name__, + ) + fallback_kwargs = self._build_embedding_kwargs(model, texts, None) + response = asyncio.run( + asyncio.wait_for( + client.embeddings.create(**fallback_kwargs), + timeout=timeout, + ) + ) + return [r.embedding for r in response.data] + raise + @log_embedding_call def embed(self, texts: list[str]) -> list[list[float]]: if isinstance(texts, str): texts = [texts] - # Sanitize Unicode to prevent encoding errors with emoji/surrogates texts = [_sanitize_unicode(t) for t in texts] - # Truncate texts if max_tokens is configured texts = self._truncate_texts(texts) if self.provider == "openai" or self.provider == "azure": + timeout = int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5)) try: - - async def _create_embeddings(): - return self.client.embeddings.create( - model=getattr(self.config, "model_name_or_path", "text-embedding-3-large"), - input=texts, - ) - - response = asyncio.run( - asyncio.wait_for( - _create_embeddings(), timeout=int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5)) - ) - ) - return [r.embedding for r in response.data] + model = getattr(self.config, "model_name_or_path", "text-embedding-3-large") + return self._call_embeddings_api(self.client, model, texts, timeout) except Exception as e: if self.use_backup_client: logger.warning( @@ -86,26 +113,18 @@ async def _create_embeddings(): type(e).__name__, ) try: - - async def _create_embeddings_backup(): - return self.backup_client.embeddings.create( - model=getattr( - self.config, - "backup_model_name_or_path", - "text-embedding-3-large", - ), - input=texts, - ) - - response = asyncio.run( - asyncio.wait_for( - _create_embeddings_backup(), - timeout=int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5)), - ) + backup_model = getattr( + self.config, + "backup_model_name_or_path", + "text-embedding-3-large", + ) + return self._call_embeddings_api( + self.backup_client, backup_model, texts, timeout ) - return [r.embedding for r in response.data] - except Exception as e: - raise ValueError(f"Backup embeddings request ended with error: {e}") from e + except Exception as e_backup: + raise ValueError( + f"Backup embeddings request ended with error: {e_backup}" + ) from e_backup else: raise ValueError(f"Embeddings request ended with error: {e}") from e else: diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py index fd61b3e9a..4568049f0 100644 --- a/tests/embedders/test_universal_api.py +++ b/tests/embedders/test_universal_api.py @@ -1,75 +1,137 @@ -import unittest +"""Tests for UniversalAPIEmbedder.""" -from unittest.mock import MagicMock, patch +from types import SimpleNamespace +from unittest.mock import patch + +import pytest from memos.configs.embedder import UniversalAPIEmbedderConfig from memos.embedders.universal_api import UniversalAPIEmbedder -class TestUniversalAPIEmbedder(unittest.TestCase): - @patch("memos.embedders.universal_api.OpenAIClient") - def test_embed_single_text(self, mock_openai_client): - """Test embedding a single text with OpenAI provider.""" - # Mock the embeddings.create return value - mock_response = MagicMock() - mock_response.data = [MagicMock(embedding=[0.1, 0.2, 0.3, 0.4])] - mock_openai_client.return_value.embeddings.create.return_value = mock_response - - config = UniversalAPIEmbedderConfig( - provider="openai", - api_key="fake-api-key", - base_url="https://api.openai.com/v1", - model_name_or_path="text-embedding-3-large", - ) +def _make_config(**overrides): + defaults = { + "provider": "openai", + "api_key": "test-key", + "model_name_or_path": "text-embedding-3-large", + "embedding_dims": None, + } + defaults.update(overrides) + return UniversalAPIEmbedderConfig(**defaults) - embedder = UniversalAPIEmbedder(config) - text = ["Test input for embedding."] - result = embedder.embed(text) - # Assert OpenAIClient was created with proper args - mock_openai_client.assert_called_once_with( - api_key="fake-api-key", base_url="https://api.openai.com/v1", default_headers=None +class TestUniversalAPIEmbedderDimensions: + def test_build_embedding_kwargs_no_dims(self): + kwargs = UniversalAPIEmbedder._build_embedding_kwargs( + "text-embedding-3-large", ["hello"], None ) + assert kwargs == {"model": "text-embedding-3-large", "input": ["hello"]} + assert "dimensions" not in kwargs - # Assert embeddings.create called with correct params - embedder.client.embeddings.create.assert_called_once_with( - model="text-embedding-3-large", - input=text, + def test_build_embedding_kwargs_with_dims(self): + kwargs = UniversalAPIEmbedder._build_embedding_kwargs( + "text-embedding-3-large", ["hello"], 256 ) + assert kwargs == { + "model": "text-embedding-3-large", + "input": ["hello"], + "dimensions": 256, + } + + def test_build_embedding_kwargs_zero_dims(self): + kwargs = UniversalAPIEmbedder._build_embedding_kwargs( + "text-embedding-3-large", ["hello"], 0 + ) + assert kwargs["dimensions"] == 0 - self.assertEqual(len(result[0]), 4) - - @patch("memos.embedders.universal_api.OpenAIClient") - def test_embed_batch_text(self, mock_openai_client): - """Test embedding multiple texts at once with OpenAI provider.""" - # Mock response for multiple texts - mock_response = MagicMock() - mock_response.data = [ - MagicMock(embedding=[0.1, 0.2]), - MagicMock(embedding=[0.3, 0.4]), - MagicMock(embedding=[0.5, 0.6]), + @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") + def test_embed_passes_embedding_dims_to_api(self, mock_call): + mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]] + config = _make_config(embedding_dims=256) + embedder = UniversalAPIEmbedder(config) + embedder.embed(["hello"]) + mock_call.assert_called_once() + call_kwargs = mock_call.call_args[0] + assert call_kwargs[2] == ["hello"] + assert call_kwargs[1] == "text-embedding-3-large" + + @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") + def test_embed_without_dims_does_not_pass_dimensions(self, mock_call): + mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]] + config = _make_config(embedding_dims=None) + embedder = UniversalAPIEmbedder(config) + embedder.embed(["hello"]) + mock_call.assert_called_once() + + @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") + def test_embed_with_backup_client(self, mock_call): + mock_call.side_effect = [ + ValueError("primary failed"), + [[0.1, 0.2] for _ in ["hello"]], ] - mock_openai_client.return_value.embeddings.create.return_value = mock_response - - config = UniversalAPIEmbedderConfig( - provider="openai", - api_key="fake-api-key", - base_url="https://api.openai.com/v1", - model_name_or_path="text-embedding-3-large", + config = _make_config( + embedding_dims=256, + backup_client=True, + backup_api_key="backup-key", + backup_base_url="https://api.example.com", + backup_model_name_or_path="text-embedding-3-small", ) + embedder = UniversalAPIEmbedder(config) + result = embedder.embed(["hello"]) + assert result == [[0.1, 0.2]] + assert mock_call.call_count == 2 + + @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") + def test_embed_raises_when_no_backup(self, mock_call): + mock_call.side_effect = ValueError("primary failed") + config = _make_config(embedding_dims=256) + embedder = UniversalAPIEmbedder(config) + with pytest.raises(ValueError, match="Embeddings request ended with error"): + embedder.embed(["hello"]) + +class TestUniversalAPIEmbedderFallback: + def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self): + config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) - texts = ["First text.", "Second text.", "Third text."] - result = embedder.embed(texts) - embedder.client.embeddings.create.assert_called_once_with( - model="text-embedding-3-large", - input=texts, - ) + mock_client = SimpleNamespace() + call_count = [0] + + def mock_create(**kwargs): + call_count[0] += 1 + if kwargs.get("dimensions") is not None: + raise Exception("dimensions not supported") + return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])]) + + mock_client.embeddings = SimpleNamespace(create=mock_create) + + with patch("memos.embedders.universal_api.asyncio.run") as mock_run: + mock_run.side_effect = lambda x: x # pass-through + result = embedder._call_embeddings_api( + mock_client, "text-embedding-3-large", ["hello"], 5 + ) + + assert call_count[0] == 2 + assert result == [[0.1, 0.2]] + + def test_call_embeddings_api_no_fallback_when_dims_not_set(self): + config = _make_config(embedding_dims=None) + embedder = UniversalAPIEmbedder(config) + + mock_client = SimpleNamespace() + + def mock_create(**kwargs): + if kwargs.get("dimensions") is not None: + raise AssertionError("dimensions should not be passed when embedding_dims is None") + return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])]) - self.assertEqual(len(result), 3) - self.assertEqual(result[0], [0.1, 0.2]) + mock_client.embeddings = SimpleNamespace(create=mock_create) + with patch("memos.embedders.universal_api.asyncio.run") as mock_run: + mock_run.side_effect = lambda x: x + result = embedder._call_embeddings_api( + mock_client, "text-embedding-3-large", ["hello"], 5 + ) -if __name__ == "__main__": - unittest.main() + assert result == [[0.1]] From 8fca0cea0ace00ddd7866bed1324ec2bc634bc5f Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Fri, 31 Jul 2026 10:04:31 +0800 Subject: [PATCH 06/17] fix(test): use asyncio.wait_for passthrough instead of asyncio.run mock for universal_api fallback tests --- tests/embedders/test_universal_api.py | 80 +++++++++++++++++---------- 1 file changed, 51 insertions(+), 29 deletions(-) diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py index 4568049f0..18cab8dd2 100644 --- a/tests/embedders/test_universal_api.py +++ b/tests/embedders/test_universal_api.py @@ -1,7 +1,9 @@ """Tests for UniversalAPIEmbedder.""" +import asyncio + from types import SimpleNamespace -from unittest.mock import patch +from unittest.mock import MagicMock, patch import pytest @@ -9,6 +11,10 @@ from memos.embedders.universal_api import UniversalAPIEmbedder +class _DimensionsUnsupportedError(Exception): + """Raised by the mock backend when dimensions are rejected.""" + + def _make_config(**overrides): defaults = { "provider": "openai", @@ -44,32 +50,50 @@ def test_build_embedding_kwargs_zero_dims(self): ) assert kwargs["dimensions"] == 0 - @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") - def test_embed_passes_embedding_dims_to_api(self, mock_call): - mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]] + @patch("memos.embedders.universal_api.OpenAIClient") + def test_embed_passes_embedding_dims_to_api(self, mock_openai_client): + mock_response = MagicMock() + mock_response.data = [MagicMock(embedding=[0.1, 0.2])] + mock_openai_client.return_value.embeddings.create.return_value = mock_response + config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) embedder.embed(["hello"]) - mock_call.assert_called_once() - call_kwargs = mock_call.call_args[0] - assert call_kwargs[2] == ["hello"] - assert call_kwargs[1] == "text-embedding-3-large" - - @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") - def test_embed_without_dims_does_not_pass_dimensions(self, mock_call): - mock_call.return_value = [[0.1, 0.2] for _ in ["hello"]] + + _, kwargs = mock_openai_client.return_value.embeddings.create.call_args + assert kwargs.get("dimensions") == 256 + + @patch("memos.embedders.universal_api.OpenAIClient") + def test_embed_without_dims_does_not_pass_dimensions(self, mock_openai_client): + mock_response = MagicMock() + mock_response.data = [MagicMock(embedding=[0.1, 0.2])] + mock_openai_client.return_value.embeddings.create.return_value = mock_response + config = _make_config(embedding_dims=None) embedder = UniversalAPIEmbedder(config) embedder.embed(["hello"]) - mock_call.assert_called_once() - - @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") - def test_embed_with_backup_client(self, mock_call): - mock_call.side_effect = [ - ValueError("primary failed"), - [[0.1, 0.2] for _ in ["hello"]], - ] + + _, kwargs = mock_openai_client.return_value.embeddings.create.call_args + assert "dimensions" not in kwargs + + @patch("memos.embedders.universal_api.OpenAIClient") + def test_embed_with_backup_client(self, mock_openai_client): + primary_client = MagicMock() + primary_client.embeddings.create.side_effect = ValueError("down") + backup_response = MagicMock() + backup_response.data = [MagicMock(embedding=[0.1, 0.2])] + backup_client = MagicMock() + backup_client.embeddings.create.return_value = backup_response + + def client_factory(api_key, **kwargs): + if api_key == "primary": + return primary_client + return backup_client + + mock_openai_client.side_effect = client_factory + config = _make_config( + api_key="primary", embedding_dims=256, backup_client=True, backup_api_key="backup-key", @@ -79,11 +103,11 @@ def test_embed_with_backup_client(self, mock_call): embedder = UniversalAPIEmbedder(config) result = embedder.embed(["hello"]) assert result == [[0.1, 0.2]] - assert mock_call.call_count == 2 + assert backup_client.embeddings.create.call_count == 1 - @patch.object(UniversalAPIEmbedder, "_call_embeddings_api") - def test_embed_raises_when_no_backup(self, mock_call): - mock_call.side_effect = ValueError("primary failed") + @patch("memos.embedders.universal_api.OpenAIClient") + def test_embed_raises_when_no_backup(self, mock_openai_client): + mock_openai_client.return_value.embeddings.create.side_effect = ValueError("primary failed") config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) with pytest.raises(ValueError, match="Embeddings request ended with error"): @@ -101,13 +125,12 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self): def mock_create(**kwargs): call_count[0] += 1 if kwargs.get("dimensions") is not None: - raise Exception("dimensions not supported") + raise _DimensionsUnsupportedError("dimensions not supported") return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])]) mock_client.embeddings = SimpleNamespace(create=mock_create) - with patch("memos.embedders.universal_api.asyncio.run") as mock_run: - mock_run.side_effect = lambda x: x # pass-through + with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro): result = embedder._call_embeddings_api( mock_client, "text-embedding-3-large", ["hello"], 5 ) @@ -128,8 +151,7 @@ def mock_create(**kwargs): mock_client.embeddings = SimpleNamespace(create=mock_create) - with patch("memos.embedders.universal_api.asyncio.run") as mock_run: - mock_run.side_effect = lambda x: x + with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro): result = embedder._call_embeddings_api( mock_client, "text-embedding-3-large", ["hello"], 5 ) From c30f5fe2483040e1c4c0c9c1b80ef8b1e4e3a3d4 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Mon, 3 Aug 2026 11:52:43 +0800 Subject: [PATCH 07/17] test(embedder): use AsyncMock for embeddings.create so asyncio.wait_for can await it UniversalAPIEmbedder now awaits client.embeddings.create() via asyncio.wait_for, so the mock must be an async function (AsyncMock) rather than a plain MagicMock. Introduce _awaitable_response/_mock_embedding_response helpers and patch embeddings.create at the instance level instead of relying on the default MagicMock return-value. --- tests/embedders/test_universal_api.py | 63 +++++++++++++++++++-------- 1 file changed, 44 insertions(+), 19 deletions(-) diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py index 18cab8dd2..259959134 100644 --- a/tests/embedders/test_universal_api.py +++ b/tests/embedders/test_universal_api.py @@ -3,7 +3,7 @@ import asyncio from types import SimpleNamespace -from unittest.mock import MagicMock, patch +from unittest.mock import AsyncMock, MagicMock, patch import pytest @@ -26,6 +26,26 @@ def _make_config(**overrides): return UniversalAPIEmbedderConfig(**defaults) +def _mock_embedding_response(vectors_per_text=1, dims=2): + """Build a MagicMock that mimics openai's embeddings response.""" + response = MagicMock() + response.data = [MagicMock(embedding=[0.1 * (i + 1)] * dims) for i in range(vectors_per_text)] + return response + + +def _awaitable_response(response): + """Wrap a MagicMock response so it can be returned by AsyncMock. + + ``asyncio.wait_for`` awaits its coroutine argument, so the + ``embeddings.create`` mock must be an async function (AsyncMock). + """ + + async def _call(**kwargs): + return response + + return AsyncMock(side_effect=_call) + + class TestUniversalAPIEmbedderDimensions: def test_build_embedding_kwargs_no_dims(self): kwargs = UniversalAPIEmbedder._build_embedding_kwargs( @@ -52,38 +72,38 @@ def test_build_embedding_kwargs_zero_dims(self): @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_passes_embedding_dims_to_api(self, mock_openai_client): - mock_response = MagicMock() - mock_response.data = [MagicMock(embedding=[0.1, 0.2])] - mock_openai_client.return_value.embeddings.create.return_value = mock_response + response = _mock_embedding_response(vectors_per_text=1, dims=2) + mock_create = _awaitable_response(response) + mock_openai_client.return_value.embeddings.create = mock_create config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) embedder.embed(["hello"]) - _, kwargs = mock_openai_client.return_value.embeddings.create.call_args + _, kwargs = mock_create.call_args assert kwargs.get("dimensions") == 256 @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_without_dims_does_not_pass_dimensions(self, mock_openai_client): - mock_response = MagicMock() - mock_response.data = [MagicMock(embedding=[0.1, 0.2])] - mock_openai_client.return_value.embeddings.create.return_value = mock_response + response = _mock_embedding_response(vectors_per_text=1, dims=2) + mock_create = _awaitable_response(response) + mock_openai_client.return_value.embeddings.create = mock_create config = _make_config(embedding_dims=None) embedder = UniversalAPIEmbedder(config) embedder.embed(["hello"]) - _, kwargs = mock_openai_client.return_value.embeddings.create.call_args + _, kwargs = mock_create.call_args assert "dimensions" not in kwargs @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_with_backup_client(self, mock_openai_client): primary_client = MagicMock() - primary_client.embeddings.create.side_effect = ValueError("down") - backup_response = MagicMock() - backup_response.data = [MagicMock(embedding=[0.1, 0.2])] + primary_client.embeddings.create = AsyncMock(side_effect=ValueError("down")) + backup_response = _mock_embedding_response(vectors_per_text=1, dims=2) + backup_create = _awaitable_response(backup_response) backup_client = MagicMock() - backup_client.embeddings.create.return_value = backup_response + backup_client.embeddings.create = backup_create def client_factory(api_key, **kwargs): if api_key == "primary": @@ -103,11 +123,14 @@ def client_factory(api_key, **kwargs): embedder = UniversalAPIEmbedder(config) result = embedder.embed(["hello"]) assert result == [[0.1, 0.2]] - assert backup_client.embeddings.create.call_count == 1 + assert backup_create.await_count == 1 @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_raises_when_no_backup(self, mock_openai_client): - mock_openai_client.return_value.embeddings.create.side_effect = ValueError("primary failed") + primary_client = MagicMock() + primary_client.embeddings.create = AsyncMock(side_effect=ValueError("primary failed")) + mock_openai_client.return_value = primary_client + config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) with pytest.raises(ValueError, match="Embeddings request ended with error"): @@ -121,12 +144,13 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self): mock_client = SimpleNamespace() call_count = [0] + ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])]) - def mock_create(**kwargs): + async def mock_create(**kwargs): call_count[0] += 1 if kwargs.get("dimensions") is not None: raise _DimensionsUnsupportedError("dimensions not supported") - return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])]) + return ok_response mock_client.embeddings = SimpleNamespace(create=mock_create) @@ -143,11 +167,12 @@ def test_call_embeddings_api_no_fallback_when_dims_not_set(self): embedder = UniversalAPIEmbedder(config) mock_client = SimpleNamespace() + ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])]) - def mock_create(**kwargs): + async def mock_create(**kwargs): if kwargs.get("dimensions") is not None: raise AssertionError("dimensions should not be passed when embedding_dims is None") - return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])]) + return ok_response mock_client.embeddings = SimpleNamespace(create=mock_create) From b98b8e02d1603944ae9d0cc6f48a8094dfefc6b6 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 5 Aug 2026 13:26:19 +0800 Subject: [PATCH 08/17] test(embedder): await fallback API mocks correctly --- tests/embedders/test_universal_api.py | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py index 259959134..e0fb53f39 100644 --- a/tests/embedders/test_universal_api.py +++ b/tests/embedders/test_universal_api.py @@ -1,7 +1,5 @@ """Tests for UniversalAPIEmbedder.""" -import asyncio - from types import SimpleNamespace from unittest.mock import AsyncMock, MagicMock, patch @@ -29,7 +27,10 @@ def _make_config(**overrides): def _mock_embedding_response(vectors_per_text=1, dims=2): """Build a MagicMock that mimics openai's embeddings response.""" response = MagicMock() - response.data = [MagicMock(embedding=[0.1 * (i + 1)] * dims) for i in range(vectors_per_text)] + response.data = [ + MagicMock(embedding=[0.1 * (dimension + 1) for dimension in range(dims)]) + for _ in range(vectors_per_text) + ] return response @@ -154,10 +155,7 @@ async def mock_create(**kwargs): mock_client.embeddings = SimpleNamespace(create=mock_create) - with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro): - result = embedder._call_embeddings_api( - mock_client, "text-embedding-3-large", ["hello"], 5 - ) + result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) assert call_count[0] == 2 assert result == [[0.1, 0.2]] @@ -176,9 +174,6 @@ async def mock_create(**kwargs): mock_client.embeddings = SimpleNamespace(create=mock_create) - with patch.object(asyncio, "wait_for", side_effect=lambda coro, timeout: coro): - result = embedder._call_embeddings_api( - mock_client, "text-embedding-3-large", ["hello"], 5 - ) + result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) assert result == [[0.1]] From ab322aa2841a72b08176d3263ea2ff3dd77a00ba Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 5 Aug 2026 13:48:38 +0800 Subject: [PATCH 09/17] test(embedder): isolate Ark factory tests from optional SDK --- tests/embedders/test_ark.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/embedders/test_ark.py b/tests/embedders/test_ark.py index 08c23aae6..991d173bd 100644 --- a/tests/embedders/test_ark.py +++ b/tests/embedders/test_ark.py @@ -7,8 +7,9 @@ class TestEmbedderFactory(unittest.TestCase): + @patch.object(ArkEmbedder, "__init__", return_value=None) @patch.object(ArkEmbedder, "embed") - def test_embed_single_text(self, mock_embed): + def test_embed_single_text(self, mock_embed, _mock_init): """Test embedding a single text.""" mock_embed.return_value = [[0.1, 0.2, 0.3, 0.4, 0.5, 0.6]] @@ -30,8 +31,9 @@ def test_embed_single_text(self, mock_embed): mock_embed.assert_called_once_with([text]) self.assertEqual(len(result[0]), 6) + @patch.object(ArkEmbedder, "__init__", return_value=None) @patch.object(ArkEmbedder, "embed") - def test_embed_batch_text(self, mock_embed): + def test_embed_batch_text(self, mock_embed, _mock_init): """Test embedding multiple texts at once.""" mock_embed.return_value = [ [0.1, 0.2, 0.3, 0.4, 0.5, 0.6], From ddb60d6475144ae58fe0ed1d00344d46e99714ac Mon Sep 17 00:00:00 2001 From: JiataiWang Date: Wed, 5 Aug 2026 18:10:29 -0700 Subject: [PATCH 10/17] fix(llm): preserve all vllm stream chunks --- src/memos/llms/vllm.py | 16 +++++++---- tests/llms/test_vllm.py | 61 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 6 deletions(-) create mode 100644 tests/llms/test_vllm.py diff --git a/src/memos/llms/vllm.py b/src/memos/llms/vllm.py index 0efead97b..ff3fd41d5 100644 --- a/src/memos/llms/vllm.py +++ b/src/memos/llms/vllm.py @@ -1,5 +1,6 @@ import json +from collections.abc import Generator from typing import Any, cast import openai @@ -152,7 +153,7 @@ def _messages_to_prompt(self, messages: list[MessageDict]) -> str: prompt_parts.append(f"{role.capitalize()}: {content}") return "\n".join(prompt_parts) - def generate_stream(self, messages: list[MessageDict], **kwargs): + def generate_stream(self, messages: list[MessageDict], **kwargs) -> Generator[str, None, None]: """ Generate a response from the model using streaming. Yields content chunks as they are received. @@ -185,11 +186,14 @@ def generate_stream(self, messages: list[MessageDict], **kwargs): reasoning_started = True yield delta.reasoning - if hasattr(delta, "content") and delta.content: - if reasoning_started and not self.config.remove_think_prefix: - yield "" - reasoning_started = False - yield delta.content + if hasattr(delta, "content") and delta.content: + if reasoning_started and not self.config.remove_think_prefix: + yield "" + reasoning_started = False + yield delta.content + + if reasoning_started and not self.config.remove_think_prefix: + yield "" else: raise RuntimeError("API client is not available") diff --git a/tests/llms/test_vllm.py b/tests/llms/test_vllm.py new file mode 100644 index 000000000..24dfe27c2 --- /dev/null +++ b/tests/llms/test_vllm.py @@ -0,0 +1,61 @@ +import unittest + +from types import SimpleNamespace +from unittest.mock import MagicMock + +from memos.configs.llm import VLLMLLMConfig +from memos.llms.vllm import VLLMLLM + + +class TestVLLMLLMGenerateStream(unittest.TestCase): + def setUp(self): + config = VLLMLLMConfig( + model_name_or_path="test-model", + api_key="test-key", + remove_think_prefix=False, + ) + self.llm = VLLMLLM(config) + self.messages = [{"role": "user", "content": "Think, then answer"}] + + @staticmethod + def make_chunk(**delta_fields): + delta = SimpleNamespace(**delta_fields) + return SimpleNamespace(choices=[SimpleNamespace(delta=delta)]) + + def generate_chunks(self, stream_chunks): + self.llm.client.chat.completions.create = MagicMock(return_value=iter(stream_chunks)) + return list(self.llm.generate_stream(self.messages)) + + def test_yields_every_content_chunk_after_reasoning(self): + stream_chunks = [ + self.make_chunk(reasoning="Considering..."), + self.make_chunk(content="Hello"), + self.make_chunk(content=", "), + self.make_chunk(content="world!"), + ] + + self.assertEqual( + self.generate_chunks(stream_chunks), + ["", "Considering...", "", "Hello", ", ", "world!"], + ) + + def test_empty_or_choiceless_stream_returns_no_chunks(self): + streams = { + "empty": [], + "choices_empty": [SimpleNamespace(choices=[])], + } + + for name, stream_chunks in streams.items(): + with self.subTest(name=name): + self.assertEqual(self.generate_chunks(stream_chunks), []) + + def test_reasoning_only_stream_closes_think_block(self): + stream_chunks = [ + self.make_chunk(reasoning="First thought. "), + self.make_chunk(reasoning="Second thought."), + ] + + self.assertEqual( + self.generate_chunks(stream_chunks), + ["", "First thought. ", "Second thought.", ""], + ) From 9ee2711c9f1e27d0734aafc6a3818f3a1b2b6a59 Mon Sep 17 00:00:00 2001 From: JiataiWang Date: Mon, 10 Aug 2026 01:58:51 -0700 Subject: [PATCH 11/17] test(llm): cover vllm streams without think tags --- tests/llms/test_vllm.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/llms/test_vllm.py b/tests/llms/test_vllm.py index 24dfe27c2..830196f48 100644 --- a/tests/llms/test_vllm.py +++ b/tests/llms/test_vllm.py @@ -59,3 +59,20 @@ def test_reasoning_only_stream_closes_think_block(self): self.generate_chunks(stream_chunks), ["", "First thought. ", "Second thought.", ""], ) + + def test_remove_think_prefix_omits_tags(self): + self.llm.config.remove_think_prefix = True + streams = { + "reasoning_then_content": ( + [self.make_chunk(reasoning="Thinking."), self.make_chunk(content="Answer")], + ["Thinking.", "Answer"], + ), + "reasoning_only": ( + [self.make_chunk(reasoning="Thinking.")], + ["Thinking."], + ), + } + + for name, (stream_chunks, expected) in streams.items(): + with self.subTest(name=name): + self.assertEqual(self.generate_chunks(stream_chunks), expected) From 0f5ed1b17f3672915da3bc65bd4ee24f5353cdc3 Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Tue, 11 Aug 2026 14:43:02 +0800 Subject: [PATCH 12/17] fix: handle embedding dimensions with sync client --- src/memos/api/config.py | 1 + src/memos/embedders/universal_api.py | 52 ++++++------ tests/embedders/test_universal_api.py | 115 ++++++++++++++++---------- 3 files changed, 101 insertions(+), 67 deletions(-) diff --git a/src/memos/api/config.py b/src/memos/api/config.py index 43ad586dd..7b450181a 100644 --- a/src/memos/api/config.py +++ b/src/memos/api/config.py @@ -622,6 +622,7 @@ def get_embedder_config() -> dict[str, Any]: "provider": os.getenv("MOS_EMBEDDER_PROVIDER", "openai"), "api_key": os.getenv("MOS_EMBEDDER_API_KEY", "sk-xxxx"), "model_name_or_path": os.getenv("MOS_EMBEDDER_MODEL", "text-embedding-3-large"), + "embedding_dims": int(os.getenv("EMBEDDING_DIMENSION", "1024")), "headers_extra": json.loads(os.getenv("MOS_EMBEDDER_HEADERS_EXTRA", "{}")), "base_url": os.getenv("MOS_EMBEDDER_API_BASE", "http://openai.com"), "backup_client": os.getenv("MOS_EMBEDDER_BACKUP_CLIENT", "false").lower() diff --git a/src/memos/embedders/universal_api.py b/src/memos/embedders/universal_api.py index 579b9bc93..44cc1e3cb 100644 --- a/src/memos/embedders/universal_api.py +++ b/src/memos/embedders/universal_api.py @@ -1,7 +1,7 @@ -import asyncio import os from openai import AzureOpenAI as AzureClient +from openai import BadRequestError from openai import OpenAI as OpenAIClient from memos.configs.embedder import UniversalAPIEmbedderConfig @@ -63,6 +63,21 @@ def _build_embedding_kwargs(model: str, texts: list[str], embedding_dims: int | kwargs["dimensions"] = embedding_dims return kwargs + @staticmethod + def _is_dimensions_unsupported(error: BadRequestError) -> bool: + message = str(error).lower() + unsupported_markers = ( + "dimensions is not supported", + "dimensions not supported", + "does not support dimensions", + "unsupported parameter: dimensions", + "unknown parameter: dimensions", + "does not support matryoshka", + "changing output dimensions is unsupported", + "changing output dimensions will lead", + ) + return any(marker in message for marker in unsupported_markers) + def _call_embeddings_api( self, client, model: str, texts: list[str], timeout: int ) -> list[list[float]]: @@ -70,30 +85,19 @@ def _call_embeddings_api( kwargs = self._build_embedding_kwargs(model, texts, embedding_dims) try: - response = asyncio.run( - asyncio.wait_for( - client.embeddings.create(**kwargs), - timeout=timeout, - ) + response = client.embeddings.create(**kwargs, timeout=timeout) + except BadRequestError as error: + if embedding_dims is None or not self._is_dimensions_unsupported(error): + raise + + logger.warning( + "Embedding provider rejected dimensions=%d; retrying without dimensions", + embedding_dims, ) - return [r.embedding for r in response.data] - except Exception as e: - if embedding_dims is not None: - logger.warning( - "Embeddings request with dimensions=%d failed error_type=%s; " - "retrying without dimensions", - embedding_dims, - type(e).__name__, - ) - fallback_kwargs = self._build_embedding_kwargs(model, texts, None) - response = asyncio.run( - asyncio.wait_for( - client.embeddings.create(**fallback_kwargs), - timeout=timeout, - ) - ) - return [r.embedding for r in response.data] - raise + fallback_kwargs = self._build_embedding_kwargs(model, texts, None) + response = client.embeddings.create(**fallback_kwargs, timeout=timeout) + + return [item.embedding for item in response.data] @log_embedding_call def embed(self, texts: list[str]) -> list[list[float]]: diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py index e0fb53f39..394770787 100644 --- a/tests/embedders/test_universal_api.py +++ b/tests/embedders/test_universal_api.py @@ -1,18 +1,17 @@ """Tests for UniversalAPIEmbedder.""" from types import SimpleNamespace -from unittest.mock import AsyncMock, MagicMock, patch +from unittest.mock import MagicMock, patch +import httpx import pytest +from openai import APITimeoutError, BadRequestError + from memos.configs.embedder import UniversalAPIEmbedderConfig from memos.embedders.universal_api import UniversalAPIEmbedder -class _DimensionsUnsupportedError(Exception): - """Raised by the mock backend when dimensions are rejected.""" - - def _make_config(**overrides): defaults = { "provider": "openai", @@ -34,17 +33,10 @@ def _mock_embedding_response(vectors_per_text=1, dims=2): return response -def _awaitable_response(response): - """Wrap a MagicMock response so it can be returned by AsyncMock. - - ``asyncio.wait_for`` awaits its coroutine argument, so the - ``embeddings.create`` mock must be an async function (AsyncMock). - """ - - async def _call(**kwargs): - return response - - return AsyncMock(side_effect=_call) +def _bad_request_error(message: str) -> BadRequestError: + request = httpx.Request("POST", "https://api.example.com/v1/embeddings") + response = httpx.Response(400, request=request) + return BadRequestError(message, response=response, body={"error": {"message": message}}) class TestUniversalAPIEmbedderDimensions: @@ -74,35 +66,39 @@ def test_build_embedding_kwargs_zero_dims(self): @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_passes_embedding_dims_to_api(self, mock_openai_client): response = _mock_embedding_response(vectors_per_text=1, dims=2) - mock_create = _awaitable_response(response) + mock_create = MagicMock(return_value=response) mock_openai_client.return_value.embeddings.create = mock_create config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) - embedder.embed(["hello"]) + result = embedder.embed(["hello"]) _, kwargs = mock_create.call_args assert kwargs.get("dimensions") == 256 + assert kwargs.get("timeout") == 5 + assert result == [[0.1, 0.2]] @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_without_dims_does_not_pass_dimensions(self, mock_openai_client): response = _mock_embedding_response(vectors_per_text=1, dims=2) - mock_create = _awaitable_response(response) + mock_create = MagicMock(return_value=response) mock_openai_client.return_value.embeddings.create = mock_create config = _make_config(embedding_dims=None) embedder = UniversalAPIEmbedder(config) - embedder.embed(["hello"]) + result = embedder.embed(["hello"]) _, kwargs = mock_create.call_args assert "dimensions" not in kwargs + assert kwargs.get("timeout") == 5 + assert result == [[0.1, 0.2]] @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_with_backup_client(self, mock_openai_client): primary_client = MagicMock() - primary_client.embeddings.create = AsyncMock(side_effect=ValueError("down")) + primary_client.embeddings.create = MagicMock(side_effect=ValueError("down")) backup_response = _mock_embedding_response(vectors_per_text=1, dims=2) - backup_create = _awaitable_response(backup_response) + backup_create = MagicMock(return_value=backup_response) backup_client = MagicMock() backup_client.embeddings.create = backup_create @@ -124,12 +120,13 @@ def client_factory(api_key, **kwargs): embedder = UniversalAPIEmbedder(config) result = embedder.embed(["hello"]) assert result == [[0.1, 0.2]] - assert backup_create.await_count == 1 + assert primary_client.embeddings.create.call_count == 1 + assert backup_create.call_count == 1 @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_raises_when_no_backup(self, mock_openai_client): primary_client = MagicMock() - primary_client.embeddings.create = AsyncMock(side_effect=ValueError("primary failed")) + primary_client.embeddings.create = MagicMock(side_effect=ValueError("primary failed")) mock_openai_client.return_value = primary_client config = _make_config(embedding_dims=256) @@ -143,37 +140,69 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self): config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) - mock_client = SimpleNamespace() - call_count = [0] ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])]) - - async def mock_create(**kwargs): - call_count[0] += 1 - if kwargs.get("dimensions") is not None: - raise _DimensionsUnsupportedError("dimensions not supported") - return ok_response - - mock_client.embeddings = SimpleNamespace(create=mock_create) + mock_create = MagicMock( + side_effect=[ + _bad_request_error("dimensions is not supported by this model"), + ok_response, + ] + ) + mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) - assert call_count[0] == 2 + assert mock_create.call_count == 2 + assert mock_create.call_args_list[0].kwargs["dimensions"] == 256 + assert "dimensions" not in mock_create.call_args_list[1].kwargs + assert all(call.kwargs["timeout"] == 5 for call in mock_create.call_args_list) assert result == [[0.1, 0.2]] + def test_call_embeddings_api_does_not_fallback_on_timeout(self): + config = _make_config(embedding_dims=256) + embedder = UniversalAPIEmbedder(config) + request = httpx.Request("POST", "https://api.example.com/v1/embeddings") + mock_create = MagicMock(side_effect=APITimeoutError(request=request)) + mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) + + with pytest.raises(APITimeoutError): + embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) + + assert mock_create.call_count == 1 + + def test_call_embeddings_api_does_not_fallback_on_unrelated_bad_request(self): + config = _make_config(embedding_dims=256) + embedder = UniversalAPIEmbedder(config) + mock_create = MagicMock(side_effect=_bad_request_error("input must not be empty")) + mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) + + with pytest.raises(BadRequestError, match="input must not be empty"): + embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) + + assert mock_create.call_count == 1 + + def test_call_embeddings_api_does_not_fallback_on_invalid_dimensions(self): + config = _make_config(embedding_dims=0) + embedder = UniversalAPIEmbedder(config) + mock_create = MagicMock( + side_effect=_bad_request_error("dimensions must be greater than zero") + ) + mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) + + with pytest.raises(BadRequestError, match="dimensions must be greater than zero"): + embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) + + assert mock_create.call_count == 1 + def test_call_embeddings_api_no_fallback_when_dims_not_set(self): config = _make_config(embedding_dims=None) embedder = UniversalAPIEmbedder(config) - mock_client = SimpleNamespace() ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1])]) - - async def mock_create(**kwargs): - if kwargs.get("dimensions") is not None: - raise AssertionError("dimensions should not be passed when embedding_dims is None") - return ok_response - - mock_client.embeddings = SimpleNamespace(create=mock_create) + mock_create = MagicMock(return_value=ok_response) + mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) + assert "dimensions" not in mock_create.call_args.kwargs + assert mock_create.call_args.kwargs["timeout"] == 5 assert result == [[0.1]] From c826169da57ff20b03b0155dba4006d2494a7e03 Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Tue, 11 Aug 2026 15:45:55 +0800 Subject: [PATCH 13/17] fix: make cachetools a core dependency --- poetry.lock | 7 +++---- pyproject.toml | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/poetry.lock b/poetry.lock index b09a72d70..915204888 100644 --- a/poetry.lock +++ b/poetry.lock @@ -174,10 +174,9 @@ transformers = ">=3.0.0" name = "cachetools" version = "6.2.1" description = "Extensible memoizing collections and decorators" -optional = true +optional = false python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"all\"" files = [ {file = "cachetools-6.2.1-py3-none-any.whl", hash = "sha256:09868944b6dde876dfd44e1d47e18484541eaf12f26f29b7af91b26cc892d701"}, {file = "cachetools-6.2.1.tar.gz", hash = "sha256:3f391e4bd8f8bf0931169baf7456cc822705f4e2a31f840d218f445b9a854201"}, @@ -6636,7 +6635,7 @@ cffi = {version = ">=1.11", markers = "platform_python_implementation == \"PyPy\ cffi = ["cffi (>=1.11)"] [extras] -all = ["alibabacloud-oss-v2", "cachetools", "chonkie", "datasketch", "jieba", "langchain-text-splitters", "markitdown", "neo4j", "nltk", "pika", "pymilvus", "pymysql", "qdrant-client", "rake-nltk", "rank-bm25", "redis", "schedule", "sentence-transformers", "tavily-python", "torch", "volcengine-python-sdk"] +all = ["alibabacloud-oss-v2", "chonkie", "datasketch", "jieba", "langchain-text-splitters", "markitdown", "neo4j", "nltk", "pika", "pymilvus", "pymysql", "qdrant-client", "rake-nltk", "rank-bm25", "redis", "schedule", "sentence-transformers", "tavily-python", "torch", "volcengine-python-sdk"] mem-reader = ["chonkie", "langchain-text-splitters", "markitdown"] mem-scheduler = ["pika", "redis"] mem-user = ["pymysql"] @@ -6648,4 +6647,4 @@ tree-mem = ["neo4j", "schedule"] [metadata] lock-version = "2.1" python-versions = ">=3.10,<4.0" -content-hash = "cfab703c19f5f87caf537b68d30174695c44c6fc228e42c2c8e71b00b81f5790" +content-hash = "0e134b24ee590115ac3270590a002fa7d54f4e4d83a9eabf53715ec03716e081" diff --git a/pyproject.toml b/pyproject.toml index 3eaf00ca3..0e572b103 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -48,6 +48,7 @@ dependencies = [ "python-dateutil (>=2.9.0.post0,<3.0.0)", "prometheus-client (>=0.23.1,<0.24.0)", "concurrent-log-handler (>=0.9.28,<1.0.0)", # Process-safe rotating file handler + "cachetools (>=6.0.0)", # Embedding request caching ] [project.urls] @@ -128,7 +129,6 @@ all = [ "datasketch (>=1.6.5,<2.0.0)", "jieba (>=0.38.1,<0.42.1)", "rank-bm25 (>=0.2.2)", - "cachetools (>=6.0.0)", # NOT exist in the above optional groups # Because they are either huge-size dependencies or infrequently used dependencies. # We kindof don't want users to install them. 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 14/17] 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 88a515aaea5ff2ee1623e5f3093631b0e219f322 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 12 Aug 2026 10:00:27 +0800 Subject: [PATCH 15/17] fix(embedder): detect structured dimensions errors Recognize provider errors that identify an unsupported dimensions parameter through structured param/code fields while preserving invalid-value failures. Add regression coverage for structured fallback and API dimension configuration. Test: .venv/bin/python -m pytest tests/embedders/test_universal_api.py -q\nTest: .venv/bin/python -m pytest tests/api -q\nTest: .venv/bin/python -m pytest tests/embedders -q --ignore=tests/embedders/test_ark.py --- src/memos/embedders/universal_api.py | 15 +++++++- tests/embedders/test_universal_api.py | 49 +++++++++++++++++++++++++-- 2 files changed, 60 insertions(+), 4 deletions(-) diff --git a/src/memos/embedders/universal_api.py b/src/memos/embedders/universal_api.py index 44cc1e3cb..22962e728 100644 --- a/src/memos/embedders/universal_api.py +++ b/src/memos/embedders/universal_api.py @@ -65,7 +65,20 @@ def _build_embedding_kwargs(model: str, texts: list[str], embedding_dims: int | @staticmethod def _is_dimensions_unsupported(error: BadRequestError) -> bool: - message = str(error).lower() + body = getattr(error, "body", None) + details = body.get("error", body) if isinstance(body, dict) else {} + if isinstance(details, dict): + param = str(details.get("param") or "").lower() + code = str(details.get("code") or "").lower() + if param == "dimensions" and any( + marker in code for marker in ("unsupported", "unknown", "unrecognized") + ): + return True + + messages = [str(error)] + if isinstance(details, dict) and isinstance(details.get("message"), str): + messages.append(details["message"]) + message = " ".join(messages).lower() unsupported_markers = ( "dimensions is not supported", "dimensions not supported", diff --git a/tests/embedders/test_universal_api.py b/tests/embedders/test_universal_api.py index 394770787..7d897ebb2 100644 --- a/tests/embedders/test_universal_api.py +++ b/tests/embedders/test_universal_api.py @@ -33,10 +33,17 @@ def _mock_embedding_response(vectors_per_text=1, dims=2): return response -def _bad_request_error(message: str) -> BadRequestError: +def _bad_request_error( + message: str, *, param: str | None = None, code: str | None = None +) -> BadRequestError: request = httpx.Request("POST", "https://api.example.com/v1/embeddings") response = httpx.Response(400, request=request) - return BadRequestError(message, response=response, body={"error": {"message": message}}) + details = {"message": message} + if param is not None: + details["param"] = param + if code is not None: + details["code"] = code + return BadRequestError(message, response=response, body={"error": details}) class TestUniversalAPIEmbedderDimensions: @@ -63,6 +70,16 @@ def test_build_embedding_kwargs_zero_dims(self): ) assert kwargs["dimensions"] == 0 + def test_api_config_maps_embedding_dimension(self, monkeypatch): + from memos.api.config import APIConfig + + monkeypatch.setenv("MOS_EMBEDDER_BACKEND", "universal_api") + monkeypatch.setenv("EMBEDDING_DIMENSION", "1536") + + config = APIConfig.get_embedder_config() + + assert config["config"]["embedding_dims"] == 1536 + @patch("memos.embedders.universal_api.OpenAIClient") def test_embed_passes_embedding_dims_to_api(self, mock_openai_client): response = _mock_embedding_response(vectors_per_text=1, dims=2) @@ -157,6 +174,28 @@ def test_call_embeddings_api_falls_back_when_dimensions_not_supported(self): assert all(call.kwargs["timeout"] == 5 for call in mock_create.call_args_list) assert result == [[0.1, 0.2]] + def test_call_embeddings_api_falls_back_on_structured_dimensions_error(self): + config = _make_config(embedding_dims=256) + embedder = UniversalAPIEmbedder(config) + ok_response = SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2])]) + mock_create = MagicMock( + side_effect=[ + _bad_request_error( + "Bad request", + param="dimensions", + code="unsupported_parameter", + ), + ok_response, + ] + ) + mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) + + result = embedder._call_embeddings_api(mock_client, "text-embedding-3-large", ["hello"], 5) + + assert mock_create.call_count == 2 + assert "dimensions" not in mock_create.call_args_list[1].kwargs + assert result == [[0.1, 0.2]] + def test_call_embeddings_api_does_not_fallback_on_timeout(self): config = _make_config(embedding_dims=256) embedder = UniversalAPIEmbedder(config) @@ -184,7 +223,11 @@ def test_call_embeddings_api_does_not_fallback_on_invalid_dimensions(self): config = _make_config(embedding_dims=0) embedder = UniversalAPIEmbedder(config) mock_create = MagicMock( - side_effect=_bad_request_error("dimensions must be greater than zero") + side_effect=_bad_request_error( + "dimensions must be greater than zero", + param="dimensions", + code="invalid_value", + ) ) mock_client = SimpleNamespace(embeddings=SimpleNamespace(create=mock_create)) 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 16/17] 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" From 50e719fa847835cf82d1147fb14eb424d60e55ff Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 14 Aug 2026 02:34:53 +0000 Subject: [PATCH 17/17] chore: change version number to v2.0.30 --- pyproject.toml | 2 +- src/memos/__init__.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 73cc31fb2..0acbcc296 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ ############################################################################## name = "MemoryOS" -version = "2.0.29" +version = "2.0.30" description = "Intelligence Begins with Memory" license = {text = "Apache-2.0"} readme = "README.md" diff --git a/src/memos/__init__.py b/src/memos/__init__.py index f334d1582..0f6dec9f7 100644 --- a/src/memos/__init__.py +++ b/src/memos/__init__.py @@ -1,4 +1,4 @@ -__version__ = "2.0.29" +__version__ = "2.0.30" from memos.configs.mem_cube import GeneralMemCubeConfig from memos.configs.mem_os import MOSConfig