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

letta/orm/sources_agents.py

@@ -1,4 +1,4 @@
-from sqlalchemy import ForeignKey, String
+from sqlalchemy import ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm.base import Base
@@ -8,6 +8,7 @@ class SourcesAgents(Base):
     """Agents can have zero to many sources"""
 
     __tablename__ = "sources_agents"
+    __table_args__ = (Index("ix_sources_agents_source_id", "source_id"),)
 
     agent_id: Mapped[String] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True)
     source_id: Mapped[String] = mapped_column(String, ForeignKey("sources.id", ondelete="CASCADE"), primary_key=True)

letta/orm/tools_agents.py

@@ -1,4 +1,4 @@
-from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy import ForeignKey, Index, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm import Base
@@ -8,7 +8,10 @@ class ToolsAgents(Base):
     """Agents can have one or many tools associated with them."""
 
     __tablename__ = "tools_agents"
-    __table_args__ = (UniqueConstraint("agent_id", "tool_id", name="unique_agent_tool"),)
+    __table_args__ = (
+        UniqueConstraint("agent_id", "tool_id", name="unique_agent_tool"),
+        Index("ix_tools_agents_tool_id", "tool_id"),
+    )
 
     # Each agent must have unique tool names
     agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True)

letta/schemas/message.py

@@ -1027,10 +1027,13 @@ class Message(BaseMessage):
         result = [m for m in result if m is not None]
         return result
 
-    def to_google_ai_dict(self, put_inner_thoughts_in_kwargs: bool = True) -> dict:
+    def to_google_dict(self, put_inner_thoughts_in_kwargs: bool = True) -> dict | None:
         """
         Go from Message class to Google AI REST message object
         """
+        if self.role == "approval" and self.tool_calls is None:
+            return None
+
         # type Content: https://ai.google.dev/api/rest/v1/Content / https://ai.google.dev/api/rest/v1beta/Content
         #     parts[]: Part
         #     role: str ('user' or 'model')
@@ -1076,7 +1079,7 @@ class Message(BaseMessage):
                 "parts": content_parts,
             }
 
-        elif self.role == "assistant":
+        elif self.role == "assistant" or self.role == "approval":
             assert self.tool_calls is not None or text_content is not None
             google_ai_message = {
                 "role": "model",  # NOTE: different
@@ -1164,6 +1167,20 @@ class Message(BaseMessage):
 
         return google_ai_message
 
+    @staticmethod
+    def to_google_dicts_from_list(
+        messages: List[Message],
+        put_inner_thoughts_in_kwargs: bool = True,
+    ):
+        result = [
+            m.to_google_dict(
+                put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
+            )
+            for m in messages
+        ]
+        result = [m for m in result if m is not None]
+        return result
+
     @staticmethod
     def generate_otid_from_id(message_id: str, index: int) -> str:
         """

letta/server/rest_api/interface.py

@@ -295,6 +295,25 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.optimistic_json_parser = OptimisticJSONParser()
         self.current_json_parse_result = {}
 
+        # NOTE (fix): OpenAI deltas may split a key and its value across chunks
+        # (e.g. '"request_heartbeat"' in one chunk, ': true' in the next). The
+        # old behavior passed through each fragment verbatim, which could emit
+        # a bare key (or a key+opening quote) without its value, producing
+        # invalid JSON slices and the "missing end-quote" symptom downstream.
+        #
+        # To make streamed arguments robust, we add a JSON-aware incremental
+        # reader that only releases safe updates for the "main" JSON portion of
+        # the tool_call arguments. This prevents partial-key emissions while
+        # preserving incremental streaming for consumers.
+        #
+        # We still stream 'name' fragments as-is (safe), but 'arguments' are
+        # parsed incrementally and emitted only when a boundary is safe.
+        self._raw_args_reader = JSONInnerThoughtsExtractor(
+            inner_thoughts_key=inner_thoughts_kwarg,
+            wait_for_first_key=False,
+        )
+        self._raw_args_tool_call_id = None
+
         # Store metadata passed from server
         self.metadata = {}
 
@@ -654,11 +673,24 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     tool_call_delta = {}
                     if tool_call.id:
                         tool_call_delta["id"] = tool_call.id
+                        # Reset raw args reader per tool_call id
+                        if self._raw_args_tool_call_id != tool_call.id:
+                            self._raw_args_tool_call_id = tool_call.id
+                            self._raw_args_reader = JSONInnerThoughtsExtractor(
+                                inner_thoughts_key=self.inner_thoughts_kwarg,
+                                wait_for_first_key=False,
+                            )
                     if tool_call.function:
-                        if tool_call.function.arguments:
-                            tool_call_delta["arguments"] = tool_call.function.arguments
+                        # Stream name fragments as-is (names are short and harmless to emit)
                         if tool_call.function.name:
                             tool_call_delta["name"] = tool_call.function.name
+                        # For arguments, incrementally parse to avoid emitting partial keys
+                        if tool_call.function.arguments:
+                            self.current_function_arguments += tool_call.function.arguments
+                            updates_main_json, _ = self._raw_args_reader.process_fragment(tool_call.function.arguments)
+                            # Only emit argument updates when a safe boundary is reached
+                            if updates_main_json:
+                                tool_call_delta["arguments"] = updates_main_json
 
                     # We might end up with a no-op, in which case we should omit
                     if (

letta/server/rest_api/json_parser.py

@@ -63,6 +63,8 @@ class OptimisticJSONParser(JSONParser):
             '"': self._parse_string,
             "t": self._parse_true,
             "f": self._parse_false,
+            "T": self._parse_true,
+            "F": self._parse_false,
             "n": self._parse_null,
         }
         # Register number parser for digits and signs

letta/server/rest_api/redis_stream_manager.py

@@ -8,6 +8,10 @@ from typing import AsyncIterator, Dict, List, Optional
 
 from letta.data_sources.redis_client import AsyncRedisClient
 from letta.log import get_logger
+from letta.schemas.enums import JobStatus
+from letta.schemas.user import User
+from letta.services.job_manager import JobManager
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -62,7 +66,7 @@ class RedisSSEStreamWriter:
         """Start the background flush task."""
         if not self._running:
             self._running = True
-            self._flush_task = asyncio.create_task(self._periodic_flush())
+            self._flush_task = safe_create_task(self._periodic_flush(), label="redis_periodic_flush")
 
     async def stop(self):
         """Stop the background flush task and flush remaining data."""
@@ -132,9 +136,9 @@ class RedisSSEStreamWriter:
 
             async with client.pipeline(transaction=False) as pipe:
                 for chunk in chunks:
-                    pipe.xadd(stream_key, chunk, maxlen=self.max_stream_length, approximate=True)
+                    await pipe.xadd(stream_key, chunk, maxlen=self.max_stream_length, approximate=True)
 
-                pipe.expire(stream_key, self.stream_ttl)
+                await pipe.expire(stream_key, self.stream_ttl)
 
                 await pipe.execute()
 
@@ -190,6 +194,8 @@ async def create_background_stream_processor(
     redis_client: AsyncRedisClient,
     run_id: str,
     writer: Optional[RedisSSEStreamWriter] = None,
+    job_manager: Optional[JobManager] = None,
+    actor: Optional[User] = None,
 ) -> None:
     """
     Process a stream in the background and store chunks to Redis.
@@ -202,6 +208,8 @@ async def create_background_stream_processor(
         redis_client: Redis client instance
         run_id: The run ID to store chunks under
         writer: Optional pre-configured writer (creates new if not provided)
+        job_manager: Optional job manager for updating job status
+        actor: Optional actor for job status updates
     """
     if writer is None:
         writer = RedisSSEStreamWriter(redis_client)
@@ -226,6 +234,12 @@ async def create_background_stream_processor(
         logger.error(f"Error processing stream for run {run_id}: {e}")
         # Write error chunk
         # error_chunk = {"error": {"message": str(e)}}
+        # Mark run_id terminal state
+        if job_manager and actor:
+            await job_manager.safe_update_job_status_async(
+                job_id=run_id, new_status=JobStatus.failed, actor=actor, metadata={"error": str(e)}
+            )
+
         error_chunk = {"error": str(e), "code": "INTERNAL_SERVER_ERROR"}
         await writer.write_chunk(run_id=run_id, data=f"event: error\ndata: {json.dumps(error_chunk)}\n\n", is_complete=True)
     finally:

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -14,6 +14,7 @@ from letta.server.rest_api.chat_completions_interface import ChatCompletionsStre
 
 # TODO this belongs in a controller!
 from letta.server.rest_api.utils import get_letta_server, get_user_message_from_chat_completions_request, sse_async_generator
+from letta.utils import safe_create_task
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -98,7 +99,7 @@ async def send_message_to_agent_chat_completions(
 
         # Offload the synchronous message_func to a separate thread
         streaming_interface.stream_start()
-        asyncio.create_task(
+        safe_create_task(
             asyncio.to_thread(
                 server.send_messages,
                 actor=actor,
@@ -106,7 +107,8 @@ async def send_message_to_agent_chat_completions(
                 input_messages=messages,
                 interface=streaming_interface,
                 put_inner_thoughts_first=False,
-            )
+            ),
+            label="openai_send_messages",
         )
 
         # return a stream

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,15 @@ 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,
-                    )
+                        job_manager=server.job_manager,
+                        actor=actor,
+                    ),
+                    label=f"background_stream_processor_{run.id}",
                 )
 
                 raw_stream = redis_sse_stream_generator(
@@ -1568,7 +1505,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 +1523,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 +1611,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 +1624,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 +1646,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 +1718,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 +1762,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.")