letta-nightly 0.11.7.dev20250913103940__py3-none-any.whl → 0.11.7.dev20250915104130__py3-none-any.whl

letta/interfaces/openai_streaming_interface.py

@@ -24,7 +24,11 @@ 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 FunctionArgumentsStreamHandler, JSONInnerThoughtsExtractor
+from letta.streaming_utils import (
+    FunctionArgumentsStreamHandler,
+    JSONInnerThoughtsExtractor,
+    sanitize_streamed_message_content,
+)
 from letta.utils import count_tokens
 
 logger = get_logger(__name__)
@@ -278,8 +282,6 @@ class OpenAIStreamingInterface:
                                     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()
-                                self.assistant_message_json_reader.in_message = True
-                                self.assistant_message_json_reader.message_started = True
 
                             else:
                                 if prev_message_type and prev_message_type != "tool_call_message":
@@ -334,8 +336,15 @@ class OpenAIStreamingInterface:
                                 self.last_flushed_function_name is not None
                                 and self.last_flushed_function_name == self.assistant_message_tool_name
                             ):
-                                # Minimal, robust extraction: only emit the value of "message"
-                                extracted = self.assistant_message_json_reader.process_json_chunk(tool_call.function.arguments)
+                                # Minimal, robust extraction: only emit the value of "message".
+                                # If we buffered a prefix while name was streaming, feed it first.
+                                if self.function_args_buffer:
+                                    payload = self.function_args_buffer + tool_call.function.arguments
+                                    self.function_args_buffer = None
+                                else:
+                                    payload = tool_call.function.arguments
+                                extracted = self.assistant_message_json_reader.process_json_chunk(payload)
+                                extracted = sanitize_streamed_message_content(extracted or "")
                                 if extracted:
                                     if prev_message_type and prev_message_type != "assistant_message":
                                         message_index += 1

letta/server/rest_api/interface.py

@@ -808,86 +808,33 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         # If there was nothing in the name buffer, we can proceed to
                         # output the arguments chunk as a ToolCallMessage
                         else:
-                            # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                            # use_assistant_message means we should emit only the value of "message"
                             if self.use_assistant_message and (
                                 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
+                                # Feed any buffered prefix first to avoid missing the start of the value
+                                payload = (self.function_args_buffer or "") + (updates_main_json or "")
+                                self.function_args_buffer = None
+                                cleaned = self.streaming_chat_completion_json_reader.process_json_chunk(payload)
+                                from letta.streaming_utils import sanitize_streamed_message_content
+
+                                cleaned = sanitize_streamed_message_content(cleaned or "")
+                                if not cleaned:
                                     return None
-
-                                # 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
-
-                                    if prev_message_type and prev_message_type != "assistant_message":
-                                        message_index += 1
-                                    processed_chunk = AssistantMessage(
-                                        id=message_id,
-                                        date=message_date,
-                                        content=combined_chunk,
-                                        name=name,
-                                        otid=Message.generate_otid_from_id(message_id, message_index),
-                                    )
-                                    # 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)
-                                        self.current_json_parse_result = parsed_args
-                                        if prev_message_type and prev_message_type != "assistant_message":
-                                            message_index += 1
-                                        processed_chunk = AssistantMessage(
-                                            id=message_id,
-                                            date=message_date,
-                                            content=diff,
-                                            name=name,
-                                            otid=Message.generate_otid_from_id(message_id, message_index),
-                                        )
-                                    else:
-                                        return None
-
-                                    # 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
+                                if prev_message_type and prev_message_type != "assistant_message":
+                                    message_index += 1
+                                processed_chunk = AssistantMessage(
+                                    id=message_id,
+                                    date=message_date,
+                                    content=cleaned,
+                                    name=name,
+                                    otid=Message.generate_otid_from_id(message_id, message_index),
+                                )
+                                # 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
+                                # Do not clear function_id_buffer here — we may still need it
                             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/server/rest_api/routers/v1/agents.py

@@ -162,8 +162,8 @@ class IndentedORJSONResponse(Response):
         return orjson.dumps(content, option=orjson.OPT_INDENT_2)
 
 
-@router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent_serialized")
-async def export_agent_serialized(
+@router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent")
+async def export_agent(
     agent_id: str,
     max_steps: int = 100,
     server: "SyncServer" = Depends(get_letta_server),
@@ -256,7 +256,7 @@ def import_agent_legacy(
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred while uploading the agent: {e!s}")
 
 
-async def import_agent(
+async def _import_agent(
     agent_file_json: dict,
     server: "SyncServer",
     actor: User,
@@ -313,8 +313,8 @@ async def import_agent(
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred while importing agents: {e!s}")
 
 
-@router.post("/import", response_model=ImportedAgentsResponse, operation_id="import_agent_serialized")
-async def import_agent_serialized(
+@router.post("/import", response_model=ImportedAgentsResponse, operation_id="import_agent")
+async def import_agent(
     file: UploadFile = File(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),
@@ -367,7 +367,7 @@ async def import_agent_serialized(
     # TODO: This is kind of hacky, but should work as long as dont' change the schema
     if "agents" in agent_json and isinstance(agent_json.get("agents"), list):
         # This is an AgentFileSchema
-        agent_ids = await import_agent(
+        agent_ids = await _import_agent(
             agent_file_json=agent_json,
             server=server,
             actor=actor,

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

@@ -12,8 +12,8 @@ router = APIRouter(prefix="/health", tags=["health"])
 
 
 # Health check
-@router.get("/", response_model=Health, operation_id="health_check")
-def health_check():
+@router.get("/", response_model=Health, operation_id="check_health")
+def check_health():
     return Health(
         version=__version__,
         status="ok",

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

@@ -19,23 +19,22 @@ router = APIRouter(prefix="/messages", tags=["messages"])
 logger = get_logger(__name__)
 
 
-# Batch APIs
-
-
 @router.post(
     "/batches",
     response_model=BatchJob,
-    operation_id="create_batch_run",
+    operation_id="create_batch",
 )
-async def create_batch_run(
+async def create_batch(
     request: Request,
     payload: CreateBatch = Body(..., description="Messages and config for all agents"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Submit a batch of agent messages for asynchronous processing.
+    Submit a batch of agent runs for asynchronous processing.
+
     Creates a job that will fan out messages to all listed agents and process them in parallel.
+    The request will be rejected if it exceeds 256MB.
     """
     # Reject requests greater than 256Mbs
     max_bytes = 256 * 1024 * 1024
@@ -76,10 +75,7 @@ async def create_batch_run(
 
         # TODO: update run metadata
     except Exception as e:
-        import traceback
-
-        print("Error creating batch job", e)
-        traceback.print_exc()
+        logger.error(f"Error creating batch job: {e}")
 
         # mark job as failed
         await server.job_manager.update_job_by_id_async(job_id=batch_job.id, job_update=JobUpdate(status=JobStatus.failed), actor=actor)
@@ -87,14 +83,14 @@ async def create_batch_run(
     return batch_job
 
 
-@router.get("/batches/{batch_id}", response_model=BatchJob, operation_id="retrieve_batch_run")
-async def retrieve_batch_run(
+@router.get("/batches/{batch_id}", response_model=BatchJob, operation_id="retrieve_batch")
+async def retrieve_batch(
     batch_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Get the status of a batch run.
+    Retrieve the status and details of a batch run.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
@@ -105,18 +101,36 @@ async def retrieve_batch_run(
         raise HTTPException(status_code=404, detail="Batch not found")
 
 
-@router.get("/batches", response_model=List[BatchJob], operation_id="list_batch_runs")
-async def list_batch_runs(
+@router.get("/batches", response_model=List[BatchJob], operation_id="list_batches")
+async def list_batches(
+    before: Optional[str] = Query(
+        None, description="Job ID cursor for pagination. Returns jobs that come before this job ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Job ID cursor for pagination. Returns jobs that come after this job ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(100, description="Maximum number of jobs to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for jobs by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     List all batch runs.
     """
-    # TODO: filter
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    jobs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.BATCH)
+    jobs = server.job_manager.list_jobs(
+        actor=actor,
+        statuses=[JobStatus.created, JobStatus.running],
+        job_type=JobType.BATCH,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=(order == "asc"),
+    )
     return [BatchJob.from_job(job) for job in jobs]
 
 
@@ -137,14 +151,17 @@ async def list_batch_messages(
     order: Literal["asc", "desc"] = Query(
         "desc", description="Sort order for messages by creation time. 'asc' for oldest first, 'desc' for newest first"
     ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
     agent_id: Optional[str] = Query(None, description="Filter messages by agent ID"),
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: SyncServer = Depends(get_letta_server),
 ):
-    """Get response messages for a specific batch job."""
+    """
+    Get response messages for a specific batch job.
+    """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    # First, verify the batch job exists and the user has access to it
+    # Verify the batch job exists and the user has access to it
     try:
         job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
         BatchJob.from_job(job)
@@ -159,8 +176,8 @@ async def list_batch_messages(
     return LettaBatchMessages(messages=messages)
 
 
-@router.patch("/batches/{batch_id}/cancel", operation_id="cancel_batch_run")
-async def cancel_batch_run(
+@router.patch("/batches/{batch_id}/cancel", operation_id="cancel_batch")
+async def cancel_batch(
     batch_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),

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

@@ -25,7 +25,7 @@ async def list_providers(
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Get a list of all custom providers in the database
+    Get a list of all custom providers.
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
@@ -46,7 +46,7 @@ async def create_provider(
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Create a new custom provider
+    Create a new custom provider.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     for field_name in request.model_fields:
@@ -68,7 +68,7 @@ async def modify_provider(
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Update an existing custom provider
+    Update an existing custom provider.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.provider_manager.update_provider_async(provider_id=provider_id, provider_update=request, actor=actor)
@@ -79,6 +79,9 @@ async def check_provider(
     request: ProviderCheck = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
+    """
+    Verify the API key and additional parameters for a provider.
+    """
     try:
         if request.base_url and len(request.base_url) == 0:
             # set to null if empty string
@@ -100,7 +103,7 @@ async def delete_provider(
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
-    Delete an existing custom provider
+    Delete an existing custom provider.
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)

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

@@ -1,14 +1,17 @@
 from datetime import datetime
 from typing import List, Literal, Optional
 
-from fastapi import APIRouter, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from pydantic import BaseModel, Field
 
 from letta.orm.errors import NoResultFound
+from letta.schemas.provider_trace import ProviderTrace
 from letta.schemas.step import Step
 from letta.schemas.step_metrics import StepMetrics
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.services.step_manager import FeedbackType
+from letta.settings import settings
 
 router = APIRouter(prefix="/steps", tags=["steps"])
 
@@ -93,10 +96,33 @@ async def retrieve_step_metrics(
         raise HTTPException(status_code=404, detail="Step metrics not found")
 
 
+@router.get("/{step_id}/trace", response_model=Optional[ProviderTrace], operation_id="retrieve_step_trace")
+async def retrieve_step_trace(
+    step_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: str | None = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    provider_trace = None
+    if settings.track_provider_trace:
+        try:
+            provider_trace = await server.telemetry_manager.get_provider_trace_by_step_id_async(
+                step_id=step_id, actor=await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+            )
+        except:
+            pass
+
+    return provider_trace
+
+
+class AddFeedbackRequest(BaseModel):
+    feedback: FeedbackType | None = Field(None, description="Whether this feedback is positive or negative")
+    tags: list[str] | None = Field(None, description="Feedback tags to add to the step")
+
+
 @router.patch("/{step_id}/feedback", response_model=Step, operation_id="add_feedback")
 async def add_feedback(
     step_id: str,
-    feedback: Optional[FeedbackType],
+    request: AddFeedbackRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: SyncServer = Depends(get_letta_server),
 ):
@@ -105,7 +131,7 @@ async def add_feedback(
     """
     try:
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-        return await server.step_manager.add_feedback_async(step_id=step_id, feedback=feedback, actor=actor)
+        return await server.step_manager.add_feedback_async(step_id=step_id, feedback=request.feedback, tags=request.tags, actor=actor)
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Step not found")
 

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

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Literal, Optional
 
 from fastapi import APIRouter, Depends, Header, Query
 
@@ -13,15 +13,26 @@ router = APIRouter(prefix="/tags", tags=["tag", "admin"])
 
 @router.get("/", tags=["admin"], response_model=List[str], operation_id="list_tags")
 async def list_tags(
-    after: Optional[str] = Query(None),
-    limit: Optional[int] = Query(50),
+    before: Optional[str] = Query(
+        None, description="Tag cursor for pagination. Returns tags that come before this tag in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Tag cursor for pagination. Returns tags that come after this tag in the specified sort order"
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of tags to return"),
+    order: Literal["asc", "desc"] = Query(
+        "asc", description="Sort order for tags. 'asc' for alphabetical order, 'desc' for reverse alphabetical order"
+    ),
+    order_by: Literal["name"] = Query("name", description="Field to sort by"),
+    query_text: Optional[str] = Query(None, description="Filter tags by text search"),
     server: "SyncServer" = Depends(get_letta_server),
-    query_text: Optional[str] = Query(None),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Get a list of all tags in the database
+    Get a list of all agent tags in the database.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-    tags = await server.agent_manager.list_tags_async(actor=actor, after=after, limit=limit, query_text=query_text)
+    tags = await server.agent_manager.list_tags_async(
+        actor=actor, before=before, after=after, limit=limit, query_text=query_text, ascending=(order == "asc")
+    )
     return tags

letta/services/agent_manager.py

@@ -3542,19 +3542,27 @@ class AgentManager:
     @enforce_types
     @trace_method
     async def list_tags_async(
-        self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50, query_text: Optional[str] = None
+        self,
+        actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        query_text: Optional[str] = None,
+        ascending: bool = True,
     ) -> List[str]:
         """
         Get all tags a user has created, ordered alphabetically.
 
         Args:
             actor: User performing the action.
-            after: Cursor for forward pagination.
-            limit: Maximum number of tags to return.
-            query text to filter tags by.
+            before: Cursor for backward pagination (tags before this tag).
+            after: Cursor for forward pagination (tags after this tag).
+            limit: Maximum number of tags to return (default: 50).
+            query_text: Filter tags by text search.
+            ascending: Sort order - True for alphabetical, False for reverse (default: True).
 
         Returns:
-            List[str]: List of all tags.
+            List[str]: List of all tags matching the criteria.
         """
         async with db_registry.async_session() as session:
             # Build the query using select() for async SQLAlchemy
@@ -3573,10 +3581,26 @@ class AgentManager:
                     # SQLite: Use LIKE with LOWER for case-insensitive search
                     query = query.where(func.lower(AgentsTags.tag).like(func.lower(f"%{query_text}%")))
 
+            # Handle pagination cursors
             if after:
-                query = query.where(AgentsTags.tag > after)
+                if ascending:
+                    query = query.where(AgentsTags.tag > after)
+                else:
+                    query = query.where(AgentsTags.tag < after)
 
-            query = query.order_by(AgentsTags.tag).limit(limit)
+            if before:
+                if ascending:
+                    query = query.where(AgentsTags.tag < before)
+                else:
+                    query = query.where(AgentsTags.tag > before)
+
+            # Apply ordering based on ascending parameter
+            if ascending:
+                query = query.order_by(AgentsTags.tag.asc())
+            else:
+                query = query.order_by(AgentsTags.tag.desc())
+
+            query = query.limit(limit)
 
             # Execute the query asynchronously
             result = await session.execute(query)

letta/services/step_manager.py

@@ -197,12 +197,16 @@ class StepManager:
 
     @enforce_types
     @trace_method
-    async def add_feedback_async(self, step_id: str, feedback: Optional[FeedbackType], actor: PydanticUser) -> PydanticStep:
+    async def add_feedback_async(
+        self, step_id: str, feedback: FeedbackType | None, actor: PydanticUser, tags: list[str] | None = None
+    ) -> PydanticStep:
         async with db_registry.async_session() as session:
             step = await StepModel.read_async(db_session=session, identifier=step_id, actor=actor)
             if not step:
                 raise NoResultFound(f"Step with id {step_id} does not exist")
             step.feedback = feedback
+            if tags:
+                step.tags = tags
             step = await step.update_async(session)
             return step.to_pydantic()
 

letta/streaming_utils.py

@@ -264,39 +264,100 @@ class FunctionArgumentsStreamHandler:
 
     def process_json_chunk(self, chunk: str) -> Optional[str]:
         """Process a chunk from the function arguments and return the plaintext version"""
-        # Use strip to handle only leading and trailing whitespace in control structures
-        if self.accumulating:
-            clean_chunk = chunk.strip()
-            if self.json_key in self.key_buffer:
-                if ":" in clean_chunk:
-                    self.in_message = True
-                    self.accumulating = False
-                    return None
+        clean_chunk = chunk.strip()
+        # Not in message yet: accumulate until we see '<json_key>': (robust to split fragments)
+        if not self.in_message:
+            if clean_chunk == "{":
+                self.key_buffer = ""
+                self.accumulating = True
+                return None
             self.key_buffer += clean_chunk
+            if self.json_key in self.key_buffer and ":" in clean_chunk:
+                # Enter value mode; attempt to extract inline content if it exists in this same chunk
+                self.in_message = True
+                self.accumulating = False
+                # Try to find the first quote after the colon within the original (unstripped) chunk
+                s = chunk
+                colon_idx = s.find(":")
+                if colon_idx != -1:
+                    q_idx = s.find('"', colon_idx + 1)
+                    if q_idx != -1:
+                        self.message_started = True
+                        rem = s[q_idx + 1 :]
+                        # Check if this same chunk also contains the terminating quote (and optional delimiter)
+                        j = len(rem) - 1
+                        while j >= 0 and rem[j] in " \t\r\n":
+                            j -= 1
+                        if j >= 1 and rem[j - 1] == '"' and rem[j] in ",}]":
+                            out = rem[: j - 1]
+                            self.in_message = False
+                            self.message_started = False
+                            return out
+                        if j >= 0 and rem[j] == '"':
+                            out = rem[:j]
+                            self.in_message = False
+                            self.message_started = False
+                            return out
+                        # No terminator yet; emit remainder as content
+                        return rem
+                return None
+            if clean_chunk == "}":
+                self.in_message = False
+                self.message_started = False
+                self.key_buffer = ""
             return None
 
+        # Inside message value
         if self.in_message:
-            if chunk.strip() == '"' and self.message_started:
+            # Bare opening/closing quote tokens
+            if clean_chunk == '"' and self.message_started:
                 self.in_message = False
                 self.message_started = False
                 return None
-            if not self.message_started and chunk.strip() == '"':
+            if not self.message_started and clean_chunk == '"':
                 self.message_started = True
                 return None
             if self.message_started:
-                if chunk.strip().endswith('"'):
+                # Detect closing patterns: '"', '",', '"}' (with optional whitespace)
+                i = len(chunk) - 1
+                while i >= 0 and chunk[i] in " \t\r\n":
+                    i -= 1
+                if i >= 1 and chunk[i - 1] == '"' and chunk[i] in ",}]":
+                    out = chunk[: i - 1]
                     self.in_message = False
-                    return chunk.rstrip('"\n')
+                    self.message_started = False
+                    return out
+                if i >= 0 and chunk[i] == '"':
+                    out = chunk[:i]
+                    self.in_message = False
+                    self.message_started = False
+                    return out
+                # Otherwise, still mid-string
                 return chunk
 
-        if chunk.strip() == "{":
-            self.key_buffer = ""
-            self.accumulating = True
-            return None
-
-        if chunk.strip() == "}":
+        if clean_chunk == "}":
             self.in_message = False
             self.message_started = False
+            self.key_buffer = ""
             return None
 
         return None
+
+
+def sanitize_streamed_message_content(text: str) -> str:
+    """Remove trailing JSON delimiters that can leak into assistant text.
+
+    Specifically handles cases where a message string is immediately followed
+    by a JSON delimiter in the stream (e.g., '"', '",', '"}', '" ]').
+    Internal commas inside the message are preserved.
+    """
+    if not text:
+        return text
+    t = text.rstrip()
+    # strip trailing quote + delimiter
+    if len(t) >= 2 and t[-2] == '"' and t[-1] in ",}]":
+        return t[:-2]
+    # strip lone trailing quote
+    if t.endswith('"'):
+        return t[:-1]
+    return t

letta/utils.py

@@ -536,6 +536,8 @@ def enforce_types(func):
 
             if origin is Union:  # Handle Union types (including Optional)
                 return any(matches_type(value, arg) for arg in args)
+            elif hasattr(hint, "__class__") and hint.__class__.__name__ == "UnionType":  # Handle Python 3.10+ X | Y syntax
+                return any(matches_type(value, arg) for arg in args)
             elif origin is list and isinstance(value, list):  # Handle List[T]
                 element_type = args[0] if args else None
                 return all(isinstance(v, element_type) for v in value) if element_type else True

{letta_nightly-0.11.7.dev20250913103940.dist-info → letta_nightly-0.11.7.dev20250915104130.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.11.7.dev20250913103940
+Version: 0.11.7.dev20250915104130
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License

{letta_nightly-0.11.7.dev20250913103940.dist-info → letta_nightly-0.11.7.dev20250915104130.dist-info}/RECORD

@@ -11,9 +11,9 @@ letta/memory.py,sha256=l5iNhLAR_xzgTb0GBlQx4SVgH8kuZh8siJdC_CFPKEs,4278
 letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/settings.py,sha256=QEjNUwRXGBgsQpQAs2kksQmGN5CbxKlxPPydrklx_Ms,15011
 letta/streaming_interface.py,sha256=rPMfwUcjqITWk2tVqFQm1hmP99tU2IOHg9gU2dgPSo8,16400
-letta/streaming_utils.py,sha256=_UhLa0EtUkd6WL_oBYIU65tDcJ9jf3uWEHuzfQ4HCa8,13769
+letta/streaming_utils.py,sha256=ZRFGFpQqn9ujCEbgZdLM7yTjiuNNvqQ47sNhV8ix-yQ,16553
 letta/system.py,sha256=kHF7n3Viq7gV5UIUEXixod2gWa2jroUgztpEzMC1Sew,8925
-letta/utils.py,sha256=bSq3St7MUw9gN1g0ICdOhNNaUFYBC3EfJLG6qsRLSFA,43290
+letta/utils.py,sha256=TwSAZKw3uCWAzmmEA156W4CYRDaEOiZmAO-zvzFdK6Q,43483
 letta/adapters/letta_llm_adapter.py,sha256=11wkOkEQfPXUuJoJxbK22wCa-8gnWiDAb3UOXOxLt5U,3427
 letta/adapters/letta_llm_request_adapter.py,sha256=wJhK5M_qOhRPAhgMmYI7EJcM8Op19tClnXe0kJ29a3Q,4831
 letta/adapters/letta_llm_stream_adapter.py,sha256=G8IqtXor0LUuW-dKtGJWsUt6DfJreVCn5h6W2lHEPBg,7658
@@ -85,7 +85,7 @@ letta/humans/examples/cs_phd.txt,sha256=9C9ZAV_VuG7GB31ksy3-_NAyk8rjE6YtVOkhp08k
 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=abmtQhWWbXSZGTPBPbMGuAJCyMo9euwttPsjI6joiVU,23768
+letta/interfaces/openai_streaming_interface.py,sha256=YLArar2ypOEaVt7suJxpg1QZr0ErwEmPSEVhzaP6JWc,24166
 letta/interfaces/utils.py,sha256=c6jvO0dBYHh8DQnlN-B0qeNC64d3CSunhfqlFA4pJTY,278
 letta/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/jobs/helpers.py,sha256=kO4aj954xsQ1RAmkjY6LQQ7JEIGuhaxB1e9pzrYKHAY,914
@@ -340,7 +340,7 @@ letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 letta/server/rest_api/app.py,sha256=T3LLveXRJmfWqR0uEzoaLY8LXwYrwCQGb80XMbSCDUo,21172
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
 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/interface.py,sha256=_GQfKYUp9w4Wo2HSE_8Ff7QU16t1blspLaqmukpER9s,67099
 letta/server/rest_api/json_parser.py,sha256=yoakaCkSMdf0Y_pyILoFKZlvzXeqF-E1KNeHzatLMDc,9157
 letta/server/rest_api/redis_stream_manager.py,sha256=hz85CigFWdLkK1FWUmF-i6ObgoKkuoEgkiwshZ6QPKI,10764
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
@@ -355,24 +355,24 @@ 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=2lGLtfgB2ZtAa0EgaiaDlNV0GJhAi_kQQy7XqXB2DG0,77771
+letta/server/rest_api/routers/v1/agents.py,sha256=rYCTQqlWHp0YgahElG1XOznD3OKT7zRr4R7mBo_ln8o,77729
 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
 letta/server/rest_api/routers/v1/groups.py,sha256=PlCKfG1ZUubg-bNVRBmqJNBMvvZtHDvT50LUKKd0w9I,11466
-letta/server/rest_api/routers/v1/health.py,sha256=MoOjkydhGcJXTiuJrKIB0etVXiRMdTa51S8RQ8-50DQ,399
+letta/server/rest_api/routers/v1/health.py,sha256=j43UoGJ7Yh5WzdwvqbKTEdWzlcKJBF6ZI5I1kslWim0,399
 letta/server/rest_api/routers/v1/identities.py,sha256=KUfw6avQIVHNw2lWz4pXOyTOPVy1g19CJGG-zayORl8,7858
 letta/server/rest_api/routers/v1/internal_templates.py,sha256=wY7tUmF7kZEVnjBVsw3_Tez4U2c8SABDJ2vplsKxhzM,11211
 letta/server/rest_api/routers/v1/jobs.py,sha256=ZcP_cqxgixCEYNtKVMqN1FwErNY-945h7XZhQV4vcEE,4933
 letta/server/rest_api/routers/v1/llms.py,sha256=0VJuuGW9_ta0cBnSDtXd3Ngw7GjsqEN2NBf5U3b6M3I,1920
-letta/server/rest_api/routers/v1/messages.py,sha256=J4Sbn8oMX24_OoBpHFLpcJi7vgJxeihmu36EgcPmfjk,7662
+letta/server/rest_api/routers/v1/messages.py,sha256=iXw59JTqpXs_I6JTxE5bNCh72EUExBOo2dewv68Lb94,8528
 letta/server/rest_api/routers/v1/organizations.py,sha256=OnG2vMDZEmN4eEvj24CPwiV76ImHQuHi2ojrgwJnw7I,2925
-letta/server/rest_api/routers/v1/providers.py,sha256=rypNWQ1VMjmZJYd48uvNGJsE2N22jDTxn89qvbDaOMs,4765
+letta/server/rest_api/routers/v1/providers.py,sha256=T3xvtiJO89p_a0wJ1fFmqPOc--kGbmOXI9eWdDW260c,4834
 letta/server/rest_api/routers/v1/runs.py,sha256=WnYwoFNjHNZicTnCkvoXCxl0XiyVAEvF70TTaMCBhPw,12982
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=f0xEOwR3PXqCS2HOjEv7UKfMWTwEaTHx105HW_X-LI4,8852
 letta/server/rest_api/routers/v1/sources.py,sha256=nXZxtHi40281VltWmx1RwGBbau_00UpzDS6teTLvt2w,22679
-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/steps.py,sha256=t_RnOQR_dwthpPeE8Bko6hSXbW3GtMvJj-9wQYvDh6A,6670
+letta/server/rest_api/routers/v1/tags.py,sha256=9VCZUc0YBZD07PvLPJl7iOaj2-foLaBJ5s5rZ8xzNHA,1608
 letta/server/rest_api/routers/v1/telemetry.py,sha256=eSTg7mWbuwPb2OTHQxwRM0EUEl49wHzNB6i1xJtH8BQ,1036
 letta/server/rest_api/routers/v1/tools.py,sha256=UMtJj3bX8fVe0VuuU5JS0TeaFimEzZ4YRyphSO2tQMU,51085
 letta/server/rest_api/routers/v1/users.py,sha256=J1vaTbS1UrBMgnPya7GdZ2wr3L9XHmkm6qdGY6pWaOI,2366
@@ -389,7 +389,7 @@ letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etz
 letta/server/ws_api/server.py,sha256=_16TQafm509rqRztZYqo0HKKZoe8ccBrNftd_kbIJTE,5833
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/agent_file_manager.py,sha256=bgYTyQA90Iqo3W-LprPtyyOKf2itoqivcRhh4EOUXss,30847
-letta/services/agent_manager.py,sha256=KaJRTWwvA1SpfKQFPPVCeYxIOKwpKmLMioeyHuGw63Y,168884
+letta/services/agent_manager.py,sha256=C-k9S8_TwLRDSdCqu0YZXbwgSRn4_hPOpP2O62NkaMM,169791
 letta/services/agent_serialization_manager.py,sha256=lWXTzYItqVxJMyy9ZYlcCDQwC3ZKk9XPCHvBkoVuszA,46388
 letta/services/archive_manager.py,sha256=P10BjZ2PxLoIkCwJ8rx7qLzchNVBsqNG3_KzxTanCLQ,14060
 letta/services/block_manager.py,sha256=mohj12QqHenSBbBx0Xmry1Rw25Gy5DSljOITzAwqMtw,33683
@@ -407,7 +407,7 @@ letta/services/per_agent_lock_manager.py,sha256=cMaW8r-qhucQbiK27jVqz8wzhlr2yuRN
 letta/services/provider_manager.py,sha256=vysp_SgJDezn6YymOfTiNVKOF93EK_dLhsM7upzSjrM,10727
 letta/services/sandbox_config_manager.py,sha256=BwN3bebiFvcliTJpRkbOwGxmV5dUJ8B64kFfXAgAqDw,25989
 letta/services/source_manager.py,sha256=mH9l2KJ9R7yG1vdqhltOIVsAajQP4KbueKcB7ZgN0QA,18624
-letta/services/step_manager.py,sha256=RLDdxyPI0bxlp2CWr1zzGuNbyR6CAttw4wThpOQAQyE,20891
+letta/services/step_manager.py,sha256=vfXhE-cuE40dv2Uv6pICrpleJeXMjYeEOrkvGcY_sqI,20987
 letta/services/telemetry_manager.py,sha256=zDdSsRrBYunmlemtUUL1Qh3bcKu5-nhL2n7AlAmVrgs,3297
 letta/services/tool_manager.py,sha256=zh52n6StaFF5-v6nu0kdNSzJq4du5ACv5iGw5_Y9EDM,43192
 letta/services/user_manager.py,sha256=XuG9eFrvax69sONx7t_D5kgpt5zNwyER-MhqLSDs8L4,9949
@@ -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.dev20250913103940.dist-info/METADATA,sha256=bBw5qZ0Uuj_L5Hs-2tji7ZiKtmp3V0LWaPeCiOkGV9A,24424
-letta_nightly-0.11.7.dev20250913103940.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-letta_nightly-0.11.7.dev20250913103940.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
-letta_nightly-0.11.7.dev20250913103940.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.11.7.dev20250913103940.dist-info/RECORD,,
+letta_nightly-0.11.7.dev20250915104130.dist-info/METADATA,sha256=mpHuQ8T7Dn58hWBd4OBq_IJhl-GIqXOmD1T4jt4SwSY,24424
+letta_nightly-0.11.7.dev20250915104130.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+letta_nightly-0.11.7.dev20250915104130.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
+letta_nightly-0.11.7.dev20250915104130.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.11.7.dev20250915104130.dist-info/RECORD,,