MemoryOS 2.0.27__tar.gz → 2.0.30__tar.gz

{memoryos-2.0.27 → memoryos-2.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MemoryOS
-Version: 2.0.27
+Version: 2.0.30
 Summary: Intelligence Begins with Memory
 License: Apache-2.0
 License-File: LICENSE
@@ -30,7 +30,7 @@ Provides-Extra: tavily
 Provides-Extra: tree-mem
 Requires-Dist: alibabacloud-oss-v2 (>=1.2.2,<1.2.3) ; extra == "all"
 Requires-Dist: alibabacloud-oss-v2 (>=1.2.2,<1.2.3) ; extra == "skill-mem"
-Requires-Dist: cachetools (>=6.0.0) ; extra == "all"
+Requires-Dist: cachetools (>=6.0.0)
 Requires-Dist: chonkie (>=1.0.7,<2.0.0) ; extra == "all"
 Requires-Dist: chonkie (>=1.0.7,<2.0.0) ; extra == "mem-reader"
 Requires-Dist: concurrent-log-handler (>=0.9.28,<1.0.0)

{memoryos-2.0.27 → memoryos-2.0.30}/pyproject.toml

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "2.0.27"
+version = "2.0.30"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"
@@ -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.

{memoryos-2.0.27 → memoryos-2.0.30}/src/memos/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.27"
+__version__ = "2.0.30"
 
 from memos.configs.mem_cube import GeneralMemCubeConfig
 from memos.configs.mem_os import MOSConfig

{memoryos-2.0.27 → memoryos-2.0.30}/src/memos/api/config.py

@@ -622,6 +622,7 @@ class APIConfig:
                     "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()

{memoryos-2.0.27 → memoryos-2.0.30}/src/memos/chunkers/base.py

@@ -1,4 +1,5 @@
 import re
+import uuid
 
 from abc import ABC, abstractmethod
 
@@ -17,6 +18,12 @@ class Chunk:
 class BaseChunker(ABC):
     """Base class for all text chunkers."""
 
+    _URL_PATTERN = r'https?://[^\s<>"{}|\\^`\[\]]+'
+    _URL_PLACEHOLDER_PREFIX = "__URL_"
+    _URL_PLACEHOLDER_PATTERN = re.compile(
+        rf"{re.escape(_URL_PLACEHOLDER_PREFIX)}(?:[0-9a-f]+_)?\d+__"
+    )
+
     @abstractmethod
     def __init__(self, config: BaseChunkerConfig):
         """Initialize the chunker with the given configuration."""
@@ -25,6 +32,17 @@ class BaseChunker(ABC):
     def chunk(self, text: str) -> list[Chunk]:
         """Chunk the given text into smaller chunks."""
 
+    @classmethod
+    def _new_url_placeholder_prefix(cls, text: str) -> str:
+        """Return a placeholder namespace that cannot collide with the input."""
+        if cls._URL_PLACEHOLDER_PREFIX not in text:
+            return cls._URL_PLACEHOLDER_PREFIX
+
+        while True:
+            placeholder_prefix = f"{cls._URL_PLACEHOLDER_PREFIX}{uuid.uuid4().hex[:8]}_"
+            if placeholder_prefix not in text:
+                return placeholder_prefix
+
     def protect_urls(self, text: str) -> tuple[str, dict[str, str]]:
         """
         Protect URLs in text from being split during chunking.
@@ -35,16 +53,16 @@ class BaseChunker(ABC):
         Returns:
             tuple: (Text with URLs replaced by placeholders, URL mapping dictionary)
         """
-        url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+'
-        url_map = {}
+        url_map: dict[str, str] = {}
+        placeholder_prefix = self._new_url_placeholder_prefix(text)
 
         def replace_url(match):
             url = match.group(0)
-            placeholder = f"__URL_{len(url_map)}__"
+            placeholder = f"{placeholder_prefix}{len(url_map)}__"
             url_map[placeholder] = url
             return placeholder
 
-        protected_text = re.sub(url_pattern, replace_url, text)
+        protected_text = re.sub(self._URL_PATTERN, replace_url, text)
         return protected_text, url_map
 
     def restore_urls(self, text: str, url_map: dict[str, str]) -> str:
@@ -58,8 +76,6 @@ class BaseChunker(ABC):
         Returns:
             str: Text with URLs restored
         """
-        restored_text = text
-        for placeholder, url in url_map.items():
-            restored_text = restored_text.replace(placeholder, url)
-
-        return restored_text
+        return self._URL_PLACEHOLDER_PATTERN.sub(
+            lambda match: url_map.get(match.group(0), match.group(0)), text
+        )

memoryos-2.0.30/src/memos/chunkers/simple_chunker.py

@@ -0,0 +1,113 @@
+from .base import BaseChunker
+
+
+class SimpleTextSplitter(BaseChunker):
+    """Simple text splitter wrapper."""
+
+    def __init__(self, chunk_size: int, chunk_overlap: int):
+        if chunk_size <= 0:
+            raise ValueError("chunk_size must be greater than 0")
+        if chunk_overlap < 0:
+            raise ValueError("chunk_overlap must be non-negative")
+        if chunk_overlap >= chunk_size:
+            raise ValueError("chunk_overlap must be smaller than chunk_size")
+
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+
+    def chunk(self, text: str, **kwargs) -> list[str]:
+        return self._simple_split_text(text, self.chunk_size, self.chunk_overlap)
+
+    @classmethod
+    def _placeholder_spans(
+        cls, protected_text: str, url_map: dict[str, str]
+    ) -> list[tuple[int, int]]:
+        """Return the protected-text ranges occupied by URL placeholders."""
+        return [
+            (match.start(), match.end())
+            for match in cls._URL_PLACEHOLDER_PATTERN.finditer(protected_text)
+            if match.group(0) in url_map
+        ]
+
+    @staticmethod
+    def _align_end_to_placeholder(
+        end: int,
+        start: int,
+        chunk_overlap: int,
+        placeholder_spans: list[tuple[int, int]],
+    ) -> int:
+        """Move a chunk end away from the middle of a URL placeholder."""
+        for placeholder_start, placeholder_end in placeholder_spans:
+            if placeholder_start < end < placeholder_end:
+                if placeholder_start - start > chunk_overlap:
+                    return placeholder_start
+                return placeholder_end
+        return end
+
+    @staticmethod
+    def _align_start_to_placeholder(
+        next_start: int,
+        previous_start: int,
+        placeholder_spans: list[tuple[int, int]],
+    ) -> int:
+        """Keep overlap starts from landing in the middle of a URL placeholder."""
+        for placeholder_start, placeholder_end in placeholder_spans:
+            if placeholder_start < next_start < placeholder_end:
+                if placeholder_start > previous_start:
+                    return placeholder_start
+                return placeholder_end
+        return next_start
+
+    def _simple_split_text(self, text: str, chunk_size: int, chunk_overlap: int) -> list[str]:
+        """
+        Simple text splitter as fallback when langchain is not available.
+
+        Args:
+            text: Text to split
+            chunk_size: Maximum size of chunks
+            chunk_overlap: Overlap between chunks
+
+        Returns:
+            List of text chunks
+        """
+        protected_text, url_map = self.protect_urls(text)
+
+        if not protected_text or len(protected_text) <= chunk_size:
+            chunks = [protected_text] if protected_text.strip() else []
+            return [self.restore_urls(chunk, url_map) for chunk in chunks]
+
+        chunks = []
+        start = 0
+        text_len = len(protected_text)
+        placeholder_spans = self._placeholder_spans(protected_text, url_map)
+
+        while start < text_len:
+            # Calculate end position
+            end = min(start + chunk_size, text_len)
+
+            # If not the last chunk, try to break at a good position
+            if end < text_len:
+                # Try to break at newline, sentence end, or space
+                for separator in ["\n\n", "\n", "。", "！", "？", ". ", "! ", "? ", " "]:
+                    last_sep = protected_text.rfind(separator, start, end)
+                    if last_sep == -1:
+                        continue
+                    split_end = last_sep + len(separator)
+                    if split_end - start > chunk_overlap:
+                        end = split_end
+                        break
+
+                end = self._align_end_to_placeholder(end, start, chunk_overlap, placeholder_spans)
+
+            chunk = protected_text[start:end].strip()
+            if chunk:
+                chunks.append(chunk)
+
+            if end >= text_len:
+                break
+
+            # Move start position with overlap
+            next_start = max(start + 1, end - chunk_overlap)
+            start = self._align_start_to_placeholder(next_start, start, placeholder_spans)
+
+        return [self.restore_urls(chunk, url_map) for chunk in chunks]

{memoryos-2.0.27 → memoryos-2.0.30}/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):

{memoryos-2.0.27 → memoryos-2.0.30}/src/memos/embedders/cache.py

@@ -1,18 +1,23 @@
+from __future__ import annotations
+
 import os
 import threading
 
 from collections import Counter
 from concurrent.futures import Future
-from typing import Any
-
-from cachetools import LRUCache, TTLCache
+from typing import TYPE_CHECKING, Any
 
 from memos.context.context import get_current_trace_id
+from memos.dependency import require_python_package
 from memos.embedders.base import BaseEmbedder
 from memos.exceptions import EmbedderError
 from memos.log import get_logger
 
 
+if TYPE_CHECKING:
+    from cachetools import LRUCache, TTLCache
+
+
 logger = get_logger(__name__)
 
 
@@ -68,9 +73,16 @@ def _env_int(name: str, default: int, minimum: int = 1) -> int:
 class CachingEmbedder(BaseEmbedder):
     """Add exact caches and singleflight coordination to an embedder."""
 
+    @require_python_package(
+        import_name="cachetools",
+        install_command="pip install 'cachetools>=6.0.0'",
+    )
     def __init__(self, backend: BaseEmbedder):
+        from cachetools import LRUCache, TTLCache
+
         self._backend = backend
         self.config = backend.config
+        self._lru_cache_cls: type[LRUCache] = LRUCache
         self._lock = threading.RLock()
         self._inflight: dict[str, Future[CachedVector]] = {}
         self._stats: Counter[str] = Counter()
@@ -196,7 +208,7 @@ class CachingEmbedder(BaseEmbedder):
             return None
         request_cache = self._request_caches.get(request_id)
         if request_cache is None:
-            request_cache = LRUCache(maxsize=self._request_cache_text_limit)
+            request_cache = self._lru_cache_cls(maxsize=self._request_cache_text_limit)
             self._request_caches[request_id] = request_cache
         return request_cache
 

memoryos-2.0.30/src/memos/embedders/universal_api.py

@@ -0,0 +1,148 @@
+import os
+
+from openai import AzureOpenAI as AzureClient
+from openai import BadRequestError
+from openai import OpenAI as OpenAIClient
+
+from memos.configs.embedder import UniversalAPIEmbedderConfig
+from memos.embedders.base import BaseEmbedder, log_embedding_call
+from memos.log import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def _sanitize_unicode(text: str) -> str:
+    """
+    Remove Unicode surrogates and other problematic characters.
+    Surrogates (U+D800-U+DFFF) cause UnicodeEncodeError with some APIs.
+    """
+    try:
+        # Encode with 'surrogatepass' then decode, replacing invalid chars
+        cleaned = text.encode("utf-8", errors="surrogatepass").decode("utf-8", errors="replace")
+        # Replace replacement char with empty string for cleaner output
+        return cleaned.replace("\ufffd", "")
+    except Exception:
+        # Fallback: remove all non-BMP characters
+        return "".join(c for c in text if ord(c) < 0x10000)
+
+
+class UniversalAPIEmbedder(BaseEmbedder):
+    def __init__(self, config: UniversalAPIEmbedderConfig):
+        self.provider = config.provider
+        self.config = config
+
+        if self.provider == "openai":
+            self.client = OpenAIClient(
+                api_key=config.api_key,
+                base_url=config.base_url,
+                default_headers=config.headers_extra if config.headers_extra else None,
+            )
+        elif self.provider == "azure":
+            self.client = AzureClient(
+                azure_endpoint=config.base_url,
+                api_version="2024-03-01-preview",
+                api_key=config.api_key,
+            )
+        else:
+            raise ValueError(f"Embeddings unsupported provider: {self.provider}")
+        self.use_backup_client = config.backup_client
+        if self.use_backup_client:
+            self.backup_client = OpenAIClient(
+                api_key=config.backup_api_key,
+                base_url=config.backup_base_url,
+                default_headers=config.backup_headers_extra
+                if config.backup_headers_extra
+                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
+
+    @staticmethod
+    def _is_dimensions_unsupported(error: BadRequestError) -> bool:
+        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",
+            "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]]:
+        embedding_dims = getattr(self.config, "embedding_dims", None)
+        kwargs = self._build_embedding_kwargs(model, texts, embedding_dims)
+
+        try:
+            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,
+            )
+            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]]:
+        if isinstance(texts, str):
+            texts = [texts]
+        texts = [_sanitize_unicode(t) for t in texts]
+        texts = self._truncate_texts(texts)
+        if self.provider == "openai" or self.provider == "azure":
+            timeout = int(os.getenv("MOS_EMBEDDER_TIMEOUT", 5))
+            try:
+                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(
+                        "Embedding request failed error_type=%s; trying backup client",
+                        type(e).__name__,
+                    )
+                    try:
+                        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
+                        )
+                    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:
+            raise ValueError(f"Embeddings unsupported provider: {self.provider}")

{memoryos-2.0.27 → memoryos-2.0.30}/src/memos/llms/openai.py

@@ -2,6 +2,7 @@ import json
 import time
 
 from collections.abc import Generator
+from typing import Any
 
 import openai
 
@@ -19,6 +20,13 @@ from memos.utils import timed_with_status
 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 @@ class OpenAILLM(BaseLLM):
             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 @@ class OpenAILLM(BaseLLM):
     )
     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 @@ class OpenAILLM(BaseLLM):
             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 @@ class AzureLLM(BaseLLM):
 
     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 @@ class AzureLLM(BaseLLM):
             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
 

{memoryos-2.0.27 → memoryos-2.0.30}/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 @@ class VLLMLLM(BaseLLM):
             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 @@ class VLLMLLM(BaseLLM):
                         reasoning_started = True
                     yield delta.reasoning
 
-            if hasattr(delta, "content") and delta.content:
-                if reasoning_started and not self.config.remove_think_prefix:
-                    yield "</think>"
-                    reasoning_started = False
-                yield delta.content
+                if hasattr(delta, "content") and delta.content:
+                    if reasoning_started and not self.config.remove_think_prefix:
+                        yield "</think>"
+                        reasoning_started = False
+                    yield delta.content
+
+            if reasoning_started and not self.config.remove_think_prefix:
+                yield "</think>"
 
         else:
             raise RuntimeError("API client is not available")