autobyteus 1.1.1__tar.gz → 1.1.2__tar.gz

{autobyteus-1.1.1 → autobyteus-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.1
+Version: 1.1.2
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -26,7 +26,8 @@ Requires-Dist: botocore
 Requires-Dist: anthropic==0.37.1
 Requires-Dist: Jinja2
 Requires-Dist: ollama
-Requires-Dist: mistral_common
+Requires-Dist: mistral_common==1.6.3
+Requires-Dist: mistralai==1.5.2
 Requires-Dist: certifi==2025.4.26
 Requires-Dist: numpy==2.2.5
 Requires-Dist: aiohttp

{autobyteus-1.1.1 → autobyteus-1.1.2}/autobyteus/agent/runtime/agent_runtime.py

@@ -120,10 +120,7 @@ class AgentRuntime:
         await self.phase_manager.notify_shutdown_initiated() 
         await self._worker.stop(timeout=timeout) 
         
-        if self.context.llm_instance and hasattr(self.context.llm_instance, 'cleanup'):
-            cleanup_func = self.context.llm_instance.cleanup
-            if asyncio.iscoroutinefunction(cleanup_func): await cleanup_func()
-            else: cleanup_func()
+        # LLM instance cleanup is now handled by the AgentWorker before its loop closes.
         
         await self.phase_manager.notify_final_shutdown_complete() 
         logger.info(f"AgentRuntime for '{agent_id}' stop() method completed.")

{autobyteus-1.1.1 → autobyteus-1.1.2}/autobyteus/agent/runtime/agent_worker.py

@@ -140,19 +140,19 @@ class AgentWorker:
 
     async def async_run(self) -> None:
         agent_id = self.context.agent_id
-        logger.info(f"AgentWorker '{agent_id}' async_run(): Starting.")
-        
-        # --- Direct Initialization ---
-        initialization_successful = await self._initialize()
-        if not initialization_successful:
-            logger.critical(f"AgentWorker '{agent_id}' failed to initialize. Worker is shutting down.")
-            if self._async_stop_event and not self._async_stop_event.is_set():
-                self._async_stop_event.set()
-            return
-        
-        # --- Main Event Loop ---
-        logger.info(f"AgentWorker '{agent_id}' initialized successfully. Entering main event loop.")
         try:
+            logger.info(f"AgentWorker '{agent_id}' async_run(): Starting.")
+            
+            # --- Direct Initialization ---
+            initialization_successful = await self._initialize()
+            if not initialization_successful:
+                logger.critical(f"AgentWorker '{agent_id}' failed to initialize. Worker is shutting down.")
+                if self._async_stop_event and not self._async_stop_event.is_set():
+                    self._async_stop_event.set()
+                return
+
+            # --- Main Event Loop ---
+            logger.info(f"AgentWorker '{agent_id}' initialized successfully. Entering main event loop.")
             while not self._async_stop_event.is_set(): 
                 try:
                     queue_event_tuple = await asyncio.wait_for(
@@ -183,18 +183,61 @@ class AgentWorker:
             if self.context.state.input_event_queues:
                 await self.context.state.input_event_queues.enqueue_internal_system_event(AgentStoppedEvent())
 
+    async def _shutdown_sequence(self):
+        """
+        The explicit, ordered shutdown sequence for the worker, executed on its own event loop.
+        """
+        agent_id = self.context.agent_id
+        logger.info(f"AgentWorker '{agent_id}': Running shutdown sequence on worker loop.")
+
+        # 1. Clean up resources like the LLM instance.
+        if self.context.llm_instance and hasattr(self.context.llm_instance, 'cleanup'):
+            logger.info(f"AgentWorker '{agent_id}': Running LLM instance cleanup.")
+            try:
+                cleanup_func = self.context.llm_instance.cleanup
+                if asyncio.iscoroutinefunction(cleanup_func):
+                    await cleanup_func()
+                else:
+                    cleanup_func()
+                logger.info(f"AgentWorker '{agent_id}': LLM instance cleanup completed.")
+            except Exception as e:
+                logger.error(f"AgentWorker '{agent_id}': Error during LLM instance cleanup: {e}", exc_info=True)
+
+        # 2. Signal the main event loop to stop.
+        await self._signal_internal_stop()
+        logger.info(f"AgentWorker '{agent_id}': Shutdown sequence completed.")
+
     async def stop(self, timeout: float = 10.0) -> None:
+        """
+        Gracefully stops the worker by scheduling a final shutdown sequence on its
+        event loop, then waiting for the thread to terminate.
+        """
         if not self._is_active or self._stop_initiated:
             return
+        
+        agent_id = self.context.agent_id
+        logger.info(f"AgentWorker '{agent_id}': Stop requested.")
         self._stop_initiated = True
-        if self.get_worker_loop() and self._async_stop_event:
-            future = asyncio.run_coroutine_threadsafe(self._signal_internal_stop(), self.get_worker_loop())
-            try: future.result(timeout=1.0)
-            except Exception: pass
+
+        # Schedule the explicit shutdown sequence on the worker's loop.
+        if self.get_worker_loop():
+            future = self.schedule_coroutine_on_worker_loop(self._shutdown_sequence)
+            try:
+                # Wait for the cleanup and stop signal to be processed.
+                future.result(timeout=max(1.0, timeout-1))
+            except Exception as e:
+                logger.error(f"AgentWorker '{agent_id}': Error during scheduled shutdown sequence: {e}", exc_info=True)
+
+        # Wait for the main thread future to complete.
         if self._thread_future:
-            try: await asyncio.wait_for(asyncio.wrap_future(self._thread_future), timeout=timeout)
-            except asyncio.TimeoutError: logger.warning(f"Timeout waiting for worker thread of '{self.context.agent_id}'.")
+            try:
+                await asyncio.wait_for(asyncio.wrap_future(self._thread_future), timeout=timeout)
+                logger.info(f"AgentWorker '{agent_id}': Worker thread has terminated.")
+            except asyncio.TimeoutError:
+                logger.warning(f"AgentWorker '{agent_id}': Timeout waiting for worker thread to terminate.")
+        
         self._is_active = False
 
+
     def is_alive(self) -> bool:
         return self._thread_future is not None and not self._thread_future.done()

autobyteus-1.1.2/autobyteus/llm/api/deepseek_llm.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class DeepSeekLLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        # Provide defaults if not specified
+        if model is None:
+            model = LLMModel['deepseek-chat']
+        if llm_config is None:
+            llm_config = LLMConfig()
+            
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="DEEPSEEK_API_KEY",
+            base_url="https://api.deepseek.com"
+        )
+        logger.info(f"DeepSeekLLM initialized with model: {self.model}")
+
+    async def cleanup(self):
+        await super().cleanup()

autobyteus-1.1.2/autobyteus/llm/api/grok_llm.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class GrokLLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        # Provide defaults if not specified
+        if model is None:
+            model = LLMModel['grok-2-1212']
+        if llm_config is None:
+            llm_config = LLMConfig()
+            
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="GROK_API_KEY",
+            base_url="https://api.x.ai/v1"
+        )
+        logger.info(f"GrokLLM initialized with model: {self.model}")
+
+    async def cleanup(self):
+        await super().cleanup()

autobyteus-1.1.2/autobyteus/llm/api/kimi_llm.py

@@ -0,0 +1,24 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class KimiLLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        # Provide defaults if not specified
+        if model is None:
+            # Setting a default Kimi model from the factory ones
+            model = LLMModel['kimi-latest']
+        if llm_config is None:
+            llm_config = LLMConfig()
+
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="KIMI_API_KEY",
+            base_url="https://api.moonshot.cn/v1"
+        )
+        logger.info(f"KimiLLM initialized with model: {self.model}")

autobyteus-1.1.1/autobyteus/llm/api/deepseek_llm.py → autobyteus-1.1.2/autobyteus/llm/api/openai_compatible_llm.py

@@ -1,37 +1,38 @@
 import logging
 import os
+from abc import ABC
 from typing import Optional, List, AsyncGenerator
 from openai import OpenAI
 from openai.types.completion_usage import CompletionUsage
 from openai.types.chat import ChatCompletionChunk
+
 from autobyteus.llm.base_llm import BaseLLM
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.utils.llm_config import LLMConfig
-from autobyteus.llm.utils.messages import MessageRole
 from autobyteus.llm.utils.image_payload_formatter import process_image
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
 
 logger = logging.getLogger(__name__)
 
-class DeepSeekLLM(BaseLLM):
-    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
-        deepseek_api_key = os.getenv("DEEPSEEK_API_KEY")
-        if not deepseek_api_key:
-            logger.error("DEEPSEEK_API_KEY environment variable is not set.")
-            raise ValueError("DEEPSEEK_API_KEY environment variable is not set.")
-
-        self.client = OpenAI(api_key=deepseek_api_key, base_url="https://api.deepseek.com")
-        logger.info("DeepSeek API key and base URL set successfully")
-
-        # Provide defaults if not specified
-        if model is None:
-            model = LLMModel.deepseek_chat
-        if llm_config is None:
-            llm_config = LLMConfig()
-            
+class OpenAICompatibleLLM(BaseLLM, ABC):
+    def __init__(
+        self,
+        model: LLMModel,
+        llm_config: LLMConfig,
+        api_key_env_var: str,
+        base_url: str
+    ):
+        api_key = os.getenv(api_key_env_var)
+        if not api_key:
+            logger.error(f"{api_key_env_var} environment variable is not set.")
+            raise ValueError(f"{api_key_env_var} environment variable is not set.")
+
+        self.client = OpenAI(api_key=api_key, base_url=base_url)
+        logger.info(f"Initialized OpenAI compatible client with base_url: {base_url}")
+        
         super().__init__(model=model, llm_config=llm_config)
-        self.max_tokens = 8000
+        self.max_tokens = 8000 # A default, can be overridden by subclass or config
 
     def _create_token_usage(self, usage_data: Optional[CompletionUsage]) -> Optional[TokenUsage]:
         """Convert usage data to TokenUsage format."""
@@ -48,7 +49,7 @@ class DeepSeekLLM(BaseLLM):
         self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
     ) -> CompleteResponse:
         """
-        Sends a non-streaming request to the DeepSeek API.
+        Sends a non-streaming request to an OpenAI-compatible API.
         Supports optional reasoning content if provided in the response.
         """
         content = []
@@ -70,13 +71,13 @@ class DeepSeekLLM(BaseLLM):
         logger.debug(f"Prepared message content: {content}")
 
         try:
-            logger.info("Sending request to DeepSeek API")
+            logger.info(f"Sending request to {self.model.provider.value} API")
             response = self.client.chat.completions.create(
                 model=self.model.value,
                 messages=[msg.to_dict() for msg in self.messages],
                 max_tokens=self.max_tokens,
             )
-            full_message = response.choices.message
+            full_message = response.choices[0].message
 
             # Extract reasoning_content if present
             reasoning = None
@@ -95,7 +96,7 @@ class DeepSeekLLM(BaseLLM):
             self.add_assistant_message(main_content, reasoning_content=reasoning)
 
             token_usage = self._create_token_usage(response.usage)
-            logger.info("Received response from DeepSeek API with usage data")
+            logger.info(f"Received response from {self.model.provider.value} API with usage data")
             
             return CompleteResponse(
                 content=main_content,
@@ -103,14 +104,14 @@ class DeepSeekLLM(BaseLLM):
                 usage=token_usage
             )
         except Exception as e:
-            logger.error(f"Error in DeepSeek API request: {str(e)}")
-            raise ValueError(f"Error in DeepSeek API request: {str(e)}")
-    
+            logger.error(f"Error in {self.model.provider.value} API request: {str(e)}")
+            raise ValueError(f"Error in {self.model.provider.value} API request: {str(e)}")
+
     async def _stream_user_message_to_llm(
         self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
         """
-        Streams the response from the DeepSeek API.
+        Streams the response from an OpenAI-compatible API.
         Yields reasoning and content in separate chunks.
         """
         content = []
@@ -136,7 +137,7 @@ class DeepSeekLLM(BaseLLM):
         accumulated_content = ""
 
         try:
-            logger.info("Starting streaming request to DeepSeek API")
+            logger.info(f"Starting streaming request to {self.model.provider.value} API")
             stream = self.client.chat.completions.create(
                 model=self.model.value,
                 messages=[msg.to_dict() for msg in self.messages],
@@ -147,9 +148,13 @@ class DeepSeekLLM(BaseLLM):
 
             for chunk in stream:
                 chunk: ChatCompletionChunk
+                if not chunk.choices:
+                    continue
+                
+                delta = chunk.choices[0].delta
 
-                # Process reasoning tokens
-                reasoning_chunk = getattr(chunk.choices.delta, "reasoning_content", None)
+                # Process reasoning tokens (if supported by model)
+                reasoning_chunk = getattr(delta, "reasoning_content", None)
                 if reasoning_chunk:
                     accumulated_reasoning += reasoning_chunk
                     yield ChunkResponse(
@@ -158,7 +163,7 @@ class DeepSeekLLM(BaseLLM):
                     )
 
                 # Process main content tokens
-                main_token = chunk.choices.delta.content
+                main_token = delta.content
                 if main_token:
                     accumulated_content += main_token
                     yield ChunkResponse(
@@ -178,11 +183,11 @@ class DeepSeekLLM(BaseLLM):
             
             # After streaming, add the fully accumulated assistant message to history
             self.add_assistant_message(accumulated_content, reasoning_content=accumulated_reasoning)
-            logger.info("Completed streaming response from DeepSeek API")
+            logger.info(f"Completed streaming response from {self.model.provider.value} API")
 
         except Exception as e:
-            logger.error(f"Error in DeepSeek API streaming: {str(e)}")
-            raise ValueError(f"Error in DeepSeek API streaming: {str(e)}")
-    
+            logger.error(f"Error in {self.model.provider.value} API streaming: {str(e)}")
+            raise ValueError(f"Error in {self.model.provider.value} API streaming: {str(e)}")
+
     async def cleanup(self):
         await super().cleanup()

autobyteus-1.1.2/autobyteus/llm/api/openai_llm.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class OpenAILLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        # Provide defaults if not specified
+        if model is None:
+            model = LLMModel['gpt-4o']  # Use factory access
+        if llm_config is None:
+            llm_config = LLMConfig()
+            
+        super().__init__(
+            model=model, 
+            llm_config=llm_config,
+            api_key_env_var="OPENAI_API_KEY",
+            base_url="https://api.openai.com/v1"
+        )
+        logger.info(f"OpenAILLM initialized with model: {self.model}")
+
+    async def cleanup(self):
+        await super().cleanup()

{autobyteus-1.1.1 → autobyteus-1.1.2}/autobyteus/llm/llm_factory.py

@@ -14,6 +14,7 @@ from autobyteus.llm.api.openai_llm import OpenAILLM
 from autobyteus.llm.api.ollama_llm import OllamaLLM
 from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
+from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
 from autobyteus.utils.singleton import SingletonMeta
 
@@ -239,6 +240,67 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(2.0, 6.0)
                 )
             ),
+            # KIMI Provider Models
+            LLMModel(
+                name="kimi-latest",
+                value="kimi-latest",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="kimi-latest",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(1.38, 4.14)
+                )
+            ),
+            LLMModel(
+                name="moonshot-v1-8k",
+                value="moonshot-v1-8k",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="moonshot-v1-8k",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(0.28, 1.38)
+                )
+            ),
+            LLMModel(
+                name="moonshot-v1-32k",
+                value="moonshot-v1-32k",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="moonshot-v1-32k",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(0.69, 2.76)
+                )
+            ),
+            LLMModel(
+                name="moonshot-v1-128k",
+                value="moonshot-v1-128k",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="moonshot-v1-128k",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(1.38, 4.14)
+                )
+            ),
+            LLMModel(
+                name="kimi-k2-0711-preview",
+                value="kimi-k2-0711-preview",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="kimi-k2-0711-preview",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(0.55, 2.21)
+                )
+            ),
+            LLMModel(
+                name="kimi-thinking-preview",
+                value="kimi-thinking-preview",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="kimi-thinking-preview",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(27.59, 27.59)
+                )
+            ),
         ]
         for model in supported_models:
             LLMFactory.register_model(model)

{autobyteus-1.1.1 → autobyteus-1.1.2}/autobyteus/llm/providers.py

@@ -12,3 +12,4 @@ class LLMProvider(Enum):
     DEEPSEEK = "deepseek"
     GROK = "grok"
     AUTOBYTEUS = "autobyteus"
+    KIMI = "kimi"

autobyteus-1.1.2/autobyteus/llm/token_counter/kimi_token_counter.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+from autobyteus.llm.token_counter.openai_token_counter import OpenAITokenCounter
+from autobyteus.llm.models import LLMModel
+
+if TYPE_CHECKING:
+    from autobyteus.llm.base_llm import BaseLLM
+
+class KimiTokenCounter(OpenAITokenCounter):
+    """
+    Token counter for Kimi (Moonshot AI) models. Uses the same token counting implementation as OpenAI.
+    
+    This implementation inherits from OpenAITokenCounter as Kimi uses the same tokenization
+    approach as OpenAI's models.
+    """
+    
+    def __init__(self, model: LLMModel, llm: 'BaseLLM' = None):
+        """
+        Initialize the Kimi token counter.
+        
+        Args:
+            model (LLMModel): The Kimi model to count tokens for.
+            llm (BaseLLM, optional): The LLM instance. Defaults to None.
+        """
+        super().__init__(model, llm)

{autobyteus-1.1.1 → autobyteus-1.1.2}/autobyteus/llm/token_counter/token_counter_factory.py

@@ -3,6 +3,7 @@ from autobyteus.llm.token_counter.openai_token_counter import OpenAITokenCounter
 from autobyteus.llm.token_counter.claude_token_counter import ClaudeTokenCounter
 from autobyteus.llm.token_counter.mistral_token_counter import MistralTokenCounter
 from autobyteus.llm.token_counter.deepseek_token_counter import DeepSeekTokenCounter
+from autobyteus.llm.token_counter.kimi_token_counter import KimiTokenCounter
 from autobyteus.llm.token_counter.base_token_counter import BaseTokenCounter
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.providers import LLMProvider
@@ -31,6 +32,8 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
         return DeepSeekTokenCounter(model, llm)
     elif model.provider == LLMProvider.GROK:
         return DeepSeekTokenCounter(model, llm)
+    elif model.provider == LLMProvider.KIMI:
+        return KimiTokenCounter(model, llm)
     elif model.provider == LLMProvider.OLLAMA:
         return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.GEMINI:

{autobyteus-1.1.1 → autobyteus-1.1.2}/autobyteus/llm/utils/messages.py

@@ -20,9 +20,9 @@ class Message:
         self.content = content
         self.reasoning_content = reasoning_content  # Optional field for reasoning content
 
-    def to_dict(self) -> Dict[str, Union[str, None]]:
-        result = {"role": self.role.value, "content": self.content}
-        if self.reasoning_content is not None:
+    def to_dict(self) -> Dict[str, Union[str, List[Dict]]]:
+        result: Dict[str, Union[str, List[Dict]]] = {"role": self.role.value, "content": self.content}
+        if self.reasoning_content:
             result["reasoning_content"] = self.reasoning_content
         return result
 

autobyteus-1.1.2/autobyteus/tools/usage/parsers/_json_extractor.py

@@ -0,0 +1,99 @@
+import re
+import logging
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+def _find_json_blobs(text: str) -> List[str]:
+    """
+    Robustly finds and extracts all top-level JSON objects or arrays from a string,
+    maintaining their original order of appearance. It handles JSON within
+    markdown-style code blocks (```json ... ```) and inline JSON.
+    
+    Args:
+        text: The string to search for JSON in.
+        
+    Returns:
+        A list of strings, where each string is a valid-looking JSON blob,
+        ordered as they appeared in the input text.
+    """
+    found_blobs = []
+
+    # 1. Find all markdown blobs first and store them with their start positions.
+    markdown_matches = list(re.finditer(r"```(?:json)?\s*([\s\S]+?)\s*```", text))
+    for match in markdown_matches:
+        content = match.group(1).strip()
+        found_blobs.append((match.start(), content))
+    
+    # 2. Create a "masked" version of the text by replacing markdown blocks with spaces.
+    #    This prevents the inline scanner from finding JSON inside them, while preserving indices.
+    masked_text_list = list(text)
+    for match in markdown_matches:
+        for i in range(match.start(), match.end()):
+            masked_text_list[i] = ' '
+    masked_text = "".join(masked_text_list)
+
+    # 3. Scan the masked text for any other JSON using a single pass brace-counter.
+    idx = 0
+    while idx < len(masked_text):
+        start_idx = -1
+        
+        # Find the next opening brace or bracket
+        next_brace = masked_text.find('{', idx)
+        next_bracket = masked_text.find('[', idx)
+
+        if next_brace == -1 and next_bracket == -1:
+            break # No more JSON starts
+        
+        if next_brace != -1 and (next_bracket == -1 or next_brace < next_bracket):
+            start_idx = next_brace
+            start_char, end_char = '{', '}'
+        else:
+            start_idx = next_bracket
+            start_char, end_char = '[', ']'
+
+        brace_count = 1
+        in_string = False
+        is_escaped = False
+        end_idx = -1
+
+        for i in range(start_idx + 1, len(masked_text)):
+            char = masked_text[i]
+            
+            if in_string:
+                if is_escaped:
+                    is_escaped = False
+                elif char == '\\':
+                    is_escaped = True
+                elif char == '"':
+                    in_string = False
+            else:
+                if char == '"':
+                    in_string = True
+                    is_escaped = False
+                elif char == '{' or char == '[':
+                    brace_count += 1
+                elif char == '}' or char == ']':
+                    brace_count -= 1
+            
+            if brace_count == 0:
+                if (start_char == '{' and char == '}') or \
+                   (start_char == '[' and char == ']'):
+                    end_idx = i
+                    break
+        
+        if end_idx != -1:
+            # We found a blob in the masked text, so its indices are correct
+            # for the original text. Extract the blob from the original text.
+            blob = text[start_idx : end_idx + 1]
+            found_blobs.append((start_idx, blob))
+            idx = end_idx + 1
+        else:
+            # No matching end brace found, move on from the start character.
+            idx = start_idx + 1
+
+    # 4. Sort all found blobs by their start position to ensure correct order
+    found_blobs.sort(key=lambda item: item[0])
+    
+    # 5. Return only the content of the blobs
+    return [content for _, content in found_blobs]