letta-nightly 0.11.7.dev20250910104051__py3-none-any.whl → 0.11.7.dev20250912104045__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):
@@ -213,8 +213,17 @@ class LettaAgentV2(BaseAgentV2):
 
         if self.stop_reason is None:
             self.stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
-        self._request_checkpoint_finish(request_span=request_span, request_start_timestamp_ns=request_start_timestamp_ns)
-        return LettaResponse(messages=response_letta_messages, stop_reason=self.stop_reason, usage=self.usage)
+
+        result = LettaResponse(messages=response_letta_messages, stop_reason=self.stop_reason, usage=self.usage)
+        if run_id:
+            if self.job_update_metadata is None:
+                self.job_update_metadata = {}
+            self.job_update_metadata["result"] = result.model_dump(mode="json")
+
+        await self._request_checkpoint_finish(
+            request_span=request_span, request_start_timestamp_ns=request_start_timestamp_ns, run_id=run_id
+        )
+        return result
 
     @trace_method
     async def stream(
@@ -301,7 +310,20 @@ class LettaAgentV2(BaseAgentV2):
                 yield f"data: {self.stop_reason.model_dump_json()}\n\n"
             raise
 
-        self._request_checkpoint_finish(request_span=request_span, request_start_timestamp_ns=request_start_timestamp_ns)
+        if run_id:
+            letta_messages = Message.to_letta_messages_from_list(
+                self.response_messages,
+                use_assistant_message=use_assistant_message,
+                reverse=False,
+            )
+            result = LettaResponse(messages=letta_messages, stop_reason=self.stop_reason, usage=self.usage)
+            if self.job_update_metadata is None:
+                self.job_update_metadata = {}
+            self.job_update_metadata["result"] = result.model_dump(mode="json")
+
+        await self._request_checkpoint_finish(
+            request_span=request_span, request_start_timestamp_ns=request_start_timestamp_ns, run_id=run_id
+        )
         for finish_chunk in self.get_finish_chunks_for_stream(self.usage, self.stop_reason):
             yield f"data: {finish_chunk}\n\n"
 
@@ -736,11 +758,10 @@ class LettaAgentV2(BaseAgentV2):
         return None
 
     @trace_method
-    def _request_checkpoint_finish(self, request_span: Span | None, request_start_timestamp_ns: int | None) -> None:
-        if request_span is not None:
-            duration_ns = get_utc_timestamp_ns() - request_start_timestamp_ns
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": ns_to_ms(duration_ns)})
-            request_span.end()
+    async def _request_checkpoint_finish(
+        self, request_span: Span | None, request_start_timestamp_ns: int | None, run_id: str | None
+    ) -> None:
+        await self._log_request(request_start_timestamp_ns, request_span, self.job_update_metadata, is_error=False, run_id=run_id)
         return None
 
     @trace_method
@@ -850,7 +871,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 +1172,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 +1184,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/helpers/tpuf_client.py

@@ -62,11 +62,18 @@ class TurbopufferClient:
         """
         from letta.llm_api.llm_client import LLMClient
 
+        # filter out empty strings after stripping
+        filtered_texts = [text for text in texts if text.strip()]
+
+        # skip embedding if no valid texts
+        if not filtered_texts:
+            return []
+
         embedding_client = LLMClient.create(
             provider_type=self.default_embedding_config.embedding_endpoint_type,
             actor=actor,
         )
-        embeddings = await embedding_client.request_embeddings(texts, self.default_embedding_config)
+        embeddings = await embedding_client.request_embeddings(filtered_texts, self.default_embedding_config)
         return embeddings
 
     @trace_method
@@ -119,8 +126,16 @@ class TurbopufferClient:
         """
         from turbopuffer import AsyncTurbopuffer
 
+        # filter out empty text chunks
+        filtered_chunks = [(i, text) for i, text in enumerate(text_chunks) if text.strip()]
+
+        if not filtered_chunks:
+            logger.warning("All text chunks were empty, skipping insertion")
+            return []
+
         # generate embeddings using the default config
-        embeddings = await self._generate_embeddings(text_chunks, actor)
+        filtered_texts = [text for _, text in filtered_chunks]
+        embeddings = await self._generate_embeddings(filtered_texts, actor)
 
         namespace_name = await self._get_archive_namespace_name(archive_id)
 
@@ -152,8 +167,8 @@ class TurbopufferClient:
         tags_arrays = []  # Store tags as arrays
         passages = []
 
-        for idx, (text, embedding) in enumerate(zip(text_chunks, embeddings)):
-            passage_id = passage_ids[idx]
+        for (original_idx, text), embedding in zip(filtered_chunks, embeddings):
+            passage_id = passage_ids[original_idx]
 
             # append to columns
             ids.append(passage_id)
@@ -240,8 +255,16 @@ class TurbopufferClient:
         """
         from turbopuffer import AsyncTurbopuffer
 
+        # filter out empty message texts
+        filtered_messages = [(i, text) for i, text in enumerate(message_texts) if text.strip()]
+
+        if not filtered_messages:
+            logger.warning("All message texts were empty, skipping insertion")
+            return True
+
         # generate embeddings using the default config
-        embeddings = await self._generate_embeddings(message_texts, actor)
+        filtered_texts = [text for _, text in filtered_messages]
+        embeddings = await self._generate_embeddings(filtered_texts, actor)
 
         namespace_name = await self._get_message_namespace_name(organization_id)
 
@@ -266,8 +289,10 @@ class TurbopufferClient:
         project_ids = []
         template_ids = []
 
-        for idx, (text, embedding, role, created_at) in enumerate(zip(message_texts, embeddings, roles, created_ats)):
-            message_id = message_ids[idx]
+        for (original_idx, text), embedding in zip(filtered_messages, embeddings):
+            message_id = message_ids[original_idx]
+            role = roles[original_idx]
+            created_at = created_ats[original_idx]
 
             # ensure the provided timestamp is timezone-aware and in UTC
             if created_at.tzinfo is None:
@@ -1162,8 +1187,15 @@ class TurbopufferClient:
         if not text_chunks:
             return []
 
+        # filter out empty text chunks
+        filtered_chunks = [text for text in text_chunks if text.strip()]
+
+        if not filtered_chunks:
+            logger.warning("All text chunks were empty, skipping file passage insertion")
+            return []
+
         # generate embeddings using the default config
-        embeddings = await self._generate_embeddings(text_chunks, actor)
+        embeddings = await self._generate_embeddings(filtered_chunks, actor)
 
         namespace_name = await self._get_file_passages_namespace_name(organization_id)
 
@@ -1189,7 +1221,7 @@ class TurbopufferClient:
         created_ats = []
         passages = []
 
-        for idx, (text, embedding) in enumerate(zip(text_chunks, embeddings)):
+        for text, embedding in zip(filtered_chunks, embeddings):
             passage = PydanticPassage(
                 text=text,
                 file_id=file_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/interfaces/openai_streaming_interface.py

@@ -24,7 +24,7 @@ from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
 from letta.server.rest_api.json_parser import OptimisticJSONParser
-from letta.streaming_utils import JSONInnerThoughtsExtractor
+from letta.streaming_utils import FunctionArgumentsStreamHandler, JSONInnerThoughtsExtractor
 from letta.utils import count_tokens
 
 logger = get_logger(__name__)
@@ -53,6 +53,8 @@ class OpenAIStreamingInterface:
 
         self.optimistic_json_parser: OptimisticJSONParser = OptimisticJSONParser()
         self.function_args_reader = JSONInnerThoughtsExtractor(wait_for_first_key=put_inner_thoughts_in_kwarg)
+        # Reader that extracts only the assistant message value from send_message args
+        self.assistant_message_json_reader = FunctionArgumentsStreamHandler(json_key=self.assistant_message_tool_kwarg)
         self.function_name_buffer = None
         self.function_args_buffer = None
         self.function_id_buffer = None
@@ -274,6 +276,8 @@ class OpenAIStreamingInterface:
                                 # Store the ID of the tool call so allow skipping the corresponding response
                                 if self.function_id_buffer:
                                     self.prev_assistant_message_id = self.function_id_buffer
+                                # Reset message reader at the start of a new send_message stream
+                                self.assistant_message_json_reader.reset()
 
                             else:
                                 if prev_message_type and prev_message_type != "tool_call_message":
@@ -328,39 +332,15 @@ class OpenAIStreamingInterface:
                                 self.last_flushed_function_name is not None
                                 and self.last_flushed_function_name == self.assistant_message_tool_name
                             ):
-                                # do an additional parse on the updates_main_json
-                                if self.function_args_buffer:
-                                    updates_main_json = self.function_args_buffer + updates_main_json
-                                    self.function_args_buffer = None
-
-                                    # Pretty gross hardcoding that assumes that if we're toggling into the keywords, we have the full prefix
-                                    match_str = '{"' + self.assistant_message_tool_kwarg + '":"'
-                                    if updates_main_json == match_str:
-                                        updates_main_json = None
-
-                                else:
-                                    # Some hardcoding to strip off the trailing "}"
-                                    if updates_main_json in ["}", '"}']:
-                                        updates_main_json = None
-                                    if updates_main_json and len(updates_main_json) > 0 and updates_main_json[-1:] == '"':
-                                        updates_main_json = updates_main_json[:-1]
-
-                                if not updates_main_json:
-                                    # early exit to turn into content mode
-                                    pass
-
-                                # There may be a buffer from a previous chunk, for example
-                                # if the previous chunk had arguments but we needed to flush name
-                                if self.function_args_buffer:
-                                    # In this case, we should release the buffer + new data at once
-                                    combined_chunk = self.function_args_buffer + updates_main_json
-
+                                # Minimal, robust extraction: only emit the value of "message"
+                                extracted = self.assistant_message_json_reader.process_json_chunk(tool_call.function.arguments)
+                                if extracted:
                                     if prev_message_type and prev_message_type != "assistant_message":
                                         message_index += 1
                                     assistant_message = AssistantMessage(
                                         id=self.letta_message_id,
                                         date=datetime.now(timezone.utc),
-                                        content=combined_chunk,
+                                        content=extracted,
                                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                     )
                                     prev_message_type = assistant_message.message_type
@@ -368,51 +348,6 @@ class OpenAIStreamingInterface:
                                     # Store the ID of the tool call so allow skipping the corresponding response
                                     if self.function_id_buffer:
                                         self.prev_assistant_message_id = self.function_id_buffer
-                                    # clear buffer
-                                    self.function_args_buffer = None
-                                    self.function_id_buffer = None
-
-                                else:
-                                    # If there's no buffer to clear, just output a new chunk with new data
-                                    # TODO: THIS IS HORRIBLE
-                                    # TODO: WE USE THE OLD JSON PARSER EARLIER (WHICH DOES NOTHING) AND NOW THE NEW JSON PARSER
-                                    # TODO: THIS IS TOTALLY WRONG AND BAD, BUT SAVING FOR A LARGER REWRITE IN THE NEAR FUTURE
-                                    parsed_args = self.optimistic_json_parser.parse(self.current_function_arguments)
-
-                                    if parsed_args.get(self.assistant_message_tool_kwarg) and parsed_args.get(
-                                        self.assistant_message_tool_kwarg
-                                    ) != self.current_json_parse_result.get(self.assistant_message_tool_kwarg):
-                                        new_content = parsed_args.get(self.assistant_message_tool_kwarg)
-                                        prev_content = self.current_json_parse_result.get(self.assistant_message_tool_kwarg, "")
-                                        # TODO: Assumes consistent state and that prev_content is subset of new_content
-                                        diff = new_content.replace(prev_content, "", 1)
-
-                                        # quick patch to mitigate double message streaming error
-                                        # TODO: root cause this issue and remove patch
-                                        if diff != "" and "\\n" not in new_content:
-                                            converted_new_content = new_content.replace("\n", "\\n")
-                                            converted_content_diff = converted_new_content.replace(prev_content, "", 1)
-                                            if converted_content_diff == "":
-                                                diff = converted_content_diff
-
-                                        self.current_json_parse_result = parsed_args
-                                        if prev_message_type and prev_message_type != "assistant_message":
-                                            message_index += 1
-                                        assistant_message = AssistantMessage(
-                                            id=self.letta_message_id,
-                                            date=datetime.now(timezone.utc),
-                                            content=diff,
-                                            # name=name,
-                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
-                                        )
-                                        prev_message_type = assistant_message.message_type
-                                        yield assistant_message
-
-                                    # Store the ID of the tool call so allow skipping the corresponding response
-                                    if self.function_id_buffer:
-                                        self.prev_assistant_message_id = self.function_id_buffer
-                                    # clear buffers
-                                    self.function_id_buffer = None
                             else:
                                 # There may be a buffer from a previous chunk, for example
                                 # if the previous chunk had arguments but we needed to flush name

letta/llm_api/google_vertex_client.py

@@ -67,6 +67,7 @@ class GoogleVertexClient(LLMClientBase):
         # https://github.com/googleapis/python-aiplatform/issues/4472
         retry_count = 1
         should_retry = True
+        response_data = None
         while should_retry and retry_count <= self.MAX_RETRIES:
             try:
                 response = await client.aio.models.generate_content(
@@ -79,6 +80,8 @@ class GoogleVertexClient(LLMClientBase):
                 if e.code == 503 or e.code == 500:
                     logger.warning(f"Received {e}, retrying {retry_count}/{self.MAX_RETRIES}")
                     retry_count += 1
+                    if retry_count > self.MAX_RETRIES:
+                        raise e
                     continue
                 raise e
             except Exception as e:
@@ -114,6 +117,8 @@ class GoogleVertexClient(LLMClientBase):
             should_retry = is_malformed_function_call
             retry_count += 1
 
+        if response_data is None:
+            raise RuntimeError("Failed to get response data after all retries")
         return response_data
 
     @staticmethod
@@ -272,7 +277,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/llm_api/openai_client.py

@@ -198,14 +198,15 @@ class OpenAIClient(LLMClientBase):
         # TODO(matt) move into LLMConfig
         # TODO: This vllm checking is very brittle and is a patch at most
         tool_choice = None
-        if self.requires_auto_tool_choice(llm_config):
-            tool_choice = "auto"
-        elif tools:
-            # only set if tools is non-Null
-            tool_choice = "required"
-
-        if force_tool_call is not None:
-            tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=force_tool_call))
+        if tools:  # only set tool_choice if tools exist
+            if self.requires_auto_tool_choice(llm_config):
+                tool_choice = "auto"
+            else:
+                # only set if tools is non-Null
+                tool_choice = "required"
+
+            if force_tool_call is not None:
+                tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=force_tool_call))
 
         data = ChatCompletionRequest(
             model=model,

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/job.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, BigInteger, Index, String
+from sqlalchemy import JSON, BigInteger, ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import UserMixin
@@ -12,6 +12,7 @@ from letta.schemas.job import Job as PydanticJob, LettaRequestConfig
 if TYPE_CHECKING:
     from letta.orm.job_messages import JobMessage
     from letta.orm.message import Message
+    from letta.orm.organization import Organization
     from letta.orm.step import Step
     from letta.orm.user import User
 
@@ -36,6 +37,7 @@ class Job(SqlalchemyBase, UserMixin):
     request_config: Mapped[Optional[LettaRequestConfig]] = mapped_column(
         JSON, nullable=True, doc="The request configuration for the job, stored as JSON."
     )
+    organization_id: Mapped[Optional[str]] = mapped_column(String, ForeignKey("organizations.id"))
 
     # callback related columns
     callback_url: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="When set, POST to this URL after job completion.")
@@ -53,6 +55,8 @@ class Job(SqlalchemyBase, UserMixin):
     user: Mapped["User"] = relationship("User", back_populates="jobs")
     job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")
     steps: Mapped[List["Step"]] = relationship("Step", back_populates="job", cascade="save-update")
+    # organization relationship (nullable for backward compatibility)
+    organization: Mapped[Optional["Organization"]] = relationship("Organization", back_populates="jobs")
 
     @property
     def messages(self) -> List["Message"]:

letta/orm/organization.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from letta.orm.block import Block
     from letta.orm.group import Group
     from letta.orm.identity import Identity
+    from letta.orm.job import Job
     from letta.orm.llm_batch_items import LLMBatchItem
     from letta.orm.llm_batch_job import LLMBatchJob
     from letta.orm.message import Message
@@ -66,3 +67,4 @@ class Organization(SqlalchemyBase):
     llm_batch_items: Mapped[List["LLMBatchItem"]] = relationship(
         "LLMBatchItem", back_populates="organization", cascade="all, delete-orphan"
     )
+    jobs: Mapped[List["Job"]] = relationship("Job", back_populates="organization", cascade="all, delete-orphan")