letta-nightly 0.6.25.dev20250213104102__py3-none-any.whl → 0.6.26.dev20250214104050__py3-none-any.whl

letta/__init__.py

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

letta/agent.py

@@ -3,12 +3,13 @@ import time
 import traceback
 import warnings
 from abc import ABC, abstractmethod
-from typing import List, Optional, Tuple, Union
+from typing import Any, List, Optional, Tuple, Union
 
 from openai.types.beta.function_tool import FunctionTool as OpenAITool
 
 from letta.constants import (
     CLI_WARNING_PREFIX,
+    COMPOSIO_ENTITY_ENV_VAR_KEY,
     ERROR_MESSAGE_PREFIX,
     FIRST_MESSAGE_ATTEMPTS,
     FUNC_FAILED_HEARTBEAT_MESSAGE,
@@ -20,7 +21,11 @@ from letta.constants import (
 from letta.errors import ContextWindowExceededError
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.functions import get_function_from_module
+from letta.functions.helpers import execute_composio_action, generate_composio_action_from_func_name
 from letta.helpers import ToolRulesSolver
+from letta.helpers.composio_helpers import get_composio_api_key
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import calculate_summarizer_cutoff, get_token_counts_for_messages, is_context_overflow_error
 from letta.llm_api.llm_api_tools import create
@@ -51,6 +56,7 @@ from letta.services.passage_manager import PassageManager
 from letta.services.provider_manager import ProviderManager
 from letta.services.step_manager import StepManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
+from letta.services.tool_manager import ToolManager
 from letta.settings import summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
@@ -58,9 +64,6 @@ from letta.utils import (
     count_tokens,
     get_friendly_error_msg,
     get_tool_call_id,
-    get_utc_time,
-    json_dumps,
-    json_loads,
     log_telemetry,
     parse_json,
     printd,
@@ -202,7 +205,7 @@ class Agent(BaseAgent):
 
     def execute_tool_and_persist_state(
         self, function_name: str, function_args: dict, target_letta_tool: Tool
-    ) -> tuple[str, Optional[SandboxRunResult]]:
+    ) -> tuple[Any, Optional[SandboxRunResult]]:
         """
         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
@@ -228,6 +231,18 @@ class Agent(BaseAgent):
                 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)
+            elif target_letta_tool.tool_type == ToolType.EXTERNAL_COMPOSIO:
+                action_name = generate_composio_action_from_func_name(target_letta_tool.name)
+                # Get entity ID from the agent_state
+                entity_id = None
+                for env_var in self.agent_state.tool_exec_environment_variables:
+                    if env_var.key == COMPOSIO_ENTITY_ENV_VAR_KEY:
+                        entity_id = env_var.value
+                # Get composio_api_key
+                composio_api_key = get_composio_api_key(actor=self.user, logger=self.logger)
+                function_response = execute_composio_action(
+                    action_name=action_name, args=function_args, api_key=composio_api_key, entity_id=entity_id
+                )
             else:
                 # Parse the source code to extract function annotations
                 annotations = get_function_annotations_from_source(target_letta_tool.source_code, function_name)
@@ -460,7 +475,10 @@ class Agent(BaseAgent):
             target_letta_tool = None
             for t in self.agent_state.tools:
                 if t.name == function_name:
-                    target_letta_tool = t
+                    # This force refreshes the target_letta_tool from the database
+                    # We only do this on name match to confirm that the agent state contains a specific tool with the right name
+                    target_letta_tool = ToolManager().get_tool_by_name(tool_name=function_name, actor=self.user)
+                    break
 
             if not target_letta_tool:
                 error_msg = f"No function named {function_name}"

letta/cli/cli_config.py

@@ -8,7 +8,7 @@ import typer
 from prettytable.colortable import ColorTable, Themes
 from tqdm import tqdm
 
-from letta import utils
+import letta.helpers.datetime_helpers
 
 app = typer.Typer()
 
@@ -51,7 +51,7 @@ def list(arg: Annotated[ListChoice, typer.Argument]):
                     agent.memory.get_block("persona").value[:100] + "...",
                     agent.memory.get_block("human").value[:100] + "...",
                     ",".join(source_names),
-                    utils.format_datetime(agent.created_at),
+                    letta.helpers.datetime_helpers.format_datetime(agent.created_at),
                 ]
             )
         print(table)
@@ -84,7 +84,7 @@ def list(arg: Annotated[ListChoice, typer.Argument]):
                     source.description,
                     source.embedding_config.embedding_model,
                     source.embedding_config.embedding_dim,
-                    utils.format_datetime(source.created_at),
+                    letta.helpers.datetime_helpers.format_datetime(source.created_at),
                 ]
             )
 

letta/constants.py

@@ -27,6 +27,7 @@ TOOL_CALL_ID_MAX_LEN = 29
 
 # minimum context window size
 MIN_CONTEXT_WINDOW = 4096
+DEFAULT_CONTEXT_WINDOW_SIZE = 32000
 
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset

letta/functions/function_sets/base.py

@@ -33,7 +33,7 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     import math
 
     from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    from letta.utils import json_dumps
+    from letta.helpers.json_helpers import json_dumps
 
     if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
         page = 0

letta/functions/function_sets/extras.py

@@ -5,9 +5,9 @@ from typing import Optional
 import requests
 
 from letta.constants import MESSAGE_CHATGPT_FUNCTION_MODEL, MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE
+from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.llm_api.llm_api_tools import create
 from letta.schemas.message import Message, TextContent
-from letta.utils import json_dumps, json_loads
 
 
 def message_chatgpt(self, message: str):

letta/functions/helpers.py

@@ -52,24 +52,53 @@ def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
     # Generate func name
     func_name = generate_func_name_from_composio_action(action_name)
 
-    wrapper_function_str = f"""
+    wrapper_function_str = f"""\
 def {func_name}(**kwargs):
-    from composio_langchain import ComposioToolSet
+    raise RuntimeError("Something went wrong - we should never be using the persisted source code for Composio. Please reach out to Letta team")
+"""
+
+    # Compile safety check
+    assert_code_gen_compilable(wrapper_function_str.strip())
+
+    return func_name, wrapper_function_str.strip()
+
+
+def execute_composio_action(
+    action_name: str, args: dict, api_key: Optional[str] = None, entity_id: Optional[str] = None
+) -> tuple[str, str]:
     import os
 
-    entity_id = os.getenv('{COMPOSIO_ENTITY_ENV_VAR_KEY}', '{DEFAULT_ENTITY_ID}')
-    composio_toolset = ComposioToolSet(entity_id=entity_id)
-    response = composio_toolset.execute_action(action='{action_name}', params=kwargs)
+    from composio.exceptions import (
+        ApiKeyNotProvidedError,
+        ComposioSDKError,
+        ConnectedAccountNotFoundError,
+        EnumMetadataNotFound,
+        EnumStringNotFound,
+    )
+    from composio_langchain import ComposioToolSet
 
-    if response["error"]:
-        raise RuntimeError(response["error"])
-    return response["data"]
-    """
+    entity_id = entity_id or os.getenv(COMPOSIO_ENTITY_ENV_VAR_KEY, DEFAULT_ENTITY_ID)
+    try:
+        composio_toolset = ComposioToolSet(api_key=api_key, entity_id=entity_id)
+        response = composio_toolset.execute_action(action=action_name, params=args)
+    except ApiKeyNotProvidedError:
+        raise RuntimeError(
+            f"Composio API key is missing for action '{action_name}'. "
+            "Please set the sandbox environment variables either through the ADE or the API."
+        )
+    except ConnectedAccountNotFoundError:
+        raise RuntimeError(f"No connected account was found for action '{action_name}'. " "Please link an account and try again.")
+    except EnumStringNotFound as e:
+        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+    except EnumMetadataNotFound as e:
+        raise RuntimeError(f"Invalid value provided for action '{action_name}': " + str(e) + ". Please check the action parameters.")
+    except ComposioSDKError as e:
+        raise RuntimeError(f"An unexpected error occurred in Composio SDK while executing action '{action_name}': " + str(e))
 
-    # Compile safety check
-    assert_code_gen_compilable(wrapper_function_str)
+    if response["error"]:
+        raise RuntimeError(f"Error while executing action '{action_name}': " + str(response["error"]))
 
-    return func_name, wrapper_function_str
+    return response["data"]
 
 
 def generate_langchain_tool_wrapper(

letta/helpers/composio_helpers.py

@@ -0,0 +1,21 @@
+from logging import Logger
+from typing import Optional
+
+from letta.schemas.user import User
+from letta.services.sandbox_config_manager import SandboxConfigManager
+from letta.settings import tool_settings
+
+
+def get_composio_api_key(actor: User, logger: Logger) -> Optional[str]:
+    api_keys = SandboxConfigManager().list_sandbox_env_vars_by_key(key="COMPOSIO_API_KEY", actor=actor)
+    if not api_keys:
+        logger.warning(f"No API keys found for Composio. Defaulting to the environment variable...")
+        if tool_settings.composio_api_key:
+            return tool_settings.composio_api_key
+        else:
+            return None
+    else:
+        # TODO: Add more protections around this
+        # Ideally, not tied to a specific sandbox, but for now we just get the first one
+        # Theoretically possible for someone to have different composio api keys per sandbox
+        return api_keys[0].value

letta/helpers/datetime_helpers.py

@@ -0,0 +1,90 @@
+import re
+from datetime import datetime, timedelta, timezone
+
+import pytz
+
+
+def parse_formatted_time(formatted_time):
+    # parse times returned by letta.utils.get_formatted_time()
+    return datetime.strptime(formatted_time, "%Y-%m-%d %I:%M:%S %p %Z%z")
+
+
+def datetime_to_timestamp(dt):
+    # convert datetime object to integer timestamp
+    return int(dt.timestamp())
+
+
+def timestamp_to_datetime(ts):
+    # convert integer timestamp to datetime object
+    return datetime.fromtimestamp(ts)
+
+
+def get_local_time_military():
+    # Get the current time in UTC
+    current_time_utc = datetime.now(pytz.utc)
+
+    # Convert to San Francisco's time zone (PST/PDT)
+    sf_time_zone = pytz.timezone("America/Los_Angeles")
+    local_time = current_time_utc.astimezone(sf_time_zone)
+
+    # You may format it as you desire
+    formatted_time = local_time.strftime("%Y-%m-%d %H:%M:%S %Z%z")
+
+    return formatted_time
+
+
+def get_local_time_timezone(timezone="America/Los_Angeles"):
+    # Get the current time in UTC
+    current_time_utc = datetime.now(pytz.utc)
+
+    # Convert to San Francisco's time zone (PST/PDT)
+    sf_time_zone = pytz.timezone(timezone)
+    local_time = current_time_utc.astimezone(sf_time_zone)
+
+    # You may format it as you desire, including AM/PM
+    formatted_time = local_time.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+
+    return formatted_time
+
+
+def get_local_time(timezone=None):
+    if timezone is not None:
+        time_str = get_local_time_timezone(timezone)
+    else:
+        # Get the current time, which will be in the local timezone of the computer
+        local_time = datetime.now().astimezone()
+
+        # You may format it as you desire, including AM/PM
+        time_str = local_time.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+
+    return time_str.strip()
+
+
+def get_utc_time() -> datetime:
+    """Get the current UTC time"""
+    # return datetime.now(pytz.utc)
+    return datetime.now(timezone.utc)
+
+
+def format_datetime(dt):
+    return dt.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+
+
+def validate_date_format(date_str):
+    """Validate the given date string in the format 'YYYY-MM-DD'."""
+    try:
+        datetime.strptime(date_str, "%Y-%m-%d")
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def extract_date_from_timestamp(timestamp):
+    """Extracts and returns the date from the given timestamp."""
+    # Extracts the date (ignoring the time and timezone)
+    match = re.match(r"(\d{4}-\d{2}-\d{2})", timestamp)
+    return match.group(1) if match else None
+
+
+def is_utc_datetime(dt: datetime) -> bool:
+    return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) == timedelta(0)

letta/helpers/json_helpers.py

@@ -0,0 +1,15 @@
+import json
+from datetime import datetime
+
+
+def json_loads(data):
+    return json.loads(data, strict=False)
+
+
+def json_dumps(data, indent=2):
+    def safe_serializer(obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        raise TypeError(f"Type {type(obj)} not serializable")
+
+    return json.dumps(data, indent=indent, default=safe_serializer, ensure_ascii=False)

letta/interface.py

@@ -5,9 +5,10 @@ from typing import List, Optional
 from colorama import Fore, Style, init
 
 from letta.constants import CLI_WARNING_PREFIX
+from letta.helpers.json_helpers import json_loads
 from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL, INNER_THOUGHTS_CLI_SYMBOL
 from letta.schemas.message import Message
-from letta.utils import json_loads, printd
+from letta.utils import printd
 
 init(autoreset=True)
 

letta/llm_api/anthropic.py

@@ -18,6 +18,7 @@ from anthropic.types.beta import (
 )
 
 from letta.errors import BedrockError, BedrockPermissionError
+from letta.helpers.datetime_helpers import get_utc_time
 from letta.llm_api.aws_bedrock import get_bedrock_client
 from letta.llm_api.helpers import add_inner_thoughts_to_functions
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
@@ -39,7 +40,6 @@ from letta.schemas.openai.chat_completion_response import MessageDelta, ToolCall
 from letta.services.provider_manager import ProviderManager
 from letta.settings import model_settings
 from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
-from letta.utils import get_utc_time
 
 BASE_URL = "https://api.anthropic.com/v1"
 

letta/llm_api/cohere.py

@@ -4,6 +4,8 @@ from typing import List, Optional, Union
 
 import requests
 
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.utils import count_tokens
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
@@ -12,7 +14,7 @@ from letta.schemas.openai.chat_completion_response import (
     Message as ChoiceMessage,  # NOTE: avoid conflict with our own Letta Message datatype
 )
 from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
-from letta.utils import get_tool_call_id, get_utc_time, json_dumps, smart_urljoin
+from letta.utils import get_tool_call_id, smart_urljoin
 
 BASE_URL = "https://api.cohere.ai/v1"
 

letta/llm_api/google_ai.py

@@ -4,12 +4,14 @@ from typing import List, Optional, Tuple
 import requests
 
 from letta.constants import NON_USER_MSG_PREFIX
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.json_helpers import json_dumps
 from letta.llm_api.helpers import make_post_request
 from letta.local_llm.json_parser import clean_json_string_extra_backslash
 from letta.local_llm.utils import count_tokens
 from letta.schemas.openai.chat_completion_request import Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
-from letta.utils import get_tool_call_id, get_utc_time, json_dumps
+from letta.utils import get_tool_call_id
 
 
 def get_gemini_endpoint_and_headers(

letta/llm_api/google_constants.py

@@ -0,0 +1,12 @@
+GOOGLE_MODEL_TO_CONTEXT_LENGTH = {
+    "gemini-2.0-flash-001": 1048576,
+    "gemini-2.0-pro-exp-02-05": 2097152,
+    "gemini-2.0-flash-lite-preview-02-05": 1048576,
+    "gemini-2.0-flash-thinking-exp-01-21": 1048576,
+    "gemini-1.5-flash": 1048576,
+    "gemini-1.5-pro": 2097152,
+    "gemini-1.0-pro": 32760,
+    "gemini-1.0-pro-vision": 16384,
+}
+
+GOOGLE_EMBEDING_MODEL_TO_DIM = {"text-embedding-005": 768, "text-multilingual-embedding-002": 768}

letta/llm_api/google_vertex.py

@@ -2,11 +2,13 @@ import uuid
 from typing import List, Optional
 
 from letta.constants import NON_USER_MSG_PREFIX
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.json_parser import clean_json_string_extra_backslash
 from letta.local_llm.utils import count_tokens
 from letta.schemas.openai.chat_completion_request import Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
-from letta.utils import get_tool_call_id, get_utc_time, json_dumps
+from letta.utils import get_tool_call_id
 
 
 def add_dummy_model_messages(messages: List[dict]) -> List[dict]:

letta/llm_api/helpers.py

@@ -7,10 +7,11 @@ from typing import Any, List, Union
 import requests
 
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
+from letta.helpers.json_helpers import json_dumps
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice
 from letta.settings import summarizer_settings
-from letta.utils import count_tokens, json_dumps, printd
+from letta.utils import count_tokens, printd
 
 
 def _convert_to_structured_output_helper(property: dict) -> dict:

letta/local_llm/chat_completion_proxy.py

@@ -6,6 +6,8 @@ import requests
 
 from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LocalLLMConnectionError, LocalLLMError
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.constants import DEFAULT_WRAPPER
 from letta.local_llm.function_parser import patch_function
 from letta.local_llm.grammars.gbnf_grammar_generator import create_dynamic_model_from_function, generate_gbnf_grammar_and_documentation
@@ -20,7 +22,7 @@ from letta.local_llm.webui.api import get_webui_completion
 from letta.local_llm.webui.legacy_api import get_webui_completion as get_webui_completion_legacy
 from letta.prompts.gpt_summarize import SYSTEM as SUMMARIZE_SYSTEM_MESSAGE
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, Message, ToolCall, UsageStatistics
-from letta.utils import get_tool_call_id, get_utc_time, json_dumps
+from letta.utils import get_tool_call_id
 
 has_shown_warning = False
 grammar_supported_backends = ["koboldcpp", "llamacpp", "webui", "webui-legacy"]

letta/local_llm/function_parser.py

@@ -1,7 +1,7 @@
 import copy
 import json
 
-from letta.utils import json_dumps, json_loads
+from letta.helpers.json_helpers import json_dumps, json_loads
 
 NO_HEARTBEAT_FUNCS = ["send_message"]
 

letta/local_llm/grammars/gbnf_grammar_generator.py

@@ -10,7 +10,7 @@ from typing import Any, Callable, List, Optional, Tuple, Type, Union, _GenericAl
 from docstring_parser import parse
 from pydantic import BaseModel, create_model
 
-from letta.utils import json_dumps
+from letta.helpers.json_helpers import json_dumps
 
 
 class PydanticDataType(Enum):

letta/local_llm/json_parser.py

@@ -2,7 +2,7 @@ import json
 import re
 
 from letta.errors import LLMJSONParsingError
-from letta.utils import json_loads
+from letta.helpers.json_helpers import json_loads
 
 
 def clean_json_string_extra_backslash(s):

letta/local_llm/llm_chat_completion_wrappers/airoboros.py

@@ -1,6 +1,5 @@
-from letta.utils import json_dumps, json_loads
-
 from ...errors import LLMJSONParsingError
+from ...helpers.json_helpers import json_dumps, json_loads
 from ..json_parser import clean_json
 from .wrapper_base import LLMChatCompletionWrapper
 

letta/local_llm/llm_chat_completion_wrappers/chatml.py

@@ -1,8 +1,8 @@
 from letta.errors import LLMJSONParsingError
+from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.local_llm.json_parser import clean_json
 from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import LLMChatCompletionWrapper
 from letta.schemas.enums import MessageRole
-from letta.utils import json_dumps, json_loads
 
 PREFIX_HINT = """# Reminders:
 # Important information about yourself and the user is stored in (limited) core memory

letta/local_llm/llm_chat_completion_wrappers/configurable_wrapper.py

@@ -1,8 +1,7 @@
 import yaml
 
-from letta.utils import json_dumps, json_loads
-
 from ...errors import LLMJSONParsingError
+from ...helpers.json_helpers import json_dumps, json_loads
 from ..json_parser import clean_json
 from .wrapper_base import LLMChatCompletionWrapper
 

letta/local_llm/llm_chat_completion_wrappers/dolphin.py

@@ -1,6 +1,5 @@
-from letta.utils import json_dumps, json_loads
-
 from ...errors import LLMJSONParsingError
+from ...helpers.json_helpers import json_dumps, json_loads
 from ..json_parser import clean_json
 from .wrapper_base import LLMChatCompletionWrapper
 

letta/local_llm/llm_chat_completion_wrappers/llama3.py

@@ -1,7 +1,7 @@
 from letta.errors import LLMJSONParsingError
+from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.local_llm.json_parser import clean_json
 from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import LLMChatCompletionWrapper
-from letta.utils import json_dumps, json_loads
 
 PREFIX_HINT = """# Reminders:
 # Important information about yourself and the user is stored in (limited) core memory

letta/local_llm/llm_chat_completion_wrappers/simple_summary_wrapper.py

@@ -1,5 +1,4 @@
-from letta.utils import json_dumps, json_loads
-
+from ...helpers.json_helpers import json_dumps, json_loads
 from .wrapper_base import LLMChatCompletionWrapper
 
 

letta/local_llm/llm_chat_completion_wrappers/zephyr.py

@@ -1,6 +1,5 @@
-from letta.utils import json_dumps, json_loads
-
 from ...errors import LLMJSONParsingError
+from ...helpers.json_helpers import json_dumps, json_loads
 from ..json_parser import clean_json
 from .wrapper_base import LLMChatCompletionWrapper
 

letta/local_llm/utils.py

@@ -249,10 +249,7 @@ def num_tokens_from_messages(messages: List[dict], model: str = "gpt-4") -> int:
                     # num_tokens += len(encoding.encode(value["arguments"]))
 
                 else:
-                    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 value is not None:
                         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))

letta/openai_backcompat/openai_object.py

@@ -4,7 +4,7 @@ from copy import deepcopy
 from enum import Enum
 from typing import Optional, Tuple, Union
 
-from letta.utils import json_dumps
+from letta.helpers.json_helpers import json_dumps
 
 api_requestor = None
 api_resources = None

letta/schemas/letta_response.py

@@ -5,10 +5,10 @@ from typing import List, Union
 
 from pydantic import BaseModel, Field
 
+from letta.helpers.json_helpers import json_dumps
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
 from letta.schemas.usage import LettaUsageStatistics
-from letta.utils import json_dumps
 
 # TODO: consider moving into own file
 

letta/schemas/message.py

@@ -12,6 +12,8 @@ from openai.types.chat.chat_completion_message_tool_call import Function as Open
 from pydantic import BaseModel, Field, field_validator, model_validator
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, TOOL_CALL_ID_MAX_LEN
+from letta.helpers.datetime_helpers import get_utc_time, is_utc_datetime
+from letta.helpers.json_helpers import json_dumps
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageContentType, MessageRole
 from letta.schemas.letta_base import OrmMetadataBase
@@ -28,7 +30,6 @@ from letta.schemas.letta_message import (
     UserMessage,
 )
 from letta.system import unpack_message
-from letta.utils import get_utc_time, is_utc_datetime, json_dumps
 
 
 def add_inner_thoughts_to_tool_call(

letta/schemas/organization.py

@@ -3,8 +3,9 @@ from typing import Optional
 
 from pydantic import Field
 
+from letta.helpers.datetime_helpers import get_utc_time
 from letta.schemas.letta_base import LettaBase
-from letta.utils import create_random_username, get_utc_time
+from letta.utils import create_random_username
 
 
 class OrganizationBase(LettaBase):

letta/schemas/passage.py

@@ -4,9 +4,9 @@ from typing import Dict, List, Optional
 from pydantic import Field, field_validator
 
 from letta.constants import MAX_EMBEDDING_DIM
+from letta.helpers.datetime_helpers import get_utc_time
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import OrmMetadataBase
-from letta.utils import get_utc_time
 
 
 class PassageBase(OrmMetadataBase):