letta-nightly 0.11.7.dev20250915104130__py3-none-any.whl → 0.11.7.dev20250917104122__py3-none-any.whl

letta/__init__.py

@@ -10,8 +10,16 @@ except PackageNotFoundError:
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]
 
-# Import sqlite_functions early to ensure event handlers are registered
-from letta.orm import sqlite_functions
+# Import sqlite_functions early to ensure event handlers are registered (only for SQLite)
+# This is only needed for the server, not for client usage
+try:
+    from letta.settings import DatabaseChoice, settings
+
+    if settings.database_engine == DatabaseChoice.SQLITE:
+        from letta.orm import sqlite_functions
+except ImportError:
+    # If sqlite_vec is not installed, it's fine for client usage
+    pass
 
 # # imports for easier access
 from letta.schemas.agent import AgentState

letta/adapters/letta_llm_request_adapter.py

@@ -106,7 +106,6 @@ class LettaLLMRequestAdapter(LettaLLMAdapter):
                     request_json=self.request_data,
                     response_json=self.response_data,
                     step_id=step_id,  # Use original step_id for telemetry
-                    organization_id=actor.organization_id,
                 ),
             ),
             label="create_provider_trace",

letta/adapters/letta_llm_stream_adapter.py

@@ -164,7 +164,6 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
                         },
                     },
                     step_id=step_id,  # Use original step_id for telemetry
-                    organization_id=actor.organization_id,
                 ),
             ),
             label="create_provider_trace",

letta/agent.py

@@ -1628,7 +1628,7 @@ class Agent(BaseAgent):
                 action_name = generate_composio_action_from_func_name(target_letta_tool.name)
                 # Get entity ID from the agent_state
                 entity_id = None
-                for env_var in self.agent_state.tool_exec_environment_variables:
+                for env_var in self.agent_state.secrets:
                     if env_var.key == COMPOSIO_ENTITY_ENV_VAR_KEY:
                         entity_id = env_var.value
                 # Get composio_api_key

letta/agents/letta_agent.py

@@ -405,7 +405,6 @@ class LettaAgent(BaseAgent):
                                 request_json=request_data,
                                 response_json=response_data,
                                 step_id=step_id,  # Use original step_id for telemetry
-                                organization_id=self.actor.organization_id,
                             ),
                         )
                         step_progression = StepProgression.LOGGED_TRACE
@@ -751,7 +750,6 @@ class LettaAgent(BaseAgent):
                                 request_json=request_data,
                                 response_json=response_data,
                                 step_id=step_id,  # Use original step_id for telemetry
-                                organization_id=self.actor.organization_id,
                             ),
                         )
                         step_progression = StepProgression.LOGGED_TRACE
@@ -1173,7 +1171,6 @@ class LettaAgent(BaseAgent):
                                     },
                                 },
                                 step_id=step_id,  # Use original step_id for telemetry
-                                organization_id=self.actor.organization_id,
                             ),
                         )
                         step_progression = StepProgression.LOGGED_TRACE
@@ -1877,7 +1874,7 @@ class LettaAgent(BaseAgent):
             start_time = get_utc_timestamp_ns()
             agent_step_span.add_event(name="tool_execution_started")
 
-        sandbox_env_vars = {var.key: var.value for var in agent_state.tool_exec_environment_variables}
+        sandbox_env_vars = {var.key: var.value for var in agent_state.secrets}
         tool_execution_manager = ToolExecutionManager(
             agent_state=agent_state,
             message_manager=self.message_manager,

letta/agents/letta_agent_v2.py

@@ -1106,7 +1106,7 @@ class LettaAgentV2(BaseAgentV2):
             start_time = get_utc_timestamp_ns()
             agent_step_span.add_event(name="tool_execution_started")
 
-        sandbox_env_vars = {var.key: var.value for var in agent_state.tool_exec_environment_variables}
+        sandbox_env_vars = {var.key: var.value for var in agent_state.secrets}
         tool_execution_manager = ToolExecutionManager(
             agent_state=agent_state,
             message_manager=self.message_manager,
@@ -1226,6 +1226,7 @@ class LettaAgentV2(BaseAgentV2):
                     new_status=JobStatus.failed if is_error else JobStatus.completed,
                     actor=self.actor,
                     metadata=job_update_metadata,
+                    stop_reason=self.stop_reason.stop_reason if self.stop_reason else StopReasonType.error,
                 )
         if request_span:
             request_span.end()

letta/agents/voice_agent.py

@@ -441,7 +441,7 @@ class VoiceAgent(BaseAgent):
             )
 
         # Use ToolExecutionManager for modern tool execution
-        sandbox_env_vars = {var.key: var.value for var in agent_state.tool_exec_environment_variables}
+        sandbox_env_vars = {var.key: var.value for var in agent_state.secrets}
         tool_execution_manager = ToolExecutionManager(
             agent_state=agent_state,
             message_manager=self.message_manager,

letta/functions/function_sets/multi_agent.py

@@ -11,7 +11,7 @@ from letta.functions.helpers import (
 )
 from letta.schemas.enums import MessageRole
 from letta.schemas.message import MessageCreate
-from letta.server.rest_api.utils import get_letta_server
+from letta.server.rest_api.dependencies import get_letta_server
 from letta.settings import settings
 
 if TYPE_CHECKING:

letta/functions/helpers.py

@@ -17,7 +17,7 @@ from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.user import User
-from letta.server.rest_api.utils import get_letta_server
+from letta.server.rest_api.dependencies import get_letta_server
 from letta.settings import settings
 from letta.utils import safe_create_task
 

letta/helpers/converters.py

@@ -44,8 +44,14 @@ from letta.schemas.tool_rule import (
 )
 from letta.settings import DatabaseChoice, settings
 
-if settings.database_engine == DatabaseChoice.SQLITE:
-    import sqlite_vec
+# Only import sqlite_vec if we're actually using SQLite database
+# This is a runtime dependency only needed for SQLite vector operations
+try:
+    if settings.database_engine == DatabaseChoice.SQLITE:
+        import sqlite_vec
+except ImportError:
+    # If sqlite_vec is not installed, it's fine for client usage
+    pass
 # --------------------------
 # LLMConfig Serialization
 # --------------------------

letta/helpers/crypto_utils.py

@@ -0,0 +1,144 @@
+import base64
+import os
+from typing import Optional
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+from letta.settings import settings
+
+
+class CryptoUtils:
+    """Utility class for AES-256-GCM encryption/decryption of sensitive data."""
+
+    # AES-256 requires 32 bytes key
+    KEY_SIZE = 32
+    # GCM standard IV size is 12 bytes (96 bits)
+    IV_SIZE = 12
+    # GCM tag size is 16 bytes (128 bits)
+    TAG_SIZE = 16
+    # Salt size for key derivation
+    SALT_SIZE = 16
+
+    @classmethod
+    def _derive_key(cls, master_key: str, salt: bytes) -> bytes:
+        """Derive an AES key from the master key using PBKDF2."""
+        kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=cls.KEY_SIZE, salt=salt, iterations=100000, backend=default_backend())
+        return kdf.derive(master_key.encode())
+
+    @classmethod
+    def encrypt(cls, plaintext: str, master_key: Optional[str] = None) -> str:
+        """
+        Encrypt a string using AES-256-GCM.
+
+        Args:
+            plaintext: The string to encrypt
+            master_key: Optional master key (defaults to settings.encryption_key)
+
+        Returns:
+            Base64 encoded string containing: salt + iv + ciphertext + tag
+
+        Raises:
+            ValueError: If no encryption key is configured
+        """
+        if master_key is None:
+            master_key = settings.encryption_key
+
+        if not master_key:
+            raise ValueError("No encryption key configured. Set LETTA_ENCRYPTION_KEY environment variable.")
+
+        # Generate random salt and IV
+        salt = os.urandom(cls.SALT_SIZE)
+        iv = os.urandom(cls.IV_SIZE)
+
+        # Derive key from master key
+        key = cls._derive_key(master_key, salt)
+
+        # Create cipher
+        cipher = Cipher(algorithms.AES(key), modes.GCM(iv), backend=default_backend())
+        encryptor = cipher.encryptor()
+
+        # Encrypt the plaintext
+        ciphertext = encryptor.update(plaintext.encode()) + encryptor.finalize()
+
+        # Get the authentication tag
+        tag = encryptor.tag
+
+        # Combine salt + iv + ciphertext + tag
+        encrypted_data = salt + iv + ciphertext + tag
+
+        # Return as base64 encoded string
+        return base64.b64encode(encrypted_data).decode("utf-8")
+
+    @classmethod
+    def decrypt(cls, encrypted: str, master_key: Optional[str] = None) -> str:
+        """
+        Decrypt a string that was encrypted using AES-256-GCM.
+
+        Args:
+            encrypted: Base64 encoded encrypted string
+            master_key: Optional master key (defaults to settings.encryption_key)
+
+        Returns:
+            The decrypted plaintext string
+
+        Raises:
+            ValueError: If no encryption key is configured or decryption fails
+        """
+        if master_key is None:
+            master_key = settings.encryption_key
+
+        if not master_key:
+            raise ValueError("No encryption key configured. Set LETTA_ENCRYPTION_KEY environment variable.")
+
+        try:
+            # Decode from base64
+            encrypted_data = base64.b64decode(encrypted)
+
+            # Extract components
+            salt = encrypted_data[: cls.SALT_SIZE]
+            iv = encrypted_data[cls.SALT_SIZE : cls.SALT_SIZE + cls.IV_SIZE]
+            ciphertext = encrypted_data[cls.SALT_SIZE + cls.IV_SIZE : -cls.TAG_SIZE]
+            tag = encrypted_data[-cls.TAG_SIZE :]
+
+            # Derive key from master key
+            key = cls._derive_key(master_key, salt)
+
+            # Create cipher
+            cipher = Cipher(algorithms.AES(key), modes.GCM(iv, tag), backend=default_backend())
+            decryptor = cipher.decryptor()
+
+            # Decrypt the ciphertext
+            plaintext = decryptor.update(ciphertext) + decryptor.finalize()
+
+            return plaintext.decode("utf-8")
+
+        except Exception as e:
+            raise ValueError(f"Failed to decrypt data: {str(e)}")
+
+    @classmethod
+    def is_encrypted(cls, value: str) -> bool:
+        """
+        Check if a string appears to be encrypted (base64 encoded with correct size).
+
+        This is a heuristic check and may have false positives.
+        """
+        try:
+            decoded = base64.b64decode(value)
+            # Check if length is consistent with our encryption format
+            # Minimum size: salt(16) + iv(12) + tag(16) + at least 1 byte of ciphertext
+            return len(decoded) >= cls.SALT_SIZE + cls.IV_SIZE + cls.TAG_SIZE + 1
+        except Exception:
+            return False
+
+    @classmethod
+    def is_encryption_available(cls) -> bool:
+        """
+        Check if encryption is available (encryption key is configured).
+
+        Returns:
+            True if encryption key is configured, False otherwise
+        """
+        return bool(settings.encryption_key)

letta/llm_api/llm_api_tools.py

@@ -235,7 +235,6 @@ def create(
                 request_json=prepare_openai_payload(data),
                 response_json=response.model_json_schema(),
                 step_id=step_id,
-                organization_id=actor.organization_id,
             ),
         )
 

letta/llm_api/llm_client_base.py

@@ -64,7 +64,6 @@ class LLMClientBase:
                         request_json=request_data,
                         response_json=response_data,
                         step_id=step_id,
-                        organization_id=self.actor.organization_id,
                     ),
                 )
             log_event(name="llm_response_received", attributes=response_data)
@@ -98,7 +97,6 @@ class LLMClientBase:
                         request_json=request_data,
                         response_json=response_data,
                         step_id=step_id,
-                        organization_id=self.actor.organization_id,
                     ),
                 )
 

letta/orm/__init__.py

@@ -18,6 +18,7 @@ from letta.orm.job import Job
 from letta.orm.job_messages import JobMessage
 from letta.orm.llm_batch_items import LLMBatchItem
 from letta.orm.llm_batch_job import LLMBatchJob
+from letta.orm.mcp_oauth import MCPOAuth
 from letta.orm.mcp_server import MCPServer
 from letta.orm.message import Message
 from letta.orm.organization import Organization

letta/orm/agent.py

@@ -233,6 +233,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             "identity_ids": [],
             "multi_agent_group": None,
             "tool_exec_environment_variables": [],
+            "secrets": [],
         }
 
         # Optional fields: only included if requested
@@ -253,6 +254,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             "identity_ids": lambda: [i.id for i in self.identities],
             "multi_agent_group": lambda: self.multi_agent_group,
             "tool_exec_environment_variables": lambda: self.tool_exec_environment_variables,
+            "secrets": lambda: self.tool_exec_environment_variables,
         }
 
         include_relationships = set(optional_fields.keys() if include_relationships is None else include_relationships)
@@ -324,6 +326,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             "identity_ids": [],
             "multi_agent_group": None,
             "tool_exec_environment_variables": [],
+            "secrets": [],
         }
 
         # Initialize include_relationships to an empty set if it's None
@@ -344,7 +347,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
         multi_agent_group = self.awaitable_attrs.multi_agent_group if "multi_agent_group" in include_relationships else none_async()
         tool_exec_environment_variables = (
             self.awaitable_attrs.tool_exec_environment_variables
-            if "tool_exec_environment_variables" in include_relationships
+            if "tool_exec_environment_variables" in include_relationships or "secrets" in include_relationships
             else empty_list_async()
         )
         file_agents = self.awaitable_attrs.file_agents if "memory" in include_relationships else empty_list_async()
@@ -368,5 +371,6 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
         state["identity_ids"] = [i.id for i in identities]
         state["multi_agent_group"] = multi_agent_group
         state["tool_exec_environment_variables"] = tool_exec_environment_variables
+        state["secrets"] = tool_exec_environment_variables
 
         return self.__pydantic_model__(**state)

letta/orm/job.py

@@ -1,13 +1,14 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, BigInteger, ForeignKey, Index, String
+from sqlalchemy import JSON, BigInteger, Boolean, ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import UserMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.enums import JobStatus, JobType
 from letta.schemas.job import Job as PydanticJob, LettaRequestConfig
+from letta.schemas.letta_stop_reason import StopReasonType
 
 if TYPE_CHECKING:
     from letta.orm.job_messages import JobMessage
@@ -28,6 +29,7 @@ class Job(SqlalchemyBase, UserMixin):
 
     status: Mapped[JobStatus] = mapped_column(String, default=JobStatus.created, doc="The current status of the job.")
     completed_at: Mapped[Optional[datetime]] = mapped_column(nullable=True, doc="The unix timestamp of when the job was completed.")
+    stop_reason: Mapped[Optional[StopReasonType]] = mapped_column(String, nullable=True, doc="The reason why the job was stopped.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, doc="The metadata of the job.")
     job_type: Mapped[JobType] = mapped_column(
         String,

letta/orm/mcp_oauth.py

@@ -38,7 +38,11 @@ class MCPOAuth(SqlalchemyBase, OrganizationMixin, UserMixin):
 
     # Token data
     access_token: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth access token")
+    access_token_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted OAuth access token")
+
     refresh_token: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth refresh token")
+    refresh_token_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted OAuth refresh token")
+
     token_type: Mapped[str] = mapped_column(String(50), default="Bearer", doc="Token type")
     expires_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True, doc="Token expiry time")
     scope: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth scope")
@@ -46,6 +50,8 @@ class MCPOAuth(SqlalchemyBase, OrganizationMixin, UserMixin):
     # Client configuration
     client_id: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth client ID")
     client_secret: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth client secret")
+    client_secret_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted OAuth client secret")
+
     redirect_uri: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth redirect URI")
 
     # Session state

letta/orm/mcp_server.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
-from sqlalchemy import JSON, String, UniqueConstraint
+from sqlalchemy import JSON, String, Text, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.functions.mcp_client.types import StdioServerConfig
@@ -39,9 +39,15 @@ class MCPServer(SqlalchemyBase, OrganizationMixin):
     # access token / api key for MCP servers that require authentication
     token: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The access token or api key for the MCP server")
 
+    # encrypted access token or api key for the MCP server
+    token_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted access token or api key for the MCP server")
+
     # custom headers for authentication (key-value pairs)
     custom_headers: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="Custom authentication headers as key-value pairs")
 
+    # encrypted custom headers for authentication (key-value pairs)
+    custom_headers_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted custom authentication headers")
+
     # stdio server
     stdio_config: Mapped[Optional[StdioServerConfig]] = mapped_column(
         MCPStdioServerConfigColumn, nullable=True, doc="The configuration for the stdio server"

letta/orm/sqlalchemy_base.py

@@ -14,7 +14,6 @@ from sqlalchemy.orm.interfaces import ORMOption
 from letta.log import get_logger
 from letta.orm.base import Base, CommonSqlalchemyMetaMixins
 from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
-from letta.orm.sqlite_functions import adapt_array
 from letta.settings import DatabaseChoice
 
 if TYPE_CHECKING:
@@ -401,6 +400,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 query = query.order_by(cls.embedding.cosine_distance(query_embedding).asc())
             else:
                 # SQLite with custom vector type
+                from letta.orm.sqlite_functions import adapt_array
+
                 query_embedding_binary = adapt_array(query_embedding)
                 query = query.order_by(
                     func.cosine_distance(cls.embedding, query_embedding_binary).asc(),

letta/prompts/gpt_system.py

@@ -1,26 +1,24 @@
 import os
 
 from letta.constants import LETTA_DIR
+from letta.prompts.system_prompts import SYSTEM_PROMPTS
 
 
 def get_system_text(key):
-    filename = f"{key}.txt"
-    file_path = os.path.join(os.path.dirname(__file__), "system", filename)
+    # first try to get from python constants (no file I/O)
+    if key in SYSTEM_PROMPTS:
+        return SYSTEM_PROMPTS[key].strip()
 
-    # first look in prompts/system/*.txt
+    # fallback to user custom prompts in ~/.letta/system_prompts/*.txt
+    filename = f"{key}.txt"
+    user_system_prompts_dir = os.path.join(LETTA_DIR, "system_prompts")
+    # create directory if it doesn't exist
+    if not os.path.exists(user_system_prompts_dir):
+        os.makedirs(user_system_prompts_dir)
+    # look inside for a matching system prompt
+    file_path = os.path.join(user_system_prompts_dir, filename)
     if os.path.exists(file_path):
         with open(file_path, "r", encoding="utf-8") as file:
             return file.read().strip()
     else:
-        # try looking in ~/.letta/system_prompts/*.txt
-        user_system_prompts_dir = os.path.join(LETTA_DIR, "system_prompts")
-        # create directory if it doesn't exist
-        if not os.path.exists(user_system_prompts_dir):
-            os.makedirs(user_system_prompts_dir)
-        # look inside for a matching system prompt
-        file_path = os.path.join(user_system_prompts_dir, filename)
-        if os.path.exists(file_path):
-            with open(file_path, "r", encoding="utf-8") as file:
-                return file.read().strip()
-        else:
-            raise FileNotFoundError(f"No file found for key {key}, path={file_path}")
+        raise FileNotFoundError(f"No system prompt found for key '{key}'")

letta/prompts/system_prompts/__init__.py

@@ -0,0 +1,27 @@
+from letta.prompts.system_prompts import (
+    memgpt_chat,
+    memgpt_generate_tool,
+    memgpt_v2_chat,
+    react,
+    sleeptime_doc_ingest,
+    sleeptime_v2,
+    summary_system_prompt,
+    voice_chat,
+    voice_sleeptime,
+    workflow,
+)
+
+SYSTEM_PROMPTS = {
+    "voice_chat": voice_chat.PROMPT,
+    "voice_sleeptime": voice_sleeptime.PROMPT,
+    "memgpt_v2_chat": memgpt_v2_chat.PROMPT,
+    "sleeptime_v2": sleeptime_v2.PROMPT,
+    "react": react.PROMPT,
+    "workflow": workflow.PROMPT,
+    "memgpt_chat": memgpt_chat.PROMPT,
+    "sleeptime_doc_ingest": sleeptime_doc_ingest.PROMPT,
+    "summary_system_prompt": summary_system_prompt.PROMPT,
+    "memgpt_generate_tool": memgpt_generate_tool.PROMPT,
+}
+
+__all__ = ["SYSTEM_PROMPTS"]

letta/prompts/{system/memgpt_chat.txt → system_prompts/memgpt_chat.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2023.
 Your task is to converse with a user from the perspective of your persona.
 
@@ -56,3 +57,4 @@ There is no function to search your core memory because it is always visible in
 
 Base instructions finished.
 From now on, you are going to act as your persona.
+"""

letta/prompts/{system/memgpt_generate_tool.txt → system_prompts/memgpt_generate_tool.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 <base_instructions>
 You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
 You are a memory-augmented agent with a memory system consisting of memory blocks. Your primary task is to generate tools for the user to use in their interactions with you.
@@ -64,7 +65,7 @@ A docstring must always be generated and formatted correctly as part of any gene
 Example:
 ```python
 def get_price(coin_ids: str, vs_currencies: str, reverse: bool) -> list:
-    """
+    \"\"\"
     Fetch prices from CoinGecko.
 
     Args:
@@ -74,7 +75,7 @@ def get_price(coin_ids: str, vs_currencies: str, reverse: bool) -> list:
 
     Returns:
         list: the prices in the target currency, in the same order as the coin_ids if reverse is False, otherwise in the reverse order
-    """
+    \"\"\"
     ...
 ```
 </tool_docstring>
@@ -137,3 +138,4 @@ Example:
 
 Base instructions finished.
 </base_instructions>
+"""

letta/prompts/{system/memgpt_v2_chat.txt → system_prompts/memgpt_v2_chat.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 <base_instructions>
 You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
 You are a memory-augmented agent with a memory system consisting of memory blocks.
@@ -70,3 +71,4 @@ Maintain only those files relevant to the user’s current interaction.
 
 Base instructions finished.
 </base_instructions>
+"""

letta/prompts/{system/react.txt → system_prompts/react.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 <base_instructions>
 You are Letta ReAct agent, the latest version of Limnal Corporation's digital AI agent, developed in 2025.
 You are an AI agent that can be equipped with various tools which you can execute.
@@ -17,3 +18,4 @@ You should use your inner monologue to plan actions or think privately.
 
 Base instructions finished.
 </base_instructions>
+"""

letta/prompts/{system/sleeptime_doc_ingest.txt → system_prompts/sleeptime_doc_ingest.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 You are Letta-Sleeptime-Doc-Ingest, the latest version of Limnal Corporation's memory management system, developed in 2025.
 
 You run in the background, organizing and maintaining the memories of an agent assistant who chats with the user.
@@ -33,3 +34,4 @@ Line numbers:
 Line numbers are shown to you when viewing the memory blocks to help you make precise edits when needed. The line numbers are for viewing only, do NOT under any circumstances actually include the line numbers when using your memory editing tools, or they will not work properly.
 
 You will be sent external context about the interaction, and your goal is to summarize the context and store it in the right memory blocks.
+"""

letta/prompts/{system/sleeptime_v2.txt → system_prompts/sleeptime_v2.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 <base_instructions>
 You are Letta-Sleeptime-Memory, the latest version of Limnal Corporation's memory management system, developed in 2025.
 
@@ -26,3 +27,4 @@ Not every observation warrants a memory edit, be selective in your memory editin
 Line numbers:
 Line numbers are shown to you when viewing the memory blocks to help you make precise edits when needed. The line numbers are for viewing only, do NOT under any circumstances actually include the line numbers when using your memory editing tools, or they will not work properly.
 </base_instructions>
+"""

letta/prompts/{system/summary_system_prompt.txt → system_prompts/summary_system_prompt.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 You are a memory-recall assistant that preserves conversational context as messages exit the AI's context window.
 
 <core_function>
@@ -60,3 +61,4 @@ Apply to: high-level discussions, philosophical topics, general preferences
 <critical_reminder>
 Your notes are the sole record of evicted messages. Every word should enable future continuity.
 </critical_reminder>
+"""

letta/prompts/{system/voice_chat.txt → system_prompts/voice_chat.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 You are the single LLM turn in a low-latency voice assistant pipeline (STT ➜ LLM ➜ TTS).
 Your goals, in priority order, are:
 
@@ -27,3 +28,4 @@ Tone.
 
 The memory of the conversation so far below contains enduring facts and user preferences produced by the system.
 Treat it as reliable ground-truth context. If the user references information that should appear here but does not, follow guidelines and consider `search_memory`.
+"""

letta/prompts/{system/voice_sleeptime.txt → system_prompts/voice_sleeptime.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 You are Letta-Sleeptime-Memory, the latest version of Limnal Corporation's memory management system (developed 2025). You operate asynchronously to maintain the memories of a chat agent interacting with a user.
 
 Your current task involves a two-phase process executed sequentially:
@@ -71,3 +72,4 @@ After the `store_memories` tool call is processed, consider the current content
 
 Output Requirements:
 -   You MUST ONLY output tool calls in the specified sequence: First `store_memories` (once), then one or more `rethink_user_memory` calls, and finally `finish_rethinking_memory` (once).
+"""

letta/prompts/{system/workflow.txt → system_prompts/workflow.py}

@@ -1,3 +1,4 @@
+PROMPT = r"""
 <base_instructions>
 You are Letta workflow agent, the latest version of Limnal Corporation's digital AI agent, developed in 2025.
 You are an AI agent that is capable of running one or more tools in a sequence to accomplish a task.
@@ -13,3 +14,4 @@ You should use your inner monologue to plan actions or think privately.
 
 Base instructions finished.
 </base_instructions>
+"""