letta-nightly 0.9.0.dev20250726104256__py3-none-any.whl → 0.9.1.dev20250727104258__py3-none-any.whl

letta/schemas/message.py

@@ -41,7 +41,7 @@ from letta.schemas.letta_message_content import (
     get_letta_message_content_union_str_json_schema,
 )
 from letta.system import unpack_message
-from letta.utils import parse_json
+from letta.utils import parse_json, validate_function_response
 
 
 def add_inner_thoughts_to_tool_call(
@@ -251,10 +251,10 @@ class Message(BaseMessage):
         include_err: Optional[bool] = None,
     ) -> List[LettaMessage]:
         """Convert message object (in DB format) to the style used by the original Letta API"""
-        messages = []
 
+        # TODO (cliandy): break this into more manageable pieces
         if self.role == MessageRole.assistant:
-
+            messages = []
             # Handle reasoning
             if self.content:
                 # Check for ReACT-style COT inside of TextContent
@@ -348,7 +348,7 @@ class Message(BaseMessage):
                         # We need to unpack the actual message contents from the function call
                         try:
                             func_args = parse_json(tool_call.function.arguments)
-                            message_string = func_args[assistant_message_tool_kwarg]
+                            message_string = validate_function_response(func_args[assistant_message_tool_kwarg], 0, truncate=False)
                         except KeyError:
                             raise ValueError(f"Function call {tool_call.function.name} missing {assistant_message_tool_kwarg} argument")
                         messages.append(
@@ -380,99 +380,106 @@ class Message(BaseMessage):
                                 is_err=self.is_err,
                             )
                         )
-        elif self.role == MessageRole.tool:
-            # This is type ToolReturnMessage
-            # Try to interpret the function return, recall that this is how we packaged:
-            # def package_function_response(was_success, response_string, timestamp=None):
-            #     formatted_time = get_local_time() if timestamp is None else timestamp
-            #     packaged_message = {
-            #         "status": "OK" if was_success else "Failed",
-            #         "message": response_string,
-            #         "time": formatted_time,
-            #     }
-            if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
-                text_content = self.content[0].text
-            else:
-                raise ValueError(f"Invalid tool return (no text object on message): {self.content}")
 
-            try:
-                function_return = parse_json(text_content)
-                text_content = str(function_return.get("message", text_content))
-                status = function_return["status"]
-                if status == "OK":
-                    status_enum = "success"
-                elif status == "Failed":
-                    status_enum = "error"
-                else:
-                    raise ValueError(f"Invalid status: {status}")
-            except json.JSONDecodeError:
-                raise ValueError(f"Failed to decode function return: {text_content}")
-            assert self.tool_call_id is not None
-            messages.append(
-                # TODO make sure this is what the API returns
-                # function_return may not match exactly...
-                ToolReturnMessage(
-                    id=self.id,
-                    date=self.created_at,
-                    tool_return=text_content,
-                    status=self.tool_returns[0].status if self.tool_returns else status_enum,
-                    tool_call_id=self.tool_call_id,
-                    stdout=self.tool_returns[0].stdout if self.tool_returns else None,
-                    stderr=self.tool_returns[0].stderr if self.tool_returns else None,
-                    name=self.name,
-                    otid=Message.generate_otid_from_id(self.id, len(messages)),
-                    sender_id=self.sender_id,
-                    step_id=self.step_id,
-                    is_err=self.is_err,
-                )
-            )
+        elif self.role == MessageRole.tool:
+            messages = [self._convert_tool_message()]
         elif self.role == MessageRole.user:
-            # This is type UserMessage
-            if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
-                text_content = self.content[0].text
-            elif self.content:
-                text_content = self.content
-            else:
-                raise ValueError(f"Invalid user message (no text object on message): {self.content}")
-
-            message = unpack_message(text_content)
-            messages.append(
-                UserMessage(
-                    id=self.id,
-                    date=self.created_at,
-                    content=message,
-                    name=self.name,
-                    otid=self.otid,
-                    sender_id=self.sender_id,
-                    step_id=self.step_id,
-                    is_err=self.is_err,
-                )
-            )
+            messages = [self._convert_user_message()]
         elif self.role == MessageRole.system:
-            # This is type SystemMessage
-            if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
-                text_content = self.content[0].text
-            else:
-                raise ValueError(f"Invalid system message (no text object on system): {self.content}")
-
-            messages.append(
-                SystemMessage(
-                    id=self.id,
-                    date=self.created_at,
-                    content=text_content,
-                    name=self.name,
-                    otid=self.otid,
-                    sender_id=self.sender_id,
-                    step_id=self.step_id,
-                )
-            )
+            messages = [self._convert_system_message()]
         else:
-            raise ValueError(self.role)
+            raise ValueError(f"Unknown role: {self.role}")
+
+        return messages[::-1] if reverse else messages
 
-        if reverse:
-            messages.reverse()
+    def _convert_tool_message(self) -> ToolReturnMessage:
+        """Convert tool role message to ToolReturnMessage
 
-        return messages
+        the tool return is packaged as follows:
+            packaged_message = {
+                "status": "OK" if was_success else "Failed",
+                "message": response_string,
+                "time": formatted_time,
+            }
+        """
+        if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+            text_content = self.content[0].text
+        else:
+            raise ValueError(f"Invalid tool return (no text object on message): {self.content}")
+
+        try:
+            function_return = parse_json(text_content)
+            message_text = str(function_return.get("message", text_content))
+            status = self._parse_tool_status(function_return["status"])
+        except json.JSONDecodeError:
+            raise ValueError(f"Failed to decode function return: {text_content}")
+
+        assert self.tool_call_id is not None
+
+        return ToolReturnMessage(
+            id=self.id,
+            date=self.created_at,
+            tool_return=message_text,
+            status=self.tool_returns[0].status if self.tool_returns else status,
+            tool_call_id=self.tool_call_id,
+            stdout=self.tool_returns[0].stdout if self.tool_returns else None,
+            stderr=self.tool_returns[0].stderr if self.tool_returns else None,
+            name=self.name,
+            otid=Message.generate_otid_from_id(self.id, 0),
+            sender_id=self.sender_id,
+            step_id=self.step_id,
+            is_err=self.is_err,
+        )
+
+    @staticmethod
+    def _parse_tool_status(status: str) -> Literal["success", "error"]:
+        """Convert tool status string to enum value"""
+        if status == "OK":
+            return "success"
+        elif status == "Failed":
+            return "error"
+        else:
+            raise ValueError(f"Invalid status: {status}")
+
+    def _convert_user_message(self) -> UserMessage:
+        """Convert user role message to UserMessage"""
+        # Extract text content
+        if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+            text_content = self.content[0].text
+        elif self.content:
+            text_content = self.content
+        else:
+            raise ValueError(f"Invalid user message (no text object on message): {self.content}")
+
+        message = unpack_message(text_content)
+
+        return UserMessage(
+            id=self.id,
+            date=self.created_at,
+            content=message,
+            name=self.name,
+            otid=self.otid,
+            sender_id=self.sender_id,
+            step_id=self.step_id,
+            is_err=self.is_err,
+        )
+
+    def _convert_system_message(self) -> SystemMessage:
+        """Convert system role message to SystemMessage"""
+        if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+            text_content = self.content[0].text
+        else:
+            raise ValueError(f"Invalid system message (no text object on system): {self.content}")
+
+        return SystemMessage(
+            id=self.id,
+            date=self.created_at,
+            content=text_content,
+            name=self.name,
+            otid=self.otid,
+            sender_id=self.sender_id,
+            step_id=self.step_id,
+        )
 
     @staticmethod
     def dict_to_message(

letta/schemas/providers/openai.py

@@ -202,7 +202,7 @@ class OpenAIProvider(Provider):
                 if model_type not in ["text->embedding"]:
                     continue
             else:
-                logger.info(
+                logger.debug(
                     f"Skipping embedding models for %s by default, as we don't assume embeddings are supported."
                     "Please open an issue on GitHub if support is required.",
                     self.base_url,

letta/server/rest_api/app.py

@@ -12,7 +12,6 @@ from typing import Optional
 import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
-from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.cors import CORSMiddleware
 
 from letta.__init__ import __version__ as letta_version
@@ -35,6 +34,7 @@ from letta.server.db import db_registry
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
 from letta.server.rest_api.auth.index import setup_auth_router  # TODO: probably remove right?
 from letta.server.rest_api.interface import StreamingServerInterface
+from letta.server.rest_api.middleware import CheckPasswordMiddleware, ProfilerContextMiddleware
 from letta.server.rest_api.routers.openai.chat_completions.chat_completions import router as openai_chat_completions_router
 from letta.server.rest_api.routers.v1 import ROUTERS as v1_routes
 from letta.server.rest_api.routers.v1.organizations import router as organizations_router
@@ -42,7 +42,7 @@ from letta.server.rest_api.routers.v1.users import router as users_router  # TOD
 from letta.server.rest_api.static_files import mount_static_files
 from letta.server.rest_api.utils import SENTRY_ENABLED
 from letta.server.server import SyncServer
-from letta.settings import settings
+from letta.settings import settings, telemetry_settings
 
 if SENTRY_ENABLED:
     import sentry_sdk
@@ -92,24 +92,6 @@ def generate_password():
 random_password = os.getenv("LETTA_SERVER_PASSWORD") or generate_password()
 
 
-class CheckPasswordMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request, call_next):
-        # Exclude health check endpoint from password protection
-        if request.url.path in {"/v1/health", "/v1/health/", "/latest/health/"}:
-            return await call_next(request)
-
-        if (
-            request.headers.get("X-BARE-PASSWORD") == f"password {random_password}"
-            or request.headers.get("Authorization") == f"Bearer {random_password}"
-        ):
-            return await call_next(request)
-
-        return JSONResponse(
-            content={"detail": "Unauthorized"},
-            status_code=401,
-        )
-
-
 @asynccontextmanager
 async def lifespan(app_: FastAPI):
     """
@@ -117,6 +99,19 @@ async def lifespan(app_: FastAPI):
     """
     worker_id = os.getpid()
 
+    if telemetry_settings.profiler:
+        try:
+            import googlecloudprofiler
+
+            googlecloudprofiler.start(
+                service="memgpt-server",
+                service_version=str(letta_version),
+                verbose=3,
+            )
+            logger.info("Profiler started.")
+        except Exception as exc:
+            logger.info("Profiler not enabled: %", exc)
+
     logger.info(f"[Worker {worker_id}] Starting lifespan initialization")
     logger.info(f"[Worker {worker_id}] Initializing database connections")
     db_registry.initialize_sync()
@@ -283,11 +278,14 @@ def create_application() -> "FastAPI":
 
     if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:
         print(f"▶ Using secure mode with password: {random_password}")
-        app.add_middleware(CheckPasswordMiddleware)
+        app.add_middleware(CheckPasswordMiddleware, password=random_password)
 
     # Add reverse proxy middleware to handle X-Forwarded-* headers
     # app.add_middleware(ReverseProxyMiddleware, base_path=settings.server_base_path)
 
+    if telemetry_settings.profiler:
+        app.add_middleware(ProfilerContextMiddleware)
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=settings.cors_origins,

letta/server/rest_api/middleware/__init__.py

@@ -0,0 +1,4 @@
+from letta.server.rest_api.middleware.check_password import CheckPasswordMiddleware
+from letta.server.rest_api.middleware.profiler_context import ProfilerContextMiddleware
+
+__all__ = ["CheckPasswordMiddleware", "ProfilerContextMiddleware"]

letta/server/rest_api/middleware/check_password.py

@@ -0,0 +1,24 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+
+
+class CheckPasswordMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, password: str):
+        super().__init__(app)
+        self.password = password
+
+    async def dispatch(self, request, call_next):
+        # Exclude health check endpoint from password protection
+        if request.url.path in {"/v1/health", "/v1/health/", "/latest/health/"}:
+            return await call_next(request)
+
+        if (
+            request.headers.get("X-BARE-PASSWORD") == f"password {self.password}"
+            or request.headers.get("Authorization") == f"Bearer {self.password}"
+        ):
+            return await call_next(request)
+
+        return JSONResponse(
+            content={"detail": "Unauthorized"},
+            status_code=401,
+        )

letta/server/rest_api/middleware/profiler_context.py

@@ -0,0 +1,25 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+class ProfilerContextMiddleware(BaseHTTPMiddleware):
+    """Middleware to set context if using profiler. Currently just uses google-cloud-profiler."""
+
+    async def dispatch(self, request, call_next):
+        ctx = None
+        if request.url.path in {"/v1/health", "/v1/health/"}:
+            return await call_next(request)
+        try:
+            labels = {
+                "method": request.method,
+                "path": request.url.path,
+                "endpoint": request.url.path,
+            }
+            import googlecloudprofiler
+
+            ctx = googlecloudprofiler.context.set_labels(**labels)
+        except:
+            return await call_next(request)
+        if ctx:
+            with ctx:
+                return await call_next(request)
+        return await call_next(request)

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

@@ -22,6 +22,7 @@ async def list_blocks(
     name: Optional[str] = Query(None, description="Name of the block"),
     identity_id: Optional[str] = Query(None, description="Search agents by identifier id"),
     identifier_keys: Optional[List[str]] = Query(None, description="Search agents by identifier keys"),
+    project_id: Optional[str] = Query(None, description="Search blocks by project id"),
     limit: Optional[int] = Query(50, description="Number of blocks to return"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -34,6 +35,7 @@ async def list_blocks(
         template_name=name,
         identity_id=identity_id,
         identifier_keys=identifier_keys,
+        project_id=project_id,
         limit=limit,
     )
 

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

@@ -31,12 +31,12 @@ def list_groups(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     return server.group_manager.list_groups(
+        actor=actor,
         project_id=project_id,
         manager_type=manager_type,
         before=before,
         after=after,
         limit=limit,
-        actor=actor,
     )
 
 

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

@@ -2,6 +2,7 @@ import asyncio
 import mimetypes
 import os
 import tempfile
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import List, Optional
 
@@ -393,6 +394,31 @@ async def get_file_metadata(
     if file_metadata.source_id != source_id:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found in source {source_id}.")
 
+    # Check for timeout if status is not terminal
+    if not file_metadata.processing_status.is_terminal_state():
+        if file_metadata.created_at:
+            # Handle timezone differences between PostgreSQL (timezone-aware) and SQLite (timezone-naive)
+            if settings.letta_pg_uri_no_default:
+                # PostgreSQL: both datetimes are timezone-aware
+                timeout_threshold = datetime.now(timezone.utc) - timedelta(minutes=settings.file_processing_timeout_minutes)
+                file_created_at = file_metadata.created_at
+            else:
+                # SQLite: both datetimes should be timezone-naive
+                timeout_threshold = datetime.utcnow() - timedelta(minutes=settings.file_processing_timeout_minutes)
+                file_created_at = file_metadata.created_at
+
+            if file_created_at < timeout_threshold:
+                # Move file to error status with timeout message
+                timeout_message = settings.file_processing_timeout_error_message.format(settings.file_processing_timeout_minutes)
+                try:
+                    file_metadata = await server.file_manager.update_file_status(
+                        file_id=file_metadata.id, actor=actor, processing_status=FileProcessingStatus.ERROR, error_message=timeout_message
+                    )
+                except ValueError as e:
+                    # state transition was blocked - log it but don't fail the request
+                    logger.warning(f"Could not update file to timeout error state: {str(e)}")
+                    # continue with existing file_metadata
+
     if should_use_pinecone() and file_metadata.processing_status == FileProcessingStatus.EMBEDDING:
         ids = await list_pinecone_index_for_files(file_id=file_id, actor=actor)
         logger.info(