SearchGPT: Speed up process.

requirements.txt

@@ -1,2 +1,3 @@
 gradio[oauth,mcp]
-openai
+openai
+aiohttp[speedups]

src/engine/browser_engine.py

@@ -3,14 +3,17 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+import asyncio
+import aiohttp
 import requests
+from urllib.parse import quote
 from config import CONTENT_EXTRACTION, SEARCH_SELECTION
 from src.core.web_loader import web_loader
 
 class BrowserEngine:
     def __init__(self, configuration):
         self.config = configuration
-    
+
     def generate_headers(self):
         ipv4 = web_loader.get_ipv4()
         ipv6 = web_loader.get_ipv6()
@@ -45,44 +48,92 @@ class BrowserEngine:
             "X-Timezone": location['timezone']
         }
 
+    def _build_search_url_and_selector(self, search_query: str, search_provider: str = "google"):
+        if search_provider == "baidu":
+            return (
+                f"{self.config.content_reader_api}{self.config.baidu_endpoint}?wd={quote(search_query)}",
+                "#content_left"
+            )
+        provider_prefix = "!go" if search_provider == "google" else "!bi"
+        return (
+            f"{self.config.content_reader_api}{self.config.searxng_endpoint}?q={quote(f'{provider_prefix} {search_query}')}",
+            "#urls"
+        )
+
+    async def _async_post(self, url: str, data: dict, headers: dict):
+        timeout = aiohttp.ClientTimeout(total=self.config.request_timeout)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.post(url, data=data, headers=headers) as response:
+                text = await response.text()
+                if response.status >= 400:
+                    raise aiohttp.ClientResponseError(
+                        request_info=response.request_info,
+                        history=response.history,
+                        status=response.status,
+                        message=text,
+                        headers=response.headers
+                    )
+                return text
+
+    async def _async_get(self, url: str, headers: dict):
+        timeout = aiohttp.ClientTimeout(total=self.config.request_timeout)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url, headers=headers) as response:
+                text = await response.text()
+                if response.status >= 400:
+                    raise aiohttp.ClientResponseError(
+                        request_info=response.request_info,
+                        history=response.history,
+                        status=response.status,
+                        message=text,
+                        headers=response.headers
+                    )
+                return text
+
+    def _sync_post(self, url: str, data: dict, headers: dict):
+        response = requests.post(url, data=data, headers=headers, timeout=self.config.request_timeout)
+        response.raise_for_status()
+        return response.text
+
+    def _sync_get(self, url: str, headers: dict):
+        response = requests.get(url, headers=headers, timeout=self.config.request_timeout)
+        response.raise_for_status()
+        return response.text
+
+    async def async_extract_page_content(self, target_url: str) -> str:
+        headers = self.generate_headers()
+        payload = {"url": target_url}
+        extracted_content = await self._async_post(self.config.content_reader_api, payload, headers)
+        return f"{extracted_content}\n\n\n{CONTENT_EXTRACTION}\n\n\n"
+
     def extract_page_content(self, target_url: str) -> str:
         try:
-            headers = self.generate_headers()
-            payload = {
-                "url": target_url
-            }
-            request_response = requests.post(
-                self.config.content_reader_api,
-                data=payload,
-                headers=headers,
-                timeout=self.config.request_timeout,
-            )
-            request_response.raise_for_status()
-            extracted_content = request_response.text
-            return f"{extracted_content}\n\n\n{CONTENT_EXTRACTION}\n\n\n"
-        except Exception as error:
-            return f"Error reading URL: {str(error)}"
+            return asyncio.run(self.async_extract_page_content(target_url))
+        except Exception:
+            try:
+                headers = self.generate_headers()
+                payload = {"url": target_url}
+                extracted_content = self._sync_post(self.config.content_reader_api, payload, headers)
+                return f"{extracted_content}\n\n\n{CONTENT_EXTRACTION}\n\n\n"
+            except Exception as error:
+                return f"Error reading URL: {str(error)}"
+
+    async def async_perform_search(self, search_query: str, search_provider: str = "google") -> str:
+        headers = self.generate_headers()
+        full_url, selector = self._build_search_url_and_selector(search_query, search_provider)
+        headers["X-Target-Selector"] = selector
+        search_results = await self._async_get(full_url, headers)
+        return f"{search_results}\n\n\n{SEARCH_SELECTION}\n\n\n"
 
     def perform_search(self, search_query: str, search_provider: str = "google") -> str:
         try:
-            headers = self.generate_headers()
-            
-            if search_provider == "baidu":
-                full_url = f"{self.config.content_reader_api}{self.config.baidu_endpoint}?wd={requests.utils.quote(search_query)}"
-                headers["X-Target-Selector"] = "#content_left"
-            else:
-                provider_prefix = "!go" if search_provider == "google" else "!bi"
-                encoded_query = requests.utils.quote(f"{provider_prefix} {search_query}")
-                full_url = f"{self.config.content_reader_api}{self.config.searxng_endpoint}?q={encoded_query}"
-                headers["X-Target-Selector"] = "#urls"
-            
-            search_response = requests.get(
-                full_url, 
-                headers=headers, 
-                timeout=self.config.request_timeout
-            )
-            search_response.raise_for_status()
-            search_results = search_response.text
-            return f"{search_results}\n\n\n{SEARCH_SELECTION}\n\n\n"
-        except Exception as error:
-            return f"Error during search: {str(error)}"
+            return asyncio.run(self.async_perform_search(search_query, search_provider))
+        except Exception:
+            try:
+                headers = self.generate_headers()
+                full_url, selector = self._build_search_url_and_selector(search_query, search_provider)
+                headers["X-Target-Selector"] = selector
+                search_results = self._sync_get(full_url, headers)
+                return f"{search_results}\n\n\n{SEARCH_SELECTION}\n\n\n"
+            except Exception as error:
+                return f"Error during search: {str(error)}"

src/processor/tools/interaction.py

@@ -14,109 +14,212 @@ from config import MAX_TOKENS, REASONING_DELAY
 
 def process_tool_interactions(server, model_name, conversation_messages, tool_definitions, search_engine):
     maximum_iterations = 1
+    max_retry_limit = 10
+    retry_count = 0
     logs_generator = ""
     tool_results = []
+    execution_success = False
+    last_error = None
+    error_history = []
+    iteration_metrics = {
+        "attempts": 0,
+        "failures": 0,
+        "success_rate": 0,
+        "error_patterns": {},
+        "retry_delays": [
+            0.5,
+            1.0,
+            1.5,
+            2.0,
+            2.5,
+            3.0
+        ],
+        "backoff_multiplier": 1.5
+    }
     
-    for iteration_index in range(maximum_iterations):
-        try:
-            model_response = server.chat.completions.create(
-                model=model_name,
-                messages=conversation_messages,
-                tools=tool_definitions,
-                tool_choice="auto",
-                max_tokens=MAX_TOKENS,
-                temperature=0.6
-            )
-        except Exception:
-            return conversation_messages, logs_generator, False
-
-        response_choice = model_response.choices[0]
-        assistant_message = response_choice.message
-        formatted_assistant_message = assistant_response(assistant_message)
+    while maximum_iterations <= max_retry_limit and not execution_success:
+        iteration_metrics["attempts"] += 1
+        current_iteration_successful = False
+        iteration_errors = []
         
-        conversation_messages.append(
-            {
-                "role": formatted_assistant_message["role"],
-                "content": formatted_assistant_message["content"],
-                "tool_calls": formatted_assistant_message["tool_calls"]
-            }
-        )
+        for iteration_index in range(maximum_iterations):
+            try:
+                retry_delay = iteration_metrics["retry_delays"][min(retry_count, len(iteration_metrics["retry_delays"]) - 1)]
+                if retry_count > 0:
+                    time.sleep(retry_delay * iteration_metrics["backoff_multiplier"])
+                
+                model_response = server.chat.completions.create(
+                    model=model_name,
+                    messages=conversation_messages,
+                    tools=tool_definitions,
+                    tool_choice="auto",
+                    max_tokens=MAX_TOKENS,
+                    temperature=0.6
+                )
+                
+                response_choice = model_response.choices[0]
+                assistant_message = response_choice.message
+                formatted_assistant_message = assistant_response(assistant_message)
+                
+                conversation_messages.append(
+                    {
+                        "role": formatted_assistant_message["role"],
+                        "content": formatted_assistant_message["content"],
+                        "tool_calls": formatted_assistant_message["tool_calls"]
+                    }
+                )
 
-        pending_tool_calls = assistant_message.tool_calls or []
-        if not pending_tool_calls:
-            if logs_generator:
-                logs_generator = styles(logs_generator.replace('<br>', '\n').strip(), expanded=False)
-            return conversation_messages, logs_generator, False
+                pending_tool_calls = assistant_message.tool_calls or []
+                if not pending_tool_calls:
+                    if logs_generator:
+                        logs_generator = styles(logs_generator.replace('<br>', '\n').strip(), expanded=False)
+                    execution_success = True
+                    current_iteration_successful = True
+                    break
+
+                tool_execution_errors = []
+                for tool_invocation in pending_tool_calls:
+                    tool_name = tool_invocation.function.name
+                    tool_arguments_raw = tool_invocation.function.arguments
+                    
+                    extracted_arguments, extraction_error = extract_tool_parameters(tool_arguments_raw)
+                    
+                    if extraction_error:
+                        error_key = f"{tool_name}_extraction"
+                        iteration_metrics["error_patterns"][error_key] = iteration_metrics["error_patterns"].get(error_key, 0) + 1
+                        tool_execution_errors.append({
+                            "tool": tool_name,
+                            "error": extraction_error,
+                            "type": "extraction"
+                        })
+                        
+                        reasoning_error = tool_reasoning(tool_name, None, "error", error=extraction_error)
+                        for i in range(0, len(reasoning_error), 20):
+                            logs_generator = styles(reasoning_interfaces(reasoning_error, i), expanded=True)
+                            yield logs_generator
+                            time.sleep(REASONING_DELAY)
+                        logs_generator = styles(reasoning_error, expanded=True)
+                        yield logs_generator
+                        tool_execution_result = extraction_error
+                    else:
+                        reasoning_status = tool_reasoning(tool_name, extracted_arguments, "parsing")
+                        for i in range(0, len(reasoning_status), 20):
+                            logs_generator = styles(reasoning_interfaces(reasoning_status, i), expanded=True)
+                            yield logs_generator
+                            time.sleep(REASONING_DELAY)
+                        
+                        reasoning_start = tool_reasoning(tool_name, extracted_arguments, "executing")
+                        for i in range(0, len(reasoning_start), 20):
+                            logs_generator = styles(reasoning_interfaces(reasoning_start, i), expanded=True)
+                            yield logs_generator
+                            time.sleep(REASONING_DELAY)
+                        
+                        try:
+                            tool_execution_result = invoke_tool_function(
+                                search_engine, 
+                                tool_name, 
+                                extracted_arguments
+                            )
+                            tool_results.append({
+                                "tool": tool_name,
+                                "arguments": extracted_arguments,
+                                "result": tool_execution_result,
+                                "iteration": maximum_iterations,
+                                "retry_count": retry_count
+                            })
+                            
+                            reasoning_done = tool_reasoning(tool_name, extracted_arguments, "completed", result=tool_execution_result)
+                            for i in range(0, len(reasoning_done), 20):
+                                logs_generator = styles(reasoning_interfaces(reasoning_done, i), expanded=True)
+                                yield logs_generator
+                                time.sleep(REASONING_DELAY)
+                            logs_generator = styles(reasoning_done, expanded=False)
+                            yield logs_generator
+                            
+                        except Exception as tool_error:
+                            error_key = f"{tool_name}_execution"
+                            iteration_metrics["error_patterns"][error_key] = iteration_metrics["error_patterns"].get(error_key, 0) + 1
+                            tool_execution_errors.append({
+                                "tool": tool_name,
+                                "error": str(tool_error),
+                                "type": "execution",
+                                "arguments": extracted_arguments
+                            })
+                            
+                            reasoning_error = tool_reasoning(tool_name, extracted_arguments, "error", error=str(tool_error))
+                            for i in range(0, len(reasoning_error), 20):
+                                logs_generator = styles(reasoning_interfaces(reasoning_error, i), expanded=True)
+                                yield logs_generator
+                                time.sleep(REASONING_DELAY)
+                            logs_generator = styles(reasoning_error, expanded=True)
+                            yield logs_generator
+                            tool_execution_result = str(tool_error)
 
-        for tool_invocation in pending_tool_calls:
-            tool_name = tool_invocation.function.name
-            tool_arguments_raw = tool_invocation.function.arguments
+                    conversation_messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_invocation.id,
+                            "name": tool_name,
+                            "content": tool_execution_result
+                        }
+                    )
+                
+                if not tool_execution_errors:
+                    execution_success = True
+                    current_iteration_successful = True
+                    break
+                else:
+                    iteration_errors.extend(tool_execution_errors)
+                    
+            except Exception as model_error:
+                last_error = str(model_error)
+                error_history.append({
+                    "iteration": maximum_iterations,
+                    "error": last_error,
+                    "timestamp": time.time()
+                })
+                iteration_metrics["failures"] += 1
+                iteration_errors.append({
+                    "error": last_error,
+                    "type": "model"
+                })
+        
+        if current_iteration_successful:
+            execution_success = True
+            break
+        else:
+            if iteration_errors:
+                error_history.extend(iteration_errors)
             
-            extracted_arguments, extraction_error = extract_tool_parameters(tool_arguments_raw)
+            retry_count += 1
+            previous_iterations = maximum_iterations
             
-            if extraction_error:
-                error_reasoning = tool_reasoning(tool_name, None, "error", error=extraction_error)
-                for i in range(0, len(error_reasoning), 5):
-                    logs_generator = styles(reasoning_interfaces(error_reasoning, i), expanded=True)
-                    yield logs_generator
-                    time.sleep(REASONING_DELAY)
-                logs_generator = styles(error_reasoning, expanded=True)
-                yield logs_generator
-                tool_execution_result = extraction_error
+            if iteration_metrics["error_patterns"]:
+                frequent_errors = max(iteration_metrics["error_patterns"].values())
+                if frequent_errors > 3:
+                    maximum_iterations = min(maximum_iterations + 2, max_retry_limit)
+                else:
+                    maximum_iterations = min(maximum_iterations + 1, max_retry_limit)
             else:
-                reasoning_status = tool_reasoning(tool_name, extracted_arguments, "parsing")
-                for i in range(0, len(reasoning_status), 5):
-                    logs_generator = styles(reasoning_interfaces(reasoning_status, i), expanded=True)
-                    yield logs_generator
-                    time.sleep(REASONING_DELAY)
-                
-                reasoning_start = tool_reasoning(tool_name, extracted_arguments, "executing")
-                for i in range(0, len(reasoning_start), 5):
-                    logs_generator = styles(reasoning_interfaces(reasoning_start, i), expanded=True)
+                maximum_iterations = min(maximum_iterations + 1, max_retry_limit)
+            
+            if maximum_iterations > previous_iterations:
+                retry_reasoning = f"Retrying with increased iterations: {maximum_iterations} (attempt {retry_count + 1})"
+                for i in range(0, len(retry_reasoning), 20):
+                    logs_generator = styles(reasoning_interfaces(retry_reasoning, i), expanded=True)
                     yield logs_generator
                     time.sleep(REASONING_DELAY)
-                
-                try:
-                    tool_execution_result = invoke_tool_function(
-                        search_engine, 
-                        tool_name, 
-                        extracted_arguments
-                    )
-                    tool_results.append({
-                        "tool": tool_name,
-                        "arguments": extracted_arguments,
-                        "result": tool_execution_result
-                    })
-                    
-                    reasoning_done = tool_reasoning(tool_name, extracted_arguments, "completed", result=tool_execution_result)
-                    for i in range(0, len(reasoning_done), 5):
-                        logs_generator = styles(reasoning_interfaces(reasoning_done, i), expanded=True)
-                        yield logs_generator
-                        time.sleep(REASONING_DELAY)
-                    logs_generator = styles(reasoning_done, expanded=False)
-                    yield logs_generator
-                    
-                except Exception as tool_error:
-                    error_reasoning = tool_reasoning(tool_name, extracted_arguments, "error", error=str(tool_error))
-                    for i in range(0, len(error_reasoning), 5):
-                        logs_generator = styles(reasoning_interfaces(error_reasoning, i), expanded=True)
-                        yield logs_generator
-                        time.sleep(REASONING_DELAY)
-                    logs_generator = styles(error_reasoning, expanded=True)
-                    yield logs_generator
-                    tool_execution_result = str(tool_error)
-
-            conversation_messages.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": tool_invocation.id,
-                    "name": tool_name,
-                    "content": tool_execution_result
-                }
-            )
+            
+            if maximum_iterations >= max_retry_limit:
+                final_error = f"Maximum retry limit reached after {iteration_metrics['attempts']} attempts with {iteration_metrics['failures']} failures"
+                logs_generator = styles(final_error, expanded=True)
+                yield logs_generator
+                break
+    
+    iteration_metrics["success_rate"] = (len(tool_results) / max(iteration_metrics["attempts"], 1)) * 100
     
     if logs_generator:
         logs_generator = styles(logs_generator.replace('<br>', '\n').strip(), expanded=False)
     
-    results_generator = len(tool_results) > 0
-    return conversation_messages, logs_generator, results_generator
+    generator_results = len(tool_results) > 0
+    return conversation_messages, logs_generator, generator_results