letta-nightly 0.7.7.dev20250430205840__py3-none-any.whl → 0.7.8.dev20250501104226__py3-none-any.whl

letta/llm_api/openai_client.py

@@ -22,6 +22,7 @@ from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_st
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION, INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST
 from letta.log import get_logger
+from letta.schemas.enums import ProviderType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
@@ -64,7 +65,14 @@ def supports_parallel_tool_calling(model: str) -> bool:
 
 class OpenAIClient(LLMClientBase):
     def _prepare_client_kwargs(self, llm_config: LLMConfig) -> dict:
-        api_key = model_settings.openai_api_key or os.environ.get("OPENAI_API_KEY")
+        api_key = None
+        if llm_config.provider_name and llm_config.provider_name != ProviderType.openai.value:
+            from letta.services.provider_manager import ProviderManager
+
+            api_key = ProviderManager().get_override_key(llm_config.provider_name)
+
+        if not api_key:
+            api_key = model_settings.openai_api_key or os.environ.get("OPENAI_API_KEY")
         # supposedly the openai python client requires a dummy API key
         api_key = api_key or "DUMMY_API_KEY"
         kwargs = {"api_key": api_key, "base_url": llm_config.model_endpoint}
@@ -135,11 +143,17 @@ class OpenAIClient(LLMClientBase):
             temperature=llm_config.temperature if supports_temperature_param(model) else None,
         )
 
+        # always set user id for openai requests
+        if self.actor_id:
+            data.user = self.actor_id
+
         if llm_config.model_endpoint == LETTA_MODEL_ENDPOINT:
-            # override user id for inference.memgpt.ai
-            import uuid
+            if not self.actor_id:
+                # override user id for inference.letta.com
+                import uuid
+
+                data.user = str(uuid.UUID(int=0))
 
-            data.user = str(uuid.UUID(int=0))
             data.model = "memgpt-openai"
 
         if data.tools is not None and len(data.tools) > 0:

letta/memory.py

@@ -79,8 +79,10 @@ def summarize_messages(
     llm_config_no_inner_thoughts.put_inner_thoughts_in_kwargs = False
 
     llm_client = LLMClient.create(
-        provider=llm_config_no_inner_thoughts.model_endpoint_type,
+        provider_name=llm_config_no_inner_thoughts.provider_name,
+        provider_type=llm_config_no_inner_thoughts.model_endpoint_type,
         put_inner_thoughts_first=False,
+        actor_id=agent_state.created_by_id,
     )
     # try to use new client, otherwise fallback to old flow
     # TODO: we can just directly call the LLM here?

letta/orm/group.py

@@ -21,6 +21,8 @@ class Group(SqlalchemyBase, OrganizationMixin):
     termination_token: Mapped[Optional[str]] = mapped_column(nullable=True, doc="")
     max_turns: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
     sleeptime_agent_frequency: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
+    max_message_buffer_length: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
+    min_message_buffer_length: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
     turns_counter: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
     last_processed_message_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="")
 

letta/orm/provider.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING
 
+from sqlalchemy import UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
@@ -15,9 +16,18 @@ class Provider(SqlalchemyBase, OrganizationMixin):
 
     __tablename__ = "providers"
     __pydantic_model__ = PydanticProvider
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            "organization_id",
+            name="unique_name_organization_id",
+        ),
+    )
 
     name: Mapped[str] = mapped_column(nullable=False, doc="The name of the provider")
+    provider_type: Mapped[str] = mapped_column(nullable=True, doc="The type of the provider")
     api_key: Mapped[str] = mapped_column(nullable=True, doc="API key used for requests to the provider.")
+    base_url: Mapped[str] = mapped_column(nullable=True, doc="Base URL for the provider.")
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="providers")

letta/schemas/agent.py

@@ -56,7 +56,6 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     name: str = Field(..., description="The name of the agent.")
     # tool rules
     tool_rules: Optional[List[ToolRule]] = Field(default=None, description="The list of tool rules.")
-
     # in-context memory
     message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
 

letta/schemas/enums.py

@@ -6,6 +6,17 @@ class ProviderType(str, Enum):
     google_ai = "google_ai"
     google_vertex = "google_vertex"
     openai = "openai"
+    letta = "letta"
+    deepseek = "deepseek"
+    lmstudio_openai = "lmstudio_openai"
+    xai = "xai"
+    mistral = "mistral"
+    ollama = "ollama"
+    groq = "groq"
+    together = "together"
+    azure = "azure"
+    vllm = "vllm"
+    bedrock = "bedrock"
 
 
 class MessageRole(str, Enum):

letta/schemas/group.py

@@ -32,6 +32,14 @@ class Group(GroupBase):
     sleeptime_agent_frequency: Optional[int] = Field(None, description="")
     turns_counter: Optional[int] = Field(None, description="")
     last_processed_message_id: Optional[str] = Field(None, description="")
+    max_message_buffer_length: Optional[int] = Field(
+        None,
+        description="The desired maximum length of messages in the context window of the convo agent. This is a best effort, and may be off slightly due to user/assistant interleaving.",
+    )
+    min_message_buffer_length: Optional[int] = Field(
+        None,
+        description="The desired minimum length of messages in the context window of the convo agent. This is a best effort, and may be off-by-one due to user/assistant interleaving.",
+    )
 
 
 class ManagerConfig(BaseModel):
@@ -87,11 +95,27 @@ class SleeptimeManagerUpdate(ManagerConfig):
 class VoiceSleeptimeManager(ManagerConfig):
     manager_type: Literal[ManagerType.voice_sleeptime] = Field(ManagerType.voice_sleeptime, description="")
     manager_agent_id: str = Field(..., description="")
+    max_message_buffer_length: Optional[int] = Field(
+        None,
+        description="The desired maximum length of messages in the context window of the convo agent. This is a best effort, and may be off slightly due to user/assistant interleaving.",
+    )
+    min_message_buffer_length: Optional[int] = Field(
+        None,
+        description="The desired minimum length of messages in the context window of the convo agent. This is a best effort, and may be off-by-one due to user/assistant interleaving.",
+    )
 
 
 class VoiceSleeptimeManagerUpdate(ManagerConfig):
     manager_type: Literal[ManagerType.voice_sleeptime] = Field(ManagerType.voice_sleeptime, description="")
     manager_agent_id: Optional[str] = Field(None, description="")
+    max_message_buffer_length: Optional[int] = Field(
+        None,
+        description="The desired maximum length of messages in the context window of the convo agent. This is a best effort, and may be off slightly due to user/assistant interleaving.",
+    )
+    min_message_buffer_length: Optional[int] = Field(
+        None,
+        description="The desired minimum length of messages in the context window of the convo agent. This is a best effort, and may be off-by-one due to user/assistant interleaving.",
+    )
 
 
 # class SwarmGroup(ManagerConfig):

letta/schemas/llm_config.py

@@ -50,6 +50,7 @@ class LLMConfig(BaseModel):
         "xai",
     ] = Field(..., description="The endpoint type for the model.")
     model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")
+    provider_name: Optional[str] = Field(None, description="The provider name for the model.")
     model_wrapper: Optional[str] = Field(None, description="The wrapper for the model.")
     context_window: int = Field(..., description="The context window size for the model.")
     put_inner_thoughts_in_kwargs: Optional[bool] = Field(

letta/schemas/llm_config_overrides.py

@@ -2,8 +2,8 @@ from typing import Dict
 
 LLM_HANDLE_OVERRIDES: Dict[str, Dict[str, str]] = {
     "anthropic": {
-        "claude-3-5-haiku-20241022": "claude-3.5-haiku",
-        "claude-3-5-sonnet-20241022": "claude-3.5-sonnet",
+        "claude-3-5-haiku-20241022": "claude-3-5-haiku",
+        "claude-3-5-sonnet-20241022": "claude-3-5-sonnet",
         "claude-3-opus-20240229": "claude-3-opus",
     },
     "openai": {

letta/schemas/providers.py

@@ -1,6 +1,6 @@
 import warnings
 from datetime import datetime
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from pydantic import Field, model_validator
 
@@ -9,9 +9,11 @@ from letta.llm_api.azure_openai import get_azure_chat_completions_endpoint, get_
 from letta.llm_api.azure_openai_constants import AZURE_MODEL_TO_CONTEXT_LENGTH
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.embedding_config_overrides import EMBEDDING_HANDLE_OVERRIDES
+from letta.schemas.enums import ProviderType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.llm_config_overrides import LLM_HANDLE_OVERRIDES
+from letta.settings import model_settings
 
 
 class ProviderBase(LettaBase):
@@ -21,10 +23,18 @@ class ProviderBase(LettaBase):
 class Provider(ProviderBase):
     id: Optional[str] = Field(None, description="The id of the provider, lazily created by the database manager.")
     name: str = Field(..., description="The name of the provider")
+    provider_type: ProviderType = Field(..., description="The type of the provider")
     api_key: Optional[str] = Field(None, description="API key used for requests to the provider.")
+    base_url: Optional[str] = Field(None, description="Base URL for the provider.")
     organization_id: Optional[str] = Field(None, description="The organization id of the user")
     updated_at: Optional[datetime] = Field(None, description="The last update timestamp of the provider.")
 
+    @model_validator(mode="after")
+    def default_base_url(self):
+        if self.provider_type == ProviderType.openai and self.base_url is None:
+            self.base_url = model_settings.openai_api_base
+        return self
+
     def resolve_identifier(self):
         if not self.id:
             self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)
@@ -59,9 +69,41 @@ class Provider(ProviderBase):
 
         return f"{self.name}/{model_name}"
 
+    def cast_to_subtype(self):
+        match (self.provider_type):
+            case ProviderType.letta:
+                return LettaProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.openai:
+                return OpenAIProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.anthropic:
+                return AnthropicProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.anthropic_bedrock:
+                return AnthropicBedrockProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.ollama:
+                return OllamaProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.google_ai:
+                return GoogleAIProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.google_vertex:
+                return GoogleVertexProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.azure:
+                return AzureProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.groq:
+                return GroqProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.together:
+                return TogetherProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.vllm_chat_completions:
+                return VLLMChatCompletionsProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.vllm_completions:
+                return VLLMCompletionsProvider(**self.model_dump(exclude_none=True))
+            case ProviderType.xai:
+                return XAIProvider(**self.model_dump(exclude_none=True))
+            case _:
+                raise ValueError(f"Unknown provider type: {self.provider_type}")
+
 
 class ProviderCreate(ProviderBase):
     name: str = Field(..., description="The name of the provider.")
+    provider_type: ProviderType = Field(..., description="The type of the provider.")
     api_key: str = Field(..., description="API key used for requests to the provider.")
 
 
@@ -70,8 +112,7 @@ class ProviderUpdate(ProviderBase):
 
 
 class LettaProvider(Provider):
-
-    name: str = "letta"
+    provider_type: Literal[ProviderType.letta] = Field(ProviderType.letta, description="The type of the provider.")
 
     def list_llm_models(self) -> List[LLMConfig]:
         return [
@@ -81,6 +122,7 @@ class LettaProvider(Provider):
                 model_endpoint=LETTA_MODEL_ENDPOINT,
                 context_window=8192,
                 handle=self.get_handle("letta-free"),
+                provider_name=self.name,
             )
         ]
 
@@ -98,7 +140,7 @@ class LettaProvider(Provider):
 
 
 class OpenAIProvider(Provider):
-    name: str = "openai"
+    provider_type: Literal[ProviderType.openai] = Field(ProviderType.openai, description="The type of the provider.")
     api_key: str = Field(..., description="API key for the OpenAI API.")
     base_url: str = Field(..., description="Base URL for the OpenAI API.")
 
@@ -180,6 +222,7 @@ class OpenAIProvider(Provider):
                     model_endpoint=self.base_url,
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
+                    provider_name=self.name,
                 )
             )
 
@@ -235,7 +278,7 @@ class DeepSeekProvider(OpenAIProvider):
     * It also does not support native function calling
     """
 
-    name: str = "deepseek"
+    provider_type: Literal[ProviderType.deepseek] = Field(ProviderType.deepseek, description="The type of the provider.")
     base_url: str = Field("https://api.deepseek.com/v1", description="Base URL for the DeepSeek API.")
     api_key: str = Field(..., description="API key for the DeepSeek API.")
 
@@ -286,6 +329,7 @@ class DeepSeekProvider(OpenAIProvider):
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
                     put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
+                    provider_name=self.name,
                 )
             )
 
@@ -297,7 +341,7 @@ class DeepSeekProvider(OpenAIProvider):
 
 
 class LMStudioOpenAIProvider(OpenAIProvider):
-    name: str = "lmstudio-openai"
+    provider_type: Literal[ProviderType.lmstudio_openai] = Field(ProviderType.lmstudio_openai, description="The type of the provider.")
     base_url: str = Field(..., description="Base URL for the LMStudio OpenAI API.")
     api_key: Optional[str] = Field(None, description="API key for the LMStudio API.")
 
@@ -423,7 +467,7 @@ class LMStudioOpenAIProvider(OpenAIProvider):
 class XAIProvider(OpenAIProvider):
     """https://docs.x.ai/docs/api-reference"""
 
-    name: str = "xai"
+    provider_type: Literal[ProviderType.xai] = Field(ProviderType.xai, description="The type of the provider.")
     api_key: str = Field(..., description="API key for the xAI/Grok API.")
     base_url: str = Field("https://api.x.ai/v1", description="Base URL for the xAI/Grok API.")
 
@@ -476,6 +520,7 @@ class XAIProvider(OpenAIProvider):
                     model_endpoint=self.base_url,
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
+                    provider_name=self.name,
                 )
             )
 
@@ -487,7 +532,7 @@ class XAIProvider(OpenAIProvider):
 
 
 class AnthropicProvider(Provider):
-    name: str = "anthropic"
+    provider_type: Literal[ProviderType.anthropic] = Field(ProviderType.anthropic, description="The type of the provider.")
     api_key: str = Field(..., description="API key for the Anthropic API.")
     base_url: str = "https://api.anthropic.com/v1"
 
@@ -563,6 +608,7 @@ class AnthropicProvider(Provider):
                     handle=self.get_handle(model["id"]),
                     put_inner_thoughts_in_kwargs=inner_thoughts_in_kwargs,
                     max_tokens=max_tokens,
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -572,7 +618,7 @@ class AnthropicProvider(Provider):
 
 
 class MistralProvider(Provider):
-    name: str = "mistral"
+    provider_type: Literal[ProviderType.mistral] = Field(ProviderType.mistral, description="The type of the provider.")
     api_key: str = Field(..., description="API key for the Mistral API.")
     base_url: str = "https://api.mistral.ai/v1"
 
@@ -596,6 +642,7 @@ class MistralProvider(Provider):
                         model_endpoint=self.base_url,
                         context_window=model["max_context_length"],
                         handle=self.get_handle(model["id"]),
+                        provider_name=self.name,
                     )
                 )
 
@@ -622,7 +669,7 @@ class OllamaProvider(OpenAIProvider):
     See: https://github.com/ollama/ollama/blob/main/docs/api.md#generate-a-completion
     """
 
-    name: str = "ollama"
+    provider_type: Literal[ProviderType.ollama] = Field(ProviderType.ollama, description="The type of the provider.")
     base_url: str = Field(..., description="Base URL for the Ollama API.")
     api_key: Optional[str] = Field(None, description="API key for the Ollama API (default: `None`).")
     default_prompt_formatter: str = Field(
@@ -652,6 +699,7 @@ class OllamaProvider(OpenAIProvider):
                     model_wrapper=self.default_prompt_formatter,
                     context_window=context_window,
                     handle=self.get_handle(model["name"]),
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -734,7 +782,7 @@ class OllamaProvider(OpenAIProvider):
 
 
 class GroqProvider(OpenAIProvider):
-    name: str = "groq"
+    provider_type: Literal[ProviderType.groq] = Field(ProviderType.groq, description="The type of the provider.")
     base_url: str = "https://api.groq.com/openai/v1"
     api_key: str = Field(..., description="API key for the Groq API.")
 
@@ -753,6 +801,7 @@ class GroqProvider(OpenAIProvider):
                     model_endpoint=self.base_url,
                     context_window=model["context_window"],
                     handle=self.get_handle(model["id"]),
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -773,7 +822,7 @@ class TogetherProvider(OpenAIProvider):
     function calling support is limited.
     """
 
-    name: str = "together"
+    provider_type: Literal[ProviderType.together] = Field(ProviderType.together, description="The type of the provider.")
     base_url: str = "https://api.together.ai/v1"
     api_key: str = Field(..., description="API key for the TogetherAI API.")
     default_prompt_formatter: str = Field(..., description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API.")
@@ -821,6 +870,7 @@ class TogetherProvider(OpenAIProvider):
                     model_wrapper=self.default_prompt_formatter,
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
+                    provider_name=self.name,
                 )
             )
 
@@ -874,7 +924,7 @@ class TogetherProvider(OpenAIProvider):
 
 class GoogleAIProvider(Provider):
     # gemini
-    name: str = "google_ai"
+    provider_type: Literal[ProviderType.google_ai] = Field(ProviderType.google_ai, description="The type of the provider.")
     api_key: str = Field(..., description="API key for the Google AI API.")
     base_url: str = "https://generativelanguage.googleapis.com"
 
@@ -889,7 +939,6 @@ class GoogleAIProvider(Provider):
         # filter by model names
         model_options = [mo[len("models/") :] if mo.startswith("models/") else mo for mo in model_options]
 
-        # TODO remove manual filtering for gemini-pro
         # Add support for all gemini models
         model_options = [mo for mo in model_options if str(mo).startswith("gemini-")]
 
@@ -903,6 +952,7 @@ class GoogleAIProvider(Provider):
                     context_window=self.get_model_context_window(model),
                     handle=self.get_handle(model),
                     max_tokens=8192,
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -938,7 +988,7 @@ class GoogleAIProvider(Provider):
 
 
 class GoogleVertexProvider(Provider):
-    name: str = "google_vertex"
+    provider_type: Literal[ProviderType.google_vertex] = Field(ProviderType.google_vertex, description="The type of the provider.")
     google_cloud_project: str = Field(..., description="GCP project ID for the Google Vertex API.")
     google_cloud_location: str = Field(..., description="GCP region for the Google Vertex API.")
 
@@ -955,6 +1005,7 @@ class GoogleVertexProvider(Provider):
                     context_window=context_length,
                     handle=self.get_handle(model),
                     max_tokens=8192,
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -978,7 +1029,7 @@ class GoogleVertexProvider(Provider):
 
 
 class AzureProvider(Provider):
-    name: str = "azure"
+    provider_type: Literal[ProviderType.azure] = Field(ProviderType.azure, description="The type of the provider.")
     latest_api_version: str = "2024-09-01-preview"  # https://learn.microsoft.com/en-us/azure/ai-services/openai/api-version-deprecation
     base_url: str = Field(
         ..., description="Base URL for the Azure API endpoint. This should be specific to your org, e.g. `https://letta.openai.azure.com`."
@@ -1011,6 +1062,7 @@ class AzureProvider(Provider):
                     model_endpoint=model_endpoint,
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
+                    provider_name=self.name,
                 ),
             )
         return configs
@@ -1051,7 +1103,7 @@ class VLLMChatCompletionsProvider(Provider):
     """vLLM provider that treats vLLM as an OpenAI /chat/completions proxy"""
 
     # NOTE: vLLM only serves one model at a time (so could configure that through env variables)
-    name: str = "vllm"
+    provider_type: Literal[ProviderType.vllm] = Field(ProviderType.vllm, description="The type of the provider.")
     base_url: str = Field(..., description="Base URL for the vLLM API.")
 
     def list_llm_models(self) -> List[LLMConfig]:
@@ -1070,6 +1122,7 @@ class VLLMChatCompletionsProvider(Provider):
                     model_endpoint=self.base_url,
                     context_window=model["max_model_len"],
                     handle=self.get_handle(model["id"]),
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -1083,7 +1136,7 @@ class VLLMCompletionsProvider(Provider):
     """This uses /completions API as the backend, not /chat/completions, so we need to specify a model wrapper"""
 
     # NOTE: vLLM only serves one model at a time (so could configure that through env variables)
-    name: str = "vllm"
+    provider_type: Literal[ProviderType.vllm] = Field(ProviderType.vllm, description="The type of the provider.")
     base_url: str = Field(..., description="Base URL for the vLLM API.")
     default_prompt_formatter: str = Field(..., description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API.")
 
@@ -1103,6 +1156,7 @@ class VLLMCompletionsProvider(Provider):
                     model_wrapper=self.default_prompt_formatter,
                     context_window=model["max_model_len"],
                     handle=self.get_handle(model["id"]),
+                    provider_name=self.name,
                 )
             )
         return configs
@@ -1117,7 +1171,7 @@ class CohereProvider(OpenAIProvider):
 
 
 class AnthropicBedrockProvider(Provider):
-    name: str = "bedrock"
+    provider_type: Literal[ProviderType.bedrock] = Field(ProviderType.bedrock, description="The type of the provider.")
     aws_region: str = Field(..., description="AWS region for Bedrock")
 
     def list_llm_models(self):
@@ -1131,10 +1185,11 @@ class AnthropicBedrockProvider(Provider):
             configs.append(
                 LLMConfig(
                     model=model_arn,
-                    model_endpoint_type=self.name,
+                    model_endpoint_type=self.provider_type.value,
                     model_endpoint=None,
                     context_window=self.get_model_context_window(model_arn),
                     handle=self.get_handle(model_arn),
+                    provider_name=self.name,
                 )
             )
         return configs

letta/schemas/tool.py

@@ -11,13 +11,9 @@ from letta.constants import (
     MCP_TOOL_TAG_NAME_PREFIX,
 )
 from letta.functions.ast_parsers import get_function_name_and_description
+from letta.functions.composio_helpers import generate_composio_tool_wrapper
 from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
-from letta.functions.helpers import (
-    generate_composio_tool_wrapper,
-    generate_langchain_tool_wrapper,
-    generate_mcp_tool_wrapper,
-    generate_model_from_args_json_schema,
-)
+from letta.functions.helpers import generate_langchain_tool_wrapper, generate_mcp_tool_wrapper, generate_model_from_args_json_schema
 from letta.functions.mcp_client.types import MCPTool
 from letta.functions.schema_generator import (
     generate_schema_from_args_schema_v2,
@@ -176,8 +172,7 @@ class ToolCreate(LettaBase):
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the Composio tool.
         """
-        from composio import LogLevel
-        from composio_langchain import ComposioToolSet
+        from composio import ComposioToolSet, LogLevel
 
         composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR, lock=False)
         composio_action_schemas = composio_toolset.get_action_schemas(actions=[action_name], check_connected_accounts=False)

letta/server/rest_api/app.py

@@ -14,6 +14,7 @@ from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.cors import CORSMiddleware
 
 from letta.__init__ import __version__
+from letta.agents.exceptions import IncompatibleAgentType
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.errors import BedrockPermissionError, LettaAgentNotFoundError, LettaUserNotFoundError
 from letta.jobs.scheduler import shutdown_cron_scheduler, start_cron_jobs
@@ -173,6 +174,17 @@ def create_application() -> "FastAPI":
     def shutdown_scheduler():
         shutdown_cron_scheduler()
 
+    @app.exception_handler(IncompatibleAgentType)
+    async def handle_incompatible_agent_type(request: Request, exc: IncompatibleAgentType):
+        return JSONResponse(
+            status_code=400,
+            content={
+                "detail": str(exc),
+                "expected_type": exc.expected_type,
+                "actual_type": exc.actual_type,
+            },
+        )
+
     @app.exception_handler(Exception)
     async def generic_error_handler(request: Request, exc: Exception):
         # Log the actual error for debugging

letta/server/rest_api/chat_completions_interface.py

@@ -12,7 +12,7 @@ from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LettaMessage
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionChunkResponse
-from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
+from letta.server.rest_api.json_parser import OptimisticJSONParser
 from letta.streaming_interface import AgentChunkStreamingInterface
 
 logger = get_logger(__name__)