letta-nightly 0.7.7.dev20250430205840__py3-none-any.whl → 0.7.8.dev20250501064110__py3-none-any.whl

letta/server/rest_api/interface.py

@@ -28,7 +28,7 @@ from letta.schemas.letta_message import (
 from letta.schemas.letta_message_content import ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionChunkResponse
-from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
+from letta.server.rest_api.json_parser import OptimisticJSONParser
 from letta.streaming_interface import AgentChunkStreamingInterface
 from letta.streaming_utils import FunctionArgumentsStreamHandler, JSONInnerThoughtsExtractor
 from letta.utils import parse_json
@@ -291,7 +291,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.streaming_chat_completion_json_reader = FunctionArgumentsStreamHandler(json_key=assistant_message_tool_kwarg)
 
         # @matt's changes here, adopting new optimistic json parser
-        self.current_function_arguments = []
+        self.current_function_arguments = ""
         self.optimistic_json_parser = OptimisticJSONParser()
         self.current_json_parse_result = {}
 
@@ -387,7 +387,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
     def stream_start(self):
         """Initialize streaming by activating the generator and clearing any old chunks."""
         self.streaming_chat_completion_mode_function_name = None
-        self.current_function_arguments = []
+        self.current_function_arguments = ""
         self.current_json_parse_result = {}
 
         if not self._active:
@@ -398,7 +398,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
     def stream_end(self):
         """Clean up the stream by deactivating and clearing chunks."""
         self.streaming_chat_completion_mode_function_name = None
-        self.current_function_arguments = []
+        self.current_function_arguments = ""
         self.current_json_parse_result = {}
 
         # if not self.streaming_chat_completion_mode and not self.nonstreaming_legacy_mode:
@@ -609,14 +609,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     # early exit to turn into content mode
                     return None
                 if tool_call.function.arguments:
-                    self.current_function_arguments.append(tool_call.function.arguments)
+                    self.current_function_arguments += tool_call.function.arguments
 
                 # if we're in the middle of parsing a send_message, we'll keep processing the JSON chunks
                 if tool_call.function.arguments and self.streaming_chat_completion_mode_function_name == self.assistant_message_tool_name:
                     # Strip out any extras tokens
                     # In the case that we just have the prefix of something, no message yet, then we should early exit to move to the next chunk
-                    combined_args = "".join(self.current_function_arguments)
-                    parsed_args = self.optimistic_json_parser.parse(combined_args)
+                    parsed_args = self.optimistic_json_parser.parse(self.current_function_arguments)
 
                     if parsed_args.get(self.assistant_message_tool_kwarg) and parsed_args.get(
                         self.assistant_message_tool_kwarg
@@ -686,7 +685,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     # updates_inner_thoughts = ""
                     # else:  # OpenAI
                     # updates_main_json, updates_inner_thoughts = self.function_args_reader.process_fragment(tool_call.function.arguments)
-                    self.current_function_arguments.append(tool_call.function.arguments)
+                    self.current_function_arguments += tool_call.function.arguments
                     updates_main_json, updates_inner_thoughts = self.function_args_reader.process_fragment(tool_call.function.arguments)
 
                     # If we have inner thoughts, we should output them as a chunk
@@ -805,8 +804,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     # TODO: THIS IS HORRIBLE
                                     # TODO: WE USE THE OLD JSON PARSER EARLIER (WHICH DOES NOTHING) AND NOW THE NEW JSON PARSER
                                     # TODO: THIS IS TOTALLY WRONG AND BAD, BUT SAVING FOR A LARGER REWRITE IN THE NEAR FUTURE
-                                    combined_args = "".join(self.current_function_arguments)
-                                    parsed_args = self.optimistic_json_parser.parse(combined_args)
+                                    parsed_args = self.optimistic_json_parser.parse(self.current_function_arguments)
 
                                     if parsed_args.get(self.assistant_message_tool_kwarg) and parsed_args.get(
                                         self.assistant_message_tool_kwarg

letta/server/rest_api/{optimistic_json_parser.py → json_parser.py}

@@ -1,7 +1,43 @@
 import json
+from abc import ABC, abstractmethod
+from typing import Any
 
+from pydantic_core import from_json
 
-class OptimisticJSONParser:
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+class JSONParser(ABC):
+    @abstractmethod
+    def parse(self, input_str: str) -> Any:
+        raise NotImplementedError()
+
+
+class PydanticJSONParser(JSONParser):
+    """
+    https://docs.pydantic.dev/latest/concepts/json/#json-parsing
+    If `strict` is True, we will not allow for partial parsing of JSON.
+
+    Compared with `OptimisticJSONParser`, this parser is more strict.
+    Note: This will not partially parse strings which may be decrease parsing speed for message strings
+    """
+
+    def __init__(self, strict=False):
+        self.strict = strict
+
+    def parse(self, input_str: str) -> Any:
+        if not input_str:
+            return {}
+        try:
+            return from_json(input_str, allow_partial="trailing-strings" if not self.strict else False)
+        except ValueError as e:
+            logger.error(f"Failed to parse JSON: {e}")
+            raise
+
+
+class OptimisticJSONParser(JSONParser):
     """
     A JSON parser that attempts to parse a given string using `json.loads`,
     and if that fails, it parses as much valid JSON as possible while
@@ -13,25 +49,25 @@ class OptimisticJSONParser:
     def __init__(self, strict=False):
         self.strict = strict
         self.parsers = {
-            " ": self.parse_space,
-            "\r": self.parse_space,
-            "\n": self.parse_space,
-            "\t": self.parse_space,
-            "[": self.parse_array,
-            "{": self.parse_object,
-            '"': self.parse_string,
-            "t": self.parse_true,
-            "f": self.parse_false,
-            "n": self.parse_null,
+            " ": self._parse_space,
+            "\r": self._parse_space,
+            "\n": self._parse_space,
+            "\t": self._parse_space,
+            "[": self._parse_array,
+            "{": self._parse_object,
+            '"': self._parse_string,
+            "t": self._parse_true,
+            "f": self._parse_false,
+            "n": self._parse_null,
         }
         # Register number parser for digits and signs
         for char in "0123456789.-":
             self.parsers[char] = self.parse_number
 
         self.last_parse_reminding = None
-        self.on_extra_token = self.default_on_extra_token
+        self.on_extra_token = self._default_on_extra_token
 
-    def default_on_extra_token(self, text, data, reminding):
+    def _default_on_extra_token(self, text, data, reminding):
         print(f"Parsed JSON with extra tokens: {data}, remaining: {reminding}")
 
     def parse(self, input_str):
@@ -45,7 +81,7 @@ class OptimisticJSONParser:
             try:
                 return json.loads(input_str)
             except json.JSONDecodeError as decode_error:
-                data, reminding = self.parse_any(input_str, decode_error)
+                data, reminding = self._parse_any(input_str, decode_error)
                 self.last_parse_reminding = reminding
                 if self.on_extra_token and reminding:
                     self.on_extra_token(input_str, data, reminding)
@@ -53,7 +89,7 @@ class OptimisticJSONParser:
         else:
             return json.loads("{}")
 
-    def parse_any(self, input_str, decode_error):
+    def _parse_any(self, input_str, decode_error):
         """Determine which parser to use based on the first character."""
         if not input_str:
             raise decode_error
@@ -62,11 +98,11 @@ class OptimisticJSONParser:
             raise decode_error
         return parser(input_str, decode_error)
 
-    def parse_space(self, input_str, decode_error):
+    def _parse_space(self, input_str, decode_error):
         """Strip leading whitespace and parse again."""
-        return self.parse_any(input_str.strip(), decode_error)
+        return self._parse_any(input_str.strip(), decode_error)
 
-    def parse_array(self, input_str, decode_error):
+    def _parse_array(self, input_str, decode_error):
         """Parse a JSON array, returning the list and remaining string."""
         # Skip the '['
         input_str = input_str[1:]
@@ -77,7 +113,7 @@ class OptimisticJSONParser:
                 # Skip the ']'
                 input_str = input_str[1:]
                 break
-            value, input_str = self.parse_any(input_str, decode_error)
+            value, input_str = self._parse_any(input_str, decode_error)
             array_values.append(value)
             input_str = input_str.strip()
             if input_str.startswith(","):
@@ -85,7 +121,7 @@ class OptimisticJSONParser:
                 input_str = input_str[1:].strip()
         return array_values, input_str
 
-    def parse_object(self, input_str, decode_error):
+    def _parse_object(self, input_str, decode_error):
         """Parse a JSON object, returning the dict and remaining string."""
         # Skip the '{'
         input_str = input_str[1:]
@@ -96,7 +132,7 @@ class OptimisticJSONParser:
                 # Skip the '}'
                 input_str = input_str[1:]
                 break
-            key, input_str = self.parse_any(input_str, decode_error)
+            key, input_str = self._parse_any(input_str, decode_error)
             input_str = input_str.strip()
 
             if not input_str or input_str[0] == "}":
@@ -113,7 +149,7 @@ class OptimisticJSONParser:
                     input_str = input_str[1:]
                 break
 
-            value, input_str = self.parse_any(input_str, decode_error)
+            value, input_str = self._parse_any(input_str, decode_error)
             obj[key] = value
             input_str = input_str.strip()
             if input_str.startswith(","):
@@ -121,7 +157,7 @@ class OptimisticJSONParser:
                 input_str = input_str[1:].strip()
         return obj, input_str
 
-    def parse_string(self, input_str, decode_error):
+    def _parse_string(self, input_str, decode_error):
         """Parse a JSON string, respecting escaped quotes if present."""
         end = input_str.find('"', 1)
         while end != -1 and input_str[end - 1] == "\\":
@@ -166,19 +202,19 @@ class OptimisticJSONParser:
 
         return num, remainder
 
-    def parse_true(self, input_str, decode_error):
+    def _parse_true(self, input_str, decode_error):
         """Parse a 'true' value."""
         if input_str.startswith(("t", "T")):
             return True, input_str[4:]
         raise decode_error
 
-    def parse_false(self, input_str, decode_error):
+    def _parse_false(self, input_str, decode_error):
         """Parse a 'false' value."""
         if input_str.startswith(("f", "F")):
             return False, input_str[5:]
         raise decode_error
 
-    def parse_null(self, input_str, decode_error):
+    def _parse_null(self, input_str, decode_error):
         """Parse a 'null' value."""
         if input_str.startswith("n"):
             return None, input_str[4:]

letta/server/rest_api/routers/v1/agents.py

@@ -678,7 +678,7 @@ async def send_message_streaming(
     server: SyncServer = Depends(get_letta_server),
     request: LettaStreamingRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
+) -> StreamingResponse | LettaResponse:
     """
     Process a user message and return the agent's response.
     This endpoint accepts a message from a user and processes it through the agent.

letta/server/rest_api/routers/v1/llms.py

@@ -1,6 +1,6 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Query
 
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
@@ -14,10 +14,11 @@ router = APIRouter(prefix="/models", tags=["models", "llms"])
 
 @router.get("/", response_model=List[LLMConfig], operation_id="list_models")
 def list_llm_models(
+    byok_only: Optional[bool] = Query(None),
     server: "SyncServer" = Depends(get_letta_server),
 ):
 
-    models = server.list_llm_models()
+    models = server.list_llm_models(byok_only=byok_only)
     # print(models)
     return models
 

letta/server/rest_api/routers/v1/providers.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
+from letta.schemas.enums import ProviderType
 from letta.schemas.providers import Provider, ProviderCreate, ProviderUpdate
 from letta.server.rest_api.utils import get_letta_server
 
@@ -13,6 +14,8 @@ router = APIRouter(prefix="/providers", tags=["providers"])
 
 @router.get("/", response_model=List[Provider], operation_id="list_providers")
 def list_providers(
+    name: Optional[str] = Query(None),
+    provider_type: Optional[ProviderType] = Query(None),
     after: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     actor_id: Optional[str] = Header(None, alias="user_id"),
@@ -23,7 +26,7 @@ def list_providers(
     """
     try:
         actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        providers = server.provider_manager.list_providers(after=after, limit=limit, actor=actor)
+        providers = server.provider_manager.list_providers(after=after, limit=limit, actor=actor, name=name, provider_type=provider_type)
     except HTTPException:
         raise
     except Exception as e:

letta/server/rest_api/routers/v1/voice.py

@@ -54,8 +54,6 @@ async def create_voice_chat_completions(
         block_manager=server.block_manager,
         passage_manager=server.passage_manager,
         actor=actor,
-        message_buffer_limit=8,
-        message_buffer_min=4,
     )
 
     # Return the streaming generator

letta/server/rest_api/utils.py

@@ -16,6 +16,7 @@ from pydantic import BaseModel
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, FUNC_FAILED_HEARTBEAT_MESSAGE, REQ_HEARTBEAT_MESSAGE
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.message_helper import convert_message_creates_to_messages
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
@@ -143,27 +144,15 @@ def log_error_to_sentry(e):
 def create_input_messages(input_messages: List[MessageCreate], agent_id: str, actor: User) -> List[Message]:
     """
     Converts a user input message into the internal structured format.
+
+    TODO (cliandy): this effectively duplicates the functionality of `convert_message_creates_to_messages`,
+    we should unify this when it's clear what message attributes we need.
     """
-    new_messages = []
-    for input_message in input_messages:
-        # Construct the Message object
-        new_message = Message(
-            id=f"message-{uuid.uuid4()}",
-            role=input_message.role,
-            content=input_message.content,
-            name=input_message.name,
-            otid=input_message.otid,
-            sender_id=input_message.sender_id,
-            organization_id=actor.organization_id,
-            agent_id=agent_id,
-            model=None,
-            tool_calls=None,
-            tool_call_id=None,
-            created_at=get_utc_time(),
-        )
-        new_messages.append(new_message)
 
-    return new_messages
+    messages = convert_message_creates_to_messages(input_messages, agent_id, wrap_user_message=False, wrap_system_message=False)
+    for message in messages:
+        message.organization_id = actor.organization_id
+    return messages
 
 
 def create_letta_messages_from_llm_response(

letta/server/server.py

@@ -268,10 +268,11 @@ class SyncServer(Server):
                     )
 
         # collect providers (always has Letta as a default)
-        self._enabled_providers: List[Provider] = [LettaProvider()]
+        self._enabled_providers: List[Provider] = [LettaProvider(name="letta")]
         if model_settings.openai_api_key:
             self._enabled_providers.append(
                 OpenAIProvider(
+                    name="openai",
                     api_key=model_settings.openai_api_key,
                     base_url=model_settings.openai_api_base,
                 )
@@ -279,12 +280,14 @@ class SyncServer(Server):
         if model_settings.anthropic_api_key:
             self._enabled_providers.append(
                 AnthropicProvider(
+                    name="anthropic",
                     api_key=model_settings.anthropic_api_key,
                 )
             )
         if model_settings.ollama_base_url:
             self._enabled_providers.append(
                 OllamaProvider(
+                    name="ollama",
                     base_url=model_settings.ollama_base_url,
                     api_key=None,
                     default_prompt_formatter=model_settings.default_prompt_formatter,
@@ -293,12 +296,14 @@ class SyncServer(Server):
         if model_settings.gemini_api_key:
             self._enabled_providers.append(
                 GoogleAIProvider(
+                    name="google_ai",
                     api_key=model_settings.gemini_api_key,
                 )
             )
         if model_settings.google_cloud_location and model_settings.google_cloud_project:
             self._enabled_providers.append(
                 GoogleVertexProvider(
+                    name="google_vertex",
                     google_cloud_project=model_settings.google_cloud_project,
                     google_cloud_location=model_settings.google_cloud_location,
                 )
@@ -307,6 +312,7 @@ class SyncServer(Server):
             assert model_settings.azure_api_version, "AZURE_API_VERSION is required"
             self._enabled_providers.append(
                 AzureProvider(
+                    name="azure",
                     api_key=model_settings.azure_api_key,
                     base_url=model_settings.azure_base_url,
                     api_version=model_settings.azure_api_version,
@@ -315,12 +321,14 @@ class SyncServer(Server):
         if model_settings.groq_api_key:
             self._enabled_providers.append(
                 GroqProvider(
+                    name="groq",
                     api_key=model_settings.groq_api_key,
                 )
             )
         if model_settings.together_api_key:
             self._enabled_providers.append(
                 TogetherProvider(
+                    name="together",
                     api_key=model_settings.together_api_key,
                     default_prompt_formatter=model_settings.default_prompt_formatter,
                 )
@@ -329,6 +337,7 @@ class SyncServer(Server):
             # vLLM exposes both a /chat/completions and a /completions endpoint
             self._enabled_providers.append(
                 VLLMCompletionsProvider(
+                    name="vllm",
                     base_url=model_settings.vllm_api_base,
                     default_prompt_formatter=model_settings.default_prompt_formatter,
                 )
@@ -338,12 +347,14 @@ class SyncServer(Server):
             # e.g. "... --enable-auto-tool-choice --tool-call-parser hermes"
             self._enabled_providers.append(
                 VLLMChatCompletionsProvider(
+                    name="vllm",
                     base_url=model_settings.vllm_api_base,
                 )
             )
         if model_settings.aws_access_key and model_settings.aws_secret_access_key and model_settings.aws_region:
             self._enabled_providers.append(
                 AnthropicBedrockProvider(
+                    name="bedrock",
                     aws_region=model_settings.aws_region,
                 )
             )
@@ -355,11 +366,11 @@ class SyncServer(Server):
                 if model_settings.lmstudio_base_url.endswith("/v1")
                 else model_settings.lmstudio_base_url + "/v1"
             )
-            self._enabled_providers.append(LMStudioOpenAIProvider(base_url=lmstudio_url))
+            self._enabled_providers.append(LMStudioOpenAIProvider(name="lmstudio_openai", base_url=lmstudio_url))
         if model_settings.deepseek_api_key:
-            self._enabled_providers.append(DeepSeekProvider(api_key=model_settings.deepseek_api_key))
+            self._enabled_providers.append(DeepSeekProvider(name="deepseek", api_key=model_settings.deepseek_api_key))
         if model_settings.xai_api_key:
-            self._enabled_providers.append(XAIProvider(api_key=model_settings.xai_api_key))
+            self._enabled_providers.append(XAIProvider(name="xai", api_key=model_settings.xai_api_key))
 
         # For MCP
         """Initialize the MCP clients (there may be multiple)"""
@@ -862,6 +873,8 @@ class SyncServer(Server):
                 agent_ids=[voice_sleeptime_agent.id],
                 manager_config=VoiceSleeptimeManager(
                     manager_agent_id=main_agent.id,
+                    max_message_buffer_length=constants.DEFAULT_MAX_MESSAGE_BUFFER_LENGTH,
+                    min_message_buffer_length=constants.DEFAULT_MIN_MESSAGE_BUFFER_LENGTH,
                 ),
             ),
             actor=actor,
@@ -1182,10 +1195,10 @@ class SyncServer(Server):
         except NoResultFound:
             raise HTTPException(status_code=404, detail=f"Organization with id {org_id} not found")
 
-    def list_llm_models(self) -> List[LLMConfig]:
+    def list_llm_models(self, byok_only: bool = False) -> List[LLMConfig]:
         """List available models"""
         llm_models = []
-        for provider in self.get_enabled_providers():
+        for provider in self.get_enabled_providers(byok_only=byok_only):
             try:
                 llm_models.extend(provider.list_llm_models())
             except Exception as e:
@@ -1205,11 +1218,12 @@ class SyncServer(Server):
                 warnings.warn(f"An error occurred while listing embedding models for provider {provider}: {e}")
         return embedding_models
 
-    def get_enabled_providers(self):
+    def get_enabled_providers(self, byok_only: bool = False):
+        providers_from_db = {p.name: p.cast_to_subtype() for p in self.provider_manager.list_providers()}
+        if byok_only:
+            return list(providers_from_db.values())
         providers_from_env = {p.name: p for p in self._enabled_providers}
-        providers_from_db = {p.name: p for p in self.provider_manager.list_providers()}
-        # Merge the two dictionaries, keeping the values from providers_from_db where conflicts occur
-        return {**providers_from_env, **providers_from_db}.values()
+        return list(providers_from_env.values()) + list(providers_from_db.values())
 
     @trace_method
     def get_llm_config_from_handle(
@@ -1294,7 +1308,7 @@ class SyncServer(Server):
         return embedding_config
 
     def get_provider_from_name(self, provider_name: str) -> Provider:
-        providers = [provider for provider in self._enabled_providers if provider.name == provider_name]
+        providers = [provider for provider in self.get_enabled_providers() if provider.name == provider_name]
         if not providers:
             raise ValueError(f"Provider {provider_name} is not supported")
         elif len(providers) > 1:

letta/services/group_manager.py

@@ -80,6 +80,12 @@ class GroupManager:
                 case ManagerType.voice_sleeptime:
                     new_group.manager_type = ManagerType.voice_sleeptime
                     new_group.manager_agent_id = group.manager_config.manager_agent_id
+                    max_message_buffer_length = group.manager_config.max_message_buffer_length
+                    min_message_buffer_length = group.manager_config.min_message_buffer_length
+                    # Safety check for buffer length range
+                    self.ensure_buffer_length_range_valid(max_value=max_message_buffer_length, min_value=min_message_buffer_length)
+                    new_group.max_message_buffer_length = max_message_buffer_length
+                    new_group.min_message_buffer_length = min_message_buffer_length
                 case _:
                     raise ValueError(f"Unsupported manager type: {group.manager_config.manager_type}")
 
@@ -97,6 +103,8 @@ class GroupManager:
             group = GroupModel.read(db_session=session, identifier=group_id, actor=actor)
 
             sleeptime_agent_frequency = None
+            max_message_buffer_length = None
+            min_message_buffer_length = None
             max_turns = None
             termination_token = None
             manager_agent_id = None
@@ -117,11 +125,24 @@ class GroupManager:
                         sleeptime_agent_frequency = group_update.manager_config.sleeptime_agent_frequency
                         if sleeptime_agent_frequency and group.turns_counter is None:
                             group.turns_counter = -1
+                    case ManagerType.voice_sleeptime:
+                        manager_agent_id = group_update.manager_config.manager_agent_id
+                        max_message_buffer_length = group_update.manager_config.max_message_buffer_length or group.max_message_buffer_length
+                        min_message_buffer_length = group_update.manager_config.min_message_buffer_length or group.min_message_buffer_length
+                        if sleeptime_agent_frequency and group.turns_counter is None:
+                            group.turns_counter = -1
                     case _:
                         raise ValueError(f"Unsupported manager type: {group_update.manager_config.manager_type}")
 
+            # Safety check for buffer length range
+            self.ensure_buffer_length_range_valid(max_value=max_message_buffer_length, min_value=min_message_buffer_length)
+
             if sleeptime_agent_frequency:
                 group.sleeptime_agent_frequency = sleeptime_agent_frequency
+            if max_message_buffer_length:
+                group.max_message_buffer_length = max_message_buffer_length
+            if min_message_buffer_length:
+                group.min_message_buffer_length = min_message_buffer_length
             if max_turns:
                 group.max_turns = max_turns
             if termination_token:
@@ -274,3 +295,40 @@ class GroupManager:
             if manager_agent:
                 for block in blocks:
                     session.add(BlocksAgents(agent_id=manager_agent.id, block_id=block.id, block_label=block.label))
+
+    @staticmethod
+    def ensure_buffer_length_range_valid(
+        max_value: Optional[int],
+        min_value: Optional[int],
+        max_name: str = "max_message_buffer_length",
+        min_name: str = "min_message_buffer_length",
+    ) -> None:
+        """
+        1) Both-or-none: if one is set, the other must be set.
+        2) Both must be ints > 4.
+        3) max_value must be strictly greater than min_value.
+        """
+        # 1) require both-or-none
+        if (max_value is None) != (min_value is None):
+            raise ValueError(
+                f"Both '{max_name}' and '{min_name}' must be provided together " f"(got {max_name}={max_value}, {min_name}={min_value})"
+            )
+
+        # no further checks if neither is provided
+        if max_value is None:
+            return
+
+        # 2) type & lower‐bound checks
+        if not isinstance(max_value, int) or not isinstance(min_value, int):
+            raise ValueError(
+                f"Both '{max_name}' and '{min_name}' must be integers "
+                f"(got {max_name}={type(max_value).__name__}, {min_name}={type(min_value).__name__})"
+            )
+        if max_value <= 4 or min_value <= 4:
+            raise ValueError(
+                f"Both '{max_name}' and '{min_name}' must be greater than 4 " f"(got {max_name}={max_value}, {min_name}={min_value})"
+            )
+
+        # 3) ordering
+        if max_value <= min_value:
+            raise ValueError(f"'{max_name}' must be greater than '{min_name}' " f"(got {max_name}={max_value} <= {min_name}={min_value})")