letta-nightly 0.8.12.dev20250710104356__tar.gz → 0.8.13.dev20250711104347__tar.gz

{letta_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.8.12.dev20250710104356
+Version: 0.8.13.dev20250711104347
 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 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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_nightly-0.8.12.dev20250710104356 → letta_nightly-0.8.13.dev20250711104347}/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,