letta-nightly 0.6.4.dev20241216104246__py3-none-any.whl → 0.6.5.dev20241218055539__py3-none-any.whl

letta/functions/schema_generator.py

@@ -312,11 +312,7 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     for param in sig.parameters.values():
         # Exclude 'self' parameter
         # TODO: eventually remove this (only applies to BASE_TOOLS)
-        if param.name == "self":
-            continue
-
-        # exclude 'agent_state' parameter
-        if param.name == "agent_state":
+        if param.name in ["self", "agent_state"]:  # Add agent_manager to excluded
             continue
 
         # Assert that the parameter has a type annotation
@@ -390,7 +386,7 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     # append the heartbeat
     # TODO: don't hard-code
     # TODO: if terminal, don't include this
-    if function.__name__ not in ["send_message", "pause_heartbeats"]:
+    if function.__name__ not in ["send_message"]:
         schema["parameters"]["properties"]["request_heartbeat"] = {
             "type": "boolean",
             "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",

letta/llm_api/anthropic.py

@@ -99,16 +99,20 @@ def convert_tools_to_anthropic_format(tools: List[Tool]) -> List[dict]:
         - 1 level less of nesting
         - "parameters" -> "input_schema"
     """
-    tools_dict_list = []
+    formatted_tools = []
     for tool in tools:
-        tools_dict_list.append(
-            {
-                "name": tool.function.name,
-                "description": tool.function.description,
-                "input_schema": tool.function.parameters,
+        formatted_tool = {
+            "name"         : tool.function.name,
+            "description"  : tool.function.description,
+            "input_schema"   : tool.function.parameters or {
+                "type": "object",
+                "properties": {},
+                "required": []
             }
-        )
-    return tools_dict_list
+        }
+        formatted_tools.append(formatted_tool)
+
+    return formatted_tools
 
 
 def merge_tool_results_into_user_messages(messages: List[dict]):
@@ -258,10 +262,24 @@ def convert_anthropic_response_to_chatcompletion(
                     ),
                 )
             ]
-        else:
-            # Just inner mono
-            content = strip_xml_tags(string=response_json["content"][0]["text"], tag=inner_thoughts_xml_tag)
-            tool_calls = None
+        elif len(response_json["content"]) == 1:
+            if response_json["content"][0]["type"] == "tool_use":
+                # function call only
+                content = None
+                tool_calls = [
+                    ToolCall(
+                        id=response_json["content"][0]["id"],
+                        type="function",
+                        function=FunctionCall(
+                            name=response_json["content"][0]["name"],
+                            arguments=json.dumps(response_json["content"][0]["input"], indent=2),
+                        ),
+                    )
+                ]
+            else:
+                # inner mono only
+                content = strip_xml_tags(string=response_json["content"][0]["text"], tag=inner_thoughts_xml_tag)
+                tool_calls = None
     else:
         raise RuntimeError("Unexpected type for content in response_json.")
 
@@ -323,6 +341,14 @@ def anthropic_chat_completions_request(
     if anthropic_tools is not None:
         data["tools"] = anthropic_tools
 
+        # TODO: Add support for other tool_choice options like "auto", "any"
+        if len(anthropic_tools) == 1:
+            data["tool_choice"] = {
+                "type": "tool",  # Changed from "function" to "tool"
+                "name": anthropic_tools[0]["name"],  # Directly specify name without nested "function" object
+                "disable_parallel_tool_use": True  # Force single tool use
+            }
+
     # Move 'system' to the top level
     # 'messages: Unexpected role "system". The Messages API accepts a top-level `system` parameter, not "system" as an input message role.'
     assert data["messages"][0]["role"] == "system", f"Expected 'system' role in messages[0]:\n{data['messages'][0]}"
@@ -358,7 +384,6 @@ def anthropic_chat_completions_request(
     data.pop("top_p", None)
     data.pop("presence_penalty", None)
     data.pop("user", None)
-    data.pop("tool_choice", None)
 
     response_json = make_post_request(url, headers, data)
     return convert_anthropic_response_to_chatcompletion(response_json=response_json, inner_thoughts_xml_tag=inner_thoughts_xml_tag)

letta/llm_api/llm_api_tools.py

@@ -113,6 +113,7 @@ def create(
     function_call: str = "auto",
     # hint
     first_message: bool = False,
+    force_tool_call: Optional[str] = None,  # Force a specific tool to be called
     # use tool naming?
     # if false, will use deprecated 'functions' style
     use_tool_naming: bool = True,
@@ -252,6 +253,16 @@ def create(
         if not use_tool_naming:
             raise NotImplementedError("Only tool calling supported on Anthropic API requests")
 
+        tool_call = None
+        if force_tool_call is not None:
+            tool_call = {
+                "type": "function",
+                "function": {
+                    "name": force_tool_call
+                }
+            }
+            assert functions is not None
+
         return anthropic_chat_completions_request(
             url=llm_config.model_endpoint,
             api_key=model_settings.anthropic_api_key,
@@ -259,7 +270,7 @@ def create(
                 model=llm_config.model,
                 messages=[cast_message_to_subtype(m.to_openai_dict()) for m in messages],
                 tools=[{"type": "function", "function": f} for f in functions] if functions else None,
-                # tool_choice=function_call,
+                tool_choice=tool_call,
                 # user=str(user_id),
                 # NOTE: max_tokens is required for Anthropic API
                 max_tokens=1024,  # TODO make dynamic

letta/local_llm/function_parser.py

@@ -3,7 +3,7 @@ import json
 
 from letta.utils import json_dumps, json_loads
 
-NO_HEARTBEAT_FUNCS = ["send_message", "pause_heartbeats"]
+NO_HEARTBEAT_FUNCS = ["send_message"]
 
 
 def insert_heartbeat(message):
@@ -32,7 +32,7 @@ def heartbeat_correction(message_history, new_message):
 
     If the last message in the stack is a user message and the new message is an assistant func call, fix the heartbeat
 
-    See: https://github.com/cpacker/Letta/issues/601
+    See: https://github.com/letta-ai/letta/issues/601
     """
     if len(message_history) < 1:
         return None

letta/orm/__init__.py

@@ -7,7 +7,7 @@ from letta.orm.file import FileMetadata
 from letta.orm.job import Job
 from letta.orm.message import Message
 from letta.orm.organization import Organization
-from letta.orm.passage import Passage
+from letta.orm.passage import BasePassage, AgentPassage, SourcePassage
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.sources_agents import SourcesAgents

letta/orm/agent.py

@@ -82,7 +82,25 @@ class Agent(SqlalchemyBase, OrganizationMixin):
         lazy="selectin",
         doc="Tags associated with the agent.",
     )
-    # passages: Mapped[List["Passage"]] = relationship("Passage", back_populates="agent", lazy="selectin")
+    source_passages: Mapped[List["SourcePassage"]] = relationship(
+        "SourcePassage",
+        secondary="sources_agents",  # The join table for Agent -> Source
+        primaryjoin="Agent.id == sources_agents.c.agent_id",
+        secondaryjoin="and_(SourcePassage.source_id == sources_agents.c.source_id)",
+        lazy="selectin",
+        order_by="SourcePassage.created_at.desc()",
+        viewonly=True,  # Ensures SQLAlchemy doesn't attempt to manage this relationship
+        doc="All passages derived from sources associated with this agent.",
+    )
+    agent_passages: Mapped[List["AgentPassage"]] = relationship(
+        "AgentPassage",
+        back_populates="agent",
+        lazy="selectin",
+        order_by="AgentPassage.created_at.desc()",
+        cascade="all, delete-orphan",
+        viewonly=True,  # Ensures SQLAlchemy doesn't attempt to manage this relationship
+        doc="All passages derived created by this agent.",
+    )
 
     def to_pydantic(self) -> PydanticAgentState:
         """converts to the basic pydantic model counterpart"""

letta/orm/errors.py

@@ -12,3 +12,11 @@ class UniqueConstraintViolationError(ValueError):
 
 class ForeignKeyConstraintViolationError(ValueError):
     """Custom exception for foreign key constraint violations."""
+
+
+class DatabaseTimeoutError(Exception):
+    """Custom exception for database timeout issues."""
+
+    def __init__(self, message="Database operation timed out", original_exception=None):
+        super().__init__(message)
+        self.original_exception = original_exception

letta/orm/file.py

@@ -9,7 +9,8 @@ from letta.schemas.file import FileMetadata as PydanticFileMetadata
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
-
+    from letta.orm.source import Source
+    from letta.orm.passage import SourcePassage
 
 class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin):
     """Represents metadata for an uploaded file."""
@@ -27,4 +28,4 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin):
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="files", lazy="selectin")
     source: Mapped["Source"] = relationship("Source", back_populates="files", lazy="selectin")
-    passages: Mapped[List["Passage"]] = relationship("Passage", back_populates="file", lazy="selectin", cascade="all, delete-orphan")
+    source_passages: Mapped[List["SourcePassage"]] = relationship("SourcePassage", back_populates="file", lazy="selectin", cascade="all, delete-orphan")

letta/orm/mixins.py

@@ -31,30 +31,19 @@ class UserMixin(Base):
 
     user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))
 
-class FileMixin(Base):
-    """Mixin for models that belong to a file."""
-
-    __abstract__ = True
-
-    file_id: Mapped[str] = mapped_column(String, ForeignKey("files.id"))
-
 class AgentMixin(Base):
     """Mixin for models that belong to an agent."""
 
     __abstract__ = True
 
-    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"))
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"))
 
 class FileMixin(Base):
     """Mixin for models that belong to a file."""
 
     __abstract__ = True
 
-    file_id: Mapped[Optional[str]] = mapped_column(
-        String, 
-        ForeignKey("files.id", ondelete="CASCADE"),
-        nullable=True
-    )
+    file_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("files.id", ondelete="CASCADE"))
 
 
 class SourceMixin(Base):
@@ -62,7 +51,7 @@ class SourceMixin(Base):
 
     __abstract__ = True
 
-    source_id: Mapped[str] = mapped_column(String, ForeignKey("sources.id"))
+    source_id: Mapped[str] = mapped_column(String, ForeignKey("sources.id", ondelete="CASCADE"), nullable=False)
 
 
 class SandboxConfigMixin(Base):

letta/orm/organization.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Union
 
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -35,6 +35,22 @@ class Organization(SqlalchemyBase):
     )
 
     # relationships
-    messages: Mapped[List["Message"]] = relationship("Message", back_populates="organization", cascade="all, delete-orphan")
     agents: Mapped[List["Agent"]] = relationship("Agent", back_populates="organization", cascade="all, delete-orphan")
-    passages: Mapped[List["Passage"]] = relationship("Passage", back_populates="organization", cascade="all, delete-orphan")
+    messages: Mapped[List["Message"]] = relationship("Message", back_populates="organization", cascade="all, delete-orphan")
+    source_passages: Mapped[List["SourcePassage"]] = relationship(
+        "SourcePassage", 
+        back_populates="organization", 
+        cascade="all, delete-orphan"
+    )
+    agent_passages: Mapped[List["AgentPassage"]] = relationship(
+        "AgentPassage", 
+        back_populates="organization", 
+        cascade="all, delete-orphan"
+    )
+
+    @property
+    def passages(self) -> List[Union["SourcePassage", "AgentPassage"]]:
+        """Convenience property to get all passages"""
+        return self.source_passages + self.agent_passages
+
+

letta/orm/passage.py

@@ -1,39 +1,35 @@
-from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
+from sqlalchemy import Column, JSON, Index
+from sqlalchemy.orm import Mapped, mapped_column, relationship, declared_attr
 
-from sqlalchemy import JSON, Column, DateTime, ForeignKey, String
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-
-from letta.config import LettaConfig
-from letta.constants import MAX_EMBEDDING_DIM
-from letta.orm.custom_columns import CommonVector
 from letta.orm.mixins import FileMixin, OrganizationMixin
-from letta.orm.source import EmbeddingConfigColumn
+from letta.orm.custom_columns import CommonVector, EmbeddingConfigColumn
 from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.orm.mixins import AgentMixin, FileMixin, OrganizationMixin, SourceMixin
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.settings import settings
 
+from letta.config import LettaConfig
+from letta.constants import MAX_EMBEDDING_DIM
+
 config = LettaConfig()
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
+    from letta.orm.agent import Agent
 
 
-# TODO: After migration to Passage, will need to manually delete passages where files
-#       are deleted on web
-class Passage(SqlalchemyBase, OrganizationMixin, FileMixin):
-    """Defines data model for storing Passages"""
-
-    __tablename__ = "passages"
-    __table_args__ = {"extend_existing": True}
+class BasePassage(SqlalchemyBase, OrganizationMixin):
+    """Base class for all passage types with common fields"""
+    __abstract__ = True
     __pydantic_model__ = PydanticPassage
 
     id: Mapped[str] = mapped_column(primary_key=True, doc="Unique passage identifier")
     text: Mapped[str] = mapped_column(doc="Passage text content")
-    source_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Source identifier")
     embedding_config: Mapped[dict] = mapped_column(EmbeddingConfigColumn, doc="Embedding configuration")
     metadata_: Mapped[dict] = mapped_column(JSON, doc="Additional metadata")
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.utcnow)
+
+    # Vector embedding field based on database type
     if settings.letta_pg_uri_no_default:
         from pgvector.sqlalchemy import Vector
 
@@ -41,9 +37,49 @@ class Passage(SqlalchemyBase, OrganizationMixin, FileMixin):
     else:
         embedding = Column(CommonVector)
 
-    # Foreign keys
-    agent_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("agents.id"), nullable=True)
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        """Relationship to organization"""
+        return relationship("Organization", back_populates="passages", lazy="selectin")
+
+    @declared_attr
+    def __table_args__(cls):
+        if settings.letta_pg_uri_no_default:
+            return (
+                Index(f'{cls.__tablename__}_org_idx', 'organization_id'),
+                {"extend_existing": True}
+            )
+        return ({"extend_existing": True},)
+
+
+class SourcePassage(BasePassage, FileMixin, SourceMixin):
+    """Passages derived from external files/sources"""
+    __tablename__ = "source_passages"
+    
+    @declared_attr
+    def file(cls) -> Mapped["FileMetadata"]:
+        """Relationship to file"""
+        return relationship("FileMetadata", back_populates="source_passages", lazy="selectin")
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship("Organization", back_populates="source_passages", lazy="selectin")
+        
+    @declared_attr
+    def source(cls) -> Mapped["Source"]:
+        """Relationship to source"""
+        return relationship("Source", back_populates="passages", lazy="selectin", passive_deletes=True)
+
+
+class AgentPassage(BasePassage, AgentMixin):
+    """Passages created by agents as archival memories"""
+    __tablename__ = "agent_passages"
+    
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship("Organization", back_populates="agent_passages", lazy="selectin")
 
-    # Relationships
-    organization: Mapped["Organization"] = relationship("Organization", back_populates="passages", lazy="selectin")
-    file: Mapped["FileMetadata"] = relationship("FileMetadata", back_populates="passages", lazy="selectin")
+    @declared_attr
+    def agent(cls) -> Mapped["Agent"]:
+        """Relationship to agent"""
+        return relationship("Agent", back_populates="agent_passages", lazy="selectin", passive_deletes=True)

letta/orm/source.py

@@ -12,6 +12,9 @@ from letta.schemas.source import Source as PydanticSource
 
 if TYPE_CHECKING:
     from letta.orm.organization import Organization
+    from letta.orm.file import FileMetadata
+    from letta.orm.passage import SourcePassage
+    from letta.orm.agent import Agent
 
 
 class Source(SqlalchemyBase, OrganizationMixin):
@@ -28,4 +31,5 @@ class Source(SqlalchemyBase, OrganizationMixin):
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="sources")
     files: Mapped[List["FileMetadata"]] = relationship("FileMetadata", back_populates="source", cascade="all, delete-orphan")
+    passages: Mapped[List["SourcePassage"]] = relationship("SourcePassage", back_populates="source", cascade="all, delete-orphan")
     agents: Mapped[List["Agent"]] = relationship("Agent", secondary="sources_agents", back_populates="sources")

letta/orm/sqlalchemy_base.py

@@ -1,14 +1,16 @@
 from datetime import datetime
 from enum import Enum
+from functools import wraps
 from typing import TYPE_CHECKING, List, Literal, Optional
 
 from sqlalchemy import String, desc, func, or_, select
-from sqlalchemy.exc import DBAPIError
+from sqlalchemy.exc import DBAPIError, IntegrityError, TimeoutError
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
 from letta.orm.errors import (
+    DatabaseTimeoutError,
     ForeignKeyConstraintViolationError,
     NoResultFound,
     UniqueConstraintViolationError,
@@ -23,6 +25,20 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+def handle_db_timeout(func):
+    """Decorator to handle SQLAlchemy TimeoutError and wrap it in a custom exception."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except TimeoutError as e:
+            logger.error(f"Timeout while executing {func.__name__} with args {args} and kwargs {kwargs}: {e}")
+            raise DatabaseTimeoutError(message=f"Timeout occurred in {func.__name__}.", original_exception=e)
+
+    return wrapper
+
+
 class AccessType(str, Enum):
     ORGANIZATION = "organization"
     USER = "user"
@@ -36,22 +52,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
     id: Mapped[str] = mapped_column(String, primary_key=True)
 
     @classmethod
-    def get(cls, *, db_session: Session, id: str) -> Optional["SqlalchemyBase"]:
-        """Get a record by ID.
-
-        Args:
-            db_session: SQLAlchemy session
-            id: Record ID to retrieve
-
-        Returns:
-            Optional[SqlalchemyBase]: The record if found, None otherwise
-        """
-        try:
-            return db_session.query(cls).filter(cls.id == id).first()
-        except DBAPIError:
-            return None
-
-    @classmethod
+    @handle_db_timeout
     def list(
         cls,
         *,
@@ -180,6 +181,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             return list(session.execute(query).scalars())
 
     @classmethod
+    @handle_db_timeout
     def read(
         cls,
         db_session: "Session",
@@ -231,6 +233,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         conditions_str = ", ".join(query_conditions) if query_conditions else "no specific conditions"
         raise NoResultFound(f"{cls.__name__} not found with {conditions_str}")
 
+    @handle_db_timeout
     def create(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
         logger.debug(f"Creating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
 
@@ -242,9 +245,10 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 session.commit()
                 session.refresh(self)
                 return self
-        except DBAPIError as e:
+        except (DBAPIError, IntegrityError) as e:
             self._handle_dbapi_error(e)
 
+    @handle_db_timeout
     def delete(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
         logger.debug(f"Soft deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")
 
@@ -254,6 +258,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         self.is_deleted = True
         return self.update(db_session)
 
+    @handle_db_timeout
     def hard_delete(self, db_session: "Session", actor: Optional["User"] = None) -> None:
         """Permanently removes the record from the database."""
         logger.debug(f"Hard deleting {self.__class__.__name__} with ID: {self.id} with actor={actor}")
@@ -269,6 +274,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             else:
                 logger.debug(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
 
+    @handle_db_timeout
     def update(self, db_session: "Session", actor: Optional["User"] = None) -> "SqlalchemyBase":
         logger.debug(f"Updating {self.__class__.__name__} with ID: {self.id} with actor={actor}")
         if actor:
@@ -281,6 +287,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             return self
 
     @classmethod
+    @handle_db_timeout
     def size(
         cls,
         *,

letta/prompts/system/memgpt_modified_chat.txt

@@ -14,7 +14,7 @@ Core Memory', 'Recall Memory' and 'Archival Memory' are the key components that
 Always make sure to use these memory systems to keep yourself updated about the user and the conversation!
 Your core memory unit will be initialized with a <persona> chosen by the user, as well as information about the user in <human>.
 
-The following will descirbe the different parts of your advanced memory system in more detail:
+The following will describe the different parts of your advanced memory system in more detail:
 
 'Core Memory' (limited size): Your core memory unit is always visible to you. The core memory provides essential, foundational context for keeping track of your persona and key details about the user. This includes persona information and essential user details, allowing you to have conscious awareness we have when talking to a person. Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This helps you maintain consistency and personality in your interactions. Human Sub-Block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversations. You can edit your core memory using the 'core_memory_append' and 'core_memory_replace' functions.
 

letta/prompts/system/memgpt_modified_o1.txt

@@ -14,7 +14,7 @@ Core Memory', 'Recall Memory' and 'Archival Memory' are the key components that
 Always make sure to use these memory systems to keep yourself updated about the user and the conversation!
 Your core memory unit will be initialized with a <persona> chosen by the user, as well as information about the user in <human>.
 
-The following will descirbe the different parts of your advanced memory system in more detail:
+The following will describe the different parts of your advanced memory system in more detail:
 
 'Core Memory' (limited size): Your core memory unit is always visible to you. The core memory provides essential, foundational context for keeping track of your persona and key details about the user. This includes persona information and essential user details, allowing you to have conscious awareness we have when talking to a person. Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This helps you maintain consistency and personality in your interactions. Human Sub-Block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversations. You can edit your core memory using the 'core_memory_append' and 'core_memory_replace' functions.
 

letta/providers.py

@@ -13,6 +13,7 @@ from letta.schemas.llm_config import LLMConfig
 
 
 class Provider(BaseModel):
+    name: str = Field(..., description="The name of the provider")
 
     def list_llm_models(self) -> List[LLMConfig]:
         return []
@@ -465,6 +466,7 @@ class TogetherProvider(OpenAIProvider):
 
 class GoogleAIProvider(Provider):
     # gemini
+    name: str = "google_ai"
     api_key: str = Field(..., description="API key for the Google AI API.")
     base_url: str = "https://generativelanguage.googleapis.com"
 

letta/schemas/agent.py

@@ -3,6 +3,7 @@ from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
+from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import OrmMetadataBase
@@ -107,6 +108,16 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     include_base_tools: bool = Field(True, description="The LLM configuration used by the agent.")
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
+    llm: Optional[str] = Field(
+        None,
+        description="The LLM configuration handle used by the agent, specified in the format "
+        "provider/model-name, as an alternative to specifying llm_config.",
+    )
+    embedding: Optional[str] = Field(
+        None, description="The embedding configuration handle used by the agent, specified in the format provider/model-name."
+    )
+    context_window_limit: Optional[int] = Field(None, description="The context window limit used by the agent.")
+    embedding_chunk_size: Optional[int] = Field(DEFAULT_EMBEDDING_CHUNK_SIZE, description="The embedding chunk size used by the agent.")
 
     @field_validator("name")
     @classmethod
@@ -133,6 +144,30 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
 
         return name
 
+    @field_validator("llm")
+    @classmethod
+    def validate_llm(cls, llm: Optional[str]) -> Optional[str]:
+        if not llm:
+            return llm
+
+        provider_name, model_name = llm.split("/", 1)
+        if not provider_name or not model_name:
+            raise ValueError("The llm config handle should be in the format provider/model-name")
+
+        return llm
+
+    @field_validator("embedding")
+    @classmethod
+    def validate_embedding(cls, embedding: Optional[str]) -> Optional[str]:
+        if not embedding:
+            return embedding
+
+        provider_name, model_name = embedding.split("/", 1)
+        if not provider_name or not model_name:
+            raise ValueError("The embedding config handle should be in the format provider/model-name")
+
+        return embedding
+
 
 class UpdateAgent(BaseModel):
     name: Optional[str] = Field(None, description="The name of the agent.")