letta-nightly 0.6.5.dev20241218213641__py3-none-any.whl → 0.6.5.dev20241219104153__py3-none-any.whl

letta/agent.py

@@ -20,7 +20,7 @@ from letta.constants import (
     REQ_HEARTBEAT_MESSAGE,
     STRUCTURED_OUTPUT_MODELS,
 )
-from letta.errors import LLMError
+from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import is_context_overflow_error
@@ -1094,6 +1094,7 @@ class Agent(BaseAgent):
 
             # If we got a context alert, try trimming the messages length, then try again
             if is_context_overflow_error(e):
+                printd(f"context window exceeded with limit {self.agent_state.llm_config.context_window}, running summarizer to trim messages")
                 # A separate API call to run a summarizer
                 self.summarize_messages_inplace()
 
@@ -1169,8 +1170,13 @@ class Agent(BaseAgent):
 
         # If at this point there's nothing to summarize, throw an error
         if len(candidate_messages_to_summarize) == 0:
-            raise LLMError(
-                f"Summarize error: tried to run summarize, but couldn't find enough messages to compress [len={len(self.messages)}, preserve_N={MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST}]"
+            raise ContextWindowExceededError(
+                "Not enough messages to compress for summarization",
+                details={
+                    "num_candidate_messages": len(candidate_messages_to_summarize),
+                    "num_total_messages": len(self.messages),
+                    "preserve_N": MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
+                },
             )
 
         # Walk down the message buffer (front-to-back) until we hit the target token count
@@ -1204,8 +1210,13 @@ class Agent(BaseAgent):
         message_sequence_to_summarize = self._messages[1:cutoff]  # do NOT get rid of the system message
         if len(message_sequence_to_summarize) <= 1:
             # This prevents a potential infinite loop of summarizing the same message over and over
-            raise LLMError(
-                f"Summarize error: tried to run summarize, but couldn't find enough messages to compress [len={len(message_sequence_to_summarize)} <= 1]"
+            raise ContextWindowExceededError(
+                "Not enough messages to compress for summarization after determining cutoff",
+                details={
+                    "num_candidate_messages": len(message_sequence_to_summarize),
+                    "num_total_messages": len(self.messages),
+                    "preserve_N": MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
+                },
             )
         else:
             printd(f"Attempting to summarize {len(message_sequence_to_summarize)} messages [1:{cutoff}] of {len(self._messages)}")
@@ -1218,6 +1229,7 @@ class Agent(BaseAgent):
             self.agent_state.llm_config.context_window = (
                 LLM_MAX_TOKENS[self.model] if (self.model is not None and self.model in LLM_MAX_TOKENS) else LLM_MAX_TOKENS["DEFAULT"]
             )
+
         summary = summarize_messages(agent_state=self.agent_state, message_sequence_to_summarize=message_sequence_to_summarize)
         printd(f"Got summary: {summary}")
 

letta/client/client.py

@@ -233,7 +233,7 @@ class AbstractClient(object):
     def get_tool_id(self, name: str) -> Optional[str]:
         raise NotImplementedError
 
-    def add_base_tools(self) -> List[Tool]:
+    def upsert_base_tools(self) -> List[Tool]:
         raise NotImplementedError
 
     def load_data(self, connector: DataConnector, source_name: str):
@@ -1466,7 +1466,7 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to get tool: {response.text}")
         return response.json()
 
-    def add_base_tools(self) -> List[Tool]:
+    def upsert_base_tools(self) -> List[Tool]:
         response = requests.post(f"{self.base_url}/{self.api_prefix}/tools/add-base-tools/", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to add base tools: {response.text}")

letta/errors.py

@@ -1,4 +1,5 @@
 import json
+from enum import Enum
 from typing import TYPE_CHECKING, List, Optional, Union
 
 # Avoid circular imports
@@ -6,9 +7,31 @@ if TYPE_CHECKING:
     from letta.schemas.message import Message
 
 
+class ErrorCode(Enum):
+    """Enum for error codes used by client."""
+
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+    CONTEXT_WINDOW_EXCEEDED = "CONTEXT_WINDOW_EXCEEDED"
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
+
+
 class LettaError(Exception):
     """Base class for all Letta related errors."""
 
+    def __init__(self, message: str, code: Optional[ErrorCode] = None, details: dict = {}):
+        self.message = message
+        self.code = code
+        self.details = details
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        if self.code:
+            return f"{self.code.value}: {self.message}"
+        return self.message
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(message='{self.message}', code='{self.code}', details={self.details})"
+
 
 class LettaToolCreateError(LettaError):
     """Error raised when a tool cannot be created."""
@@ -16,10 +39,7 @@ class LettaToolCreateError(LettaError):
     default_error_message = "Error creating tool."
 
     def __init__(self, message=None):
-        if message is None:
-            message = self.default_error_message
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message or self.default_error_message)
 
 
 class LettaConfigurationError(LettaError):
@@ -27,23 +47,17 @@ class LettaConfigurationError(LettaError):
 
     def __init__(self, message: str, missing_fields: Optional[List[str]] = None):
         self.missing_fields = missing_fields or []
-        super().__init__(message)
+        super().__init__(message=message, details={"missing_fields": self.missing_fields})
 
 
 class LettaAgentNotFoundError(LettaError):
     """Error raised when an agent is not found."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(self.message)
+    pass
 
 
 class LettaUserNotFoundError(LettaError):
     """Error raised when a user is not found."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(self.message)
+    pass
 
 
 class LLMError(LettaError):
@@ -54,24 +68,45 @@ class LLMJSONParsingError(LettaError):
     """Exception raised for errors in the JSON parsing process."""
 
     def __init__(self, message="Error parsing JSON generated by LLM"):
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message)
 
 
 class LocalLLMError(LettaError):
     """Generic catch-all error for local LLM problems"""
 
     def __init__(self, message="Encountered an error while running local LLM"):
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message)
 
 
 class LocalLLMConnectionError(LettaError):
     """Error for when local LLM cannot be reached with provided IP/port"""
 
     def __init__(self, message="Could not connect to local LLM"):
-        self.message = message
-        super().__init__(self.message)
+        super().__init__(message=message)
+
+
+class ContextWindowExceededError(LettaError):
+    """Error raised when the context window is exceeded but further summarization fails."""
+
+    def __init__(self, message: str, details: dict = {}):
+        error_message = f"{message} ({details})"
+        super().__init__(
+            message=error_message,
+            code=ErrorCode.CONTEXT_WINDOW_EXCEEDED,
+            details=details,
+        )
+
+
+class RateLimitExceededError(LettaError):
+    """Error raised when the llm rate limiter throttles api requests."""
+
+    def __init__(self, message: str, max_retries: int):
+        error_message = f"{message} ({max_retries})"
+        super().__init__(
+            message=error_message,
+            code=ErrorCode.RATE_LIMIT_EXCEEDED,
+            details={"max_retries": max_retries},
+        )
 
 
 class LettaMessageError(LettaError):

letta/functions/function_sets/base.py

@@ -61,60 +61,6 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     return results_str
 
 
-def conversation_search_date(self: "Agent", start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
-    """
-    Search prior conversation history using a date range.
-
-    Args:
-        start_date (str): The start of the date range to search, in the format 'YYYY-MM-DD'.
-        end_date (str): The end of the date range to search, in the format 'YYYY-MM-DD'.
-        page (int): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
-
-    Returns:
-        str: Query result string
-    """
-    import math
-    from datetime import datetime
-
-    from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    from letta.utils import json_dumps
-
-    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
-        page = 0
-    try:
-        page = int(page)
-        if page < 0:
-            raise ValueError
-    except:
-        raise ValueError(f"'page' argument must be an integer")
-
-    # Convert date strings to datetime objects
-    try:
-        start_datetime = datetime.strptime(start_date, "%Y-%m-%d").replace(hour=0, minute=0, second=0, microsecond=0)
-        end_datetime = datetime.strptime(end_date, "%Y-%m-%d").replace(hour=23, minute=59, second=59, microsecond=999999)
-    except ValueError:
-        raise ValueError("Dates must be in the format 'YYYY-MM-DD'")
-
-    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results = self.message_manager.list_user_messages_for_agent(
-        # TODO: add paging by page number. currently cursor only works with strings.
-        agent_id=self.agent_state.id,
-        actor=self.user,
-        start_date=start_datetime,
-        end_date=end_datetime,
-        limit=count,
-    )
-    total = len(results)
-    num_pages = math.ceil(total / count) - 1  # 0 index
-    if len(results) == 0:
-        results_str = f"No results found."
-    else:
-        results_pref = f"Showing {len(results)} of {total} results (page {page}/{num_pages}):"
-        results_formatted = [f"timestamp: {d['timestamp']}, {d['message']['role']} - {d['message']['content']}" for d in results]
-        results_str = f"{results_pref} {json_dumps(results_formatted)}"
-    return results_str
-
-
 def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     """
     Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.

letta/llm_api/llm_api_tools.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Union
 import requests
 
 from letta.constants import CLI_WARNING_PREFIX
-from letta.errors import LettaConfigurationError
+from letta.errors import LettaConfigurationError, RateLimitExceededError
 from letta.llm_api.anthropic import anthropic_chat_completions_request
 from letta.llm_api.azure_openai import azure_openai_chat_completions_request
 from letta.llm_api.google_ai import (
@@ -80,7 +80,7 @@ def retry_with_exponential_backoff(
 
                     # Check if max retries has been reached
                     if num_retries > max_retries:
-                        raise Exception(f"Maximum number of retries ({max_retries}) exceeded.")
+                        raise RateLimitExceededError("Maximum number of retries exceeded", max_retries=max_retries)
 
                     # Increment the delay
                     delay *= exponential_base * (1 + jitter * random.random())

letta/orm/message.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from sqlalchemy import Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.custom_columns import ToolCallColumn
@@ -13,7 +14,7 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     """Defines data model for storing Message objects"""
 
     __tablename__ = "messages"
-    __table_args__ = {"extend_existing": True}
+    __table_args__ = (Index("ix_messages_agent_created_at", "agent_id", "created_at"),)
     __pydantic_model__ = PydanticMessage
 
     id: Mapped[str] = mapped_column(primary_key=True, doc="Unique message identifier")

letta/orm/passage.py

@@ -1,26 +1,26 @@
 from typing import TYPE_CHECKING
-from sqlalchemy import Column, JSON, Index
-from sqlalchemy.orm import Mapped, mapped_column, relationship, declared_attr
 
-from letta.orm.mixins import FileMixin, OrganizationMixin
+from sqlalchemy import JSON, Column, Index
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
+
+from letta.config import LettaConfig
+from letta.constants import MAX_EMBEDDING_DIM
 from letta.orm.custom_columns import CommonVector, EmbeddingConfigColumn
-from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin, SourceMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.settings import settings
 
-from letta.config import LettaConfig
-from letta.constants import MAX_EMBEDDING_DIM
-
 config = LettaConfig()
 
 if TYPE_CHECKING:
-    from letta.orm.organization import Organization
     from letta.orm.agent import Agent
+    from letta.orm.organization import Organization
 
 
 class BasePassage(SqlalchemyBase, OrganizationMixin):
     """Base class for all passage types with common fields"""
+
     __abstract__ = True
     __pydantic_model__ = PydanticPassage
 
@@ -45,17 +45,15 @@ class BasePassage(SqlalchemyBase, OrganizationMixin):
     @declared_attr
     def __table_args__(cls):
         if settings.letta_pg_uri_no_default:
-            return (
-                Index(f'{cls.__tablename__}_org_idx', 'organization_id'),
-                {"extend_existing": True}
-            )
+            return (Index(f"{cls.__tablename__}_org_idx", "organization_id"), {"extend_existing": True})
         return ({"extend_existing": True},)
 
 
 class SourcePassage(BasePassage, FileMixin, SourceMixin):
     """Passages derived from external files/sources"""
+
     __tablename__ = "source_passages"
-    
+
     @declared_attr
     def file(cls) -> Mapped["FileMetadata"]:
         """Relationship to file"""
@@ -64,7 +62,7 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
         return relationship("Organization", back_populates="source_passages", lazy="selectin")
-        
+
     @declared_attr
     def source(cls) -> Mapped["Source"]:
         """Relationship to source"""
@@ -73,8 +71,9 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
 
 class AgentPassage(BasePassage, AgentMixin):
     """Passages created by agents as archival memories"""
+
     __tablename__ = "agent_passages"
-    
+
     @declared_attr
     def organization(cls) -> Mapped["Organization"]:
         return relationship("Organization", back_populates="agent_passages", lazy="selectin")

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

@@ -17,6 +17,7 @@ from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
 from letta.schemas.block import (  # , BlockLabelUpdate, BlockLimitUpdate
@@ -54,6 +55,8 @@ from letta.server.server import SyncServer
 
 router = APIRouter(prefix="/agents", tags=["agents"])
 
+logger = get_logger(__name__)
+
 
 # TODO: This should be paginated
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")
@@ -453,6 +456,13 @@ def get_agent_messages(
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
 
+    # TODO: Temporary debugging logs for debugging very slow endpoint
+    import uuid
+
+    temp_rand_uuid = uuid.uuid4()
+
+    logger.info(f"[{temp_rand_uuid}] RECEIVED GET /messages for agent_id={agent_id} before={before} limit={limit}")
+
     return server.get_agent_recall_cursor(
         user_id=actor.id,
         agent_id=agent_id,
@@ -462,6 +472,7 @@ def get_agent_messages(
         return_message_object=msg_object,
         assistant_message_tool_name=assistant_message_tool_name,
         assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+        temp_rand_uuid=temp_rand_uuid,
     )
 
 

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

@@ -152,30 +152,15 @@ def update_tool(
 
 
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")
-def add_base_tools(
+def upsert_base_tools(
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
-    Add base tools
+    Upsert base tools
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.tool_manager.add_base_tools(actor=actor)
-
-
-# NOTE: can re-enable if needed
-# @router.post("/{tool_id}/run", response_model=FunctionReturn, operation_id="run_tool")
-# def run_tool(
-#     server: SyncServer = Depends(get_letta_server),
-#     request: ToolRun = Body(...),
-#     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-# ):
-#     """
-#     Run an existing tool on provided arguments
-#     """
-#     actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-#     return server.run_tool(tool_id=request.tool_id, tool_args=request.tool_args, user_id=actor.id)
+    return server.tool_manager.upsert_base_tools(actor=actor)
 
 
 @router.post("/run", response_model=FunctionReturn, operation_id="run_tool_from_source")

letta/server/rest_api/utils.py

@@ -8,6 +8,7 @@ from typing import AsyncGenerator, Optional, Union
 from fastapi import Header
 from pydantic import BaseModel
 
+from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.schemas.usage import LettaUsageStatistics
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.server import SyncServer
@@ -61,34 +62,21 @@ async def sse_async_generator(
                 if not isinstance(usage, LettaUsageStatistics):
                     raise ValueError(f"Expected LettaUsageStatistics, got {type(usage)}")
                 yield sse_formatter({"usage": usage.model_dump()})
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                warnings.warn(f"SSE stream generator failed: {e}")
 
-                # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
-                # Print the stack trace
-                if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
-                    import sentry_sdk
+            except ContextWindowExceededError as e:
+                log_error_to_sentry(e)
+                yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
-                    sentry_sdk.capture_exception(e)
+            except RateLimitExceededError as e:
+                log_error_to_sentry(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)
                 yield sse_formatter({"error": f"Stream failed (internal error occured)"})
 
     except Exception as e:
-        import traceback
-
-        traceback.print_exc()
-        warnings.warn(f"SSE stream generator failed: {e}")
-
-        # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
-        # Print the stack trace
-        if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
-            import sentry_sdk
-
-            sentry_sdk.capture_exception(e)
-
+        log_error_to_sentry(e)
         yield sse_formatter({"error": "Stream failed (decoder encountered an error)"})
 
     finally:
@@ -113,3 +101,16 @@ def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optio
 
 def get_current_interface() -> StreamingServerInterface:
     return StreamingServerInterface
+
+def log_error_to_sentry(e):
+    import traceback
+
+    traceback.print_exc()
+    warnings.warn(f"SSE stream generator failed: {e}")
+
+    # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
+    # Print the stack trace
+    if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+        import sentry_sdk
+
+        sentry_sdk.capture_exception(e)

letta/server/server.py

@@ -301,7 +301,7 @@ class SyncServer(Server):
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
             self.block_manager.add_default_blocks(actor=self.default_user)
-            self.tool_manager.add_base_tools(actor=self.default_user)
+            self.tool_manager.upsert_base_tools(actor=self.default_user)
 
             # If there is a default org/user
             # This logic may have to change in the future
@@ -979,16 +979,32 @@ class SyncServer(Server):
         return_message_object: bool = True,
         assistant_message_tool_name: str = constants.DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
+        temp_rand_uuid: Optional[str] = None,
     ) -> Union[List[Message], List[LettaMessage]]:
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
+        import datetime
+
+        start_time = datetime.datetime.utcnow()
+
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Fetching actor for user_id={user_id} (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Loading agent object for agent_id={agent_id} (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
 
-        # iterate over records
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Resolving start_date and end_date for filtering messages (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         start_date = self.message_manager.get_message_by_id(after, actor=actor).created_at if after else None
         end_date = self.message_manager.get_message_by_id(before, actor=actor).created_at if before else None
+
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Fetching messages for agent_id={agent_id}, start_date={start_date}, end_date={end_date}, limit={limit}, reverse={reverse} (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         records = letta_agent.message_manager.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
@@ -998,10 +1014,15 @@ class SyncServer(Server):
             ascending=not reverse,
         )
 
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Validating message types (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         assert all(isinstance(m, Message) for m in records)
 
         if not return_message_object:
-            # If we're GETing messages in reverse, we need to reverse the inner list (generated by to_letta_message)
+            logger.info(
+                f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Converting messages to LettaMessage objects (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+            )
             records = [
                 msg
                 for m in records
@@ -1012,8 +1033,14 @@ class SyncServer(Server):
             ]
 
         if reverse:
+            logger.info(
+                f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Reversing message order (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+            )
             records = records[::-1]
 
+        logger.info(
+            f"[{temp_rand_uuid}] {datetime.datetime.utcnow()} - Returning {len(records)} messages (Elapsed: {(datetime.datetime.utcnow() - start_time).total_seconds()}s)"
+        )
         return records
 
     def get_server_config(self, include_defaults: bool = False) -> dict:

letta/services/agent_manager.py

@@ -1,18 +1,18 @@
-from typing import Dict, List, Optional
 from datetime import datetime
-import numpy as np
+from typing import Dict, List, Optional
 
-from sqlalchemy import select, union_all, literal, func, Select
+import numpy as np
+from sqlalchemy import Select, func, literal, select, union_all
 
 from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, MAX_EMBEDDING_DIM
 from letta.embeddings import embedding_model
 from letta.log import get_logger
 from letta.orm import Agent as AgentModel
+from letta.orm import AgentPassage
 from letta.orm import Block as BlockModel
 from letta.orm import Source as SourceModel
+from letta.orm import SourcePassage, SourcesAgents
 from letta.orm import Tool as ToolModel
-from letta.orm import AgentPassage, SourcePassage
-from letta.orm import SourcesAgents
 from letta.orm.errors import NoResultFound
 from letta.orm.sqlite_functions import adapt_array
 from letta.schemas.agent import AgentState as PydanticAgentState
@@ -77,6 +77,8 @@ class AgentManager:
             tool_names.extend(BASE_TOOLS + BASE_MEMORY_TOOLS)
         if agent_create.tools:
             tool_names.extend(agent_create.tools)
+        # Remove duplicates
+        tool_names = list(set(tool_names))
 
         tool_ids = agent_create.tool_ids or []
         for tool_name in tool_names:
@@ -431,7 +433,7 @@ class AgentManager:
         agent_only: bool = False,
     ) -> Select:
         """Helper function to build the base passage query with all filters applied.
-        
+
         Returns the query before any limit or count operations are applied.
         """
         embedded_text = None
@@ -448,21 +450,14 @@ class AgentManager:
             if not agent_only:  # Include source passages
                 if agent_id is not None:
                     source_passages = (
-                        select(
-                            SourcePassage,
-                            literal(None).label('agent_id')
-                        )
+                        select(SourcePassage, literal(None).label("agent_id"))
                         .join(SourcesAgents, SourcesAgents.source_id == SourcePassage.source_id)
                         .where(SourcesAgents.agent_id == agent_id)
                         .where(SourcePassage.organization_id == actor.organization_id)
                     )
                 else:
-                    source_passages = (
-                        select(
-                            SourcePassage,
-                            literal(None).label('agent_id')
-                        )
-                        .where(SourcePassage.organization_id == actor.organization_id)
+                    source_passages = select(SourcePassage, literal(None).label("agent_id")).where(
+                        SourcePassage.organization_id == actor.organization_id
                     )
 
                 if source_id:
@@ -486,9 +481,9 @@ class AgentManager:
                         AgentPassage._created_by_id,
                         AgentPassage._last_updated_by_id,
                         AgentPassage.organization_id,
-                        literal(None).label('file_id'),
-                        literal(None).label('source_id'),
-                        AgentPassage.agent_id
+                        literal(None).label("file_id"),
+                        literal(None).label("source_id"),
+                        AgentPassage.agent_id,
                     )
                     .where(AgentPassage.agent_id == agent_id)
                     .where(AgentPassage.organization_id == actor.organization_id)
@@ -496,11 +491,11 @@ class AgentManager:
 
             # Combine queries
             if source_passages is not None and agent_passages is not None:
-                combined_query = union_all(source_passages, agent_passages).cte('combined_passages')
+                combined_query = union_all(source_passages, agent_passages).cte("combined_passages")
             elif agent_passages is not None:
-                combined_query = agent_passages.cte('combined_passages')
+                combined_query = agent_passages.cte("combined_passages")
             elif source_passages is not None:
-                combined_query = source_passages.cte('combined_passages')
+                combined_query = source_passages.cte("combined_passages")
             else:
                 raise ValueError("No passages found")
 
@@ -521,9 +516,7 @@ class AgentManager:
             if embedded_text:
                 if settings.letta_pg_uri_no_default:
                     # PostgreSQL with pgvector
-                    main_query = main_query.order_by(
-                        combined_query.c.embedding.cosine_distance(embedded_text).asc()
-                    )
+                    main_query = main_query.order_by(combined_query.c.embedding.cosine_distance(embedded_text).asc())
                 else:
                     # SQLite with custom vector type
                     query_embedding_binary = adapt_array(embedded_text)
@@ -531,13 +524,13 @@ class AgentManager:
                         main_query = main_query.order_by(
                             func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
                             combined_query.c.created_at.asc(),
-                            combined_query.c.id.asc()
+                            combined_query.c.id.asc(),
                         )
                     else:
                         main_query = main_query.order_by(
                             func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
                             combined_query.c.created_at.desc(),
-                            combined_query.c.id.asc()
+                            combined_query.c.id.asc(),
                         )
             else:
                 if query_text:
@@ -545,18 +538,12 @@ class AgentManager:
 
             # Handle cursor-based pagination
             if cursor:
-                cursor_query = select(combined_query.c.created_at).where(
-                    combined_query.c.id == cursor
-                ).scalar_subquery()
-                
+                cursor_query = select(combined_query.c.created_at).where(combined_query.c.id == cursor).scalar_subquery()
+
                 if ascending:
-                    main_query = main_query.where(
-                        combined_query.c.created_at > cursor_query
-                    )
+                    main_query = main_query.where(combined_query.c.created_at > cursor_query)
                 else:
-                    main_query = main_query.where(
-                        combined_query.c.created_at < cursor_query
-                    )
+                    main_query = main_query.where(combined_query.c.created_at < cursor_query)
 
             # Add ordering if not already ordered by similarity
             if not embed_query:
@@ -588,7 +575,7 @@ class AgentManager:
         embed_query: bool = False,
         ascending: bool = True,
         embedding_config: Optional[EmbeddingConfig] = None,
-        agent_only: bool = False
+        agent_only: bool = False,
     ) -> List[PydanticPassage]:
         """Lists all passages attached to an agent."""
         with self.session_maker() as session:
@@ -617,19 +604,18 @@ class AgentManager:
             passages = []
             for row in results:
                 data = dict(row._mapping)
-                if data['agent_id'] is not None:
+                if data["agent_id"] is not None:
                     # This is an AgentPassage - remove source fields
-                    data.pop('source_id', None)
-                    data.pop('file_id', None)
+                    data.pop("source_id", None)
+                    data.pop("file_id", None)
                     passage = AgentPassage(**data)
                 else:
                     # This is a SourcePassage - remove agent field
-                    data.pop('agent_id', None)
+                    data.pop("agent_id", None)
                     passage = SourcePassage(**data)
                 passages.append(passage)
-            
-            return [p.to_pydantic() for p in passages]
 
+            return [p.to_pydantic() for p in passages]
 
     @enforce_types
     def passage_size(
@@ -645,7 +631,7 @@ class AgentManager:
         embed_query: bool = False,
         ascending: bool = True,
         embedding_config: Optional[EmbeddingConfig] = None,
-        agent_only: bool = False
+        agent_only: bool = False,
     ) -> int:
         """Returns the count of passages matching the given criteria."""
         with self.session_maker() as session:
@@ -663,7 +649,7 @@ class AgentManager:
                 embedding_config=embedding_config,
                 agent_only=agent_only,
             )
-            
+
             # Convert to count query
             count_query = select(func.count()).select_from(main_query.subquery())
             return session.scalar(count_query) or 0

letta/services/tool_manager.py

@@ -3,6 +3,7 @@ import inspect
 import warnings
 from typing import List, Optional
 
+from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS
 from letta.functions.functions import derive_openai_json_schema, load_function_set
 
 # TODO: Remove this once we translate all of these to the ORM
@@ -20,7 +21,6 @@ class ToolManager:
     BASE_TOOL_NAMES = [
         "send_message",
         "conversation_search",
-        "conversation_search_date",
         "archival_memory_insert",
         "archival_memory_search",
     ]
@@ -133,7 +133,7 @@ class ToolManager:
                 raise ValueError(f"Tool with id {tool_id} not found.")
 
     @enforce_types
-    def add_base_tools(self, actor: PydanticUser) -> List[PydanticTool]:
+    def upsert_base_tools(self, actor: PydanticUser) -> List[PydanticTool]:
         """Add default tools in base.py"""
         module_name = "base"
         full_module_name = f"letta.functions.function_sets.{module_name}"
@@ -154,7 +154,7 @@ class ToolManager:
         # create tool in db
         tools = []
         for name, schema in functions_to_schema.items():
-            if name in self.BASE_TOOL_NAMES + self.BASE_MEMORY_TOOL_NAMES:
+            if name in BASE_TOOLS + BASE_MEMORY_TOOLS:
                 # print([str(inspect.getsource(line)) for line in schema["imports"]])
                 source_code = inspect.getsource(schema["python_function"])
                 tags = [module_name]

{letta_nightly-0.6.5.dev20241218213641.dist-info → letta_nightly-0.6.5.dev20241219104153.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.5.dev20241218213641
+Version: 0.6.5.dev20241219104153
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.5.dev20241218213641.dist-info → letta_nightly-0.6.5.dev20241219104153.dist-info}/RECORD

@@ -1,6 +1,6 @@
 letta/__init__.py,sha256=zY_5By7t8Jgl0Nejq2i4yOTJQg0lzJNlwdmp8sB-W9Y,1014
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=I4qbwYEkq9ZXYb_ToRRdGfNnMIkeI715vXRziQu731Y,77721
+letta/agent.py,sha256=qFWmRmpjBtIA-fQ3zhStLeHb69vvz4Hf1tygvAOrJqw,78266
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/chat_only_agent.py,sha256=3wBCzddcfF6IMbPdDtTZFze5-HJSYxHd8w6jkkSwzsw,4628
@@ -8,7 +8,7 @@ letta/cli/cli.py,sha256=N6jCmysldhAGTQPkGDmRVMAIID7GlgECXqarcMV5h3M,16502
 letta/cli/cli_config.py,sha256=tB0Wgz3O9j6KiCsU1HWfsKmhNM9RqLsAxzxEDFQFGnM,8565
 letta/cli/cli_load.py,sha256=xFw-CuzjChcIptaqQ1XpDROENt0JSjyPeiQ0nmEeO1k,2706
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=VG2I6YwAOUwENuqpgzU2PZh5QHl6Web09OpIL3Tz8eA,126667
+letta/client/client.py,sha256=hQDOqeWIeHNvvWTiO6QgBcuzHQ54V-G0DjtbJ-ycL9Y,126673
 letta/client/streaming.py,sha256=Hh5pjlyrdCuO2V75ZCxSSOCPd3BmHdKFGaIUJC6fBp0,4775
 letta/client/utils.py,sha256=OJlAKWrldc4I6M1WpcTWNtPJ4wfxlzlZqWLfCozkFtI,2872
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
@@ -17,9 +17,9 @@ letta/credentials.py,sha256=D9mlcPsdDWlIIXQQD8wSPE9M_QvsRrb0p3LB5i9OF5Q,5806
 letta/data_sources/connectors.py,sha256=Bwgf6mW55rDrdX69dY3bLzQW9Uuk_o9w4skwbx1NioY,7039
 letta/data_sources/connectors_helper.py,sha256=2TQjCt74fCgT5sw1AP8PalDEk06jPBbhrPG4HVr-WLs,3371
 letta/embeddings.py,sha256=r1jWuZplYZl8GzfObBZxPdKWg2O0Msd8D164qSoCPIM,8855
-letta/errors.py,sha256=Voy_BP0W_M816-vWudKLBlgydRufPPA-Q2PNd-SvZYc,3897
+letta/errors.py,sha256=Suh7081WzyH-LcAaJGs8tQ6TQ6b4ATd5cmUyBCa5aoA,5139
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/functions/function_sets/base.py,sha256=OcjkPBfurAGWSXfvG8i108c5cpA9lnykC9COXXmzbM8,8173
+letta/functions/function_sets/base.py,sha256=bOiitkhzqYKwZBiRYrx29AlordiA5IrXw25eVSRK8BY,5984
 letta/functions/function_sets/extras.py,sha256=Jik3UiDqYTm4Lam1XPTvuVjvgUHwIAhopsnbmVhGMBg,4732
 letta/functions/functions.py,sha256=evH6GKnIJwVVre1Xre2gaSIqREv4eNM4DiWOhn8PMqg,3299
 letta/functions/helpers.py,sha256=fJo4gPvWpkvR7jn0HucRorz4VlpYVqmYsiX1RetnnSY,8569
@@ -37,7 +37,7 @@ letta/llm_api/azure_openai_constants.py,sha256=oXtKrgBFHf744gyt5l1thILXgyi8NDNUr
 letta/llm_api/cohere.py,sha256=vDRd-SUGp1t_JUIdwC3RkIhwMl0OY7n-tAU9uPORYkY,14826
 letta/llm_api/google_ai.py,sha256=xKz9JDZs3m6yzSfcgCAAUD_rjI20BBIINoiSvlcnOw0,17621
 letta/llm_api/helpers.py,sha256=F8xZDZgDojWX5v-0vakyeUQyCyBr1HmzmsITRdOsmVg,13457
-letta/llm_api/llm_api_tools.py,sha256=MadPiVSc_JYwf5dwpeCc5lRBN3rBmsops5EQy2HW-gw,17687
+letta/llm_api/llm_api_tools.py,sha256=Qb1NsOOLmgMzMZ_A1J0v2EoQPm444Z2kZ9d-5j-FL6c,17731
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
 letta/llm_api/openai.py,sha256=4GEGROTv4vLawSgODnAHCI-DeIWDqrhuxtKrqYzHvso,24160
 letta/local_llm/README.md,sha256=hFJyw5B0TU2jrh9nb0zGZMgdH-Ei1dSRfhvPQG_NSoU,168
@@ -96,10 +96,10 @@ letta/orm/enums.py,sha256=KfHcFt_fR6GUmSlmfsa-TetvmuRxGESNve8MStRYW64,145
 letta/orm/errors.py,sha256=Se0Guz-gqi-D36NUWSh7AP9zTVCSph9KgZh_trwng4o,734
 letta/orm/file.py,sha256=0qfqmBFizwtYriCz_qrshjxw3A9lMaRFKtwsZecviyo,1765
 letta/orm/job.py,sha256=If-qSTJW4t5h-6Jolw3tS3-xMZEaPIbXe3S0GMf_FXI,1102
-letta/orm/message.py,sha256=yWf46-adgYGqhxjn_QREW19jvVjYU0eD11uwlVSrdT4,1490
+letta/orm/message.py,sha256=Ui3mMZTAObP7RvmNnqCFudw8Pkt8IAPTlIjCSCsVDFA,1560
 letta/orm/mixins.py,sha256=fBT4WjKDfDgGkkOHD8lFAaofDKElTLOx3oM1d6yQHSk,1620
 letta/orm/organization.py,sha256=PSu9pHBT_YYdZo7Z7AZBBM4veOzD7x2H2NYN4SjD82E,2519
-letta/orm/passage.py,sha256=fsETrGtmiGI45N5Rc2pMLy-9Mzggn6FZ-fRwI-0x-Hg,3249
+letta/orm/passage.py,sha256=tm5YhUozLR9hN7odGCqCniTl-3GDiFNz3LWAxullaGA,3132
 letta/orm/sandbox_config.py,sha256=PCMHE-eJPzBT-90OYtXjEMRF4f9JB8AJIGETE7bu-f0,2870
 letta/orm/source.py,sha256=SlX08BnoJYMh34cGTuPbo2kraCuXSy25xGdNWb7d7DQ,1782
 letta/orm/sources_agents.py,sha256=q5Wf5TFNI9KH6cGW93roNhvFD3n39UE2bYQhnSJwlME,433
@@ -180,7 +180,7 @@ letta/server/rest_api/routers/openai/assistants/schemas.py,sha256=d3LdBLUI-mMUCP
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=Yvhcr1FVk1JltXg8PRwkJf8TD1fO4ARDAVsMmHY5xzc,4849
 letta/server/rest_api/routers/v1/__init__.py,sha256=RZc0fIHNN4BGretjU6_TGK7q49RyV4jfYNudoiK_sUo,762
-letta/server/rest_api/routers/v1/agents.py,sha256=ryzV4R0Tfhkk0MDuSQFg1DXuHOpLgtYsajx6toAlK3g,30295
+letta/server/rest_api/routers/v1/agents.py,sha256=JIeHoe-C1_6PaSSYWuj5GPbHBEiWLqsQJzb_HCebvHw,30637
 letta/server/rest_api/routers/v1/blocks.py,sha256=IJ2pppwNooaUjIwyBALnKL4sJ8idW8cVJlY-VH_J9HY,4803
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
 letta/server/rest_api/routers/v1/jobs.py,sha256=-tEyuIxlXZfPREeMks-sRzHwhKE2xxgzbXeEbBAS2Q8,2730
@@ -188,11 +188,11 @@ letta/server/rest_api/routers/v1/llms.py,sha256=TcyvSx6MEM3je5F4DysL7ligmssL_pFl
 letta/server/rest_api/routers/v1/organizations.py,sha256=tyqVzXTpMtk3sKxI3Iz4aS6RhbGEbXDzFBB_CpW18v4,2080
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=pG3X3bYbmsq90kRc-06qfnM6yalvYEpVVEQnTuZVm0o,5134
 letta/server/rest_api/routers/v1/sources.py,sha256=bLvxyYBOLx1VD5YPuoCBrQrua0AruzUzvCMIiekjVQg,9974
-letta/server/rest_api/routers/v1/tools.py,sha256=g6LKwz6aamNwMrjMqUSYDu8X0FjKAzCtOKJRAwcuZEk,11762
+letta/server/rest_api/routers/v1/tools.py,sha256=y6Dx8VDcq0CShDbMqv47y1dgrT-P6bMAiIQE4CIw9Yo,11170
 letta/server/rest_api/routers/v1/users.py,sha256=EBQe9IfCG3kzHpKmotz4yVGZioXz3SCSRy5yEhJK8hU,2293
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
-letta/server/rest_api/utils.py,sha256=5GO52-3EehRFZPDkvk4pUoHa0GZXvbPuQsmX298gbJg,3905
-letta/server/server.py,sha256=xL1hZ3pS7Imc8CKahTXVkzL-gKjW0pgzJz_jpMrBb7I,60291
+letta/server/rest_api/utils.py,sha256=3wF-KavVVKzcdxcTQ7zzKtQQ1a7jRN3YuKXttrI5S9Y,3963
+letta/server/server.py,sha256=eBLkVhbmPrlNWMI38fI15PjTdLuv9Uc3yQTPxF0JlPg,61973
 letta/server/startup.sh,sha256=722uKJWB2C4q3vjn39De2zzPacaZNw_1fN1SpLGjKIo,1569
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=DjG3J3RSFLcinzoisOYYLiyTAIe5Uaxge3HE-DmQIsU,7688
@@ -206,7 +206,7 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=M_-gM5iuDBwa1cuN2IGNCG5GxMJwU2d3XW93XALv9s8,1821
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=5XODToGznZjdH4J3y-j-ToaP1rsbxQ82YxldEAO6kVU,30678
+letta/services/agent_manager.py,sha256=GQyLp6ZgBCXozkkbfeY81_sFbf-UHVU_ulaTvFO9dCM,30338
 letta/services/block_manager.py,sha256=HUj9HKW2LvAsENEsgCO3Pf3orvSy6XOimev38VKmRZ8,4929
 letta/services/helpers/agent_manager_helper.py,sha256=4AoJJI3ELDZrfhx38vc2OwgQflb7mkdppucln0MkgYg,3457
 letta/services/job_manager.py,sha256=FrkSXloke48CZKuzlYdysxM5gKWoTu7FRigPrs_YW4A,3645
@@ -217,7 +217,7 @@ letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1H
 letta/services/sandbox_config_manager.py,sha256=USTXwEEWexKRZjng4NepP4_eetrxCJ5n16cl2AHJ_VM,13220
 letta/services/source_manager.py,sha256=ZtLQikeJjwAq49f0d4WxUzyUN3LZBqWCZI4a-AzEMWQ,7643
 letta/services/tool_execution_sandbox.py,sha256=NtjSXdm86_lbTeW2gF08tyf2KSoxBP0Bxq7qSNudrGE,21567
-letta/services/tool_manager.py,sha256=lfrfWyxiFUWcEf-nATHs7r76XWutMYbOPyePs543ZOo,7681
+letta/services/tool_manager.py,sha256=eKhvGYNBq8MOwfuk-GyqiTdEcxRn4srYvTJqj-HgTKA,7686
 letta/services/tool_sandbox_env/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/user_manager.py,sha256=oqLF9C4mGbN0TaGj7wMpb2RH2bUg6OJJcdyaWv370rQ,4272
 letta/settings.py,sha256=sC4gS8Po1NyPmSMTk-TTxrKEoJUi8qgou1K3-BqtNA4,3979
@@ -225,8 +225,8 @@ letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=AlGH2fADkU5VkGISj9-hwMSZVKQUiI1whWTvXCKOiYw,33338
-letta_nightly-0.6.5.dev20241218213641.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.5.dev20241218213641.dist-info/METADATA,sha256=-2w35SQszfsdEU08nGDDFTTLCG1gUW3nkpNz226zGSs,21693
-letta_nightly-0.6.5.dev20241218213641.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.5.dev20241218213641.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.5.dev20241218213641.dist-info/RECORD,,
+letta_nightly-0.6.5.dev20241219104153.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.5.dev20241219104153.dist-info/METADATA,sha256=T6o-VctnMHTFvzBlj19iFGVpp7dF3IzSf-4pOjbYB4Y,21693
+letta_nightly-0.6.5.dev20241219104153.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.5.dev20241219104153.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.5.dev20241219104153.dist-info/RECORD,,