letta-nightly 0.6.27.dev20250220104103__py3-none-any.whl → 0.6.29.dev20250221033538__py3-none-any.whl

letta/local_llm/lmstudio/api.py

@@ -1,3 +1,4 @@
+import json
 from urllib.parse import urljoin
 
 from letta.local_llm.settings.settings import get_completions_settings
@@ -6,6 +7,73 @@ from letta.utils import count_tokens
 
 LMSTUDIO_API_CHAT_SUFFIX = "/v1/chat/completions"
 LMSTUDIO_API_COMPLETIONS_SUFFIX = "/v1/completions"
+LMSTUDIO_API_CHAT_COMPLETIONS_SUFFIX = "/v1/chat/completions"
+
+
+def get_lmstudio_completion_chatcompletions(endpoint, auth_type, auth_key, model, messages):
+    """
+    This is the request we need to send
+
+    {
+    "model": "deepseek-r1-distill-qwen-7b",
+    "messages": [
+      { "role": "system", "content": "Always answer in rhymes. Today is Thursday" },
+      { "role": "user", "content": "What day is it today?" },
+      { "role": "user", "content": "What day is it today?" }],
+    "temperature": 0.7,
+    "max_tokens": -1,
+    "stream": false
+    """
+    from letta.utils import printd
+
+    URI = endpoint + LMSTUDIO_API_CHAT_COMPLETIONS_SUFFIX
+    request = {"model": model, "messages": messages}
+
+    response = post_json_auth_request(uri=URI, json_payload=request, auth_type=auth_type, auth_key=auth_key)
+
+    # Get the reasoning from the model
+    if response.status_code == 200:
+        result_full = response.json()
+        result_reasoning = result_full["choices"][0]["message"].get("reasoning_content")
+        result = result_full["choices"][0]["message"]["content"]
+        usage = result_full["usage"]
+
+    # See if result is json
+    try:
+        function_call = json.loads(result)
+        if "function" in function_call and "params" in function_call:
+            return result, usage, result_reasoning
+        else:
+            print("Did not get json on without json constraint, attempting with json decoding")
+    except Exception as e:
+        print(f"Did not get json on without json constraint, attempting with json decoding: {e}")
+
+    request["messages"].append({"role": "assistant", "content": result_reasoning})
+    request["messages"].append({"role": "user", "content": ""})  # last message must be user
+    # Now run with json decoding to get the function
+    request["response_format"] = {
+        "type": "json_schema",
+        "json_schema": {
+            "name": "function_call",
+            "strict": "true",
+            "schema": {
+                "type": "object",
+                "properties": {"function": {"type": "string"}, "params": {"type": "object"}},
+                "required": ["function", "params"],
+            },
+        },
+    }
+
+    response = post_json_auth_request(uri=URI, json_payload=request, auth_type=auth_type, auth_key=auth_key)
+    if response.status_code == 200:
+        result_full = response.json()
+        printd(f"JSON API response:\n{result_full}")
+        result = result_full["choices"][0]["message"]["content"]
+        # add usage with previous call, merge with prev usage
+        for key, value in result_full["usage"].items():
+            usage[key] += value
+
+    return result, usage, result_reasoning
 
 
 def get_lmstudio_completion(endpoint, auth_type, auth_key, prompt, context_window, api="completions"):
@@ -24,7 +92,8 @@ def get_lmstudio_completion(endpoint, auth_type, auth_key, prompt, context_windo
             # This controls how LM studio handles context overflow
             # In Letta we handle this ourselves, so this should be disabled
             # "context_overflow_policy": 0,
-            "lmstudio": {"context_overflow_policy": 0},  # 0 = stop at limit
+            # "lmstudio": {"context_overflow_policy": 0},  # 0 = stop at limit
+            # "lmstudio": {"context_overflow_policy": "stopAtLimit"}, # https://github.com/letta-ai/letta/issues/1782
             "stream": False,
             "model": "local model",
         }
@@ -72,6 +141,11 @@ def get_lmstudio_completion(endpoint, auth_type, auth_key, prompt, context_windo
             elif api == "completions":
                 result = result_full["choices"][0]["text"]
                 usage = result_full.get("usage", None)
+            elif api == "chat/completions":
+                result = result_full["choices"][0]["content"]
+                result_full["choices"][0]["reasoning_content"]
+                usage = result_full.get("usage", None)
+
         else:
             # Example error: msg={"error":"Context length exceeded. Tokens in context: 8000, Context length: 8000"}
             if "context length" in str(response.text).lower():

letta/orm/__init__.py

@@ -4,6 +4,8 @@ from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
+from letta.orm.identities_agents import IdentitiesAgents
+from letta.orm.identity import Identity
 from letta.orm.job import Job
 from letta.orm.job_messages import JobMessage
 from letta.orm.message import Message

letta/orm/agent.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.block import Block
 from letta.orm.custom_columns import EmbeddingConfigColumn, LLMConfigColumn, ToolRulesColumn
+from letta.orm.identity import Identity
 from letta.orm.message import Message
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.organization import Organization
@@ -15,10 +16,11 @@ from letta.schemas.agent import AgentType
 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 TerminalToolRule, ToolRule
+from letta.schemas.tool_rule import ToolRule
 
 if TYPE_CHECKING:
     from letta.orm.agents_tags import AgentsTags
+    from letta.orm.identity import Identity
     from letta.orm.organization import Organization
     from letta.orm.source import Source
     from letta.orm.tool import Tool
@@ -119,14 +121,18 @@ class Agent(SqlalchemyBase, OrganizationMixin):
         viewonly=True,  # Ensures SQLAlchemy doesn't attempt to manage this relationship
         doc="All passages derived created by this agent.",
     )
+    identities: Mapped[List["Identity"]] = relationship(
+        "Identity",
+        secondary="identities_agents",
+        lazy="selectin",
+        back_populates="agents",
+        passive_deletes=True,
+    )
 
     def to_pydantic(self) -> PydanticAgentState:
         """converts to the basic pydantic model counterpart"""
         # add default rule for having send_message be a terminal tool
         tool_rules = self.tool_rules
-        if not tool_rules:
-            tool_rules = [TerminalToolRule(tool_name="send_message"), TerminalToolRule(tool_name="send_message_to_agent_async")]
-
         state = {
             "id": self.id,
             "organization_id": self.organization_id,
@@ -151,6 +157,7 @@ class Agent(SqlalchemyBase, OrganizationMixin):
             "project_id": self.project_id,
             "template_id": self.template_id,
             "base_template_id": self.base_template_id,
+            "identity_ids": [identity.id for identity in self.identities],
             "message_buffer_autoclear": self.message_buffer_autoclear,
         }
 

letta/orm/custom_columns.py

@@ -1,159 +1,80 @@
-import base64
-from typing import List, Union
-
-import numpy as np
-from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
-from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
 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.tool_rule import ChildToolRule, ConditionalToolRule, InitToolRule, TerminalToolRule
+from letta.helpers.converters import (
+    deserialize_embedding_config,
+    deserialize_llm_config,
+    deserialize_tool_calls,
+    deserialize_tool_rules,
+    deserialize_vector,
+    serialize_embedding_config,
+    serialize_llm_config,
+    serialize_tool_calls,
+    serialize_tool_rules,
+    serialize_vector,
+)
 
 
-class EmbeddingConfigColumn(TypeDecorator):
-    """Custom type for storing EmbeddingConfig as JSON."""
+class LLMConfigColumn(TypeDecorator):
+    """Custom SQLAlchemy column type for storing LLMConfig as JSON."""
 
     impl = JSON
     cache_ok = True
 
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
     def process_bind_param(self, value, dialect):
-        if value and isinstance(value, EmbeddingConfig):
-            return value.model_dump()
-        return value
+        return serialize_llm_config(value)
 
     def process_result_value(self, value, dialect):
-        if value:
-            return EmbeddingConfig(**value)
-        return value
+        return deserialize_llm_config(value)
 
 
-class LLMConfigColumn(TypeDecorator):
-    """Custom type for storing LLMConfig as JSON."""
+class EmbeddingConfigColumn(TypeDecorator):
+    """Custom SQLAlchemy column type for storing EmbeddingConfig as JSON."""
 
     impl = JSON
     cache_ok = True
 
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
     def process_bind_param(self, value, dialect):
-        if value and isinstance(value, LLMConfig):
-            return value.model_dump()
-        return value
+        return serialize_embedding_config(value)
 
     def process_result_value(self, value, dialect):
-        if value:
-            return LLMConfig(**value)
-        return value
+        return deserialize_embedding_config(value)
 
 
 class ToolRulesColumn(TypeDecorator):
-    """Custom type for storing a list of ToolRules as JSON"""
+    """Custom SQLAlchemy column type for storing a list of ToolRules as JSON."""
 
     impl = JSON
     cache_ok = True
 
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
     def process_bind_param(self, value, dialect):
-        """Convert a list of ToolRules to JSON-serializable format."""
-        if value:
-            data = [rule.model_dump() for rule in value]
-            for d in data:
-                d["type"] = d["type"].value
-
-            for d in data:
-                assert not (d["type"] == "ToolRule" and "children" not in d), "ToolRule does not have children field"
-            return data
-        return value
-
-    def process_result_value(self, value, dialect) -> List[Union[ChildToolRule, InitToolRule, TerminalToolRule]]:
-        """Convert JSON back to a list of ToolRules."""
-        if value:
-            return [self.deserialize_tool_rule(rule_data) for rule_data in value]
-        return value
-
-    @staticmethod
-    def deserialize_tool_rule(data: dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule]:
-        """Deserialize a dictionary to the appropriate ToolRule subclass based on the 'type'."""
-        rule_type = ToolRuleType(data.get("type"))  # Remove 'type' field if it exists since it is a class var
-        if rule_type == ToolRuleType.run_first or rule_type == "InitToolRule":
-            data["type"] = ToolRuleType.run_first
-            return InitToolRule(**data)
-        elif rule_type == ToolRuleType.exit_loop or rule_type == "TerminalToolRule":
-            data["type"] = ToolRuleType.exit_loop
-            return TerminalToolRule(**data)
-        elif rule_type == ToolRuleType.constrain_child_tools or rule_type == "ToolRule":
-            data["type"] = ToolRuleType.constrain_child_tools
-            rule = ChildToolRule(**data)
-            return rule
-        elif rule_type == ToolRuleType.conditional:
-            rule = ConditionalToolRule(**data)
-            return rule
-        else:
-            raise ValueError(f"Unknown tool rule type: {rule_type}")
+        return serialize_tool_rules(value)
+
+    def process_result_value(self, value, dialect):
+        return deserialize_tool_rules(value)
 
 
 class ToolCallColumn(TypeDecorator):
+    """Custom SQLAlchemy column type for storing OpenAI ToolCall objects as JSON."""
 
     impl = JSON
     cache_ok = True
 
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
     def process_bind_param(self, value, dialect):
-        if value:
-            values = []
-            for v in value:
-                if isinstance(v, OpenAIToolCall):
-                    values.append(v.model_dump())
-                else:
-                    values.append(v)
-            return values
-
-        return value
+        return serialize_tool_calls(value)
 
     def process_result_value(self, value, dialect):
-        if value:
-            tools = []
-            for tool_value in value:
-                if "function" in tool_value:
-                    tool_call_function = OpenAIFunction(**tool_value["function"])
-                    del tool_value["function"]
-                else:
-                    tool_call_function = None
-                tools.append(OpenAIToolCall(function=tool_call_function, **tool_value))
-            return tools
-        return value
+        return deserialize_tool_calls(value)
 
 
 class CommonVector(TypeDecorator):
-    """Common type for representing vectors in SQLite"""
+    """Custom SQLAlchemy column type for storing vectors in SQLite."""
 
     impl = BINARY
     cache_ok = True
 
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(BINARY())
-
     def process_bind_param(self, value, dialect):
-        if value is None:
-            return value
-        if isinstance(value, list):
-            value = np.array(value, dtype=np.float32)
-        return base64.b64encode(value.tobytes())
+        return serialize_vector(value)
 
     def process_result_value(self, value, dialect):
-        if not value:
-            return value
-        if dialect.name == "sqlite":
-            value = base64.b64decode(value)
-        return np.frombuffer(value, dtype=np.float32)
+        return deserialize_vector(value, dialect)

letta/orm/identities_agents.py

@@ -0,0 +1,13 @@
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from letta.orm.base import Base
+
+
+class IdentitiesAgents(Base):
+    """Identities may have one or many agents associated with them."""
+
+    __tablename__ = "identities_agents"
+
+    identity_id: Mapped[str] = mapped_column(String, ForeignKey("identities.id", ondelete="CASCADE"), primary_key=True)
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True)

letta/orm/identity.py

@@ -0,0 +1,60 @@
+import uuid
+from typing import List, Optional
+
+from sqlalchemy import String, UniqueConstraint
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.identity import Identity as PydanticIdentity
+from letta.schemas.identity import IdentityProperty
+
+
+class Identity(SqlalchemyBase, OrganizationMixin):
+    """Identity ORM class"""
+
+    __tablename__ = "identities"
+    __pydantic_model__ = PydanticIdentity
+    __table_args__ = (
+        UniqueConstraint(
+            "identifier_key",
+            "project_id",
+            "organization_id",
+            name="unique_identifier_without_project",
+            postgresql_nulls_not_distinct=True,
+        ),
+    )
+
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"identity-{uuid.uuid4()}")
+    identifier_key: Mapped[str] = mapped_column(nullable=False, doc="External, user-generated identifier key of the identity.")
+    name: Mapped[str] = mapped_column(nullable=False, doc="The name of the identity.")
+    identity_type: Mapped[str] = mapped_column(nullable=False, doc="The type of the identity.")
+    project_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The project id of the identity.")
+    properties: Mapped[List["IdentityProperty"]] = mapped_column(
+        JSONB, nullable=False, default=list, doc="List of properties associated with the identity"
+    )
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="identities")
+    agents: Mapped[List["Agent"]] = relationship(
+        "Agent", secondary="identities_agents", lazy="selectin", passive_deletes=True, back_populates="identities"
+    )
+
+    @property
+    def agent_ids(self) -> List[str]:
+        """Get just the agent IDs without loading the full agent objects"""
+        return [agent.id for agent in self.agents]
+
+    def to_pydantic(self) -> PydanticIdentity:
+        state = {
+            "id": self.id,
+            "identifier_key": self.identifier_key,
+            "name": self.name,
+            "identity_type": self.identity_type,
+            "project_id": self.project_id,
+            "agent_ids": self.agent_ids,
+            "organization_id": self.organization_id,
+            "properties": self.properties,
+        }
+        return PydanticIdentity(**state)

letta/orm/organization.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
 
     from letta.orm.agent import Agent
     from letta.orm.file import FileMetadata
+    from letta.orm.identity import Identity
     from letta.orm.provider import Provider
     from letta.orm.sandbox_config import AgentEnvironmentVariable
     from letta.orm.tool import Tool
@@ -47,6 +48,7 @@ class Organization(SqlalchemyBase):
     )
     agent_passages: Mapped[List["AgentPassage"]] = relationship("AgentPassage", back_populates="organization", cascade="all, delete-orphan")
     providers: Mapped[List["Provider"]] = relationship("Provider", back_populates="organization", cascade="all, delete-orphan")
+    identities: Mapped[List["Identity"]] = relationship("Identity", back_populates="organization", cascade="all, delete-orphan")
 
     @property
     def passages(self) -> List[Union["SourcePassage", "AgentPassage"]]:

letta/orm/sqlalchemy_base.py

@@ -68,6 +68,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         access_type: AccessType = AccessType.ORGANIZATION,
         join_model: Optional[Base] = None,
         join_conditions: Optional[Union[Tuple, List]] = None,
+        identifier_keys: Optional[List[str]] = None,
         **kwargs,
     ) -> List["SqlalchemyBase"]:
         """
@@ -143,6 +144,9 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 # Group by primary key and all necessary columns to avoid JSON comparison
                 query = query.group_by(cls.id)
 
+            if identifier_keys and hasattr(cls, "identities"):
+                query = query.join(cls.identities).filter(cls.identities.property.mapper.class_.identifier_key.in_(identifier_keys))
+
             # Apply filtering logic from kwargs
             for key, value in kwargs.items():
                 if "." in key:

letta/schemas/agent.py

@@ -83,6 +83,7 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
     template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
+    identity_ids: List[str] = Field([], description="The ids of the identities associated with this agent.")
 
     # An advanced configuration that makes it so this agent does not remember any previous messages
     message_buffer_autoclear: bool = Field(
@@ -129,6 +130,9 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     include_multi_agent_tools: bool = Field(
         False, description="If true, attaches the Letta multi-agent tools (e.g. sending a message to another agent)."
     )
+    include_base_tool_rules: bool = Field(
+        True, description="If true, attaches the Letta base tool rules (e.g. deny all tools not explicitly allowed)."
+    )
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
     model: Optional[str] = Field(
@@ -143,7 +147,11 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     embedding_chunk_size: Optional[int] = Field(DEFAULT_EMBEDDING_CHUNK_SIZE, description="The embedding chunk size used by the agent.")
     from_template: Optional[str] = Field(None, description="The template id used to configure the agent")
     template: bool = Field(False, description="Whether the agent is a template")
-    project: Optional[str] = Field(None, description="The project slug that the agent will be associated with.")
+    project: Optional[str] = Field(
+        None,
+        deprecated=True,
+        description="Deprecated: Project should now be passed via the X-Project header instead of in the request body. If using the sdk, this can be done via the new x_project field below.",
+    )
     tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
         None, description="The environment variables for tool execution specific to this agent."
     )
@@ -151,6 +159,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
     template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
+    identity_ids: Optional[List[str]] = Field(None, description="The ids of the identities associated with this agent.")
     message_buffer_autoclear: bool = Field(
         False,
         description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
@@ -225,6 +234,7 @@ class UpdateAgent(BaseModel):
     project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
     template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
+    identity_ids: Optional[List[str]] = Field(None, description="The ids of the identities associated with this agent.")
     message_buffer_autoclear: Optional[bool] = Field(
         None,
         description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",

letta/schemas/identity.py

@@ -0,0 +1,67 @@
+from enum import Enum
+from typing import List, Optional, Union
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class IdentityType(str, Enum):
+    """
+    Enum to represent the type of the identity.
+    """
+
+    org = "org"
+    user = "user"
+    other = "other"
+
+
+class IdentityPropertyType(str, Enum):
+    """
+    Enum to represent the type of the identity property.
+    """
+
+    string = "string"
+    number = "number"
+    boolean = "boolean"
+    json = "json"
+
+
+class IdentityBase(LettaBase):
+    __id_prefix__ = "identity"
+
+
+class IdentityProperty(LettaBase):
+    """A property of an identity"""
+
+    key: str = Field(..., description="The key of the property")
+    value: Union[str, int, float, bool, dict] = Field(..., description="The value of the property")
+    type: IdentityPropertyType = Field(..., description="The type of the property")
+
+
+class Identity(IdentityBase):
+    id: str = IdentityBase.generate_id_field()
+    identifier_key: str = Field(..., description="External, user-generated identifier key of the identity.")
+    name: str = Field(..., description="The name of the identity.")
+    identity_type: IdentityType = Field(..., description="The type of the identity.")
+    project_id: Optional[str] = Field(None, description="The project id of the identity, if applicable.")
+    agent_ids: List[str] = Field(..., description="The IDs of the agents associated with the identity.")
+    organization_id: Optional[str] = Field(None, description="The organization id of the user")
+    properties: List[IdentityProperty] = Field(default_factory=list, description="List of properties associated with the identity")
+
+
+class IdentityCreate(LettaBase):
+    identifier_key: str = Field(..., description="External, user-generated identifier key of the identity.")
+    name: str = Field(..., description="The name of the identity.")
+    identity_type: IdentityType = Field(..., description="The type of the identity.")
+    project_id: Optional[str] = Field(None, description="The project id of the identity, if applicable.")
+    agent_ids: Optional[List[str]] = Field(None, description="The agent ids that are associated with the identity.")
+    properties: Optional[List[IdentityProperty]] = Field(None, description="List of properties associated with the identity.")
+
+
+class IdentityUpdate(LettaBase):
+    identifier_key: Optional[str] = Field(None, description="External, user-generated identifier key of the identity.")
+    name: Optional[str] = Field(None, description="The name of the identity.")
+    identity_type: Optional[IdentityType] = Field(None, description="The type of the identity.")
+    agent_ids: Optional[List[str]] = Field(None, description="The agent ids that are associated with the identity.")
+    properties: Optional[List[IdentityProperty]] = Field(None, description="List of properties associated with the identity.")

letta/schemas/llm_config.py

@@ -33,6 +33,7 @@ class LLMConfig(BaseModel):
         "webui-legacy",
         "lmstudio",
         "lmstudio-legacy",
+        "lmstudio-chatcompletions",
         "llamacpp",
         "koboldcpp",
         "vllm",
@@ -40,6 +41,7 @@ class LLMConfig(BaseModel):
         "mistral",
         "together",  # completions endpoint
         "bedrock",
+        "deepseek",
     ] = Field(..., description="The endpoint type for the model.")
     model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")
     model_wrapper: Optional[str] = Field(None, description="The wrapper for the model.")

letta/schemas/message.py

@@ -647,7 +647,7 @@ class Message(BaseMessage):
         #     role: str ('user' or 'model')
 
         if self.role != "tool" and self.name is not None:
-            raise UserWarning(f"Using Google AI with non-null 'name' field ({self.name}) not yet supported.")
+            warnings.warn(f"Using Google AI with non-null 'name' field ({self.name}) not yet supported.")
 
         if self.role == "system":
             # NOTE: Gemini API doesn't have a 'system' role, use 'user' instead

letta/schemas/openai/chat_completion_response.py

@@ -39,6 +39,7 @@ class Message(BaseModel):
     tool_calls: Optional[List[ToolCall]] = None
     role: str
     function_call: Optional[FunctionCall] = None  # Deprecated
+    reasoning_content: Optional[str] = None  # Used in newer reasoning APIs
 
 
 class Choice(BaseModel):
@@ -115,6 +116,7 @@ class MessageDelta(BaseModel):
     """
 
     content: Optional[str] = None
+    reasoning_content: Optional[str] = None
     tool_calls: Optional[List[ToolCallDelta]] = None
     role: Optional[str] = None
     function_call: Optional[FunctionCallDelta] = None  # Deprecated