letta-nightly 0.7.21.dev20250521233415__py3-none-any.whl → 0.7.22.dev20250523081403__py3-none-any.whl

letta/data_sources/connectors.py

@@ -37,7 +37,9 @@ class DataConnector:
         """
 
 
-def load_data(connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User"):
+async def load_data(
+    connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User"
+):
     """Load data from a connector (generates file and passages) into a specified source_id, associated with a user_id."""
     embedding_config = source.embedding_config
 
@@ -51,7 +53,7 @@ def load_data(connector: DataConnector, source: Source, passage_manager: Passage
     file_count = 0
     for file_metadata in connector.find_files(source):
         file_count += 1
-        source_manager.create_file(file_metadata, actor)
+        await source_manager.create_file(file_metadata, actor)
 
         # generate passages
         for passage_text, passage_metadata in connector.generate_passages(file_metadata, chunk_size=embedding_config.embedding_chunk_size):

letta/functions/ast_parsers.py

@@ -1,5 +1,7 @@
 import ast
+import builtins
 import json
+import typing
 from typing import Dict, Optional, Tuple
 
 from letta.errors import LettaToolCreateError
@@ -22,7 +24,7 @@ def resolve_type(annotation: str):
     Resolve a type annotation string into a Python type.
 
     Args:
-        annotation (str): The annotation string (e.g., 'int', 'list', etc.).
+        annotation (str): The annotation string (e.g., 'int', 'list[int]', 'dict[str, int]').
 
     Returns:
         type: The corresponding Python type.
@@ -34,24 +36,17 @@ def resolve_type(annotation: str):
         return BUILTIN_TYPES[annotation]
 
     try:
-        if annotation.startswith("list["):
-            inner_type = annotation[len("list[") : -1]
-            resolve_type(inner_type)
-            return list
-        elif annotation.startswith("dict["):
-            inner_types = annotation[len("dict[") : -1]
-            key_type, value_type = inner_types.split(",")
-            return dict
-        elif annotation.startswith("tuple["):
-            inner_types = annotation[len("tuple[") : -1]
-            [resolve_type(t.strip()) for t in inner_types.split(",")]
-            return tuple
-
-        parsed = ast.literal_eval(annotation)
-        if isinstance(parsed, type):
-            return parsed
-        raise ValueError(f"Annotation '{annotation}' is not a recognized type.")
-    except (ValueError, SyntaxError):
+        # Allow use of typing and builtins in a safe eval context
+        namespace = {
+            **vars(typing),
+            **vars(builtins),
+            "list": list,
+            "dict": dict,
+            "tuple": tuple,
+            "set": set,
+        }
+        return eval(annotation, namespace)
+    except Exception:
         raise ValueError(f"Unsupported annotation: {annotation}")
 
 
@@ -82,41 +77,36 @@ def get_function_annotations_from_source(source_code: str, function_name: str) -
 
 
 def coerce_dict_args_by_annotations(function_args: dict, annotations: Dict[str, str]) -> dict:
-    """
-    Coerce arguments in a dictionary to their annotated types.
-
-    Args:
-        function_args (dict): The original function arguments.
-        annotations (Dict[str, str]): Argument annotations as strings.
-
-    Returns:
-        dict: The updated dictionary with coerced argument types.
-
-    Raises:
-        ValueError: If type coercion fails for an argument.
-    """
-    coerced_args = dict(function_args)  # Shallow copy for mutation safety
+    coerced_args = dict(function_args)  # Shallow copy
 
     for arg_name, value in coerced_args.items():
         if arg_name in annotations:
             annotation_str = annotations[arg_name]
             try:
-                # Resolve the type from the annotation
                 arg_type = resolve_type(annotation_str)
 
-                # Handle JSON-like inputs for dict and list types
-                if arg_type in {dict, list} and isinstance(value, str):
+                # Always parse strings using literal_eval or json if possible
+                if isinstance(value, str):
                     try:
-                        # First, try JSON parsing
                         value = json.loads(value)
                     except json.JSONDecodeError:
-                        # Fall back to literal_eval for Python-specific literals
-                        value = ast.literal_eval(value)
-
-                # Coerce the value to the resolved type
-                coerced_args[arg_name] = arg_type(value)
-            except (TypeError, ValueError, json.JSONDecodeError, SyntaxError) as e:
+                        try:
+                            value = ast.literal_eval(value)
+                        except (SyntaxError, ValueError) as e:
+                            if arg_type is not str:
+                                raise ValueError(f"Failed to coerce argument '{arg_name}' to {annotation_str}: {e}")
+
+                origin = typing.get_origin(arg_type)
+                if origin in (list, dict, tuple, set):
+                    # Let the origin (e.g., list) handle coercion
+                    coerced_args[arg_name] = origin(value)
+                else:
+                    # Coerce simple types (e.g., int, float)
+                    coerced_args[arg_name] = arg_type(value)
+
+            except Exception as e:
                 raise ValueError(f"Failed to coerce argument '{arg_name}' to {annotation_str}: {e}")
+
     return coerced_args
 
 

letta/groups/sleeptime_multi_agent_v2.py

@@ -19,6 +19,8 @@ from letta.services.group_manager import GroupManager
 from letta.services.job_manager import JobManager
 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
 
 
 class SleeptimeMultiAgentV2(BaseAgent):
@@ -32,6 +34,8 @@ class SleeptimeMultiAgentV2(BaseAgent):
         group_manager: GroupManager,
         job_manager: JobManager,
         actor: User,
+        step_manager: StepManager = NoopStepManager(),
+        telemetry_manager: TelemetryManager = NoopTelemetryManager(),
         group: Optional[Group] = None,
     ):
         super().__init__(
@@ -45,11 +49,18 @@ class SleeptimeMultiAgentV2(BaseAgent):
         self.passage_manager = passage_manager
         self.group_manager = group_manager
         self.job_manager = job_manager
+        self.step_manager = step_manager
+        self.telemetry_manager = telemetry_manager
         # Group settings
         assert group.manager_type == ManagerType.sleeptime, f"Expected group manager type to be 'sleeptime', got {group.manager_type}"
         self.group = group
 
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
+    async def step(
+        self,
+        input_messages: List[MessageCreate],
+        max_steps: int = 10,
+        use_assistant_message: bool = True,
+    ) -> LettaResponse:
         run_ids = []
 
         # Prepare new messages
@@ -68,22 +79,26 @@ class SleeptimeMultiAgentV2(BaseAgent):
             block_manager=self.block_manager,
             passage_manager=self.passage_manager,
             actor=self.actor,
+            step_manager=self.step_manager,
+            telemetry_manager=self.telemetry_manager,
         )
         # Perform foreground agent step
-        response = await foreground_agent.step(input_messages=new_messages, max_steps=max_steps)
+        response = await foreground_agent.step(
+            input_messages=new_messages, max_steps=max_steps, use_assistant_message=use_assistant_message
+        )
 
         # Get last response messages
         last_response_messages = foreground_agent.response_messages
 
         # Update turns counter
         if self.group.sleeptime_agent_frequency is not None and self.group.sleeptime_agent_frequency > 0:
-            turns_counter = self.group_manager.bump_turns_counter(group_id=self.group.id, actor=self.actor)
+            turns_counter = await self.group_manager.bump_turns_counter_async(group_id=self.group.id, actor=self.actor)
 
         # Perform participant steps
         if self.group.sleeptime_agent_frequency is None or (
             turns_counter is not None and turns_counter % self.group.sleeptime_agent_frequency == 0
         ):
-            last_processed_message_id = self.group_manager.get_last_processed_message_id_and_update(
+            last_processed_message_id = await self.group_manager.get_last_processed_message_id_and_update_async(
                 group_id=self.group.id, last_processed_message_id=last_response_messages[-1].id, actor=self.actor
             )
             for participant_agent_id in self.group.agent_ids:
@@ -92,6 +107,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
                         participant_agent_id,
                         last_response_messages,
                         last_processed_message_id,
+                        use_assistant_message,
                     )
                     run_ids.append(run_id)
 
@@ -103,7 +119,13 @@ class SleeptimeMultiAgentV2(BaseAgent):
         response.usage.run_ids = run_ids
         return response
 
-    async def step_stream(self, input_messages: List[MessageCreate], max_steps: int = 10) -> AsyncGenerator[str, None]:
+    async def step_stream(
+        self,
+        input_messages: List[MessageCreate],
+        max_steps: int = 10,
+        use_assistant_message: bool = True,
+        request_start_timestamp_ns: Optional[int] = None,
+    ) -> AsyncGenerator[str, None]:
         # Prepare new messages
         new_messages = []
         for message in input_messages:
@@ -120,9 +142,16 @@ class SleeptimeMultiAgentV2(BaseAgent):
             block_manager=self.block_manager,
             passage_manager=self.passage_manager,
             actor=self.actor,
+            step_manager=self.step_manager,
+            telemetry_manager=self.telemetry_manager,
         )
         # Perform foreground agent step
-        async for chunk in foreground_agent.step_stream(input_messages=new_messages, max_steps=max_steps):
+        async for chunk in foreground_agent.step_stream(
+            input_messages=new_messages,
+            max_steps=max_steps,
+            use_assistant_message=use_assistant_message,
+            request_start_timestamp_ns=request_start_timestamp_ns,
+        ):
             yield chunk
 
         # Get response messages
@@ -130,20 +159,21 @@ class SleeptimeMultiAgentV2(BaseAgent):
 
         # Update turns counter
         if self.group.sleeptime_agent_frequency is not None and self.group.sleeptime_agent_frequency > 0:
-            turns_counter = self.group_manager.bump_turns_counter(group_id=self.group.id, actor=self.actor)
+            turns_counter = await self.group_manager.bump_turns_counter_async(group_id=self.group.id, actor=self.actor)
 
         # Perform participant steps
         if self.group.sleeptime_agent_frequency is None or (
             turns_counter is not None and turns_counter % self.group.sleeptime_agent_frequency == 0
         ):
-            last_processed_message_id = self.group_manager.get_last_processed_message_id_and_update(
+            last_processed_message_id = await self.group_manager.get_last_processed_message_id_and_update_async(
                 group_id=self.group.id, last_processed_message_id=last_response_messages[-1].id, actor=self.actor
             )
             for sleeptime_agent_id in self.group.agent_ids:
-                self._issue_background_task(
+                run_id = await self._issue_background_task(
                     sleeptime_agent_id,
                     last_response_messages,
                     last_processed_message_id,
+                    use_assistant_message,
                 )
 
     async def _issue_background_task(
@@ -151,6 +181,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         sleeptime_agent_id: str,
         response_messages: List[Message],
         last_processed_message_id: str,
+        use_assistant_message: bool = True,
     ) -> str:
         run = Run(
             user_id=self.actor.id,
@@ -160,7 +191,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 "agent_id": sleeptime_agent_id,
             },
         )
-        run = self.job_manager.create_job(pydantic_job=run, actor=self.actor)
+        run = await self.job_manager.create_job_async(pydantic_job=run, actor=self.actor)
 
         asyncio.create_task(
             self._participant_agent_step(
@@ -169,6 +200,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 response_messages=response_messages,
                 last_processed_message_id=last_processed_message_id,
                 run_id=run.id,
+                use_assistant_message=True,
             )
         )
         return run.id
@@ -180,11 +212,12 @@ class SleeptimeMultiAgentV2(BaseAgent):
         response_messages: List[Message],
         last_processed_message_id: str,
         run_id: str,
+        use_assistant_message: bool = True,
     ) -> str:
         try:
             # Update job status
             job_update = JobUpdate(status=JobStatus.running)
-            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.actor)
+            await self.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=self.actor)
 
             # Create conversation transcript
             prior_messages = []
@@ -221,11 +254,14 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 block_manager=self.block_manager,
                 passage_manager=self.passage_manager,
                 actor=self.actor,
+                step_manager=self.step_manager,
+                telemetry_manager=self.telemetry_manager,
             )
 
             # Perform sleeptime agent step
             result = await sleeptime_agent.step(
                 input_messages=sleeptime_agent_messages,
+                use_assistant_message=use_assistant_message,
             )
 
             # Update job status
@@ -237,7 +273,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
                     "agent_id": sleeptime_agent_id,
                 },
             )
-            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.actor)
+            await self.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=self.actor)
             return result
         except Exception as e:
             job_update = JobUpdate(
@@ -245,5 +281,5 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 completed_at=datetime.now(timezone.utc).replace(tzinfo=None),
                 metadata={"error": str(e)},
             )
-            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.actor)
+            await self.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=self.actor)
             raise

letta/jobs/llm_batch_job_polling.py

@@ -106,7 +106,7 @@ async def poll_batch_updates(server: SyncServer, batch_jobs: List[LLMBatchJob],
     results: List[BatchPollingResult] = await asyncio.gather(*coros)
 
     # Update the server with batch status changes
-    server.batch_manager.bulk_update_llm_batch_statuses(updates=results)
+    await server.batch_manager.bulk_update_llm_batch_statuses_async(updates=results)
     logger.info(f"[Poll BatchJob] Bulk-updated {len(results)} LLM batch(es) in the DB at job level.")
 
     return results
@@ -197,13 +197,13 @@ async def poll_running_llm_batches(server: "SyncServer") -> List[LettaBatchRespo
         # 6. Bulk update all items for newly completed batch(es)
         if item_updates:
             metrics.updated_items_count = len(item_updates)
-            server.batch_manager.bulk_update_batch_llm_items_results_by_agent(item_updates)
+            await server.batch_manager.bulk_update_batch_llm_items_results_by_agent_async(item_updates)
 
             # ─── Kick off post‑processing for each batch that just completed ───
             completed = [r for r in batch_results if r.request_status == JobStatus.completed]
 
             async def _resume(batch_row: LLMBatchJob) -> LettaBatchResponse:
-                actor: User = server.user_manager.get_user_by_id(batch_row.created_by_id)
+                actor: User = await server.user_manager.get_actor_by_id_async(batch_row.created_by_id)
                 runner = LettaAgentBatch(
                     message_manager=server.message_manager,
                     agent_manager=server.agent_manager,

letta/jobs/scheduler.py

@@ -4,10 +4,11 @@ from typing import Optional
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.interval import IntervalTrigger
+from sqlalchemy import text
 
 from letta.jobs.llm_batch_job_polling import poll_running_llm_batches
 from letta.log import get_logger
-from letta.server.db import db_context
+from letta.server.db import db_registry
 from letta.server.server import SyncServer
 from letta.settings import settings
 
@@ -34,18 +35,16 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
     acquired_lock = False
     try:
         # Use a temporary connection context for the attempt initially
-        with db_context() as session:
-            engine = session.get_bind()
-            # Get raw connection - MUST be kept open if lock is acquired
-            raw_conn = engine.raw_connection()
-            cur = raw_conn.cursor()
+        async with db_registry.async_session() as session:
+            raw_conn = await session.connection()
 
-        cur.execute("SELECT pg_try_advisory_lock(CAST(%s AS bigint))", (ADVISORY_LOCK_KEY,))
-        acquired_lock = cur.fetchone()[0]
+            # Try to acquire the advisory lock
+            sql = text("SELECT pg_try_advisory_lock(CAST(:lock_key AS bigint))")
+            result = await session.execute(sql, {"lock_key": ADVISORY_LOCK_KEY})
+            acquired_lock = result.scalar_one()
 
         if not acquired_lock:
-            cur.close()
-            raw_conn.close()
+            await raw_conn.close()
             logger.info("Scheduler lock held by another instance.")
             return False
 
@@ -106,14 +105,14 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
         # Clean up temporary resources if lock wasn't acquired or error occurred before storing
         if cur:
             try:
-                cur.close()
-            except:
-                pass
+                await cur.close()
+            except Exception as e:
+                logger.warning(f"Error closing cursor: {e}")
         if raw_conn:
             try:
-                raw_conn.close()
-            except:
-                pass
+                await raw_conn.close()
+            except Exception as e:
+                logger.warning(f"Error closing connection: {e}")
 
 
 async def _background_lock_retry_loop(server: SyncServer):
@@ -161,7 +160,9 @@ async def _release_advisory_lock():
         try:
             if not lock_conn.closed:
                 if not lock_cur.closed:
-                    lock_cur.execute("SELECT pg_advisory_unlock(CAST(%s AS bigint))", (ADVISORY_LOCK_KEY,))
+                    # Use SQLAlchemy text() for raw SQL
+                    unlock_sql = text("SELECT pg_advisory_unlock(CAST(:lock_key AS bigint))")
+                    lock_cur.execute(unlock_sql, {"lock_key": ADVISORY_LOCK_KEY})
                     lock_cur.fetchone()  # Consume result
                     lock_conn.commit()
                     logger.info(f"Executed pg_advisory_unlock for lock {ADVISORY_LOCK_KEY}")
@@ -175,12 +176,12 @@ async def _release_advisory_lock():
             # Ensure resources are closed regardless of unlock success
             try:
                 if lock_cur and not lock_cur.closed:
-                    lock_cur.close()
+                    await lock_cur.close()
             except Exception as e:
                 logger.error(f"Error closing advisory lock cursor: {e}", exc_info=True)
             try:
                 if lock_conn and not lock_conn.closed:
-                    lock_conn.close()
+                    await lock_conn.close()
                 logger.info("Closed database connection that held advisory lock.")
             except Exception as e:
                 logger.error(f"Error closing advisory lock connection: {e}", exc_info=True)

letta/llm_api/anthropic_client.py

@@ -45,11 +45,13 @@ logger = get_logger(__name__)
 
 class AnthropicClient(LLMClientBase):
 
+    @trace_method
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(llm_config, async_client=False)
         response = client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
         return response.model_dump()
 
+    @trace_method
     async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(llm_config, async_client=True)
         response = await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
@@ -339,6 +341,7 @@ class AnthropicClient(LLMClientBase):
 
     # TODO: Input messages doesn't get used here
     # TODO: Clean up this interface
+    @trace_method
     def convert_response_to_chat_completion(
         self,
         response_data: dict,

letta/llm_api/google_vertex_client.py

@@ -17,6 +17,7 @@ from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import Tool
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, FunctionCall, Message, ToolCall, UsageStatistics
 from letta.settings import model_settings, settings
+from letta.tracing import trace_method
 from letta.utils import get_tool_call_id
 
 logger = get_logger(__name__)
@@ -32,6 +33,7 @@ class GoogleVertexClient(LLMClientBase):
             http_options={"api_version": "v1"},
         )
 
+    @trace_method
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying request to llm and returns raw response.
@@ -44,6 +46,7 @@ class GoogleVertexClient(LLMClientBase):
         )
         return response.model_dump()
 
+    @trace_method
     async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying request to llm and returns raw response.
@@ -189,6 +192,7 @@ class GoogleVertexClient(LLMClientBase):
 
         return [{"functionDeclarations": function_list}]
 
+    @trace_method
     def build_request_data(
         self,
         messages: List[PydanticMessage],
@@ -248,6 +252,7 @@ class GoogleVertexClient(LLMClientBase):
 
         return request_data
 
+    @trace_method
     def convert_response_to_chat_completion(
         self,
         response_data: dict,

letta/llm_api/openai_client.py

@@ -32,6 +32,7 @@ from letta.schemas.openai.chat_completion_request import Tool as OpenAITool
 from letta.schemas.openai.chat_completion_request import ToolFunctionChoice, cast_message_to_subtype
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.settings import model_settings
+from letta.tracing import trace_method
 
 logger = get_logger(__name__)
 
@@ -124,6 +125,7 @@ class OpenAIClient(LLMClientBase):
 
         return kwargs
 
+    @trace_method
     def build_request_data(
         self,
         messages: List[PydanticMessage],
@@ -213,6 +215,7 @@ class OpenAIClient(LLMClientBase):
 
         return data.model_dump(exclude_unset=True)
 
+    @trace_method
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying synchronous request to OpenAI API and returns raw response dict.
@@ -222,6 +225,7 @@ class OpenAIClient(LLMClientBase):
         response: ChatCompletion = client.chat.completions.create(**request_data)
         return response.model_dump()
 
+    @trace_method
     async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying asynchronous request to OpenAI API and returns raw response dict.
@@ -230,6 +234,7 @@ class OpenAIClient(LLMClientBase):
         response: ChatCompletion = await client.chat.completions.create(**request_data)
         return response.model_dump()
 
+    @trace_method
     def convert_response_to_chat_completion(
         self,
         response_data: dict,