letta-nightly 0.6.8.dev20250111020743__tar.gz → 0.6.8.dev20250111030335__tar.gz

{letta_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.8.dev20250111020743
+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.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743/letta → letta_nightly-0.6.8.dev20250111030335/letta/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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_nightly-0.6.8.dev20250111020743 → letta_nightly-0.6.8.dev20250111030335}/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"]