letta-nightly 0.11.7.dev20250910104051__py3-none-any.whl → 0.11.7.dev20250911104039__py3-none-any.whl

letta/server/rest_api/routers/v1/agents.py

@@ -12,7 +12,9 @@ from pydantic import BaseModel, Field
 from sqlalchemy.exc import IntegrityError, OperationalError
 from starlette.responses import Response, StreamingResponse
 
+from letta.agents.agent_loop import AgentLoop
 from letta.agents.letta_agent import LettaAgent
+from letta.agents.letta_agent_v2 import LettaAgentV2
 from letta.constants import AGENT_ID_PATTERN, DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REDIS_RUN_ID_PREFIX
 from letta.data_sources.redis_client import NoopAsyncRedisClient, get_redis_client
 from letta.errors import (
@@ -58,7 +60,7 @@ from letta.server.server import SyncServer
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.telemetry_manager import NoopTelemetryManager
 from letta.settings import settings
-from letta.utils import safe_create_task, truncate_file_visible_content
+from letta.utils import safe_create_shielded_task, safe_create_task, truncate_file_visible_content
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -1144,7 +1146,9 @@ async def send_message(
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent = await server.agent_manager.get_agent_by_id_async(
+        agent_id, actor, include_relationships=["memory", "multi_agent_group", "sources", "tool_exec_environment_variables", "tools"]
+    )
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in [
         "anthropic",
@@ -1190,42 +1194,11 @@ async def send_message(
 
     try:
         if agent_eligible and model_compatible:
-            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
-                agent_loop = SleeptimeMultiAgentV2(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    passage_manager=server.passage_manager,
-                    group_manager=server.group_manager,
-                    job_manager=server.job_manager,
-                    actor=actor,
-                    group=agent.multi_agent_group,
-                    current_run_id=run.id if run else None,
-                )
-            else:
-                agent_loop = LettaAgent(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    job_manager=server.job_manager,
-                    passage_manager=server.passage_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    current_run_id=run.id if run else None,
-                    # summarizer settings to be added here
-                    summarizer_mode=(
-                        SummarizationMode.STATIC_MESSAGE_BUFFER
-                        if agent.agent_type == AgentType.voice_convo_agent
-                        else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                    ),
-                )
-
+            agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
             result = await agent_loop.step(
                 request.messages,
                 max_steps=request.max_steps,
+                run_id=run.id if run else None,
                 use_assistant_message=request.use_assistant_message,
                 request_start_timestamp_ns=request_start_timestamp_ns,
                 include_return_message_types=request.include_return_message_types,
@@ -1299,7 +1272,9 @@ async def send_message_streaming(
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    agent = await server.agent_manager.get_agent_by_id_async(
+        agent_id, actor, include_relationships=["memory", "multi_agent_group", "sources", "tool_exec_environment_variables", "tools"]
+    )
     agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in [
         "anthropic",
@@ -1344,57 +1319,16 @@ async def send_message_streaming(
 
     try:
         if agent_eligible and model_compatible:
-            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
-                agent_loop = SleeptimeMultiAgentV2(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    passage_manager=server.passage_manager,
-                    group_manager=server.group_manager,
-                    job_manager=server.job_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    group=agent.multi_agent_group,
-                    current_run_id=run.id if run else None,
-                )
-            else:
-                agent_loop = LettaAgent(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    job_manager=server.job_manager,
-                    passage_manager=server.passage_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    current_run_id=run.id if run else None,
-                    # summarizer settings to be added here
-                    summarizer_mode=(
-                        SummarizationMode.STATIC_MESSAGE_BUFFER
-                        if agent.agent_type == AgentType.voice_convo_agent
-                        else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                    ),
-                )
-
-            if request.stream_tokens and model_compatible_token_streaming:
-                raw_stream = agent_loop.step_stream(
-                    input_messages=request.messages,
-                    max_steps=request.max_steps,
-                    use_assistant_message=request.use_assistant_message,
-                    request_start_timestamp_ns=request_start_timestamp_ns,
-                    include_return_message_types=request.include_return_message_types,
-                )
-            else:
-                raw_stream = agent_loop.step_stream_no_tokens(
-                    request.messages,
-                    max_steps=request.max_steps,
-                    use_assistant_message=request.use_assistant_message,
-                    request_start_timestamp_ns=request_start_timestamp_ns,
-                    include_return_message_types=request.include_return_message_types,
-                )
+            agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
+            raw_stream = agent_loop.stream(
+                input_messages=request.messages,
+                max_steps=request.max_steps,
+                stream_tokens=request.stream_tokens and model_compatible_token_streaming,
+                run_id=run.id if run else None,
+                use_assistant_message=request.use_assistant_message,
+                request_start_timestamp_ns=request_start_timestamp_ns,
+                include_return_message_types=request.include_return_message_types,
+            )
 
             from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode, add_keepalive_to_stream
 
@@ -1409,12 +1343,13 @@ async def send_message_streaming(
                         ),
                     )
 
-                asyncio.create_task(
+                safe_create_task(
                     create_background_stream_processor(
                         stream_generator=raw_stream,
                         redis_client=redis_client,
                         run_id=run.id,
-                    )
+                    ),
+                    label=f"background_stream_processor_{run.id}",
                 )
 
                 raw_stream = redis_sse_stream_generator(
@@ -1568,7 +1503,9 @@ async def _process_message_background(
     """Background task to process the message and update job status."""
     request_start_timestamp_ns = get_utc_timestamp_ns()
     try:
-        agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+        agent = await server.agent_manager.get_agent_by_id_async(
+            agent_id, actor, include_relationships=["memory", "multi_agent_group", "sources", "tool_exec_environment_variables", "tools"]
+        )
         agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
         model_compatible = agent.llm_config.model_endpoint_type in [
             "anthropic",
@@ -1584,37 +1521,7 @@ async def _process_message_background(
             "deepseek",
         ]
         if agent_eligible and model_compatible:
-            if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
-                agent_loop = SleeptimeMultiAgentV2(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    passage_manager=server.passage_manager,
-                    group_manager=server.group_manager,
-                    job_manager=server.job_manager,
-                    actor=actor,
-                    group=agent.multi_agent_group,
-                )
-            else:
-                agent_loop = LettaAgent(
-                    agent_id=agent_id,
-                    message_manager=server.message_manager,
-                    agent_manager=server.agent_manager,
-                    block_manager=server.block_manager,
-                    job_manager=server.job_manager,
-                    passage_manager=server.passage_manager,
-                    actor=actor,
-                    step_manager=server.step_manager,
-                    telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                    # summarizer settings to be added here
-                    summarizer_mode=(
-                        SummarizationMode.STATIC_MESSAGE_BUFFER
-                        if agent.agent_type == AgentType.voice_convo_agent
-                        else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                    ),
-                )
-
+            agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
             result = await agent_loop.step(
                 messages,
                 max_steps=max_steps,
@@ -1702,8 +1609,8 @@ async def send_message_async(
     )
     run = await server.job_manager.create_job_async(pydantic_job=run, actor=actor)
 
-    # Create asyncio task for background processing
-    task = asyncio.create_task(
+    # Create asyncio task for background processing (shielded to prevent cancellation)
+    task = safe_create_shielded_task(
         _process_message_background(
             run_id=run.id,
             server=server,
@@ -1715,28 +1622,20 @@ async def send_message_async(
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
             max_steps=request.max_steps,
             include_return_message_types=request.include_return_message_types,
-        )
+        ),
+        label=f"process_message_background_{run.id}",
     )
 
     def handle_task_completion(t):
         try:
             t.result()
         except asyncio.CancelledError:
-            logger.error(f"Background task for run {run.id} was cancelled")
-            asyncio.create_task(
-                server.job_manager.update_job_by_id_async(
-                    job_id=run.id,
-                    job_update=JobUpdate(
-                        status=JobStatus.failed,
-                        completed_at=datetime.now(timezone.utc),
-                        metadata={"error": "Task was cancelled"},
-                    ),
-                    actor=actor,
-                )
-            )
+            # Note: With shielded tasks, cancellation attempts don't actually stop the task
+            logger.info(f"Cancellation attempted on shielded background task for run {run.id}, but task continues running")
+            # Don't mark as failed since the shielded task is still running
         except Exception as e:
             logger.error(f"Unhandled exception in background task for run {run.id}: {e}")
-            asyncio.create_task(
+            safe_create_task(
                 server.job_manager.update_job_by_id_async(
                     job_id=run.id,
                     job_update=JobUpdate(
@@ -1745,7 +1644,8 @@ async def send_message_async(
                         metadata={"error": str(e)},
                     ),
                     actor=actor,
-                )
+                ),
+                label=f"update_failed_job_{run.id}",
             )
 
     task.add_done_callback(handle_task_completion)
@@ -1816,38 +1716,10 @@ async def preview_raw_payload(
     ]
 
     if agent_eligible and model_compatible:
-        if agent.enable_sleeptime:
-            # TODO: @caren need to support this for sleeptime
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Payload inspection is not supported for agents with sleeptime enabled.",
-            )
-        else:
-            agent_loop = LettaAgent(
-                agent_id=agent_id,
-                message_manager=server.message_manager,
-                agent_manager=server.agent_manager,
-                block_manager=server.block_manager,
-                job_manager=server.job_manager,
-                passage_manager=server.passage_manager,
-                actor=actor,
-                step_manager=server.step_manager,
-                telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-                summarizer_mode=(
-                    SummarizationMode.STATIC_MESSAGE_BUFFER
-                    if agent.agent_type == AgentType.voice_convo_agent
-                    else SummarizationMode.PARTIAL_EVICT_MESSAGE_BUFFER
-                ),
-            )
-
-        # TODO: Support step_streaming
-        return await agent_loop.step(
+        agent_loop = AgentLoop.load(agent_state=agent, actor=actor)
+        return await agent_loop.build_request(
             input_messages=request.messages,
-            use_assistant_message=request.use_assistant_message,
-            include_return_message_types=request.include_return_message_types,
-            dry_run=True,
         )
-
     else:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -1888,19 +1760,14 @@ async def summarize_agent_conversation(
     ]
 
     if agent_eligible and model_compatible:
-        agent = LettaAgent(
-            agent_id=agent_id,
-            message_manager=server.message_manager,
-            agent_manager=server.agent_manager,
-            block_manager=server.block_manager,
-            job_manager=server.job_manager,
-            passage_manager=server.passage_manager,
-            actor=actor,
-            step_manager=server.step_manager,
-            telemetry_manager=server.telemetry_manager if settings.llm_api_logging else NoopTelemetryManager(),
-            message_buffer_min=max_message_length,
+        agent_loop = LettaAgentV2(agent_state=agent, actor=actor)
+        in_context_messages = await server.message_manager.get_messages_by_ids_async(message_ids=agent.message_ids, actor=actor)
+        await agent_loop.summarize_conversation_history(
+            in_context_messages=in_context_messages,
+            new_letta_messages=[],
+            total_tokens=None,
+            force=True,
         )
-        await agent.summarize_conversation_history()
         # Summarization completed, return 204 No Content
     else:
         raise HTTPException(

letta/server/rest_api/routers/v1/folders.py

@@ -327,7 +327,7 @@ async def upload_file_to_folder(
         logger=logger,
         label="file_processor.process",
     )
-    safe_create_task(sleeptime_document_ingest_async(server, folder_id, actor), logger=logger, label="sleeptime_document_ingest_async")
+    safe_create_task(sleeptime_document_ingest_async(server, folder_id, actor), label="sleeptime_document_ingest_async")
 
     return file_metadata
 
@@ -467,7 +467,7 @@ async def delete_file_from_folder(
         logger.info(f"Deleting file {file_id} from pinecone index")
         await delete_file_records_from_pinecone_index(file_id=file_id, actor=actor)
 
-    asyncio.create_task(sleeptime_document_ingest_async(server, folder_id, actor, clear_history=True))
+    safe_create_task(sleeptime_document_ingest_async(server, folder_id, actor, clear_history=True), label="document_ingest_after_delete")
     if deleted_file is None:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 

letta/server/rest_api/routers/v1/sources.py

@@ -325,7 +325,7 @@ async def upload_file_to_source(
         logger=logger,
         label="file_processor.process",
     )
-    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), logger=logger, label="sleeptime_document_ingest_async")
+    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor), label="sleeptime_document_ingest_async")
 
     return file_metadata
 
@@ -452,7 +452,7 @@ async def delete_file_from_source(
         logger.info(f"Deleting file {file_id} from pinecone index")
         await delete_file_records_from_pinecone_index(file_id=file_id, actor=actor)
 
-    asyncio.create_task(sleeptime_document_ingest_async(server, source_id, actor, clear_history=True))
+    safe_create_task(sleeptime_document_ingest_async(server, source_id, actor, clear_history=True), label="document_ingest_after_delete")
     if deleted_file is None:
         raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
 

letta/server/rest_api/streaming_response.py

@@ -19,6 +19,7 @@ from letta.schemas.user import User
 from letta.server.rest_api.utils import capture_sentry_exception
 from letta.services.job_manager import JobManager
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -64,7 +65,7 @@ async def add_keepalive_to_stream(
             await queue.put(("end", None))
 
     # Start the stream reader task
-    reader_task = asyncio.create_task(stream_reader())
+    reader_task = safe_create_task(stream_reader(), label="stream_reader")
 
     try:
         while True:

letta/server/server.py

@@ -109,7 +109,7 @@ from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import DatabaseChoice, model_settings, settings, tool_settings
 from letta.streaming_interface import AgentChunkStreamingInterface
-from letta.utils import get_friendly_error_msg, get_persona_text, make_key
+from letta.utils import get_friendly_error_msg, get_persona_text, make_key, safe_create_task
 
 config = LettaConfig.load()
 logger = get_logger(__name__)
@@ -2248,7 +2248,7 @@ class SyncServer(Server):
 
             # Offload the synchronous message_func to a separate thread
             streaming_interface.stream_start()
-            task = asyncio.create_task(
+            task = safe_create_task(
                 asyncio.to_thread(
                     self.send_messages,
                     actor=actor,
@@ -2256,7 +2256,8 @@ class SyncServer(Server):
                     input_messages=input_messages,
                     interface=streaming_interface,
                     metadata=metadata,
-                )
+                ),
+                label="send_messages_thread",
             )
 
             if stream_steps:
@@ -2363,13 +2364,14 @@ class SyncServer(Server):
             streaming_interface.metadata = metadata
 
         streaming_interface.stream_start()
-        task = asyncio.create_task(
+        task = safe_create_task(
             asyncio.to_thread(
                 letta_multi_agent.step,
                 input_messages=input_messages,
                 chaining=self.chaining,
                 max_chaining_steps=self.max_chaining_steps,
-            )
+            ),
+            label="multi_agent_step_thread",
         )
 
         if stream_steps:

letta/services/agent_serialization_manager.py

@@ -53,7 +53,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
 from letta.settings import settings
-from letta.utils import get_latest_alembic_revision
+from letta.utils import get_latest_alembic_revision, safe_create_task
 
 logger = get_logger(__name__)
 
@@ -622,10 +622,11 @@ class AgentSerializationManager:
 
                         # Create background task for file processing
                         # TODO: This can be moved to celery or RQ or something
-                        task = asyncio.create_task(
+                        task = safe_create_task(
                             self._process_file_async(
                                 file_metadata=file_metadata, source_id=source_db_id, file_processor=file_processor, actor=actor
-                            )
+                            ),
+                            label=f"process_file_{file_metadata.file_name}",
                         )
                         background_tasks.append(task)
                         logger.info(f"Started background processing for file {file_metadata.file_name} (ID: {file_db_id})")

letta/services/mcp_manager.py

@@ -43,7 +43,7 @@ from letta.services.mcp.stdio_client import AsyncStdioMCPClient
 from letta.services.mcp.streamable_http_client import AsyncStreamableHTTPMCPClient
 from letta.services.tool_manager import ToolManager
 from letta.settings import tool_settings
-from letta.utils import enforce_types, printd
+from letta.utils import enforce_types, printd, safe_create_task
 
 logger = get_logger(__name__)
 
@@ -869,7 +869,7 @@ class MCPManager:
 
             # Run connect_to_server in background to avoid blocking
             # This will trigger the OAuth flow and the redirect_handler will save the authorization URL to database
-            connect_task = asyncio.create_task(temp_client.connect_to_server())
+            connect_task = safe_create_task(temp_client.connect_to_server(), label="mcp_oauth_connect")
 
             # Give the OAuth flow time to trigger and save the URL
             await asyncio.sleep(1.0)

letta/services/summarizer/summarizer.py

@@ -20,6 +20,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.system import package_summarize_message_no_counts
 from letta.templates.template_helper import render_template
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -100,7 +101,7 @@ class Summarizer:
             return in_context_messages, False
 
     def fire_and_forget(self, coro):
-        task = asyncio.create_task(coro)
+        task = safe_create_task(coro, label="summarizer_background_task")
 
         def callback(t):
             try:

letta/services/tool_executor/multi_agent_tool_executor.py

@@ -13,6 +13,7 @@ from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -55,7 +56,8 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             f"{message}"
         )
 
-        return str(await self._process_agent(agent_id=other_agent_id, message=augmented_message))
+        other_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=other_agent_id, actor=self.actor)
+        return str(await self._process_agent(agent_state=other_agent_state, message=augmented_message))
 
     async def send_message_to_agents_matching_tags_async(
         self, agent_state: AgentState, message: str, match_all: List[str], match_some: List[str]
@@ -75,22 +77,20 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
         )
 
         tasks = [
-            asyncio.create_task(self._process_agent(agent_id=agent_state.id, message=augmented_message)) for agent_state in matching_agents
+            safe_create_task(
+                self._process_agent(agent_state=agent_state, message=augmented_message), label=f"process_agent_{agent_state.id}"
+            )
+            for agent_state in matching_agents
         ]
         results = await asyncio.gather(*tasks)
         return str(results)
 
-    async def _process_agent(self, agent_id: str, message: str) -> Dict[str, Any]:
-        from letta.agents.letta_agent import LettaAgent
+    async def _process_agent(self, agent_state: AgentState, message: str) -> Dict[str, Any]:
+        from letta.agents.letta_agent_v2 import LettaAgentV2
 
         try:
-            letta_agent = LettaAgent(
-                agent_id=agent_id,
-                message_manager=self.message_manager,
-                agent_manager=self.agent_manager,
-                block_manager=self.block_manager,
-                job_manager=self.job_manager,
-                passage_manager=self.passage_manager,
+            letta_agent = LettaAgentV2(
+                agent_state=agent_state,
                 actor=self.actor,
             )
 
@@ -100,13 +100,13 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             send_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]
 
             return {
-                "agent_id": agent_id,
+                "agent_id": agent_state.id,
                 "response": send_message_content if send_message_content else ["<no response>"],
             }
 
         except Exception as e:
             return {
-                "agent_id": agent_id,
+                "agent_id": agent_state.id,
                 "error": str(e),
                 "type": type(e).__name__,
             }
@@ -123,7 +123,10 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             f"{message}"
         )
 
-        task = asyncio.create_task(self._process_agent(agent_id=other_agent_id, message=prefixed))
+        other_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=other_agent_id, actor=self.actor)
+        task = safe_create_task(
+            self._process_agent(agent_state=other_agent_state, message=prefixed), label=f"send_message_to_{other_agent_id}"
+        )
 
         task.add_done_callback(lambda t: (logger.error(f"Async send_message task failed: {t.exception()}") if t.exception() else None))
 

letta/services/tool_sandbox/local_sandbox.py

@@ -23,7 +23,7 @@ from letta.services.helpers.tool_execution_helper import (
 from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.settings import tool_settings
-from letta.utils import get_friendly_error_msg, parse_stderr_error_msg
+from letta.utils import get_friendly_error_msg, parse_stderr_error_msg, safe_create_task
 
 logger = get_logger(__name__)
 
@@ -89,7 +89,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         venv_preparation_task = None
         if use_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))
+            venv_preparation_task = safe_create_task(self._prepare_venv(local_configs, venv_path, env), label="prepare_venv")
 
         # Generate and write execution script (always with markers, since we rely on stdout)
         code = await self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)

letta/services/tool_sandbox/modal_version_manager.py

@@ -16,6 +16,7 @@ from letta.log import get_logger
 from letta.schemas.tool import ToolUpdate
 from letta.services.tool_manager import ToolManager
 from letta.services.tool_sandbox.modal_constants import CACHE_TTL_SECONDS, DEFAULT_CONFIG_KEY, MODAL_DEPLOYMENTS_KEY
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -197,7 +198,7 @@ class ModalVersionManager:
         if deployment_key in self._deployments_in_progress:
             self._deployments_in_progress[deployment_key].set()
             # Clean up after a short delay to allow waiters to wake up
-            asyncio.create_task(self._cleanup_deployment_marker(deployment_key))
+            safe_create_task(self._cleanup_deployment_marker(deployment_key), label=f"cleanup_deployment_{deployment_key}")
 
     async def _cleanup_deployment_marker(self, deployment_key: str):
         """Clean up deployment marker after a delay."""