letta-nightly 0.6.43.dev20250319104146__py3-none-any.whl → 0.6.43.dev20250321104124__py3-none-any.whl

letta/schemas/providers.py

@@ -210,6 +210,257 @@ class OpenAIProvider(Provider):
         else:
             return LLM_MAX_TOKENS["DEFAULT"]
 
+
+class xAIProvider(OpenAIProvider):
+    """https://docs.x.ai/docs/api-reference"""
+
+    name: str = "xai"
+    api_key: str = Field(..., description="API key for the xAI/Grok API.")
+    base_url: str = Field("https://api.x.ai/v1", description="Base URL for the xAI/Grok API.")
+
+    def get_model_context_window_size(self, model_name: str) -> Optional[int]:
+        # xAI doesn't return context window in the model listing,
+        # so these are hardcoded from their website
+        if model_name == "grok-2-1212":
+            return 131072
+        else:
+            return None
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list
+
+        response = openai_get_model_list(self.base_url, api_key=self.api_key)
+
+        if "data" in response:
+            data = response["data"]
+        else:
+            data = response
+
+        configs = []
+        for model in data:
+            assert "id" in model, f"xAI/Grok model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            # In case xAI starts supporting it in the future:
+            if "context_length" in model:
+                context_window_size = model["context_length"]
+            else:
+                context_window_size = self.get_model_context_window_size(model_name)
+
+            if not context_window_size:
+                warnings.warn(f"Couldn't find context window size for model {model_name}")
+                continue
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="xai",
+                    model_endpoint=self.base_url,
+                    context_window=context_window_size,
+                    handle=self.get_handle(model_name),
+                )
+            )
+
+        return configs
+
+    def list_embedding_models(self) -> List[EmbeddingConfig]:
+        # No embeddings supported
+        return []
+
+
+class DeepSeekProvider(OpenAIProvider):
+    """
+    DeepSeek ChatCompletions API is similar to OpenAI's reasoning API,
+    but with slight differences:
+    * For example, DeepSeek's API requires perfect interleaving of user/assistant
+    * It also does not support native function calling
+    """
+
+    name: str = "deepseek"
+    base_url: str = Field("https://api.deepseek.com/v1", description="Base URL for the DeepSeek API.")
+    api_key: str = Field(..., description="API key for the DeepSeek API.")
+
+    def get_model_context_window_size(self, model_name: str) -> Optional[int]:
+        # DeepSeek doesn't return context window in the model listing,
+        # so these are hardcoded from their website
+        if model_name == "deepseek-reasoner":
+            return 64000
+        elif model_name == "deepseek-chat":
+            return 64000
+        else:
+            return None
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list
+
+        response = openai_get_model_list(self.base_url, api_key=self.api_key)
+
+        if "data" in response:
+            data = response["data"]
+        else:
+            data = response
+
+        configs = []
+        for model in data:
+            assert "id" in model, f"DeepSeek model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            # In case DeepSeek starts supporting it in the future:
+            if "context_length" in model:
+                # Context length is returned in OpenRouter as "context_length"
+                context_window_size = model["context_length"]
+            else:
+                context_window_size = self.get_model_context_window_size(model_name)
+
+            if not context_window_size:
+                warnings.warn(f"Couldn't find context window size for model {model_name}")
+                continue
+
+            # Not used for deepseek-reasoner, but otherwise is true
+            put_inner_thoughts_in_kwargs = False if model_name == "deepseek-reasoner" else True
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="deepseek",
+                    model_endpoint=self.base_url,
+                    context_window=context_window_size,
+                    handle=self.get_handle(model_name),
+                    put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
+                )
+            )
+
+        return configs
+
+    def list_embedding_models(self) -> List[EmbeddingConfig]:
+        # No embeddings supported
+        return []
+
+
+class LMStudioOpenAIProvider(OpenAIProvider):
+    name: str = "lmstudio-openai"
+    base_url: str = Field(..., description="Base URL for the LMStudio OpenAI API.")
+    api_key: Optional[str] = Field(None, description="API key for the LMStudio API.")
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list
+
+        # For LMStudio, we want to hit 'GET /api/v0/models' instead of 'GET /v1/models'
+        MODEL_ENDPOINT_URL = f"{self.base_url.strip('/v1')}/api/v0"
+        response = openai_get_model_list(MODEL_ENDPOINT_URL)
+
+        """
+        Example response:
+
+        {
+          "object": "list",
+          "data": [
+            {
+              "id": "qwen2-vl-7b-instruct",
+              "object": "model",
+              "type": "vlm",
+              "publisher": "mlx-community",
+              "arch": "qwen2_vl",
+              "compatibility_type": "mlx",
+              "quantization": "4bit",
+              "state": "not-loaded",
+              "max_context_length": 32768
+            },
+            ...
+        """
+        if "data" not in response:
+            warnings.warn(f"LMStudio OpenAI model query response missing 'data' field: {response}")
+            return []
+
+        configs = []
+        for model in response["data"]:
+            assert "id" in model, f"Model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            if "type" not in model:
+                warnings.warn(f"LMStudio OpenAI model missing 'type' field: {model}")
+                continue
+            elif model["type"] not in ["vlm", "llm"]:
+                continue
+
+            if "max_context_length" in model:
+                context_window_size = model["max_context_length"]
+            else:
+                warnings.warn(f"LMStudio OpenAI model missing 'max_context_length' field: {model}")
+                continue
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="openai",
+                    model_endpoint=self.base_url,
+                    context_window=context_window_size,
+                    handle=self.get_handle(model_name),
+                )
+            )
+
+        return configs
+
+    def list_embedding_models(self) -> List[EmbeddingConfig]:
+        from letta.llm_api.openai import openai_get_model_list
+
+        # For LMStudio, we want to hit 'GET /api/v0/models' instead of 'GET /v1/models'
+        MODEL_ENDPOINT_URL = f"{self.base_url.strip('/v1')}/api/v0"
+        response = openai_get_model_list(MODEL_ENDPOINT_URL)
+
+        """
+        Example response:
+        {
+          "object": "list",
+          "data": [
+            {
+              "id": "text-embedding-nomic-embed-text-v1.5",
+              "object": "model",
+              "type": "embeddings",
+              "publisher": "nomic-ai",
+              "arch": "nomic-bert",
+              "compatibility_type": "gguf",
+              "quantization": "Q4_0",
+              "state": "not-loaded",
+              "max_context_length": 2048
+            }
+            ...
+        """
+        if "data" not in response:
+            warnings.warn(f"LMStudio OpenAI model query response missing 'data' field: {response}")
+            return []
+
+        configs = []
+        for model in response["data"]:
+            assert "id" in model, f"Model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            if "type" not in model:
+                warnings.warn(f"LMStudio OpenAI model missing 'type' field: {model}")
+                continue
+            elif model["type"] not in ["embeddings"]:
+                continue
+
+            if "max_context_length" in model:
+                context_window_size = model["max_context_length"]
+            else:
+                warnings.warn(f"LMStudio OpenAI model missing 'max_context_length' field: {model}")
+                continue
+
+            configs.append(
+                EmbeddingConfig(
+                    embedding_model=model_name,
+                    embedding_endpoint_type="openai",
+                    embedding_endpoint=self.base_url,
+                    embedding_dim=context_window_size,
+                    embedding_chunk_size=300,  # NOTE: max is 2048
+                    handle=self.get_handle(model_name),
+                ),
+            )
+
+        return configs
+
+
 class xAIProvider(OpenAIProvider):
     """https://docs.x.ai/docs/api-reference"""
 

letta/schemas/tool.py

@@ -171,7 +171,7 @@ class ToolCreate(LettaBase):
         from composio import LogLevel
         from composio_langchain import ComposioToolSet
 
-        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
+        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR, lock=False)
         composio_action_schemas = composio_toolset.get_action_schemas(actions=[action_name], check_connected_accounts=False)
 
         assert len(composio_action_schemas) > 0, "User supplied parameters do not match any Composio tools"
@@ -250,3 +250,6 @@ class ToolRunFromSource(LettaBase):
     name: Optional[str] = Field(None, description="The name of the tool to run.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
     args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
+    json_schema: Optional[Dict] = Field(
+        None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
+    )

letta/server/rest_api/app.py

@@ -43,16 +43,6 @@ interface: StreamingServerInterface = StreamingServerInterface
 server = SyncServer(default_interface_factory=lambda: interface())
 logger = get_logger(__name__)
 
-# TODO: remove
-password = None
-## TODO(ethan): eventuall remove
-# if password := settings.server_pass:
-#    # if the pass was specified in the environment, use it
-#    print(f"Using existing admin server password from environment.")
-# else:
-#    # Autogenerate a password for this session and dump it to stdout
-#    password = secrets.token_urlsafe(16)
-#    #typer.secho(f"Generated admin server password for this session: {password}", fg=typer.colors.GREEN)
 
 import logging
 import platform
@@ -287,7 +277,7 @@ def create_application() -> "FastAPI":
     app.include_router(openai_chat_completions_router, prefix=OPENAI_API_PREFIX)
 
     # /api/auth endpoints
-    app.include_router(setup_auth_router(server, interface, password), prefix=API_PREFIX)
+    app.include_router(setup_auth_router(server, interface, random_password), prefix=API_PREFIX)
 
     # / static files
     mount_static_files(app)

letta/server/rest_api/optimistic_json_parser.py

@@ -32,7 +32,7 @@ class OptimisticJSONParser:
         self.on_extra_token = self.default_on_extra_token
 
     def default_on_extra_token(self, text, data, reminding):
-        pass
+        print(f"Parsed JSON with extra tokens: {data}, remaining: {reminding}")
 
     def parse(self, input_str):
         """
@@ -130,8 +130,8 @@ class OptimisticJSONParser:
         if end == -1:
             # Incomplete string
             if not self.strict:
-                return input_str[1:], ""
-            return json.loads(f'"{input_str[1:]}"'), ""
+                return input_str[1:], ""  # Lenient mode returns partial string
+            raise decode_error  # Raise error for incomplete string in strict mode
 
         str_val = input_str[: end + 1]
         input_str = input_str[end + 1 :]
@@ -152,8 +152,8 @@ class OptimisticJSONParser:
         num_str = input_str[:idx]
         remainder = input_str[idx:]
 
-        # If it's only a sign or just '.', return as-is with empty remainder
-        if not num_str or num_str in {"-", "."}:
+        # If not strict, and it's only a sign or just '.', return as-is with empty remainder
+        if not self.strict and (not num_str or num_str in {"-", "."}):
             return num_str, ""
 
         try:

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

@@ -12,6 +12,7 @@ from composio.exceptions import (
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.errors import LettaToolCreateError
+from letta.functions.mcp_client.exceptions import MCPTimeoutError
 from letta.functions.mcp_client.types import MCPTool, SSEServerConfig, StdioServerConfig
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.log import get_logger
@@ -192,6 +193,7 @@ def run_tool_from_source(
             tool_env_vars=request.env_vars,
             tool_name=request.name,
             tool_args_json_schema=request.args_json_schema,
+            tool_json_schema=request.json_schema,
             actor=actor,
         )
     except LettaToolCreateError as e:
@@ -366,6 +368,15 @@ def list_mcp_tools_by_server(
                 "mcp_server_name": mcp_server_name,
             },
         )
+    except MCPTimeoutError as e:
+        raise HTTPException(
+            status_code=408,  # Timeout
+            detail={
+                "code": "MCPTimeoutError",
+                "message": str(e),
+                "mcp_server_name": mcp_server_name,
+            },
+        )
 
 
 @router.post("/mcp/servers/{mcp_server_name}/{mcp_tool_name}", response_model=Tool, operation_id="add_mcp_tool")
@@ -380,8 +391,29 @@ def add_mcp_tool(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    available_tools = server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
-    # See if the tool is in the avaialable list
+    try:
+        available_tools = server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
+    except ValueError as e:
+        # ValueError means that the MCP server name doesn't exist
+        raise HTTPException(
+            status_code=400,  # Bad Request
+            detail={
+                "code": "MCPServerNotFoundError",
+                "message": str(e),
+                "mcp_server_name": mcp_server_name,
+            },
+        )
+    except MCPTimeoutError as e:
+        raise HTTPException(
+            status_code=408,  # Timeout
+            detail={
+                "code": "MCPTimeoutError",
+                "message": str(e),
+                "mcp_server_name": mcp_server_name,
+            },
+        )
+
+    # See if the tool is in the available list
     mcp_tool = None
     for tool in available_tools:
         if tool.name == mcp_tool_name:

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

@@ -6,7 +6,7 @@ from fastapi import APIRouter, Body, Depends, Header
 from fastapi.responses import StreamingResponse
 from openai.types.chat.completion_create_params import CompletionCreateParams
 
-from letta.agents.low_latency_agent import LowLatencyAgent
+from letta.agents.voice_agent import VoiceAgent
 from letta.log import get_logger
 from letta.schemas.openai.chat_completions import UserMessage
 from letta.server.rest_api.utils import get_letta_server, get_messages_from_completion_request
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
     from letta.server.server import SyncServer
 
 
-router = APIRouter(prefix="/voice", tags=["voice"])
+router = APIRouter(prefix="/voice-beta", tags=["voice"])
 
 logger = get_logger(__name__)
 
@@ -61,15 +61,15 @@ async def create_voice_chat_completions(
     )
 
     # Instantiate our LowLatencyAgent
-    agent = LowLatencyAgent(
+    agent = VoiceAgent(
         agent_id=agent_id,
         openai_client=client,
         message_manager=server.message_manager,
         agent_manager=server.agent_manager,
         block_manager=server.block_manager,
         actor=actor,
-        message_buffer_limit=10,
-        message_buffer_min=4,
+        message_buffer_limit=50,
+        message_buffer_min=10,
     )
 
     # Return the streaming generator

letta/server/server.py

@@ -1202,6 +1202,7 @@ class SyncServer(Server):
         tool_source_type: Optional[str] = None,
         tool_name: Optional[str] = None,
         tool_args_json_schema: Optional[Dict[str, Any]] = None,
+        tool_json_schema: Optional[Dict[str, Any]] = None,
     ) -> ToolReturnMessage:
         """Run a tool from source code"""
         if tool_source_type is not None and tool_source_type != "python":
@@ -1213,6 +1214,11 @@ class SyncServer(Server):
             source_code=tool_source,
             args_json_schema=tool_args_json_schema,
         )
+
+        # If tools_json_schema is explicitly passed in, override it on the created Tool object
+        if tool_json_schema:
+            tool.json_schema = tool_json_schema
+
         assert tool.name is not None, "Failed to create tool object"
 
         # TODO eventually allow using agent state in tools

letta/services/agent_manager.py

@@ -755,7 +755,7 @@ class AgentManager:
                 if updated_value != agent_state.memory.get_block(label).value:
                     # update the block if it's changed
                     block_id = agent_state.memory.get_block(label).id
-                    block = self.block_manager.update_block(block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=actor)
+                    self.block_manager.update_block(block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=actor)
 
             # refresh memory from DB (using block ids)
             agent_state.memory = Memory(

letta/services/block_manager.py

@@ -106,12 +106,14 @@ class BlockManager:
 
     @enforce_types
     def get_all_blocks_by_ids(self, block_ids: List[str], actor: Optional[PydanticUser] = None) -> List[PydanticBlock]:
-        # TODO: We can do this much more efficiently by listing, instead of executing individual queries per block_id
-        blocks = []
-        for block_id in block_ids:
-            block = self.get_block_by_id(block_id, actor=actor)
-            blocks.append(block)
-        return blocks
+        """Retrieve blocks by their names."""
+        with self.session_maker() as session:
+            blocks = list(
+                map(lambda obj: obj.to_pydantic(), BlockModel.read_multiple(db_session=session, identifiers=block_ids, actor=actor))
+            )
+            # backwards compatibility. previous implementation added None for every block not found.
+            blocks.extend([None for _ in range(len(block_ids) - len(blocks))])
+            return blocks
 
     @enforce_types
     def add_default_blocks(self, actor: PydanticUser):

letta/services/message_manager.py

@@ -63,8 +63,71 @@ class MessageManager:
 
     @enforce_types
     def create_many_messages(self, pydantic_msgs: List[PydanticMessage], actor: PydanticUser) -> List[PydanticMessage]:
-        """Create multiple messages."""
-        return [self.create_message(m, actor=actor) for m in pydantic_msgs]
+        """
+        Create multiple messages in a single database transaction.
+
+        Args:
+            pydantic_msgs: List of Pydantic message models to create
+            actor: User performing the action
+
+        Returns:
+            List of created Pydantic message models
+        """
+        if not pydantic_msgs:
+            return []
+
+        # Create ORM model instances for all messages
+        orm_messages = []
+        for pydantic_msg in pydantic_msgs:
+            # Set the organization id of the Pydantic message
+            pydantic_msg.organization_id = actor.organization_id
+            msg_data = pydantic_msg.model_dump(to_orm=True)
+            orm_messages.append(MessageModel(**msg_data))
+
+        # Use the batch_create method for efficient creation
+        with self.session_maker() as session:
+            created_messages = MessageModel.batch_create(orm_messages, session, actor=actor)
+
+            # Convert back to Pydantic models
+            return [msg.to_pydantic() for msg in created_messages]
+
+    @enforce_types
+    def update_message_by_letta_message(
+        self, message_id: str, letta_message_update: LettaMessageUpdateUnion, actor: PydanticUser
+    ) -> PydanticMessage:
+        """
+        Updated the underlying messages table giving an update specified to the user-facing LettaMessage
+        """
+        message = self.get_message_by_id(message_id=message_id, actor=actor)
+        if letta_message_update.message_type == "assistant_message":
+            # modify the tool call for send_message
+            # TODO: fix this if we add parallel tool calls
+            # TODO: note this only works if the AssistantMessage is generated by the standard send_message
+            assert (
+                message.tool_calls[0].function.name == "send_message"
+            ), f"Expected the first tool call to be send_message, but got {message.tool_calls[0].function.name}"
+            original_args = json.loads(message.tool_calls[0].function.arguments)
+            original_args["message"] = letta_message_update.content  # override the assistant message
+            update_tool_call = message.tool_calls[0].__deepcopy__()
+            update_tool_call.function.arguments = json.dumps(original_args)
+
+            update_message = MessageUpdate(tool_calls=[update_tool_call])
+        elif letta_message_update.message_type == "reasoning_message":
+            update_message = MessageUpdate(content=letta_message_update.reasoning)
+        elif letta_message_update.message_type == "user_message" or letta_message_update.message_type == "system_message":
+            update_message = MessageUpdate(content=letta_message_update.content)
+        else:
+            raise ValueError(f"Unsupported message type for modification: {letta_message_update.message_type}")
+
+        message = self.update_message_by_id(message_id=message_id, message_update=update_message, actor=actor)
+
+        # convert back to LettaMessage
+        for letta_msg in message.to_letta_message(use_assistant_message=True):
+            if letta_msg.message_type == letta_message_update.message_type:
+                return letta_msg
+
+        # raise error if message type got modified
+        raise ValueError(f"Message type got modified: {letta_message_update.message_type}")
 
     @enforce_types
     def update_message_by_letta_message(

letta/settings.py

@@ -19,8 +19,8 @@ class ToolSettings(BaseSettings):
     local_sandbox_dir: Optional[str] = None
 
     # MCP settings
-    mcp_connect_to_server_timeout: float = 15.0
-    mcp_list_tools_timeout: float = 10.0
+    mcp_connect_to_server_timeout: float = 30.0
+    mcp_list_tools_timeout: float = 30.0
     mcp_execute_tool_timeout: float = 60.0
     mcp_read_from_config: bool = True  # if False, will throw if attempting to read/write from file
 
@@ -179,7 +179,7 @@ class Settings(BaseSettings):
 
     # telemetry logging
     verbose_telemetry_logging: bool = False
-    otel_exporter_otlp_endpoint: str = "http://localhost:4317"
+    otel_exporter_otlp_endpoint: Optional[str] = None  # otel default: "http://localhost:4317"
     disable_tracing: bool = False
 
     # uvicorn settings

{letta_nightly-0.6.43.dev20250319104146.dist-info → letta_nightly-0.6.43.dev20250321104124.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.43.dev20250319104146
+Version: 0.6.43.dev20250321104124
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -31,7 +31,7 @@ Requires-Dist: brotli (>=1.1.0,<2.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.7,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.7,<0.8.0)
-Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0)
+Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0) ; extra == "desktop" or extra == "all"
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)
@@ -49,12 +49,12 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.65,<0.2.0)
+Requires-Dist: letta_client (>=0.1.65,<0.2.0) ; extra == "desktop"
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
 Requires-Dist: marshmallow-sqlalchemy (>=1.4.1,<2.0.0)
-Requires-Dist: mcp (>=1.3.0,<2.0.0)
+Requires-Dist: mcp (>=1.3.0,<2.0.0) ; extra == "desktop"
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: openai (>=1.60.0,<2.0.0)