letta-nightly 0.8.5.dev20250624104340__py3-none-any.whl → 0.8.6.dev20250625222533__py3-none-any.whl

letta/llm_api/anthropic.py

@@ -72,11 +72,16 @@ MODEL_LIST = [
         "name": "claude-3-opus-20240229",
         "context_window": 200000,
     },
-    # latest
+    # 3 latest
     {
         "name": "claude-3-opus-latest",
         "context_window": 200000,
     },
+    # 4
+    {
+        "name": "claude-opus-4-20250514",
+        "context_window": 200000,
+    },
     ## Sonnet
     # 3.0
     {
@@ -108,6 +113,11 @@ MODEL_LIST = [
         "name": "claude-3-7-sonnet-latest",
         "context_window": 200000,
     },
+    # 4
+    {
+        "name": "claude-sonnet-4-20250514",
+        "context_window": 200000,
+    },
     ## Haiku
     # 3.0
     {

letta/llm_api/anthropic_client.py

@@ -21,9 +21,11 @@ from letta.errors import (
     LLMPermissionDeniedError,
     LLMRateLimitError,
     LLMServerError,
+    LLMTimeoutError,
     LLMUnprocessableEntityError,
 )
 from letta.helpers.datetime_helpers import get_utc_time_int
+from letta.helpers.decorators import deprecated
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, unpack_all_inner_thoughts_from_kwargs
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
@@ -47,22 +49,23 @@ logger = get_logger(__name__)
 class AnthropicClient(LLMClientBase):
 
     @trace_method
+    @deprecated("Synchronous version of this is no longer valid. Will result in model_dump of coroutine")
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(llm_config, async_client=False)
-        response = client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
+        response = client.beta.messages.create(**request_data)
         return response.model_dump()
 
     @trace_method
     async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = await self._get_anthropic_client_async(llm_config, async_client=True)
-        response = await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
+        response = await client.beta.messages.create(**request_data)
         return response.model_dump()
 
     @trace_method
     async def stream_async(self, request_data: dict, llm_config: LLMConfig) -> AsyncStream[BetaRawMessageStreamEvent]:
         client = await self._get_anthropic_client_async(llm_config, async_client=True)
         request_data["stream"] = True
-        return await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
+        return await client.beta.messages.create(**request_data)
 
     @trace_method
     async def send_llm_batch_request_async(
@@ -299,6 +302,14 @@ class AnthropicClient(LLMClientBase):
 
     @trace_method
     def handle_llm_error(self, e: Exception) -> Exception:
+        if isinstance(e, anthropic.APITimeoutError):
+            logger.warning(f"[Anthropic] Request timeout: {e}")
+            return LLMTimeoutError(
+                message=f"Request to Anthropic timed out: {str(e)}",
+                code=ErrorCode.TIMEOUT,
+                details={"cause": str(e.__cause__) if e.__cause__ else None},
+            )
+
         if isinstance(e, anthropic.APIConnectionError):
             logger.warning(f"[Anthropic] API connection error: {e.__cause__}")
             return LLMConnectionError(

letta/llm_api/aws_bedrock.py

@@ -3,38 +3,32 @@ from typing import Any, Dict, List, Optional
 
 from anthropic import AnthropicBedrock
 
-from letta.log import get_logger
 from letta.settings import model_settings
 
-logger = get_logger(__name__)
-
 
 def has_valid_aws_credentials() -> bool:
     """
     Check if AWS credentials are properly configured.
     """
-    valid_aws_credentials = (
-        os.getenv("AWS_ACCESS_KEY") is not None and os.getenv("AWS_SECRET_ACCESS_KEY") is not None and os.getenv("AWS_REGION") is not None
-    )
+    valid_aws_credentials = os.getenv("AWS_ACCESS_KEY_ID") and os.getenv("AWS_SECRET_ACCESS_KEY") and os.getenv("AWS_DEFAULT_REGION")
     return valid_aws_credentials
 
 
 def get_bedrock_client(
-    access_key: Optional[str] = None,
+    access_key_id: Optional[str] = None,
     secret_key: Optional[str] = None,
-    region: Optional[str] = None,
+    default_region: Optional[str] = None,
 ):
     """
     Get a Bedrock client
     """
     import boto3
 
-    logger.debug(f"Getting Bedrock client for {model_settings.aws_region}")
     sts_client = boto3.client(
         "sts",
-        aws_access_key_id=access_key or model_settings.aws_access_key,
+        aws_access_key_id=access_key_id or model_settings.aws_access_key_id,
         aws_secret_access_key=secret_key or model_settings.aws_secret_access_key,
-        region_name=region or model_settings.aws_region,
+        region_name=default_region or model_settings.aws_default_region,
     )
     credentials = sts_client.get_session_token()["Credentials"]
 
@@ -42,7 +36,7 @@ def get_bedrock_client(
         aws_access_key=credentials["AccessKeyId"],
         aws_secret_key=credentials["SecretAccessKey"],
         aws_session_token=credentials["SessionToken"],
-        aws_region=region or model_settings.aws_region,
+        aws_region=default_region or model_settings.aws_default_region,
     )
     return bedrock
 
@@ -61,13 +55,34 @@ def bedrock_get_model_list(region_name: str) -> List[dict]:
     """
     import boto3
 
-    logger.debug(f"Getting model list for {region_name}")
     try:
         bedrock = boto3.client("bedrock", region_name=region_name)
         response = bedrock.list_inference_profiles()
         return response["inferenceProfileSummaries"]
     except Exception as e:
-        logger.exception(f"Error getting model list: {str(e)}", e)
+        print(f"Error getting model list: {str(e)}")
+        raise e
+
+
+async def bedrock_get_model_list_async(
+    access_key_id: Optional[str] = None,
+    secret_access_key: Optional[str] = None,
+    default_region: Optional[str] = None,
+) -> List[dict]:
+    from aioboto3.session import Session
+
+    try:
+        session = Session()
+        async with session.client(
+            "bedrock",
+            aws_access_key_id=access_key_id,
+            aws_secret_access_key=secret_access_key,
+            region_name=default_region,
+        ) as bedrock:
+            response = await bedrock.list_inference_profiles()
+            return response["inferenceProfileSummaries"]
+    except Exception as e:
+        print(f"Error getting model list: {str(e)}")
         raise e
 
 
@@ -78,7 +93,6 @@ def bedrock_get_model_details(region_name: str, model_id: str) -> Dict[str, Any]
     import boto3
     from botocore.exceptions import ClientError
 
-    logger.debug(f"Getting model details for {model_id}")
     try:
         bedrock = boto3.client("bedrock", region_name=region_name)
         response = bedrock.get_foundation_model(modelIdentifier=model_id)

letta/llm_api/bedrock_client.py

@@ -0,0 +1,74 @@
+from typing import List, Optional, Union
+
+import anthropic
+from aioboto3.session import Session
+
+from letta.llm_api.anthropic_client import AnthropicClient
+from letta.log import get_logger
+from letta.otel.tracing import trace_method
+from letta.schemas.enums import ProviderCategory
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.message import Message as PydanticMessage
+from letta.services.provider_manager import ProviderManager
+from letta.settings import model_settings
+
+logger = get_logger(__name__)
+
+
+class BedrockClient(AnthropicClient):
+
+    @trace_method
+    async def _get_anthropic_client_async(
+        self, llm_config: LLMConfig, async_client: bool = False
+    ) -> Union[anthropic.AsyncAnthropic, anthropic.Anthropic, anthropic.AsyncAnthropicBedrock, anthropic.AnthropicBedrock]:
+        override_access_key_id, override_secret_access_key, override_default_region = None, None, None
+        if llm_config.provider_category == ProviderCategory.byok:
+            (
+                override_access_key_id,
+                override_secret_access_key,
+                override_default_region,
+            ) = await ProviderManager().get_bedrock_credentials_async(
+                llm_config.provider_name,
+                actor=self.actor,
+            )
+
+        session = Session()
+        async with session.client(
+            "sts",
+            aws_access_key_id=override_access_key_id or model_settings.aws_access_key_id,
+            aws_secret_access_key=override_secret_access_key or model_settings.aws_secret_access_key,
+            region_name=override_default_region or model_settings.aws_default_region,
+        ) as sts_client:
+            session_token = await sts_client.get_session_token()
+            credentials = session_token["Credentials"]
+
+        if async_client:
+            return anthropic.AsyncAnthropicBedrock(
+                aws_access_key=credentials["AccessKeyId"],
+                aws_secret_key=credentials["SecretAccessKey"],
+                aws_session_token=credentials["SessionToken"],
+                aws_region=override_default_region or model_settings.aws_default_region,
+                max_retries=model_settings.anthropic_max_retries,
+            )
+        else:
+            return anthropic.AnthropicBedrock(
+                aws_access_key=credentials["AccessKeyId"],
+                aws_secret_key=credentials["SecretAccessKey"],
+                aws_session_token=credentials["SessionToken"],
+                aws_region=override_default_region or model_settings.aws_default_region,
+                max_retries=model_settings.anthropic_max_retries,
+            )
+
+    @trace_method
+    def build_request_data(
+        self,
+        messages: List[PydanticMessage],
+        llm_config: LLMConfig,
+        tools: Optional[List[dict]] = None,
+        force_tool_call: Optional[str] = None,
+    ) -> dict:
+        data = super().build_request_data(messages, llm_config, tools, force_tool_call)
+        # remove disallowed fields
+        if "tool_choice" in data:
+            del data["tool_choice"]["disable_parallel_tool_use"]
+        return data

letta/llm_api/google_ai_client.py

@@ -2,20 +2,24 @@ from typing import List, Optional, Tuple
 
 import httpx
 from google import genai
+from google.genai.types import HttpOptions
 
 from letta.errors import ErrorCode, LLMAuthenticationError, LLMError
 from letta.llm_api.google_constants import GOOGLE_MODEL_FOR_API_KEY_CHECK
 from letta.llm_api.google_vertex_client import GoogleVertexClient
 from letta.log import get_logger
-from letta.settings import model_settings
+from letta.settings import model_settings, settings
 
 logger = get_logger(__name__)
 
 
 class GoogleAIClient(GoogleVertexClient):
-
     def _get_client(self):
-        return genai.Client(api_key=model_settings.gemini_api_key)
+        timeout_ms = int(settings.llm_request_timeout_seconds * 1000)
+        return genai.Client(
+            api_key=model_settings.gemini_api_key,
+            http_options=HttpOptions(timeout=timeout_ms),
+        )
 
 
 def get_gemini_endpoint_and_headers(

letta/llm_api/google_vertex_client.py

@@ -3,7 +3,14 @@ import uuid
 from typing import List, Optional
 
 from google import genai
-from google.genai.types import FunctionCallingConfig, FunctionCallingConfigMode, GenerateContentResponse, ThinkingConfig, ToolConfig
+from google.genai.types import (
+    FunctionCallingConfig,
+    FunctionCallingConfigMode,
+    GenerateContentResponse,
+    HttpOptions,
+    ThinkingConfig,
+    ToolConfig,
+)
 
 from letta.constants import NON_USER_MSG_PREFIX
 from letta.helpers.datetime_helpers import get_utc_time_int
@@ -26,11 +33,12 @@ logger = get_logger(__name__)
 class GoogleVertexClient(LLMClientBase):
 
     def _get_client(self):
+        timeout_ms = int(settings.llm_request_timeout_seconds * 1000)
         return genai.Client(
             vertexai=True,
             project=model_settings.google_cloud_project,
             location=model_settings.google_cloud_location,
-            http_options={"api_version": "v1"},
+            http_options=HttpOptions(api_version="v1", timeout=timeout_ms),
         )
 
     @trace_method
@@ -59,7 +67,8 @@ class GoogleVertexClient(LLMClientBase):
         )
         return response.model_dump()
 
-    def add_dummy_model_messages(self, messages: List[dict]) -> List[dict]:
+    @staticmethod
+    def add_dummy_model_messages(messages: List[dict]) -> List[dict]:
         """Google AI API requires all function call returns are immediately followed by a 'model' role message.
 
         In Letta, the 'model' will often call a function (e.g. send_message) that itself yields to the user,
@@ -90,7 +99,7 @@ class GoogleVertexClient(LLMClientBase):
         # Per https://ai.google.dev/gemini-api/docs/function-calling?example=meeting#notes_and_limitations
         # * Only a subset of the OpenAPI schema is supported.
         # * Supported parameter types in Python are limited.
-        unsupported_keys = ["default", "exclusiveMaximum", "exclusiveMinimum", "additionalProperties"]
+        unsupported_keys = ["default", "exclusiveMaximum", "exclusiveMinimum", "additionalProperties", "$schema"]
         keys_to_remove_at_this_level = [key for key in unsupported_keys if key in schema_part]
         for key_to_remove in keys_to_remove_at_this_level:
             logger.warning(f"Removing unsupported keyword 	'{key_to_remove}' from schema part.")
@@ -484,3 +493,8 @@ class GoogleVertexClient(LLMClientBase):
             "propertyOrdering": ["name", "args"],
             "required": ["name", "args"],
         }
+
+    @trace_method
+    def handle_llm_error(self, e: Exception) -> Exception:
+        # Fallback to base implementation
+        return super().handle_llm_error(e)

letta/llm_api/llm_client.py

@@ -51,6 +51,13 @@ class LLMClient:
                     put_inner_thoughts_first=put_inner_thoughts_first,
                     actor=actor,
                 )
+            case ProviderType.bedrock:
+                from letta.llm_api.bedrock_client import BedrockClient
+
+                return BedrockClient(
+                    put_inner_thoughts_first=put_inner_thoughts_first,
+                    actor=actor,
+                )
             case ProviderType.openai | ProviderType.together:
                 from letta.llm_api.openai_client import OpenAIClient
 

letta/llm_api/openai_client.py

@@ -17,6 +17,7 @@ from letta.errors import (
     LLMPermissionDeniedError,
     LLMRateLimitError,
     LLMServerError,
+    LLMTimeoutError,
     LLMUnprocessableEntityError,
 )
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_structured_output, unpack_all_inner_thoughts_from_kwargs
@@ -317,6 +318,18 @@ class OpenAIClient(LLMClientBase):
         """
         Maps OpenAI-specific errors to common LLMError types.
         """
+        if isinstance(e, openai.APITimeoutError):
+            timeout_duration = getattr(e, "timeout", "unknown")
+            logger.warning(f"[OpenAI] Request timeout after {timeout_duration} seconds: {e}")
+            return LLMTimeoutError(
+                message=f"Request to OpenAI timed out: {str(e)}",
+                code=ErrorCode.TIMEOUT,
+                details={
+                    "timeout_duration": timeout_duration,
+                    "cause": str(e.__cause__) if e.__cause__ else None,
+                },
+            )
+
         if isinstance(e, openai.APIConnectionError):
             logger.warning(f"[OpenAI] API connection error: {e}")
             return LLMConnectionError(

letta/orm/agent.py

@@ -89,6 +89,9 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
         Integer, nullable=True, doc="The duration in milliseconds of the agent's last run."
     )
 
+    # timezone
+    timezone: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The timezone of the agent (for the context window).")
+
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="agents")
     tool_exec_environment_variables: Mapped[List["AgentEnvironmentVariable"]] = relationship(
@@ -187,6 +190,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
             "response_format": self.response_format,
             "last_run_completion": self.last_run_completion,
             "last_run_duration_ms": self.last_run_duration_ms,
+            "timezone": self.timezone,
             # optional field defaults
             "tags": [],
             "tools": [],
@@ -261,6 +265,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
             "last_updated_by_id": self.last_updated_by_id,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
+            "timezone": self.timezone,
             "enable_sleeptime": self.enable_sleeptime,
             "response_format": self.response_format,
             "last_run_completion": self.last_run_completion,

letta/orm/block_history.py

@@ -4,9 +4,9 @@ from typing import Optional
 from sqlalchemy import JSON, BigInteger, ForeignKey, Index, Integer, String, Text
 from sqlalchemy.orm import Mapped, mapped_column
 
-from letta.orm.enums import ActorType
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import ActorType
 
 
 class BlockHistory(OrganizationMixin, SqlalchemyBase):

letta/orm/enums.py

@@ -1,3 +1,9 @@
+"""Compatibility module for enums that were moved to address circular imports.
+
+This module maintains the old enum definitions for backwards compatibility,
+especially for pickled objects that reference the old import paths.
+"""
+
 from enum import Enum
 
 
@@ -14,28 +20,3 @@ class ToolType(str, Enum):
     EXTERNAL_LANGCHAIN = "external_langchain"
     # TODO is "external" the right name here? Since as of now, MCP is local / doesn't support remote?
     EXTERNAL_MCP = "external_mcp"
-
-
-class JobType(str, Enum):
-    JOB = "job"
-    RUN = "run"
-    BATCH = "batch"
-
-
-class ToolSourceType(str, Enum):
-    """Defines what a tool was derived from"""
-
-    python = "python"
-    json = "json"
-
-
-class ActorType(str, Enum):
-    LETTA_USER = "letta_user"
-    LETTA_AGENT = "letta_agent"
-    LETTA_SYSTEM = "letta_system"
-
-
-class MCPServerType(str, Enum):
-    SSE = "sse"
-    STDIO = "stdio"
-    STREAMABLE_HTTP = "streamable_http"

letta/orm/job.py

@@ -4,10 +4,9 @@ from typing import TYPE_CHECKING, List, Optional
 from sqlalchemy import JSON, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.enums import JobType
 from letta.orm.mixins import UserMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, JobType
 from letta.schemas.job import Job as PydanticJob
 from letta.schemas.job import LettaRequestConfig
 

letta/orm/llm_batch_items.py

@@ -8,8 +8,8 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 from letta.orm.custom_columns import AgentStepStateColumn, BatchRequestResultColumn, LLMConfigColumn
 from letta.orm.mixins import AgentMixin, OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.agent import AgentStepState
 from letta.schemas.enums import AgentStepStatus, JobStatus
+from letta.schemas.llm_batch_job import AgentStepState
 from letta.schemas.llm_batch_job import LLMBatchItem as PydanticLLMBatchItem
 from letta.schemas.llm_config import LLMConfig
 

letta/orm/mcp_server.py

@@ -7,9 +7,9 @@ from letta.functions.mcp_client.types import StdioServerConfig
 from letta.orm.custom_columns import MCPStdioServerConfigColumn
 
 # TODO everything in functions should live in this model
-from letta.orm.enums import MCPServerType
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import MCPServerType
 from letta.schemas.mcp import MCPServer
 
 if TYPE_CHECKING:

letta/orm/passage.py

@@ -60,13 +60,19 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
 
     @declared_attr
     def __table_args__(cls):
+        # TODO (cliandy): investigate if this is necessary, may be for SQLite compatability or do we need to add as well?
         if settings.letta_pg_uri_no_default:
             return (
                 Index("source_passages_org_idx", "organization_id"),
                 Index("source_passages_created_at_id_idx", "created_at", "id"),
+                Index("source_passages_file_id_idx", "file_id"),
                 {"extend_existing": True},
             )
-        return (Index("source_passages_created_at_id_idx", "created_at", "id"), {"extend_existing": True})
+        return (
+            Index("source_passages_created_at_id_idx", "created_at", "id"),
+            Index("source_passages_file_id_idx", "file_id"),
+            {"extend_existing": True},
+        )
 
     @declared_attr
     def source(cls) -> Mapped["Source"]:

letta/orm/sqlalchemy_base.py

@@ -49,6 +49,11 @@ def handle_db_timeout(func):
         return async_wrapper
 
 
+def is_postgresql_session(session: Session) -> bool:
+    """Check if the database session is PostgreSQL instead of SQLite for setting query options."""
+    return session.bind.dialect.name == "postgresql"
+
+
 class AccessType(str, Enum):
     ORGANIZATION = "organization"
     USER = "user"
@@ -490,20 +495,17 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         Raises:
             NoResultFound: if the object is not found
         """
-        from letta.settings import settings
-
         identifiers = [] if identifier is None else [identifier]
         query, query_conditions = cls._read_multiple_preprocess(identifiers, actor, access, access_type, check_is_deleted, **kwargs)
         if query is None:
             raise NoResultFound(f"{cls.__name__} not found with identifier {identifier}")
-
-        if settings.letta_pg_uri_no_default:
+        if is_postgresql_session(db_session):
             await db_session.execute(text("SET LOCAL enable_seqscan = OFF"))
         try:
             result = await db_session.execute(query)
             item = result.scalar_one_or_none()
         finally:
-            if settings.letta_pg_uri_no_default:
+            if is_postgresql_session(db_session):
                 await db_session.execute(text("SET LOCAL enable_seqscan = ON"))
 
         if item is None:

letta/orm/tool.py

@@ -4,9 +4,10 @@ from sqlalchemy import JSON, Index, 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, ToolType
+from letta.orm.enums import ToolType
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import ToolSourceType
 from letta.schemas.tool import Tool as PydanticTool
 
 if TYPE_CHECKING: