letta-nightly 0.7.3.dev20250424104224__tar.gz → 0.7.5.dev20250425010311__tar.gz

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/PKG-INFO

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

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.3"
+__version__ = "0.7.5"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/agent.py

@@ -190,16 +190,15 @@ class Agent(BaseAgent):
         Returns:
             modified (bool): whether the memory was updated
         """
-        if self.agent_state.memory.compile() != new_memory.compile():
+        system_message = self.message_manager.get_message_by_id(message_id=self.agent_state.message_ids[0], actor=self.user)
+        if new_memory.compile() not in system_message.content[0].text:
             # update the blocks (LRW) in the DB
             for label in self.agent_state.memory.list_block_labels():
                 updated_value = new_memory.get_block(label).value
                 if updated_value != self.agent_state.memory.get_block(label).value:
                     # update the block if it's changed
                     block_id = self.agent_state.memory.get_block(label).id
-                    block = self.block_manager.update_block(
-                        block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=self.user
-                    )
+                    self.block_manager.update_block(block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=self.user)
 
             # refresh memory from DB (using block ids)
             self.agent_state.memory = Memory(

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/groups/sleeptime_multi_agent.py

@@ -43,24 +43,21 @@ class SleeptimeMultiAgent(Agent):
 
     def _run_async_in_new_thread(self, coro):
         """Run an async coroutine in a new thread with its own event loop"""
-        result = None
 
         def run_async():
-            nonlocal result
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
             try:
-                result = loop.run_until_complete(coro)
+                loop.run_until_complete(coro)
             finally:
                 loop.close()
                 asyncio.set_event_loop(None)
 
         thread = threading.Thread(target=run_async)
+        thread.daemon = True
         thread.start()
-        thread.join()
-        return result
 
-    async def _issue_background_task(
+    def _issue_background_task(
         self,
         participant_agent_id: str,
         messages: List[Message],
@@ -81,7 +78,7 @@ class SleeptimeMultiAgent(Agent):
         )
         run = self.job_manager.create_job(pydantic_job=run, actor=self.user)
 
-        asyncio.create_task(
+        self._run_async_in_new_thread(
             self._perform_background_agent_step(
                 participant_agent_id=participant_agent_id,
                 messages=messages,
@@ -239,17 +236,15 @@ class SleeptimeMultiAgent(Agent):
                 )
                 for participant_agent_id in self.agent_ids:
                     try:
-                        run_id = self._run_async_in_new_thread(
-                            self._issue_background_task(
-                                participant_agent_id,
-                                last_response_messages,
-                                chaining,
-                                max_chaining_steps,
-                                token_streaming,
-                                metadata,
-                                put_inner_thoughts_first,
-                                last_processed_message_id,
-                            )
+                        run_id = self._issue_background_task(
+                            participant_agent_id,
+                            last_response_messages,
+                            chaining,
+                            max_chaining_steps,
+                            token_streaming,
+                            metadata,
+                            put_inner_thoughts_first,
+                            last_processed_message_id,
                         )
                         run_ids.append(run_id)
 

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/schemas/message.py

@@ -699,6 +699,10 @@ class Message(BaseMessage):
         else:
             raise ValueError(self.role)
 
+        # Optional field, do not include if null
+        if self.name is not None:
+            openai_message["name"] = self.name
+
         if parse_content_parts:
             for content in self.content:
                 if isinstance(content, ReasoningContent):

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/schemas/providers.py

@@ -1233,7 +1233,10 @@ class AzureProvider(Provider):
         """
         This is hardcoded for now, since there is no API endpoints to retrieve metadata for a model.
         """
-        return AZURE_MODEL_TO_CONTEXT_LENGTH.get(model_name, 4096)
+        context_window = AZURE_MODEL_TO_CONTEXT_LENGTH.get(model_name, None)
+        if context_window is None:
+            context_window = LLM_MAX_TOKENS.get(model_name, 4096)
+        return context_window
 
 
 class VLLMChatCompletionsProvider(Provider):

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/schemas/sandbox_config.py

@@ -47,14 +47,14 @@ class PipRequirement(BaseModel):
 
 class LocalSandboxConfig(BaseModel):
     sandbox_dir: Optional[str] = Field(None, description="Directory for the sandbox environment.")
-    use_venv: bool = Field(False, description="Whether or not to use the venv, or run directly in the same run loop.")
+    force_create_venv: bool = Field(False, description="Whether or not to use the venv, or run directly in the same run loop.")
     venv_name: str = Field(
         "venv",
         description="The name for the venv in the sandbox directory. We first search for an existing venv with this name, otherwise, we make it from the requirements.txt.",
     )
     pip_requirements: List[PipRequirement] = Field(
         default_factory=list,
-        description="List of pip packages to install with mandatory name and optional version following semantic versioning. This only is considered when use_venv is True.",
+        description="List of pip packages to install with mandatory name and optional version following semantic versioning. This only is considered when force_create_venv is True.",
     )
 
     @property

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/server/rest_api/routers/v1/agents.py

@@ -104,6 +104,17 @@ def list_agents(
     )
 
 
+@router.get("/count", response_model=int, operation_id="count_agents")
+def count_agents(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get the count of all agents associated with a given user.
+    """
+    return server.agent_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 class IndentedORJSONResponse(Response):
     media_type = "application/json"
 

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/server/rest_api/routers/v1/identities.py

@@ -49,6 +49,24 @@ def list_identities(
     return identities
 
 
+@router.get("/count", tags=["identities"], response_model=int, operation_id="count_identities")
+def count_identities(
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get count of all identities for a user
+    """
+    try:
+        return server.identity_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    except NoResultFound:
+        return 0
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
 @router.get("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="retrieve_identity")
 def retrieve_identity(
     identity_id: str,

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/server/rest_api/routers/v1/sources.py

@@ -67,6 +67,17 @@ def list_sources(
     return server.list_all_sources(actor=actor)
 
 
+@router.get("/count", response_model=int, operation_id="count_sources")
+def count_sources(
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Count all data sources created by a user.
+    """
+    return server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 @router.post("/", response_model=Source, operation_id="create_source")
 def create_source(
     source_create: SourceCreate,

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/server/rest_api/routers/v1/tools.py

@@ -80,6 +80,21 @@ def list_tools(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+@router.get("/count", response_model=int, operation_id="count_tools")
+def count_tools(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get a count of all tools available to agents belonging to the org of the user
+    """
+    try:
+        return server.tool_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+    except Exception as e:
+        print(f"Error occurred: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @router.post("/", response_model=Tool, operation_id="create_tool")
 def create_tool(
     request: ToolCreate = Body(...),

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/agent_manager.py

@@ -556,6 +556,16 @@ class AgentManager:
 
             return list(session.execute(query).scalars())
 
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of agents for the given user.
+        """
+        with self.session_maker() as session:
+            return AgentModel.size(db_session=session, actor=actor)
+
     @enforce_types
     def get_agent_by_id(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         """Fetch an agent by its ID."""
@@ -590,15 +600,18 @@ class AgentManager:
             agents_to_delete = [agent]
             sleeptime_group_to_delete = None
 
-            # Delete sleeptime agent and group
+            # Delete sleeptime agent and group (TODO this is flimsy pls fix)
             if agent.multi_agent_group:
                 participant_agent_ids = agent.multi_agent_group.agent_ids
                 if agent.multi_agent_group.manager_type == ManagerType.sleeptime and len(participant_agent_ids) == 1:
-                    sleeptime_agent = AgentModel.read(db_session=session, identifier=participant_agent_ids[0], actor=actor)
-                    if sleeptime_agent.agent_type == AgentType.sleeptime_agent:
-                        sleeptime_agent_group = GroupModel.read(db_session=session, identifier=agent.multi_agent_group.id, actor=actor)
-                        sleeptime_group_to_delete = sleeptime_agent_group
+                    try:
+                        sleeptime_agent = AgentModel.read(db_session=session, identifier=participant_agent_ids[0], actor=actor)
                         agents_to_delete.append(sleeptime_agent)
+                    except NoResultFound:
+                        pass  # agent already deleted
+                    sleeptime_agent_group = GroupModel.read(db_session=session, identifier=agent.multi_agent_group.id, actor=actor)
+                    sleeptime_group_to_delete = sleeptime_agent_group
+
             try:
                 if sleeptime_group_to_delete is not None:
                     session.delete(sleeptime_group_to_delete)
@@ -931,7 +944,8 @@ class AgentManager:
             modified (bool): whether the memory was updated
         """
         agent_state = self.get_agent_by_id(agent_id=agent_id, actor=actor)
-        if agent_state.memory.compile() != new_memory.compile():
+        system_message = self.message_manager.get_message_by_id(message_id=agent_state.message_ids[0], actor=actor)
+        if new_memory.compile() not in system_message.content[0].text:
             # update the blocks (LRW) in the DB
             for label in agent_state.memory.list_block_labels():
                 updated_value = new_memory.get_block(label).value

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/helpers/tool_execution_helper.py

@@ -24,7 +24,7 @@ def find_python_executable(local_configs: LocalSandboxConfig) -> str:
     """
     sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)  # Expand tilde
 
-    if not local_configs.use_venv:
+    if not local_configs.force_create_venv:
         return "python.exe" if platform.system().lower().startswith("win") else "python3"
 
     venv_path = os.path.join(sandbox_dir, local_configs.venv_name)
@@ -96,7 +96,7 @@ def install_pip_requirements_for_sandbox(
     python_exec = find_python_executable(local_configs)
 
     # If using a virtual environment, upgrade pip before installing dependencies.
-    if local_configs.use_venv:
+    if local_configs.force_create_venv:
         ensure_pip_is_up_to_date(python_exec, env=env)
 
     # Construct package list
@@ -108,7 +108,7 @@ def install_pip_requirements_for_sandbox(
         pip_cmd.append("--upgrade")
     pip_cmd += packages
 
-    if user_install_if_no_venv and not local_configs.use_venv:
+    if user_install_if_no_venv and not local_configs.force_create_venv:
         pip_cmd.append("--user")
 
     run_subprocess(pip_cmd, env=env, fail_msg=f"Failed to install packages: {', '.join(packages)}")

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/identity_manager.py

@@ -190,6 +190,17 @@ class IdentityManager:
             session.delete(identity)
             session.commit()
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of identities for the given user.
+        """
+        with self.session_maker() as session:
+            return IdentityModel.size(db_session=session, actor=actor)
+
     def _process_relationship(
         self,
         session: Session,

letta_nightly-0.7.5.dev20250425010311/letta/services/mcp/base_client.py

@@ -0,0 +1,67 @@
+from contextlib import AsyncExitStack
+from typing import Optional, Tuple
+
+from mcp import ClientSession
+from mcp import Tool as MCPTool
+from mcp.types import TextContent
+
+from letta.functions.mcp_client.types import BaseServerConfig
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+# TODO: Get rid of Async prefix on this class name once we deprecate old sync code
+class AsyncBaseMCPClient:
+    def __init__(self, server_config: BaseServerConfig):
+        self.server_config = server_config
+        self.exit_stack = AsyncExitStack()
+        self.session: Optional[ClientSession] = None
+        self.initialized = False
+
+    async def connect_to_server(self):
+        try:
+            await self._initialize_connection(self.server_config)
+            await self.session.initialize()
+            self.initialized = True
+        except Exception as e:
+            logger.error(
+                f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
+            )
+            raise e
+
+    async def _initialize_connection(self, exit_stack: AsyncExitStack[bool | None], server_config: BaseServerConfig) -> None:
+        raise NotImplementedError("Subclasses must implement _initialize_connection")
+
+    async def list_tools(self) -> list[MCPTool]:
+        self._check_initialized()
+        response = await self.session.list_tools()
+        return response.tools
+
+    async def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
+        self._check_initialized()
+        result = await self.session.call_tool(tool_name, tool_args)
+        parsed_content = []
+        for content_piece in result.content:
+            if isinstance(content_piece, TextContent):
+                parsed_content.append(content_piece.text)
+                print("parsed_content (text)", parsed_content)
+            else:
+                parsed_content.append(str(content_piece))
+                print("parsed_content (other)", parsed_content)
+        if len(parsed_content) > 0:
+            final_content = " ".join(parsed_content)
+        else:
+            # TODO move hardcoding to constants
+            final_content = "Empty response from tool"
+
+        return final_content, result.isError
+
+    def _check_initialized(self):
+        if not self.initialized:
+            logger.error("MCPClient has not been initialized")
+            raise RuntimeError("MCPClient has not been initialized")
+
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.exit_stack.aclose()

letta_nightly-0.7.5.dev20250425010311/letta/services/mcp/sse_client.py

@@ -0,0 +1,25 @@
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+from letta.functions.mcp_client.types import SSEServerConfig
+from letta.log import get_logger
+from letta.services.mcp.base_client import AsyncBaseMCPClient
+
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
+logger = get_logger(__name__)
+
+
+# TODO: Get rid of Async prefix on this class name once we deprecate old sync code
+class AsyncSSEMCPClient(AsyncBaseMCPClient):
+    async def _initialize_connection(self, exit_stack: AsyncExitStack[bool | None], server_config: SSEServerConfig) -> None:
+        sse_cm = sse_client(url=server_config.server_url)
+        sse_transport = await exit_stack.enter_async_context(sse_cm)
+        self.stdio, self.write = sse_transport
+
+        # Create and enter the ClientSession context manager
+        session_cm = ClientSession(self.stdio, self.write)
+        self.session = await exit_stack.enter_async_context(session_cm)

letta_nightly-0.7.5.dev20250425010311/letta/services/mcp/stdio_client.py

@@ -0,0 +1,19 @@
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from letta.functions.mcp_client.types import StdioServerConfig
+from letta.log import get_logger
+from letta.services.mcp.base_client import AsyncBaseMCPClient
+
+logger = get_logger(__name__)
+
+
+# TODO: Get rid of Async prefix on this class name once we deprecate old sync code
+class AsyncStdioMCPClient(AsyncBaseMCPClient):
+    async def _initialize_connection(self, exit_stack: AsyncExitStack[bool | None], server_config: StdioServerConfig) -> None:
+        server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
+        stdio_transport = await exit_stack.enter_async_context(stdio_client(server_params))
+        self.stdio, self.write = stdio_transport
+        self.session = await exit_stack.enter_async_context(ClientSession(self.stdio, self.write))

letta_nightly-0.7.5.dev20250425010311/letta/services/mcp/types.py

@@ -0,0 +1,48 @@
+from enum import Enum
+from typing import List, Optional
+
+from mcp import Tool
+from pydantic import BaseModel, Field
+
+
+class MCPTool(Tool):
+    """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""
+
+
+class MCPServerType(str, Enum):
+    SSE = "sse"
+    STDIO = "stdio"
+
+
+class BaseServerConfig(BaseModel):
+    server_name: str = Field(..., description="The name of the server")
+    type: MCPServerType
+
+
+class SSEServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.SSE
+    server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "sse",
+            "url": self.server_url,
+        }
+        return values
+
+
+class StdioServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.STDIO
+    command: str = Field(..., description="The command to run (MCP 'local' client will run this command)")
+    args: List[str] = Field(..., description="The arguments to pass to the command")
+    env: Optional[dict[str, str]] = Field(None, description="Environment variables to set")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "stdio",
+            "command": self.command,
+            "args": self.args,
+        }
+        if self.env is not None:
+            values["env"] = self.env
+        return values

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/source_manager.py

@@ -77,6 +77,17 @@ class SourceManager:
             )
             return [source.to_pydantic() for source in sources]
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of sources for the given user.
+        """
+        with self.session_maker() as session:
+            return SourceModel.size(db_session=session, actor=actor)
+
     @enforce_types
     def list_attached_agents(self, source_id: str, actor: Optional[PydanticUser] = None) -> List[PydanticAgentState]:
         """

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/tool_executor/tool_execution_sandbox.py

@@ -144,7 +144,7 @@ class ToolExecutionSandbox:
 
         # Write the code to a temp file in the sandbox_dir
         with tempfile.NamedTemporaryFile(mode="w", dir=local_configs.sandbox_dir, suffix=".py", delete=False) as temp_file:
-            if local_configs.use_venv:
+            if local_configs.force_create_venv:
                 # If using venv, we need to wrap with special string markers to separate out the output and the stdout (since it is all in stdout)
                 code = self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)
             else:
@@ -154,7 +154,7 @@ class ToolExecutionSandbox:
             temp_file.flush()
             temp_file_path = temp_file.name
         try:
-            if local_configs.use_venv:
+            if local_configs.force_create_venv:
                 return self.run_local_dir_sandbox_venv(sbx_config, env, temp_file_path)
             else:
                 return self.run_local_dir_sandbox_directly(sbx_config, env, temp_file_path)
@@ -204,12 +204,7 @@ class ToolExecutionSandbox:
         try:
             log_event(name="start subprocess")
             result = subprocess.run(
-                [python_executable, temp_file_path],
-                env=env,
-                cwd=sandbox_dir,
-                timeout=60,
-                capture_output=True,
-                text=True,
+                [python_executable, temp_file_path], env=env, cwd=sandbox_dir, timeout=60, capture_output=True, text=True, check=True
             )
             log_event(name="finish subprocess")
             func_result, stdout = self.parse_out_function_results_markers(result.stdout)
@@ -272,7 +267,7 @@ class ToolExecutionSandbox:
                     source = f.read()
                 code_obj = compile(source, temp_file_path, "exec")
 
-                # Provide a dict for globals
+                # Provide a dict for globals.
                 globals_dict = dict(env)  # or {}
                 # If you need to mimic `__main__` behavior:
                 globals_dict["__name__"] = "__main__"

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/tool_manager.py

@@ -145,6 +145,17 @@ class ToolManager:
 
         return results
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of tools for the given user.
+        """
+        with self.session_maker() as session:
+            return ToolModel.size(db_session=session, actor=actor)
+
     @enforce_types
     def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> PydanticTool:
         """Update a tool by its ID with the given ToolUpdate object."""

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/letta/services/tool_sandbox/local_sandbox.py

@@ -69,7 +69,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         else:
             sbx_config = self.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=self.user)
         local_configs = sbx_config.get_local_config()
-        use_venv = local_configs.use_venv
+        force_create_venv = local_configs.force_create_venv
 
         # Prepare environment variables
         env = os.environ.copy()
@@ -92,7 +92,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
 
         # If using a virtual environment, ensure it's prepared in parallel
         venv_preparation_task = None
-        if use_venv:
+        if force_create_venv:
             venv_path = str(os.path.join(sandbox_dir, local_configs.venv_name))
             venv_preparation_task = asyncio.create_task(self._prepare_venv(local_configs, venv_path, env))
 
@@ -110,7 +110,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
 
             # Determine the python executable and environment for the subprocess
             exec_env = env.copy()
-            if use_venv:
+            if force_create_venv:
                 venv_path = str(os.path.join(sandbox_dir, local_configs.venv_name))
                 python_executable = find_python_executable(local_configs)
                 exec_env["VIRTUAL_ENV"] = venv_path

{letta_nightly-0.7.3.dev20250424104224 → letta_nightly-0.7.5.dev20250425010311}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.7.3.dev20250424104224"
+version = "0.7.5.dev20250425010311"
 packages = [
     {include = "letta"},
 ]