letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.12.0.dev20251009104148__py3-none-any.whl

letta/llm_api/xai_client.py

@@ -8,6 +8,7 @@ from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 from letta.llm_api.openai_client import OpenAIClient
 from letta.otel.tracing import trace_method
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import AgentType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.settings import model_settings
@@ -23,12 +24,14 @@ class XAIClient(OpenAIClient):
     @trace_method
     def build_request_data(
         self,
+        agent_type: AgentType,
         messages: List[PydanticMessage],
         llm_config: LLMConfig,
         tools: Optional[List[dict]] = None,
         force_tool_call: Optional[str] = None,
+        requires_subsequent_tool_call: bool = False,
     ) -> dict:
-        data = super().build_request_data(messages, llm_config, tools, force_tool_call)
+        data = super().build_request_data(agent_type, messages, llm_config, tools, force_tool_call, requires_subsequent_tool_call)
 
         # Specific bug for the mini models (as of Apr 14, 2025)
         # 400 - {'code': 'Client specified an invalid argument', 'error': 'Argument not supported on this model: presencePenalty'}

letta/main.py

@@ -3,12 +3,16 @@ import os
 import typer
 
 from letta.cli.cli import server
-from letta.cli.cli_load import app as load_app
-
-# disable composio print on exit
-os.environ["COMPOSIO_DISABLE_VERSION_CHECK"] = "true"
 
 app = typer.Typer(pretty_exceptions_enable=False)
+
+# Register server as both the default command and as a subcommand
 app.command(name="server")(server)
 
-app.add_typer(load_app, name="load")
+
+# Also make server the default when no command is specified
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    if ctx.invoked_subcommand is None:
+        # If no subcommand is specified, run the server
+        server()

letta/memory.py

@@ -91,6 +91,7 @@ def summarize_messages(
     # TODO: we can just directly call the LLM here?
     if llm_client:
         response = llm_client.send_llm_request(
+            agent_type=agent_state.agent_type,
             messages=message_sequence,
             llm_config=llm_config_no_inner_thoughts,
         )

letta/orm/__init__.py

@@ -15,7 +15,6 @@ from letta.orm.identities_agents import IdentitiesAgents
 from letta.orm.identities_blocks import IdentitiesBlocks
 from letta.orm.identity import Identity
 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
@@ -27,6 +26,8 @@ from letta.orm.passage_tag import PassageTag
 from letta.orm.prompt import Prompt
 from letta.orm.provider import Provider
 from letta.orm.provider_trace import ProviderTrace
+from letta.orm.run import Run
+from letta.orm.run_metrics import RunMetrics
 from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.sources_agents import SourcesAgents

letta/orm/agent.py

@@ -28,6 +28,7 @@ if TYPE_CHECKING:
     from letta.orm.files_agents import FileAgent
     from letta.orm.identity import Identity
     from letta.orm.organization import Organization
+    from letta.orm.run import Run
     from letta.orm.source import Source
     from letta.orm.tool import Tool
 
@@ -38,6 +39,8 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
     __table_args__ = (
         Index("ix_agents_created_at", "created_at", "id"),
         Index("ix_agents_organization_id", "organization_id"),
+        Index("ix_agents_organization_id_deployment_id", "organization_id", "deployment_id"),
+        Index("ix_agents_project_id", "project_id"),
     )
 
     # agent generates its own id
@@ -132,6 +135,13 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
         lazy="selectin",
         doc="Tags associated with the agent.",
     )
+    runs: Mapped[List["Run"]] = relationship(
+        "Run",
+        back_populates="agent",
+        cascade="all, delete-orphan",
+        lazy="selectin",
+        doc="Runs associated with the agent.",
+    )
     identities: Mapped[List["Identity"]] = relationship(
         "Identity",
         secondary="identities_agents",

letta/orm/block.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, List, Optional, Type
 
 from sqlalchemy import JSON, BigInteger, ForeignKey, Index, Integer, String, UniqueConstraint, event
-from sqlalchemy.orm import Mapped, attributes, declared_attr, mapped_column, relationship
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
 
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.orm.block_history import BlockHistory
@@ -25,6 +25,12 @@ class Block(OrganizationMixin, SqlalchemyBase, ProjectMixin, TemplateEntityMixin
         UniqueConstraint("id", "label", name="unique_block_id_label"),
         Index("created_at_label_idx", "created_at", "label"),
         Index("ix_block_label", "label"),
+        Index("ix_block_organization_id", "organization_id"),
+        Index("ix_block_project_id", "project_id"),
+        Index("ix_block_is_template", "is_template"),
+        Index("ix_block_hidden", "hidden"),
+        Index("ix_block_org_project_template", "organization_id", "project_id", "is_template"),
+        Index("ix_block_organization_id_deployment_id", "organization_id", "deployment_id"),
     )
 
     template_name: Mapped[Optional[str]] = mapped_column(
@@ -104,21 +110,6 @@ class Block(OrganizationMixin, SqlalchemyBase, ProjectMixin, TemplateEntityMixin
         )  # Helps manage potential FK cycles
 
 
-@event.listens_for(Block, "after_update")  # Changed from 'before_update'
-def block_before_update(mapper, connection, target):
-    """Handle updating BlocksAgents when a block's label changes."""
-    label_history = attributes.get_history(target, "label")
-    if not label_history.has_changes():
-        return
-
-    blocks_agents = BlocksAgents.__table__
-    connection.execute(
-        blocks_agents.update()
-        .where(blocks_agents.c.block_id == target.id, blocks_agents.c.block_label == label_history.deleted[0])
-        .values(block_label=label_history.added[0])
-    )
-
-
 @event.listens_for(Block, "before_insert")
 @event.listens_for(Block, "before_update")
 def validate_value_length(mapper, connection, target):

letta/orm/blocks_agents.py

@@ -15,7 +15,13 @@ class BlocksAgents(Base):
             name="unique_label_per_agent",
         ),
         ForeignKeyConstraint(
-            ["block_id", "block_label"], ["block.id", "block.label"], name="fk_block_id_label", deferrable=True, initially="DEFERRED"
+            ["block_id", "block_label"],
+            ["block.id", "block.label"],
+            name="fk_block_id_label",
+            onupdate="CASCADE",
+            ondelete="CASCADE",
+            deferrable=True,
+            initially="IMMEDIATE",
         ),
         UniqueConstraint("agent_id", "block_id", name="unique_agent_block"),
         Index("ix_blocks_agents_block_label_agent_id", "block_label", "agent_id"),
@@ -24,6 +30,6 @@ class BlocksAgents(Base):
     )
 
     # unique agent + block label
-    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True)
     block_id: Mapped[str] = mapped_column(String, primary_key=True)
     block_label: Mapped[str] = mapped_column(String, primary_key=True)

letta/orm/files_agents.py

@@ -32,6 +32,8 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
         # helpful indexes for look-ups
         Index("ix_file_agent", "file_id", "agent_id"),
         Index("ix_agent_filename", "agent_id", "file_name"),
+        # improve lookups by agent alone (e.g., WHERE agent_id IN (...))
+        Index("ix_files_agents_agent_id", "agent_id"),
     )
     __pydantic_model__ = PydanticFileAgent
 

letta/orm/job.py

@@ -11,10 +11,8 @@ 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
     from letta.orm.message import Message
     from letta.orm.organization import Organization
-    from letta.orm.step import Step
     from letta.orm.user import User
 
 
@@ -25,11 +23,17 @@ class Job(SqlalchemyBase, UserMixin):
 
     __tablename__ = "jobs"
     __pydantic_model__ = PydanticJob
-    __table_args__ = (Index("ix_jobs_created_at", "created_at", "id"),)
+    __table_args__ = (
+        Index("ix_jobs_created_at", "created_at", "id"),
+        Index("ix_jobs_user_id", "user_id"),
+    )
 
     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.")
+    background: Mapped[Optional[bool]] = mapped_column(
+        Boolean, nullable=True, default=False, doc="Whether the job was created in background mode."
+    )
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, doc="The metadata of the job.")
     job_type: Mapped[JobType] = mapped_column(
         String,
@@ -55,8 +59,6 @@ class Job(SqlalchemyBase, UserMixin):
 
     # relationships
     user: Mapped["User"] = relationship("User", back_populates="jobs")
-    job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")
-    steps: Mapped[List["Step"]] = relationship("Step", back_populates="job", cascade="save-update")
     # organization relationship (nullable for backward compatibility)
     organization: Mapped[Optional["Organization"]] = relationship("Organization", back_populates="jobs")
 

letta/orm/mcp_oauth.py

@@ -35,6 +35,7 @@ class MCPOAuth(SqlalchemyBase, OrganizationMixin, UserMixin):
     # OAuth flow data
     authorization_url: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth authorization URL")
     authorization_code: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth authorization code")
+    authorization_code_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted OAuth authorization code")
 
     # Token data
     access_token: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="OAuth access token")

letta/orm/message.py

@@ -7,7 +7,8 @@ from sqlalchemy.orm import Mapped, Session, mapped_column, relationship
 from letta.orm.custom_columns import MessageContentColumn, ToolCallColumn, ToolReturnColumn
 from letta.orm.mixins import AgentMixin, OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.letta_message_content import MessageContent, TextContent as PydanticTextContent
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message_content import MessageContent, TextContent, TextContent as PydanticTextContent
 from letta.schemas.message import Message as PydanticMessage, ToolReturn
 from letta.settings import DatabaseChoice, settings
 
@@ -21,6 +22,9 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
         Index("ix_messages_created_at", "created_at", "id"),
         Index("ix_messages_agent_sequence", "agent_id", "sequence_id"),
         Index("ix_messages_org_agent", "organization_id", "agent_id"),
+        Index("ix_messages_run_id", "run_id"),
+        # Composite index for optimizing the frequently-run query:
+        Index("ix_messages_run_sequence", "run_id", "sequence_id"),
     )
     __pydantic_model__ = PydanticMessage
 
@@ -35,6 +39,9 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     step_id: Mapped[Optional[str]] = mapped_column(
         ForeignKey("steps.id", ondelete="SET NULL"), nullable=True, doc="ID of the step that this message belongs to"
     )
+    run_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("runs.id", ondelete="SET NULL"), nullable=True, doc="ID of the run that this message belongs to"
+    )
     otid: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The offline threading ID associated with this message")
     tool_returns: Mapped[List[ToolReturn]] = mapped_column(
         ToolReturnColumn, nullable=True, doc="Tool execution return information for prior tool calls"
@@ -68,11 +75,7 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     # Relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="raise")
     step: Mapped["Step"] = relationship("Step", back_populates="messages", lazy="selectin")
-
-    # Job relationship
-    job_message: Mapped[Optional["JobMessage"]] = relationship(
-        "JobMessage", back_populates="message", uselist=False, cascade="all, delete-orphan", single_parent=True
-    )
+    run: Mapped["Run"] = relationship("Run", back_populates="messages", lazy="selectin")
 
     @property
     def job(self) -> Optional["Job"]:
@@ -87,6 +90,18 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
         # If there are no tool calls, set tool_calls to None
         if self.tool_calls is None or len(self.tool_calls) == 0:
             model.tool_calls = None
+
+        # Handle legacy case of tool message with single tool return + single text content
+        if (
+            self.role == MessageRole.tool
+            and self.tool_returns
+            and len(self.tool_returns) == 1
+            and self.content
+            and len(self.content) == 1
+            and isinstance(self.content[0], TextContent)
+        ):
+            self.tool_returns[0].func_response = self.content[0].text
+
         return model
 
 

letta/orm/organization.py

@@ -19,6 +19,7 @@ if TYPE_CHECKING:
     from letta.orm.passage import ArchivalPassage, SourcePassage
     from letta.orm.passage_tag import PassageTag
     from letta.orm.provider import Provider
+    from letta.orm.run import Run
     from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig, SandboxEnvironmentVariable
     from letta.orm.tool import Tool
     from letta.orm.user import User
@@ -68,3 +69,4 @@ class Organization(SqlalchemyBase):
         "LLMBatchItem", back_populates="organization", cascade="all, delete-orphan"
     )
     jobs: Mapped[List["Job"]] = relationship("Job", back_populates="organization", cascade="all, delete-orphan")
+    runs: Mapped[List["Run"]] = relationship("Run", back_populates="organization", cascade="all, delete-orphan")

letta/orm/provider.py

@@ -1,6 +1,6 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
-from sqlalchemy import UniqueConstraint
+from sqlalchemy import Text, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import OrganizationMixin
@@ -33,5 +33,9 @@ class Provider(SqlalchemyBase, OrganizationMixin):
     region: Mapped[str] = mapped_column(nullable=True, doc="Region used for requests to the provider.")
     api_version: Mapped[str] = mapped_column(nullable=True, doc="API version used for requests to the provider.")
 
+    # encrypted columns
+    api_key_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted API key or secret key for the provider.")
+    access_key_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted access key for the provider.")
+
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="providers")

letta/orm/run.py

@@ -0,0 +1,71 @@
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+from sqlalchemy import JSON, BigInteger, Boolean, DateTime, ForeignKey, Index, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin, ProjectMixin, TemplateMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import RunStatus
+from letta.schemas.job import LettaRequestConfig
+from letta.schemas.letta_stop_reason import StopReasonType
+from letta.schemas.run import Run as PydanticRun
+
+if TYPE_CHECKING:
+    from letta.orm.agent import Agent
+    from letta.orm.message import Message
+    from letta.orm.organization import Organization
+    from letta.orm.step import Step
+
+
+class Run(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateMixin):
+    """Runs are created when agents process messages and represent a conversation or processing session.
+    Unlike Jobs, Runs are specifically tied to agent interactions and message processing.
+    """
+
+    __tablename__ = "runs"
+    __pydantic_model__ = PydanticRun
+    __table_args__ = (
+        Index("ix_runs_created_at", "created_at", "id"),
+        Index("ix_runs_agent_id", "agent_id"),
+        Index("ix_runs_organization_id", "organization_id"),
+    )
+
+    # Generate run ID with run- prefix
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"run-{uuid.uuid4()}")
+
+    # Core run fields
+    status: Mapped[RunStatus] = mapped_column(String, default=RunStatus.created, doc="The current status of the run.")
+    completed_at: Mapped[Optional[datetime]] = mapped_column(nullable=True, doc="The unix timestamp of when the run was completed.")
+    stop_reason: Mapped[Optional[StopReasonType]] = mapped_column(String, nullable=True, doc="The reason why the run was stopped.")
+    background: Mapped[Optional[bool]] = mapped_column(
+        Boolean, nullable=True, default=False, doc="Whether the run was created in background mode."
+    )
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, doc="The metadata of the run.")
+    request_config: Mapped[Optional[LettaRequestConfig]] = mapped_column(
+        JSON, nullable=True, doc="The request configuration for the run, stored as JSON."
+    )
+
+    # Agent relationship - A run belongs to one agent
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"), nullable=False, doc="The agent that owns this run.")
+
+    # Callback related columns
+    callback_url: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="When set, POST to this URL after run completion.")
+    callback_sent_at: Mapped[Optional[datetime]] = mapped_column(nullable=True, doc="Timestamp when the callback was last attempted.")
+    callback_status_code: Mapped[Optional[int]] = mapped_column(nullable=True, doc="HTTP status code returned by the callback endpoint.")
+    callback_error: Mapped[Optional[str]] = mapped_column(
+        nullable=True, doc="Optional error message from attempting to POST the callback endpoint."
+    )
+
+    # Timing metrics (in nanoseconds for precision)
+    ttft_ns: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, doc="Time to first token in nanoseconds")
+    total_duration_ns: Mapped[Optional[int]] = mapped_column(BigInteger, nullable=True, doc="Total run duration in nanoseconds")
+
+    # Relationships
+    agent: Mapped["Agent"] = relationship("Agent", back_populates="runs")
+    organization: Mapped[Optional["Organization"]] = relationship("Organization", back_populates="runs")
+
+    # Steps that are part of this run
+    steps: Mapped[List["Step"]] = relationship("Step", back_populates="run", cascade="all, delete-orphan")
+    messages: Mapped[List["Message"]] = relationship("Message", back_populates="run", cascade="all, delete-orphan")

letta/orm/run_metrics.py

@@ -0,0 +1,82 @@
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import BigInteger, ForeignKey, Integer, String
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, Session, mapped_column, relationship
+
+from letta.orm.mixins import AgentMixin, OrganizationMixin, ProjectMixin, TemplateMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.run_metrics import RunMetrics as PydanticRunMetrics
+from letta.schemas.user import User
+from letta.settings import DatabaseChoice, settings
+
+if TYPE_CHECKING:
+    from letta.orm.agent import Agent
+    from letta.orm.run import Run
+    from letta.orm.step import Step
+
+
+class RunMetrics(SqlalchemyBase, ProjectMixin, AgentMixin, OrganizationMixin, TemplateMixin):
+    """Tracks performance metrics for agent steps."""
+
+    __tablename__ = "run_metrics"
+    __pydantic_model__ = PydanticRunMetrics
+
+    id: Mapped[str] = mapped_column(
+        ForeignKey("runs.id", ondelete="CASCADE"),
+        primary_key=True,
+        doc="The unique identifier of the run this metric belongs to (also serves as PK)",
+    )
+    run_start_ns: Mapped[Optional[int]] = mapped_column(
+        BigInteger,
+        nullable=True,
+        doc="The timestamp of the start of the run in nanoseconds",
+    )
+    run_ns: Mapped[Optional[int]] = mapped_column(
+        BigInteger,
+        nullable=True,
+        doc="Total time for the run in nanoseconds",
+    )
+    num_steps: Mapped[Optional[int]] = mapped_column(
+        Integer,
+        nullable=True,
+        doc="The number of steps in the run",
+    )
+    run: Mapped[Optional["Run"]] = relationship("Run", foreign_keys=[id])
+    agent: Mapped[Optional["Agent"]] = relationship("Agent")
+
+    def create(
+        self,
+        db_session: Session,
+        actor: Optional[User] = None,
+        no_commit: bool = False,
+    ) -> "RunMetrics":
+        """Override create to handle SQLite timestamp issues"""
+        # For SQLite, explicitly set timestamps as server_default may not work
+        if settings.database_engine == DatabaseChoice.SQLITE:
+            now = datetime.now(timezone.utc)
+            if not self.created_at:
+                self.created_at = now
+            if not self.updated_at:
+                self.updated_at = now
+
+        return super().create(db_session, actor=actor, no_commit=no_commit)
+
+    async def create_async(
+        self,
+        db_session: AsyncSession,
+        actor: Optional[User] = None,
+        no_commit: bool = False,
+        no_refresh: bool = False,
+    ) -> "RunMetrics":
+        """Override create_async to handle SQLite timestamp issues"""
+        # For SQLite, explicitly set timestamps as server_default may not work
+        if settings.database_engine == DatabaseChoice.SQLITE:
+            now = datetime.now(timezone.utc)
+            if not self.created_at:
+                self.created_at = now
+            if not self.updated_at:
+                self.updated_at = now
+
+        return await super().create_async(db_session, actor=actor, no_commit=no_commit, no_refresh=no_refresh)

letta/orm/sandbox_config.py

@@ -1,7 +1,7 @@
 import uuid
 from typing import TYPE_CHECKING, Dict, List, Optional
 
-from sqlalchemy import JSON, Enum as SqlEnum, Index, String, UniqueConstraint
+from sqlalchemy import JSON, Enum as SqlEnum, Index, String, Text, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import AgentMixin, OrganizationMixin, SandboxConfigMixin
@@ -49,6 +49,9 @@ class SandboxEnvironmentVariable(SqlalchemyBase, OrganizationMixin, SandboxConfi
     value: Mapped[str] = mapped_column(String, nullable=False, doc="The value of the environment variable.")
     description: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="An optional description of the environment variable.")
 
+    # encrypted columns
+    value_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted value of the environment variable.")
+
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="sandbox_environment_variables")
     sandbox_config: Mapped["SandboxConfig"] = relationship("SandboxConfig", back_populates="sandbox_environment_variables")
@@ -71,5 +74,8 @@ class AgentEnvironmentVariable(SqlalchemyBase, OrganizationMixin, AgentMixin):
     value: Mapped[str] = mapped_column(String, nullable=False, doc="The value of the environment variable.")
     description: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="An optional description of the environment variable.")
 
+    # encrypted columns
+    value_enc: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Encrypted value of the environment variable.")
+
     organization: Mapped["Organization"] = relationship("Organization", back_populates="agent_environment_variables")
     agent: Mapped[List["Agent"]] = relationship("Agent", back_populates="tool_exec_environment_variables")