chore: bump v0.8.17 (#2725)

Co-authored-by: Kian Jones <[email protected]>
Co-authored-by: Sarah Wooders <[email protected]>
Co-authored-by: Matthew Zhou <[email protected]>
Co-authored-by: Andy Li <[email protected]>
Co-authored-by: jnjpng <[email protected]>
Co-authored-by: Jin Peng <[email protected]>
Co-authored-by: cpacker <[email protected]>
Co-authored-by: Shubham Naik <[email protected]>
Co-authored-by: Shubham Naik <[email protected]>
Co-authored-by: Kevin Lin <[email protected]>
Co-authored-by: Eric Ly <[email protected]>
Co-authored-by: Eric Ly <[email protected]>

Author: 13 people

letta/__init__.py

@@ -5,7 +5,7 @@
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.8.16"
+    __version__ = "0.8.17"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/schemas/letta_message.py

@@ -63,13 +63,13 @@ def serialize_datetime(self, dt: datetime, _info):
             dt = dt.replace(tzinfo=timezone.utc)
         return dt.isoformat(timespec="seconds")
 
-    @field_serializer("is_err", when_used="unless-none")
-    def serialize_is_err(self, value: bool | None, _info):
+    @field_serializer("is_err", mode="wrap")
+    def serialize_is_err(self, value: bool | None, handler, _info):
         """
         Only serialize is_err field when it's True (for debugging purposes).
         When is_err is None or False, this field will be excluded from the JSON output.
         """
-        return value if value is True else None
+        return handler(value) if value is True else None
 
 
 class SystemMessage(LettaMessage):

letta/schemas/message.py

@@ -269,6 +269,7 @@ def to_letta_messages(
                             otid=otid,
                             sender_id=self.sender_id,
                             step_id=self.step_id,
+                            is_err=self.is_err,
                         )
                     )
                 # Otherwise, we may have a list of multiple types
@@ -287,6 +288,7 @@ def to_letta_messages(
                                     otid=otid,
                                     sender_id=self.sender_id,
                                     step_id=self.step_id,
+                                    is_err=self.is_err,
                                 )
                             )
                         elif isinstance(content_part, ReasoningContent):
@@ -301,6 +303,7 @@ def to_letta_messages(
                                     name=self.name,
                                     otid=otid,
                                     step_id=self.step_id,
+                                    is_err=self.is_err,
                                 )
                             )
                         elif isinstance(content_part, RedactedReasoningContent):
@@ -315,6 +318,7 @@ def to_letta_messages(
                                     otid=otid,
                                     sender_id=self.sender_id,
                                     step_id=self.step_id,
+                                    is_err=self.is_err,
                                 )
                             )
                         elif isinstance(content_part, OmittedReasoningContent):
@@ -328,6 +332,7 @@ def to_letta_messages(
                                     name=self.name,
                                     otid=otid,
                                     step_id=self.step_id,
+                                    is_err=self.is_err,
                                 )
                             )
                         else:
@@ -355,6 +360,7 @@ def to_letta_messages(
                                 otid=otid,
                                 sender_id=self.sender_id,
                                 step_id=self.step_id,
+                                is_err=self.is_err,
                             )
                         )
                     else:
@@ -371,6 +377,7 @@ def to_letta_messages(
                                 otid=otid,
                                 sender_id=self.sender_id,
                                 step_id=self.step_id,
+                                is_err=self.is_err,
                             )
                         )
         elif self.role == MessageRole.tool:
@@ -416,6 +423,7 @@ def to_letta_messages(
                     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.user:
@@ -437,6 +445,7 @@ def to_letta_messages(
                     otid=self.otid,
                     sender_id=self.sender_id,
                     step_id=self.step_id,
+                    is_err=self.is_err,
                 )
             )
         elif self.role == MessageRole.system:

letta/server/db.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 import threading
 import time
@@ -116,6 +117,13 @@ def __init__(self):
         self.config = LettaConfig.load()
         self.logger = get_logger(__name__)
 
+        if settings.db_max_concurrent_sessions:
+            self._db_semaphore = asyncio.Semaphore(settings.db_max_concurrent_sessions)
+            self.logger.info(f"Initialized database throttling with max {settings.db_max_concurrent_sessions} concurrent sessions")
+        else:
+            self.logger.info("Database throttling is disabled")
+            self._db_semaphore = None
+
     def initialize_sync(self, force: bool = False) -> None:
         """Initialize the synchronous database engine if not already initialized."""
         with self._lock:
@@ -364,16 +372,33 @@ def session(self, name: str = "default") -> Generator[Any, None, None]:
     @trace_method
     @asynccontextmanager
     async def async_session(self, name: str = "default") -> AsyncGenerator[AsyncSession, None]:
-        """Async context manager for database sessions."""
-        session_factory = self.get_async_session_factory(name)
-        if not session_factory:
-            raise ValueError(f"No async session factory found for '{name}' or async database is not configured")
+        """Async context manager for database sessions with throttling."""
+        if self._db_semaphore:
+            async with self._db_semaphore:
+                session_factory = self.get_async_session_factory(name)
+                if not session_factory:
+                    raise ValueError(f"No async session factory found for '{name}' or async database is not configured")
+
+                session = session_factory()
+                try:
+                    yield session
+                finally:
+                    await session.close()
+        else:
+            session_factory = self.get_async_session_factory(name)
+            if not session_factory:
+                raise ValueError(f"No async session factory found for '{name}' or async database is not configured")
 
-        session = session_factory()
-        try:
-            yield session
-        finally:
-            await session.close()
+            session = session_factory()
+            try:
+                yield session
+            finally:
+                await session.close()
+
+    @trace_method
+    def session_caller_trace(self, caller_info: str):
+        """Trace sync db caller information for debugging purposes."""
+        pass  # wrapper used for otel tracing only
 
     @trace_method
     def session_caller_trace(self, caller_info: str):

letta/server/rest_api/streaming_response.py

@@ -125,14 +125,7 @@ async def stream_response(self, send: Send) -> None:
                         if not isinstance(content, bytes):
                             content = content.encode(self.charset)
                         more_body = False
-                        await send(
-                            {
-                                "type": "http.response.body",
-                                "body": content,
-                                "more_body": more_body,
-                            }
-                        )
-                        raise Exception(f"An exception occurred mid-stream with status code {status_code}", detail={"content": content})
+                        raise Exception(f"An exception occurred mid-stream with status code {status_code} with content {content}")
                 else:
                     content = chunk
 

letta/server/rest_api/utils.py

@@ -120,22 +120,22 @@ async def sse_async_generator(
                 yield sse_formatter(usage.model_dump(exclude={"steps_messages"}))
 
             except ContextWindowExceededError as e:
-                log_error_to_sentry(e)
+                capture_sentry_exception(e)
                 logger.error(f"ContextWindowExceededError error: {e}")
                 yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
             except RateLimitExceededError as e:
-                log_error_to_sentry(e)
+                capture_sentry_exception(e)
                 logger.error(f"RateLimitExceededError error: {e}")
                 yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
             except Exception as e:
-                log_error_to_sentry(e)
+                capture_sentry_exception(e)
                 logger.error(f"Caught unexpected Exception: {e}")
                 yield sse_formatter({"error": "Stream failed (internal error occurred)"})
 
     except Exception as e:
-        log_error_to_sentry(e)
+        capture_sentry_exception(e)
         logger.error(f"Caught unexpected Exception: {e}")
         yield sse_formatter({"error": "Stream failed (decoder encountered an error)"})