Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
chore: bump version 0.8.13 (#2718)
cthomas7132104f4d4d
diff --git a/letta/__init__.py b/letta/__init__.pyindex f7de8edc4..3aae91bf3 100644--- a/letta/__init__.py+++ b/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"]diff --git a/letta/agents/base_agent.py b/letta/agents/base_agent.pyindex b86132015..a556ab732 100644--- a/letta/agents/base_agent.py+++ b/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 = Noneif 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 thiscurr_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_messagesmemory_edit_timestamp = get_utc_time()- # [DB Call] size of messages and archival memories- # todo: blocking for now+ # size of messages and archival memoriesif 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:diff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.pyindex 9a6aaadb5..7ab25738a 100644--- a/letta/agents/letta_agent.py+++ b/letta/agents/letta_agent.py@@ -3,7 +3,7 @@ import jsonimport uuidfrom collections.abc import AsyncGeneratorfrom datetime import datetime-from typing import Optional+from typing import Optional, Unionfrom openai import AsyncStreamfrom 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 functionsagent_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 = resultreturn _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 agent1. 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,diff --git a/letta/functions/ast_parsers.py b/letta/functions/ast_parsers.pyindex 57785b461..627b7fdb7 100644--- a/letta/functions/ast_parsers.py+++ b/letta/functions/ast_parsers.py@@ -129,7 +129,8 @@ def get_function_name_and_docstring(source_code: str, name: Optional[str] = Noneraise 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, docstringdiff --git a/letta/helpers/json_helpers.py b/letta/helpers/json_helpers.pyindex 3a1af4126..45fa3414e 100644--- a/letta/helpers/json_helpers.py+++ b/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)diff --git a/letta/helpers/pinecone_utils.py b/letta/helpers/pinecone_utils.pyindex d51b071d4..f583b9334 100644--- a/letta/helpers/pinecone_utils.py+++ b/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 = Falsefrom 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, chasync 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_idtry:@@ -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_idtry:@@ -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_idtry:diff --git a/letta/jobs/scheduler.py b/letta/jobs/scheduler.pyindex df220e4b1..1e6867b22 100644--- a/letta/jobs/scheduler.py+++ b/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 = Nonelock_session = Noneacquired_lock = Falsetry:@@ -36,32 +37,25 @@ async def _try_acquire_lock_and_start_scheduler(server: SyncServer) -> bool:engine = session.get_bind()engine_name = engine.namelogger.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 = Trueelse:- 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 = Nonetrigger = 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_sessionawait _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):breakexcept 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_sessionif 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 = Noneexcept Exception as e:logger.error(f"Error closing advisory lock session: {e}", exc_info=True)else:diff --git a/letta/otel/metric_registry.py b/letta/otel/metric_registry.pyindex c5b242f33..f3069a9e7 100644--- a/letta/otel/metric_registry.py+++ b/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",+ ),+ )diff --git a/letta/schemas/enums.py b/letta/schemas/enums.pyindex f4cd35f8b..cbe922ca7 100644--- a/letta/schemas/enums.py+++ b/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)diff --git a/letta/schemas/tool.py b/letta/schemas/tool.pyindex a9a41b2b0..dde4975ff 100644--- a/letta/schemas/tool.py+++ b/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_schemaif 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 hereself.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 populatedif 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 providedif not self.name:diff --git a/letta/server/rest_api/app.py b/letta/server/rest_api/app.pyindex 8ddb175f0..c630e2f59 100644--- a/letta/server/rest_api/app.py+++ b/letta/server/rest_api/app.py@@ -337,8 +337,11 @@ def create_application() -> "FastAPI":# / static filesmount_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 appdiff --git a/letta/server/rest_api/routers/v1/agents.py b/letta/server/rest_api/routers/v1/agents.pyindex 6f0df27d9..fee2de035 100644--- a/letta/server/rest_api/routers/v1/agents.py+++ b/letta/server/rest_api/routers/v1/agents.py@@ -2,7 +2,7 @@ import asyncioimport jsonimport tracebackfrom datetime import datetime, timezone-from typing import Annotated, Any, List, Optional+from typing import Annotated, Any, Dict, List, Optional, Unionfrom fastapi import APIRouter, Body, Depends, File, Header, HTTPException, Query, Request, UploadFile, statusfrom 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)+ "/{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,diff --git a/letta/server/rest_api/routers/v1/sources.py b/letta/server/rest_api/routers/v1/sources.pyindex 48049d730..e7ab53701 100644--- a/letta/server/rest_api/routers/v1/sources.py+++ b/letta/server/rest_api/routers/v1/sources.py@@ -19,7 +19,7 @@ from letta.log import get_loggerfrom letta.otel.tracing import trace_methodfrom letta.schemas.agent import AgentStatefrom letta.schemas.embedding_config import EmbeddingConfig-from letta.schemas.enums import FileProcessingStatus+from letta.schemas.enums import DuplicateFileHandling, FileProcessingStatusfrom letta.schemas.file import FileMetadatafrom letta.schemas.passage import Passagefrom 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 logicoriginal_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_metadatadiff --git a/letta/services/agent_manager.py b/letta/services/agent_manager.pyindex 3e17740f4..2bc792806 100644--- a/letta/services/agent_manager.py+++ b/letta/services/agent_manager.py@@ -4,7 +4,7 @@ from datetime import datetime, timezonefrom typing import Dict, List, Optional, Set, Tupleimport 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_insertfrom letta.constants import (@@ -224,13 +224,44 @@ class AgentManager:@staticmethodasync 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 operationsdiff --git a/letta/services/file_manager.py b/letta/services/file_manager.pyindex f4a84fb3c..530fa3e15 100644--- a/letta/services/file_manager.py+++ b/letta/services/file_manager.py@@ -22,6 +22,15 @@ from letta.server.db import db_registryfrom 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_methodasync 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.namereturn f"{source.name}/{original_filename}"else:- # Add numeric suffix+ # Add numeric suffix to make uniquereturn 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_methodasync def get_organization_sources_metadata(self, actor: PydanticUser) -> OrganizationSourcesStats:diff --git a/letta/services/file_processor/file_processor.py b/letta/services/file_processor/file_processor.pyindex 07b324c97..4dec0ac22 100644--- a/letta/services/file_processor/file_processor.py+++ b/letta/services/file_processor/file_processor.py@@ -1,6 +1,7 @@from typing import Listfrom letta.log import get_logger+from letta.otel.context import get_ctx_attributesfrom letta.otel.tracing import log_event, trace_methodfrom letta.schemas.agent import AgentStatefrom 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",diff --git a/letta/services/helpers/tool_parser_helper.py b/letta/services/helpers/tool_parser_helper.pyindex f38de9298..8bc5333bd 100644--- a/letta/services/helpers/tool_parser_helper.py+++ b/letta/services/helpers/tool_parser_helper.py@@ -1,7 +1,7 @@import astimport base64import pickle-from typing import Any+from typing import Any, Unionfrom letta.constants import REQUEST_HEARTBEAT_DESCRIPTION, REQUEST_HEARTBEAT_PARAM, SEND_MESSAGE_TOOL_NAMEfrom letta.schemas.agent import AgentState@@ -9,7 +9,7 @@ from letta.schemas.response_format import ResponseFormatType, ResponseFormatUniofrom 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).diff --git a/letta/services/job_manager.py b/letta/services/job_manager.pyindex 5b8e26933..dbba4a91d 100644--- a/letta/services/job_manager.py+++ b/letta/services/job_manager.py@@ -2,6 +2,7 @@ from functools import partial, reducefrom operator import addfrom typing import List, Literal, Optional, Union+from httpx import AsyncClient, postfrom sqlalchemy import selectfrom sqlalchemy.orm import Session@@ -95,6 +96,8 @@ class JobManager:@trace_methodasync 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 IDjob = 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 databaseawait 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, Nonetry:- 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_codeexcept 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()diff --git a/letta/services/tool_sandbox/local_sandbox.py b/letta/services/tool_sandbox/local_sandbox.pyindex 3f24fca13..5056adde5 100644--- a/letta/services/tool_sandbox/local_sandbox.py+++ b/letta/services/tool_sandbox/local_sandbox.py@@ -8,6 +8,7 @@ from typing import Any, Dict, Optionalfrom pydantic.config import JsonDict+from letta.log import get_loggerfrom letta.otel.tracing import log_event, trace_methodfrom letta.schemas.agent import AgentStatefrom letta.schemas.sandbox_config import SandboxConfig, SandboxType@@ -23,6 +24,8 @@ from letta.services.tool_sandbox.base import AsyncToolSandboxBasefrom letta.settings import tool_settingsfrom 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__,diff --git a/letta/templates/sandbox_code_file.py.j2 b/letta/templates/sandbox_code_file.py.j2index 953b8ae86..3f4c45175 100644--- a/letta/templates/sandbox_code_file.py.j2+++ b/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}diff --git a/letta/templates/sandbox_code_file_async.py.j2 b/letta/templates/sandbox_code_file_async.py.j2index 6ed9cdbe2..33c8971da 100644--- a/letta/templates/sandbox_code_file_async.py.j2+++ b/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}diff --git a/poetry.lock b/poetry.lockindex 763cf6a85..f771114bd 100644--- a/poetry.lock+++ b/poetry.lock@@ -186,9 +186,10 @@ speedups = ["Brotli ; platform_python_implementation == \"CPython\"", "aiodns (>name = "aiohttp-retry"version = "2.9.1"description = "Simple retry client for aiohttp"-optional = false+optional = truepython-versions = ">=3.7"groups = ["main"]+markers = "extra == \"pinecone\" or extra == \"all\""files = [{file = "aiohttp_retry-2.9.1-py3-none-any.whl", hash = "sha256:66d2759d1921838256a05a3f80ad7e724936f083e35be5abb5e16eed6be6dc54"},{file = "aiohttp_retry-2.9.1.tar.gz", hash = "sha256:8eb75e904ed4ee5c2ec242fefe85bf04240f685391c4879d8f541d6028ff01f1"},@@ -944,7 +945,7 @@ version = "2025.6.15"description = "Python package for providing Mozilla's CA Bundle."optional = falsepython-versions = ">=3.7"-groups = ["main", "dev"]+groups = ["main"]files = [{file = "certifi-2025.6.15-py3-none-any.whl", hash = "sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057"},{file = "certifi-2025.6.15.tar.gz", hash = "sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b"},@@ -1050,7 +1051,7 @@ version = "3.4.2"description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."optional = falsepython-versions = ">=3.7"-groups = ["main", "dev"]+groups = ["main"]files = [{file = "charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941"},{file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd"},@@ -2792,7 +2793,7 @@ version = "3.10"description = "Internationalized Domain Names in Applications (IDNA)"optional = falsepython-versions = ">=3.6"-groups = ["main", "dev"]+groups = ["main"]files = [{file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},{file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},@@ -3590,14 +3591,14 @@ pytest = ["pytest (>=7.0.0)", "rich (>=13.9.4,<14.0.0)"][[package]]name = "letta-client"-version = "0.1.191"+version = "0.1.198"description = ""optional = falsepython-versions = "<4.0,>=3.8"groups = ["main"]files = [- {file = "letta_client-0.1.191-py3-none-any.whl", hash = "sha256:2cc234668784b022a25aeab4db48b944a0a188e42112870efd8b028ad223347b"},- {file = "letta_client-0.1.191.tar.gz", hash = "sha256:95957695e679183ec0d87673c8dd169a83f9807359c4740d42ed84fbb6b05efc"},+ {file = "letta_client-0.1.198-py3-none-any.whl", hash = "sha256:08bbc238b128da2552b2a6e54feb3294794b5586e0962ce0bb95bb525109f58f"},+ {file = "letta_client-0.1.198.tar.gz", hash = "sha256:990c9132423e2955d9c7f7549e5064b2366616232d270e5927788cddba4ef9da"},][package.dependencies]@@ -5207,9 +5208,10 @@ xmp = ["defusedxml"]name = "pinecone"version = "7.3.0"description = "Pinecone client and SDK"-optional = false+optional = truepython-versions = "<4.0,>=3.9"-groups = ["main", "dev"]+groups = ["main"]+markers = "extra == \"pinecone\" or extra == \"all\""files = [{file = "pinecone-7.3.0-py3-none-any.whl", hash = "sha256:315b8fef20320bef723ecbb695dec0aafa75d8434d86e01e5a0e85933e1009a8"},{file = "pinecone-7.3.0.tar.gz", hash = "sha256:307edc155621d487c20dc71b76c3ad5d6f799569ba42064190d03917954f9a7b"},@@ -5236,9 +5238,10 @@ grpc = ["googleapis-common-protos (>=1.66.0)", "grpcio (>=1.44.0) ; python_versiname = "pinecone-plugin-assistant"version = "1.7.0"description = "Assistant plugin for Pinecone SDK"-optional = false+optional = truepython-versions = "<4.0,>=3.9"-groups = ["main", "dev"]+groups = ["main"]+markers = "extra == \"pinecone\" or extra == \"all\""files = [{file = "pinecone_plugin_assistant-1.7.0-py3-none-any.whl", hash = "sha256:864cb8e7930588e6c2da97c6d44f0240969195f43fa303c5db76cbc12bf903a5"},{file = "pinecone_plugin_assistant-1.7.0.tar.gz", hash = "sha256:e26e3ba10a8b71c3da0d777cff407668022e82963c4913d0ffeb6c552721e482"},@@ -5252,9 +5255,10 @@ requests = ">=2.32.3,<3.0.0"name = "pinecone-plugin-interface"version = "0.0.7"description = "Plugin interface for the Pinecone python client"-optional = false+optional = truepython-versions = "<4.0,>=3.8"-groups = ["main", "dev"]+groups = ["main"]+markers = "extra == \"pinecone\" or extra == \"all\""files = [{file = "pinecone_plugin_interface-0.0.7-py3-none-any.whl", hash = "sha256:875857ad9c9fc8bbc074dbe780d187a2afd21f5bfe0f3b08601924a61ef1bba8"},{file = "pinecone_plugin_interface-0.0.7.tar.gz", hash = "sha256:b8e6675e41847333aa13923cc44daa3f85676d7157324682dc1640588a982846"},@@ -6578,7 +6582,7 @@ version = "2.32.4"description = "Python HTTP for Humans."optional = falsepython-versions = ">=3.8"-groups = ["main", "dev"]+groups = ["main"]files = [{file = "requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c"},{file = "requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"},@@ -7473,7 +7477,7 @@ files = [{file = "typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76"},{file = "typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36"},]-markers = {"dev,tests" = "python_version == \"3.10\""}+markers = {dev = "python_version < \"3.12\"", "dev,tests" = "python_version == \"3.10\""}[[package]]name = "typing-inspect"@@ -7542,7 +7546,7 @@ version = "2.5.0"description = "HTTP library with thread-safe connection pooling, file post, and more."optional = falsepython-versions = ">=3.9"-groups = ["main", "dev"]+groups = ["main"]files = [{file = "urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc"},{file = "urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760"},@@ -8348,7 +8352,7 @@ cffi = {version = ">=1.11", markers = "platform_python_implementation == \"PyPy\cffi = ["cffi (>=1.11)"][extras]-all = ["autoflake", "black", "docker", "fastapi", "granian", "isort", "langchain", "langchain-community", "locust", "pexpect", "pg8000", "pgvector", "pre-commit", "psycopg2", "psycopg2-binary", "pyright", "pytest-asyncio", "pytest-order", "redis", "uvicorn", "uvloop", "wikipedia"]+all = ["autoflake", "black", "docker", "fastapi", "granian", "isort", "langchain", "langchain-community", "locust", "pexpect", "pg8000", "pgvector", "pinecone", "pre-commit", "psycopg2", "psycopg2-binary", "pyright", "pytest-asyncio", "pytest-order", "redis", "uvicorn", "uvloop", "wikipedia"]bedrock = ["aioboto3", "boto3"]cloud-tool-sandbox = ["e2b-code-interpreter"]desktop = ["docker", "fastapi", "langchain", "langchain-community", "locust", "pg8000", "pgvector", "psycopg2", "psycopg2-binary", "pyright", "uvicorn", "wikipedia"]@@ -8356,6 +8360,7 @@ dev = ["autoflake", "black", "isort", "locust", "pexpect", "pre-commit", "pyrighexperimental = ["granian", "uvloop"]external-tools = ["docker", "firecrawl-py", "langchain", "langchain-community", "wikipedia"]google = ["google-genai"]+pinecone = ["pinecone"]postgres = ["asyncpg", "pg8000", "pgvector", "psycopg2", "psycopg2-binary"]redis = ["redis"]server = ["fastapi", "uvicorn"]@@ -8364,4 +8369,4 @@ tests = ["wikipedia"][metadata]lock-version = "2.1"python-versions = "<3.14,>=3.10"-content-hash = "b2f23b566c52a2ecb9d656383d00f8ac64293690e0f6fcc0d354ed2d2ad8807b"+content-hash = "c4fa225d582dac743e5eb8a1338a71c32bd8c8eb8283dec2331c28599bdf7698"diff --git a/pyproject.toml b/pyproject.tomlindex 6610bbe01..ac4991aff 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -1,6 +1,6 @@[tool.poetry]name = "letta"-version = "0.8.12"+version = "0.8.13"packages = [{include = "letta"},]@@ -72,7 +72,7 @@ llama-index = "^0.12.2"llama-index-embeddings-openai = "^0.3.1"e2b-code-interpreter = {version = "^1.0.3", optional = true}anthropic = "^0.49.0"-letta_client = "^0.1.183"+letta_client = "^0.1.197"openai = "^1.60.0"opentelemetry-api = "1.30.0"opentelemetry-sdk = "1.30.0"@@ -98,13 +98,13 @@ redis = {version = "^6.2.0", optional = true}structlog = "^25.4.0"certifi = "^2025.6.15"aioboto3 = {version = "^14.3.0", optional = true}-pinecone = {extras = ["asyncio"], version = "^7.3.0"}-aiosqlite = "^0.21.0"+pinecone = {extras = ["asyncio"], version = "^7.3.0", optional = true}[tool.poetry.extras]postgres = ["pgvector", "pg8000", "psycopg2-binary", "psycopg2", "asyncpg"]redis = ["redis"]+pinecone = ["pinecone"]dev = ["pytest", "pytest-asyncio", "pexpect", "black", "pre-commit", "pyright", "pytest-order", "autoflake", "isort", "locust"]experimental = ["uvloop", "granian"]server = ["websockets", "fastapi", "uvicorn"]@@ -114,7 +114,7 @@ tests = ["wikipedia"]bedrock = ["boto3", "aioboto3"]google = ["google-genai"]desktop = ["pgvector", "pg8000", "psycopg2-binary", "psycopg2", "pyright", "websockets", "fastapi", "uvicorn", "docker", "langchain", "wikipedia", "langchain-community", "locust"]-all = ["pgvector", "pg8000", "psycopg2-binary", "psycopg2", "pytest", "pytest-asyncio", "pexpect", "black", "pre-commit", "pyright", "pytest-order", "autoflake", "isort", "websockets", "fastapi", "uvicorn", "docker", "langchain", "wikipedia", "langchain-community", "locust", "uvloop", "granian", "redis"]+all = ["pgvector", "pg8000", "psycopg2-binary", "psycopg2", "pytest", "pytest-asyncio", "pexpect", "black", "pre-commit", "pyright", "pytest-order", "autoflake", "isort", "websockets", "fastapi", "uvicorn", "docker", "langchain", "wikipedia", "langchain-community", "locust", "uvloop", "granian", "redis", "pinecone"][tool.poetry.group.dev.dependencies]@@ -122,8 +122,6 @@ black = "^24.4.2"ipykernel = "^6.29.5"ipdb = "^0.13.13"pytest-mock = "^3.14.0"-pinecone = "^7.3.0"-[tool.poetry.group."dev,tests".dependencies]pytest-json-report = "^1.5.0"diff --git a/tests/conftest.py b/tests/conftest.pyindex 0abe389df..2d5eb88ea 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -28,6 +28,32 @@ def disable_e2b_api_key() -> Generator[None, None, None]:tool_settings.e2b_api_key = original_api_key+def e2b_sandbox_mode(request) -> Generator[None, None, None]:+ """+ Parametrizable fixture to enable/disable E2B sandbox mode.++ Usage:+ @pytest.mark.parametrize("e2b_sandbox_mode", [True, False], indirect=True)+ def test_function(e2b_sandbox_mode, ...):+ # Test runs twice - once with E2B enabled, once disabled+ """+ from letta.settings import tool_settings++ enable_e2b = request.param+ original_api_key = tool_settings.e2b_api_key++ if not enable_e2b:+ # Disable E2B by setting API key to None+ tool_settings.e2b_api_key = None+ # If enable_e2b is True, leave the original API key unchanged++ yield++ # Restore original API key+ tool_settings.e2b_api_key = original_api_key++@pytest.fixturedef disable_pinecone() -> Generator[None, None, None]:"""diff --git a/tests/integration_test_send_message.py b/tests/integration_test_send_message.pyindex 3894981be..9f6a250e7 100644--- a/tests/integration_test_send_message.py+++ b/tests/integration_test_send_message.py@@ -752,13 +752,14 @@ def test_step_stream_agent_loop_error("""last_message = client.agents.messages.list(agent_id=agent_state_no_tools.id, limit=1)agent_state_no_tools = client.agents.modify(agent_id=agent_state_no_tools.id, llm_config=llm_config)- with pytest.raises(ApiError):+ with pytest.raises(Exception) as exc_info:response = client.agents.messages.create_stream(agent_id=agent_state_no_tools.id,messages=USER_MESSAGE_FORCE_REPLY,)list(response)-+ assert type(exc_info.value) in (ApiError, ValueError)+ print(exc_info.value)messages_from_db = client.agents.messages.list(agent_id=agent_state_no_tools.id, after=last_message[0].id)assert len(messages_from_db) == 0diff --git a/tests/test_managers.py b/tests/test_managers.pyindex 8b88000ae..2048533e8 100644--- a/tests/test_managers.py+++ b/tests/test_managers.py@@ -8,8 +8,6 @@ import timefrom datetime import datetime, timedelta, timezonefrom typing import List-import httpx-# tests/test_file_content_flow.pyimport pytestfrom _pytest.python_api import approx@@ -3902,7 +3900,7 @@ async def test_bulk_update_return_hydrated_true(server: SyncServer, default_usermgr = BlockManager()# create a block- b = mgr.create_or_update_block(+ b = await mgr.create_or_update_block_async(PydanticBlock(label="persona", value="foo", limit=20),actor=default_user,)@@ -5117,6 +5115,137 @@ async def test_delete_cascades_to_content(server, default_user, default_source,assert await _count_file_content_rows(async_session, created.id) == 0+async def test_get_file_by_original_name_and_source_found(server: SyncServer, default_user, default_source):+ """Test retrieving a file by original filename and source when it exists."""+ original_filename = "test_original_file.txt"+ file_metadata = PydanticFileMetadata(+ file_name="some_generated_name.txt",+ original_file_name=original_filename,+ file_path="/path/to/test_file.txt",+ file_type="text/plain",+ file_size=1024,+ source_id=default_source.id,+ )+ created_file = await server.file_manager.create_file(file_metadata=file_metadata, actor=default_user)++ # Retrieve the file by original name and source+ retrieved_file = await server.file_manager.get_file_by_original_name_and_source(+ original_filename=original_filename, source_id=default_source.id, actor=default_user+ )++ # Assertions to verify the retrieved file matches the created one+ assert retrieved_file is not None+ assert retrieved_file.id == created_file.id+ assert retrieved_file.original_file_name == original_filename+ assert retrieved_file.source_id == default_source.id+++async def test_get_file_by_original_name_and_source_not_found(server: SyncServer, default_user, default_source):+ """Test retrieving a file by original filename and source when it doesn't exist."""+ non_existent_filename = "does_not_exist.txt"++ # Try to retrieve a non-existent file+ retrieved_file = await server.file_manager.get_file_by_original_name_and_source(+ original_filename=non_existent_filename, source_id=default_source.id, actor=default_user+ )++ # Should return None for non-existent file+ assert retrieved_file is None+++async def test_get_file_by_original_name_and_source_different_sources(server: SyncServer, default_user, default_source):+ """Test that files with same original name in different sources are handled correctly."""+ from letta.schemas.source import Source as PydanticSource++ # Create a second source+ second_source_pydantic = PydanticSource(+ name="second_test_source",+ description="This is a test source.",+ metadata={"type": "test"},+ embedding_config=DEFAULT_EMBEDDING_CONFIG,+ )+ second_source = await server.source_manager.create_source(source=second_source_pydantic, actor=default_user)++ original_filename = "shared_filename.txt"++ # Create file in first source+ file_metadata_1 = PydanticFileMetadata(+ file_name="file_in_source_1.txt",+ original_file_name=original_filename,+ file_path="/path/to/file1.txt",+ file_type="text/plain",+ file_size=1024,+ source_id=default_source.id,+ )+ created_file_1 = await server.file_manager.create_file(file_metadata=file_metadata_1, actor=default_user)++ # Create file with same original name in second source+ file_metadata_2 = PydanticFileMetadata(+ file_name="file_in_source_2.txt",+ original_file_name=original_filename,+ file_path="/path/to/file2.txt",+ file_type="text/plain",+ file_size=2048,+ source_id=second_source.id,+ )+ created_file_2 = await server.file_manager.create_file(file_metadata=file_metadata_2, actor=default_user)++ # Retrieve file from first source+ retrieved_file_1 = await server.file_manager.get_file_by_original_name_and_source(+ original_filename=original_filename, source_id=default_source.id, actor=default_user+ )++ # Retrieve file from second source+ retrieved_file_2 = await server.file_manager.get_file_by_original_name_and_source(+ original_filename=original_filename, source_id=second_source.id, actor=default_user+ )++ # Should retrieve different files+ assert retrieved_file_1 is not None+ assert retrieved_file_2 is not None+ assert retrieved_file_1.id == created_file_1.id+ assert retrieved_file_2.id == created_file_2.id+ assert retrieved_file_1.id != retrieved_file_2.id+ assert retrieved_file_1.source_id == default_source.id+ assert retrieved_file_2.source_id == second_source.id+++async def test_get_file_by_original_name_and_source_ignores_deleted(server: SyncServer, default_user, default_source):+ """Test that deleted files are ignored when searching by original name and source."""+ original_filename = "to_be_deleted.txt"+ file_metadata = PydanticFileMetadata(+ file_name="deletable_file.txt",+ original_file_name=original_filename,+ file_path="/path/to/deletable.txt",+ file_type="text/plain",+ file_size=512,+ source_id=default_source.id,+ )+ created_file = await server.file_manager.create_file(file_metadata=file_metadata, actor=default_user)++ # Verify file can be found before deletion+ retrieved_file = await server.file_manager.get_file_by_original_name_and_source(+ original_filename=original_filename, source_id=default_source.id, actor=default_user+ )+ assert retrieved_file is not None+ assert retrieved_file.id == created_file.id++ # Delete the file+ await server.file_manager.delete_file(created_file.id, actor=default_user)++ # Try to retrieve the deleted file+ retrieved_file_after_delete = await server.file_manager.get_file_by_original_name_and_source(+ original_filename=original_filename, source_id=default_source.id, actor=default_user+ )++ # Should return None for deleted file+ assert retrieved_file_after_delete is None++@pytest.mark.asyncioasync def test_list_files(server: SyncServer, default_user, default_source):"""Test listing files with pagination."""@@ -5870,7 +5999,9 @@ async def test_e2e_job_callback(monkeypatch, server: SyncServer, default_user):return await mock_post(url, json, timeout)# Patch the AsyncClient- monkeypatch.setattr(httpx, "AsyncClient", MockAsyncClient)+ import letta.services.job_manager as job_manager_module++ monkeypatch.setattr(job_manager_module, "AsyncClient", MockAsyncClient)job_in = PydanticJob(status=JobStatus.created, metadata={"foo": "bar"}, callback_url="http://example.test/webhook/jobs")created = await server.job_manager.create_job_async(pydantic_job=job_in, actor=default_user)@@ -7813,3 +7944,231 @@ async def test_attach_files_bulk_oversized_bulk(server, default_user, sarah_agen# All files should be attached (some open, some closed)all_files_after = await server.file_agent_manager.list_files_for_agent(sarah_agent.id, actor=default_user)assert len(all_files_after) == MAX_FILES_OPEN + 3+++# ======================================================================================================================+# Race Condition Tests - Blocks+# ======================================================================================================================+++async def test_concurrent_block_updates_race_condition(+ server: SyncServer, comprehensive_test_agent_fixture, default_user: PydanticUser, event_loop+):+ """Test that concurrent block updates don't cause race conditions."""+ agent, _ = comprehensive_test_agent_fixture++ # Create multiple blocks to use in concurrent updates+ blocks = []+ for i in range(5):+ block = await server.block_manager.create_or_update_block_async(+ PydanticBlock(label=f"test_block_{i}", value=f"Test block content {i}", limit=1000), actor=default_user+ )+ blocks.append(block)++ # Test concurrent updates with different block combinations+ async def update_agent_blocks(block_subset):+ """Update agent with a specific subset of blocks."""+ update_request = UpdateAgent(block_ids=[b.id for b in block_subset])+ try:+ return await server.agent_manager.update_agent_async(agent.id, update_request, actor=default_user)+ except Exception as e:+ # Capture any errors that occur during concurrent updates+ return {"error": str(e)}++ # Run concurrent updates with different block combinations+ tasks = [+ update_agent_blocks(blocks[:2]), # blocks 0, 1+ update_agent_blocks(blocks[1:3]), # blocks 1, 2+ update_agent_blocks(blocks[2:4]), # blocks 2, 3+ update_agent_blocks(blocks[3:5]), # blocks 3, 4+ update_agent_blocks(blocks[:1]), # block 0 only+ ]++ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Verify no exceptions occurred+ errors = [r for r in results if isinstance(r, Exception) or (isinstance(r, dict) and "error" in r)]+ assert len(errors) == 0, f"Concurrent updates failed with errors: {errors}"++ # Verify all results are valid agent states+ valid_results = [r for r in results if not isinstance(r, Exception) and not (isinstance(r, dict) and "error" in r)]+ assert len(valid_results) == 5, "All concurrent updates should succeed"++ # Verify final state is consistent+ final_agent = await server.agent_manager.get_agent_by_id_async(agent.id, actor=default_user)+ assert final_agent is not None+ assert len(final_agent.memory.blocks) > 0++ # Clean up+ for block in blocks:+ await server.block_manager.delete_block_async(block.id, actor=default_user)+++async def test_concurrent_same_block_updates_race_condition(+ server: SyncServer, comprehensive_test_agent_fixture, default_user: PydanticUser, event_loop+):+ """Test that multiple concurrent updates to the same block configuration don't cause issues."""+ agent, _ = comprehensive_test_agent_fixture++ # Create a single block configuration to use in all updates+ block = await server.block_manager.create_or_update_block_async(+ PydanticBlock(label="shared_block", value="Shared block content", limit=1000), actor=default_user+ )++ # Test multiple concurrent updates with the same block configuration+ async def update_agent_with_same_blocks():+ """Update agent with the same block configuration."""+ update_request = UpdateAgent(block_ids=[block.id])+ try:+ return await server.agent_manager.update_agent_async(agent.id, update_request, actor=default_user)+ except Exception as e:+ return {"error": str(e)}++ # Run 10 concurrent identical updates+ tasks = [update_agent_with_same_blocks() for _ in range(10)]+ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Verify no exceptions occurred+ errors = [r for r in results if isinstance(r, Exception) or (isinstance(r, dict) and "error" in r)]+ assert len(errors) == 0, f"Concurrent identical updates failed with errors: {errors}"++ # Verify final state is consistent+ final_agent = await server.agent_manager.get_agent_by_id_async(agent.id, actor=default_user)+ assert len(final_agent.memory.blocks) == 1+ assert final_agent.memory.blocks[0].id == block.id++ # Clean up+ await server.block_manager.delete_block_async(block.id, actor=default_user)+++async def test_concurrent_empty_block_updates_race_condition(+ server: SyncServer, comprehensive_test_agent_fixture, default_user: PydanticUser, event_loop+):+ """Test concurrent updates that remove all blocks."""+ agent, _ = comprehensive_test_agent_fixture++ # Test concurrent updates that clear all blocks+ async def clear_agent_blocks():+ """Update agent to have no blocks."""+ update_request = UpdateAgent(block_ids=[])+ try:+ return await server.agent_manager.update_agent_async(agent.id, update_request, actor=default_user)+ except Exception as e:+ return {"error": str(e)}++ # Run concurrent clear operations+ tasks = [clear_agent_blocks() for _ in range(5)]+ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Verify no exceptions occurred+ errors = [r for r in results if isinstance(r, Exception) or (isinstance(r, dict) and "error" in r)]+ assert len(errors) == 0, f"Concurrent clear operations failed with errors: {errors}"++ # Verify final state is consistent (no blocks)+ final_agent = await server.agent_manager.get_agent_by_id_async(agent.id, actor=default_user)+ assert len(final_agent.memory.blocks) == 0+++async def test_concurrent_mixed_block_operations_race_condition(+ server: SyncServer, comprehensive_test_agent_fixture, default_user: PydanticUser, event_loop+):+ """Test mixed concurrent operations: some adding blocks, some removing."""+ agent, _ = comprehensive_test_agent_fixture++ # Create test blocks+ blocks = []+ for i in range(3):+ block = await server.block_manager.create_or_update_block_async(+ PydanticBlock(label=f"mixed_block_{i}", value=f"Mixed block content {i}", limit=1000), actor=default_user+ )+ blocks.append(block)++ # Mix of operations: add blocks, remove blocks, clear all+ async def mixed_operation(operation_type):+ """Perform different types of block operations."""+ if operation_type == "add_all":+ update_request = UpdateAgent(block_ids=[b.id for b in blocks])+ elif operation_type == "add_subset":+ update_request = UpdateAgent(block_ids=[blocks[0].id])+ elif operation_type == "clear":+ update_request = UpdateAgent(block_ids=[])+ else:+ update_request = UpdateAgent(block_ids=[blocks[1].id, blocks[2].id])++ try:+ return await server.agent_manager.update_agent_async(agent.id, update_request, actor=default_user)+ except Exception as e:+ return {"error": str(e)}++ # Run mixed concurrent operations+ tasks = [+ mixed_operation("add_all"),+ mixed_operation("add_subset"),+ mixed_operation("clear"),+ mixed_operation("add_two"),+ mixed_operation("add_all"),+ ]++ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Verify no exceptions occurred+ errors = [r for r in results if isinstance(r, Exception) or (isinstance(r, dict) and "error" in r)]+ assert len(errors) == 0, f"Mixed concurrent operations failed with errors: {errors}"++ # Verify final state is consistent (any valid state is acceptable)+ final_agent = await server.agent_manager.get_agent_by_id_async(agent.id, actor=default_user)+ assert final_agent is not None++ # Clean up+ for block in blocks:+ await server.block_manager.delete_block_async(block.id, actor=default_user)+++async def test_high_concurrency_stress_test(server: SyncServer, comprehensive_test_agent_fixture, default_user: PydanticUser, event_loop):+ """Stress test with high concurrency to catch race conditions."""+ agent, _ = comprehensive_test_agent_fixture++ # Create many blocks for stress testing+ blocks = []+ for i in range(10):+ block = await server.block_manager.create_or_update_block_async(+ PydanticBlock(label=f"stress_block_{i}", value=f"Stress test content {i}", limit=1000), actor=default_user+ )+ blocks.append(block)++ # Create many concurrent update tasks+ async def stress_update(task_id):+ """Perform a random block update operation."""+ import random++ # Random subset of blocks+ num_blocks = random.randint(0, len(blocks))+ selected_blocks = random.sample(blocks, num_blocks)++ update_request = UpdateAgent(block_ids=[b.id for b in selected_blocks])++ try:+ return await server.agent_manager.update_agent_async(agent.id, update_request, actor=default_user)+ except Exception as e:+ return {"error": str(e), "task_id": task_id}++ # Run 20 concurrent stress updates+ tasks = [stress_update(i) for i in range(20)]+ results = await asyncio.gather(*tasks, return_exceptions=True)++ # Verify no exceptions occurred+ errors = [r for r in results if isinstance(r, Exception) or (isinstance(r, dict) and "error" in r)]+ assert len(errors) == 0, f"High concurrency stress test failed with errors: {errors}"++ # Verify final state is consistent+ final_agent = await server.agent_manager.get_agent_by_id_async(agent.id, actor=default_user)+ assert final_agent is not None++ # Clean up+ for block in blocks:+ await server.block_manager.delete_block_async(block.id, actor=default_user)diff --git a/tests/test_sdk_client.py b/tests/test_sdk_client.pyindex 46ed45e06..7ff378519 100644--- a/tests/test_sdk_client.py+++ b/tests/test_sdk_client.py@@ -1,15 +1,19 @@+import jsonimport osimport threadingimport timeimport uuid+from typing import List, Typeimport pytestfrom dotenv import load_dotenvfrom letta_client import CreateBlockfrom letta_client import Letta as LettaSDKClient-from letta_client import MessageCreate+from letta_client import LettaRequest, MessageCreate, TextContent+from letta_client.client import BaseToolfrom letta_client.core import ApiErrorfrom letta_client.types import AgentState, ToolReturnMessage+from pydantic import BaseModel, Field# ConstantsSERVER_PORT = 8283@@ -762,3 +766,270 @@ def test_base_tools_upsert_on_list(client: LettaSDKClient):final_tool_names = {tool.name for tool in final_tools}for deleted_tool in tools_to_delete:assert deleted_tool.name in final_tool_names, f"Deleted tool {deleted_tool.name} was not properly restored"++[email protected]("e2b_sandbox_mode", [True, False], indirect=True)+def test_pydantic_inventory_management_tool(e2b_sandbox_mode, client: LettaSDKClient):+ class InventoryItem(BaseModel):+ sku: str+ name: str+ price: float+ category: str++ class InventoryEntry(BaseModel):+ timestamp: int+ item: InventoryItem+ transaction_id: str++ class InventoryEntryData(BaseModel):+ data: InventoryEntry+ quantity_change: int++ class ManageInventoryTool(BaseTool):+ name: str = "manage_inventory"+ args_schema: Type[BaseModel] = InventoryEntryData+ description: str = "Update inventory catalogue with a new data entry"+ tags: List[str] = ["inventory", "shop"]++ def run(self, data: InventoryEntry, quantity_change: int) -> bool:+ print(f"Updated inventory for {data.item.name} with a quantity change of {quantity_change}")+ return True++ tool = client.tools.add(+ tool=ManageInventoryTool(),+ )++ assert tool is not None+ assert tool.name == "manage_inventory"+ assert "inventory" in tool.tags+ assert "shop" in tool.tags++ temp_agent = client.agents.create(+ memory_blocks=[+ CreateBlock(+ label="persona",+ value="You are a helpful inventory management assistant.",+ ),+ ],+ model="openai/gpt-4o-mini",+ embedding="openai/text-embedding-3-small",+ tool_ids=[tool.id],+ include_base_tools=False,+ )++ response = client.agents.messages.create(+ agent_id=temp_agent.id,+ messages=[+ MessageCreate(+ role="user",+ content="Update the inventory for product 'iPhone 15' with SKU 'IPH15-001', price $999.99, category 'Electronics', transaction ID 'TXN-12345', timestamp 1640995200, with a quantity change of +10",+ ),+ ],+ )++ assert response is not None++ tool_call_messages = [msg for msg in response.messages if msg.message_type == "tool_call_message"]+ assert len(tool_call_messages) > 0, "Expected at least one tool call message"++ first_tool_call = tool_call_messages[0]+ assert first_tool_call.tool_call.name == "manage_inventory"++ args = json.loads(first_tool_call.tool_call.arguments)+ assert "data" in args+ assert "quantity_change" in args+ assert "item" in args["data"]+ assert "name" in args["data"]["item"]+ assert "sku" in args["data"]["item"]+ assert "price" in args["data"]["item"]+ assert "category" in args["data"]["item"]+ assert "transaction_id" in args["data"]+ assert "timestamp" in args["data"]++ tool_return_messages = [msg for msg in response.messages if msg.message_type == "tool_return_message"]+ assert len(tool_return_messages) > 0, "Expected at least one tool return message"++ first_tool_return = tool_return_messages[0]+ assert first_tool_return.status == "success"+ assert first_tool_return.tool_return == "True"+ assert "Updated inventory for iPhone 15 with a quantity change of 10" in "\n".join(first_tool_return.stdout)++ client.agents.delete(temp_agent.id)+ client.tools.delete(tool.id)++[email protected]("e2b_sandbox_mode", [True, False], indirect=True)+def test_pydantic_task_planning_tool(e2b_sandbox_mode, client: LettaSDKClient):++ class Step(BaseModel):+ name: str = Field(..., description="Name of the step.")+ description: str = Field(..., description="An exhaustive description of what this step is trying to achieve.")++ class StepsList(BaseModel):+ steps: List[Step] = Field(..., description="List of steps to add to the task plan.")+ explanation: str = Field(..., description="Explanation for the list of steps.")++ def create_task_plan(steps, explanation):+ """Creates a task plan for the current task."""+ print(f"Created task plan with {len(steps)} steps: {explanation}")+ return steps++ tool = client.tools.upsert_from_function(func=create_task_plan, args_schema=StepsList, tags=["planning", "task", "pydantic_test"])++ assert tool is not None+ assert tool.name == "create_task_plan"+ assert "planning" in tool.tags+ assert "task" in tool.tags++ temp_agent = client.agents.create(+ memory_blocks=[+ CreateBlock(+ label="persona",+ value="You are a helpful task planning assistant.",+ ),+ ],+ model="openai/gpt-4o-mini",+ embedding="openai/text-embedding-3-small",+ tool_ids=[tool.id],+ include_base_tools=False,+ )++ response = client.agents.messages.create(+ agent_id=temp_agent.id,+ messages=[+ MessageCreate(+ role="user",+ content="Create a task plan for organizing a team meeting with 3 steps: 1) Schedule meeting (find available time slots), 2) Send invitations (notify all team members), 3) Prepare agenda (outline discussion topics). Explanation: This plan ensures a well-organized team meeting.",+ ),+ ],+ )++ assert response is not None+ assert hasattr(response, "messages")+ assert len(response.messages) > 0++ tool_call_messages = [msg for msg in response.messages if msg.message_type == "tool_call_message"]+ assert len(tool_call_messages) > 0, "Expected at least one tool call message"++ first_tool_call = tool_call_messages[0]+ assert first_tool_call.tool_call.name == "create_task_plan"++ args = json.loads(first_tool_call.tool_call.arguments)+ assert "steps" in args+ assert "explanation" in args+ assert isinstance(args["steps"], list)+ assert len(args["steps"]) > 0++ for step in args["steps"]:+ assert "name" in step+ assert "description" in step++ tool_return_messages = [msg for msg in response.messages if msg.message_type == "tool_return_message"]+ assert len(tool_return_messages) > 0, "Expected at least one tool return message"++ first_tool_return = tool_return_messages[0]+ assert first_tool_return.status == "success"++ client.agents.delete(temp_agent.id)+ client.tools.delete(tool.id)++[email protected]("e2b_sandbox_mode", [True, False], indirect=True)+def test_create_tool_from_function_with_docstring(e2b_sandbox_mode, client: LettaSDKClient):+ """Test creating a tool from a function with a docstring using create_from_function"""++ def roll_dice() -> str:+ """+ Simulate the roll of a 20-sided die (d20).++ This function generates a random integer between 1 and 20, inclusive,+ which represents the outcome of a single roll of a d20.++ Returns:+ str: The result of the die roll.+ """+ import random++ dice_role_outcome = random.randint(1, 20)+ output_string = f"You rolled a {dice_role_outcome}"+ return output_string++ tool = client.tools.create_from_function(func=roll_dice)++ assert tool is not None+ assert tool.name == "roll_dice"+ assert "Simulate the roll of a 20-sided die" in tool.description+ assert tool.source_code is not None+ assert "random.randint(1, 20)" in tool.source_code++ all_tools = client.tools.list()+ tool_names = [t.name for t in all_tools]+ assert "roll_dice" in tool_names++ client.tools.delete(tool.id)+++def test_preview_payload(client: LettaSDKClient, agent):+ payload = client.agents.messages.preview_raw_payload(+ agent_id=agent.id,+ request=LettaRequest(+ messages=[+ MessageCreate(+ role="user",+ content=[+ TextContent(+ text="text",+ )+ ],+ )+ ],+ ),+ )++ assert isinstance(payload, dict)+ assert "model" in payload+ assert "messages" in payload+ assert "tools" in payload+ assert "frequency_penalty" in payload+ assert "max_completion_tokens" in payload+ assert "temperature" in payload+ assert "user" in payload+ assert "parallel_tool_calls" in payload+ assert "tool_choice" in payload++ assert payload["model"] == "gpt-4o-mini"++ assert isinstance(payload["messages"], list)+ assert len(payload["messages"]) >= 3++ system_message = payload["messages"][0]+ assert system_message["role"] == "system"+ assert "base_instructions" in system_message["content"]+ assert "memory_blocks" in system_message["content"]+ assert "tool_usage_rules" in system_message["content"]+ assert "Letta" in system_message["content"]++ assert isinstance(payload["tools"], list)+ assert len(payload["tools"]) > 0++ tool_names = [tool["function"]["name"] for tool in payload["tools"]]+ expected_tools = ["send_message", "conversation_search", "core_memory_replace", "core_memory_append"]+ for tool_name in expected_tools:+ assert tool_name in tool_names, f"Expected tool {tool_name} not found in tools"++ for tool in payload["tools"]:+ assert tool["type"] == "function"+ assert "function" in tool+ assert "name" in tool["function"]+ assert "description" in tool["function"]+ assert "parameters" in tool["function"]+ assert tool["function"]["strict"] is True++ assert payload["frequency_penalty"] == 1.0+ assert payload["max_completion_tokens"] == 4096+ assert payload["temperature"] == 0.7+ assert payload["parallel_tool_calls"] is False+ assert payload["tool_choice"] == "required"+ assert payload["user"].startswith("user-")++ print(payload)diff --git a/tests/test_sources.py b/tests/test_sources.pyindex 6a1a4af2c..758fc3689 100644--- a/tests/test_sources.py+++ b/tests/test_sources.py@@ -7,18 +7,37 @@ import pytestfrom dotenv import load_dotenvfrom letta_client import CreateBlockfrom letta_client import Letta as LettaSDKClient+from letta_client import LettaRequest+from letta_client import MessageCreate as ClientMessageCreatefrom letta_client.types import AgentStatefrom letta.constants import DEFAULT_ORG_ID, FILES_TOOLSfrom letta.orm.enums import ToolTypefrom letta.schemas.message import MessageCreatefrom letta.schemas.user import User+from letta.settings import settingsfrom tests.utils import wait_for_server# ConstantsSERVER_PORT = 8283+def get_raw_system_message(client: LettaSDKClient, agent_id: str) -> str:+ """Helper function to get the raw system message from an agent's preview payload."""+ raw_payload = client.agents.messages.preview_raw_payload(+ agent_id=agent_id,+ request=LettaRequest(+ messages=[+ ClientMessageCreate(+ role="user",+ content="Testing",+ )+ ],+ ),+ )+ return raw_payload["messages"][0]["content"]++@pytest.fixture(autouse=True)def clear_sources(client: LettaSDKClient):# Clear existing sources@@ -172,6 +191,10 @@ def test_file_upload_creates_source_blocks_correctly(expected_value: str,expected_label_regex: str,):+ # skip pdf tests if mistral api key is missing+ if file_path.endswith(".pdf") and not settings.mistral_api_key:+ pytest.skip("mistral api key required for pdf processing")+# Create a new sourcesource = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")assert len(client.sources.list()) == 1@@ -195,6 +218,15 @@ def test_file_upload_creates_source_blocks_correctly(assert any(b.value.startswith("[Viewing file start") for b in blocks)assert any(re.fullmatch(expected_label_regex, b.label) for b in blocks)+ # verify raw system message contains source information+ raw_system_message = get_raw_system_message(client, agent_state.id)+ assert "test_source" in raw_system_message+ assert "<directories>" in raw_system_message+ # verify file-specific details in raw system message+ file_name = files[0].file_name+ assert f'name="test_source/{file_name}"' in raw_system_message+ assert 'status="open"' in raw_system_message+# Remove file from sourceclient.sources.files.delete(source_id=source.id, file_id=files[0].id)@@ -205,6 +237,14 @@ def test_file_upload_creates_source_blocks_correctly(assert not any(expected_value in b.value for b in blocks)assert not any(re.fullmatch(expected_label_regex, b.label) for b in blocks)+ # verify raw system message no longer contains source information+ raw_system_message_after_removal = get_raw_system_message(client, agent_state.id)+ # this should be in, because we didn't delete the source+ assert "test_source" in raw_system_message_after_removal+ assert "<directories>" in raw_system_message_after_removal+ # verify file-specific details are also removed+ assert f'name="test_source/{file_name}"' not in raw_system_message_after_removal+def test_attach_existing_files_creates_source_blocks_correctly(disable_pinecone, client: LettaSDKClient, agent_state: AgentState):# Create a new source@@ -224,6 +264,25 @@ def test_attach_existing_files_creates_source_blocks_correctly(disable_pinecone,# Attach after uploading the fileclient.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)+ raw_system_message = get_raw_system_message(client, agent_state.id)++ # Assert that the expected chunk is in the raw system message+ expected_chunk = """<directories>+<directory name="test_source">+<file status="open" name="test_source/test.txt">+<metadata>+- read_only=true+- chars_current=46+- chars_limit=50000+</metadata>+<value>+[Viewing file start (out of 1 chunks)]+1: test+</value>+</file>+</directory>+</directories>"""+ assert expected_chunk in raw_system_message# Get the agent state, check blocks existagent_state = client.agents.retrieve(agent_id=agent_state.id)@@ -241,20 +300,46 @@ def test_attach_existing_files_creates_source_blocks_correctly(disable_pinecone,assert len(blocks) == 0assert not any("test" in b.value for b in blocks)+ # Verify no traces of the prompt exist in the raw system message after detaching+ raw_system_message_after_detach = get_raw_system_message(client, agent_state.id)+ assert expected_chunk not in raw_system_message_after_detach+ assert "test_source" not in raw_system_message_after_detach+ assert "<directories>" not in raw_system_message_after_detach+def test_delete_source_removes_source_blocks_correctly(disable_pinecone, client: LettaSDKClient, agent_state: AgentState):# Create a new sourcesource = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")assert len(client.sources.list()) == 1- # Attachclient.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)+ raw_system_message = get_raw_system_message(client, agent_state.id)+ assert "test_source" in raw_system_message+ assert "<directories>" in raw_system_message# Load files into the sourcefile_path = "tests/data/test.txt"# Upload the filesupload_file_and_wait(client, source.id, file_path)+ raw_system_message = get_raw_system_message(client, agent_state.id)+ # Assert that the expected chunk is in the raw system message+ expected_chunk = """<directories>+<directory name="test_source">+<file status="open" name="test_source/test.txt">+<metadata>+- read_only=true+- chars_current=46+- chars_limit=50000+</metadata>+<value>+[Viewing file start (out of 1 chunks)]+1: test+</value>+</file>+</directory>+</directories>"""+ assert expected_chunk in raw_system_message# Get the agent state, check blocks existagent_state = client.agents.retrieve(agent_id=agent_state.id)@@ -264,6 +349,10 @@ def test_delete_source_removes_source_blocks_correctly(disable_pinecone, client:# Remove file from sourceclient.sources.delete(source_id=source.id)+ raw_system_message_after_detach = get_raw_system_message(client, agent_state.id)+ assert expected_chunk not in raw_system_message_after_detach+ assert "test_source" not in raw_system_message_after_detach+ assert "<directories>" not in raw_system_message_after_detach# Get the agent state, check blocks do NOT existagent_state = client.agents.retrieve(agent_id=agent_state.id)