letta-nightly 0.8.17.dev20250722104501__py3-none-any.whl → 0.9.0.dev20250724081419__py3-none-any.whl

letta/orm/sqlite_functions.py

@@ -1,4 +1,3 @@
-import base64
 import sqlite3
 from typing import Optional, Union
 
@@ -7,11 +6,15 @@ from sqlalchemy import event
 from sqlalchemy.engine import Engine
 
 from letta.constants import MAX_EMBEDDING_DIM
+from letta.settings import DatabaseChoice, settings
+
+if settings.database_engine == DatabaseChoice.SQLITE:
+    import sqlite_vec
 
 
 def adapt_array(arr):
     """
-    Converts numpy array to binary for SQLite storage
+    Converts numpy array to binary for SQLite storage using sqlite-vec
     """
     if arr is None:
         return None
@@ -21,15 +24,14 @@ def adapt_array(arr):
     elif not isinstance(arr, np.ndarray):
         raise ValueError(f"Unsupported type: {type(arr)}")
 
-    # Convert to bytes and then base64 encode
-    bytes_data = arr.tobytes()
-    base64_data = base64.b64encode(bytes_data)
-    return sqlite3.Binary(base64_data)
+    # Ensure float32 for compatibility
+    arr = arr.astype(np.float32)
+    return sqlite_vec.serialize_float32(arr.tolist())
 
 
 def convert_array(text):
     """
-    Converts binary back to numpy array
+    Converts binary back to numpy array using sqlite-vec format
     """
     if text is None:
         return None
@@ -41,13 +43,11 @@ def convert_array(text):
     # Handle both bytes and sqlite3.Binary
     binary_data = bytes(text) if isinstance(text, sqlite3.Binary) else text
 
-    try:
-        # First decode base64
-        decoded_data = base64.b64decode(binary_data)
-        # Then convert to numpy array
-        return np.frombuffer(decoded_data, dtype=np.float32)
-    except Exception:
-        return None
+    # Use sqlite-vec native format
+    if len(binary_data) % 4 == 0:  # Must be divisible by 4 for float32
+        return np.frombuffer(binary_data, dtype=np.float32)
+    else:
+        raise ValueError(f"Invalid sqlite-vec binary data length: {len(binary_data)}")
 
 
 def verify_embedding_dimension(embedding: np.ndarray, expected_dim: int = MAX_EMBEDDING_DIM) -> bool:
@@ -131,11 +131,55 @@ def cosine_distance(embedding1, embedding2, expected_dim=MAX_EMBEDDING_DIM):
     return distance
 
 
+# Note: sqlite-vec provides native SQL functions for vector operations
+# We don't need custom Python distance functions since sqlite-vec handles this at the SQL level
+
+
 @event.listens_for(Engine, "connect")
 def register_functions(dbapi_connection, connection_record):
-    """Register SQLite functions"""
-    if isinstance(dbapi_connection, sqlite3.Connection):
-        dbapi_connection.create_function("cosine_distance", 2, cosine_distance)
+    """Register SQLite functions and enable sqlite-vec extension"""
+    # Check for both sync SQLite connections and async aiosqlite connections
+    is_sqlite_connection = isinstance(dbapi_connection, sqlite3.Connection)
+    is_aiosqlite_connection = hasattr(dbapi_connection, "_connection") and str(type(dbapi_connection)).find("aiosqlite") != -1
+
+    if is_sqlite_connection or is_aiosqlite_connection:
+        # Get the actual SQLite connection for async connections
+        actual_connection = dbapi_connection._connection if is_aiosqlite_connection else dbapi_connection
+
+        # Enable sqlite-vec extension
+        try:
+            if is_aiosqlite_connection:
+                # For aiosqlite connections, we cannot use async operations in sync event handlers
+                # The extension will need to be loaded per-connection when actually used
+                print("Detected aiosqlite connection - sqlite-vec will be loaded per-query")
+            else:
+                # For sync connections
+                dbapi_connection.enable_load_extension(True)
+                sqlite_vec.load(dbapi_connection)
+                dbapi_connection.enable_load_extension(False)
+                print("Successfully loaded sqlite-vec extension (sync)")
+        except Exception as e:
+            raise RuntimeError(f"Failed to load sqlite-vec extension: {e}")
+
+        # Register custom cosine_distance function for backward compatibility
+        try:
+            if is_aiosqlite_connection:
+                # Try to register function on the actual connection, even though it might be async
+                # This may require the function to be registered per-connection
+                print("Attempting function registration for aiosqlite connection")
+                # For async connections, we need to register the function differently
+                # We'll use the sync-style registration on the underlying connection
+                raw_conn = getattr(actual_connection, "_connection", actual_connection)
+                if hasattr(raw_conn, "create_function"):
+                    raw_conn.create_function("cosine_distance", 2, cosine_distance)
+                    print("Successfully registered cosine_distance for aiosqlite")
+            else:
+                dbapi_connection.create_function("cosine_distance", 2, cosine_distance)
+                print("Successfully registered cosine_distance for sync connection")
+        except Exception as e:
+            raise RuntimeError(f"Failed to register cosine_distance function: {e}")
+    else:
+        print(f"Warning: Not a SQLite connection, but instead {type(dbapi_connection)}: skipping function registration")
 
 
 # Register adapters and converters for numpy arrays

letta/otel/db_pool_monitoring.py

@@ -89,18 +89,18 @@ class DatabasePoolMonitor:
             try:
                 from letta.otel.metric_registry import MetricRegistry
 
-                # Record current pool statistics
-                pool_stats = self._get_pool_stats(pool)
                 attrs = {
                     "engine_name": engine_name,
                     **get_ctx_attributes(),
                 }
-
-                MetricRegistry().db_pool_connections_checked_out_gauge.set(pool_stats["checked_out"], attributes=attrs)
-                MetricRegistry().db_pool_connections_available_gauge.set(pool_stats["available"], attributes=attrs)
-                MetricRegistry().db_pool_connections_total_gauge.set(pool_stats["total"], attributes=attrs)
-                if pool_stats["overflow"] is not None:
-                    MetricRegistry().db_pool_connections_overflow_gauge.set(pool_stats["overflow"], attributes=attrs)
+                # Record current pool statistics
+                if isinstance(pool, QueuePool):
+                    pool_stats = self._get_pool_stats(pool)
+                    MetricRegistry().db_pool_connections_checked_out_gauge.set(pool_stats["checked_out"], attributes=attrs)
+                    MetricRegistry().db_pool_connections_available_gauge.set(pool_stats["available"], attributes=attrs)
+                    MetricRegistry().db_pool_connections_total_gauge.set(pool_stats["total"], attributes=attrs)
+                    if pool_stats["overflow"] is not None:
+                        MetricRegistry().db_pool_connections_overflow_gauge.set(pool_stats["overflow"], attributes=attrs)
 
                 # Record checkout event
                 attrs["event"] = "checkout"
@@ -137,15 +137,16 @@ class DatabasePoolMonitor:
             try:
                 from letta.otel.metric_registry import MetricRegistry
 
-                # Record current pool statistics after checkin
-                pool_stats = self._get_pool_stats(pool)
                 attrs = {
                     "engine_name": engine_name,
                     **get_ctx_attributes(),
                 }
 
-                MetricRegistry().db_pool_connections_checked_out_gauge.set(pool_stats["checked_out"], attributes=attrs)
-                MetricRegistry().db_pool_connections_available_gauge.set(pool_stats["available"], attributes=attrs)
+                # Record current pool statistics after checkin
+                if isinstance(pool, QueuePool):
+                    pool_stats = self._get_pool_stats(pool)
+                    MetricRegistry().db_pool_connections_checked_out_gauge.set(pool_stats["checked_out"], attributes=attrs)
+                    MetricRegistry().db_pool_connections_available_gauge.set(pool_stats["available"], attributes=attrs)
 
                 # Record checkin event
                 attrs["event"] = "checkin"

letta/schemas/agent.py

@@ -19,7 +19,7 @@ from letta.schemas.response_format import ResponseFormatUnion
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import ToolRule
-from letta.utils import create_random_username
+from letta.utils import calculate_file_defaults_based_on_context_window, create_random_username
 
 
 class AgentType(str, Enum):
@@ -112,6 +112,16 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     # timezone
     timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
 
+    # file related controls
+    max_files_open: Optional[int] = Field(
+        None,
+        description="Maximum number of files that can be open at once for this agent. Setting this too high may exceed the context window, which will break the agent.",
+    )
+    per_file_view_window_char_limit: Optional[int] = Field(
+        None,
+        description="The per-file view window character limit for this agent. Setting this too high may exceed the context window, which will break the agent.",
+    )
+
     def get_agent_env_vars_as_dict(self) -> Dict[str, str]:
         # Get environment variables for this agent specifically
         per_agent_env_vars = {}
@@ -119,6 +129,27 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
             per_agent_env_vars[agent_env_var_obj.key] = agent_env_var_obj.value
         return per_agent_env_vars
 
+    @model_validator(mode="after")
+    def set_file_defaults_based_on_context_window(self) -> "AgentState":
+        """Set reasonable defaults for file-related fields based on the model's context window size."""
+        # Only set defaults if not explicitly provided
+        if self.max_files_open is not None and self.per_file_view_window_char_limit is not None:
+            return self
+
+        # Get context window size from llm_config
+        context_window = self.llm_config.context_window if self.llm_config and self.llm_config.context_window else None
+
+        # Calculate defaults using the helper function
+        default_max_files, default_char_limit = calculate_file_defaults_based_on_context_window(context_window)
+
+        # Apply defaults only if not set
+        if self.max_files_open is None:
+            self.max_files_open = default_max_files
+        if self.per_file_view_window_char_limit is None:
+            self.per_file_view_window_char_limit = default_char_limit
+
+        return self
+
 
 class CreateAgent(BaseModel, validate_assignment=True):  #
     # all optional as server can generate defaults
@@ -197,6 +228,14 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
     response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the agent.")
     timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
+    max_files_open: Optional[int] = Field(
+        None,
+        description="Maximum number of files that can be open at once for this agent. Setting this too high may exceed the context window, which will break the agent.",
+    )
+    per_file_view_window_char_limit: Optional[int] = Field(
+        None,
+        description="The per-file view window character limit for this agent. Setting this too high may exceed the context window, which will break the agent.",
+    )
 
     @field_validator("name")
     @classmethod
@@ -291,6 +330,14 @@ class UpdateAgent(BaseModel):
     last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
     last_run_duration_ms: Optional[int] = Field(None, description="The duration in milliseconds of the agent's last run.")
     timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
+    max_files_open: Optional[int] = Field(
+        None,
+        description="Maximum number of files that can be open at once for this agent. Setting this too high may exceed the context window, which will break the agent.",
+    )
+    per_file_view_window_char_limit: Optional[int] = Field(
+        None,
+        description="The per-file view window character limit for this agent. Setting this too high may exceed the context window, which will break the agent.",
+    )
 
     class Config:
         extra = "ignore"  # Ignores extra fields
@@ -313,6 +360,12 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
         return (
             "{% if sources %}"
             "<directories>\n"
+            "{% if max_files_open %}"
+            "<file_limits>\n"
+            "- current_files_open={{ file_blocks|selectattr('value')|list|length }}\n"
+            "- max_files_open={{ max_files_open }}\n"
+            "</file_limits>\n"
+            "{% endif %}"
             "{% for source in sources %}"
             f'<directory name="{{{{ source.name }}}}">\n'
             "{% if source.description %}"
@@ -323,7 +376,7 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% endif %}"
             "{% if file_blocks %}"
             "{% for block in file_blocks %}"
-            "{% if block.metadata and block.metadata.get('source_id') == source.id %}"
+            "{% if block.source_id and block.source_id == source.id %}"
             f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
             "<{{ block.label }}>\n"
             "<description>\n"
@@ -380,6 +433,12 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% endif %}"
             "\n\n{% if sources %}"
             "<directories>\n"
+            "{% if max_files_open %}"
+            "<file_limits>\n"
+            "- current_files_open={{ file_blocks|selectattr('value')|list|length }}\n"
+            "- max_files_open={{ max_files_open }}\n"
+            "</file_limits>\n"
+            "{% endif %}"
             "{% for source in sources %}"
             f'<directory name="{{{{ source.name }}}}">\n'
             "{% if source.description %}"
@@ -390,7 +449,7 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% endif %}"
             "{% if file_blocks %}"
             "{% for block in file_blocks %}"
-            "{% if block.metadata and block.metadata.get('source_id') == source.id %}"
+            "{% if block.source_id and block.source_id == source.id %}"
             f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\" name=\"{{{{ block.label }}}}\">\n"
             "{% if block.description %}"
             "<description>\n"
@@ -446,6 +505,12 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% endif %}"
             "\n\n{% if sources %}"
             "<directories>\n"
+            "{% if max_files_open %}"
+            "<file_limits>\n"
+            "- current_files_open={{ file_blocks|selectattr('value')|list|length }}\n"
+            "- max_files_open={{ max_files_open }}\n"
+            "</file_limits>\n"
+            "{% endif %}"
             "{% for source in sources %}"
             f'<directory name="{{{{ source.name }}}}">\n'
             "{% if source.description %}"
@@ -456,7 +521,7 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% endif %}"
             "{% if file_blocks %}"
             "{% for block in file_blocks %}"
-            "{% if block.metadata and block.metadata.get('source_id') == source.id %}"
+            "{% if block.source_id and block.source_id == source.id %}"
             f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\" name=\"{{{{ block.label }}}}\">\n"
             "{% if block.description %}"
             "<description>\n"

letta/schemas/agent_file.py

@@ -145,6 +145,8 @@ class AgentSchema(CreateAgent):
             enable_sleeptime=False,  # TODO: Need to figure out how to patch this
             response_format=agent_state.response_format,
             timezone=agent_state.timezone or "UTC",
+            max_files_open=agent_state.max_files_open,
+            per_file_view_window_char_limit=agent_state.per_file_view_window_char_limit,
         )
 
         messages = await message_manager.list_messages_for_agent_async(

letta/schemas/block.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Optional
 
 from pydantic import Field, model_validator
@@ -79,6 +80,16 @@ class Block(BaseBlock):
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that last updated this Block.")
 
 
+class FileBlock(Block):
+    file_id: str = Field(..., description="Unique identifier of the file.")
+    source_id: str = Field(..., description="Unique identifier of the source.")
+    is_open: bool = Field(..., description="True if the agent currently has the file open.")
+    last_accessed_at: Optional[datetime] = Field(
+        default_factory=datetime.utcnow,
+        description="UTC timestamp of the agent’s most recent access to this file. Any operations from the open, close, or search tools will update this field.",
+    )
+
+
 class Human(Block):
     """Human block of the LLM context"""
 

letta/schemas/embedding_config.py

@@ -2,6 +2,8 @@ from typing import Literal, Optional
 
 from pydantic import BaseModel, Field
 
+from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
+
 
 class EmbeddingConfig(BaseModel):
     """
@@ -40,6 +42,7 @@ class EmbeddingConfig(BaseModel):
         "hugging-face",
         "mistral",
         "together",  # completions endpoint
+        "pinecone",
     ] = Field(..., description="The endpoint type for the model.")
     embedding_endpoint: Optional[str] = Field(None, description="The endpoint for the model (`None` if local).")
     embedding_model: str = Field(..., description="The model for the embedding.")
@@ -62,7 +65,7 @@ class EmbeddingConfig(BaseModel):
                 embedding_endpoint_type="openai",
                 embedding_endpoint="https://api.openai.com/v1",
                 embedding_dim=1536,
-                embedding_chunk_size=300,
+                embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
             )
         if (model_name == "text-embedding-3-small" and provider == "openai") or (not model_name and provider == "openai"):
             return cls(
@@ -70,16 +73,25 @@ class EmbeddingConfig(BaseModel):
                 embedding_endpoint_type="openai",
                 embedding_endpoint="https://api.openai.com/v1",
                 embedding_dim=2000,
-                embedding_chunk_size=300,
+                embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
             )
         elif model_name == "letta":
             return cls(
                 embedding_endpoint="https://embeddings.memgpt.ai",
                 embedding_model="BAAI/bge-large-en-v1.5",
                 embedding_dim=1024,
-                embedding_chunk_size=300,
+                embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
                 embedding_endpoint_type="hugging-face",
             )
+        elif provider == "pinecone":
+            # default config for pinecone with empty endpoint
+            return cls(
+                embedding_endpoint=None,
+                embedding_model="llama-text-embed-v2",
+                embedding_dim=1536,  # assuming default openai dimension
+                embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
+                embedding_endpoint_type="pinecone",
+            )
         else:
             raise ValueError(f"Model {model_name} not supported.")
 

letta/schemas/enums.py

@@ -8,6 +8,7 @@ class ProviderType(str, Enum):
     openai = "openai"
     letta = "letta"
     deepseek = "deepseek"
+    cerebras = "cerebras"
     lmstudio_openai = "lmstudio_openai"
     xai = "xai"
     mistral = "mistral"
@@ -17,6 +18,7 @@ class ProviderType(str, Enum):
     azure = "azure"
     vllm = "vllm"
     bedrock = "bedrock"
+    cohere = "cohere"
 
 
 class ProviderCategory(str, Enum):

letta/schemas/file.py

@@ -67,7 +67,7 @@ class FileAgentBase(LettaBase):
     # Core file-agent association fields
     agent_id: str = Field(..., description="Unique identifier of the agent.")
     file_id: str = Field(..., description="Unique identifier of the file.")
-    source_id: str = Field(..., description="Unique identifier of the source (denormalized from files.source_id).")
+    source_id: str = Field(..., description="Unique identifier of the source.")
     file_name: str = Field(..., description="Name of the file.")
     is_open: bool = Field(True, description="True if the agent currently has the file open.")
     visible_content: Optional[str] = Field(

letta/schemas/folder.py

@@ -0,0 +1,74 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.letta_base import LettaBase
+
+
+class BaseFolder(LettaBase):
+    """
+    Shared attributes across all folder schemas.
+    """
+
+    __id_prefix__ = "source"  # TODO: change to "folder"
+
+    # Core folder fields
+    name: str = Field(..., description="The name of the folder.")
+    description: Optional[str] = Field(None, description="The description of the folder.")
+    instructions: Optional[str] = Field(None, description="Instructions for how to use the folder.")
+    metadata: Optional[dict] = Field(None, description="Metadata associated with the folder.")
+
+
+class Folder(BaseFolder):
+    """
+    Representation of a folder, which is a collection of files and passages.
+
+    Parameters:
+        id (str): The ID of the folder
+        name (str): The name of the folder.
+        embedding_config (EmbeddingConfig): The embedding configuration used by the folder.
+        user_id (str): The ID of the user that created the folder.
+        metadata (dict): Metadata associated with the folder.
+        description (str): The description of the folder.
+    """
+
+    id: str = BaseFolder.generate_id_field()
+    embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the folder.")
+    organization_id: Optional[str] = Field(None, description="The ID of the organization that created the folder.")
+    metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="Metadata associated with the folder.")
+
+    # metadata fields
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    created_at: Optional[datetime] = Field(None, description="The timestamp when the folder was created.")
+    updated_at: Optional[datetime] = Field(None, description="The timestamp when the folder was last updated.")
+
+
+class FolderCreate(BaseFolder):
+    """
+    Schema for creating a new Folder.
+    """
+
+    # TODO: @matt, make this required after shub makes the FE changes
+    embedding: Optional[str] = Field(None, description="The handle for the embedding config used by the folder.")
+    embedding_chunk_size: Optional[int] = Field(None, description="The chunk size of the embedding.")
+
+    # TODO: remove (legacy config)
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="(Legacy) The embedding configuration used by the folder.")
+
+
+class FolderUpdate(BaseFolder):
+    """
+    Schema for updating an existing Folder.
+    """
+
+    # Override base fields to make them optional for updates
+    name: Optional[str] = Field(None, description="The name of the folder.")
+    description: Optional[str] = Field(None, description="The description of the folder.")
+    instructions: Optional[str] = Field(None, description="Instructions for how to use the folder.")
+    metadata: Optional[dict] = Field(None, description="Metadata associated with the folder.")
+
+    # Additional update-specific fields
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the folder.")

letta/schemas/memory.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 from openai.types.beta.function_tool import FunctionTool as OpenAITool
 
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
-from letta.schemas.block import Block
+from letta.schemas.block import Block, FileBlock
 from letta.schemas.message import Message
 
 
@@ -66,8 +66,8 @@ class Memory(BaseModel, validate_assignment=True):
 
     # Memory.block contains the list of memory blocks in the core memory
     blocks: List[Block] = Field(..., description="Memory blocks contained in the agent's in-context memory")
-    file_blocks: List[Block] = Field(
-        default_factory=list, description="Blocks representing the agent's in-context memory of an attached file"
+    file_blocks: List[FileBlock] = Field(
+        default_factory=list, description="Special blocks representing the agent's in-context memory of an attached file"
     )
 
     @field_validator("file_blocks")
@@ -124,7 +124,7 @@ class Memory(BaseModel, validate_assignment=True):
             Template(prompt_template)
 
             # Validate compatibility with current memory structure
-            Template(prompt_template).render(blocks=self.blocks, file_blocks=self.file_blocks, sources=[])
+            Template(prompt_template).render(blocks=self.blocks, file_blocks=self.file_blocks, sources=[], max_files_open=None)
 
             # If we get here, the template is valid and compatible
             self.prompt_template = prompt_template
@@ -133,11 +133,17 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
-    def compile(self, tool_usage_rules=None, sources=None) -> str:
+    def compile(self, tool_usage_rules=None, sources=None, max_files_open=None) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
         try:
             template = Template(self.prompt_template)
-            return template.render(blocks=self.blocks, file_blocks=self.file_blocks, tool_usage_rules=tool_usage_rules, sources=sources)
+            return template.render(
+                blocks=self.blocks,
+                file_blocks=self.file_blocks,
+                tool_usage_rules=tool_usage_rules,
+                sources=sources,
+                max_files_open=max_files_open,
+            )
         except TemplateSyntaxError as e:
             raise ValueError(f"Invalid Jinja2 template syntax: {str(e)}")
         except Exception as e:

letta/schemas/prompt.py

@@ -0,0 +1,9 @@
+from pydantic import Field
+
+from letta.schemas.letta_base import OrmMetadataBase
+
+
+class Prompt(OrmMetadataBase):
+    id: str = Field(..., description="The id of the agent. Assigned by the database.")
+    project_id: str | None = Field(None, description="The associated project id.")
+    prompt: str = Field(..., description="The string contents of the prompt.")

letta/schemas/providers/__init__.py

@@ -0,0 +1,47 @@
+# Provider base classes and utilities
+# Provider implementations
+from .anthropic import AnthropicProvider
+from .azure import AzureProvider
+from .base import Provider, ProviderBase, ProviderCheck, ProviderCreate, ProviderUpdate
+from .bedrock import BedrockProvider
+from .cerebras import CerebrasProvider
+from .cohere import CohereProvider
+from .deepseek import DeepSeekProvider
+from .google_gemini import GoogleAIProvider
+from .google_vertex import GoogleVertexProvider
+from .groq import GroqProvider
+from .letta import LettaProvider
+from .lmstudio import LMStudioOpenAIProvider
+from .mistral import MistralProvider
+from .ollama import OllamaProvider
+from .openai import OpenAIProvider
+from .together import TogetherProvider
+from .vllm import VLLMProvider
+from .xai import XAIProvider
+
+__all__ = [
+    # Base classes
+    "Provider",
+    "ProviderBase",
+    "ProviderCreate",
+    "ProviderUpdate",
+    "ProviderCheck",
+    # Provider implementations
+    "AnthropicProvider",
+    "AzureProvider",
+    "BedrockProvider",
+    "CerebrasProvider",  # NEW
+    "CohereProvider",
+    "DeepSeekProvider",
+    "GoogleAIProvider",
+    "GoogleVertexProvider",
+    "GroqProvider",
+    "LettaProvider",
+    "LMStudioOpenAIProvider",
+    "MistralProvider",
+    "OllamaProvider",
+    "OpenAIProvider",
+    "TogetherProvider",
+    "VLLMProvider",  # Replaces ChatCompletions and Completions
+    "XAIProvider",
+]