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

letta/adapters/letta_llm_request_adapter.py

@@ -8,6 +8,7 @@ from letta.schemas.letta_message_content import OmittedReasoningContent, Reasoni
 from letta.schemas.provider_trace import ProviderTraceCreate
 from letta.schemas.user import User
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 
 class LettaLLMRequestAdapter(LettaLLMAdapter):
@@ -98,7 +99,7 @@ class LettaLLMRequestAdapter(LettaLLMAdapter):
         if step_id is None or actor is None or not settings.track_provider_trace:
             return
 
-        asyncio.create_task(
+        safe_create_task(
             self.telemetry_manager.create_provider_trace_async(
                 actor=actor,
                 provider_trace_create=ProviderTraceCreate(
@@ -107,5 +108,6 @@ class LettaLLMRequestAdapter(LettaLLMAdapter):
                     step_id=step_id,  # Use original step_id for telemetry
                     organization_id=actor.organization_id,
                 ),
-            )
+            ),
+            label="create_provider_trace",
         )

letta/adapters/letta_llm_stream_adapter.py

@@ -13,6 +13,7 @@ from letta.schemas.provider_trace import ProviderTraceCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 
 class LettaLLMStreamAdapter(LettaLLMAdapter):
@@ -141,7 +142,7 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
         if step_id is None or actor is None or not settings.track_provider_trace:
             return
 
-        asyncio.create_task(
+        safe_create_task(
             self.telemetry_manager.create_provider_trace_async(
                 actor=actor,
                 provider_trace_create=ProviderTraceCreate(
@@ -165,5 +166,6 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
                     step_id=step_id,  # Use original step_id for telemetry
                     organization_id=actor.organization_id,
                 ),
-            )
+            ),
+            label="create_provider_trace",
         )

letta/agents/agent_loop.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING
+
+from letta.agents.base_agent_v2 import BaseAgentV2
+from letta.agents.letta_agent_v2 import LettaAgentV2
+from letta.groups.sleeptime_multi_agent_v3 import SleeptimeMultiAgentV3
+from letta.schemas.agent import AgentState, AgentType
+
+if TYPE_CHECKING:
+    from letta.orm import User
+
+
+class AgentLoop:
+    """Factory class for instantiating the agent execution loop based on agent type"""
+
+    @staticmethod
+    def load(agent_state: AgentState, actor: "User") -> BaseAgentV2:
+        if agent_state.enable_sleeptime and agent_state.agent_type != AgentType.voice_convo_agent:
+            return SleeptimeMultiAgentV3(agent_state=agent_state, actor=actor, group=agent_state.multi_agent_group)
+        else:
+            return LettaAgentV2(
+                agent_state=agent_state,
+                actor=actor,
+            )

letta/agents/letta_agent_v2.py

@@ -58,7 +58,7 @@ from letta.services.tool_executor.tool_execution_manager import ToolExecutionMan
 from letta.settings import model_settings, settings, summarizer_settings
 from letta.system import package_function_response
 from letta.types import JsonDict
-from letta.utils import log_telemetry, united_diff, validate_function_response
+from letta.utils import log_telemetry, safe_create_task, united_diff, validate_function_response
 
 
 class LettaAgentV2(BaseAgentV2):
@@ -850,7 +850,7 @@ class LettaAgentV2(BaseAgentV2):
             tool_call_messages = create_letta_messages_from_llm_response(
                 agent_id=agent_state.id,
                 model=agent_state.llm_config.model,
-                function_name="",
+                function_name=tool_call.function.name,
                 function_arguments={},
                 tool_execution_result=ToolExecutionResult(status="error"),
                 tool_call_id=tool_call_id,
@@ -1151,7 +1151,7 @@ class LettaAgentV2(BaseAgentV2):
         step_metrics: StepMetrics,
         run_id: str | None = None,
     ):
-        task = asyncio.create_task(
+        task = safe_create_task(
             self.step_manager.record_step_metrics_async(
                 actor=self.actor,
                 step_id=step_id,
@@ -1163,7 +1163,8 @@ class LettaAgentV2(BaseAgentV2):
                 project_id=self.agent_state.project_id,
                 template_id=self.agent_state.template_id,
                 base_template_id=self.agent_state.base_template_id,
-            )
+            ),
+            label="record_step_metrics",
         )
         return task
 

letta/functions/helpers.py

@@ -19,6 +19,7 @@ from letta.schemas.message import Message, MessageCreate
 from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 
 # TODO needed?
@@ -447,7 +448,7 @@ async def _send_message_to_agents_matching_tags_async(
             timeout=settings.multi_agent_send_message_timeout,
         )
 
-    tasks = [asyncio.create_task(_send_single(agent_state)) for agent_state in matching_agents]
+    tasks = [safe_create_task(_send_single(agent_state), label=f"send_to_agent_{agent_state.id}") for agent_state in matching_agents]
     results = await asyncio.gather(*tasks, return_exceptions=True)
     final = []
     for r in results:
@@ -488,7 +489,7 @@ async def _send_message_to_all_agents_in_group_async(sender_agent: "Agent", mess
                 timeout=settings.multi_agent_send_message_timeout,
             )
 
-    tasks = [asyncio.create_task(_send_single(agent_state)) for agent_state in worker_agents]
+    tasks = [safe_create_task(_send_single(agent_state), label=f"send_to_worker_{agent_state.id}") for agent_state in worker_agents]
     results = await asyncio.gather(*tasks, return_exceptions=True)
     final = []
     for r in results:

letta/groups/sleeptime_multi_agent_v2.py

@@ -24,6 +24,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.step_manager import NoopStepManager, StepManager
 from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
+from letta.utils import safe_create_task
 
 
 class SleeptimeMultiAgentV2(BaseAgent):
@@ -236,7 +237,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         )
         run = await self.job_manager.create_job_async(pydantic_job=run, actor=self.actor)
 
-        asyncio.create_task(
+        safe_create_task(
             self._participant_agent_step(
                 foreground_agent_id=self.agent_id,
                 sleeptime_agent_id=sleeptime_agent_id,
@@ -244,7 +245,8 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 last_processed_message_id=last_processed_message_id,
                 run_id=run.id,
                 use_assistant_message=True,
-            )
+            ),
+            label=f"participant_agent_step_{sleeptime_agent_id}",
         )
         return run.id
 

letta/groups/sleeptime_multi_agent_v3.py

@@ -17,6 +17,7 @@ from letta.schemas.message import Message, MessageCreate
 from letta.schemas.run import Run
 from letta.schemas.user import User
 from letta.services.group_manager import GroupManager
+from letta.utils import safe_create_task
 
 
 class SleeptimeMultiAgentV3(LettaAgentV2):
@@ -142,7 +143,7 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
         )
         run = await self.job_manager.create_job_async(pydantic_job=run, actor=self.actor)
 
-        asyncio.create_task(
+        safe_create_task(
             self._participant_agent_step(
                 foreground_agent_id=self.agent_state.id,
                 sleeptime_agent_id=sleeptime_agent_id,
@@ -150,7 +151,8 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
                 last_processed_message_id=last_processed_message_id,
                 run_id=run.id,
                 use_assistant_message=use_assistant_message,
-            )
+            ),
+            label=f"participant_agent_step_{sleeptime_agent_id}",
         )
         return run.id
 

letta/interfaces/anthropic_streaming_interface.py

@@ -106,15 +106,19 @@ class AnthropicStreamingInterface:
         try:
             tool_input = json.loads(self.accumulated_tool_call_args)
         except json.JSONDecodeError as e:
-            logger.warning(
-                f"Failed to decode tool call arguments for tool_call_id={self.tool_call_id}, "
-                f"name={self.tool_call_name}. Raw input: {self.accumulated_tool_call_args!r}. Error: {e}"
-            )
-            raise
+            # Attempt to use OptimisticJSONParser to handle incomplete/malformed JSON
+            try:
+                tool_input = self.json_parser.parse(self.accumulated_tool_call_args)
+            except:
+                logger.warning(
+                    f"Failed to decode tool call arguments for tool_call_id={self.tool_call_id}, "
+                    f"name={self.tool_call_name}. Raw input: {self.accumulated_tool_call_args!r}. Error: {e}"
+                )
+                raise e
         if "id" in tool_input and tool_input["id"].startswith("toolu_") and "function" in tool_input:
             arguments = str(json.dumps(tool_input["function"]["arguments"], indent=2))
         else:
-            arguments = self.accumulated_tool_call_args
+            arguments = str(json.dumps(tool_input, indent=2))
         return ToolCall(id=self.tool_call_id, function=FunctionCall(arguments=arguments, name=self.tool_call_name))
 
     def _check_inner_thoughts_complete(self, combined_args: str) -> bool:

letta/llm_api/google_vertex_client.py

@@ -272,7 +272,7 @@ class GoogleVertexClient(LLMClientBase):
             tool_names = []
 
         contents = self.add_dummy_model_messages(
-            [m.to_google_ai_dict() for m in messages],
+            PydanticMessage.to_google_dicts_from_list(messages),
         )
 
         request_data = {

letta/orm/agent.py

@@ -34,7 +34,10 @@ if TYPE_CHECKING:
 class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin, TemplateMixin, AsyncAttrs):
     __tablename__ = "agents"
     __pydantic_model__ = PydanticAgentState
-    __table_args__ = (Index("ix_agents_created_at", "created_at", "id"),)
+    __table_args__ = (
+        Index("ix_agents_created_at", "created_at", "id"),
+        Index("ix_agents_organization_id", "organization_id"),
+    )
 
     # 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

letta/orm/block.py

@@ -24,6 +24,7 @@ class Block(OrganizationMixin, SqlalchemyBase, ProjectMixin, TemplateEntityMixin
     __table_args__ = (
         UniqueConstraint("id", "label", name="unique_block_id_label"),
         Index("created_at_label_idx", "created_at", "label"),
+        Index("ix_block_label", "label"),
     )
 
     template_name: Mapped[Optional[str]] = mapped_column(

letta/orm/blocks_agents.py

@@ -20,6 +20,7 @@ class BlocksAgents(Base):
         UniqueConstraint("agent_id", "block_id", name="unique_agent_block"),
         Index("ix_blocks_agents_block_label_agent_id", "block_label", "agent_id"),
         Index("ix_blocks_block_label", "block_label"),
+        Index("ix_blocks_agents_block_id", "block_id"),
     )
 
     # unique agent + block label

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,7 @@ from typing import AsyncIterator, Dict, List, Optional
 
 from letta.data_sources.redis_client import AsyncRedisClient
 from letta.log import get_logger
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -62,7 +63,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."""

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