run black, add isort config to pyproject.toml

alembic/env.py

@@ -1,11 +1,12 @@
 import os
 from logging.config import fileConfig
 
+from sqlalchemy import engine_from_config, pool
+
 from alembic import context
 from letta.config import LettaConfig
 from letta.orm import Base
 from letta.settings import settings
-from sqlalchemy import engine_from_config, pool
 
 letta_config = LettaConfig.load()
 

alembic/versions/08b2f8225812_adding_toolsagents_orm.py

@@ -9,6 +9,7 @@ Create Date: 2024-12-05 16:46:51.258831
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

alembic/versions/1c8880d671ee_make_an_blocks_agents_mapping_table.py

@@ -9,6 +9,7 @@ Create Date: 2024-11-22 15:42:47.209229
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

alembic/versions/3c683a662c82_migrate_jobs_to_the_orm.py

@@ -9,9 +9,10 @@ Create Date: 2024-12-04 15:59:41.708396
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "3c683a662c82"
 down_revision: Union[str, None] = "5987401b40ae"

alembic/versions/4e88e702f85e_drop_api_tokens_table_in_oss.py

@@ -9,6 +9,7 @@ Create Date: 2024-12-13 17:19:55.796210
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

alembic/versions/54dec07619c4_divide_passage_table_into_.py

@@ -9,11 +9,12 @@ Create Date: 2024-12-14 17:23:08.772554
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
-from letta.orm.custom_columns import EmbeddingConfigColumn
 from pgvector.sqlalchemy import Vector
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+from letta.orm.custom_columns import EmbeddingConfigColumn
+
 # revision identifiers, used by Alembic.
 revision: str = "54dec07619c4"
 down_revision: Union[str, None] = "4e88e702f85e"

alembic/versions/5987401b40ae_refactor_agent_memory.py

@@ -9,9 +9,10 @@ Create Date: 2024-11-25 14:35:00.896507
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "5987401b40ae"
 down_revision: Union[str, None] = "1c8880d671ee"

alembic/versions/95badb46fdf9_migrate_messages_to_the_orm.py

@@ -9,9 +9,10 @@ Create Date: 2024-12-05 14:02:04.163150
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "95badb46fdf9"
 down_revision: Union[str, None] = "08b2f8225812"

alembic/versions/9a505cc7eca9_create_a_baseline_migrations.py

@@ -8,12 +8,13 @@ Create Date: 2024-10-11 14:19:19.875656
 
 from typing import Sequence, Union
 
-import letta.orm
 import pgvector
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+import letta.orm
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "9a505cc7eca9"
 down_revision: Union[str, None] = None

alembic/versions/a91994b9752f_add_column_to_tools_table_to_contain_.py

@@ -9,6 +9,7 @@ Create Date: 2024-12-09 18:27:25.650079
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 from letta.constants import FUNCTION_RETURN_CHAR_LIMIT
 

alembic/versions/b6d7ca024aa9_add_agents_tags_table.py

@@ -9,6 +9,7 @@ Create Date: 2024-11-06 10:48:08.424108
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

alembic/versions/c5d964280dff_add_passages_orm_drop_legacy_passages_.py

@@ -9,9 +9,10 @@ Create Date: 2024-12-10 15:05:32.335519
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "c5d964280dff"
 down_revision: Union[str, None] = "a91994b9752f"

alembic/versions/c85a3d07c028_move_files_to_orm.py

@@ -9,6 +9,7 @@ Create Date: 2024-11-12 13:58:57.221081
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

alembic/versions/cda66b6cb0d6_move_sources_to_orm.py

@@ -9,9 +9,10 @@ Create Date: 2024-11-07 13:29:57.186107
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "cda66b6cb0d6"
 down_revision: Union[str, None] = "b6d7ca024aa9"

alembic/versions/d05669b60ebe_migrate_agents_to_orm.py

@@ -9,9 +9,10 @@ Create Date: 2024-12-12 10:25:31.825635
 from typing import Sequence, Union
 
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "d05669b60ebe"
 down_revision: Union[str, None] = "c5d964280dff"

alembic/versions/d14ae606614c_move_organizations_users_tools_to_orm.py

@@ -8,11 +8,12 @@ Create Date: 2024-11-05 15:03:12.350096
 
 from typing import Sequence, Union
 
-import letta
 import sqlalchemy as sa
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+import letta
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "d14ae606614c"
 down_revision: Union[str, None] = "9a505cc7eca9"

alembic/versions/e1a625072dbf_tweak_created_at_field_for_messages.py

@@ -8,9 +8,10 @@ Create Date: 2024-12-07 14:28:27.643583
 
 from typing import Sequence, Union
 
-from alembic import op
 from sqlalchemy.dialects import postgresql
 
+from alembic import op
+
 # revision identifiers, used by Alembic.
 revision: str = "e1a625072dbf"
 down_revision: Union[str, None] = "95badb46fdf9"

alembic/versions/f7507eab4bb9_migrate_blocks_to_orm_model.py

@@ -9,6 +9,7 @@ Create Date: 2024-11-18 15:40:13.149438
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

alembic/versions/f81ceea2c08d_create_sandbox_config_and_sandbox_env_.py

@@ -9,6 +9,7 @@ Create Date: 2024-11-14 17:51:27.263561
 from typing import Sequence, Union
 
 import sqlalchemy as sa
+
 from alembic import op
 
 # revision identifiers, used by Alembic.

examples/swarm/simple.py

@@ -1,7 +1,8 @@
 import typer
-from letta import EmbeddingConfig, LLMConfig
 from swarm import Swarm
 
+from letta import EmbeddingConfig, LLMConfig
+
 """
 This is an example of how to implement the basic example provided by OpenAI for tranferring a conversation between two agents:
 https://github.com/openai/swarm/tree/main?tab=readme-ov-file#usage

examples/swarm/swarm.py

@@ -2,6 +2,7 @@ import json
 from typing import List, Optional
 
 import typer
+
 from letta import AgentState, EmbeddingConfig, LLMConfig, create_client
 from letta.schemas.agent import AgentType
 from letta.schemas.memory import BasicBlockMemory, Block

examples/tool_rule_usage.py

@@ -4,10 +4,7 @@ import uuid
 from letta import create_client
 from letta.schemas.letta_message import ToolCallMessage
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
-from tests.helpers.endpoints_helper import (
+from tests.helpers.endpoints_helper import assert_invoked_send_message_with_keyword, setup_agent
-  assert_invoked_send_message_with_keyword,
-  setup_agent,
-)
 from tests.helpers.utils import cleanup
 from tests.test_model_letta_perfomance import llm_config_dir
 

letta/__init__.py

@@ -12,13 +12,7 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.memory import (
+from letta.schemas.memory import ArchivalMemorySummary, BasicBlockMemory, ChatMemory, Memory, RecallMemorySummary
-  ArchivalMemorySummary,
-  BasicBlockMemory,
-  ChatMemory,
-  Memory,
-  RecallMemorySummary,
-)
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.organization import Organization

letta/agent.py

@@ -7,17 +7,17 @@ from abc import ABC, abstractmethod
 from typing import List, Optional, Tuple, Union
 
 from letta.constants import (
-  BASE_TOOLS,
+    BASE_TOOLS,
-  CLI_WARNING_PREFIX,
+    CLI_WARNING_PREFIX,
-  ERROR_MESSAGE_PREFIX,
+    ERROR_MESSAGE_PREFIX,
-  FIRST_MESSAGE_ATTEMPTS,
+    FIRST_MESSAGE_ATTEMPTS,
-  FUNC_FAILED_HEARTBEAT_MESSAGE,
+    FUNC_FAILED_HEARTBEAT_MESSAGE,
-  LLM_MAX_TOKENS,
+    LLM_MAX_TOKENS,
-  MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
+    MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST,
-  MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC,
+    MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC,
-  MESSAGE_SUMMARY_WARNING_FRAC,
+    MESSAGE_SUMMARY_WARNING_FRAC,
-  O1_BASE_TOOLS,
+    O1_BASE_TOOLS,
-  REQ_HEARTBEAT_MESSAGE,
+    REQ_HEARTBEAT_MESSAGE,
 )
 from letta.errors import ContextWindowExceededError
 from letta.helpers import ToolRulesSolver
@@ -33,44 +33,31 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import ContextWindowOverview, Memory
 from letta.schemas.message import Message
-from letta.schemas.openai.chat_completion_request import (
+from letta.schemas.openai.chat_completion_request import Tool as ChatCompletionRequestTool
-  Tool as ChatCompletionRequestTool,
-)
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
-from letta.schemas.openai.chat_completion_response import (
+from letta.schemas.openai.chat_completion_response import Message as ChatCompletionMessage
-  Message as ChatCompletionMessage,
-)
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import (
+from letta.services.helpers.agent_manager_helper import check_supports_structured_output, compile_memory_metadata_block
-  check_supports_structured_output,
-  compile_memory_metadata_block,
-)
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.streaming_interface import StreamingRefreshCLIInterface
-from letta.system import (
+from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
-  get_heartbeat,
-  get_token_limit_warning,
-  package_function_response,
-  package_summarize_message,
-  package_user_message,
-)
 from letta.utils import (
-  count_tokens,
+    count_tokens,
-  get_friendly_error_msg,
+    get_friendly_error_msg,
-  get_tool_call_id,
+    get_tool_call_id,
-  get_utc_time,
+    get_utc_time,
-  json_dumps,
+    json_dumps,
-  json_loads,
+    json_loads,
-  parse_json,
+    parse_json,
-  printd,
+    printd,
-  validate_function_response,
+    validate_function_response,
 )
 
 

letta/benchmark/benchmark.py

@@ -5,6 +5,7 @@ import uuid
 from typing import Annotated, Union
 
 import typer
+
 from letta import LocalClient, RESTClient, create_client
 from letta.benchmark.constants import HUMAN, PERSONA, PROMPTS, TRIES
 from letta.config import LettaConfig

letta/cli/cli.py

@@ -3,18 +3,14 @@ import sys
 from enum import Enum
 from typing import Annotated, Optional
 
-import letta.utils as utils
 import questionary
 import typer
+
+import letta.utils as utils
 from letta import create_client
 from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
-from letta.constants import (
+from letta.constants import CLI_WARNING_PREFIX, CORE_MEMORY_BLOCK_CHAR_LIMIT, LETTA_DIR, MIN_CONTEXT_WINDOW
-  CLI_WARNING_PREFIX,
-  CORE_MEMORY_BLOCK_CHAR_LIMIT,
-  LETTA_DIR,
-  MIN_CONTEXT_WINDOW,
-)
 from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL
 from letta.log import get_logger
 from letta.schemas.enums import OptionState
@@ -22,9 +18,7 @@ from letta.schemas.memory import ChatMemory, Memory
 from letta.server.server import logger as server_logger
 
 # from letta.interface import CLIInterface as interface  # for printing to terminal
-from letta.streaming_interface import (
+from letta.streaming_interface import StreamingRefreshCLIInterface as interface  # for printing to terminal
-  StreamingRefreshCLIInterface as interface,  # for printing to terminal
-)
 from letta.utils import open_folder_in_explorer, printd
 
 logger = get_logger(__name__)

letta/cli/cli_config.py

@@ -5,10 +5,11 @@ from typing import Annotated, List, Optional
 
 import questionary
 import typer
-from letta import utils
 from prettytable.colortable import ColorTable, Themes
 from tqdm import tqdm
 
+from letta import utils
+
 app = typer.Typer()
 
 

letta/cli/cli_load.py

@@ -13,6 +13,7 @@ from typing import Annotated, List, Optional
 
 import questionary
 import typer
+
 from letta import create_client
 from letta.data_sources.connectors import DirectoryConnector
 

letta/client/client.py

@@ -2,16 +2,10 @@ import logging
 import time
 from typing import Callable, Dict, Generator, List, Optional, Union
 
-import letta.utils
 import requests
-from letta.constants import (
+
-  ADMIN_PREFIX,
+import letta.utils
-  BASE_MEMORY_TOOLS,
+from letta.constants import ADMIN_PREFIX, BASE_MEMORY_TOOLS, BASE_TOOLS, DEFAULT_HUMAN, DEFAULT_PERSONA, FUNCTION_RETURN_CHAR_LIMIT
-  BASE_TOOLS,
-  DEFAULT_HUMAN,
-  DEFAULT_PERSONA,
-  FUNCTION_RETURN_CHAR_LIMIT,
-)
 from letta.data_sources.connectors import DataConnector
 from letta.functions.functions import parse_source_code
 from letta.orm.errors import NoResultFound
@@ -26,26 +20,20 @@ from letta.schemas.job import Job
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse, LettaStreamingResponse
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.memory import (
+from letta.schemas.memory import ArchivalMemorySummary, ChatMemory, CreateArchivalMemory, Memory, RecallMemorySummary
-  ArchivalMemorySummary,
-  ChatMemory,
-  CreateArchivalMemory,
-  Memory,
-  RecallMemorySummary,
-)
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.openai.chat_completions import ToolCall
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
 from letta.schemas.sandbox_config import (
-  E2BSandboxConfig,
+    E2BSandboxConfig,
-  LocalSandboxConfig,
+    LocalSandboxConfig,
-  SandboxConfig,
+    SandboxConfig,
-  SandboxConfigCreate,
+    SandboxConfigCreate,
-  SandboxConfigUpdate,
+    SandboxConfigUpdate,
-  SandboxEnvironmentVariable,
+    SandboxEnvironmentVariable,
-  SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableCreate,
-  SandboxEnvironmentVariableUpdate,
+    SandboxEnvironmentVariableUpdate,
 )
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate

letta/client/streaming.py

@@ -3,14 +3,11 @@ from typing import Generator
 
 import httpx
 from httpx_sse import SSEError, connect_sse
+
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
 from letta.errors import LLMError
 from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import (
+from letta.schemas.letta_message import ReasoningMessage, ToolCallMessage, ToolReturnMessage
-  ReasoningMessage,
-  ToolCallMessage,
-  ToolReturnMessage,
-)
 from letta.schemas.letta_response import LettaStreamingResponse
 from letta.schemas.usage import LettaUsageStatistics
 

letta/client/utils.py

@@ -3,12 +3,10 @@ from datetime import datetime
 from typing import Optional
 
 from IPython.display import HTML, display
-from letta.local_llm.constants import (
-  ASSISTANT_MESSAGE_CLI_SYMBOL,
-  INNER_THOUGHTS_CLI_SYMBOL,
-)
 from sqlalchemy.testing.plugin.plugin_base import warnings
 
+from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL, INNER_THOUGHTS_CLI_SYMBOL
+
 
 def pprint(messages):
     """Utility function for pretty-printing the output of client.send_message in notebooks"""

letta/config.py

@@ -5,12 +5,12 @@ from typing import Optional
 
 import letta
 from letta.constants import (
-  CORE_MEMORY_HUMAN_CHAR_LIMIT,
+    CORE_MEMORY_HUMAN_CHAR_LIMIT,
-  CORE_MEMORY_PERSONA_CHAR_LIMIT,
+    CORE_MEMORY_PERSONA_CHAR_LIMIT,
-  DEFAULT_HUMAN,
+    DEFAULT_HUMAN,
-  DEFAULT_PERSONA,
+    DEFAULT_PERSONA,
-  DEFAULT_PRESET,
+    DEFAULT_PRESET,
-  LETTA_DIR,
+    LETTA_DIR,
 )
 from letta.log import get_logger
 from letta.schemas.embedding_config import EmbeddingConfig

letta/data_sources/connectors.py

@@ -1,11 +1,8 @@
 from typing import Dict, Iterator, List, Tuple
 
 import typer
-from letta.data_sources.connectors_helper import (
+
-  assert_all_files_exist_locally,
+from letta.data_sources.connectors_helper import assert_all_files_exist_locally, extract_metadata_from_files, get_filenames_in_dir
-  extract_metadata_from_files,
-  get_filenames_in_dir,
-)
 from letta.embeddings import embedding_model
 from letta.schemas.file import FileMetadata
 from letta.schemas.passage import Passage

letta/embeddings.py

@@ -3,11 +3,8 @@ from typing import Any, List, Optional
 
 import numpy as np
 import tiktoken
-from letta.constants import (
+
-  EMBEDDING_TO_TOKENIZER_DEFAULT,
+from letta.constants import EMBEDDING_TO_TOKENIZER_DEFAULT, EMBEDDING_TO_TOKENIZER_MAP, MAX_EMBEDDING_DIM
-  EMBEDDING_TO_TOKENIZER_MAP,
-  MAX_EMBEDDING_DIM,
-)
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.utils import is_valid_url, printd
 

letta/functions/function_sets/extras.py

@@ -3,10 +3,8 @@ import uuid
 from typing import Optional
 
 import requests
-from letta.constants import (
+
-  MESSAGE_CHATGPT_FUNCTION_MODEL,
+from letta.constants import MESSAGE_CHATGPT_FUNCTION_MODEL, MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE
-  MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE,
-)
 from letta.llm_api.llm_api_tools import create
 from letta.schemas.message import Message
 from letta.utils import json_dumps, json_loads

letta/helpers/tool_rule_solver.py

@@ -1,16 +1,11 @@
 import json
 from typing import List, Optional, Union
 
-from letta.schemas.enums import ToolRuleType
-from letta.schemas.tool_rule import (
-  BaseToolRule,
-  ChildToolRule,
-  ConditionalToolRule,
-  InitToolRule,
-  TerminalToolRule,
-)
 from pydantic import BaseModel, Field
 
+from letta.schemas.enums import ToolRuleType
+from letta.schemas.tool_rule import BaseToolRule, ChildToolRule, ConditionalToolRule, InitToolRule, TerminalToolRule
+
 
 class ToolRuleValidationError(Exception):
     """Custom exception for tool rule validation errors in ToolRulesSolver."""

letta/interface.py

@@ -3,11 +3,9 @@ from abc import ABC, abstractmethod
 from typing import List, Optional
 
 from colorama import Fore, Style, init
+
 from letta.constants import CLI_WARNING_PREFIX
-from letta.local_llm.constants import (
+from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL, INNER_THOUGHTS_CLI_SYMBOL
-  ASSISTANT_MESSAGE_CLI_SYMBOL,
-  INNER_THOUGHTS_CLI_SYMBOL,
-)
 from letta.schemas.message import Message
 from letta.utils import json_loads, printd
 

letta/llm_api/anthropic.py

@@ -5,13 +5,9 @@ from typing import List, Optional, Union
 from letta.llm_api.helpers import make_post_request
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall
 from letta.schemas.openai.chat_completion_response import (
-  ChatCompletionResponse,
+    Message as ChoiceMessage,  # NOTE: avoid conflict with our own Letta Message datatype
-  Choice,
-  FunctionCall,
-)
-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_utc_time, smart_urljoin

letta/llm_api/azure_openai.py

@@ -1,6 +1,7 @@
 from collections import defaultdict
 
 import requests
+
 from letta.llm_api.helpers import make_post_request
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse

letta/llm_api/cohere.py

@@ -3,16 +3,13 @@ import uuid
 from typing import List, Optional, Union
 
 import requests
+
 from letta.local_llm.utils import count_tokens
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall
 from letta.schemas.openai.chat_completion_response import (
-  ChatCompletionResponse,
+    Message as ChoiceMessage,  # NOTE: avoid conflict with our own Letta Message datatype
-  Choice,
-  FunctionCall,
-)
-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
@@ -275,10 +272,7 @@ def convert_tools_to_cohere_format(tools: List[Tool], inner_thoughts_in_kwargs:
     if inner_thoughts_in_kwargs:
         # NOTE: since Cohere doesn't allow "text" in the response when a tool call happens, if we want
         # a simultaneous CoT + tool call we need to put it inside a kwarg
-        from letta.local_llm.constants import (
+        from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
-          INNER_THOUGHTS_KWARG,
-          INNER_THOUGHTS_KWARG_DESCRIPTION,
-        )
 
         for cohere_tool in tools_dict_list:
             cohere_tool["parameter_definitions"][INNER_THOUGHTS_KWARG] = {

letta/llm_api/google_ai.py

@@ -2,19 +2,13 @@ import uuid
 from typing import List, Optional, Tuple
 
 import requests
+
 from letta.constants import NON_USER_MSG_PREFIX
 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 (
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
-  ChatCompletionResponse,
-  Choice,
-  FunctionCall,
-  Message,
-  ToolCall,
-  UsageStatistics,
-)
 from letta.utils import get_tool_call_id, get_utc_time, json_dumps
 
 
@@ -229,10 +223,7 @@ def convert_tools_to_google_ai_format(tools: List[Tool], inner_thoughts_in_kwarg
             param_fields["type"] = param_fields["type"].upper()
         # Add inner thoughts
         if inner_thoughts_in_kwargs:
-            from letta.local_llm.constants import (
+            from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
-              INNER_THOUGHTS_KWARG,
-              INNER_THOUGHTS_KWARG_DESCRIPTION,
-            )
 
             func["parameters"]["properties"][INNER_THOUGHTS_KWARG] = {
                 "type": "STRING",

letta/llm_api/helpers.py

@@ -5,6 +5,7 @@ from collections import OrderedDict
 from typing import Any, List, Union
 
 import requests
+
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice
 from letta.utils import json_dumps, printd

letta/llm_api/llm_api_tools.py

@@ -3,42 +3,27 @@ import time
 from typing import List, Optional, Union
 
 import requests
+
 from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LettaConfigurationError, RateLimitExceededError
 from letta.llm_api.anthropic import anthropic_chat_completions_request
 from letta.llm_api.azure_openai import azure_openai_chat_completions_request
-from letta.llm_api.google_ai import (
+from letta.llm_api.google_ai import convert_tools_to_google_ai_format, google_ai_chat_completions_request
-  convert_tools_to_google_ai_format,
+from letta.llm_api.helpers import add_inner_thoughts_to_functions, unpack_all_inner_thoughts_from_kwargs
-  google_ai_chat_completions_request,
-)
-from letta.llm_api.helpers import (
-  add_inner_thoughts_to_functions,
-  unpack_all_inner_thoughts_from_kwargs,
-)
 from letta.llm_api.openai import (
-  build_openai_chat_completions_request,
+    build_openai_chat_completions_request,
-  openai_chat_completions_process_stream,
+    openai_chat_completions_process_stream,
-  openai_chat_completions_request,
+    openai_chat_completions_request,
 )
 from letta.local_llm.chat_completion_proxy import get_chat_completion
-from letta.local_llm.constants import (
+from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
-  INNER_THOUGHTS_KWARG,
-  INNER_THOUGHTS_KWARG_DESCRIPTION,
-)
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message
-from letta.schemas.openai.chat_completion_request import (
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool, cast_message_to_subtype
-  ChatCompletionRequest,
-  Tool,
-  cast_message_to_subtype,
-)
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.settings import ModelSettings
-from letta.streaming_interface import (
+from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
-  AgentChunkStreamingInterface,
-  AgentRefreshStreamingInterface,
-)
 
 LLM_API_PROVIDER_OPTIONS = ["openai", "azure", "anthropic", "google_ai", "cohere", "local", "groq"]
 

letta/llm_api/mistral.py

@@ -1,4 +1,5 @@
 import requests
+
 from letta.utils import printd, smart_urljoin
 
 

letta/llm_api/openai.py

@@ -6,44 +6,29 @@ import httpx
 import requests
 from httpx_sse import connect_sse
 from httpx_sse._exceptions import SSEError
+
 from letta.constants import OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING
 from letta.errors import LLMError
-from letta.llm_api.helpers import (
+from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_structured_output, make_post_request
-  add_inner_thoughts_to_functions,
+from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
-  convert_to_structured_output,
-  make_post_request,
-)
-from letta.local_llm.constants import (
-  INNER_THOUGHTS_KWARG,
-  INNER_THOUGHTS_KWARG_DESCRIPTION,
-)
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as _Message
 from letta.schemas.message import MessageRole as _MessageRole
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
-from letta.schemas.openai.chat_completion_request import (
+from letta.schemas.openai.chat_completion_request import FunctionCall as ToolFunctionChoiceFunctionCall
-  FunctionCall as ToolFunctionChoiceFunctionCall,
+from letta.schemas.openai.chat_completion_request import Tool, ToolFunctionChoice, cast_message_to_subtype
-)
-from letta.schemas.openai.chat_completion_request import (
-  Tool,
-  ToolFunctionChoice,
-  cast_message_to_subtype,
-)
 from letta.schemas.openai.chat_completion_response import (
-  ChatCompletionChunkResponse,
+    ChatCompletionChunkResponse,
-  ChatCompletionResponse,
+    ChatCompletionResponse,
-  Choice,
+    Choice,
-  FunctionCall,
+    FunctionCall,
-  Message,
+    Message,
-  ToolCall,
+    ToolCall,
-  UsageStatistics,
+    UsageStatistics,
 )
 from letta.schemas.openai.embedding_response import EmbeddingResponse
-from letta.streaming_interface import (
+from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
-  AgentChunkStreamingInterface,
-  AgentRefreshStreamingInterface,
-)
 from letta.utils import get_tool_call_id, smart_urljoin
 
 OPENAI_SSE_DONE = "[DONE]"

letta/local_llm/chat_completion_proxy.py

@@ -3,14 +3,12 @@
 import uuid
 
 import requests
+
 from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LocalLLMConnectionError, LocalLLMError
 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 (
+from letta.local_llm.grammars.gbnf_grammar_generator import create_dynamic_model_from_function, generate_gbnf_grammar_and_documentation
-  create_dynamic_model_from_function,
-  generate_gbnf_grammar_and_documentation,
-)
 from letta.local_llm.koboldcpp.api import get_koboldcpp_completion
 from letta.local_llm.llamacpp.api import get_llamacpp_completion
 from letta.local_llm.llm_chat_completion_wrappers import simple_summary_wrapper
@@ -19,17 +17,9 @@ from letta.local_llm.ollama.api import get_ollama_completion
 from letta.local_llm.utils import count_tokens, get_available_wrappers
 from letta.local_llm.vllm.api import get_vllm_completion
 from letta.local_llm.webui.api import get_webui_completion
-from letta.local_llm.webui.legacy_api import (
+from letta.local_llm.webui.legacy_api import get_webui_completion as get_webui_completion_legacy
-  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 (
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, Message, ToolCall, UsageStatistics
-  ChatCompletionResponse,
-  Choice,
-  Message,
-  ToolCall,
-  UsageStatistics,
-)
 from letta.utils import get_tool_call_id, get_utc_time, json_dumps
 
 has_shown_warning = False

letta/local_llm/constants.py

@@ -1,7 +1,5 @@
 # import letta.local_llm.llm_chat_completion_wrappers.airoboros as airoboros
-from letta.local_llm.llm_chat_completion_wrappers.chatml import (
+from letta.local_llm.llm_chat_completion_wrappers.chatml import ChatMLInnerMonologueWrapper
-  ChatMLInnerMonologueWrapper,
-)
 
 DEFAULT_ENDPOINTS = {
     # Local

letta/local_llm/grammars/gbnf_grammar_generator.py

@@ -5,23 +5,13 @@ from copy import copy
 from enum import Enum
 from inspect import getdoc, isclass
 from types import NoneType
-from typing import (
+from typing import Any, Callable, List, Optional, Tuple, Type, Union, _GenericAlias, get_args, get_origin
-  Any,
-  Callable,
-  List,
-  Optional,
-  Tuple,
-  Type,
-  Union,
-  _GenericAlias,
-  get_args,
-  get_origin,
-)
 
 from docstring_parser import parse
-from letta.utils import json_dumps
 from pydantic import BaseModel, create_model
 
+from letta.utils import json_dumps
+
 
 class PydanticDataType(Enum):
     """

letta/local_llm/llm_chat_completion_wrappers/chatml.py

@@ -1,8 +1,6 @@
 from letta.errors import LLMJSONParsingError
 from letta.local_llm.json_parser import clean_json
-from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import (
+from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import LLMChatCompletionWrapper
-  LLMChatCompletionWrapper,
-)
 from letta.schemas.enums import MessageRole
 from letta.utils import json_dumps, json_loads
 
@@ -75,10 +73,7 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
         func_str += f"\n  description: {schema['description']}"
         func_str += f"\n  params:"
         if add_inner_thoughts:
-            from letta.local_llm.constants import (
+            from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
-              INNER_THOUGHTS_KWARG,
-              INNER_THOUGHTS_KWARG_DESCRIPTION,
-            )
 
             func_str += f"\n    {INNER_THOUGHTS_KWARG}: {INNER_THOUGHTS_KWARG_DESCRIPTION}"
         for param_k, param_v in schema["parameters"]["properties"].items():

letta/local_llm/llm_chat_completion_wrappers/configurable_wrapper.py

@@ -1,4 +1,5 @@
 import yaml
+
 from letta.utils import json_dumps, json_loads
 
 from ...errors import LLMJSONParsingError

letta/local_llm/llm_chat_completion_wrappers/llama3.py

@@ -1,8 +1,6 @@
 from letta.errors import LLMJSONParsingError
 from letta.local_llm.json_parser import clean_json
-from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import (
+from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import LLMChatCompletionWrapper
-  LLMChatCompletionWrapper,
-)
 from letta.utils import json_dumps, json_loads
 
 PREFIX_HINT = """# Reminders:
@@ -74,10 +72,7 @@ class LLaMA3InnerMonologueWrapper(LLMChatCompletionWrapper):
         func_str += f"\n  description: {schema['description']}"
         func_str += "\n  params:"
         if add_inner_thoughts:
-            from letta.local_llm.constants import (
+            from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
-              INNER_THOUGHTS_KWARG,
-              INNER_THOUGHTS_KWARG_DESCRIPTION,
-            )
 
             func_str += f"\n    {INNER_THOUGHTS_KWARG}: {INNER_THOUGHTS_KWARG_DESCRIPTION}"
         for param_k, param_v in schema["parameters"]["properties"].items():

letta/local_llm/settings/settings.py

@@ -2,9 +2,7 @@ import json
 import os
 
 from letta.constants import LETTA_DIR
-from letta.local_llm.settings.deterministic_mirostat import (
+from letta.local_llm.settings.deterministic_mirostat import settings as det_miro_settings
-  settings as det_miro_settings,
-)
 from letta.local_llm.settings.simple import settings as simple_settings
 
 DEFAULT = "simple"

letta/local_llm/utils.py

@@ -2,14 +2,15 @@ import os
 import warnings
 from typing import List, Union
 
+import requests
+import tiktoken
+
 import letta.local_llm.llm_chat_completion_wrappers.airoboros as airoboros
 import letta.local_llm.llm_chat_completion_wrappers.chatml as chatml
 import letta.local_llm.llm_chat_completion_wrappers.configurable_wrapper as configurable_wrapper
 import letta.local_llm.llm_chat_completion_wrappers.dolphin as dolphin
 import letta.local_llm.llm_chat_completion_wrappers.llama3 as llama3
 import letta.local_llm.llm_chat_completion_wrappers.zephyr as zephyr
-import requests
-import tiktoken
 from letta.schemas.openai.chat_completion_request import Tool, ToolCall
 
 

letta/main.py

@@ -2,12 +2,14 @@ import os
 import sys
 import traceback
 
-import letta.agent as agent
-import letta.errors as errors
-import letta.system as system
 import questionary
 import requests
 import typer
+from rich.console import Console
+
+import letta.agent as agent
+import letta.errors as errors
+import letta.system as system
 
 # import benchmark
 from letta import create_client
@@ -20,7 +22,6 @@ from letta.constants import FUNC_FAILED_HEARTBEAT_MESSAGE, REQ_HEARTBEAT_MESSAGE
 
 # from letta.interface import CLIInterface as interface  # for printing to terminal
 from letta.streaming_interface import AgentRefreshStreamingInterface
-from rich.console import Console
 
 # interface = interface()
 

letta/orm/agent.py

@@ -1,12 +1,11 @@
 import uuid
 from typing import TYPE_CHECKING, List, Optional
 
+from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm.block import Block
-from letta.orm.custom_columns import (
+from letta.orm.custom_columns import EmbeddingConfigColumn, LLMConfigColumn, ToolRulesColumn
-  EmbeddingConfigColumn,
-  LLMConfigColumn,
-  ToolRulesColumn,
-)
 from letta.orm.message import Message
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.organization import Organization
@@ -17,8 +16,6 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.tool_rule import ToolRule
-from sqlalchemy import JSON, String, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm.agents_tags import AgentsTags

letta/orm/agents_tags.py

@@ -1,7 +1,8 @@
-from letta.orm.base import Base
 from sqlalchemy import ForeignKey, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.orm.base import Base
+
 
 class AgentsTags(Base):
     __tablename__ = "agents_tags"

letta/orm/base.py

@@ -2,13 +2,7 @@ from datetime import datetime
 from typing import Optional
 
 from sqlalchemy import Boolean, DateTime, String, func, text
-from sqlalchemy.orm import (
+from sqlalchemy.orm import DeclarativeBase, Mapped, declarative_mixin, declared_attr, mapped_column
-  DeclarativeBase,
-  Mapped,
-  declarative_mixin,
-  declared_attr,
-  mapped_column,
-)
 
 
 class Base(DeclarativeBase):

letta/orm/block.py

@@ -1,13 +1,14 @@
 from typing import TYPE_CHECKING, Optional, Type
 
+from sqlalchemy import JSON, BigInteger, Integer, UniqueConstraint, event
+from sqlalchemy.orm import Mapped, attributes, mapped_column, relationship
+
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import Human, Persona
-from sqlalchemy import JSON, BigInteger, Integer, UniqueConstraint, event
-from sqlalchemy.orm import Mapped, attributes, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm import Organization

letta/orm/blocks_agents.py

@@ -1,7 +1,8 @@
-from letta.orm.base import Base
 from sqlalchemy import ForeignKey, ForeignKeyConstraint, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column
 
+from letta.orm.base import Base
+
 
 class BlocksAgents(Base):
     """Agents must have one or many blocks to make up their core memory."""

letta/orm/custom_columns.py

@@ -2,18 +2,14 @@ import base64
 from typing import List, Union
 
 import numpy as np
+from sqlalchemy import JSON
+from sqlalchemy.types import BINARY, TypeDecorator
+
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
-from letta.schemas.tool_rule import (
+from letta.schemas.tool_rule import ChildToolRule, ConditionalToolRule, InitToolRule, TerminalToolRule
-  ChildToolRule,
-  ConditionalToolRule,
-  InitToolRule,
-  TerminalToolRule,
-)
-from sqlalchemy import JSON
-from sqlalchemy.types import BINARY, TypeDecorator
 
 
 class EmbeddingConfigColumn(TypeDecorator):

letta/orm/file.py

@@ -1,10 +1,11 @@
 from typing import TYPE_CHECKING, List, Optional
 
+from sqlalchemy import Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm.mixins import OrganizationMixin, SourceMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.file import FileMetadata as PydanticFileMetadata
-from sqlalchemy import Integer, String
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization

letta/orm/job.py

@@ -1,12 +1,13 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, Optional
 
+from sqlalchemy import JSON, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm.mixins import UserMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job as PydanticJob
-from sqlalchemy import JSON, String
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm.user import User

letta/orm/message.py

@@ -1,12 +1,13 @@
 from typing import Optional
 
+from sqlalchemy import Index
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm.custom_columns import ToolCallColumn
 from letta.orm.mixins import AgentMixin, OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completions import ToolCall
-from sqlalchemy import Index
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 
 class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):

letta/orm/mixins.py

@@ -1,10 +1,11 @@
 from typing import Optional
 from uuid import UUID
 
-from letta.orm.base import Base
 from sqlalchemy import ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
+from letta.orm.base import Base
+
 
 def is_valid_uuid4(uuid_string: str) -> bool:
     """Check if a string is a valid UUID4."""

letta/orm/organization.py

@@ -1,8 +1,9 @@
 from typing import TYPE_CHECKING, List, Union
 
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.organization import Organization as PydanticOrganization
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
 

letta/orm/passage.py

@@ -1,5 +1,8 @@
 from typing import TYPE_CHECKING
 
+from sqlalchemy import JSON, Column, Index
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
+
 from letta.config import LettaConfig
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.orm.custom_columns import CommonVector, EmbeddingConfigColumn
@@ -7,8 +10,6 @@ from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin, SourceMix
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.settings import settings
-from sqlalchemy import JSON, Column, Index
-from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
 
 config = LettaConfig()
 

letta/orm/sandbox_config.py

@@ -1,17 +1,16 @@
 from typing import TYPE_CHECKING, Dict, List, Optional
 
-from letta.orm.mixins import OrganizationMixin, SandboxConfigMixin
-from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
-from letta.schemas.sandbox_config import (
-  SandboxEnvironmentVariable as PydanticSandboxEnvironmentVariable,
-)
-from letta.schemas.sandbox_config import SandboxType
 from sqlalchemy import JSON
 from sqlalchemy import Enum as SqlEnum
 from sqlalchemy import String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.orm.mixins import OrganizationMixin, SandboxConfigMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
+from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticSandboxEnvironmentVariable
+from letta.schemas.sandbox_config import SandboxType
+
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
 

letta/orm/source.py

@@ -1,13 +1,14 @@
 from typing import TYPE_CHECKING, List, Optional
 
+from sqlalchemy import JSON
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm import FileMetadata
 from letta.orm.custom_columns import EmbeddingConfigColumn
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.source import Source as PydanticSource
-from sqlalchemy import JSON
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm.agent import Agent

letta/orm/sources_agents.py

@@ -1,7 +1,8 @@
-from letta.orm.base import Base
 from sqlalchemy import ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
+from letta.orm.base import Base
+
 
 class SourcesAgents(Base):
     """Agents can have zero to many sources"""

letta/orm/sqlalchemy_base.py

@@ -3,19 +3,15 @@ from enum import Enum
 from functools import wraps
 from typing import TYPE_CHECKING, List, Literal, Optional
 
-from letta.log import get_logger
-from letta.orm.base import Base, CommonSqlalchemyMetaMixins
-from letta.orm.errors import (
-  DatabaseTimeoutError,
-  ForeignKeyConstraintViolationError,
-  NoResultFound,
-  UniqueConstraintViolationError,
-)
-from letta.orm.sqlite_functions import adapt_array
 from sqlalchemy import String, desc, func, or_, select
 from sqlalchemy.exc import DBAPIError, IntegrityError, TimeoutError
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
+from letta.log import get_logger
+from letta.orm.base import Base, CommonSqlalchemyMetaMixins
+from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
+from letta.orm.sqlite_functions import adapt_array
+
 if TYPE_CHECKING:
     from pydantic import BaseModel
     from sqlalchemy.orm import Session

letta/orm/sqlite_functions.py

@@ -3,10 +3,11 @@ import sqlite3
 from typing import Optional, Union
 
 import numpy as np
-from letta.constants import MAX_EMBEDDING_DIM
 from sqlalchemy import event
 from sqlalchemy.engine import Engine
 
+from letta.constants import MAX_EMBEDDING_DIM
+
 
 def adapt_array(arr):
     """

letta/orm/tool.py

@@ -1,12 +1,13 @@
 from typing import TYPE_CHECKING, List, Optional
 
+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.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.tool import Tool as PydanticTool
-from sqlalchemy import JSON, String, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization

letta/orm/tools_agents.py

@@ -1,7 +1,8 @@
-from letta.orm import Base
 from sqlalchemy import ForeignKey, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column
 
+from letta.orm import Base
+
 
 class ToolsAgents(Base):
     """Agents can have one or many tools associated with them."""

letta/orm/user.py

@@ -1,9 +1,10 @@
 from typing import TYPE_CHECKING, List
 
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.user import User as PydanticUser
-from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 if TYPE_CHECKING:
     from letta.orm import Job, Organization

letta/providers.py

@@ -1,14 +1,12 @@
 from typing import List, Optional
 
+from pydantic import BaseModel, Field, model_validator
+
 from letta.constants import LLM_MAX_TOKENS, MIN_CONTEXT_WINDOW
-from letta.llm_api.azure_openai import (
+from letta.llm_api.azure_openai import get_azure_chat_completions_endpoint, get_azure_embeddings_endpoint
-  get_azure_chat_completions_endpoint,
-  get_azure_embeddings_endpoint,
-)
 from letta.llm_api.azure_openai_constants import AZURE_MODEL_TO_CONTEXT_LENGTH
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
-from pydantic import BaseModel, Field, model_validator
 
 
 class Provider(BaseModel):
@@ -567,9 +565,7 @@ class AzureProvider(Provider):
         return values
 
     def list_llm_models(self) -> List[LLMConfig]:
-        from letta.llm_api.azure_openai import (
+        from letta.llm_api.azure_openai import azure_openai_get_chat_completion_model_list
-          azure_openai_get_chat_completion_model_list,
-        )
 
         model_options = azure_openai_get_chat_completion_model_list(self.base_url, api_key=self.api_key, api_version=self.api_version)
         configs = []

letta/schemas/agent.py

@@ -1,6 +1,8 @@
 from enum import Enum
 from typing import Dict, List, Optional
 
+from pydantic import BaseModel, Field, field_validator
+
 from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -13,7 +15,6 @@ from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import ToolRule
 from letta.utils import create_random_username
-from pydantic import BaseModel, Field, field_validator
 
 
 class AgentType(str, Enum):

letta/schemas/block.py

@@ -1,9 +1,10 @@
 from typing import Optional
 
+from pydantic import BaseModel, Field, model_validator
+from typing_extensions import Self
+
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.letta_base import LettaBase
-from pydantic import BaseModel, Field, model_validator
-from typing_extensions import Self
 
 # block of the LLM context
 

letta/schemas/file.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
-from letta.schemas.letta_base import LettaBase
 from pydantic import Field
 
+from letta.schemas.letta_base import LettaBase
+
 
 class FileMetadataBase(LettaBase):
     """Base class for FileMetadata schemas"""

letta/schemas/job.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
+from pydantic import Field
+
 from letta.schemas.enums import JobStatus
 from letta.schemas.letta_base import OrmMetadataBase
-from pydantic import Field
 
 
 class JobBase(OrmMetadataBase):

letta/schemas/letta_request.py

@@ -1,8 +1,9 @@
 from typing import List
 
+from pydantic import BaseModel, Field
+
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.message import MessageCreate
-from pydantic import BaseModel, Field
 
 
 class LettaRequest(BaseModel):

letta/schemas/letta_response.py

@@ -3,11 +3,12 @@ import json
 import re
 from typing import List, Union
 
+from pydantic import BaseModel, Field
+
 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
-from pydantic import BaseModel, Field
 
 # TODO: consider moving into own file
 

letta/schemas/message.py

@@ -4,25 +4,17 @@ import warnings
 from datetime import datetime, timezone
 from typing import List, Literal, Optional
 
-from letta.constants import (
+from pydantic import BaseModel, Field, field_validator
-  DEFAULT_MESSAGE_TOOL,
+
-  DEFAULT_MESSAGE_TOOL_KWARG,
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, TOOL_CALL_ID_MAX_LEN
-  TOOL_CALL_ID_MAX_LEN,
-)
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_base import OrmMetadataBase
-from letta.schemas.letta_message import (
+from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, SystemMessage
-  AssistantMessage,
-  LettaMessage,
-  ReasoningMessage,
-  SystemMessage,
-)
 from letta.schemas.letta_message import ToolCall as LettaToolCall
 from letta.schemas.letta_message import ToolCallMessage, ToolReturnMessage, UserMessage
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.utils import get_utc_time, is_utc_datetime, json_dumps
-from pydantic import BaseModel, Field, field_validator
 
 
 def add_inner_thoughts_to_tool_call(

letta/schemas/organization.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
+from pydantic import Field
+
 from letta.schemas.letta_base import LettaBase
 from letta.utils import create_random_username, get_utc_time
-from pydantic import Field
 
 
 class OrganizationBase(LettaBase):

letta/schemas/passage.py

@@ -1,11 +1,12 @@
 from datetime import datetime
 from typing import Dict, List, Optional
 
+from pydantic import Field, field_validator
+
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.utils import get_utc_time
-from pydantic import Field, field_validator
 
 
 class PassageBase(OrmMetadataBase):

letta/schemas/sandbox_config.py

@@ -3,10 +3,11 @@ import json
 from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Union
 
+from pydantic import BaseModel, Field, model_validator
+
 from letta.schemas.agent import AgentState
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
 from letta.settings import tool_settings
-from pydantic import BaseModel, Field, model_validator
 
 
 # Sandbox Config

letta/schemas/source.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
+from pydantic import Field
+
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
-from pydantic import Field
 
 
 class BaseSource(LettaBase):

letta/schemas/tool.py

@@ -1,15 +1,13 @@
 from typing import 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.functions.helpers import (
+from letta.functions.helpers import generate_composio_tool_wrapper, generate_langchain_tool_wrapper
-  generate_composio_tool_wrapper,
-  generate_langchain_tool_wrapper,
-)
 from letta.functions.schema_generator import generate_schema_from_args_schema_v2
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
-from pydantic import Field, model_validator
 
 
 class BaseTool(LettaBase):

letta/schemas/tool_rule.py

@@ -1,8 +1,9 @@
 from typing import Any, Dict, List, Optional, Union
 
+from pydantic import Field
+
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.letta_base import LettaBase
-from pydantic import Field
 
 
 class BaseToolRule(LettaBase):

letta/schemas/user.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from typing import Optional
 
+from pydantic import Field
+
 from letta.schemas.letta_base import LettaBase
 from letta.services.organization_manager import OrganizationManager
-from pydantic import Field
 
 
 class UserBase(LettaBase):

letta/server/rest_api/app.py

@@ -8,44 +8,30 @@ from typing import Optional
 import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.middleware.cors import CORSMiddleware
+
 from letta.__init__ import __version__
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.errors import LettaAgentNotFoundError, LettaUserNotFoundError
 from letta.log import get_logger
-from letta.orm.errors import (
+from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
-  DatabaseTimeoutError,
-  ForeignKeyConstraintViolationError,
-  NoResultFound,
-  UniqueConstraintViolationError,
-)
 from letta.schemas.letta_response import LettaResponse
 from letta.server.constants import REST_DEFAULT_PORT
 
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
-from letta.server.rest_api.auth.index import (
+from letta.server.rest_api.auth.index import setup_auth_router  # TODO: probably remove right?
-  setup_auth_router,  # TODO: probably remove right?
-)
 from letta.server.rest_api.interface import StreamingServerInterface
-from letta.server.rest_api.routers.openai.assistants.assistants import (
+from letta.server.rest_api.routers.openai.assistants.assistants import router as openai_assistants_router
-  router as openai_assistants_router,
+from letta.server.rest_api.routers.openai.chat_completions.chat_completions import router as openai_chat_completions_router
-)
-from letta.server.rest_api.routers.openai.chat_completions.chat_completions import (
-  router as openai_chat_completions_router,
-)
 
 # from letta.orm.utilities import get_db_session  # TODO(ethan) reenable once we merge ORM
 from letta.server.rest_api.routers.v1 import ROUTERS as v1_routes
-from letta.server.rest_api.routers.v1.organizations import (
+from letta.server.rest_api.routers.v1.organizations import router as organizations_router
-  router as organizations_router,
+from letta.server.rest_api.routers.v1.users import router as users_router  # TODO: decide on admin
-)
-from letta.server.rest_api.routers.v1.users import (
-  router as users_router,  # TODO: decide on admin
-)
 from letta.server.rest_api.static_files import mount_static_files
 from letta.server.server import SyncServer
 from letta.settings import settings
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.middleware.cors import CORSMiddleware
 
 # TODO(ethan)
 # NOTE(charles): @ethan I had to add this to get the global as the bottom to work

letta/server/rest_api/auth/index.py

@@ -2,10 +2,11 @@ from typing import Optional
 from uuid import UUID
 
 from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
 from letta.log import get_logger
 from letta.server.rest_api.interface import QueuingInterface
 from letta.server.server import SyncServer
-from pydantic import BaseModel, Field
 
 logger = get_logger(__name__)
 router = APIRouter()

letta/server/rest_api/auth_token.py

@@ -2,6 +2,7 @@ import uuid
 
 from fastapi import Depends, HTTPException
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
 from letta.server.server import SyncServer
 
 security = HTTPBearer()

letta/server/rest_api/interface.py

@@ -11,23 +11,20 @@ from letta.interface import AgentInterface
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import (
-  AssistantMessage,
+    AssistantMessage,
-  LegacyFunctionCallMessage,
+    LegacyFunctionCallMessage,
-  LegacyLettaMessage,
+    LegacyLettaMessage,
-  LettaMessage,
+    LettaMessage,
-  ReasoningMessage,
+    ReasoningMessage,
-  ToolCall,
+    ToolCall,
-  ToolCallDelta,
+    ToolCallDelta,
-  ToolCallMessage,
+    ToolCallMessage,
-  ToolReturnMessage,
+    ToolReturnMessage,
 )
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionChunkResponse
 from letta.streaming_interface import AgentChunkStreamingInterface
-from letta.streaming_utils import (
+from letta.streaming_utils import FunctionArgumentsStreamHandler, JSONInnerThoughtsExtractor
-  FunctionArgumentsStreamHandler,
-  JSONInnerThoughtsExtractor,
-)
 from letta.utils import is_utc_datetime
 
 

letta/server/rest_api/routers/openai/assistants/assistants.py

@@ -1,13 +1,14 @@
 from typing import List
 
 from fastapi import APIRouter, Body, HTTPException, Path, Query
+
 from letta.constants import DEFAULT_PRESET
 from letta.schemas.openai.openai import AssistantFile, OpenAIAssistant
 from letta.server.rest_api.routers.openai.assistants.schemas import (
-  CreateAssistantFileRequest,
+    CreateAssistantFileRequest,
-  CreateAssistantRequest,
+    CreateAssistantRequest,
-  DeleteAssistantFileResponse,
+    DeleteAssistantFileResponse,
-  DeleteAssistantResponse,
+    DeleteAssistantResponse,
 )
 from letta.utils import get_utc_time
 

letta/server/rest_api/routers/openai/assistants/schemas.py

@@ -1,14 +1,9 @@
 from typing import List, Optional
 
-from letta.schemas.openai.openai import (
-  MessageRoleType,
-  OpenAIMessage,
-  OpenAIThread,
-  ToolCall,
-  ToolCallOutput,
-)
 from pydantic import BaseModel, Field
 
+from letta.schemas.openai.openai import MessageRoleType, OpenAIMessage, OpenAIThread, ToolCall, ToolCallOutput
+
 
 class CreateAssistantRequest(BaseModel):
     model: str = Field(..., description="The model to use for the assistant.")

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -2,15 +2,11 @@ import json
 from typing import TYPE_CHECKING, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
+
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message import LettaMessage, ToolCall
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
-from letta.schemas.openai.chat_completion_response import (
+from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, Message, UsageStatistics
-  ChatCompletionResponse,
-  Choice,
-  Message,
-  UsageStatistics,
-)
 
 # TODO this belongs in a controller!
 from letta.server.rest_api.routers.v1.agents import send_message_to_agent

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

@@ -3,9 +3,7 @@ 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.sandbox_configs import (
+from letta.server.rest_api.routers.v1.sandbox_configs import router as sandbox_configs_router
-  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
 

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

@@ -3,42 +3,21 @@ import warnings
 from datetime import datetime
 from typing import List, Optional, Union
 
-from fastapi import (
+from fastapi import APIRouter, BackgroundTasks, Body, Depends, Header, HTTPException, Query, status
-  APIRouter,
-  BackgroundTasks,
-  Body,
-  Depends,
-  Header,
-  HTTPException,
-  Query,
-  status,
-)
 from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import Field
+
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
-from letta.schemas.block import (  # , BlockLabelUpdate, BlockLimitUpdate
+from letta.schemas.block import Block, BlockUpdate, CreateBlock  # , BlockLabelUpdate, BlockLimitUpdate
-  Block,
-  BlockUpdate,
-  CreateBlock,
-)
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.job import Job, JobStatus, JobUpdate
-from letta.schemas.letta_message import (
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, LettaMessageUnion
-  LegacyLettaMessage,
-  LettaMessage,
-  LettaMessageUnion,
-)
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.memory import (
+from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, CreateArchivalMemory, Memory, RecallMemorySummary
-  ArchivalMemorySummary,
-  ContextWindowOverview,
-  CreateArchivalMemory,
-  Memory,
-  RecallMemorySummary,
-)
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
@@ -47,7 +26,6 @@ from letta.schemas.user import User
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import get_letta_server, sse_async_generator
 from letta.server.server import SyncServer
-from pydantic import Field
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 

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

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Response
+
 from letta.orm.errors import NoResultFound
 from letta.schemas.block import Block, BlockUpdate, CreateBlock
 from letta.server.rest_api.utils import get_letta_server

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

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING
 
 from fastapi import APIRouter
+
 from letta.cli.cli import version
 from letta.schemas.health import Health