SearchGPT: Release pre-stable scripts.

Signed-off-by: Hadad <[email protected]>

config.py

@@ -9,12 +9,43 @@
 MODEL = "gpt-4.1-nano"
 
 MAX_TOKENS = 131072
+TOOLS_TEMPERATURE = 0.6
+CHAT_TEMPERATURE  = 0.75
+STREAM = True
 
 SEARXNG_ENDPOINT = "https://searx.stream/search"  # See the endpoint list at https://searx.space
 BAIDU_ENDPOINT   = "https://www.baidu.com/s"
 READER_ENDPOINT  = "https://r.jina.ai/"
 REQUEST_TIMEOUT  = 300  # 5 minute
 
+MAXIMUM_ITERATIONS = 1  # Max tool execution
+MAX_RETRY_LIMIT = 10  # Max retries if tools fail or server doesn’t respond
+
+ITERATION_METRICS = {
+    "attempts": 0,
+    "failures": 0,
+    "success_rate": 0,
+    "error_patterns": {},
+    "retry_delays": [
+        0.02,
+        0.03,
+        0.04,
+        0.05,
+        0.06,
+        0.07
+    ],
+    "backoff_multiplier": 0.2
+}
+
+TCP_CONNECTOR_ENABLE_DNS_CACHE = True  # aiohttp
+TCP_CONNECTOR_TTL_DNS_CACHE = 300  # aiohttp
+TCP_CONNECTOR_LIMIT = 100  # aiohttp
+TCP_CONNECTOR_LIMIT_PER_HOST = 30  # aiohttp
+TCP_CONNECTOR_FORCE_CLOSE = False  # aiohttp
+TCP_CONNECTOR_ENABLE_CLEANUP = True  # aiohttp
+ENABLE_TRUST_ENV = True  # aiohttp
+ENABLE_CONNECTOR_OWNER = True  # aiohttp
+
 INSTRUCTIONS_START = """
 You are ChatGPT, an AI assistant with mandatory real-time web search, URL content extraction, knowledge validation, and professional summarization capabilities.  
 
@@ -57,7 +88,7 @@ Execution Workflow:
    - Balance depth (for experts) with clarity (for general readers).
 
 6. Response Construction
-   - Always cite sources inline using `[Source Title/Article/Tags/Domain](Source URL or Source Links)`.
+   - Always cite sources inline using `[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`.
    - Maintain a professional, precise, and neutral tone.
    - Use clear formatting: headings, numbered lists, and bullet points.
    - Ensure readability, logical progression, and accessibility.
@@ -76,7 +107,7 @@ Execution Workflow:
 Critical Instruction:
 - Every new query or request must trigger a `web_search` or `read_url`.
 - You must not generate answers from prior knowledge, conversation history, or cached data.
-- Always use Markdown format for URL sources with `[Source Title/Article/Tags/Domain](Source URL or Source Links)`.
+- Always use Markdown format for URL sources with `[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`.
 - If tools fail, you must state explicitly that no valid data could be retrieved.
 \n\n\n
 """
@@ -89,7 +120,7 @@ CONTENT_EXTRACTION = """
 - Evaluate credibility of sources, highlight potential biases or conflicts
 - Produce a structured, professional, and comprehensive summary
 - Emphasize clarity, accuracy, and logical flow
-- Include all discovered URLs in the final summary as [Source Title](URL)
+- Include all discovered URLs in the final summary as `[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`
 - Mark any uncertainties, contradictions, or missing information clearly
 </system>
 \n\n\n
@@ -101,7 +132,7 @@ SEARCH_SELECTION = """
 - Extract key information, main arguments, data points, and statistics
 - Capture every URL present in the content or references
 - Create a professional structured summary.
-- List each source at the end of the summary in the format [Source title](link)
+- List each source at the end of the summary in the format `[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`
 - Identify ambiguities or gaps in information
 - Ensure clarity, completeness, and high information density
 </system>
@@ -127,7 +158,7 @@ REASONING_STEPS = {
             "- Search Query: {query}<br>"
             "- Search Engine: {engine}<br><br>"
             "I'm verifying that the network connection is stable and that the search service is accessible. "
-            "All preliminary checks have been completed successfully."
+            "All preliminary checks have been completed successfully.<br><br>"
         ),
         "executing": (
             "I'm now executing the web search for: {query}<br><br>"
@@ -142,7 +173,7 @@ REASONING_STEPS = {
             "I'm also verifying the credibility of the sources to ensure high-quality information.<br><br>"
             "Current status: Processing search results...<br>"
             "Results found: Multiple relevant sources identified<br>"
-            "Quality assessment: High relevance detected"
+            "Quality assessment: High relevance detected<br><br>"
         ),
         "completed": (
             "I have successfully completed the web search for: {query}<br><br>"
@@ -173,7 +204,7 @@ REASONING_STEPS = {
             "I will try to recover from this error and provide the best possible response.<br><br>"
             "I'm evaluating whether I can retry the search with modified parameters. "
             "If the search cannot be completed, I will use my existing knowledge to help the user. "
-            "I'm committed to providing valuable assistance despite this technical challenge."
+            "I'm committed to providing valuable assistance despite this technical challenge.<br><br>"
         )
     },
     "read_url": {
@@ -191,7 +222,7 @@ REASONING_STEPS = {
             "- Content Type: HTML/Text<br>"
             "- Encoding: Auto-detect<br><br>"
             "I'm checking if the website requires any special handling or authentication. "
-            "All preliminary validation checks have been completed successfully."
+            "All preliminary validation checks have been completed successfully.<br><br>"
         ),
         "executing": (
             "I'm now accessing the URL: {url}<br><br>"
@@ -206,7 +237,7 @@ REASONING_STEPS = {
             "I'm focusing on extracting the primary article or information content.<br><br>"
             "Current status: Extracting content...<br>"
             "Response received: Processing HTML<br>"
-            "Content extraction: In progress"
+            "Content extraction: In progress<br><br>"
         ),
         "completed": (
             "I have successfully extracted content from: {url}<br><br>"
@@ -237,14 +268,14 @@ REASONING_STEPS = {
             "I will try to work around this limitation and provide alternative assistance.<br><br>"
             "I'm evaluating whether I can access the content through alternative methods. "
             "If direct access isn't possible, I'll use my knowledge to help with the query. "
-            "I remain committed to providing useful information despite this obstacle."
+            "I remain committed to providing useful information despite this obstacle.<br><br>"
         )
     }
 }
 
 REASONING_DEFAULT = "I'm processing the tool execution request..."
-
-REASONING_DELAY = 0.01  # 10 ms
+REASONING_DELAY   = 0.01  # 10 ms
+REASONING_INSERT  = 15    # Stream-like word-by-word display
 
 OS = [
     "Windows NT 10.0; Win64; x64",

src/core/web_loader.py

@@ -5,7 +5,6 @@
 
 import random
 import threading
-import time
 from collections import deque
 from config import (
     OS,
@@ -37,96 +36,59 @@ class WebLoader:
         
     def generate_ipv4(self):
         while len(self.ipv4_pool) < 1000 and self.running:
-            octet = random.choice(OCTETS)
-            ip = f"{octet}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(1, 254)}"
+            ip = f"{random.choice(OCTETS)}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(1, 254)}"
             with self.lock:
                 self.ipv4_pool.append(ip)
-            time.sleep(0.001)
             
     def generate_ipv6(self):
         while len(self.ipv6_pool) < 1000 and self.running:
-            segments = []
-            for _ in range(8):
-                segments.append(f"{random.randint(0, 65535):04x}")
+            segments = [f"{random.randint(0, 65535):04x}" for _ in range(8)]
             ip = ":".join(segments)
             with self.lock:
                 self.ipv6_pool.append(ip)
-            time.sleep(0.001)
             
     def generate_user_agents(self):
-        os_list = OS
-        browsers = BROWSERS
-        chrome_versions = CHROME_VERSIONS
-        firefox_versions = FIREFOX_VERSIONS
-        safari_versions = SAFARI_VERSIONS
-        edge_versions = EDGE_VERSIONS
-        
         while len(self.user_agent_pool) < 500 and self.running:
-            browser = random.choice(browsers)
-            os_string = random.choice(os_list)
+            browser = random.choice(BROWSERS)
             
             if browser == "Chrome":
-                version = random.choice(chrome_versions)
-                ua = f"Mozilla/5.0 ({os_string}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version} Safari/537.36"
+                ua = f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{random.choice(CHROME_VERSIONS)} Safari/537.36"
             elif browser == "Firefox":
-                version = random.choice(firefox_versions)
-                ua = f"Mozilla/5.0 ({os_string}) Gecko/20100101 Firefox/{version}"
+                ua = f"Mozilla/5.0 ({random.choice(OS)}) Gecko/20100101 Firefox/{random.choice(FIREFOX_VERSIONS)}"
             elif browser == "Safari":
-                version = random.choice(safari_versions)
                 webkit_version = f"{600 + random.randint(0, 15)}.{random.randint(1, 9)}.{random.randint(1, 20)}"
-                ua = f"Mozilla/5.0 ({os_string}) AppleWebKit/{webkit_version} (KHTML, like Gecko) Version/{version} Safari/{webkit_version}"
+                ua = f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/{webkit_version} (KHTML, like Gecko) Version/{random.choice(SAFARI_VERSIONS)} Safari/{webkit_version}"
             elif browser == "Edge":
-                version = random.choice(edge_versions)
-                ua = f"Mozilla/5.0 ({os_string}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version.split('.')[0]}.0.0.0 Safari/537.36 Edg/{version}"
+                version = random.choice(EDGE_VERSIONS)
+                ua = f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version.split('.')[0]}.0.0.0 Safari/537.36 Edg/{version}"
             else:
                 version = f"{random.randint(70, 100)}.0.{random.randint(3000, 5000)}.{random.randint(50, 150)}"
-                ua = f"Mozilla/5.0 ({os_string}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version} Safari/537.36 OPR/{random.randint(80, 106)}.0.0.0"
+                ua = f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version} Safari/537.36 OPR/{random.randint(80, 106)}.0.0.0"
                 
             with self.lock:
                 self.user_agent_pool.append(ua)
-            time.sleep(0.002)
             
     def generate_origins(self):
-        domains = DOMAINS
-        protocols = PROTOCOLS
-        
         while len(self.origin_pool) < 500 and self.running:
-            protocol = random.choice(protocols)
-            domain = random.choice(domains)
-            origin = f"{protocol}{domain}"
+            origin = f"{random.choice(PROTOCOLS)}{random.choice(DOMAINS)}"
             with self.lock:
                 self.origin_pool.append(origin)
-            time.sleep(0.002)
             
     def generate_referrers(self):
-        search_engines = SEARCH_ENGINES
-        keywords = KEYWORDS
-        
         while len(self.referrer_pool) < 500 and self.running:
-            engine = random.choice(search_engines)
-            keyword = random.choice(keywords)
-            referrer = f"{engine}{keyword}"
+            referrer = f"{random.choice(SEARCH_ENGINES)}{random.choice(KEYWORDS)}"
             with self.lock:
                 self.referrer_pool.append(referrer)
-            time.sleep(0.002)
             
     def generate_locations(self):
-        countries = COUNTRIES
-        languages = LANGUAGES
-        timezones = TIMEZONES
-        
         while len(self.location_pool) < 500 and self.running:
-            country = random.choice(countries)
-            language = random.choice(languages)
-            timezone = random.choice(timezones)
             location = {
-                "country": country,
-                "language": language,
-                "timezone": timezone
+                "country": random.choice(COUNTRIES),
+                "language": random.choice(LANGUAGES),
+                "timezone": random.choice(TIMEZONES)
             }
             with self.lock:
                 self.location_pool.append(location)
-            time.sleep(0.002)
             
     def get_ipv4(self):
         with self.lock:

src/engine/browser_engine.py

@@ -3,11 +3,21 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-import asyncio
 import aiohttp
-import requests
+import asyncio
 from urllib.parse import quote
-from config import CONTENT_EXTRACTION, SEARCH_SELECTION
+from config import (
+    CONTENT_EXTRACTION,
+    SEARCH_SELECTION,
+    TCP_CONNECTOR_ENABLE_DNS_CACHE,
+    TCP_CONNECTOR_TTL_DNS_CACHE,
+    TCP_CONNECTOR_LIMIT,
+    TCP_CONNECTOR_LIMIT_PER_HOST,
+    TCP_CONNECTOR_FORCE_CLOSE,
+    TCP_CONNECTOR_ENABLE_CLEANUP,
+    ENABLE_TRUST_ENV,
+    ENABLE_CONNECTOR_OWNER
+)
 from src.core.web_loader import web_loader
 
 class BrowserEngine:
@@ -21,7 +31,7 @@ class BrowserEngine:
         origin = web_loader.get_origin()
         referrer = web_loader.get_referrer()
         location = web_loader.get_location()
-        
+
         return {
             "User-Agent": user_agent,
             "X-Forwarded-For": f"{ipv4}, {ipv6}",
@@ -48,7 +58,7 @@ class BrowserEngine:
             "X-Timezone": location['timezone']
         }
 
-    def _build_search_url_and_selector(self, search_query: str, search_provider: str = "google"):
+    def web_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)}",
@@ -60,80 +70,48 @@ class BrowserEngine:
             "#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):
+    async def web_request(self, method: str, url: str, headers: dict, data: dict = None):
         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:
+        connector = aiohttp.TCPConnector(
+            use_dns_cache=TCP_CONNECTOR_ENABLE_DNS_CACHE,
+            ttl_dns_cache=TCP_CONNECTOR_TTL_DNS_CACHE,
+            limit=TCP_CONNECTOR_LIMIT,
+            limit_per_host=TCP_CONNECTOR_LIMIT_PER_HOST,
+            force_close=TCP_CONNECTOR_FORCE_CLOSE,
+            enable_cleanup_closed=TCP_CONNECTOR_ENABLE_CLEANUP
+        )
+        async with aiohttp.ClientSession(
+            timeout=timeout,
+            connector=connector,
+            trust_env=ENABLE_TRUST_ENV,
+            connector_owner=ENABLE_CONNECTOR_OWNER
+        ) as session:
+            async with session.request(method, url, headers=headers, data=data) 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
-                    )
+                response.raise_for_status()
                 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
+    async def _post(self, url: str, data: dict, headers: dict):
+        return await self.web_request("POST", url, headers, data)
 
-    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 _get(self, url: str, headers: dict):
+        return await self.web_request("GET", url, headers)
 
-    async def async_extract_page_content(self, target_url: str) -> str:
+    def 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:
-            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)}"
+            extracted_content = asyncio.run(self._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:
+    def 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)
+        full_url, selector = self.web_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:
-            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)}"
+            search_results = asyncio.run(self._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/response/generator.py

@@ -4,7 +4,12 @@
 #
 
 import traceback
-from config import MAX_TOKENS, INSTRUCTIONS_END
+from config import (
+    INSTRUCTIONS_END,
+    MAX_TOKENS,
+    CHAT_TEMPERATURE,
+    STREAM
+)
 
 def generate_response(
     server,
@@ -16,12 +21,11 @@ def generate_response(
     response_generator = ""
     
     if tools_done:
-        system_reminder = {
+        conversation_messages.append({
             "role": "system",
             "content": INSTRUCTIONS_END
-        }
-        conversation_messages.append(system_reminder)
-    
+        })
+        
     try:
         response = server.chat.completions.create(
             model=model_name,
@@ -29,8 +33,8 @@ def generate_response(
             tools=tool_definitions if not tools_done else None,
             tool_choice="none",
             max_tokens=MAX_TOKENS,
-            temperature=0.75,
-            stream=True
+            temperature=CHAT_TEMPERATURE,
+            stream=STREAM
         )
         
         for data in response:

src/processor/tools/interaction.py

@@ -10,43 +10,34 @@ from ..reasoning.interface import reasoning_interfaces
 from ..reasoning.tool_reasoning import tool_reasoning
 from .parser import extract_tool_parameters
 from .executor import invoke_tool_function
-from config import MAX_TOKENS, REASONING_DELAY
+from config import (
+    MAX_TOKENS,
+    REASONING_DELAY,
+    REASONING_INSERT,
+    TOOLS_TEMPERATURE,
+    MAXIMUM_ITERATIONS,
+    MAX_RETRY_LIMIT,
+    ITERATION_METRICS
+)
 
 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.02,
-            0.03,
-            0.04,
-            0.05,
-            0.06,
-            0.07
-        ],
-        "backoff_multiplier": 1.0
-    }
-    
-    while maximum_iterations <= max_retry_limit and not execution_success:
-        iteration_metrics["attempts"] += 1
+
+    while MAXIMUM_ITERATIONS <= MAX_RETRY_LIMIT and not execution_success:
+        ITERATION_METRICS["attempts"] += 1
         current_iteration_successful = False
         iteration_errors = []
         
-        for iteration_index in range(maximum_iterations):
+        for iteration_index in range(MAXIMUM_ITERATIONS):
             try:
-                retry_delay = iteration_metrics["retry_delays"][min(retry_count, len(iteration_metrics["retry_delays"]) - 1)]
+                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"])
+                    time.sleep(retry_delay * ITERATION_METRICS["backoff_multiplier"])
                 
                 model_response = server.chat.completions.create(
                     model=model_name,
@@ -54,7 +45,7 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                     tools=tool_definitions,
                     tool_choice="auto",
                     max_tokens=MAX_TOKENS,
-                    temperature=0.6
+                    temperature=TOOLS_TEMPERATURE
                 )
                 
                 response_choice = model_response.choices[0]
@@ -86,7 +77,7 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                     
                     if extraction_error:
                         error_key = f"{tool_name}_extraction"
-                        iteration_metrics["error_patterns"][error_key] = iteration_metrics["error_patterns"].get(error_key, 0) + 1
+                        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,
@@ -94,7 +85,7 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                         })
                         
                         reasoning_error = tool_reasoning(tool_name, None, "error", error=extraction_error)
-                        for i in range(0, len(reasoning_error), 10):
+                        for i in range(0, len(reasoning_error), REASONING_INSERT):
                             logs_generator = styles(reasoning_interfaces(reasoning_error, i), expanded=True)
                             yield logs_generator
                             time.sleep(REASONING_DELAY)
@@ -103,13 +94,13 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                         tool_execution_result = extraction_error
                     else:
                         reasoning_status = tool_reasoning(tool_name, extracted_arguments, "parsing")
-                        for i in range(0, len(reasoning_status), 10):
+                        for i in range(0, len(reasoning_status), REASONING_INSERT):
                             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), 10):
+                        for i in range(0, len(reasoning_start), REASONING_INSERT):
                             logs_generator = styles(reasoning_interfaces(reasoning_start, i), expanded=True)
                             yield logs_generator
                             time.sleep(REASONING_DELAY)
@@ -124,12 +115,12 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                                 "tool": tool_name,
                                 "arguments": extracted_arguments,
                                 "result": tool_execution_result,
-                                "iteration": maximum_iterations,
+                                "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), 10):
+                            for i in range(0, len(reasoning_done), REASONING_INSERT):
                                 logs_generator = styles(reasoning_interfaces(reasoning_done, i), expanded=True)
                                 yield logs_generator
                                 time.sleep(REASONING_DELAY)
@@ -138,7 +129,7 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                             
                         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
+                            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),
@@ -147,7 +138,7 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                             })
                             
                             reasoning_error = tool_reasoning(tool_name, extracted_arguments, "error", error=str(tool_error))
-                            for i in range(0, len(reasoning_error), 10):
+                            for i in range(0, len(reasoning_error), REASONING_INSERT):
                                 logs_generator = styles(reasoning_interfaces(reasoning_error, i), expanded=True)
                                 yield logs_generator
                                 time.sleep(REASONING_DELAY)
@@ -174,11 +165,11 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
             except Exception as model_error:
                 last_error = str(model_error)
                 error_history.append({
-                    "iteration": maximum_iterations,
+                    "iteration": MAXIMUM_ITERATIONS,
                     "error": last_error,
                     "timestamp": time.time()
                 })
-                iteration_metrics["failures"] += 1
+                ITERATION_METRICS["failures"] += 1
                 iteration_errors.append({
                     "error": last_error,
                     "type": "model"
@@ -192,31 +183,31 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                 error_history.extend(iteration_errors)
             
             retry_count += 1
-            previous_iterations = maximum_iterations
+            previous_iterations = MAXIMUM_ITERATIONS
             
-            if iteration_metrics["error_patterns"]:
-                frequent_errors = max(iteration_metrics["error_patterns"].values())
+            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)
+                    new_iterations = min(MAXIMUM_ITERATIONS + 2, MAX_RETRY_LIMIT)
                 else:
-                    maximum_iterations = min(maximum_iterations + 1, max_retry_limit)
+                    new_iterations = min(MAXIMUM_ITERATIONS + 1, MAX_RETRY_LIMIT)
             else:
-                maximum_iterations = min(maximum_iterations + 1, max_retry_limit)
+                new_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), 10):
+            if new_iterations > previous_iterations:
+                retry_reasoning = f"Retrying with increased iterations: {new_iterations} (attempt {retry_count + 1})"
+                for i in range(0, len(retry_reasoning), REASONING_INSERT):
                     logs_generator = styles(reasoning_interfaces(retry_reasoning, i), expanded=True)
                     yield logs_generator
                     time.sleep(REASONING_DELAY)
             
-            if maximum_iterations >= max_retry_limit:
-                final_error = f"Maximum retry limit reached after {iteration_metrics['attempts']} attempts with {iteration_metrics['failures']} failures"
+            if new_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
+    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)