letta-nightly 0.6.8.dev20250110190527__py3-none-any.whl → 0.6.8.dev20250111030335__py3-none-any.whl

letta/agent.py

@@ -7,11 +7,11 @@ from abc import ABC, abstractmethod
 from typing import List, Optional, Tuple, Union
 
 from letta.constants import (
-    BASE_TOOLS,
     CLI_WARNING_PREFIX,
     ERROR_MESSAGE_PREFIX,
     FIRST_MESSAGE_ATTEMPTS,
     FUNC_FAILED_HEARTBEAT_MESSAGE,
+    LETTA_CORE_TOOL_MODULE_NAME,
     LLM_MAX_TOKENS,
     MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
     MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC,
@@ -19,6 +19,7 @@ from letta.constants import (
     REQ_HEARTBEAT_MESSAGE,
 )
 from letta.errors import ContextWindowExceededError
+from letta.functions.functions import get_function_from_module
 from letta.helpers import ToolRulesSolver
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import is_context_overflow_error
@@ -26,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 summarize_messages
 from letta.orm import User
+from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -153,7 +155,7 @@ class Agent(BaseAgent):
                     raise ValueError(f"Invalid JSON format in message: {msg.text}")
         return None
 
-    def update_memory_if_change(self, new_memory: Memory) -> bool:
+    def update_memory_if_changed(self, new_memory: Memory) -> bool:
         """
         Update internal memory object and system prompt if there have been modifications.
 
@@ -192,39 +194,45 @@ class Agent(BaseAgent):
         Execute tool modifications and persist the state of the agent.
         Note: only some agent state modifications will be persisted, such as data in the AgentState ORM and block data
         """
-        # TODO: Get rid of this. This whole piece is pretty shady, that we exec the function to just get the type hints for args.
-        env = {}
-        env.update(globals())
-        exec(target_letta_tool.source_code, env)
-        callable_func = env[target_letta_tool.json_schema["name"]]
-        spec = inspect.getfullargspec(callable_func).annotations
-        for name, arg in function_args.items():
-            if isinstance(function_args[name], dict):
-                function_args[name] = spec[name](**function_args[name])
-
         # TODO: add agent manager here
         orig_memory_str = self.agent_state.memory.compile()
 
         # TODO: need to have an AgentState object that actually has full access to the block data
         # this is because the sandbox tools need to be able to access block.value to edit this data
         try:
-            # TODO: This is NO BUENO
-            # TODO: Matching purely by names is extremely problematic, users can create tools with these names and run them in the agent loop
-            # TODO: We will have probably have to match the function strings exactly for safety
-            if function_name in BASE_TOOLS:
+            if target_letta_tool.tool_type == ToolType.LETTA_CORE:
                 # base tools are allowed to access the `Agent` object and run on the database
+                callable_func = get_function_from_module(LETTA_CORE_TOOL_MODULE_NAME, function_name)
                 function_args["self"] = self  # need to attach self to arg since it's dynamically linked
                 function_response = callable_func(**function_args)
+            elif target_letta_tool.tool_type == ToolType.LETTA_MEMORY_CORE:
+                callable_func = get_function_from_module(LETTA_CORE_TOOL_MODULE_NAME, function_name)
+                agent_state_copy = self.agent_state.__deepcopy__()
+                function_args["agent_state"] = agent_state_copy  # need to attach self to arg since it's dynamically linked
+                function_response = callable_func(**function_args)
+                self.update_memory_if_changed(agent_state_copy.memory)
             else:
+                # TODO: Get rid of this. This whole piece is pretty shady, that we exec the function to just get the type hints for args.
+                env = {}
+                env.update(globals())
+                exec(target_letta_tool.source_code, env)
+                callable_func = env[target_letta_tool.json_schema["name"]]
+                spec = inspect.getfullargspec(callable_func).annotations
+                for name, arg in function_args.items():
+                    if isinstance(function_args[name], dict):
+                        function_args[name] = spec[name](**function_args[name])
+
                 # execute tool in a sandbox
                 # TODO: allow agent_state to specify which sandbox to execute tools in
-                sandbox_run_result = ToolExecutionSandbox(function_name, function_args, self.user).run(
-                    agent_state=self.agent_state.__deepcopy__()
-                )
+                # TODO: This is only temporary, can remove after we publish a pip package with this object
+                agent_state_copy = self.agent_state.__deepcopy__()
+                agent_state_copy.tools = []
+
+                sandbox_run_result = ToolExecutionSandbox(function_name, function_args, self.user).run(agent_state=agent_state_copy)
                 function_response, updated_agent_state = sandbox_run_result.func_return, sandbox_run_result.agent_state
                 assert orig_memory_str == self.agent_state.memory.compile(), "Memory should not be modified in a sandbox tool"
                 if updated_agent_state is not None:
-                    self.update_memory_if_change(updated_agent_state.memory)
+                    self.update_memory_if_changed(updated_agent_state.memory)
         except Exception as e:
             # Need to catch error here, or else trunction wont happen
             # TODO: modify to function execution error
@@ -677,7 +685,7 @@ class Agent(BaseAgent):
             current_persisted_memory = Memory(
                 blocks=[self.block_manager.get_block_by_id(block.id, actor=self.user) for block in self.agent_state.memory.get_blocks()]
             )  # read blocks from DB
-            self.update_memory_if_change(current_persisted_memory)
+            self.update_memory_if_changed(current_persisted_memory)
 
             # Step 1: add user message
             if isinstance(messages, Message):

letta/constants.py

@@ -2,12 +2,16 @@ import os
 from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
+LETTA_DIR_TOOL_SANDBOX = os.path.join(LETTA_DIR, "tool_sandbox_dir")
 
 ADMIN_PREFIX = "/v1/admin"
 API_PREFIX = "/v1"
 OPENAI_API_PREFIX = "/openai"
 
 COMPOSIO_ENTITY_ENV_VAR_KEY = "COMPOSIO_ENTITY"
+COMPOSIO_TOOL_TAG_NAME = "composio"
+
+LETTA_CORE_TOOL_MODULE_NAME = "letta.functions.function_sets.base"
 
 # String in the error message for when the context window is too large
 # Example full message:

letta/functions/functions.py

@@ -1,3 +1,4 @@
+import importlib
 import inspect
 from textwrap import dedent  # remove indentation
 from types import ModuleType
@@ -64,6 +65,70 @@ def parse_source_code(func) -> str:
     return source_code
 
 
+def get_function_from_module(module_name: str, function_name: str):
+    """
+    Dynamically imports a function from a specified module.
+
+    Args:
+        module_name (str): The name of the module to import (e.g., 'base').
+        function_name (str): The name of the function to retrieve.
+
+    Returns:
+        Callable: The imported function.
+
+    Raises:
+        ModuleNotFoundError: If the specified module cannot be found.
+        AttributeError: If the function is not found in the module.
+    """
+    try:
+        # Dynamically import the module
+        module = importlib.import_module(module_name)
+        # Retrieve the function
+        return getattr(module, function_name)
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(f"Module '{module_name}' not found.")
+    except AttributeError:
+        raise AttributeError(f"Function '{function_name}' not found in module '{module_name}'.")
+
+
+def get_json_schema_from_module(module_name: str, function_name: str) -> dict:
+    """
+    Dynamically loads a specific function from a module and generates its JSON schema.
+
+    Args:
+        module_name (str): The name of the module to import (e.g., 'base').
+        function_name (str): The name of the function to retrieve.
+
+    Returns:
+        dict: The JSON schema for the specified function.
+
+    Raises:
+        ModuleNotFoundError: If the specified module cannot be found.
+        AttributeError: If the function is not found in the module.
+        ValueError: If the attribute is not a user-defined function.
+    """
+    try:
+        # Dynamically import the module
+        module = importlib.import_module(module_name)
+
+        # Retrieve the function
+        attr = getattr(module, function_name, None)
+
+        # Check if it's a user-defined function
+        if not (inspect.isfunction(attr) and attr.__module__ == module.__name__):
+            raise ValueError(f"'{function_name}' is not a user-defined function in module '{module_name}'")
+
+        # Generate schema (assuming a `generate_schema` function exists)
+        generated_schema = generate_schema(attr)
+
+        return generated_schema
+
+    except ModuleNotFoundError:
+        raise ModuleNotFoundError(f"Module '{module_name}' not found.")
+    except AttributeError:
+        raise AttributeError(f"Function '{function_name}' not found in module '{module_name}'.")
+
+
 def load_function_set(module: ModuleType) -> dict:
     """Load the functions and generate schema for them, given a module object"""
     function_dict = {}

letta/llm_api/google_ai.py

@@ -264,6 +264,7 @@ def convert_google_ai_response_to_chatcompletion(
     """
     try:
         choices = []
+        index = 0
         for candidate in response_json["candidates"]:
             content = candidate["content"]
 
@@ -272,86 +273,87 @@ def convert_google_ai_response_to_chatcompletion(
 
             parts = content["parts"]
             # TODO support parts / multimodal
-            assert len(parts) == 1, f"Multi-part not yet supported:\n{parts}"
-            response_message = parts[0]
-
-            # Convert the actual message style to OpenAI style
-            if "functionCall" in response_message and response_message["functionCall"] is not None:
-                function_call = response_message["functionCall"]
-                assert isinstance(function_call, dict), function_call
-                function_name = function_call["name"]
-                assert isinstance(function_name, str), function_name
-                function_args = function_call["args"]
-                assert isinstance(function_args, dict), function_args
-
-                # NOTE: this also involves stripping the inner monologue out of the function
-                if pull_inner_thoughts_from_args:
-                    from letta.local_llm.constants import INNER_THOUGHTS_KWARG
-
-                    assert INNER_THOUGHTS_KWARG in function_args, f"Couldn't find inner thoughts in function args:\n{function_call}"
-                    inner_thoughts = function_args.pop(INNER_THOUGHTS_KWARG)
-                    assert inner_thoughts is not None, f"Expected non-null inner thoughts function arg:\n{function_call}"
-                else:
-                    inner_thoughts = None
-
-                # Google AI API doesn't generate tool call IDs
-                openai_response_message = Message(
-                    role="assistant",  # NOTE: "model" -> "assistant"
-                    content=inner_thoughts,
-                    tool_calls=[
-                        ToolCall(
-                            id=get_tool_call_id(),
-                            type="function",
-                            function=FunctionCall(
-                                name=function_name,
-                                arguments=clean_json_string_extra_backslash(json_dumps(function_args)),
-                            ),
-                        )
-                    ],
-                )
-
-            else:
+            # TODO support parallel tool calling natively
+            # TODO Alternative here is to throw away everything else except for the first part
+            for response_message in parts:
+                # Convert the actual message style to OpenAI style
+                if "functionCall" in response_message and response_message["functionCall"] is not None:
+                    function_call = response_message["functionCall"]
+                    assert isinstance(function_call, dict), function_call
+                    function_name = function_call["name"]
+                    assert isinstance(function_name, str), function_name
+                    function_args = function_call["args"]
+                    assert isinstance(function_args, dict), function_args
+
+                    # NOTE: this also involves stripping the inner monologue out of the function
+                    if pull_inner_thoughts_from_args:
+                        from letta.local_llm.constants import INNER_THOUGHTS_KWARG
+
+                        assert INNER_THOUGHTS_KWARG in function_args, f"Couldn't find inner thoughts in function args:\n{function_call}"
+                        inner_thoughts = function_args.pop(INNER_THOUGHTS_KWARG)
+                        assert inner_thoughts is not None, f"Expected non-null inner thoughts function arg:\n{function_call}"
+                    else:
+                        inner_thoughts = None
+
+                    # Google AI API doesn't generate tool call IDs
+                    openai_response_message = Message(
+                        role="assistant",  # NOTE: "model" -> "assistant"
+                        content=inner_thoughts,
+                        tool_calls=[
+                            ToolCall(
+                                id=get_tool_call_id(),
+                                type="function",
+                                function=FunctionCall(
+                                    name=function_name,
+                                    arguments=clean_json_string_extra_backslash(json_dumps(function_args)),
+                                ),
+                            )
+                        ],
+                    )
 
-                # Inner thoughts are the content by default
-                inner_thoughts = response_message["text"]
-
-                # Google AI API doesn't generate tool call IDs
-                openai_response_message = Message(
-                    role="assistant",  # NOTE: "model" -> "assistant"
-                    content=inner_thoughts,
-                )
+                else:
 
-            # Google AI API uses different finish reason strings than OpenAI
-            # OpenAI: 'stop', 'length', 'function_call', 'content_filter', null
-            #   see: https://platform.openai.com/docs/guides/text-generation/chat-completions-api
-            # Google AI API: FINISH_REASON_UNSPECIFIED, STOP, MAX_TOKENS, SAFETY, RECITATION, OTHER
-            #   see: https://ai.google.dev/api/python/google/ai/generativelanguage/Candidate/FinishReason
-            finish_reason = candidate["finishReason"]
-            if finish_reason == "STOP":
-                openai_finish_reason = (
-                    "function_call"
-                    if openai_response_message.tool_calls is not None and len(openai_response_message.tool_calls) > 0
-                    else "stop"
-                )
-            elif finish_reason == "MAX_TOKENS":
-                openai_finish_reason = "length"
-            elif finish_reason == "SAFETY":
-                openai_finish_reason = "content_filter"
-            elif finish_reason == "RECITATION":
-                openai_finish_reason = "content_filter"
-            else:
-                raise ValueError(f"Unrecognized finish reason in Google AI response: {finish_reason}")
-
-            choices.append(
-                Choice(
-                    finish_reason=openai_finish_reason,
-                    index=candidate["index"],
-                    message=openai_response_message,
+                    # Inner thoughts are the content by default
+                    inner_thoughts = response_message["text"]
+
+                    # Google AI API doesn't generate tool call IDs
+                    openai_response_message = Message(
+                        role="assistant",  # NOTE: "model" -> "assistant"
+                        content=inner_thoughts,
+                    )
+
+                # Google AI API uses different finish reason strings than OpenAI
+                # OpenAI: 'stop', 'length', 'function_call', 'content_filter', null
+                #   see: https://platform.openai.com/docs/guides/text-generation/chat-completions-api
+                # Google AI API: FINISH_REASON_UNSPECIFIED, STOP, MAX_TOKENS, SAFETY, RECITATION, OTHER
+                #   see: https://ai.google.dev/api/python/google/ai/generativelanguage/Candidate/FinishReason
+                finish_reason = candidate["finishReason"]
+                if finish_reason == "STOP":
+                    openai_finish_reason = (
+                        "function_call"
+                        if openai_response_message.tool_calls is not None and len(openai_response_message.tool_calls) > 0
+                        else "stop"
+                    )
+                elif finish_reason == "MAX_TOKENS":
+                    openai_finish_reason = "length"
+                elif finish_reason == "SAFETY":
+                    openai_finish_reason = "content_filter"
+                elif finish_reason == "RECITATION":
+                    openai_finish_reason = "content_filter"
+                else:
+                    raise ValueError(f"Unrecognized finish reason in Google AI response: {finish_reason}")
+
+                choices.append(
+                    Choice(
+                        finish_reason=openai_finish_reason,
+                        index=index,
+                        message=openai_response_message,
+                    )
                 )
-            )
+                index += 1
 
-        if len(choices) > 1:
-            raise UserWarning(f"Unexpected number of candidates in response (expected 1, got {len(choices)})")
+        # if len(choices) > 1:
+        #     raise UserWarning(f"Unexpected number of candidates in response (expected 1, got {len(choices)})")
 
         # NOTE: some of the Google AI APIs show UsageMetadata in the response, but it seems to not exist?
         #  "usageMetadata": {

letta/orm/agent.py

@@ -1,7 +1,7 @@
 import uuid
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy import JSON, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.block import Block
@@ -27,7 +27,6 @@ if TYPE_CHECKING:
 class Agent(SqlalchemyBase, OrganizationMixin):
     __tablename__ = "agents"
     __pydantic_model__ = PydanticAgentState
-    __table_args__ = (UniqueConstraint("organization_id", "name", name="unique_org_agent_name"),)
 
     # agent generates its own id
     # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
@@ -109,6 +108,7 @@ class Agent(SqlalchemyBase, OrganizationMixin):
         """converts to the basic pydantic model counterpart"""
         state = {
             "id": self.id,
+            "organization_id": self.organization_id,
             "name": self.name,
             "description": self.description,
             "message_ids": self.message_ids,

letta/orm/base.py

@@ -17,6 +17,16 @@ class CommonSqlalchemyMetaMixins(Base):
     updated_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), server_default=func.now(), server_onupdate=func.now())
     is_deleted: Mapped[bool] = mapped_column(Boolean, server_default=text("FALSE"))
 
+    def set_updated_at(self, timestamp: Optional[datetime] = None) -> None:
+        """
+        Set the updated_at timestamp for the model instance.
+
+        Args:
+            timestamp (Optional[datetime]): The timestamp to set.
+                                            If None, uses the current UTC time.
+        """
+        self.updated_at = timestamp or datetime.utcnow()
+
     def _set_created_and_updated_by_fields(self, actor_id: str) -> None:
         """Populate created_by_id and last_updated_by_id based on actor."""
         if not self.created_by_id:

letta/orm/provider.py

@@ -4,7 +4,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.providers import Provider as PydanticProvider
+from letta.schemas.providers import Provider as PydanticProvider
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization

letta/orm/sqlalchemy_base.py

@@ -100,9 +100,13 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
                 if match_all_tags:
                     # Match ALL tags - use subqueries
-                    for tag in tags:
-                        subquery = select(cls.tags.property.mapper.class_.agent_id).where(cls.tags.property.mapper.class_.tag == tag)
-                        query = query.filter(cls.id.in_(subquery))
+                    subquery = (
+                        select(cls.tags.property.mapper.class_.agent_id)
+                        .where(cls.tags.property.mapper.class_.tag.in_(tags))
+                        .group_by(cls.tags.property.mapper.class_.agent_id)
+                        .having(func.count() == len(tags))
+                    )
+                    query = query.filter(cls.id.in_(subquery))
                 else:
                     # Match ANY tag - use join and filter
                     query = (
@@ -275,6 +279,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         if actor:
             self._set_created_and_updated_by_fields(actor.id)
 
+        self.set_updated_at()
+
         with db_session as session:
             session.add(self)
             session.commit()

letta/orm/tool.py

@@ -4,7 +4,7 @@ from sqlalchemy import JSON, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 # TODO everything in functions should live in this model
-from letta.orm.enums import ToolSourceType
+from letta.orm.enums import ToolSourceType, ToolType
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.tool import Tool as PydanticTool
@@ -29,12 +29,17 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
 
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
+    tool_type: Mapped[ToolType] = mapped_column(
+        String,
+        default=ToolType.CUSTOM,
+        doc="The type of tool. This affects whether or not we generate json_schema and source_code on the fly.",
+    )
     return_char_limit: Mapped[int] = mapped_column(nullable=True, doc="The maximum number of characters the tool can return.")
     description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The description of the tool.")
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")
     source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
     source_code: Mapped[Optional[str]] = mapped_column(String, doc="The source code of the function.")
-    json_schema: Mapped[dict] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
+    json_schema: Mapped[Optional[dict]] = mapped_column(JSON, default=lambda: {}, doc="The OAI compatable JSON schema of the function.")
     module: Mapped[Optional[str]] = mapped_column(
         String, nullable=True, doc="the module path from which this tool was derived in the codebase."
     )

letta/{providers.py → schemas/providers.py}

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import List, Optional
 
 from pydantic import Field, model_validator
@@ -8,7 +9,6 @@ from letta.llm_api.azure_openai_constants import AZURE_MODEL_TO_CONTEXT_LENGTH
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
-from letta.services.organization_manager import OrganizationManager
 
 
 class ProviderBase(LettaBase):
@@ -16,9 +16,15 @@ class ProviderBase(LettaBase):
 
 
 class Provider(ProviderBase):
+    id: Optional[str] = Field(None, description="The id of the provider, lazily created by the database manager.")
     name: str = Field(..., description="The name of the provider")
     api_key: Optional[str] = Field(None, description="API key used for requests to the provider.")
-    organization_id: Optional[str] = Field(OrganizationManager.DEFAULT_ORG_ID, description="The organization id of the user")
+    organization_id: Optional[str] = Field(None, description="The organization id of the user")
+    updated_at: Optional[datetime] = Field(None, description="The last update timestamp of the provider.")
+
+    def resolve_identifier(self):
+        if not self.id:
+            self.id = ProviderBase._generate_id(prefix=ProviderBase.__id_prefix__)
 
     def list_llm_models(self) -> List[LLMConfig]:
         return []
@@ -40,7 +46,6 @@ class Provider(ProviderBase):
 class ProviderCreate(ProviderBase):
     name: str = Field(..., description="The name of the provider.")
     api_key: str = Field(..., description="API key used for requests to the provider.")
-    organization_id: str = Field(..., description="The organization id that this provider information pertains to.")
 
 
 class ProviderUpdate(ProviderBase):

letta/schemas/tool.py

@@ -1,11 +1,12 @@
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import Field, model_validator
 
-from letta.constants import FUNCTION_RETURN_CHAR_LIMIT
-from letta.functions.functions import derive_openai_json_schema
+from letta.constants import COMPOSIO_TOOL_TAG_NAME, FUNCTION_RETURN_CHAR_LIMIT, LETTA_CORE_TOOL_MODULE_NAME
+from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
 from letta.functions.helpers import generate_composio_tool_wrapper, generate_langchain_tool_wrapper
 from letta.functions.schema_generator import generate_schema_from_args_schema_v2
+from letta.orm.enums import ToolType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 
@@ -28,6 +29,7 @@ class Tool(BaseTool):
     """
 
     id: str = BaseTool.generate_id_field()
+    tool_type: ToolType = Field(ToolType.CUSTOM, description="The type of the tool.")
     description: Optional[str] = Field(None, description="The description of the tool.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
     module: Optional[str] = Field(None, description="The module of the function.")
@@ -36,7 +38,7 @@ class Tool(BaseTool):
     tags: List[str] = Field([], description="Metadata tags.")
 
     # code
-    source_code: str = Field(..., description="The source code of the function.")
+    source_code: Optional[str] = Field(None, description="The source code of the function.")
     json_schema: Optional[Dict] = Field(None, description="The JSON schema of the function.")
 
     # tool configuration
@@ -51,9 +53,19 @@ class Tool(BaseTool):
         """
         Populate missing fields: name, description, and json_schema.
         """
-        # Derive JSON schema if not provided
-        if not self.json_schema:
-            self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+        if self.tool_type == ToolType.CUSTOM:
+            # If it's a custom tool, we need to ensure source_code is present
+            if not self.source_code:
+                raise ValueError(f"Custom tool with id={self.id} is missing source_code field.")
+
+            # Always derive json_schema for freshest possible json_schema
+            # TODO: Instead of checking the tag, we should having `COMPOSIO` as a specific ToolType
+            # TODO: We skip this for Composio bc composio json schemas are derived differently
+            if not (COMPOSIO_TOOL_TAG_NAME in self.tags):
+                self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+        elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE}:
+            # If it's letta core tool, we generate the json_schema on the fly here
+            self.json_schema = get_json_schema_from_module(module_name=LETTA_CORE_TOOL_MODULE_NAME, function_name=self.name)
 
         # Derive name from the JSON schema if not provided
         if not self.name:
@@ -125,7 +137,7 @@ class ToolCreate(LettaBase):
 
         description = composio_tool.description
         source_type = "python"
-        tags = ["composio"]
+        tags = [COMPOSIO_TOOL_TAG_NAME]
         wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action_name)
         json_schema = generate_schema_from_args_schema_v2(composio_tool.args_schema, name=wrapper_func_name, description=description)
 
@@ -215,7 +227,7 @@ class ToolUpdate(LettaBase):
 
 class ToolRunFromSource(LettaBase):
     source_code: str = Field(..., description="The source code of the function.")
-    args: Dict[str, str] = Field(..., description="The arguments to pass to the tool.")
+    args: Dict[str, Any] = Field(..., description="The arguments to pass to the tool.")
     env_vars: Dict[str, str] = Field(None, description="The environment variables to pass to the tool.")
     name: Optional[str] = Field(None, description="The name of the tool to run.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")

letta/server/rest_api/app.py

@@ -244,10 +244,6 @@ def create_application() -> "FastAPI":
     # / static files
     mount_static_files(app)
 
-    @app.on_event("startup")
-    def on_startup():
-        generate_openapi_schema(app)
-
     @app.on_event("shutdown")
     def on_shutdown():
         global server

letta/server/rest_api/interface.py

@@ -198,10 +198,6 @@ class QueuingInterface(AgentInterface):
             assert is_utc_datetime(msg_obj.created_at), msg_obj.created_at
             new_message["date"] = msg_obj.created_at.isoformat()
         else:
-            # FIXME this is a total hack
-            assert self.buffer.qsize() > 1, "Tried to reach back to grab function call data, but couldn't find a buffer message."
-            # TODO also should not be accessing protected member here
-
             new_message["id"] = self.buffer.queue[-1]["message_api"]["id"]
             # assert is_utc_datetime(msg_obj.created_at), msg_obj.created_at
             new_message["date"] = self.buffer.queue[-1]["message_api"]["date"]

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

@@ -3,8 +3,19 @@ from letta.server.rest_api.routers.v1.blocks import router as blocks_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
+from letta.server.rest_api.routers.v1.providers import router as providers_router
 from letta.server.rest_api.routers.v1.sandbox_configs import router as sandbox_configs_router
 from letta.server.rest_api.routers.v1.sources import router as sources_router
 from letta.server.rest_api.routers.v1.tools import router as tools_router
 
-ROUTERS = [tools_router, sources_router, agents_router, llm_router, blocks_router, jobs_router, health_router, sandbox_configs_router]
+ROUTERS = [
+    tools_router,
+    sources_router,
+    agents_router,
+    llm_router,
+    blocks_router,
+    jobs_router,
+    health_router,
+    sandbox_configs_router,
+    providers_router,
+]

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

@@ -1,15 +1,17 @@
-from fastapi import APIRouter, Depends
+from typing import TYPE_CHECKING, List, Optional
 
-from letta.providers import Provider, ProviderCreate, ProviderUpdate
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+
+from letta.schemas.providers import Provider, ProviderCreate, ProviderUpdate
 from letta.server.rest_api.utils import get_letta_server
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
 
-router = APIRouter(prefix="/providers", tags=["providers", "admin"])
+router = APIRouter(prefix="/providers", tags=["providers"])
 
 
-@router.get("/", tags=["admin"], response_model=List[Provider], operation_id="list_providers")
+@router.get("/", tags=["providers"], response_model=List[Provider], operation_id="list_providers")
 def list_providers(
     cursor: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
@@ -27,20 +29,23 @@ def list_providers(
     return providers
 
 
-@router.post("/", tags=["admin"], response_model=Provider, operation_id="create_provider")
+@router.post("/", tags=["providers"], response_model=Provider, operation_id="create_provider")
 def create_provider(
     request: ProviderCreate = Body(...),
     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
 ):
     """
     Create a new custom provider
     """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
     provider = Provider(**request.model_dump())
-    provider = server.provider_manager.create_provider(provider)
+    provider = server.provider_manager.create_provider(provider, actor=actor)
     return provider
 
 
-@router.put("/", tags=["admin"], response_model=Provider, operation_id="update_provider")
+@router.put("/", tags=["providers"], response_model=Provider, operation_id="update_provider")
 def update_provider(
     request: ProviderUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
@@ -52,7 +57,7 @@ def update_provider(
     return provider
 
 
-@router.delete("/", tags=["admin"], response_model=Provider, operation_id="delete_provider")
+@router.delete("/", tags=["providers"], response_model=None, operation_id="delete_provider")
 def delete_provider(
     provider_id: str = Query(..., description="The provider_id key to be deleted."),
     server: "SyncServer" = Depends(get_letta_server),
@@ -61,12 +66,8 @@ def delete_provider(
     Delete an existing custom provider
     """
     try:
-        provider = server.provider_manager.get_provider_by_id(provider_id=provider_id)
-        if provider is None:
-            raise HTTPException(status_code=404, detail=f"Provider does not exist")
         server.provider_manager.delete_provider_by_id(provider_id=provider_id)
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
-    return user

letta/server/server.py

@@ -25,19 +25,6 @@ from letta.log import get_logger
 from letta.offline_memory_agent import OfflineMemoryAgent
 from letta.orm import Base
 from letta.orm.errors import NoResultFound
-from letta.providers import (
-    AnthropicProvider,
-    AzureProvider,
-    GoogleAIProvider,
-    GroqProvider,
-    LettaProvider,
-    OllamaProvider,
-    OpenAIProvider,
-    Provider,
-    TogetherProvider,
-    VLLMChatCompletionsProvider,
-    VLLMCompletionsProvider,
-)
 from letta.schemas.agent import AgentState, AgentType, CreateAgent
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -52,6 +39,19 @@ from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, M
 from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
+from letta.schemas.providers import (
+    AnthropicProvider,
+    AzureProvider,
+    GoogleAIProvider,
+    GroqProvider,
+    LettaProvider,
+    OllamaProvider,
+    OpenAIProvider,
+    Provider,
+    TogetherProvider,
+    VLLMChatCompletionsProvider,
+    VLLMCompletionsProvider,
+)
 from letta.schemas.sandbox_config import SandboxType
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool

letta/services/provider_manager.py

@@ -1,8 +1,9 @@
 from typing import List, Optional
 
 from letta.orm.provider import Provider as ProviderModel
-from letta.providers import Provider as PydanticProvider
-from letta.providers import ProviderUpdate
+from letta.schemas.providers import Provider as PydanticProvider
+from letta.schemas.providers import ProviderUpdate
+from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
 
@@ -14,10 +15,16 @@ class ProviderManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_provider(self, provider: PydanticProvider) -> PydanticProvider:
+    def create_provider(self, provider: PydanticProvider, actor: PydanticUser) -> PydanticProvider:
         """Create a new provider if it doesn't already exist."""
         with self.session_maker() as session:
-            new_provider = ProviderModel(**provider.model_dump())
+            # Assign the organization id based on the actor
+            provider.organization_id = actor.organization_id
+
+            # Lazily create the provider id prior to persistence
+            provider.resolve_identifier()
+
+            new_provider = ProviderModel(**provider.model_dump(exclude_unset=True))
             new_provider.create(session)
             return new_provider.to_pydantic()
 

letta/services/sandbox_config_manager.py

@@ -1,6 +1,6 @@
-from pathlib import Path
 from typing import Dict, List, Optional
 
+from letta.constants import LETTA_DIR_TOOL_SANDBOX
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.sandbox_config import SandboxConfig as SandboxConfigModel
@@ -35,7 +35,7 @@ class SandboxConfigManager:
                 default_config = {}  # Empty
             else:
                 # TODO: May want to move this to environment variables v.s. persisting in database
-                default_local_sandbox_path = str(Path(__file__).parent / "tool_sandbox_env")
+                default_local_sandbox_path = LETTA_DIR_TOOL_SANDBOX
                 default_config = LocalSandboxConfig(sandbox_dir=default_local_sandbox_path).model_dump(exclude_none=True)
 
             sandbox_config = self.create_or_update_sandbox_config(SandboxConfigCreate(config=default_config), actor=actor)

letta/services/tool_execution_sandbox.py

@@ -119,8 +119,9 @@ class ToolExecutionSandbox:
             env.update(additional_env_vars)
 
         # Safety checks
-        if not os.path.isdir(local_configs.sandbox_dir):
-            raise FileNotFoundError(f"Sandbox directory does not exist: {local_configs.sandbox_dir}")
+        if not os.path.exists(local_configs.sandbox_dir) or not os.path.isdir(local_configs.sandbox_dir):
+            logger.warning(f"Sandbox directory does not exist, creating: {local_configs.sandbox_dir}")
+            os.makedirs(local_configs.sandbox_dir)
 
         # Write the code to a temp file in the sandbox_dir
         with tempfile.NamedTemporaryFile(mode="w", dir=local_configs.sandbox_dir, suffix=".py", delete=False) as temp_file:

letta/services/tool_manager.py

@@ -1,10 +1,10 @@
 import importlib
-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
+from letta.orm.enums import ToolType
 
 # TODO: Remove this once we translate all of these to the ORM
 from letta.orm.errors import NoResultFound
@@ -32,10 +32,10 @@ class ToolManager:
 
         self.session_maker = db_context
 
+    # TODO: Refactor this across the codebase to use CreateTool instead of passing in a Tool object
     @enforce_types
     def create_or_update_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
-        # Derive json_schema
         tool = self.get_tool_by_name(tool_name=pydantic_tool.name, actor=actor)
         if tool:
             # Put to dict and remove fields that should not be reset
@@ -63,6 +63,7 @@ class ToolManager:
             if pydantic_tool.description is None:
                 pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
             tool_data = pydantic_tool.model_dump()
+
             tool = ToolModel(**tool_data)
             tool.create(session, actor=actor)  # Re-raise other database-related errors
         return tool.to_pydantic()
@@ -113,8 +114,6 @@ class ToolManager:
             # If source code is changed and a new json_schema is not provided, we want to auto-refresh the schema
             if "source_code" in update_data.keys() and "json_schema" not in update_data.keys():
                 pydantic_tool = tool.to_pydantic()
-
-                update_data["name"] if "name" in update_data.keys() else None
                 new_schema = derive_openai_json_schema(source_code=pydantic_tool.source_code)
 
                 tool.json_schema = new_schema
@@ -155,12 +154,19 @@ class ToolManager:
         tools = []
         for name, schema in functions_to_schema.items():
             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]
                 if module_name == "base":
                     tags.append("letta-base")
 
+                # BASE_MEMORY_TOOLS should be executed in an e2b sandbox
+                # so they should NOT be letta_core tools, instead, treated as custom tools
+                if name in BASE_TOOLS:
+                    tool_type = ToolType.LETTA_CORE
+                elif name in BASE_MEMORY_TOOLS:
+                    tool_type = ToolType.LETTA_MEMORY_CORE
+                else:
+                    raise ValueError(f"Tool name {name} is not in the list of base tool names: {BASE_TOOLS + BASE_MEMORY_TOOLS}")
+
                 # create to tool
                 tools.append(
                     self.create_or_update_tool(
@@ -168,9 +174,7 @@ class ToolManager:
                             name=name,
                             tags=tags,
                             source_type="python",
-                            module=schema["module"],
-                            source_code=source_code,
-                            json_schema=schema["json_schema"],
+                            tool_type=tool_type,
                         ),
                         actor=actor,
                     )

letta/settings.py

@@ -10,10 +10,13 @@ from letta.local_llm.constants import DEFAULT_WRAPPER_NAME
 class ToolSettings(BaseSettings):
     composio_api_key: Optional[str] = None
 
-    # Sandbox configurations
+    # E2B Sandbox configurations
     e2b_api_key: Optional[str] = None
     e2b_sandbox_template_id: Optional[str] = None  # Updated manually
 
+    # Local Sandbox configurations
+    local_sandbox_dir: Optional[str] = None
+
 
 class ModelSettings(BaseSettings):
 
@@ -59,6 +62,9 @@ class ModelSettings(BaseSettings):
     openllm_auth_type: Optional[str] = None
     openllm_api_key: Optional[str] = None
 
+    # disable openapi schema generation
+    disable_schema_generation: bool = False
+
 
 cors_origins = [
     "http://letta.localhost",

{letta_nightly-0.6.8.dev20250110190527.dist-info → letta_nightly-0.6.8.dev20250111030335.dist-info}/METADATA

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

{letta_nightly-0.6.8.dev20250110190527.dist-info → letta_nightly-0.6.8.dev20250111030335.dist-info}/RECORD

@@ -1,6 +1,6 @@
 letta/__init__.py,sha256=-CRF0Bm3fnfx91Zwqgy6SjNRFRTorD37JtSJnVMpRGQ,991
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=fvd_atYh1BDgjDWxP3pJjCQ7cJFRWQigfI8TtmXQ0Ng,54838
+letta/agent.py,sha256=QedEmRz_9UWl_0qZxz3nMK-eMSyVFMWugO2YrpNzSpI,55551
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/chat_only_agent.py,sha256=ECqJS7KzXOsNkJc9mv7reKbcxBI_PKP_PQyk95tsT1Y,4761
@@ -12,7 +12,7 @@ letta/client/client.py,sha256=oOwifm06z0bVpHnv3yR4o-tMQxD0C7_p41luQ5r-C5E,127098
 letta/client/streaming.py,sha256=Hz2j_hQZG2g7uhucjx2p3ybf2qjPT-vmIGCHGo87iCQ,4677
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
-letta/constants.py,sha256=gl0uecmIZxO2si3gG9H-MRvHrH6jzFih3Uvfa02lewk,7071
+letta/constants.py,sha256=FrbNM2ngNNI-MO9pYbBchSwqydKgNpGCW44qYMCUH14,7244
 letta/credentials.py,sha256=D9mlcPsdDWlIIXQQD8wSPE9M_QvsRrb0p3LB5i9OF5Q,5806
 letta/data_sources/connectors.py,sha256=L-WL-znjaRstMwSunHf3xDywjvgnbjnUR9rUpL6Ypo0,7023
 letta/data_sources/connectors_helper.py,sha256=2TQjCt74fCgT5sw1AP8PalDEk06jPBbhrPG4HVr-WLs,3371
@@ -21,7 +21,7 @@ letta/errors.py,sha256=bzHXK2co-cQOUWCjKjgphEJ-_-BihO3wTfwGfK570_Q,5093
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/function_sets/base.py,sha256=bOiitkhzqYKwZBiRYrx29AlordiA5IrXw25eVSRK8BY,5984
 letta/functions/function_sets/extras.py,sha256=sNY5oavQ5ZmO5GpAtnm8hkWokqwqB8ClPB2VOL-B8MM,4719
-letta/functions/functions.py,sha256=evH6GKnIJwVVre1Xre2gaSIqREv4eNM4DiWOhn8PMqg,3299
+letta/functions/functions.py,sha256=wxxo6MJXBfcPeEc1YYWK5ENOD3RFNTIc65RTDBo77x4,5673
 letta/functions/helpers.py,sha256=PkhzSHc8gZBxX2NHFaDYX0ZwUK9kuGQbz1zpIZ-KXVo,8860
 letta/functions/schema_generator.py,sha256=u8ix-spnLeP-epFMxP4jF23_aQDa-yCUIW2_O2CBOuo,17561
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
@@ -35,7 +35,7 @@ letta/llm_api/anthropic.py,sha256=iq2iwEWEa53T7WX9ROyvzVzBgqfJP32tPqBdFBAHpG0,14
 letta/llm_api/azure_openai.py,sha256=Y1HKPog1XzM_f7ujUK_Gv2zQkoy5pU-1bKiUnvSxSrs,6297
 letta/llm_api/azure_openai_constants.py,sha256=oXtKrgBFHf744gyt5l1thILXgyi8NDNUrKEa2GGGpjw,278
 letta/llm_api/cohere.py,sha256=H5kzYH_aQAnGNq7lip7XyKGLEOKC318Iw0_tiTP6kc4,14772
-letta/llm_api/google_ai.py,sha256=0rkWKGzOGUvMXycbflqJMUQ3zFZ1VFLxWf0h7uGtPYQ,17543
+letta/llm_api/google_ai.py,sha256=MIX4nmyC6448AvyPPSE8JZ_tzSpKJTArkZSfQGGoy0M,17920
 letta/llm_api/helpers.py,sha256=iP9EswPflaRzsmLqQuMGt1OCUQgPrPq1xTjrqmMKPiA,13675
 letta/llm_api/llm_api_tools.py,sha256=DnWsyowH_re5Zvd8-XNfGvB7KkjqcfdkqjmlVvM7_BU,18444
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
@@ -85,9 +85,9 @@ letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 letta/openai_backcompat/openai_object.py,sha256=Y1ZS1sATP60qxJiOsjOP3NbwSzuzvkNAvb3DeuhM5Uk,13490
 letta/orm/__all__.py,sha256=2gh2MZTkA3Hw67VWVKK3JIStJOqTeLdpCvYSVYNeEDA,692
 letta/orm/__init__.py,sha256=cVnGGFjrAIuRpguw10l5moUG3Z5vKHqQjVsCv6uww3M,764
-letta/orm/agent.py,sha256=Uvez0vJGyuL20gVTSIvqYpVp1C2udLJlfQrGvLZCeH8,6162
+letta/orm/agent.py,sha256=X-u2qUlI3O6RqGlZVWKSDK722YaovIHpuGy5yy9DQDE,6099
 letta/orm/agents_tags.py,sha256=dYSnHz4IWBjyOiQ4RJomX3P0QN76JTlEZEw5eJM6Emg,925
-letta/orm/base.py,sha256=47Pyo6iGPlJoT8oeXZWl3E7XHbPzcB81EueoFzeXbxE,2691
+letta/orm/base.py,sha256=VjvxF9TwKF9Trf8BJkDgf7D6KrWWopOkUiF18J3IElk,3071
 letta/orm/block.py,sha256=U2fOXdab9ynQscOqzUo3xv1a_GjqHLIgoNSZq-U0mYg,3308
 letta/orm/blocks_agents.py,sha256=W0dykl9OchAofSuAYZD5zNmhyMabPr9LTJrz-I3A0m4,983
 letta/orm/custom_columns.py,sha256=dBYJn3yc1BIy7ZntIFfq9oEdQav-u0r412C2HyDeUPU,5056
@@ -99,13 +99,13 @@ letta/orm/message.py,sha256=Ui3mMZTAObP7RvmNnqCFudw8Pkt8IAPTlIjCSCsVDFA,1560
 letta/orm/mixins.py,sha256=9c79Kfr-Z1hL-SDYKeoptx_yMTbBwJJBo9nrKEzSDAc,1622
 letta/orm/organization.py,sha256=b12iASuskPnG2yHyFh8p2BFROkoqMPEYUFMuVcFPCHs,2897
 letta/orm/passage.py,sha256=tm5YhUozLR9hN7odGCqCniTl-3GDiFNz3LWAxullaGA,3132
-letta/orm/provider.py,sha256=Efy4dATyl1AbT_mGpKce5H7sKNqCHVQhkcSZpXgTw-k,797
+letta/orm/provider.py,sha256=-qA9tvKTZgaM4D7CoDZZiA7zTgjaaWDV4jZvifQv_MM,805
 letta/orm/sandbox_config.py,sha256=DyOy_1_zCMlp13elCqPcuuA6OwUove6mrjhcpROTg50,4150
 letta/orm/source.py,sha256=xM3Iwy3xzYdoZja9BZrQwyAnPf5iksaQOs8HlNCvb_c,2031
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
-letta/orm/sqlalchemy_base.py,sha256=VXGFfcdUTXFJcW10XHClHhsj7Y9pFhjeoX-Kj4ZPYKA,17753
+letta/orm/sqlalchemy_base.py,sha256=opPgwG9DjKaL56x-h0teQBAIrs-IdaLZRAV0RaWoU-Q,17950
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
-letta/orm/tool.py,sha256=qvDul85Gq0XORx6gyMGk0As3C1bSt9nASqezdPOikQ4,2216
+letta/orm/tool.py,sha256=L2FwFC6gaKwTxcn3uyjQOCSdqD-3eOTigemnSKomZMU,2453
 letta/orm/tools_agents.py,sha256=r6t-V21w2_mG8n38zuUb5jOi_3hRxsjgezsLA4sg0m4,626
 letta/orm/user.py,sha256=rK5N5ViDxmesZMqVVHB7FcQNpcSoM-hB42MyI6q3MnI,1004
 letta/personas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -134,7 +134,6 @@ letta/prompts/system/memgpt_modified_chat.txt,sha256=F_yD4ZcR4aGDE3Z98tI7e609GYe
 letta/prompts/system/memgpt_modified_o1.txt,sha256=objnDgnxpF3-MmU28ZqZ7-TOG8UlHBM_HMyAdSDWK88,5492
 letta/prompts/system/memgpt_offline_memory.txt,sha256=rWEJeF-6aiinjkJM9hgLUYCmlEcC_HekYB1bjEUYq6M,2460
 letta/prompts/system/memgpt_offline_memory_chat.txt,sha256=ituh7gDuio7nC2UKFB7GpBq6crxb8bYedQfJ0ADoPgg,3949
-letta/providers.py,sha256=f-ZbMBmvX1rtVWuW-GS4mihFjWHg343keAzqVb9NgWY,27468
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/schemas/agent.py,sha256=mDaOHz1TOb4VgaXJisI6OZXNFfK38W9A6jVCyrD2NBQ,11482
 letta/schemas/block.py,sha256=pVDH8jr5r-oxdX4cK9dX2wXyLBzgGKQOBWOzqZSeBog,5944
@@ -158,9 +157,10 @@ letta/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNo
 letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwndk,7970
 letta/schemas/organization.py,sha256=WWbUWVSp_VQRFwWN4fdHg1yObiV6x9rZnvIY8x5BPs0,746
 letta/schemas/passage.py,sha256=t_bSI8hpEuh-mj8bV8qOiIA1tAgyjGKrZMVe9l5oIaY,3675
+letta/schemas/providers.py,sha256=YsVQWVjFlyT2I2H-wfD6AL3VP0TIrHkb-DsVp-H85Hc,27647
 letta/schemas/sandbox_config.py,sha256=v32V5T73X-VxhDk0g_1RGniK985KMvg2xyLVi1dvMQY,4215
 letta/schemas/source.py,sha256=B1VbaDJV-EGPv1nQXwCx_RAzeAJd50UqP_1m1cIRT8c,2854
-letta/schemas/tool.py,sha256=_2FaWTDdGtbKTh3-KHa57f5CKS_veWYtyS2Fk5ZwMFw,10349
+letta/schemas/tool.py,sha256=v2y1vNQqa0AoCFHsakUcALiCRhn0lsmWqcVd7aPeAU8,11384
 letta/schemas/tool_rule.py,sha256=LJwi1T474-3zbFGiW7_fegyfduC3F2u7cdlBsV0U_IU,1679
 letta/schemas/usage.py,sha256=8oYRH-JX0PfjIu2zkT5Uu3UWQ7Unnz_uHiO8hRGI4m0,912
 letta/schemas/user.py,sha256=V32Tgl6oqB3KznkxUz12y7agkQicjzW7VocSpj78i6Q,1526
@@ -168,11 +168,11 @@ letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=8_wwXLzeL84a2NtN-LMW9t-yUHQ59GV72cC3DB1LTFQ,11096
+letta/server/rest_api/app.py,sha256=xa34qWm8rpcb_pYnOL9k7sQ0qZAeVhH32uvbb6Xnu8g,11007
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
-letta/server/rest_api/interface.py,sha256=1VswXnbsufSJEvK9Swq7_y2cmUcCBeGa5742u3NSXw8,45767
+letta/server/rest_api/interface.py,sha256=imcpXkfEJboKVEFIHD5OPbS3F_fqjupWratm0zSFpwY,45525
 letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/assistants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -180,21 +180,21 @@ letta/server/rest_api/routers/openai/assistants/assistants.py,sha256=PXv5vLFDa3p
 letta/server/rest_api/routers/openai/assistants/schemas.py,sha256=ZWUrmkvDMeywlxYhcp1hHzLXNgWpD8qWt80jRlhb7Rc,5605
 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=szOelaigEMNNzlvl5ZkS4KDzdyLhv2ATZ8XuaDPN3Jc,4820
-letta/server/rest_api/routers/v1/__init__.py,sha256=6Aw18C9of0ayRNyFYUK_-nxajeVLaYau1bLw-tg_OQ4,753
+letta/server/rest_api/routers/v1/__init__.py,sha256=UX9dUw3ZO-h5up9VnoJFNucDgRlPh05PCUX9gTD8ynA,892
 letta/server/rest_api/routers/v1/agents.py,sha256=S79Bz0y-MGPQfzXuPPDNjJvBDBRQOKE_ixAqENx9J8Q,30986
 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
 letta/server/rest_api/routers/v1/llms.py,sha256=TcyvSx6MEM3je5F4DysL7ligmssL_pFlJaaO4uL95VY,877
 letta/server/rest_api/routers/v1/organizations.py,sha256=tyqVzXTpMtk3sKxI3Iz4aS6RhbGEbXDzFBB_CpW18v4,2080
-letta/server/rest_api/routers/v1/providers.py,sha256=7_921hS6AsvOG-9LeGsF61fM_8cP7Ez-AVUBX-G1iVs,2358
+letta/server/rest_api/routers/v1/providers.py,sha256=ftYyPgqFinfPbjCS4y77xQaq2SPFj8k8wwaErieAppU,2445
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=DJ8mz7HsXCuGypNaxTgoMW8xR1kMOwdVnon00srRdCo,5266
 letta/server/rest_api/routers/v1/sources.py,sha256=EJ-VCqiKtaiYuivZrWx1gYSNUKnWJuduSm-L_2ljhLc,9913
 letta/server/rest_api/routers/v1/tools.py,sha256=rGw3hDUFYmY_kmJw5hsQWnBOWQqJFdfT3bfKiXwXikg,12764
 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=M4VE76TtC9qorvszq1x7MTBW9jSWgtUUCRahqpJNYNc,3953
-letta/server/server.py,sha256=H_-51emg5gHQryjuL0cw5J7XV8mEtzs1JOun_GhYOYQ,50272
+letta/server/server.py,sha256=f6-IqdHScc9K3fIHlVkfMFwSJSo9zBn1W2Smg4GdGRA,50280
 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=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -216,20 +216,19 @@ letta/services/message_manager.py,sha256=a7U0MfgaNAdjbls7ZtUdS7eJ6prJaMkE0NIHgtz
 letta/services/organization_manager.py,sha256=hJI86_FErkRaW-VLBBmvmmciIXN59LN0mEMm78C36kQ,3331
 letta/services/passage_manager.py,sha256=Lq1caspE1VGmT7vlsUOuJVRflJZ122qfG0dmNGm_6o8,7691
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
-letta/services/provider_manager.py,sha256=wCYgl2toWsuOHwFGkz0i94G0hyWtFNyRLUzB2ElTckw,2589
-letta/services/sandbox_config_manager.py,sha256=RtJCiw43S80K_a8QgpQUH7P0jpi7UwoUV1fDjfyX1t4,13289
+letta/services/provider_manager.py,sha256=QsiKXnl-TuVLpL1keAkkMmCbJj4KehGgqu-SZACgbg0,2926
+letta/services/sandbox_config_manager.py,sha256=YWJES09KX5POXwL-hijaf87zW3az3Ioh8lWDeZYPY6k,13290
 letta/services/source_manager.py,sha256=ZtLQikeJjwAq49f0d4WxUzyUN3LZBqWCZI4a-AzEMWQ,7643
-letta/services/tool_execution_sandbox.py,sha256=380xw7ptSdrAbfolZ0l4jnwpzCfbdUfIkOh2tg2vbmI,23019
-letta/services/tool_manager.py,sha256=eKhvGYNBq8MOwfuk-GyqiTdEcxRn4srYvTJqj-HgTKA,7686
-letta/services/tool_sandbox_env/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+letta/services/tool_execution_sandbox.py,sha256=ycAVNabaEI30t2MxYFi-7gLtselSpt3knJdPZvvmT-I,23120
+letta/services/tool_manager.py,sha256=zLdqgo0pipmfyG3-8YkrEGxtrj2i7Iw81ibUV4BuaqM,7935
 letta/services/user_manager.py,sha256=oqLF9C4mGbN0TaGj7wMpb2RH2bUg6OJJcdyaWv370rQ,4272
-letta/settings.py,sha256=8WfAKNCG_ahCvnshMG5YvEQ9qYWs2ZFnWk9EOLOLwpA,3945
+letta/settings.py,sha256=5R0VeNaoIz5KWPtsCk3LWHPCI9b70ifIiHd9p0y92Ak,4114
 letta/streaming_interface.py,sha256=lo2VAQRUJOdWTijwnXuKOC9uejqr2siUAEmZiQUXkj8,15710
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=1-HhTZEw7j5fXI2ukdto0y1cZ-I8wpHKf7rqtdwFnT4,33382
-letta_nightly-0.6.8.dev20250110190527.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.8.dev20250110190527.dist-info/METADATA,sha256=jVpu1w9e5acpFTZtETXxGlx0ZrQGdwn7jpVJXts6DCI,21694
-letta_nightly-0.6.8.dev20250110190527.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.8.dev20250110190527.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.8.dev20250110190527.dist-info/RECORD,,
+letta_nightly-0.6.8.dev20250111030335.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.8.dev20250111030335.dist-info/METADATA,sha256=OFRSl9XZNZcbMgMk-68iBg5XISR4Q5tJF7RoTF_t4jQ,21694
+letta_nightly-0.6.8.dev20250111030335.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.8.dev20250111030335.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.8.dev20250111030335.dist-info/RECORD,,