letta-nightly 0.8.12.dev20250710104356__py3-none-any.whl → 0.8.13.dev20250710230421__py3-none-any.whl

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.8.12"
+    __version__ = "0.8.13"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/agents/base_agent.py

@@ -96,7 +96,7 @@ class BaseAgent(ABC):
         """
         try:
             # [DB Call] loading blocks (modifies: agent_state.memory.blocks)
-            await self.agent_manager.refresh_memory_async(agent_state=agent_state, actor=self.actor)
+            agent_state = await self.agent_manager.refresh_memory_async(agent_state=agent_state, actor=self.actor)
 
             tool_constraint_block = None
             if tool_rules_solver is not None:
@@ -104,18 +104,37 @@ class BaseAgent(ABC):
 
             # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
             curr_system_message = in_context_messages[0]
-            curr_memory_str = agent_state.memory.compile(tool_usage_rules=tool_constraint_block, sources=agent_state.sources)
             curr_system_message_text = curr_system_message.content[0].text
-            if curr_memory_str in curr_system_message_text:
+
+            # extract the dynamic section that includes memory blocks, tool rules, and directories
+            # this avoids timestamp comparison issues
+            def extract_dynamic_section(text):
+                start_marker = "</base_instructions>"
+                end_marker = "<memory_metadata>"
+
+                start_idx = text.find(start_marker)
+                end_idx = text.find(end_marker)
+
+                if start_idx != -1 and end_idx != -1:
+                    return text[start_idx:end_idx]
+                return text  # fallback to full text if markers not found
+
+            curr_dynamic_section = extract_dynamic_section(curr_system_message_text)
+
+            # generate just the memory string with current state for comparison
+            curr_memory_str = agent_state.memory.compile(tool_usage_rules=tool_constraint_block, sources=agent_state.sources)
+            new_dynamic_section = extract_dynamic_section(curr_memory_str)
+
+            # compare just the dynamic sections (memory blocks, tool rules, directories)
+            if curr_dynamic_section == new_dynamic_section:
                 logger.debug(
-                    f"Memory hasn't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
+                    f"Memory and sources haven't changed for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name}), skipping system prompt rebuild"
                 )
                 return in_context_messages
 
             memory_edit_timestamp = get_utc_time()
 
-            # [DB Call] size of messages and archival memories
-            # todo: blocking for now
+            # size of messages and archival memories
             if num_messages is None:
                 num_messages = await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
             if num_archival_memories is None:

letta/agents/letta_agent.py

@@ -3,7 +3,7 @@ import json
 import uuid
 from collections.abc import AsyncGenerator
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Union
 
 from openai import AsyncStream
 from openai.types.chat import ChatCompletionChunk
@@ -165,18 +165,28 @@ class LettaAgent(BaseAgent):
         use_assistant_message: bool = True,
         request_start_timestamp_ns: int | None = None,
         include_return_message_types: list[MessageType] | None = None,
-    ) -> LettaResponse:
+        dry_run: bool = False,
+    ) -> Union[LettaResponse, dict]:
         # TODO (cliandy): pass in run_id and use at send_message endpoints for all step functions
         agent_state = await self.agent_manager.get_agent_by_id_async(
-            agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
+            agent_id=self.agent_id,
+            include_relationships=["tools", "memory", "tool_exec_environment_variables", "sources"],
+            actor=self.actor,
         )
-        _, new_in_context_messages, stop_reason, usage = await self._step(
+        result = await self._step(
             agent_state=agent_state,
             input_messages=input_messages,
             max_steps=max_steps,
             run_id=run_id,
             request_start_timestamp_ns=request_start_timestamp_ns,
+            dry_run=dry_run,
         )
+
+        # If dry run, return the request payload directly
+        if dry_run:
+            return result
+
+        _, new_in_context_messages, stop_reason, usage = result
         return _create_letta_response(
             new_in_context_messages=new_in_context_messages,
             use_assistant_message=use_assistant_message,
@@ -195,7 +205,9 @@ class LettaAgent(BaseAgent):
         include_return_message_types: list[MessageType] | None = None,
     ):
         agent_state = await self.agent_manager.get_agent_by_id_async(
-            agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
+            agent_id=self.agent_id,
+            include_relationships=["tools", "memory", "tool_exec_environment_variables", "sources"],
+            actor=self.actor,
         )
         current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_no_persist_async(
             input_messages, agent_state, self.message_manager, self.actor
@@ -279,6 +291,7 @@ class LettaAgent(BaseAgent):
                 tool_rules_solver,
                 response.usage,
                 reasoning_content=reasoning,
+                step_id=step_id,
                 initial_messages=initial_messages,
                 agent_step_span=agent_step_span,
                 is_final_step=(i == max_steps - 1),
@@ -357,7 +370,8 @@ class LettaAgent(BaseAgent):
         max_steps: int = DEFAULT_MAX_STEPS,
         run_id: str | None = None,
         request_start_timestamp_ns: int | None = None,
-    ) -> tuple[list[Message], list[Message], LettaStopReason | None, LettaUsageStatistics]:
+        dry_run: bool = False,
+    ) -> Union[tuple[list[Message], list[Message], LettaStopReason | None, LettaUsageStatistics], dict]:
         """
         Carries out an invocation of the agent loop. In each step, the agent
             1. Rebuilds its memory
@@ -394,6 +408,16 @@ class LettaAgent(BaseAgent):
             agent_step_span = tracer.start_span("agent_step", start_time=step_start)
             agent_step_span.set_attributes({"step_id": step_id})
 
+            # If dry run, build request data and return it without making LLM call
+            if dry_run:
+                request_data, valid_tool_names = await self._create_llm_request_data_async(
+                    llm_client=llm_client,
+                    in_context_messages=current_in_context_messages + new_in_context_messages,
+                    agent_state=agent_state,
+                    tool_rules_solver=tool_rules_solver,
+                )
+                return request_data
+
             request_data, response_data, current_in_context_messages, new_in_context_messages, valid_tool_names = (
                 await self._build_and_request_from_llm(
                     current_in_context_messages, new_in_context_messages, agent_state, llm_client, tool_rules_solver, agent_step_span
@@ -530,7 +554,9 @@ class LettaAgent(BaseAgent):
             4. Processes the response
         """
         agent_state = await self.agent_manager.get_agent_by_id_async(
-            agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
+            agent_id=self.agent_id,
+            include_relationships=["tools", "memory", "tool_exec_environment_variables", "sources"],
+            actor=self.actor,
         )
         current_in_context_messages, new_in_context_messages = await _prepare_in_context_messages_no_persist_async(
             input_messages, agent_state, self.message_manager, self.actor
@@ -628,7 +654,7 @@ class LettaAgent(BaseAgent):
             )
 
             # log LLM request time
-            llm_request_ms = ns_to_ms(stream_end_time_ns - request_start_timestamp_ns)
+            llm_request_ms = ns_to_ms(stream_end_time_ns - provider_request_start_timestamp_ns)
             agent_step_span.add_event(name="llm_request_ms", attributes={"duration_ms": llm_request_ms})
             MetricRegistry().llm_execution_time_ms_histogram.record(
                 llm_request_ms,

letta/functions/ast_parsers.py

@@ -129,7 +129,8 @@ def get_function_name_and_docstring(source_code: str, name: Optional[str] = None
             raise LettaToolCreateError("Could not determine function name")
 
         if not docstring:
-            raise LettaToolCreateError("Docstring is missing")
+            # For tools with args_json_schema, the docstring is optional
+            docstring = f"The {function_name} tool"
 
         return function_name, docstring
 

letta/helpers/json_helpers.py

@@ -10,6 +10,8 @@ def json_dumps(data, indent=2):
     def safe_serializer(obj):
         if isinstance(obj, datetime):
             return obj.isoformat()
+        if isinstance(obj, bytes):
+            return obj.decode("utf-8")
         raise TypeError(f"Type {type(obj)} not serializable")
 
     return json.dumps(data, indent=indent, default=safe_serializer, ensure_ascii=False)

letta/helpers/pinecone_utils.py

@@ -1,6 +1,12 @@
 from typing import Any, Dict, List
 
-from pinecone import PineconeAsyncio
+try:
+    from pinecone import IndexEmbed, PineconeAsyncio
+    from pinecone.exceptions.exceptions import NotFoundException
+
+    PINECONE_AVAILABLE = True
+except ImportError:
+    PINECONE_AVAILABLE = False
 
 from letta.constants import (
     PINECONE_CLOUD,
@@ -27,11 +33,20 @@ def should_use_pinecone(verbose: bool = False):
             bool(settings.pinecone_source_index),
         )
 
-    return settings.enable_pinecone and settings.pinecone_api_key and settings.pinecone_agent_index and settings.pinecone_source_index
+    return all(
+        (
+            PINECONE_AVAILABLE,
+            settings.enable_pinecone,
+            settings.pinecone_api_key,
+            settings.pinecone_agent_index,
+            settings.pinecone_source_index,
+        )
+    )
 
 
 async def upsert_pinecone_indices():
-    from pinecone import IndexEmbed, PineconeAsyncio
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     for index_name in get_pinecone_indices():
         async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
@@ -49,6 +64,9 @@ def get_pinecone_indices() -> List[str]:
 
 
 async def upsert_file_records_to_pinecone_index(file_id: str, source_id: str, chunks: List[str], actor: User):
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
+
     records = []
     for i, chunk in enumerate(chunks):
         record = {
@@ -63,7 +81,8 @@ async def upsert_file_records_to_pinecone_index(file_id: str, source_id: str, ch
 
 
 async def delete_file_records_from_pinecone_index(file_id: str, actor: User):
-    from pinecone.exceptions.exceptions import NotFoundException
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     namespace = actor.organization_id
     try:
@@ -81,7 +100,8 @@ async def delete_file_records_from_pinecone_index(file_id: str, actor: User):
 
 
 async def delete_source_records_from_pinecone_index(source_id: str, actor: User):
-    from pinecone.exceptions.exceptions import NotFoundException
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     namespace = actor.organization_id
     try:
@@ -94,6 +114,9 @@ async def delete_source_records_from_pinecone_index(source_id: str, actor: User)
 
 
 async def upsert_records_to_pinecone_index(records: List[dict], actor: User):
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
+
     async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
         description = await pc.describe_index(name=settings.pinecone_source_index)
         async with pc.IndexAsyncio(host=description.index.host) as dense_index:
@@ -104,6 +127,9 @@ async def upsert_records_to_pinecone_index(records: List[dict], actor: User):
 
 
 async def search_pinecone_index(query: str, limit: int, filter: Dict[str, Any], actor: User) -> Dict[str, Any]:
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
+
     async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
         description = await pc.describe_index(name=settings.pinecone_source_index)
         async with pc.IndexAsyncio(host=description.index.host) as dense_index:
@@ -127,7 +153,8 @@ async def search_pinecone_index(query: str, limit: int, filter: Dict[str, Any],
 
 
 async def list_pinecone_index_for_files(file_id: str, actor: User, limit: int = None, pagination_token: str = None) -> List[str]:
-    from pinecone.exceptions.exceptions import NotFoundException
+    if not PINECONE_AVAILABLE:
+        raise ImportError("Pinecone is not available. Please install pinecone to use this feature.")
 
     namespace = actor.organization_id
     try:

letta/jobs/scheduler.py

@@ -29,6 +29,7 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
     if _is_scheduler_leader:
         return True  # Already leading
 
+    engine_name = None
     lock_session = None
     acquired_lock = False
     try:
@@ -36,32 +37,25 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
             engine = session.get_bind()
             engine_name = engine.name
             logger.info(f"Database engine type: {engine_name}")
-            if engine_name != "postgresql":
-                logger.warning(f"Advisory locks not supported for {engine_name} database. Starting scheduler without leader election.")
-                acquired_lock = True
-            else:
-                lock_session = db_registry.get_async_session_factory()()
-                result = await lock_session.execute(
-                    text("SELECT pg_try_advisory_lock(CAST(:lock_key AS bigint))"), {"lock_key": ADVISORY_LOCK_KEY}
-                )
-                acquired_lock = result.scalar()
-                await lock_session.commit()
-
-        if not acquired_lock:
-            if lock_session:
-                await lock_session.close()
-            logger.info("Scheduler lock held by another instance.")
-            return False
 
-        if engine_name == "postgresql":
-            logger.info("Acquired PostgreSQL advisory lock.")
-            _advisory_lock_session = lock_session
-            lock_session = None
+        if engine_name != "postgresql":
+            logger.warning(f"Advisory locks not supported for {engine_name} database. Starting scheduler without leader election.")
+            acquired_lock = True
         else:
-            logger.info("Starting scheduler for non-PostgreSQL database.")
-            if lock_session:
+            lock_session = db_registry.get_async_session_factory()()
+            result = await lock_session.execute(
+                text("SELECT pg_try_advisory_lock(CAST(:lock_key AS bigint))"), {"lock_key": ADVISORY_LOCK_KEY}
+            )
+            acquired_lock = result.scalar()
+            await lock_session.commit()
+
+            if not acquired_lock:
                 await lock_session.close()
-            lock_session = None
+                logger.info("Scheduler lock held by another instance.")
+                return False
+            else:
+                _advisory_lock_session = lock_session
+                lock_session = None
 
         trigger = IntervalTrigger(
             seconds=settings.poll_running_llm_batches_interval_seconds,
@@ -90,7 +84,6 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
         if acquired_lock:
             logger.warning("Attempting to release lock due to error during startup.")
             try:
-                _advisory_lock_session = lock_session
                 await _release_advisory_lock(lock_session)
             except Exception as unlock_err:
                 logger.error(f"Failed to release lock during error handling: {unlock_err}", exc_info=True)
@@ -108,8 +101,8 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:
         if lock_session:
             try:
                 await lock_session.close()
-            except:
-                pass
+            except Exception as e:
+                logger.error(f"Failed to close session during error handling: {e}", exc_info=True)
 
 
 async def _background_lock_retry_loop(server: SyncServer):
@@ -138,15 +131,13 @@ async def _background_lock_retry_loop(server: SyncServer):
             break
         except Exception as e:
             logger.error(f"Error in background lock retry loop: {e}", exc_info=True)
-            await asyncio.sleep(settings.poll_lock_retry_interval_seconds)
 
 
-async def _release_advisory_lock(lock_session=None):
+async def _release_advisory_lock(target_lock_session=None):
     """Releases the advisory lock using the stored session."""
     global _advisory_lock_session
 
-    lock_session = _advisory_lock_session or lock_session
-    _advisory_lock_session = None
+    lock_session = target_lock_session or _advisory_lock_session
 
     if lock_session is not None:
         logger.info(f"Attempting to release PostgreSQL advisory lock {ADVISORY_LOCK_KEY}")
@@ -161,6 +152,8 @@ async def _release_advisory_lock(lock_session=None):
                 if lock_session:
                     await lock_session.close()
                 logger.info("Closed database session that held advisory lock.")
+                if lock_session == _advisory_lock_session:
+                    _advisory_lock_session = None
             except Exception as e:
                 logger.error(f"Error closing advisory lock session: {e}", exc_info=True)
     else:

letta/otel/metric_registry.py

@@ -58,7 +58,12 @@ class MetricRegistry:
     def tool_execution_counter(self) -> Counter:
         return self._get_or_create_metric(
             "count_tool_execution",
-            partial(self._meter.create_counter, name="count_tool_execution", description="Counts the number of tools executed.", unit="1"),
+            partial(
+                self._meter.create_counter,
+                name="count_tool_execution",
+                description="Counts the number of tools executed.",
+                unit="1",
+            ),
         )
 
     # project_id + model
@@ -66,7 +71,12 @@ class MetricRegistry:
     def ttft_ms_histogram(self) -> Histogram:
         return self._get_or_create_metric(
             "hist_ttft_ms",
-            partial(self._meter.create_histogram, name="hist_ttft_ms", description="Histogram for the Time to First Token (ms)", unit="ms"),
+            partial(
+                self._meter.create_histogram,
+                name="hist_ttft_ms",
+                description="Histogram for the Time to First Token (ms)",
+                unit="ms",
+            ),
         )
 
     # (includes model name)
@@ -158,3 +168,15 @@ class MetricRegistry:
                 unit="1",
             ),
         )
+
+    @property
+    def file_process_bytes_histogram(self) -> Histogram:
+        return self._get_or_create_metric(
+            "hist_file_process_bytes",
+            partial(
+                self._meter.create_histogram,
+                name="hist_file_process_bytes",
+                description="Histogram for file process in bytes",
+                unit="By",
+            ),
+        )

letta/schemas/enums.py

@@ -139,3 +139,11 @@ class MCPServerType(str, Enum):
     SSE = "sse"
     STDIO = "stdio"
     STREAMABLE_HTTP = "streamable_http"
+
+
+class DuplicateFileHandling(str, Enum):
+    """How to handle duplicate filenames when uploading files"""
+
+    SKIP = "skip"  # skip files with duplicate names
+    ERROR = "error"  # error when duplicate names are encountered
+    SUFFIX = "suffix"  # add numeric suffix to make names unique (default behavior)

letta/schemas/tool.py

@@ -77,9 +77,8 @@ class Tool(BaseTool):
 
         if self.tool_type is ToolType.CUSTOM:
             if not self.source_code:
-                error_msg = f"Custom tool with id={self.id} is missing source_code field."
-                logger.error(error_msg)
-                raise ValueError(error_msg)
+                logger.error("Custom tool with id=%s is missing source_code field", self.id)
+                raise ValueError(f"Custom tool with id={self.id} is missing source_code field.")
 
             # Always derive json_schema for freshest possible json_schema
             if self.args_json_schema is not None:
@@ -96,8 +95,7 @@ class Tool(BaseTool):
                 try:
                     self.json_schema = derive_openai_json_schema(source_code=self.source_code)
                 except Exception as e:
-                    error_msg = f"Failed to derive json schema for tool with id={self.id} name={self.name}. Error: {str(e)}"
-                    logger.error(error_msg)
+                    logger.error("Failed to derive json schema for tool with id=%s name=%s: %s", self.id, self.name, e)
         elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE, ToolType.LETTA_SLEEPTIME_CORE}:
             # If it's letta core tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_CORE_TOOL_MODULE_NAME, function_name=self.name)
@@ -119,9 +117,8 @@ class Tool(BaseTool):
 
         # At this point, we need to validate that at least json_schema is populated
         if not self.json_schema:
-            error_msg = f"Tool with id={self.id} name={self.name} tool_type={self.tool_type} is missing a json_schema."
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error("Tool with id=%s name=%s tool_type=%s is missing a json_schema", self.id, self.name, self.tool_type)
+            raise ValueError(f"Tool with id={self.id} name={self.name} tool_type={self.tool_type} is missing a json_schema.")
 
         # Derive name from the JSON schema if not provided
         if not self.name:

letta/server/rest_api/app.py

@@ -337,8 +337,11 @@ def create_application() -> "FastAPI":
     # / static files
     mount_static_files(app)
 
+    no_generation = "--no-generation" in sys.argv
+
     # Generate OpenAPI schema after all routes are mounted
-    generate_openapi_schema(app)
+    if not no_generation:
+        generate_openapi_schema(app)
 
     return app
 

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

@@ -2,7 +2,7 @@ import asyncio
 import json
 import traceback
 from datetime import datetime, timezone
-from typing import Annotated, Any, List, Optional
+from typing import Annotated, Any, Dict, List, Optional, Union
 
 from fastapi import APIRouter, Body, Depends, File, Header, HTTPException, Query, Request, UploadFile, status
 from fastapi.responses import JSONResponse
@@ -522,7 +522,7 @@ async def attach_block(
     actor_id: str | None = Header(None, alias="user_id"),
 ):
     """
-    Attach a core memoryblock to an agent.
+    Attach a core memory block to an agent.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.agent_manager.attach_block_async(agent_id=agent_id, block_id=block_id, actor=actor)
@@ -1160,6 +1160,69 @@ async def list_agent_groups(
     return server.agent_manager.list_groups(agent_id=agent_id, manager_type=manager_type, actor=actor)
 
 
+@router.post(
+    "/{agent_id}/messages/preview-raw-payload",
+    response_model=Dict[str, Any],
+    operation_id="preview_raw_payload",
+)
+async def preview_raw_payload(
+    agent_id: str,
+    request: Union[LettaRequest, LettaStreamingRequest] = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: str | None = Header(None, alias="user_id"),
+):
+    """
+    Inspect the raw LLM request payload without sending it.
+
+    This endpoint processes the message through the agent loop up until
+    the LLM request, then returns the raw request payload that would
+    be sent to the LLM provider. Useful for debugging and inspection.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+    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", "openai", "together", "google_ai", "google_vertex", "bedrock"]
+
+    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(
+            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,
+            detail="Payload inspection is not currently supported for this agent configuration.",
+        )
+
+
 @router.post("/{agent_id}/summarize", response_model=AgentState, operation_id="summarize_agent_conversation")
 async def summarize_agent_conversation(
     agent_id: str,

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

@@ -19,7 +19,7 @@ from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import FileProcessingStatus
+from letta.schemas.enums import DuplicateFileHandling, FileProcessingStatus
 from letta.schemas.file import FileMetadata
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
@@ -208,6 +208,7 @@ async def delete_source(
 async def upload_file_to_source(
     file: UploadFile,
     source_id: str,
+    duplicate_handling: DuplicateFileHandling = Query(DuplicateFileHandling.SUFFIX, description="How to handle duplicate filenames"),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -264,8 +265,31 @@ async def upload_file_to_source(
 
     content = await file.read()
 
-    # Store original filename and generate unique filename
+    # Store original filename and handle duplicate logic
     original_filename = sanitize_filename(file.filename)  # Basic sanitization only
+
+    # Check if duplicate exists
+    existing_file = await server.file_manager.get_file_by_original_name_and_source(
+        original_filename=original_filename, source_id=source_id, actor=actor
+    )
+
+    if existing_file:
+        # Duplicate found, handle based on strategy
+        if duplicate_handling == DuplicateFileHandling.ERROR:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT, detail=f"File '{original_filename}' already exists in source '{source.name}'"
+            )
+        elif duplicate_handling == DuplicateFileHandling.SKIP:
+            # Return existing file metadata with custom header to indicate it was skipped
+            from fastapi import Response
+
+            response = Response(
+                content=existing_file.model_dump_json(), media_type="application/json", headers={"X-Upload-Result": "skipped"}
+            )
+            return response
+        # For SUFFIX, continue to generate unique filename
+
+    # Generate unique filename (adds suffix if needed)
     unique_filename = await server.file_manager.generate_unique_filename(
         original_filename=original_filename, source=source, organization_id=actor.organization_id
     )
@@ -360,6 +384,13 @@ async def get_file_metadata(
         file_id=file_id, actor=actor, include_content=include_content, strip_directory_prefix=True
     )
 
+    if not file_metadata:
+        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
+
+    # Verify the file belongs to the specified source
+    if file_metadata.source_id != source_id:
+        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found in source {source_id}.")
+
     if should_use_pinecone() and not file_metadata.is_processing_terminal():
         ids = await list_pinecone_index_for_files(file_id=file_id, actor=actor, limit=file_metadata.total_chunks)
         logger.info(
@@ -375,13 +406,6 @@ async def get_file_metadata(
                 file_id=file_metadata.id, actor=actor, chunks_embedded=len(ids), processing_status=file_status
             )
 
-    if not file_metadata:
-        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found.")
-
-    # Verify the file belongs to the specified source
-    if file_metadata.source_id != source_id:
-        raise HTTPException(status_code=404, detail=f"File with id={file_id} not found in source {source_id}.")
-
     return file_metadata
 
 

letta/services/agent_manager.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 from typing import Dict, List, Optional, Set, Tuple
 
 import sqlalchemy as sa
-from sqlalchemy import delete, func, insert, literal, or_, select
+from sqlalchemy import delete, func, insert, literal, or_, select, tuple_
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 
 from letta.constants import (
@@ -224,13 +224,44 @@ class AgentManager:
     @staticmethod
     async def _replace_pivot_rows_async(session, table, agent_id: str, rows: list[dict]):
         """
-        Replace all pivot rows for an agent with *exactly* the provided list.
-        Uses two bulk statements (DELETE + INSERT ... ON CONFLICT DO NOTHING).
+        Replace all pivot rows for an agent atomically using MERGE pattern.
         """
-        # delete all existing rows for this agent
-        await session.execute(delete(table).where(table.c.agent_id == agent_id))
-        if rows:
-            await AgentManager._bulk_insert_pivot_async(session, table, rows)
+        dialect = session.bind.dialect.name
+
+        if dialect == "postgresql":
+            if rows:
+                # separate upsert and delete operations
+                stmt = pg_insert(table).values(rows)
+                stmt = stmt.on_conflict_do_nothing()
+                await session.execute(stmt)
+
+                # delete rows not in new set
+                pk_names = [c.name for c in table.primary_key.columns]
+                new_keys = [tuple(r[c] for c in pk_names) for r in rows]
+                await session.execute(
+                    delete(table).where(table.c.agent_id == agent_id, ~tuple_(*[table.c[c] for c in pk_names]).in_(new_keys))
+                )
+            else:
+                # if no rows to insert, just delete all
+                await session.execute(delete(table).where(table.c.agent_id == agent_id))
+
+        elif dialect == "sqlite":
+            if rows:
+                stmt = sa.insert(table).values(rows).prefix_with("OR REPLACE")
+                await session.execute(stmt)
+
+            if rows:
+                primary_key_cols = [table.c[c.name] for c in table.primary_key.columns]
+                new_keys = [tuple(r[c.name] for c in table.primary_key.columns) for r in rows]
+                await session.execute(delete(table).where(table.c.agent_id == agent_id, ~tuple_(*primary_key_cols).in_(new_keys)))
+            else:
+                await session.execute(delete(table).where(table.c.agent_id == agent_id))
+
+        else:
+            # fallback: use original DELETE + INSERT pattern
+            await session.execute(delete(table).where(table.c.agent_id == agent_id))
+            if rows:
+                await AgentManager._bulk_insert_pivot_async(session, table, rows)
 
     # ======================================================================================================================
     # Basic CRUD operations

letta/services/file_manager.py

@@ -22,6 +22,15 @@ from letta.server.db import db_registry
 from letta.utils import enforce_types
 
 
+class DuplicateFileError(Exception):
+    """Raised when a duplicate file is encountered and error handling is specified"""
+
+    def __init__(self, filename: str, source_name: str):
+        self.filename = filename
+        self.source_name = source_name
+        super().__init__(f"File '{filename}' already exists in source '{source_name}'")
+
+
 class FileManager:
     """Manager class to handle business logic related to files."""
 
@@ -237,16 +246,16 @@ class FileManager:
     @trace_method
     async def generate_unique_filename(self, original_filename: str, source: PydanticSource, organization_id: str) -> str:
         """
-        Generate a unique filename by checking for duplicates and adding a numeric suffix if needed.
-        Similar to how filesystems handle duplicates (e.g., file.txt, file (1).txt, file (2).txt).
+        Generate a unique filename by adding a numeric suffix if duplicates exist.
+        Always returns a unique filename - does not handle duplicate policies.
 
         Parameters:
             original_filename (str): The original filename as uploaded.
-            source_id (str): Source ID to check for duplicates within.
+            source (PydanticSource): Source to check for duplicates within.
             organization_id (str): Organization ID to check for duplicates within.
 
         Returns:
-            str: A unique filename with numeric suffix if needed.
+            str: A unique filename with source.name prefix and numeric suffix if needed.
         """
         base, ext = os.path.splitext(original_filename)
 
@@ -271,9 +280,44 @@ class FileManager:
                 # No duplicates, return original filename with source.name
                 return f"{source.name}/{original_filename}"
             else:
-                # Add numeric suffix
+                # Add numeric suffix to make unique
                 return f"{source.name}/{base}_({count}){ext}"
 
+    @enforce_types
+    @trace_method
+    async def get_file_by_original_name_and_source(
+        self, original_filename: str, source_id: str, actor: PydanticUser
+    ) -> Optional[PydanticFileMetadata]:
+        """
+        Get a file by its original filename and source ID.
+
+        Parameters:
+            original_filename (str): The original filename to search for.
+            source_id (str): The source ID to search within.
+            actor (PydanticUser): The actor performing the request.
+
+        Returns:
+            Optional[PydanticFileMetadata]: The file metadata if found, None otherwise.
+        """
+        async with db_registry.async_session() as session:
+            query = (
+                select(FileMetadataModel)
+                .where(
+                    FileMetadataModel.original_file_name == original_filename,
+                    FileMetadataModel.source_id == source_id,
+                    FileMetadataModel.organization_id == actor.organization_id,
+                    FileMetadataModel.is_deleted == False,
+                )
+                .limit(1)
+            )
+
+            result = await session.execute(query)
+            file_orm = result.scalar_one_or_none()
+
+            if file_orm:
+                return await file_orm.to_pydantic_async()
+            return None
+
     @enforce_types
     @trace_method
     async def get_organization_sources_metadata(self, actor: PydanticUser) -> OrganizationSourcesStats:

letta/services/file_processor/file_processor.py

@@ -1,6 +1,7 @@
 from typing import List
 
 from letta.log import get_logger
+from letta.otel.context import get_ctx_attributes
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import FileProcessingStatus
@@ -122,6 +123,10 @@ class FileProcessor:
             if isinstance(content, str):
                 content = content.encode("utf-8")
 
+            from letta.otel.metric_registry import MetricRegistry
+
+            MetricRegistry().file_process_bytes_histogram.record(len(content), attributes=get_ctx_attributes())
+
             if len(content) > self.max_file_size:
                 log_event(
                     "file_processor.size_limit_exceeded",

letta/services/helpers/tool_parser_helper.py

@@ -1,7 +1,7 @@
 import ast
 import base64
 import pickle
-from typing import Any
+from typing import Any, Union
 
 from letta.constants import REQUEST_HEARTBEAT_DESCRIPTION, REQUEST_HEARTBEAT_PARAM, SEND_MESSAGE_TOOL_NAME
 from letta.schemas.agent import AgentState
@@ -9,7 +9,7 @@ from letta.schemas.response_format import ResponseFormatType, ResponseFormatUnio
 from letta.types import JsonDict, JsonValue
 
 
-def parse_stdout_best_effort(text: str | bytes) -> tuple[Any, AgentState | None]:
+def parse_stdout_best_effort(text: Union[str, bytes]) -> tuple[Any, AgentState | None]:
     """
     Decode and unpickle the result from the function execution if possible.
     Returns (function_return_value, agent_state).

letta/services/job_manager.py

@@ -2,6 +2,7 @@ from functools import partial, reduce
 from operator import add
 from typing import List, Literal, Optional, Union
 
+from httpx import AsyncClient, post
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
@@ -95,6 +96,8 @@ class JobManager:
     @trace_method
     async def update_job_by_id_async(self, job_id: str, job_update: JobUpdate, actor: PydanticUser) -> PydanticJob:
         """Update a job by its ID with the given JobUpdate object asynchronously."""
+        callback_func = None
+
         async with db_registry.async_session() as session:
             # Fetch the job by ID
             job = await self._verify_job_access_async(session=session, job_id=job_id, actor=actor, access=["write"])
@@ -114,11 +117,23 @@ class JobManager:
                 logger.info(f"Current job completed at: {job.completed_at}")
                 job.completed_at = get_utc_time().replace(tzinfo=None)
                 if job.callback_url:
-                    await self._dispatch_callback_async(job)
+                    callback_func = self._dispatch_callback_async(
+                        callback_url=job.callback_url,
+                        payload={
+                            "job_id": job.id,
+                            "status": job.status,
+                            "completed_at": job.completed_at.isoformat() if job.completed_at else None,
+                            "metadata": job.metadata_,
+                        },
+                        actor=actor,
+                    )
 
             # Save the updated job to the database
             await job.update_async(db_session=session, actor=actor)
 
+            if callback_func:
+                return await callback_func
+
             return job.to_pydantic()
 
     @enforce_types
@@ -683,10 +698,8 @@ class JobManager:
             "metadata": job.metadata_,
         }
         try:
-            import httpx
-
             log_event("POST callback dispatched", payload)
-            resp = httpx.post(job.callback_url, json=payload, timeout=5.0)
+            resp = post(job.callback_url, json=payload, timeout=5.0)
             log_event("POST callback finished")
             job.callback_sent_at = get_utc_time().replace(tzinfo=None)
             job.callback_status_code = resp.status_code
@@ -700,31 +713,33 @@ class JobManager:
             # Continue silently - callback failures should not affect job completion
 
     @trace_method
-    async def _dispatch_callback_async(self, job: JobModel) -> None:
+    async def _dispatch_callback_async(self, callback_url: str, payload: dict, actor: PydanticUser) -> PydanticJob:
         """
         POST a standard JSON payload to job.callback_url and record timestamp + HTTP status asynchronously.
         """
-        payload = {
-            "job_id": job.id,
-            "status": job.status,
-            "completed_at": job.completed_at.isoformat() if job.completed_at else None,
-            "metadata": job.metadata_,
-        }
+        job_id = payload["job_id"]
+        callback_sent_at, callback_status_code, callback_error = None, None, None
 
         try:
-            import httpx
-
-            async with httpx.AsyncClient() as client:
+            async with AsyncClient() as client:
                 log_event("POST callback dispatched", payload)
-                resp = await client.post(job.callback_url, json=payload, timeout=5.0)
+                resp = await client.post(callback_url, json=payload, timeout=5.0)
                 log_event("POST callback finished")
                 # Ensure timestamp is timezone-naive for DB compatibility
-                job.callback_sent_at = get_utc_time().replace(tzinfo=None)
-                job.callback_status_code = resp.status_code
+                callback_sent_at = get_utc_time().replace(tzinfo=None)
+                callback_status_code = resp.status_code
         except Exception as e:
-            error_message = f"Failed to dispatch callback for job {job.id} to {job.callback_url}: {e!s}"
+            error_message = f"Failed to dispatch callback for job {job_id} to {callback_url}: {e!s}"
             logger.error(error_message)
             # Record the failed attempt
-            job.callback_sent_at = get_utc_time().replace(tzinfo=None)
-            job.callback_error = error_message
+            callback_sent_at = get_utc_time().replace(tzinfo=None)
+            callback_error = error_message
             # Continue silently - callback failures should not affect job completion
+
+        async with db_registry.async_session() as session:
+            job = await JobModel.read_async(db_session=session, identifier=job_id, actor=actor, access_type=AccessType.USER)
+            job.callback_sent_at = callback_sent_at
+            job.callback_status_code = callback_status_code
+            job.callback_error = callback_error
+            await job.update_async(db_session=session, actor=actor)
+            return job.to_pydantic()

letta/services/tool_sandbox/local_sandbox.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Optional
 
 from pydantic.config import JsonDict
 
+from letta.log import get_logger
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.sandbox_config import SandboxConfig, SandboxType
@@ -23,6 +24,8 @@ from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.settings import tool_settings
 from letta.utils import get_friendly_error_msg, parse_stderr_error_msg
 
+logger = get_logger(__name__)
+
 
 class AsyncToolSandboxLocal(AsyncToolSandboxBase):
     METADATA_CONFIG_STATE_KEY = "config_state"
@@ -240,9 +243,9 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
             if isinstance(e, TimeoutError):
                 raise e
 
-            print(f"Subprocess execution for tool {self.tool_name} encountered an error: {e}")
-            print(e.__class__.__name__)
-            print(e.__traceback__)
+            logger.error(f"Subprocess execution for tool {self.tool_name} encountered an error: {e}")
+            logger.error(e.__class__.__name__)
+            logger.error(e.__traceback__)
             func_return = get_friendly_error_msg(
                 function_name=self.tool_name,
                 exception_name=type(e).__name__,

letta/templates/sandbox_code_file.py.j2

@@ -24,8 +24,32 @@ agent_state = {{ 'pickle.loads(' ~ agent_state_pickle ~ ')' if agent_state_pickl
 {{ tool_source_code }}
 
 {# Invoke the function and store the result in a global variable #}
+_function_result = {{ invoke_function_call }}
+
+{# Use a temporary Pydantic wrapper to recursively serialize any nested Pydantic objects #}
+try:
+    from pydantic import BaseModel
+    from typing import Any
+
+    class _TempResultWrapper(BaseModel):
+        result: Any
+
+        class Config:
+            arbitrary_types_allowed = True
+
+    _wrapped = _TempResultWrapper(result=_function_result)
+    _serialized_result = _wrapped.model_dump()['result']
+except ImportError:
+    # Pydantic not available in sandbox, fall back to string conversion
+    print("Pydantic not available in sandbox environment, falling back to string conversion")
+    _serialized_result = str(_function_result)
+except Exception as e:
+    # If wrapping fails, print the error and stringify the result
+    print(f"Failed to serialize result with Pydantic wrapper: {e}")
+    _serialized_result = str(_function_result)
+
 {{ local_sandbox_result_var_name }} = {
-    "results": {{ invoke_function_call }},
+    "results": _serialized_result,
     "agent_state": agent_state
 }
 

letta/templates/sandbox_code_file_async.py.j2

@@ -26,9 +26,32 @@ agent_state = {{ 'pickle.loads(' ~ agent_state_pickle ~ ')' if agent_state_pickl
 
 {# Async wrapper to handle the function call and store the result #}
 async def _async_wrapper():
-    result = await {{ invoke_function_call }}
+    _function_result = await {{ invoke_function_call }}
+
+    {# Use a temporary Pydantic wrapper to recursively serialize any nested Pydantic objects #}
+    try:
+        from pydantic import BaseModel
+        from typing import Any
+
+        class _TempResultWrapper(BaseModel):
+            result: Any
+
+            class Config:
+                arbitrary_types_allowed = True
+
+        _wrapped = _TempResultWrapper(result=_function_result)
+        _serialized_result = _wrapped.model_dump()['result']
+    except ImportError:
+        # Pydantic not available in sandbox, fall back to string conversion
+        print("Pydantic not available in sandbox environment, falling back to string conversion")
+        _serialized_result = str(_function_result)
+    except Exception as e:
+        # If wrapping fails, print the error and stringify the result
+        print(f"Failed to serialize result with Pydantic wrapper: {e}")
+        _serialized_result = str(_function_result)
+
     return {
-        "results": result,
+        "results": _serialized_result,
         "agent_state": agent_state
     }
 

{letta_nightly-0.8.12.dev20250710104356.dist-info → letta_nightly-0.8.13.dev20250710230421.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.12.dev20250710104356
+Version: 0.8.13.dev20250710230421
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -19,13 +19,13 @@ Provides-Extra: dev
 Provides-Extra: experimental
 Provides-Extra: external-tools
 Provides-Extra: google
+Provides-Extra: pinecone
 Provides-Extra: postgres
 Provides-Extra: redis
 Provides-Extra: server
 Provides-Extra: tests
 Requires-Dist: aioboto3 (>=14.3.0,<15.0.0) ; extra == "bedrock"
 Requires-Dist: aiomultiprocess (>=0.9.1,<0.10.0)
-Requires-Dist: aiosqlite (>=0.21.0,<0.22.0)
 Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: anthropic (>=0.49.0,<0.50.0)
 Requires-Dist: apscheduler (>=3.11.0,<4.0.0)
@@ -56,7 +56,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.183,<0.2.0)
+Requires-Dist: letta_client (>=0.1.197,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
@@ -75,7 +75,7 @@ Requires-Dist: pathvalidate (>=3.2.1,<4.0.0)
 Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres" or extra == "desktop" or extra == "all"
 Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres" or extra == "desktop" or extra == "all"
-Requires-Dist: pinecone[asyncio] (>=7.3.0,<8.0.0)
+Requires-Dist: pinecone[asyncio] (>=7.3.0,<8.0.0) ; extra == "pinecone" or extra == "all"
 Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: prettytable (>=3.9.0,<4.0.0)
 Requires-Dist: psycopg2 (>=2.9.10,<3.0.0) ; extra == "postgres" or extra == "desktop" or extra == "all"

{letta_nightly-0.8.12.dev20250710104356.dist-info → letta_nightly-0.8.13.dev20250710230421.dist-info}/RECORD

@@ -1,12 +1,12 @@
-letta/__init__.py,sha256=O18yG1Lw_7vBqjWzHjZ1QG1xU3TTjRvuxL3iG4G-GxM,1222
+letta/__init__.py,sha256=P44L6tH5GEgZx3hAnIaAoBytfTCJGpqFrCashKMQmZ8,1222
 letta/agent.py,sha256=esW2W5hBzO7aPr7ghEDb_fLnUxgYqBYDq_VWtQDrB0c,89153
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/agents/base_agent.py,sha256=Z1jgCTMFRTLnaLRcfdo8TmsP8tuCYqNcOM8ov9kviMA,6869
+letta/agents/base_agent.py,sha256=35JcOjA6FUuQRIf4CiPnJSwgniCaDrjM-fVlWmIk68E,7766
 letta/agents/ephemeral_agent.py,sha256=el-SUF_16vv_7OouIR-6z0pAE9Yc0PLibygvfCKwqfo,2736
 letta/agents/ephemeral_summary_agent.py,sha256=tOldA_daa_PduTJ2RA7fAo9Rv6sUb-C_9dJaD6iujS4,4454
 letta/agents/exceptions.py,sha256=BQY4D4w32OYHM63CM19ko7dPwZiAzUs3NbKvzmCTcJg,318
 letta/agents/helpers.py,sha256=reSrQCEgIz8wE2FKIr-Gm6jsJeihS607BPqFVs_jaK0,10025
-letta/agents/letta_agent.py,sha256=71KuwatbeW3d8KY2aOOARKuelKBjwB3jMm_mfB-5EBM,56825
+letta/agents/letta_agent.py,sha256=5xpKc9qfbjqdkbG5kzjYJ7MdfRAOLeYfHGj0jbmWZGA,57723
 letta/agents/letta_agent_batch.py,sha256=cl9_nZYflIZWR23D_x_fUpmMHYITDWu0FUfPW1ivDuw,28031
 letta/agents/voice_agent.py,sha256=73zvqCivmKIW-5yQcRziuUqA3EDBGcfgHu3pKGzx0lc,23465
 letta/agents/voice_sleeptime_agent.py,sha256=ByRRoH115SaDr0ORMimQdYBWdz6c2RlFWQjVrFiGniQ,8743
@@ -25,7 +25,7 @@ letta/data_sources/redis_client.py,sha256=6hQLdfsJ3ejNvLuA9Md7YXisgjqBiaw-Yl89xf
 letta/embeddings.py,sha256=KvC2bl5tARpVY9xcFmw4Cwu1vN0DoH266v2mSUZqwkY,10528
 letta/errors.py,sha256=Ef10b2cHXJJ04rXBmOx4Yrr4qwqCh8bAImgoUExahEo,7063
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/functions/ast_parsers.py,sha256=lEmjIzGrTjlDJFAX-gjg0dU2CIBu6Vo4msSq-fhhup4,4969
+letta/functions/ast_parsers.py,sha256=0dXAN4qx3pWL_Y0aoEkaBpMKwI-kpoLEJftjW3v2I4E,5031
 letta/functions/async_composio_toolset.py,sha256=IuhZTVghPDXRsehOOZsEEiJGYyjWjDTQc2xrjTg0yBo,4786
 letta/functions/composio_helpers.py,sha256=mpybCYcB93HWoKrmQIqcuRQG9IH2lHWhsPQx2i8XP_8,3593
 letta/functions/function_sets/base.py,sha256=FS-LRbvzO-duSUy0yLP_fBk2WSs4NAaaTAUuhl2ZS-I,16154
@@ -57,9 +57,9 @@ letta/helpers/composio_helpers.py,sha256=MwfmLt7tgjvxAXLHpx9pa5QolxcqoCbofb-30-D
 letta/helpers/converters.py,sha256=_-6Ke5ZUtaKYmh8SncGj1ejTG3GyKhZ4ByVCrlcHsOI,15026
 letta/helpers/datetime_helpers.py,sha256=8AwZInX-NX_XQiqej2arozYqfC2ysnWpCJ9ETv8RdL0,4381
 letta/helpers/decorators.py,sha256=jyywXMxO5XPDSe93ybVXIOjTWkGX514S9BMcy_gP0j8,5891
-letta/helpers/json_helpers.py,sha256=PWZ5HhSqGXO4e563dM_8M72q7ScirjXQ4Rv1ckohaV8,396
+letta/helpers/json_helpers.py,sha256=9W_1dhNnXWdQLiZD3tO9047cB2ATrCAYVHnYGvT8Ke0,470
 letta/helpers/message_helper.py,sha256=Xzf_VCMAXT0Ys8LVUh1ySVtgJwabSQYksOdPr7P4EJU,3549
-letta/helpers/pinecone_utils.py,sha256=LMfrynzenK_IuVGEsZmULz4AAtZ58Wof02ENj-NwtLQ,6511
+letta/helpers/pinecone_utils.py,sha256=cF5VeEmENCepbaNT7_cEpiHU3U0x-32g0AG1d4OF73A,7461
 letta/helpers/singleton.py,sha256=Y4dG_ZBCcrogvl9iZ69bSLq-QltrdP8wHqKkhef8OBI,370
 letta/helpers/tool_execution_helper.py,sha256=BgBgVLZzbc-JTdOGwyU9miV_-zM3A30jkMpwH1otxaU,7599
 letta/helpers/tool_rule_solver.py,sha256=avRMQzqxE2r6gRvw7oTImYmkSvuoMHlADPND0__feBw,11620
@@ -75,7 +75,7 @@ letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/jobs/helpers.py,sha256=kO4aj954xsQ1RAmkjY6LQQ7JEIGuhaxB1e9pzrYKHAY,914
 letta/jobs/llm_batch_job_polling.py,sha256=HUCTa1lTOiLAB_8m95RUfeNJa4lxlF8paGdCV1NqOeA,10413
-letta/jobs/scheduler.py,sha256=_KkOp0uL8C7WpZEwCvHYtvtEjU6RBFXzcS8dnv7fhUM,8947
+letta/jobs/scheduler.py,sha256=Ub5VTCA8P5C9Y-0mPK2YIPJSEzKbSd2l5Sp0sOWctD8,8697
 letta/jobs/types.py,sha256=K8GKEnqEgAT6Kq4F2hUrBC4ZAFM9OkfOjVMStzxKuXQ,742
 letta/llm_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/llm_api/anthropic.py,sha256=tbMy4483TySrEmbXD3juM6TpPRrV9_M3Fgp59sDBcqE,47935
@@ -180,7 +180,7 @@ letta/orm/user.py,sha256=rK5N5ViDxmesZMqVVHB7FcQNpcSoM-hB42MyI6q3MnI,1004
 letta/otel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/otel/context.py,sha256=GUTxFpWMdCmib1Qy80TpAs0Qb5fNH_m5sCYZ1LN3HmM,789
 letta/otel/events.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/otel/metric_registry.py,sha256=QWgOzHt-UoeQetYB8o0aXzrIspyNnsDvBFx8jNIw8LI,5493
+letta/otel/metric_registry.py,sha256=DDsN0edcbs-BgVo_FPvcx8Sdpz10N0u6YaIFuHI2PpU,6039
 letta/otel/metrics.py,sha256=GlIt8XLkP-igTXptah8UBonpHF7nEtSqTONSkAEERAs,4740
 letta/otel/resource.py,sha256=3T8dcmHMxsgSi-kKIGFW1T56EkZbdbbWPkICH0kba7I,719
 letta/otel/tracing.py,sha256=EoSA5WxWpcHrDZhM1h7mplu3RyHuxfbb4Atw5LzR7yI,8840
@@ -232,7 +232,7 @@ letta/schemas/agent.py,sha256=vu3-sPanrFmXueh2FgS2h-BlllXr4tB-KNzrucZLdf4,25231
 letta/schemas/block.py,sha256=awxCQKxmv4I4k9Au5h-a2RCeSVF54EfWyBQPtHRwuNQ,5585
 letta/schemas/embedding_config.py,sha256=huMcqUbSUDwAbd7IkjzxDSmOxGCJG_0eMqPqLj6B8JE,3886
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
-letta/schemas/enums.py,sha256=Vx6qTUtOTphAkqJ932yXxsWELcrmV2XH2avvyOhQZ4E,3295
+letta/schemas/enums.py,sha256=QU6WneYqWtPqL9Z8o8wEw55uheS8df8dRPc7W7-naXI,3606
 letta/schemas/environment_variables.py,sha256=VRtzOjdeQdHcSHXisk7oJUQlheruxhSWNS0xqlfGzbs,2429
 letta/schemas/file.py,sha256=lJFQfUCf6iqtbyqxynL98fupDobnRPsoc2GrhgYJaig,4595
 letta/schemas/group.py,sha256=0qFbCvE5gbdSAk1oXXT8xWQ02R4mS_jttJm0ASh8eCQ,6415
@@ -267,7 +267,7 @@ letta/schemas/sandbox_config.py,sha256=thI4p7R4nnW1W-F_PBNkpmyHXpSH_lorlQX8YxDXS
 letta/schemas/source.py,sha256=ZDeTjkNp1rKamG7xZzoUHeCptjpW9WNLzAcJ9QQRxlM,3444
 letta/schemas/source_metadata.py,sha256=_dGjuXhGcVMlc53ja9yuk16Uj64ggEzilRDgmkqYfNs,1334
 letta/schemas/step.py,sha256=QudHSpLMcNVC-oI26Uy48lsp3FOrcd3JYAp5ubDEIHY,2651
-letta/schemas/tool.py,sha256=C2HdnmwrjAWoBjB8H2lpO8oIys3HlkRrRWtR8uMcUfc,14375
+letta/schemas/tool.py,sha256=DO0kPVQWR5_A6YHQ4VJbsyWwwjEgvYyT4yBHaZX4uxE,14397
 letta/schemas/tool_execution_result.py,sha256=4P77llsUsZBnRd0PtPiC4VzGjx7i_-fUNgXQfCpMS9U,896
 letta/schemas/tool_rule.py,sha256=dJ-qNDy0LneTt_DhKXsRyC9NAJxZ_aWY3IRpzGuH_sY,10910
 letta/schemas/usage.py,sha256=9SSTH5kUliwiVF14b-yKbDcmxQBOLg4YH5xhXDbW9UU,1281
@@ -287,7 +287,7 @@ letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/db.py,sha256=q5wCpTxpcbutk2HuF2ZpyhlPGCdUuLpRFZ0QE5VkZ38,11751
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=JEJlOKBPKfnkQeM6BAd5Olf4EM7O2TKD4_MHObFuci8,18084
+letta/server/rest_api/app.py,sha256=zzK9W4ZcosJvNtWjvWr8aHPKA-v3u1G2wQlEnX_sdWQ,18165
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
@@ -298,7 +298,7 @@ letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=QBWab1fn2LXVDMtc6li3gOzmrNzDiUw5WUJsMeeMZII,5076
 letta/server/rest_api/routers/v1/__init__.py,sha256=JfSSttkEWu0W18NVVDxl8AGnd8Qhj0BXJNxntOB7070,1768
-letta/server/rest_api/routers/v1/agents.py,sha256=i0zS-tEZlMf2gfVy-NOq-4mgicJHQBpqRJTLsRUU6L4,52709
+letta/server/rest_api/routers/v1/agents.py,sha256=KuQB05DedF7wg72PD4dKz-W06QAjVJutUX6FB0dW9HM,55520
 letta/server/rest_api/routers/v1/blocks.py,sha256=MArBBnC7k9bc-Z1xMf46aH4ij6qhKAQAOoK9KjiXatU,5257
 letta/server/rest_api/routers/v1/embeddings.py,sha256=PRaQlrmEXPiIdWsTbadrFsv3Afyv5oEFUdhgHA8FTi8,989
 letta/server/rest_api/routers/v1/groups.py,sha256=kR_oAuwPd9q-DaeK4Q6Xqu1XlXTXkwEvf2hH7tOiVuw,10978
@@ -311,7 +311,7 @@ letta/server/rest_api/routers/v1/organizations.py,sha256=5NEjTOdGKWrfN584jfPpJhA
 letta/server/rest_api/routers/v1/providers.py,sha256=8SJ_RsSk7L4nh1f_uFE31JOxefmGhOfN-fMJ0Sp6SJo,4353
 letta/server/rest_api/routers/v1/runs.py,sha256=vieUp7uTvRTdAte0Nw1bqX2APMATZhKTr2R1HVNJT74,8879
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=pKuy88GD3atrBkKa7VVfKTjg8Y07e1vVtdw4TtxkQBk,8910
-letta/server/rest_api/routers/v1/sources.py,sha256=RfCp7XCFpEIF6eTHfbKXvE7mAdHFUrpDU_AXbwvJj3o,19584
+letta/server/rest_api/routers/v1/sources.py,sha256=ImunBc5PKO5sFtYLtJ1qOZ0kt5ZXckfr242qtWJrP30,20768
 letta/server/rest_api/routers/v1/steps.py,sha256=N863b0Oyzz64rKHqpyQnXEQBw0SCQ8kAxWaZ7huV1Rk,4925
 letta/server/rest_api/routers/v1/tags.py,sha256=ef94QitUSJ3NQVffWF1ZqANUZ2b2jRyGHp_I3UUjhno,912
 letta/server/rest_api/routers/v1/telemetry.py,sha256=z53BW3Pefi3eWy47FPJyGhFWbZicX9jPJUi5LC5c3sk,790
@@ -335,12 +335,12 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=7xdWIchSUmlPCnNRsXjzd-9EKyk05t9WpGaerMwJLkg,121953
+letta/services/agent_manager.py,sha256=yZ52BHJ0XyngIQUHkAQQ9cSh73c3WFwP4uezmyf7u8w,123384
 letta/services/block_manager.py,sha256=7EliXd0-LpSRwD2LbyjFpH5uiBdrtdZ6YLgb2_wKs3o,22905
 letta/services/context_window_calculator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/context_window_calculator/context_window_calculator.py,sha256=H0-Ello1DHV28MnzMseWrg--jarDc6YwCcgwPlWjtZk,6527
 letta/services/context_window_calculator/token_counter.py,sha256=Ai9-aPkNvhhMTj9zlvdiQAdVqroTzIyAn0TrHpHNQZY,2954
-letta/services/file_manager.py,sha256=Zm0wK4pkKz_rkPtANZCaxp2mXgi6rWg9moJ-nic6Bms,14277
+letta/services/file_manager.py,sha256=yxBRGKBpCcV7FnllMymYGJheUsfttbI6s-zUr3G3CKo,15938
 letta/services/file_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/chunker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/chunker/line_chunker.py,sha256=m02molsKXU_RUEebbHhMA6LNxg3JmFlCTOuX6kZcz3E,7024
@@ -349,7 +349,7 @@ letta/services/file_processor/embedder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 letta/services/file_processor/embedder/base_embedder.py,sha256=cuHF2kAlBFL9Hr63Q5vJQYYrfyDNtm31vYvW5boUQ58,518
 letta/services/file_processor/embedder/openai_embedder.py,sha256=qafYDdbbBDCv5Mg-gdZozc5qFCdraaG8B8OCLd8_3vY,5715
 letta/services/file_processor/embedder/pinecone_embedder.py,sha256=O33NGvDyOG07Iz-tEhZDu_PKq7NfWIaBzjJuLi8hDiU,2841
-letta/services/file_processor/file_processor.py,sha256=E2lEoootYA8mAgNKGq2u2KCVqJqg8QCAO3-3pVaV60U,10047
+letta/services/file_processor/file_processor.py,sha256=vjl_pcwqDIMOhDDGbJQuL4oUXRVHm_o_mgy7kXQUanQ,10277
 letta/services/file_processor/file_types.py,sha256=9k3Lt_bquQjJ7T6L12fPS9IS5wldhJ2puSkH6rhfCaE,13128
 letta/services/file_processor/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/parser/base_parser.py,sha256=WfnXP6fL-xQz4eIHEWa6-ZNEAARbF_alowqH4BAUzJo,238
@@ -359,9 +359,9 @@ letta/services/files_agents_manager.py,sha256=4o9GtgTpmPvpppvgcTJi8MqPDsGwDnt6Cu
 letta/services/group_manager.py,sha256=X2gKKUGKTXGRMC8YjwmE6EOB1cVM4lo31eCnmog7dPQ,23368
 letta/services/helpers/agent_manager_helper.py,sha256=8of5EgKA9-Y-s0ovD0NwTnOiaW-z8kBlKleZqnrwy5g,44034
 letta/services/helpers/tool_execution_helper.py,sha256=45L7woJ98jK5MQAnhE_4NZdCeyOOzC4328FTQPM7iTA,9159
-letta/services/helpers/tool_parser_helper.py,sha256=EI5tcre-D5U3mEzIMhfkAGlUwYckW1JlCJ-iqwoTTrc,4336
+letta/services/helpers/tool_parser_helper.py,sha256=_3oAVRVfRaicGpO6qRKAlCAujZw2uBGUclei4FUC6Do,4349
 letta/services/identity_manager.py,sha256=L8EYGYXA9sveLwPCTYZIdYZwOMnHex47TBiMYcco_y4,10575
-letta/services/job_manager.py,sha256=JVmMF9N7pQlbb4zcXMvpDLqTYEhxk8lT18c0U0uYVTo,27922
+letta/services/job_manager.py,sha256=TQZLxPtoF9BzSpLaMgA1xD7PZ_qjONTjM48bID88W30,28803
 letta/services/llm_batch_manager.py,sha256=SJXzlhg9yu8EIal8WiZFRez-CMhqUVxEW42cQPxG1OQ,20824
 letta/services/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/mcp/base_client.py,sha256=8PtauZGtXU2pks5Beggz4BOoE_Bas3LDeBXv1xNLfJ0,4461
@@ -397,21 +397,21 @@ letta/services/tool_manager.py,sha256=6VI3mjXa6-vrPA74Aar_-ti9Rn3EEBq5TIiayyzoVA
 letta/services/tool_sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_sandbox/base.py,sha256=Vt4CnxuY5otUD6Kv8PpJNrAtl9eI8tjfcwkOdtUFwKg,7917
 letta/services/tool_sandbox/e2b_sandbox.py,sha256=TrWWav56H1AsnaKgNZuq0RI-FeWHOZvOubtUywPH72s,11125
-letta/services/tool_sandbox/local_sandbox.py,sha256=mDMoBUl0asu03p7gp2BlzBCna68esMqIRwWF_dzteCA,11937
+letta/services/tool_sandbox/local_sandbox.py,sha256=P6FH-2zNq3MQSuHZe790-G982c7rq2gwOUee-U5hlgk,12022
 letta/services/user_manager.py,sha256=Neik-mxXgf9jc9jBiiBIlK38UukJonUy9NRS2soFR98,10405
 letta/settings.py,sha256=lWaLL1t06s9pp4VK5ojQvTiI7D85VcJPjaVKak5LFxs,11304
 letta/streaming_interface.py,sha256=c-T7zoMTXGXFwDWJJXrv7UypeMPXwPOmNHeuuh0b9zk,16398
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
 letta/system.py,sha256=-cfh9Xpl2Ef_H7N3oZQtNuJqb1EEskdDXNa-VwKsF0A,8977
 letta/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/templates/sandbox_code_file.py.j2,sha256=zgzaboDZVtM15XkxILnhiKisF7DSUoI2YpfK2xF2WB0,1379
-letta/templates/sandbox_code_file_async.py.j2,sha256=hL6UWt4L16o79OPOBq1_Cw7gR5-gpaR_esbmU8bSp8w,1805
+letta/templates/sandbox_code_file.py.j2,sha256=-tLXbRjWaXGhj82oVKbRRMOakTRcuy5bwBTa_ak1GjU,2260
+letta/templates/sandbox_code_file_async.py.j2,sha256=TmhqHHm83jNVPm2azkhxCygEJzMEczzPlDjqrkP5HAs,2742
 letta/templates/summary_request_text.j2,sha256=ZttQwXonW2lk4pJLYzLK0pmo4EO4EtUUIXjgXKiizuc,842
 letta/templates/template_helper.py,sha256=uHWO1PukgMoIIvgqQdPyHq3o3CQ6mcjUjTGvx9VLGkk,409
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
 letta/utils.py,sha256=4segcFYPNsPrzMpiouYoV6Qzj4TIHuqtCyzVwAMildM,36172
-letta_nightly-0.8.12.dev20250710104356.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.8.12.dev20250710104356.dist-info/METADATA,sha256=kL1xk74S1rsRef_Byt0LgX5jXjWf1JMHMGWvX2ShA7k,22892
-letta_nightly-0.8.12.dev20250710104356.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.8.12.dev20250710104356.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.8.12.dev20250710104356.dist-info/RECORD,,
+letta_nightly-0.8.13.dev20250710230421.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.8.13.dev20250710230421.dist-info/METADATA,sha256=X9rQMXAA8UdRgxmuf86otSrDA5afl8VJQNUvyfF_P-I,22913
+letta_nightly-0.8.13.dev20250710230421.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.8.13.dev20250710230421.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.8.13.dev20250710230421.dist-info/RECORD,,