letta-nightly 0.5.2.dev20241118104226__py3-none-any.whl → 0.5.3.dev20241120010849__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.2"
+__version__ = "0.5.3"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -27,6 +27,7 @@ from letta.llm_api.llm_api_tools import create
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.memory import ArchivalMemory, RecallMemory, summarize_messages
 from letta.metadata import MetadataStore
+from letta.orm import User
 from letta.persistence_manager import LocalStateManager
 from letta.schemas.agent import AgentState, AgentStepResponse
 from letta.schemas.block import Block
@@ -46,6 +47,7 @@ from letta.schemas.passage import Passage
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
+from letta.services.block_manager import BlockManager
 from letta.services.source_manager import SourceManager
 from letta.services.user_manager import UserManager
 from letta.streaming_interface import StreamingRefreshCLIInterface
@@ -234,6 +236,7 @@ class Agent(BaseAgent):
         # agents can be created from providing agent_state
         agent_state: AgentState,
         tools: List[Tool],
+        user: User,
         # memory: Memory,
         # extras
         messages_total: Optional[int] = None,  # TODO remove?
@@ -245,6 +248,8 @@ class Agent(BaseAgent):
         self.agent_state = agent_state
         assert isinstance(self.agent_state.memory, Memory), f"Memory object is not of type Memory: {type(self.agent_state.memory)}"
 
+        self.user = user
+
         # link tools
         self.link_tools(tools)
 
@@ -1221,7 +1226,9 @@ class Agent(BaseAgent):
                     # future if we expect templates to change often.
                     continue
                 block_id = block.get("id")
-                db_block = ms.get_block(block_id=block_id)
+
+                # TODO: This is really hacky and we should probably figure out how to
+                db_block = BlockManager().get_block_by_id(block_id=block_id, actor=self.user)
                 if db_block is None:
                     # this case covers if someone has deleted a shared block by interacting
                     # with some other agent.
@@ -1584,7 +1591,8 @@ class Agent(BaseAgent):
 
     def count_tokens(self) -> int:
         """Count the tokens in the current context window"""
-        return self.get_context_window().context_window_size_current
+        context_window_breakdown = self.get_context_window()
+        return context_window_breakdown.context_window_size_current
 
 
 def save_agent(agent: Agent, ms: MetadataStore):
@@ -1597,7 +1605,7 @@ def save_agent(agent: Agent, ms: MetadataStore):
 
     # NOTE: we're saving agent memory before persisting the agent to ensure
     # that allocated block_ids for each memory block are present in the agent model
-    save_agent_memory(agent=agent, ms=ms)
+    save_agent_memory(agent=agent)
 
     if ms.get_agent(agent_id=agent.agent_state.id):
         ms.update_agent(agent_state)
@@ -1608,7 +1616,7 @@ def save_agent(agent: Agent, ms: MetadataStore):
     assert isinstance(agent.agent_state.memory, Memory), f"Memory is not a Memory object: {type(agent_state.memory)}"
 
 
-def save_agent_memory(agent: Agent, ms: MetadataStore):
+def save_agent_memory(agent: Agent):
     """
     Save agent memory to metadata store. Memory is a collection of blocks and each block is persisted to the block table.
 
@@ -1617,14 +1625,12 @@ def save_agent_memory(agent: Agent, ms: MetadataStore):
 
     for block_dict in agent.memory.to_dict()["memory"].values():
         # TODO: block creation should happen in one place to enforce these sort of constraints consistently.
-        if block_dict.get("user_id", None) is None:
-            block_dict["user_id"] = agent.agent_state.user_id
         block = Block(**block_dict)
         # FIXME: should we expect for block values to be None? If not, we need to figure out why that is
         # the case in some tests, if so we should relax the DB constraint.
         if block.value is None:
             block.value = ""
-        ms.update_or_create_block(block)
+        BlockManager().create_or_update_block(block, actor=agent.user)
 
 
 def strip_name_field_from_user_message(user_message_text: str) -> Tuple[str, Optional[str]]:

letta/agent_store/db.py

@@ -380,9 +380,10 @@ class PostgresStorageConnector(SQLStorageConnector):
         else:
             raise ValueError(f"Table type {table_type} not implemented")
 
-        for c in self.db_model.__table__.columns:
-            if c.name == "embedding":
-                assert isinstance(c.type, Vector), f"Embedding column must be of type Vector, got {c.type}"
+        if settings.pg_uri:
+            for c in self.db_model.__table__.columns:
+                if c.name == "embedding":
+                    assert isinstance(c.type, Vector), f"Embedding column must be of type Vector, got {c.type}"
 
         from letta.server.server import db_context
 

letta/cli/cli.py

@@ -220,7 +220,7 @@ def run(
 
         # create agent
         tools = [server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=client.user) for tool_name in agent_state.tools]
-        letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools)
+        letta_agent = Agent(agent_state=agent_state, interface=interface(), tools=tools, user=client.user)
 
     else:  # create new agent
         # create new agent config: override defaults with args if provided
@@ -320,6 +320,7 @@ def run(
             tools=tools,
             # gpt-3.5-turbo tends to omit inner monologue, relax this requirement for now
             first_message_verify_mono=True if (model is not None and "gpt-4" in model) else False,
+            user=client.user,
         )
         save_agent(agent=letta_agent, ms=ms)
         typer.secho(f"🎉 Created new agent '{letta_agent.agent_state.name}' (id={letta_agent.agent_state.id})", fg=typer.colors.GREEN)

letta/client/client.py

@@ -12,12 +12,10 @@ from letta.memory import get_memory_functions
 from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgentState
 from letta.schemas.block import (
     Block,
-    CreateBlock,
-    CreateHuman,
-    CreatePersona,
+    BlockCreate,
+    BlockUpdate,
     Human,
     Persona,
-    UpdateBlock,
     UpdateHuman,
     UpdatePersona,
 )
@@ -883,8 +881,8 @@ class RESTClient(AbstractClient):
         else:
             return [Block(**block) for block in response.json()]
 
-    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
-        request = CreateBlock(label=label, value=text, template=template, template_name=template_name)
+    def create_block(self, label: str, value: str, template_name: Optional[str] = None, is_template: bool = False) -> Block:  #
+        request = BlockCreate(label=label, value=value, template=is_template, template_name=template_name)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create block: {response.text}")
@@ -896,7 +894,7 @@ class RESTClient(AbstractClient):
             return Block(**response.json())
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
-        request = UpdateBlock(id=block_id, template_name=name, value=text)
+        request = BlockUpdate(id=block_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{block_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update block: {response.text}")
@@ -950,7 +948,7 @@ class RESTClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.create_block(label="human", template_name=name, text=text, template=True)
+        return self.create_block(label="human", template_name=name, value=text, is_template=True)
 
     def update_human(self, human_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Human:
         """
@@ -990,7 +988,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.create_block(label="persona", template_name=name, text=text, template=True)
+        return self.create_block(label="persona", template_name=name, value=text, is_template=True)
 
     def update_persona(self, persona_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Persona:
         """
@@ -2125,8 +2123,7 @@ class LocalClient(AbstractClient):
     # humans / personas
 
     def get_block_id(self, name: str, label: str) -> str:
-
-        block = self.server.get_blocks(name=name, label=label, user_id=self.user_id, template=True)
+        block = self.server.block_manager.get_blocks(actor=self.user, template_name=name, label=label, is_template=True)
         if not block:
             return None
         return block[0].id
@@ -2142,7 +2139,7 @@ class LocalClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.server.create_block(CreateHuman(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.block_manager.create_or_update_block(Human(template_name=name, value=text), actor=self.user)
 
     def create_persona(self, name: str, text: str):
         """
@@ -2155,7 +2152,7 @@ class LocalClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.server.create_block(CreatePersona(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.block_manager.create_or_update_block(Persona(template_name=name, value=text), actor=self.user)
 
     def list_humans(self):
         """
@@ -2164,7 +2161,7 @@ class LocalClient(AbstractClient):
         Returns:
             humans (List[Human]): List of human blocks
         """
-        return self.server.get_blocks(label="human", user_id=self.user_id, template=True)
+        return self.server.block_manager.get_blocks(actor=self.user, label="human", is_template=True)
 
     def list_personas(self) -> List[Persona]:
         """
@@ -2173,7 +2170,7 @@ class LocalClient(AbstractClient):
         Returns:
             personas (List[Persona]): List of persona blocks
         """
-        return self.server.get_blocks(label="persona", user_id=self.user_id, template=True)
+        return self.server.block_manager.get_blocks(actor=self.user, label="persona", is_template=True)
 
     def update_human(self, human_id: str, text: str):
         """
@@ -2186,7 +2183,9 @@ class LocalClient(AbstractClient):
         Returns:
             human (Human): Updated human block
         """
-        return self.server.update_block(UpdateHuman(id=human_id, value=text, user_id=self.user_id, template=True))
+        return self.server.block_manager.update_block(
+            block_id=human_id, block_update=UpdateHuman(value=text, is_template=True), actor=self.user
+        )
 
     def update_persona(self, persona_id: str, text: str):
         """
@@ -2199,7 +2198,9 @@ class LocalClient(AbstractClient):
         Returns:
             persona (Persona): Updated persona block
         """
-        return self.server.update_block(UpdatePersona(id=persona_id, value=text, user_id=self.user_id, template=True))
+        return self.server.block_manager.update_block(
+            block_id=persona_id, block_update=UpdatePersona(value=text, is_template=True), actor=self.user
+        )
 
     def get_persona(self, id: str) -> Persona:
         """
@@ -2212,7 +2213,7 @@ class LocalClient(AbstractClient):
             persona (Persona): Persona block
         """
         assert id, f"Persona ID must be provided"
-        return Persona(**self.server.get_block(id).model_dump())
+        return Persona(**self.server.block_manager.get_block_by_id(id, actor=self.user).model_dump())
 
     def get_human(self, id: str) -> Human:
         """
@@ -2225,7 +2226,7 @@ class LocalClient(AbstractClient):
             human (Human): Human block
         """
         assert id, f"Human ID must be provided"
-        return Human(**self.server.get_block(id).model_dump())
+        return Human(**self.server.block_manager.get_block_by_id(id, actor=self.user).model_dump())
 
     def get_persona_id(self, name: str) -> str:
         """
@@ -2237,7 +2238,7 @@ class LocalClient(AbstractClient):
         Returns:
             id (str): ID of the persona block
         """
-        persona = self.server.get_blocks(name=name, label="persona", user_id=self.user_id, template=True)
+        persona = self.server.block_manager.get_blocks(actor=self.user, template_name=name, label="persona", is_template=True)
         if not persona:
             return None
         return persona[0].id
@@ -2252,7 +2253,7 @@ class LocalClient(AbstractClient):
         Returns:
             id (str): ID of the human block
         """
-        human = self.server.get_blocks(name=name, label="human", user_id=self.user_id, template=True)
+        human = self.server.block_manager.get_blocks(actor=self.user, template_name=name, label="human", is_template=True)
         if not human:
             return None
         return human[0].id
@@ -2264,7 +2265,7 @@ class LocalClient(AbstractClient):
         Args:
             id (str): ID of the persona block
         """
-        self.server.delete_block(id)
+        self.delete_block(id)
 
     def delete_human(self, id: str):
         """
@@ -2273,7 +2274,7 @@ class LocalClient(AbstractClient):
         Args:
             id (str): ID of the human block
         """
-        self.server.delete_block(id)
+        self.delete_block(id)
 
     # tools
     def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
@@ -2661,9 +2662,9 @@ class LocalClient(AbstractClient):
         Returns:
             blocks (List[Block]): List of blocks
         """
-        return self.server.get_blocks(label=label, template=templates_only)
+        return self.server.block_manager.get_blocks(actor=self.user, label=label, is_template=templates_only)
 
-    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
+    def create_block(self, label: str, value: str, template_name: Optional[str] = None, is_template: bool = False) -> Block:  #
         """
         Create a block
 
@@ -2675,8 +2676,8 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Created block
         """
-        return self.server.create_block(
-            CreateBlock(label=label, template_name=template_name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
+        return self.server.block_manager.create_or_update_block(
+            Block(label=label, template_name=template_name, value=value, is_template=is_template), actor=self.user
         )
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
@@ -2691,7 +2692,9 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Updated block
         """
-        return self.server.update_block(UpdateBlock(id=block_id, template_name=name, value=text))
+        return self.server.block_manager.update_block(
+            block_id=block_id, block_update=BlockUpdate(template_name=name, value=text), actor=self.user
+        )
 
     def get_block(self, block_id: str) -> Block:
         """
@@ -2703,7 +2706,7 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Block
         """
-        return self.server.get_block(block_id)
+        return self.server.block_manager.get_block_by_id(block_id, actor=self.user)
 
     def delete_block(self, id: str) -> Block:
         """
@@ -2715,7 +2718,7 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Deleted block
         """
-        return self.server.delete_block(id)
+        return self.server.block_manager.delete_block(id, actor=self.user)
 
     def set_default_llm_config(self, llm_config: LLMConfig):
         """

letta/constants.py

@@ -19,7 +19,7 @@ IN_CONTEXT_MEMORY_KEYWORD = "CORE_MEMORY"
 TOOL_CALL_ID_MAX_LEN = 29
 
 # minimum context window size
-MIN_CONTEXT_WINDOW = 4000
+MIN_CONTEXT_WINDOW = 4096
 
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
@@ -158,3 +158,6 @@ RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE = 5
 # TODO Is this config or constant?
 CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 2000
 CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 2000
+
+MAX_FILENAME_LENGTH = 255
+RESERVED_FILENAMES = {"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "LPT1", "LPT2"}

letta/functions/functions.py

@@ -3,7 +3,7 @@ import inspect
 import os
 from textwrap import dedent  # remove indentation
 from types import ModuleType
-from typing import Optional
+from typing import Optional, List
 
 from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
@@ -15,6 +15,7 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
         # Define a custom environment with necessary imports
         env = {
             "Optional": Optional,  # Add any other required imports here
+            "List": List
         }
 
         env.update(globals())

letta/llm_api/llm_api_tools.py

@@ -25,6 +25,7 @@ from letta.local_llm.constants import (
     INNER_THOUGHTS_KWARG,
     INNER_THOUGHTS_KWARG_DESCRIPTION,
 )
+from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import (
@@ -33,6 +34,7 @@ from letta.schemas.openai.chat_completion_request import (
     cast_message_to_subtype,
 )
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
+from letta.settings import ModelSettings
 from letta.streaming_interface import (
     AgentChunkStreamingInterface,
     AgentRefreshStreamingInterface,
@@ -122,10 +124,19 @@ def create(
     """Return response to chat completion with backoff"""
     from letta.utils import printd
 
+    # Count the tokens first, if there's an overflow exit early by throwing an error up the stack
+    # NOTE: we want to include a specific substring in the error message to trigger summarization
+    messages_oai_format = [m.to_openai_dict() for m in messages]
+    prompt_tokens = num_tokens_from_messages(messages=messages_oai_format, model=llm_config.model)
+    function_tokens = num_tokens_from_functions(functions=functions, model=llm_config.model) if functions else 0
+    if prompt_tokens + function_tokens > llm_config.context_window:
+        raise Exception(f"Request exceeds maximum context length ({prompt_tokens + function_tokens} > {llm_config.context_window} tokens)")
+
     if not model_settings:
         from letta.settings import model_settings
 
         model_settings = model_settings
+        assert isinstance(model_settings, ModelSettings)
 
     printd(f"Using model {llm_config.model_endpoint_type}, endpoint: {llm_config.model_endpoint}")
 
@@ -326,6 +337,33 @@ def create(
 
         return response
 
+    elif llm_config.model_endpoint_type == "together":
+        """TogetherAI endpoint that goes via /completions instead of /chat/completions"""
+
+        if stream:
+            raise NotImplementedError(f"Streaming not yet implemented for TogetherAI (via the /completions endpoint).")
+
+        if model_settings.together_api_key is None and llm_config.model_endpoint == "https://api.together.ai/v1/completions":
+            raise ValueError(f"TogetherAI key is missing from letta config file")
+
+        return get_chat_completion(
+            model=llm_config.model,
+            messages=messages,
+            functions=functions,
+            functions_python=functions_python,
+            function_call=function_call,
+            context_window=llm_config.context_window,
+            endpoint=llm_config.model_endpoint,
+            endpoint_type="vllm",  # NOTE: use the vLLM path through /completions
+            wrapper=llm_config.model_wrapper,
+            user=str(user_id),
+            # hint
+            first_message=first_message,
+            # auth-related
+            auth_type="bearer_token",  # NOTE: Together expects bearer token auth
+            auth_key=model_settings.together_api_key,
+        )
+
     # local model
     else:
         if stream:

letta/llm_api/openai.py

@@ -536,7 +536,6 @@ def openai_chat_completions_request(
             tool["function"] = convert_to_structured_output(tool["function"])
 
     response_json = make_post_request(url, headers, data)
-
     return ChatCompletionResponse(**response_json)
 
 

letta/local_llm/utils.py

@@ -94,7 +94,10 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
     num_tokens = 0
     for function in functions:
         function_tokens = len(encoding.encode(function["name"]))
-        function_tokens += len(encoding.encode(function["description"]))
+        if function["description"]:
+            function_tokens += len(encoding.encode(function["description"]))
+        else:
+            raise ValueError(f"Function {function['name']} has no description, function: {function}")
 
         if "parameters" in function:
             parameters = function["parameters"]
@@ -184,6 +187,7 @@ def num_tokens_from_messages(messages: List[dict], model: str = "gpt-4") -> int:
         https://community.openai.com/t/how-to-calculate-the-tokens-when-using-function-call/266573/11
     """
     try:
+        # Attempt to search for the encoding based on the model string
         encoding = tiktoken.encoding_for_model(model)
     except KeyError:
         # print("Warning: model not found. Using cl100k_base encoding.")
@@ -228,7 +232,13 @@ def num_tokens_from_messages(messages: List[dict], model: str = "gpt-4") -> int:
                     # num_tokens += len(encoding.encode(value["arguments"]))
 
                 else:
-                    num_tokens += len(encoding.encode(value))
+                    if value is None:
+                        # raise ValueError(f"Message has null value: {key} with value: {value} - message={message}")
+                        warnings.warn(f"Message has null value: {key} with value: {value} - message={message}")
+                    else:
+                        if not isinstance(value, str):
+                            raise ValueError(f"Message has non-string value: {key} with value: {value} - message={message}")
+                        num_tokens += len(encoding.encode(value))
 
                 if key == "name":
                     num_tokens += tokens_per_name