letta-nightly 0.6.7.dev20250106104119__tar.gz → 0.6.7.dev20250106211813__tar.gz

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.7.dev20250106104119
+Version: 0.6.7.dev20250106211813
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/client/client.py

@@ -15,6 +15,11 @@ from letta.schemas.embedding_config import EmbeddingConfig
 
 # new schemas
 from letta.schemas.enums import JobStatus, MessageRole
+from letta.schemas.environment_variables import (
+    SandboxEnvironmentVariable,
+    SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableUpdate,
+)
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
@@ -25,16 +30,7 @@ from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.openai.chat_completions import ToolCall
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
-from letta.schemas.sandbox_config import (
-    E2BSandboxConfig,
-    LocalSandboxConfig,
-    SandboxConfig,
-    SandboxConfigCreate,
-    SandboxConfigUpdate,
-    SandboxEnvironmentVariable,
-    SandboxEnvironmentVariableCreate,
-    SandboxEnvironmentVariableUpdate,
-)
+from letta.schemas.sandbox_config import E2BSandboxConfig, LocalSandboxConfig, SandboxConfig, SandboxConfigCreate, SandboxConfigUpdate
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
 from letta.schemas.tool_rule import BaseToolRule

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/client/streaming.py

@@ -45,7 +45,6 @@ def _sse_post(url: str, data: dict, headers: dict) -> Generator[LettaStreamingRe
                     # break
                     if sse.data in [status.value for status in MessageStreamStatus]:
                         # break
-                        # print("sse.data::", sse.data)
                         yield MessageStreamStatus(sse.data)
                     else:
                         chunk_data = json.loads(sse.data)

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/orm/agent.py

@@ -31,7 +31,7 @@ class Agent(SqlalchemyBase, OrganizationMixin):
 
     # agent generates its own id
     # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
-    # TODO: Move this in this PR? at the very end?
+    # TODO: Some still rely on the Pydantic object to do this
     id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"agent-{uuid.uuid4()}")
 
     # Descriptor fields
@@ -61,6 +61,13 @@ class Agent(SqlalchemyBase, OrganizationMixin):
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="agents")
+    tool_exec_environment_variables: Mapped[List["AgentEnvironmentVariable"]] = relationship(
+        "AgentEnvironmentVariable",
+        back_populates="agent",
+        cascade="all, delete-orphan",
+        lazy="selectin",
+        doc="Environment variables associated with this agent.",
+    )
     tools: Mapped[List["Tool"]] = relationship("Tool", secondary="tools_agents", lazy="selectin", passive_deletes=True)
     sources: Mapped[List["Source"]] = relationship("Source", secondary="sources_agents", lazy="selectin")
     core_memory: Mapped[List["Block"]] = relationship("Block", secondary="blocks_agents", lazy="selectin")
@@ -119,5 +126,6 @@ class Agent(SqlalchemyBase, OrganizationMixin):
             "last_updated_by_id": self.last_updated_by_id,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
+            "tool_exec_environment_variables": self.tool_exec_environment_variables,
         }
         return self.__pydantic_model__(**state)

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/orm/organization.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
 
     from letta.orm.agent import Agent
     from letta.orm.file import FileMetadata
+    from letta.orm.sandbox_config import AgentEnvironmentVariable
     from letta.orm.tool import Tool
     from letta.orm.user import User
 
@@ -33,6 +34,9 @@ class Organization(SqlalchemyBase):
     sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
         "SandboxEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
     )
+    agent_environment_variables: Mapped[List["AgentEnvironmentVariable"]] = relationship(
+        "AgentEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
+    )
 
     # relationships
     agents: Mapped[List["Agent"]] = relationship("Agent", back_populates="organization", cascade="all, delete-orphan")

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/orm/sandbox_config.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import TYPE_CHECKING, Dict, List, Optional
 
 from sqlalchemy import JSON
@@ -5,13 +6,14 @@ from sqlalchemy import Enum as SqlEnum
 from sqlalchemy import String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.mixins import OrganizationMixin, SandboxConfigMixin
+from letta.orm.mixins import AgentMixin, OrganizationMixin, SandboxConfigMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.environment_variables import SandboxEnvironmentVariable as PydanticSandboxEnvironmentVariable
 from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
-from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticSandboxEnvironmentVariable
 from letta.schemas.sandbox_config import SandboxType
 
 if TYPE_CHECKING:
+    from letta.orm.agent import Agent
     from letta.orm.organization import Organization
 
 
@@ -52,3 +54,21 @@ class SandboxEnvironmentVariable(SqlalchemyBase, OrganizationMixin, SandboxConfi
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="sandbox_environment_variables")
     sandbox_config: Mapped["SandboxConfig"] = relationship("SandboxConfig", back_populates="sandbox_environment_variables")
+
+
+class AgentEnvironmentVariable(SqlalchemyBase, OrganizationMixin, AgentMixin):
+    """ORM model for environment variables associated with agents."""
+
+    __tablename__ = "agent_environment_variables"
+    # We cannot have duplicate key names for the same agent, the env var would get overwritten
+    __table_args__ = (UniqueConstraint("key", "agent_id", name="uix_key_agent"),)
+
+    # agent_env_var generates its own id
+    # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"agent-env-{uuid.uuid4()}")
+    key: Mapped[str] = mapped_column(String, nullable=False, doc="The name of the environment variable.")
+    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.")
+
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="agent_environment_variables")
+    agent: Mapped[List["Agent"]] = relationship("Agent", back_populates="tool_exec_environment_variables")

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/schemas/agent.py

@@ -6,6 +6,7 @@ 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.environment_variables import AgentEnvironmentVariable
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
@@ -78,6 +79,9 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     tools: List[Tool] = Field(..., description="The tools used by the agent.")
     sources: List[Source] = Field(..., description="The sources used by the agent.")
     tags: List[str] = Field(..., description="The tags associated with the agent.")
+    tool_exec_environment_variables: List[AgentEnvironmentVariable] = Field(
+        ..., description="The environment variables for tool execution specific to this agent."
+    )
 
 
 class CreateAgent(BaseModel, validate_assignment=True):  #
@@ -120,6 +124,9 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     embedding_chunk_size: Optional[int] = Field(DEFAULT_EMBEDDING_CHUNK_SIZE, description="The embedding chunk size used by the agent.")
     from_template: Optional[str] = Field(None, description="The template id used to configure the agent")
     project_id: Optional[str] = Field(None, description="The project id that the agent will be associated with.")
+    tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
+        None, description="The environment variables for tool execution specific to this agent."
+    )
 
     @field_validator("name")
     @classmethod
@@ -184,6 +191,9 @@ class UpdateAgent(BaseModel):
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
+    tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
+        None, description="The environment variables for tool execution specific to this agent."
+    )
 
     class Config:
         extra = "ignore"  # Ignores extra fields

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/schemas/enums.py

@@ -30,8 +30,8 @@ class JobStatus(str, Enum):
 
 
 class MessageStreamStatus(str, Enum):
-    done_generation = "[DONE_GEN]"
-    done_step = "[DONE_STEP]"
+    # done_generation = "[DONE_GEN]"
+    # done_step = "[DONE_STEP]"
     done = "[DONE]"
 
 

letta_nightly-0.6.7.dev20250106211813/letta/schemas/environment_variables.py

@@ -0,0 +1,62 @@
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+
+
+# Base Environment Variable
+class EnvironmentVariableBase(OrmMetadataBase):
+    id: str = Field(..., description="The unique identifier for the environment variable.")
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+    organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
+
+
+class EnvironmentVariableCreateBase(LettaBase):
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+
+
+class EnvironmentVariableUpdateBase(LettaBase):
+    key: Optional[str] = Field(None, description="The name of the environment variable.")
+    value: Optional[str] = Field(None, description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+
+
+# Sandbox-Specific Environment Variable
+class SandboxEnvironmentVariableBase(EnvironmentVariableBase):
+    __id_prefix__ = "sandbox-env"
+    sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")
+
+
+class SandboxEnvironmentVariable(SandboxEnvironmentVariableBase):
+    id: str = SandboxEnvironmentVariableBase.generate_id_field()
+
+
+class SandboxEnvironmentVariableCreate(EnvironmentVariableCreateBase):
+    pass
+
+
+class SandboxEnvironmentVariableUpdate(EnvironmentVariableUpdateBase):
+    pass
+
+
+# Agent-Specific Environment Variable
+class AgentEnvironmentVariableBase(EnvironmentVariableBase):
+    __id_prefix__ = "agent-env"
+    agent_id: str = Field(..., description="The ID of the agent this environment variable belongs to.")
+
+
+class AgentEnvironmentVariable(AgentEnvironmentVariableBase):
+    id: str = AgentEnvironmentVariableBase.generate_id_field()
+
+
+class AgentEnvironmentVariableCreate(EnvironmentVariableCreateBase):
+    pass
+
+
+class AgentEnvironmentVariableUpdate(EnvironmentVariableUpdateBase):
+    pass

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/schemas/letta_response.py

@@ -29,19 +29,20 @@ class LettaResponse(BaseModel):
         json_schema_extra={
             "items": {
                 "oneOf": [
-                    {"x-ref-name": "SystemMessage"},
-                    {"x-ref-name": "UserMessage"},
-                    {"x-ref-name": "ReasoningMessage"},
-                    {"x-ref-name": "ToolCallMessage"},
-                    {"x-ref-name": "ToolReturnMessage"},
-                    {"x-ref-name": "AssistantMessage"},
+                    {"$ref": "#/components/schemas/SystemMessage-Output"},
+                    {"$ref": "#/components/schemas/UserMessage-Output"},
+                    {"$ref": "#/components/schemas/ReasoningMessage"},
+                    {"$ref": "#/components/schemas/ToolCallMessage"},
+                    {"$ref": "#/components/schemas/ToolReturnMessage"},
+                    {"$ref": "#/components/schemas/AssistantMessage-Output"},
                 ],
                 "discriminator": {"propertyName": "message_type"},
             }
         },
     )
     usage: LettaUsageStatistics = Field(
-        ..., description="The usage statistics of the agent.", json_schema_extra={"x-ref-name": "LettaUsageStatistics"}
+        ...,
+        description="The usage statistics of the agent.",
     )
 
     def __str__(self):

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/schemas/sandbox_config.py

@@ -102,31 +102,3 @@ class SandboxConfigUpdate(LettaBase):
     """Pydantic model for updating SandboxConfig fields."""
 
     config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(None, description="The JSON configuration data for the sandbox.")
-
-
-# Environment Variable
-class SandboxEnvironmentVariableBase(OrmMetadataBase):
-    __id_prefix__ = "sandbox-env"
-
-
-class SandboxEnvironmentVariable(SandboxEnvironmentVariableBase):
-    id: str = SandboxEnvironmentVariableBase.generate_id_field()
-    key: str = Field(..., description="The name of the environment variable.")
-    value: str = Field(..., description="The value of the environment variable.")
-    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
-    sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")
-    organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
-
-
-class SandboxEnvironmentVariableCreate(LettaBase):
-    key: str = Field(..., description="The name of the environment variable.")
-    value: str = Field(..., description="The value of the environment variable.")
-    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
-
-
-class SandboxEnvironmentVariableUpdate(LettaBase):
-    """Pydantic model for updating SandboxEnvironmentVariable fields."""
-
-    key: Optional[str] = Field(None, description="The name of the environment variable.")
-    value: Optional[str] = Field(None, description="The value of the environment variable.")
-    description: Optional[str] = Field(None, description="An optional description of the environment variable.")

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/server/rest_api/interface.py

@@ -292,8 +292,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         # if multi_step = True, the stream ends when the agent yields
         # if multi_step = False, the stream ends when the step ends
         self.multi_step = multi_step
-        self.multi_step_indicator = MessageStreamStatus.done_step
-        self.multi_step_gen_indicator = MessageStreamStatus.done_generation
+        # self.multi_step_indicator = MessageStreamStatus.done_step
+        # self.multi_step_gen_indicator = MessageStreamStatus.done_generation
 
         # Support for AssistantMessage
         self.use_assistant_message = False  # TODO: Remove this
@@ -378,8 +378,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         """Clean up the stream by deactivating and clearing chunks."""
         self.streaming_chat_completion_mode_function_name = None
 
-        if not self.streaming_chat_completion_mode and not self.nonstreaming_legacy_mode:
-            self._push_to_buffer(self.multi_step_gen_indicator)
+        # if not self.streaming_chat_completion_mode and not self.nonstreaming_legacy_mode:
+        #     self._push_to_buffer(self.multi_step_gen_indicator)
 
         # Wipe the inner thoughts buffers
         self._reset_inner_thoughts_json_reader()
@@ -390,9 +390,9 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             # end the stream
             self._active = False
             self._event.set()  # Unblock the generator if it's waiting to allow it to complete
-        elif not self.streaming_chat_completion_mode and not self.nonstreaming_legacy_mode:
-            # signal that a new step has started in the stream
-            self._push_to_buffer(self.multi_step_indicator)
+        # elif not self.streaming_chat_completion_mode and not self.nonstreaming_legacy_mode:
+        #     # signal that a new step has started in the stream
+        #     self._push_to_buffer(self.multi_step_indicator)
 
         # Wipe the inner thoughts buffers
         self._reset_inner_thoughts_json_reader()

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/server/rest_api/routers/v1/sandbox_configs.py

@@ -2,10 +2,10 @@ from typing import List, Optional
 
 from fastapi import APIRouter, Depends, Query
 
+from letta.schemas.environment_variables import SandboxEnvironmentVariable as PydanticEnvVar
+from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate
 from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
-from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate
-from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticEnvVar
-from letta.schemas.sandbox_config import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate, SandboxType
+from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate, SandboxType
 from letta.server.rest_api.utils import get_letta_server, get_user_id
 from letta.server.server import SyncServer
 

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/server/server.py

@@ -46,6 +46,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
 from letta.schemas.enums import JobStatus
+from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
 from letta.schemas.job import Job, JobUpdate
 from letta.schemas.letta_message import LettaMessage, ToolReturnMessage
 from letta.schemas.llm_config import LLMConfig
@@ -53,7 +54,7 @@ from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, M
 from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
-from letta.schemas.sandbox_config import SandboxEnvironmentVariableCreate, SandboxType
+from letta.schemas.sandbox_config import SandboxType
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/services/agent_manager.py

@@ -14,6 +14,7 @@ from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
 from letta.orm import Tool as ToolModel
 from letta.orm.errors import NoResultFound
+from letta.orm.sandbox_config import AgentEnvironmentVariable as AgentEnvironmentVariableModel
 from letta.orm.sqlite_functions import adapt_array
 from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.agent import AgentType, CreateAgent, UpdateAgent
@@ -116,6 +117,14 @@ class AgentManager:
             actor=actor,
         )
 
+        # If there are provided environment variables, add them in
+        if agent_create.tool_exec_environment_variables:
+            agent_state = self._set_environment_variables(
+                agent_id=agent_state.id,
+                env_vars=agent_create.tool_exec_environment_variables,
+                actor=actor,
+            )
+
         # TODO: See if we can merge this into the above SQL create call for performance reasons
         # Generate a sequence of initial messages to put in the buffer
         init_messages = initialize_message_sequence(
@@ -192,6 +201,14 @@ class AgentManager:
     def update_agent(self, agent_id: str, agent_update: UpdateAgent, actor: PydanticUser) -> PydanticAgentState:
         agent_state = self._update_agent(agent_id=agent_id, agent_update=agent_update, actor=actor)
 
+        # If there are provided environment variables, add them in
+        if agent_update.tool_exec_environment_variables:
+            agent_state = self._set_environment_variables(
+                agent_id=agent_state.id,
+                env_vars=agent_update.tool_exec_environment_variables,
+                actor=actor,
+            )
+
         # Rebuild the system prompt if it's different
         if agent_update.system and agent_update.system != agent_state.system:
             agent_state = self.rebuild_system_prompt(agent_id=agent_state.id, actor=actor, force=True, update_timestamp=False)
@@ -296,6 +313,43 @@ class AgentManager:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             agent.hard_delete(session)
 
+    # ======================================================================================================================
+    # Per Agent Environment Variable Management
+    # ======================================================================================================================
+    @enforce_types
+    def _set_environment_variables(
+        self,
+        agent_id: str,
+        env_vars: Dict[str, str],
+        actor: PydanticUser,
+    ) -> PydanticAgentState:
+        """
+        Adds or replaces the environment variables for the specified agent.
+
+        Args:
+            agent_id: The agent id.
+            env_vars: A dictionary of environment variable key-value pairs.
+            actor: The user performing the action.
+
+        Returns:
+            PydanticAgentState: The updated agent as a Pydantic model.
+        """
+        with self.session_maker() as session:
+            # Retrieve the agent
+            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+
+            # Replace the environment variables
+            agent.tool_exec_environment_variables = [
+                AgentEnvironmentVariableModel(key=key, value=value, agent_id=agent_id, organization_id=actor.organization_id)
+                for key, value in env_vars.items()
+            ]
+
+            # Update the agent in the database
+            agent.update(session, actor=actor)
+
+            # Return the updated agent state
+            return agent.to_pydantic()
+
     # ======================================================================================================================
     # In Context Messages Management
     # ======================================================================================================================

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/services/sandbox_config_manager.py

@@ -5,11 +5,11 @@ from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.sandbox_config import SandboxConfig as SandboxConfigModel
 from letta.orm.sandbox_config import SandboxEnvironmentVariable as SandboxEnvVarModel
+from letta.schemas.environment_variables import SandboxEnvironmentVariable as PydanticEnvVar
+from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate
 from letta.schemas.sandbox_config import LocalSandboxConfig
 from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
-from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate
-from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticEnvVar
-from letta.schemas.sandbox_config import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate, SandboxType
+from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate, SandboxType
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types, printd
 

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/letta/services/tool_execution_sandbox.py

@@ -278,11 +278,14 @@ class ToolExecutionSandbox:
         sbx = self.get_running_e2b_sandbox_with_same_state(sbx_config)
         if not sbx or self.force_recreate:
             if not sbx:
-              logger.info(f"No running e2b sandbox found with the same state: {sbx_config}")
+                logger.info(f"No running e2b sandbox found with the same state: {sbx_config}")
             else:
-              logger.info(f"Force recreated e2b sandbox with state: {sbx_config}")
+                logger.info(f"Force recreated e2b sandbox with state: {sbx_config}")
             sbx = self.create_e2b_sandbox_with_metadata_hash(sandbox_config=sbx_config)
 
+        logger.info(f"E2B Sandbox configurations: {sbx_config}")
+        logger.info(f"E2B Sandbox ID: {sbx.sandbox_id}")
+
         # Since this sandbox was used, we extend its lifecycle by the timeout
         sbx.set_timeout(sbx_config.get_e2b_config().timeout)
 

{letta_nightly-0.6.7.dev20250106104119 → letta_nightly-0.6.7.dev20250106211813}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.7.dev20250106104119"
+version = "0.6.7.dev20250106211813"
 packages = [
     {include = "letta"}
 ]