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

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/server/rest_api/streaming_response.py

@@ -19,6 +19,7 @@ from letta.schemas.user import User
 from letta.server.rest_api.utils import capture_sentry_exception
 from letta.services.job_manager import JobManager
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -64,7 +65,7 @@ async def add_keepalive_to_stream(
             await queue.put(("end", None))
 
     # Start the stream reader task
-    reader_task = asyncio.create_task(stream_reader())
+    reader_task = safe_create_task(stream_reader(), label="stream_reader")
 
     try:
         while True:

letta/server/server.py

@@ -109,7 +109,7 @@ from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import DatabaseChoice, model_settings, settings, tool_settings
 from letta.streaming_interface import AgentChunkStreamingInterface
-from letta.utils import get_friendly_error_msg, get_persona_text, make_key
+from letta.utils import get_friendly_error_msg, get_persona_text, make_key, safe_create_task
 
 config = LettaConfig.load()
 logger = get_logger(__name__)
@@ -2248,7 +2248,7 @@ class SyncServer(Server):
 
             # Offload the synchronous message_func to a separate thread
             streaming_interface.stream_start()
-            task = asyncio.create_task(
+            task = safe_create_task(
                 asyncio.to_thread(
                     self.send_messages,
                     actor=actor,
@@ -2256,7 +2256,8 @@ class SyncServer(Server):
                     input_messages=input_messages,
                     interface=streaming_interface,
                     metadata=metadata,
-                )
+                ),
+                label="send_messages_thread",
             )
 
             if stream_steps:
@@ -2363,13 +2364,14 @@ class SyncServer(Server):
             streaming_interface.metadata = metadata
 
         streaming_interface.stream_start()
-        task = asyncio.create_task(
+        task = safe_create_task(
             asyncio.to_thread(
                 letta_multi_agent.step,
                 input_messages=input_messages,
                 chaining=self.chaining,
                 max_chaining_steps=self.max_chaining_steps,
-            )
+            ),
+            label="multi_agent_step_thread",
         )
 
         if stream_steps:

letta/services/agent_serialization_manager.py

@@ -53,7 +53,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
 from letta.settings import settings
-from letta.utils import get_latest_alembic_revision
+from letta.utils import get_latest_alembic_revision, safe_create_task
 
 logger = get_logger(__name__)
 
@@ -622,10 +622,11 @@ class AgentSerializationManager:
 
                         # Create background task for file processing
                         # TODO: This can be moved to celery or RQ or something
-                        task = asyncio.create_task(
+                        task = safe_create_task(
                             self._process_file_async(
                                 file_metadata=file_metadata, source_id=source_db_id, file_processor=file_processor, actor=actor
-                            )
+                            ),
+                            label=f"process_file_{file_metadata.file_name}",
                         )
                         background_tasks.append(task)
                         logger.info(f"Started background processing for file {file_metadata.file_name} (ID: {file_db_id})")

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

@@ -43,7 +43,7 @@ from letta.services.mcp.stdio_client import AsyncStdioMCPClient
 from letta.services.mcp.streamable_http_client import AsyncStreamableHTTPMCPClient
 from letta.services.tool_manager import ToolManager
 from letta.settings import tool_settings
-from letta.utils import enforce_types, printd
+from letta.utils import enforce_types, printd, safe_create_task
 
 logger = get_logger(__name__)
 
@@ -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."""
@@ -869,7 +930,7 @@ class MCPManager:
 
             # Run connect_to_server in background to avoid blocking
             # This will trigger the OAuth flow and the redirect_handler will save the authorization URL to database
-            connect_task = asyncio.create_task(temp_client.connect_to_server())
+            connect_task = safe_create_task(temp_client.connect_to_server(), label="mcp_oauth_connect")
 
             # Give the OAuth flow time to trigger and save the URL
             await asyncio.sleep(1.0)

letta/services/summarizer/summarizer.py

@@ -20,6 +20,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.system import package_summarize_message_no_counts
 from letta.templates.template_helper import render_template
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -100,7 +101,7 @@ class Summarizer:
             return in_context_messages, False
 
     def fire_and_forget(self, coro):
-        task = asyncio.create_task(coro)
+        task = safe_create_task(coro, label="summarizer_background_task")
 
         def callback(t):
             try:

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/services/tool_executor/multi_agent_tool_executor.py

@@ -13,6 +13,7 @@ from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
 from letta.settings import settings
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -55,7 +56,8 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             f"{message}"
         )
 
-        return str(await self._process_agent(agent_id=other_agent_id, message=augmented_message))
+        other_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=other_agent_id, actor=self.actor)
+        return str(await self._process_agent(agent_state=other_agent_state, message=augmented_message))
 
     async def send_message_to_agents_matching_tags_async(
         self, agent_state: AgentState, message: str, match_all: List[str], match_some: List[str]
@@ -75,22 +77,20 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
         )
 
         tasks = [
-            asyncio.create_task(self._process_agent(agent_id=agent_state.id, message=augmented_message)) for agent_state in matching_agents
+            safe_create_task(
+                self._process_agent(agent_state=agent_state, message=augmented_message), label=f"process_agent_{agent_state.id}"
+            )
+            for agent_state in matching_agents
         ]
         results = await asyncio.gather(*tasks)
         return str(results)
 
-    async def _process_agent(self, agent_id: str, message: str) -> Dict[str, Any]:
-        from letta.agents.letta_agent import LettaAgent
+    async def _process_agent(self, agent_state: AgentState, message: str) -> Dict[str, Any]:
+        from letta.agents.letta_agent_v2 import LettaAgentV2
 
         try:
-            letta_agent = LettaAgent(
-                agent_id=agent_id,
-                message_manager=self.message_manager,
-                agent_manager=self.agent_manager,
-                block_manager=self.block_manager,
-                job_manager=self.job_manager,
-                passage_manager=self.passage_manager,
+            letta_agent = LettaAgentV2(
+                agent_state=agent_state,
                 actor=self.actor,
             )
 
@@ -100,13 +100,13 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             send_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]
 
             return {
-                "agent_id": agent_id,
+                "agent_id": agent_state.id,
                 "response": send_message_content if send_message_content else ["<no response>"],
             }
 
         except Exception as e:
             return {
-                "agent_id": agent_id,
+                "agent_id": agent_state.id,
                 "error": str(e),
                 "type": type(e).__name__,
             }
@@ -123,7 +123,10 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             f"{message}"
         )
 
-        task = asyncio.create_task(self._process_agent(agent_id=other_agent_id, message=prefixed))
+        other_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=other_agent_id, actor=self.actor)
+        task = safe_create_task(
+            self._process_agent(agent_state=other_agent_state, message=prefixed), label=f"send_message_to_{other_agent_id}"
+        )
 
         task.add_done_callback(lambda t: (logger.error(f"Async send_message task failed: {t.exception()}") if t.exception() else None))
 

letta/services/tool_sandbox/local_sandbox.py

@@ -23,7 +23,7 @@ from letta.services.helpers.tool_execution_helper import (
 from letta.services.helpers.tool_parser_helper import parse_stdout_best_effort
 from letta.services.tool_sandbox.base import AsyncToolSandboxBase
 from letta.settings import tool_settings
-from letta.utils import get_friendly_error_msg, parse_stderr_error_msg
+from letta.utils import get_friendly_error_msg, parse_stderr_error_msg, safe_create_task
 
 logger = get_logger(__name__)
 
@@ -89,7 +89,7 @@ class AsyncToolSandboxLocal(AsyncToolSandboxBase):
         venv_preparation_task = None
         if use_venv:
             venv_path = str(os.path.join(sandbox_dir, local_configs.venv_name))
-            venv_preparation_task = asyncio.create_task(self._prepare_venv(local_configs, venv_path, env))
+            venv_preparation_task = safe_create_task(self._prepare_venv(local_configs, venv_path, env), label="prepare_venv")
 
         # Generate and write execution script (always with markers, since we rely on stdout)
         code = await self.generate_execution_script(agent_state=agent_state, wrap_print_with_markers=True)

letta/services/tool_sandbox/modal_version_manager.py

@@ -16,6 +16,7 @@ from letta.log import get_logger
 from letta.schemas.tool import ToolUpdate
 from letta.services.tool_manager import ToolManager
 from letta.services.tool_sandbox.modal_constants import CACHE_TTL_SECONDS, DEFAULT_CONFIG_KEY, MODAL_DEPLOYMENTS_KEY
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -197,7 +198,7 @@ class ModalVersionManager:
         if deployment_key in self._deployments_in_progress:
             self._deployments_in_progress[deployment_key].set()
             # Clean up after a short delay to allow waiters to wake up
-            asyncio.create_task(self._cleanup_deployment_marker(deployment_key))
+            safe_create_task(self._cleanup_deployment_marker(deployment_key), label=f"cleanup_deployment_{deployment_key}")
 
     async def _cleanup_deployment_marker(self, deployment_key: str):
         """Clean up deployment marker after a delay."""

letta/streaming_utils.py

@@ -99,6 +99,15 @@ class JSONInnerThoughtsExtractor:
                         else:
                             updates_main_json += c
                             self.main_buffer += c
+            # NOTE (fix): Streaming JSON can arrive token-by-token from the LLM.
+            # In the old implementation we pre-inserted an opening quote after every
+            # key's colon (i.e. we emitted '"key":"' immediately). That implicitly
+            # assumed all values are strings. When a non-string value (e.g. true/false,
+            # numbers, null, or a nested object/array) streamed in next, the stream
+            # ended up with an unmatched '"' and appeared as a "missing end-quote" to
+            # clients. We now only emit an opening quote when we actually enter a
+            # string value (see below). This keeps values like booleans unquoted and
+            # avoids generating dangling quotes mid-stream.
             elif c == '"':
                 if not self.escaped:
                     self.in_string = not self.in_string
@@ -112,6 +121,14 @@ class JSONInnerThoughtsExtractor:
                                 self.main_buffer += self.main_json_held_buffer
                                 self.main_json_held_buffer = ""
                                 self.hold_main_json = False
+                        elif self.state == "value":
+                            # Opening quote for a string value (non-inner-thoughts only)
+                            if not self.is_inner_thoughts_value:
+                                if self.hold_main_json:
+                                    self.main_json_held_buffer += '"'
+                                else:
+                                    updates_main_json += '"'
+                                    self.main_buffer += '"'
                     else:
                         if self.state == "key":
                             self.state = "colon"
@@ -156,18 +173,26 @@ class JSONInnerThoughtsExtractor:
                             updates_main_json += c
                             self.main_buffer += c
             else:
+                # NOTE (fix): Do NOT pre-insert an opening quote after ':' any more.
+                # The value may not be a string; we only emit quotes when we actually
+                # see a string begin (handled in the '"' branch above). This prevents
+                # forced-quoting of non-string values and eliminates the common
+                # streaming artifact of "... 'request_heartbeat':'true}" missing the
+                # final quote.
                 if c == ":" and self.state == "colon":
+                    # Transition to reading a value; don't pre-insert quotes
                     self.state = "value"
                     self.is_inner_thoughts_value = self.current_key == self.inner_thoughts_key
                     if self.is_inner_thoughts_value:
-                        pass  # Do not include 'inner_thoughts' key in main_json
+                        # Do not include 'inner_thoughts' key in main_json
+                        pass
                     else:
                         key_colon = f'"{self.current_key}":'
                         if self.hold_main_json:
-                            self.main_json_held_buffer += key_colon + '"'
+                            self.main_json_held_buffer += key_colon
                         else:
-                            updates_main_json += key_colon + '"'
-                            self.main_buffer += key_colon + '"'
+                            updates_main_json += key_colon
+                            self.main_buffer += key_colon
                 elif c == "," and self.state == "comma_or_end":
                     if self.is_inner_thoughts_value:
                         # Inner thoughts value ended