letta-nightly 0.11.7.dev20250911104039__py3-none-any.whl → 0.11.7.dev20250912104045__py3-none-any.whl

letta/agents/letta_agent_v2.py

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

letta/helpers/tpuf_client.py

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

letta/interfaces/openai_streaming_interface.py

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

letta/llm_api/google_vertex_client.py

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

letta/llm_api/openai_client.py

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

letta/orm/job.py

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

letta/orm/organization.py

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

letta/server/rest_api/redis_stream_manager.py

@@ -8,6 +8,9 @@ from typing import AsyncIterator, Dict, List, Optional
 
 from letta.data_sources.redis_client import AsyncRedisClient
 from letta.log import get_logger
+from letta.schemas.enums import JobStatus
+from letta.schemas.user import User
+from letta.services.job_manager import JobManager
 from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
@@ -133,9 +136,9 @@ class RedisSSEStreamWriter:
 
             async with client.pipeline(transaction=False) as pipe:
                 for chunk in chunks:
-                    pipe.xadd(stream_key, chunk, maxlen=self.max_stream_length, approximate=True)
+                    await pipe.xadd(stream_key, chunk, maxlen=self.max_stream_length, approximate=True)
 
-                pipe.expire(stream_key, self.stream_ttl)
+                await pipe.expire(stream_key, self.stream_ttl)
 
                 await pipe.execute()
 
@@ -191,6 +194,8 @@ async def create_background_stream_processor(
     redis_client: AsyncRedisClient,
     run_id: str,
     writer: Optional[RedisSSEStreamWriter] = None,
+    job_manager: Optional[JobManager] = None,
+    actor: Optional[User] = None,
 ) -> None:
     """
     Process a stream in the background and store chunks to Redis.
@@ -203,6 +208,8 @@ async def create_background_stream_processor(
         redis_client: Redis client instance
         run_id: The run ID to store chunks under
         writer: Optional pre-configured writer (creates new if not provided)
+        job_manager: Optional job manager for updating job status
+        actor: Optional actor for job status updates
     """
     if writer is None:
         writer = RedisSSEStreamWriter(redis_client)
@@ -227,6 +234,12 @@ async def create_background_stream_processor(
         logger.error(f"Error processing stream for run {run_id}: {e}")
         # Write error chunk
         # error_chunk = {"error": {"message": str(e)}}
+        # Mark run_id terminal state
+        if job_manager and actor:
+            await job_manager.safe_update_job_status_async(
+                job_id=run_id, new_status=JobStatus.failed, actor=actor, metadata={"error": str(e)}
+            )
+
         error_chunk = {"error": str(e), "code": "INTERNAL_SERVER_ERROR"}
         await writer.write_chunk(run_id=run_id, data=f"event: error\ndata: {json.dumps(error_chunk)}\n\n", is_complete=True)
     finally:

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

@@ -1348,6 +1348,8 @@ async def send_message_streaming(
                         stream_generator=raw_stream,
                         redis_client=redis_client,
                         run_id=run.id,
+                        job_manager=server.job_manager,
+                        actor=actor,
                     ),
                     label=f"background_stream_processor_{run.id}",
                 )

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

@@ -12,7 +12,7 @@ from composio.exceptions import (
     EnumStringNotFound,
 )
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Request
-from httpx import HTTPStatusError
+from httpx import ConnectError, HTTPStatusError
 from pydantic import BaseModel, Field
 from starlette.responses import StreamingResponse
 
@@ -151,7 +151,6 @@ async def count_tools(
             exclude_letta_tools=exclude_letta_tools,
         )
     except Exception as e:
-        print(f"Error occurred: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -265,8 +264,6 @@ async def list_tools(
             return_only_letta_tools=return_only_letta_tools,
         )
     except Exception as e:
-        # Log or print the full exception here for debugging
-        print(f"Error occurred: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -284,21 +281,13 @@ async def create_tool(
         tool = Tool(**request.model_dump(exclude_unset=True))
         return await server.tool_manager.create_tool_async(pydantic_tool=tool, actor=actor)
     except UniqueConstraintViolationError as e:
-        # Log or print the full exception here for debugging
-        print(f"Error occurred: {e}")
         clean_error_message = "Tool with this name already exists."
         raise HTTPException(status_code=409, detail=clean_error_message)
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool creation: {e}")
-        # print the full stack trace
-        import traceback
-
-        print(traceback.format_exc())
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -319,15 +308,12 @@ async def upsert_tool(
         return tool
     except UniqueConstraintViolationError as e:
         # Log the error and raise a conflict exception
-        print(f"Unique constraint violation occurred: {e}")
         raise HTTPException(status_code=409, detail=str(e))
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool upsert: {e}")
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -344,7 +330,6 @@ async def modify_tool(
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         tool = await server.tool_manager.update_tool_by_id_async(tool_id=tool_id, tool_update=request, actor=actor)
-        print("FINAL TOOL", tool)
         return tool
     except LettaToolNameConflictError as e:
         # HTTP 409 == Conflict
@@ -394,16 +379,10 @@ async def run_tool_from_source(
         )
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
-        print(f"Error occurred during tool creation: {e}")
-        # print the full stack trace
-        import traceback
-
-        print(traceback.format_exc())
         raise HTTPException(status_code=400, detail=str(e))
 
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
-        print(f"Unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -559,32 +538,38 @@ async def list_mcp_tools_by_server(
     """
     Get a list of all tools for a specific MCP server
     """
-    if tool_settings.mcp_read_from_config:
-        try:
-            return await server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
-        except ValueError as e:
-            # ValueError means that the MCP server name doesn't exist
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        mcp_tools = await server.mcp_manager.list_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor)
+        return mcp_tools
+    except Exception as e:
+        if isinstance(e, ConnectError) or isinstance(e, ConnectionError):
             raise HTTPException(
-                status_code=400,  # Bad Request
+                status_code=404,
                 detail={
-                    "code": "MCPServerNotFoundError",
+                    "code": "MCPListToolsError",
                     "message": str(e),
                     "mcp_server_name": mcp_server_name,
                 },
             )
-        except MCPTimeoutError as e:
+        if isinstance(e, HTTPStatusError):
             raise HTTPException(
-                status_code=408,  # Timeout
+                status_code=401,
                 detail={
-                    "code": "MCPTimeoutError",
+                    "code": "MCPListToolsError",
+                    "message": str(e),
+                    "mcp_server_name": mcp_server_name,
+                },
+            )
+        else:
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "code": "MCPListToolsError",
                     "message": str(e),
                     "mcp_server_name": mcp_server_name,
                 },
             )
-    else:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        mcp_tools = await server.mcp_manager.list_mcp_server_tools(mcp_server_name=mcp_server_name, actor=actor)
-        return mcp_tools
 
 
 @router.post("/mcp/servers/{mcp_server_name}/resync", operation_id="resync_mcp_server_tools")
@@ -753,7 +738,8 @@ async def add_mcp_server_to_config(
                     custom_headers=request.custom_headers,
                 )
 
-            await server.mcp_manager.create_mcp_server(mapped_request, actor=actor)
+            # Create MCP server and optimistically sync tools
+            await server.mcp_manager.create_mcp_server_with_tools(mapped_request, actor=actor)
 
             # TODO: don't do this in the future (just return MCPServer)
             all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
@@ -769,7 +755,6 @@ async def add_mcp_server_to_config(
             },
         )
     except Exception as e:
-        print(f"Unexpected error occurred while adding MCP server: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
@@ -801,7 +786,6 @@ async def update_mcp_server(
         # Re-raise HTTP exceptions (like 404)
         raise
     except Exception as e:
-        print(f"Unexpected error occurred while updating MCP server: {e}")
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 

letta/services/job_manager.py

@@ -43,6 +43,7 @@ class JobManager:
             pydantic_job.user_id = actor.id
             job_data = pydantic_job.model_dump(to_orm=True)
             job = JobModel(**job_data)
+            job.organization_id = actor.organization_id
             job.create(session, actor=actor)  # Save job in the database
         return job.to_pydantic()
 
@@ -57,6 +58,7 @@ class JobManager:
             pydantic_job.user_id = actor.id
             job_data = pydantic_job.model_dump(to_orm=True)
             job = JobModel(**job_data)
+            job.organization_id = actor.organization_id
             job = await job.create_async(session, actor=actor, no_commit=True, no_refresh=True)  # Save job in the database
             result = job.to_pydantic()
             await session.commit()
@@ -150,8 +152,9 @@ class JobManager:
                     logger.error(f"Invalid job status transition from {current_status} to {job_update.status} for job {job_id}")
                     raise ValueError(f"Invalid job status transition from {current_status} to {job_update.status}")
 
-            # Check if we'll need to dispatch callback
-            if job_update.status in {JobStatus.completed, JobStatus.failed} and job.callback_url:
+            # Check if we'll need to dispatch callback (only if not already completed)
+            not_completed_before = not bool(job.completed_at)
+            if job_update.status in {JobStatus.completed, JobStatus.failed} and not_completed_before and job.callback_url:
                 needs_callback = True
                 callback_url = job.callback_url
 

letta/services/mcp_manager.py

@@ -79,11 +79,16 @@ class MCPManager:
         except Exception as e:
             # MCP tool listing errors are often due to connection/configuration issues, not system errors
             # Log at info level to avoid triggering Sentry alerts for expected failures
-            logger.info(f"Error listing tools for MCP server {mcp_server_name}: {e}")
-            return []
+            logger.warning(f"Error listing tools for MCP server {mcp_server_name}: {e}")
+            raise e
         finally:
             if mcp_client:
-                await mcp_client.cleanup()
+                try:
+                    await mcp_client.cleanup()
+                except* Exception as eg:
+                    for e in eg.exceptions:
+                        logger.warning(f"Error listing tools for MCP server {mcp_server_name}: {e}")
+                        raise e
 
     @enforce_types
     async def execute_mcp_server_tool(
@@ -349,6 +354,62 @@ class MCPManager:
                 logger.error(f"Failed to create MCP server: {e}")
                 raise
 
+    @enforce_types
+    async def create_mcp_server_with_tools(self, pydantic_mcp_server: MCPServer, actor: PydanticUser) -> MCPServer:
+        """
+        Create a new MCP server and optimistically sync its tools.
+
+        This method:
+        1. Creates the MCP server record
+        2. Attempts to connect and fetch tools
+        3. Persists valid tools in parallel (best-effort)
+        """
+        import asyncio
+
+        # First, create the MCP server
+        created_server = await self.create_mcp_server(pydantic_mcp_server, actor)
+
+        # Optimistically try to sync tools
+        try:
+            logger.info(f"Attempting to auto-sync tools from MCP server: {created_server.server_name}")
+
+            # List all tools from the MCP server
+            mcp_tools = await self.list_mcp_server_tools(mcp_server_name=created_server.server_name, actor=actor)
+
+            # Filter out invalid tools
+            valid_tools = [tool for tool in mcp_tools if not (tool.health and tool.health.status == "INVALID")]
+
+            # Register in parallel
+            if valid_tools:
+                tool_tasks = []
+                for mcp_tool in valid_tools:
+                    tool_create = ToolCreate.from_mcp(mcp_server_name=created_server.server_name, mcp_tool=mcp_tool)
+                    task = self.tool_manager.create_mcp_tool_async(
+                        tool_create=tool_create, mcp_server_name=created_server.server_name, mcp_server_id=created_server.id, actor=actor
+                    )
+                    tool_tasks.append(task)
+
+                results = await asyncio.gather(*tool_tasks, return_exceptions=True)
+
+                successful = sum(1 for r in results if not isinstance(r, Exception))
+                failed = len(results) - successful
+                logger.info(
+                    f"Auto-sync completed for MCP server {created_server.server_name}: "
+                    f"{successful} tools persisted, {failed} failed, "
+                    f"{len(mcp_tools) - len(valid_tools)} invalid tools skipped"
+                )
+            else:
+                logger.info(f"No valid tools found to sync from MCP server {created_server.server_name}")
+
+        except Exception as e:
+            # Log the error but don't fail the server creation
+            logger.warning(
+                f"Failed to auto-sync tools from MCP server {created_server.server_name}: {e}. "
+                f"Server was created successfully but tools were not persisted."
+            )
+
+        return created_server
+
     @enforce_types
     async def update_mcp_server_by_id(self, mcp_server_id: str, mcp_server_update: UpdateMCPServer, actor: PydanticUser) -> MCPServer:
         """Update a tool by its ID with the given ToolUpdate object."""

letta/services/tool_executor/files_tool_executor.py

@@ -645,7 +645,7 @@ class LettaFileToolExecutor(ToolExecutor):
             raise e
 
         if not files_with_matches:
-            return f"No semantic matches found in Turbopuffer for query: '{query}'"
+            return f"No semantic matches found for query: '{query}'"
 
         # Format results
         passage_num = 0
@@ -678,7 +678,7 @@ class LettaFileToolExecutor(ToolExecutor):
 
         # create summary header
         file_count = len(files_with_matches)
-        summary = f"Found {total_hits} Turbopuffer matches in {file_count} file{'s' if file_count != 1 else ''} for query: '{query}'"
+        summary = f"Found {total_hits} matches in {file_count} file{'s' if file_count != 1 else ''} for query: '{query}'"
 
         # combine all results
         formatted_results = [summary, "=" * len(summary)] + results

{letta_nightly-0.11.7.dev20250911104039.dist-info → letta_nightly-0.11.7.dev20250912104045.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.11.7.dev20250911104039
+Version: 0.11.7.dev20250912104045
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License
@@ -84,7 +84,7 @@ Requires-Dist: magika>=0.6.2; extra == 'desktop'
 Requires-Dist: pgvector>=0.2.3; extra == 'desktop'
 Requires-Dist: sqlite-vec>=0.1.7a2; extra == 'desktop'
 Requires-Dist: tiktoken>=0.11.0; extra == 'desktop'
-Requires-Dist: uvicorn>=0.24.0.post1; extra == 'desktop'
+Requires-Dist: uvicorn==0.29.0; extra == 'desktop'
 Requires-Dist: websockets; extra == 'desktop'
 Requires-Dist: wikipedia>=1.4.0; extra == 'desktop'
 Provides-Extra: dev
@@ -125,7 +125,7 @@ Provides-Extra: redis
 Requires-Dist: redis>=6.2.0; extra == 'redis'
 Provides-Extra: server
 Requires-Dist: fastapi>=0.115.6; extra == 'server'
-Requires-Dist: uvicorn>=0.24.0.post1; extra == 'server'
+Requires-Dist: uvicorn==0.29.0; extra == 'server'
 Requires-Dist: websockets; extra == 'server'
 Provides-Extra: sqlite
 Requires-Dist: aiosqlite>=0.21.0; extra == 'sqlite'

{letta_nightly-0.11.7.dev20250911104039.dist-info → letta_nightly-0.11.7.dev20250912104045.dist-info}/RECORD

@@ -27,7 +27,7 @@ letta/agents/exceptions.py,sha256=BQY4D4w32OYHM63CM19ko7dPwZiAzUs3NbKvzmCTcJg,31
 letta/agents/helpers.py,sha256=eCHsvZEkTe0L_uZHYkfNAztsEJW0FTnKZMgVbqlI0Yg,11618
 letta/agents/letta_agent.py,sha256=6nRTh5kzUpqK7eNMk4DlcgEoPmDxFmRb5ysoVHa-vh8,99488
 letta/agents/letta_agent_batch.py,sha256=17RpYVXpGh9dlKxdMOLMCOHWFsi6N5S9FJHxooxkJCI,27998
-letta/agents/letta_agent_v2.py,sha256=EDQ7ShQXS09cCMTMj0i3J2eECp5-ISDrB4QQWT9ALlg,58257
+letta/agents/letta_agent_v2.py,sha256=Xs54mewx9SgHHFAz8uLJ_6OHv9RHU1PtkwAB_Pu0XMk,58992
 letta/agents/voice_agent.py,sha256=y-n6qadfKsswvGODzXH02pLIQQ44wnaDSE6oUgKHVkA,23381
 letta/agents/voice_sleeptime_agent.py,sha256=_JzCbWBOKrmo1cTaqZFTrQudpJEapwAyrXYtAHUILGo,8675
 letta/cli/cli.py,sha256=tKtghlX36Rp0_HbkMosvlAapL07JXhA0vKLGTNKnxSQ,1615
@@ -78,14 +78,14 @@ letta/helpers/reasoning_helper.py,sha256=8P5AJo-UFsYhZC3yNx4N-pIkVUsjfz7ZPmydsVK
 letta/helpers/singleton.py,sha256=Y4dG_ZBCcrogvl9iZ69bSLq-QltrdP8wHqKkhef8OBI,370
 letta/helpers/tool_execution_helper.py,sha256=Oz9xNDrSFUIrYhEhLaw8yoXdHbfijuxwtS1tJv-lH2A,5149
 letta/helpers/tool_rule_solver.py,sha256=dd5gvj67_8FgXrC0_Px5TWXE8A9CMFvH_E26idPrkKY,9848
-letta/helpers/tpuf_client.py,sha256=dZuR5ZZqWOUYwXS4aX5YDEkw1Wf3zo_r5hpL8x7xFig,60993
+letta/helpers/tpuf_client.py,sha256=7x6dP7MeHfINs_aVxQAmEXYYM3bJcw3fiyrJYG1ZpAk,62211
 letta/humans/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/humans/examples/basic.txt,sha256=Lcp8YESTWvOJgO4Yf_yyQmgo5bKakeB1nIVrwEGG6PA,17
 letta/humans/examples/cs_phd.txt,sha256=9C9ZAV_VuG7GB31ksy3-_NAyk8rjE6YtVOkhp08k1xw,297
 letta/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/interfaces/anthropic_streaming_interface.py,sha256=0VyK8kTRgCLNDLQN6vX1gJ0dfJhqguL_NL1GYgFr6fU,25614
 letta/interfaces/openai_chat_completions_streaming_interface.py,sha256=3xHXh8cW79EkiMUTYfvcH_s92nkLjxXfvtVOVC3bfLo,5050
-letta/interfaces/openai_streaming_interface.py,sha256=m2QeZo4w5lclwTypqAcHOJ4disaHqwb9yeqQaukfesA,28157
+letta/interfaces/openai_streaming_interface.py,sha256=t_TKcZSH0Bv_ajOh2mTd4RetrCr-rahkjmGIZIIGDXQ,23593
 letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/jobs/helpers.py,sha256=kO4aj954xsQ1RAmkjY6LQQ7JEIGuhaxB1e9pzrYKHAY,914
@@ -99,7 +99,7 @@ letta/llm_api/bedrock_client.py,sha256=gNKSFGCbrrLMPvtBItAOz1nme4K_opgkZdFa3cUzp
 letta/llm_api/deepseek_client.py,sha256=di6ApSQu1DewXw0_JIP7AK4IHvXQHd0e32tQfFf5F34,16975
 letta/llm_api/google_ai_client.py,sha256=JweTUHZXvK6kcZBGXA7XEU53KP4vM7_zdD7AorCtsdI,8166
 letta/llm_api/google_constants.py,sha256=eOjOv-FImyJ4b4QGIaod-mEROMtrBFz0yhuYHqOEkwY,797
-letta/llm_api/google_vertex_client.py,sha256=PUTUa2DM-nIVhE7H3pDwPqgPl2gLAAgGgANzABV6Xfc,28680
+letta/llm_api/google_vertex_client.py,sha256=57qrBe5dY-ERB9xI9_tWRwW_uSxGbHqR02mvnWmCLGY,28910
 letta/llm_api/groq_client.py,sha256=nNeWSgDVOLn3iFiicDKyhHj7f73JxrB9-7_M2Pv2e1I,3192
 letta/llm_api/helpers.py,sha256=GXV_SuaU7uSCDj6bxDcCCF7CUjuZQCVWd5qZ3OsHVNk,17587
 letta/llm_api/llm_api_tools.py,sha256=lsZ6OeIHesyOfbNQi5CVw5hn1lTQP5gJyforp-D0nk8,12294
@@ -107,7 +107,7 @@ letta/llm_api/llm_client.py,sha256=iXiPbrhluP2DBczv9nkFlAXdwWGOkg0lNDA9LzLrG4o,3
 letta/llm_api/llm_client_base.py,sha256=RFo8H4ILxVyzB3DeF4rJoJJYjRF8ScVO4yyDrhuN0DY,10052
 letta/llm_api/mistral.py,sha256=ruOTBt07Uzx7S30_eXhedVWngtpjtlzG6Ox1Iw0_mQs,662
 letta/llm_api/openai.py,sha256=56cwdS9l-75cMTtY9df6Dbb1M9crH8YQsSdF3Pm3Rpg,27393
-letta/llm_api/openai_client.py,sha256=rnWMspbJ7ZcpFPhIJDBNACRJPk_Y3v8DtRzSMbl76ZU,22396
+letta/llm_api/openai_client.py,sha256=Ww68D103uQolsALOzfPD5-CTuEaIFBbkdnrtMBIaZlc,22475
 letta/llm_api/together_client.py,sha256=HeDMDDa525yfDTKciODDfX_t93QBfFmX0n2P-FT1QTU,2284
 letta/llm_api/xai_client.py,sha256=3mpSQ9OoWyjqo2VhNM_m0EPBzS69r4p-OEwL7UWc9oY,3772
 letta/llm_api/sample_response_jsons/aws_bedrock.json,sha256=RS3VqyxPB9hQQCPm42hWoga0bisKv_0e8ZF-c3Ag1FA,930
@@ -171,7 +171,7 @@ letta/orm/groups_blocks.py,sha256=ou18XqI9tkb0fcecUd4eHTVmmndGuby1DIdmHM5lHF4,48
 letta/orm/identities_agents.py,sha256=cfIQ6UsbwmjxtGVmFt1ArK2zbKr9k6VWoELuISDnLSc,502
 letta/orm/identities_blocks.py,sha256=oS0DnDXKzcWtlH2dDFREkNF1JHJ3Kyg8fN9GI8DKtcg,501
 letta/orm/identity.py,sha256=NRgC6ArQZCrs3LYhGHoBMHNJzi_uoYFvJAr0HoRhqLg,2924
-letta/orm/job.py,sha256=kTRnIWBjfwt0fSKmu3XPC1sPpjVukWJx672PRhJrQG0,3019
+letta/orm/job.py,sha256=nlDw6Y7zT96jFW-OOjf-vY66Py7S6_3jTRmhOmNnIUw,3357
 letta/orm/job_messages.py,sha256=SgwaYPYwwAC3dBtl9Xye_TWUl9H_-m95S95TTcfPyOg,1245
 letta/orm/llm_batch_items.py,sha256=LZI9vjOrswiGXPVLvLOT5uObDtyTXX1p7yljSiiMH7g,2725
 letta/orm/llm_batch_job.py,sha256=LaeOrnNf6FMm6ff2kOCEAjtbSuz4C5KYU5OmM90F1PY,2368
@@ -179,7 +179,7 @@ letta/orm/mcp_oauth.py,sha256=lr0XIcj9zwQpWlqQHIWAaT73YnunsrkEnLzBLP-8L2k,3095
 letta/orm/mcp_server.py,sha256=PT3Edqn0Er1ZDExsXdjhC--iGL4Vi3XjPPgxNfbNRDA,2155
 letta/orm/message.py,sha256=sGMH7XJRErtIEngFV08b9A_zk5veyLkpQsU3zKN0AhM,9335
 letta/orm/mixins.py,sha256=moZyS4e9gXGULKNsOqQuZrBn55IlrFF7MQOAVl68Aq0,2688
-letta/orm/organization.py,sha256=g7d4rFMdVM3r7TwHnx_uSCKLoOw5kXzAgKd2bPr7S6U,4058
+letta/orm/organization.py,sha256=wZ3yvPa6Vy-c_74S_XGjzjWND1oR7U7xzrdrdipZM8A,4205
 letta/orm/passage.py,sha256=qjBZdyZV05ZGe6Dprn4GIwdc3wjYRuchZO2Ja9I9bT4,4404
 letta/orm/passage_tag.py,sha256=TtT00DjXh9n0BshehBBcTjo3lnR1d-wNBi-ePJTZ_0M,2121
 letta/orm/prompt.py,sha256=NpFPTm3jD8Aewxhlnq8s4eIzANJ3bAEtbq6UmFqyc3U,489
@@ -342,7 +342,7 @@ letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfN
 letta/server/rest_api/chat_completions_interface.py,sha256=-7wO7pNBWXMqblVkJpuZ8JPJ-LjudLTtT6BJu-q_XAM,11138
 letta/server/rest_api/interface.py,sha256=X5NZ8oerDcipG9y1AfD92zJ_2TgVMO4eJ42RP82GFF8,70952
 letta/server/rest_api/json_parser.py,sha256=yoakaCkSMdf0Y_pyILoFKZlvzXeqF-E1KNeHzatLMDc,9157
-letta/server/rest_api/redis_stream_manager.py,sha256=YR9daW5kG-s31-lyg4YVPU8lClS6UG7zuzZWKVUXBQg,10179
+letta/server/rest_api/redis_stream_manager.py,sha256=hz85CigFWdLkK1FWUmF-i6ObgoKkuoEgkiwshZ6QPKI,10764
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/streaming_response.py,sha256=wfhby6skucjGtw9d9pcfa856lI1r6JKaosCYbutKD2k,14458
 letta/server/rest_api/utils.py,sha256=IT3RnZJWNIaTdFEEyveZb47o9PIzDT_2pIgpPBVN7iU,19326
@@ -355,7 +355,7 @@ letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=ohM1i8BsNxTiw8duuRT5X_0tSUzBwctQM4fJ5DXURic,5157
 letta/server/rest_api/routers/v1/__init__.py,sha256=9MnEA7CgtIxyU_dDNG0jm-Ziqu1somBml-e5gKjgd9I,1997
-letta/server/rest_api/routers/v1/agents.py,sha256=VQyGsi6Ci7Ili8rSoKnwY9RZYBcSXzcj7lnpz4OopSk,75580
+letta/server/rest_api/routers/v1/agents.py,sha256=2eo7EDXTpybTPfOvgEGhm81LenIJcXNxv-bf5CcqjkU,75673
 letta/server/rest_api/routers/v1/blocks.py,sha256=ykI77xnmIxPLqdAy5kzGyGw0w0ZRyVXn-O5Xcdj6-70,7690
 letta/server/rest_api/routers/v1/embeddings.py,sha256=PRaQlrmEXPiIdWsTbadrFsv3Afyv5oEFUdhgHA8FTi8,989
 letta/server/rest_api/routers/v1/folders.py,sha256=8Yb-bw2JdXBxMfrJNIZQk9_FKN2fet9Ccp8T83_c2sc,23539
@@ -374,7 +374,7 @@ letta/server/rest_api/routers/v1/sources.py,sha256=nXZxtHi40281VltWmx1RwGBbau_00
 letta/server/rest_api/routers/v1/steps.py,sha256=bTzfz1GR3VEZdJRYUGiSr6ZLd12i5faPsf3oAqu1eMk,5570
 letta/server/rest_api/routers/v1/tags.py,sha256=ef94QitUSJ3NQVffWF1ZqANUZ2b2jRyGHp_I3UUjhno,912
 letta/server/rest_api/routers/v1/telemetry.py,sha256=eSTg7mWbuwPb2OTHQxwRM0EUEl49wHzNB6i1xJtH8BQ,1036
-letta/server/rest_api/routers/v1/tools.py,sha256=aYp__U2PgTCpL3eypYUJ6V5C4iQA6LeFBHTSo8w-WOg,51890
+letta/server/rest_api/routers/v1/tools.py,sha256=UMtJj3bX8fVe0VuuU5JS0TeaFimEzZ4YRyphSO2tQMU,51085
 letta/server/rest_api/routers/v1/users.py,sha256=J1vaTbS1UrBMgnPya7GdZ2wr3L9XHmkm6qdGY6pWaOI,2366
 letta/server/rest_api/routers/v1/voice.py,sha256=ghMBp5Uovbf0-3nN6d9P5kpl1hHACLRMhIDGQp96G9Q,1986
 letta/server/static_files/favicon.ico,sha256=DezhLdFSbM8o81wCOZcV3riq7tFUOGQD4h6-vr-HuU0,342
@@ -397,9 +397,9 @@ letta/services/file_manager.py,sha256=d4uX8RblmqNGk1MsfeGzQ5uDWKVFP-AH63Jz5xOkj2
 letta/services/files_agents_manager.py,sha256=QJrJTgDn3RXUjZIGiIw4GQ5k2iKj-Wvzs-WQetpQ154,30059
 letta/services/group_manager.py,sha256=dD4DDHjOptMrtbWqw1ErlhpBqChw2ubLJdILjeLTY8I,29183
 letta/services/identity_manager.py,sha256=JI9Xc7EsBagSwDS2na4rFNhoO_LuaxlkVO_1oIK_ITQ,11841
-letta/services/job_manager.py,sha256=31AKBwQWkjOFH2n4Cx3KCv1g_n499C_1VRIVviUGsLI,35312
+letta/services/job_manager.py,sha256=nDrnr_r8ELwf8KMKyRRrWHsysrTGldgCTplJdaSiNiQ,35543
 letta/services/llm_batch_manager.py,sha256=iDzLFfmgpQooGY4zpN_w8q1SZ27fr2Cv6Ks3ltZErL8,20929
-letta/services/mcp_manager.py,sha256=aenw1-UgjecmQ6BLrTWVvpKJmeFcGslocdhRKT_PqEk,45077
+letta/services/mcp_manager.py,sha256=QuvKQnwxMXrhiCaYlF50GZwXmbSU7PxmcOZ85sQ3t7I,47848
 letta/services/message_manager.py,sha256=tomsZidPT-I95sJsEsls-vj3qglehV7XNTs-m2zF8Bg,60629
 letta/services/organization_manager.py,sha256=JMW5oS_sr6vQQ27OgRV3BR1JL0MqyoGUDcpEOs3SLRY,5800
 letta/services/passage_manager.py,sha256=kOQjlJFz7Dy6e0NEECoFHhcH8hPIMNeEHxZ1JJ-R2Cs,52372
@@ -447,7 +447,7 @@ letta/services/tool_executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 letta/services/tool_executor/builtin_tool_executor.py,sha256=QKPFXbgzYQobqWRuFs9RhVcQ1d53q8-yV_GFdR2IX88,9718
 letta/services/tool_executor/composio_tool_executor.py,sha256=ia2AA_WDOseR8Ylam-HEayR7OiyfNSb1sSUrjwqlmFM,2308
 letta/services/tool_executor/core_tool_executor.py,sha256=bd9x0M9Ttj3FqoIUU66k2FHa2PVY0OlUHqs1aLZYxFI,22624
-letta/services/tool_executor/files_tool_executor.py,sha256=HyJ2RXYMVOhvKoLAamgMA2YsgQJmu6CcjioXiaGfAn0,37808
+letta/services/tool_executor/files_tool_executor.py,sha256=nlXk0w-t_dLiN7fpUrnBrHGIwWIEmSkcXa7b_YJs2ME,37781
 letta/services/tool_executor/mcp_tool_executor.py,sha256=2zEXmkKsH-IGbMG2Xw1S9op4eL21g25RA4vGImB29KY,2000
 letta/services/tool_executor/multi_agent_tool_executor.py,sha256=LIg9yh8BlfYokP_29WryLZPPSMqEsJUwc0mZGMlhc00,5724
 letta/services/tool_executor/sandbox_tool_executor.py,sha256=LamEZUVqsiBfBL9S1uQMXFGQOXqJlXK9ZrfpZBk5jsA,6258
@@ -470,8 +470,8 @@ letta/templates/sandbox_code_file_async.py.j2,sha256=lb7nh_P2W9VZHzU_9TxSCEMUod7
 letta/templates/summary_request_text.j2,sha256=ZttQwXonW2lk4pJLYzLK0pmo4EO4EtUUIXjgXKiizuc,842
 letta/templates/template_helper.py,sha256=HkG3zwRc5NVGmSTQu5PUTpz7LevK43bzXVaQuN8urf0,1634
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
-letta_nightly-0.11.7.dev20250911104039.dist-info/METADATA,sha256=toGJ1-WRYUWzjt9UP7FnP49pm3M_vjCliXaUV3yLsw0,24436
-letta_nightly-0.11.7.dev20250911104039.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-letta_nightly-0.11.7.dev20250911104039.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
-letta_nightly-0.11.7.dev20250911104039.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.11.7.dev20250911104039.dist-info/RECORD,,
+letta_nightly-0.11.7.dev20250912104045.dist-info/METADATA,sha256=tqJlpOfovWrr9Go7iI1cwIOkAgFx0Qwf7JYX11vg2JI,24424
+letta_nightly-0.11.7.dev20250912104045.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+letta_nightly-0.11.7.dev20250912104045.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
+letta_nightly-0.11.7.dev20250912104045.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.11.7.dev20250912104045.dist-info/RECORD,,