letta-nightly 0.6.27.dev20250220104103__py3-none-any.whl → 0.6.28.dev20250220163833__py3-none-any.whl

letta/schemas/agent.py

@@ -84,6 +84,9 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     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
+    identifier_key: Optional[str] = Field(None, description="The identifier key belonging to the identity associated with this agent.")
+
     # An advanced configuration that makes it so this agent does not remember any previous messages
     message_buffer_autoclear: bool = Field(
         False,
@@ -129,6 +132,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 +149,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 +161,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.")
+    identifier_key: Optional[str] = Field(None, description="The identifier key belonging to the identity 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 +236,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.")
+    identifier_key: Optional[str] = Field(None, description="The identifier key belonging to the identity 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,44 @@
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import Field
+
+from letta.schemas.agent import AgentState
+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 IdentityBase(LettaBase):
+    __id_prefix__ = "identity"
+
+
+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.")
+    agents: List[AgentState] = Field(..., description="The agents 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.")
+
+
+class IdentityUpdate(LettaBase):
+    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.")

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

letta/schemas/providers.py

@@ -211,6 +211,75 @@ class OpenAIProvider(Provider):
             return None
 
 
+class DeepSeekProvider(OpenAIProvider):
+    """
+    DeepSeek ChatCompletions API is similar to OpenAI's reasoning API,
+    but with slight differences:
+    * For example, DeepSeek's API requires perfect interleaving of user/assistant
+    * It also does not support native function calling
+    """
+
+    name: str = "deepseek"
+    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.")
+
+    def get_model_context_window_size(self, model_name: str) -> Optional[int]:
+        # DeepSeek doesn't return context window in the model listing,
+        # so these are hardcoded from their website
+        if model_name == "deepseek-reasoner":
+            return 64000
+        elif model_name == "deepseek-chat":
+            return 64000
+        else:
+            return None
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list
+
+        response = openai_get_model_list(self.base_url, api_key=self.api_key)
+
+        if "data" in response:
+            data = response["data"]
+        else:
+            data = response
+
+        configs = []
+        for model in data:
+            assert "id" in model, f"DeepSeek model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            # In case DeepSeek starts supporting it in the future:
+            if "context_length" in model:
+                # Context length is returned in OpenRouter as "context_length"
+                context_window_size = model["context_length"]
+            else:
+                context_window_size = self.get_model_context_window_size(model_name)
+
+            if not context_window_size:
+                warnings.warn(f"Couldn't find context window size for model {model_name}")
+                continue
+
+            # Not used for deepseek-reasoner, but otherwise is true
+            put_inner_thoughts_in_kwargs = False if model_name == "deepseek-reasoner" else True
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="deepseek",
+                    model_endpoint=self.base_url,
+                    context_window=context_window_size,
+                    handle=self.get_handle(model_name),
+                    put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
+                )
+            )
+
+        return configs
+
+    def list_embedding_models(self) -> List[EmbeddingConfig]:
+        # No embeddings supported
+        return []
+
+
 class LMStudioOpenAIProvider(OpenAIProvider):
     name: str = "lmstudio-openai"
     base_url: str = Field(..., description="Base URL for the LMStudio OpenAI API.")
@@ -945,4 +1014,6 @@ class AnthropicBedrockProvider(Provider):
         return bedrock_get_model_context_window(model_name)
 
     def get_handle(self, model_name: str) -> str:
-        return f"anthropic/{model_name}"
+        print(model_name)
+        model = model_name.split(".")[-1]
+        return f"bedrock/{model}"

letta/schemas/tool_rule.py

@@ -48,7 +48,15 @@ class TerminalToolRule(BaseToolRule):
     type: Literal[ToolRuleType.exit_loop] = ToolRuleType.exit_loop
 
 
+class ContinueToolRule(BaseToolRule):
+    """
+    Represents a tool rule configuration where if this tool gets called, it must continue the agent loop.
+    """
+
+    type: Literal[ToolRuleType.continue_loop] = ToolRuleType.continue_loop
+
+
 ToolRule = Annotated[
-    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule],
+    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule],
     Field(discriminator="type"),
 ]

letta/serialize_schemas/__init__.py

@@ -0,0 +1 @@
+from letta.serialize_schemas.agent import SerializedAgentSchema

letta/serialize_schemas/agent.py

@@ -0,0 +1,36 @@
+from marshmallow import fields
+
+from letta.orm import Agent
+from letta.serialize_schemas.base import BaseSchema
+from letta.serialize_schemas.custom_fields import EmbeddingConfigField, LLMConfigField, ToolRulesField
+from letta.serialize_schemas.message import SerializedMessageSchema
+
+
+class SerializedAgentSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Agent objects.
+    Excludes relational fields.
+    """
+
+    llm_config = LLMConfigField()
+    embedding_config = EmbeddingConfigField()
+    tool_rules = ToolRulesField()
+
+    messages = fields.List(fields.Nested(SerializedMessageSchema))
+
+    def __init__(self, *args, session=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        if session:
+            self.session = session
+
+            # propagate session to nested schemas
+            for field_name, field_obj in self.fields.items():
+                if isinstance(field_obj, fields.List) and hasattr(field_obj.inner, "schema"):
+                    field_obj.inner.schema.session = session
+                elif hasattr(field_obj, "schema"):
+                    field_obj.schema.session = session
+
+    class Meta(BaseSchema.Meta):
+        model = Agent
+        # TODO: Serialize these as well...
+        exclude = ("tools", "sources", "core_memory", "tags", "source_passages", "agent_passages", "organization")

letta/serialize_schemas/base.py

@@ -0,0 +1,12 @@
+from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
+
+
+class BaseSchema(SQLAlchemyAutoSchema):
+    """
+    Base schema for all SQLAlchemy models.
+    This ensures all schemas share the same session.
+    """
+
+    class Meta:
+        include_relationships = True
+        load_instance = True

letta/serialize_schemas/custom_fields.py

@@ -0,0 +1,69 @@
+from marshmallow import fields
+
+from letta.helpers.converters import (
+    deserialize_embedding_config,
+    deserialize_llm_config,
+    deserialize_tool_calls,
+    deserialize_tool_rules,
+    serialize_embedding_config,
+    serialize_llm_config,
+    serialize_tool_calls,
+    serialize_tool_rules,
+)
+
+
+class PydanticField(fields.Field):
+    """Generic Marshmallow field for handling Pydantic models."""
+
+    def __init__(self, pydantic_class, **kwargs):
+        self.pydantic_class = pydantic_class
+        super().__init__(**kwargs)
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        return value.model_dump() if value else None
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        return self.pydantic_class(**value) if value else None
+
+
+class LLMConfigField(fields.Field):
+    """Marshmallow field for handling LLMConfig serialization."""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        return serialize_llm_config(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        return deserialize_llm_config(value)
+
+
+class EmbeddingConfigField(fields.Field):
+    """Marshmallow field for handling EmbeddingConfig serialization."""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        return serialize_embedding_config(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        return deserialize_embedding_config(value)
+
+
+class ToolRulesField(fields.List):
+    """Custom Marshmallow field to handle a list of ToolRules."""
+
+    def __init__(self, **kwargs):
+        super().__init__(fields.Dict(), **kwargs)
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        return serialize_tool_rules(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        return deserialize_tool_rules(value)
+
+
+class ToolCallField(fields.Field):
+    """Marshmallow field for handling a list of OpenAI ToolCall objects."""
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        return serialize_tool_calls(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        return deserialize_tool_calls(value)

letta/serialize_schemas/message.py

@@ -0,0 +1,15 @@
+from letta.orm.message import Message
+from letta.serialize_schemas.base import BaseSchema
+from letta.serialize_schemas.custom_fields import ToolCallField
+
+
+class SerializedMessageSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Message objects.
+    """
+
+    tool_calls = ToolCallField()
+
+    class Meta(BaseSchema.Meta):
+        model = Message
+        exclude = ("step", "job_message")

letta/server/db.py

@@ -0,0 +1,111 @@
+import os
+from contextlib import contextmanager
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from letta.config import LettaConfig
+from letta.log import get_logger
+from letta.orm import Base
+
+# NOTE: hack to see if single session management works
+from letta.settings import settings
+
+config = LettaConfig.load()
+
+logger = get_logger(__name__)
+
+
+def print_sqlite_schema_error():
+    """Print a formatted error message for SQLite schema issues"""
+    console = Console()
+    error_text = Text()
+    error_text.append("Existing SQLite DB schema is invalid, and schema migrations are not supported for SQLite. ", style="bold red")
+    error_text.append("To have migrations supported between Letta versions, please run Letta with Docker (", style="white")
+    error_text.append("https://docs.letta.com/server/docker", style="blue underline")
+    error_text.append(") or use Postgres by setting ", style="white")
+    error_text.append("LETTA_PG_URI", style="yellow")
+    error_text.append(".\n\n", style="white")
+    error_text.append("If you wish to keep using SQLite, you can reset your database by removing the DB file with ", style="white")
+    error_text.append("rm ~/.letta/sqlite.db", style="yellow")
+    error_text.append(" or downgrade to your previous version of Letta.", style="white")
+
+    console.print(Panel(error_text, border_style="red"))
+
+
+@contextmanager
+def db_error_handler():
+    """Context manager for handling database errors"""
+    try:
+        yield
+    except Exception as e:
+        # Handle other SQLAlchemy errors
+        print(e)
+        print_sqlite_schema_error()
+        # raise ValueError(f"SQLite DB error: {str(e)}")
+        exit(1)
+
+
+if settings.letta_pg_uri_no_default:
+    print("Creating postgres engine")
+    config.recall_storage_type = "postgres"
+    config.recall_storage_uri = settings.letta_pg_uri_no_default
+    config.archival_storage_type = "postgres"
+    config.archival_storage_uri = settings.letta_pg_uri_no_default
+
+    # create engine
+    engine = create_engine(
+        settings.letta_pg_uri,
+        pool_size=settings.pg_pool_size,
+        max_overflow=settings.pg_max_overflow,
+        pool_timeout=settings.pg_pool_timeout,
+        pool_recycle=settings.pg_pool_recycle,
+        echo=settings.pg_echo,
+    )
+else:
+    # TODO: don't rely on config storage
+    engine_path = "sqlite:///" + os.path.join(config.recall_storage_path, "sqlite.db")
+    logger.info("Creating sqlite engine " + engine_path)
+
+    engine = create_engine(engine_path)
+
+    # Store the original connect method
+    original_connect = engine.connect
+
+    def wrapped_connect(*args, **kwargs):
+        with db_error_handler():
+            # Get the connection
+            connection = original_connect(*args, **kwargs)
+
+            # Store the original execution method
+            original_execute = connection.execute
+
+            # Wrap the execute method of the connection
+            def wrapped_execute(*args, **kwargs):
+                with db_error_handler():
+                    return original_execute(*args, **kwargs)
+
+            # Replace the connection's execute method
+            connection.execute = wrapped_execute
+
+            return connection
+
+    # Replace the engine's connect method
+    engine.connect = wrapped_connect
+
+    Base.metadata.create_all(bind=engine)
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+db_context = contextmanager(get_db)

letta/server/rest_api/app.py

@@ -231,6 +231,14 @@ def create_application() -> "FastAPI":
         allow_headers=["*"],
     )
 
+    # Set up OpenTelemetry tracing
+    endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+    if endpoint:
+        print(f"▶ Using OTLP tracing with endpoint: {endpoint}")
+        from letta.tracing import setup_tracing
+
+        setup_tracing(endpoint=endpoint, service_name="memgpt-server")
+
     for route in v1_routes:
         app.include_router(route, prefix=API_PREFIX)
         # this gives undocumented routes for "latest" and bare api calls.