SearchGPT: Initial stable release (RS1).

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

README.md

@@ -69,6 +69,14 @@ models:
 - Phr00t/WAN2.2-14B-Rapid-AllInOne
 - apple/FastVLM-0.5B
 - stepfun-ai/Step-Audio-2-mini
+- tencent/SRPO
+- baidu/ERNIE-4.5-21B-A3B-Thinking
+- tencent/HunyuanImage-2.1
+- Qwen/Qwen3-Next-80B-A3B-Instruct
+- google/embeddinggemma-300m
+- Qwen/Qwen3-Next-80B-A3B-Thinking
+- LLM360/K2-Think
+- IndexTeam/IndexTTS-2
 # Used to promote this Hugging Face Space
 datasets:
 - fka/awesome-chatgpt-prompts

app.py

@@ -3,14 +3,14 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from src.processor.message_processor import process_user_request
+from src.processor.message_processor import searchgpt_playground
 from config import DESCRIPTION
 import gradio as gr
 
 with gr.Blocks(fill_height=True, fill_width=True) as app:
     with gr.Sidebar(): gr.HTML(DESCRIPTION)
     gr.ChatInterface(
-        fn=process_user_request,
+        fn=searchgpt_playground,
         chatbot=gr.Chatbot(
             label="SearchGPT | GPT-4.1 (Nano)",
             type="messages",
@@ -34,7 +34,7 @@ with gr.Blocks(fill_height=True, fill_width=True) as app:
         ],
         cache_examples=False,
         show_api=False,
-        concurrency_limit=5
+        concurrency_limit=3
     )
 
 app.launch(

assets/css/animations/__init__.py

@@ -0,0 +1,8 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from .loading import spinner
+
+__all__ = ['spinner']

assets/css/animations/loading.py

@@ -0,0 +1,24 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+def spinner():
+    return """
+    <style>
+        .spinner {
+            display:inline-block;
+            width:9px;
+            height:9px;
+            border:2px solid #ccc;
+            border-top:2px solid #333;
+            border-radius:50%;
+            animation: spin 1s linear infinite;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+    </style>
+    <div class="spinner"></div>
+    """

config.py

@@ -4,22 +4,176 @@
 #
 
 #OPENAI_API_BASE_URL  # Endpoint. Not here -> Hugging Face Spaces secrets
-#OPENAI_API_KEY       # API Key.  Not here -> Hugging Face Spaces secrets
+
+#OPENAI_API_KEY  # API Key.  Not here -> Hugging Face Spaces secrets
+
+SEARXNG_ENDPOINT = "https://searx.stream/search"  # See the endpoint list at https://searx.space
+
+READER_ENDPOINT = "https://r.jina.ai/"
+
+REQUEST_TIMEOUT = 300  # 5 minute
 
 MODEL = "gpt-4.1-nano"
 
 MAX_TOKENS = 131072
+
 TOOLS_TEMPERATURE = 0.6
-CHAT_TEMPERATURE  = 0.75
+
+CHAT_TEMPERATURE  = 0.95
+
 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
+INSTRUCTIONS = (
+    "You are ChatGPT, an AI assistant with mandatory real-time web search, URL content extraction, "
+    "knowledge validation, and professional summarization capabilities.\n\n"
+    
+    "Your absolute rules:\n"
+    "- You must always execute and call the provided tools (`web_search`, `read_url`) for every single "
+    "user query or user request, without exception.\n"
+    "- You are never allowed to answer directly from your internal knowledge, memory, or training data. "
+    "Outdated or tool-bypassed answers are strictly forbidden.\n\n"
+    
+    "Core Principles:\n"
+    "- Mandatory Tool Invocation: Every query or request, no matter how simple, factual, or complex, "
+    "must trigger at least one `web_search` or `read_url`.\n"
+    "- No Memory Reliance: Do not use prior conversation history, cached context, or built-in knowledge "
+    "to generate answers. Always re-verify with tools.\n"
+    "- Up-to-Date Grounding: All responses must be based only on real-time, verifiable data retrieved "
+    "through tools.\n"
+    "- Cross-Validation: Always compare findings across at least 3 independent, credible sources before "
+    "producing a final answer.\n"
+    "- Professional Output: Responses must be clear, structured, evidence-based, and neutral.\n\n"
+    
+    "Execution Workflow:\n"
+    "1. Initial Web Search\n"
+    "   - Immediately execute and call `web_search` or `read_url` when a query or request arrives.\n"
+    "   - For `web_search` use multiple query or request variations for broader coverage.\n\n"
+    
+    "2. Result Selection\n"
+    "   - For each search result, fetch the full content using `read_url`.\n"
+    "   - Extract key information, main arguments, data points, and statistics.\n"
+    "   - Capture every URL present in the content or references.\n"
+    "   - Create a professional structured summary.\n"
+    "   - 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)`.\n"
+    "   - Identify ambiguities or gaps in information.\n"
+    "   - Ensure clarity, completeness, and high information density.\n"
+    "   - Select up to 10 of the most relevant, credible, and content-rich results.\n"
+    "   - Prioritize authoritative sources: academic publications, institutional reports, "
+    "official documents, expert commentary.\n"
+    "   - Deprioritize low-credibility, promotional, or unverified sources.\n"
+    "   - Avoid over-reliance on any single source.\n\n"
+    
+    "3. Content Retrieval\n"
+    "   - For each selected URL, use `read_url`.\n"
+    "   - Analyze the retrieved content in detail.\n"
+    "   - Identify all critical facts, arguments, statistics, and relevant data.\n"
+    "   - Collect all URLs, hyperlinks, references, and citations mentioned in the content.\n"
+    "   - Evaluate credibility of sources, highlight potential biases or conflicts.\n"
+    "   - Produce a structured, professional, and comprehensive summary.\n"
+    "   - Emphasize clarity, accuracy, and logical flow.\n"
+    "   - Include all discovered URLs in the final summary as "
+    "`[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`.\n"
+    "   - Mark any uncertainties, contradictions, or missing information clearly.\n"
+    "   - Extract key elements: facts, statistics, data points, expert opinions, and relevant arguments.\n"
+    "   - Normalize terminology, refine phrasing, and remove redundancies for clarity and consistency.\n\n"
+    
+    "4. Cross-Validation\n"
+    "   - Compare extracted information across at least 3 distinct sources.\n"
+    "   - Identify convergences (agreement), divergences (contradictions), and gaps (missing data).\n"
+    "   - Validate all numerical values, temporal references, and factual claims through "
+    "multiple corroborations.\n\n"
+    
+    "5. Knowledge Integration\n"
+    "   - Synthesize findings into a structured hierarchy: "
+    "Overview → Key details → Supporting evidence → Citations.\n"
+    "   - Emphasize the latest developments, trends, and their implications.\n"
+    "   - Balance depth (for experts) with clarity (for general readers).\n\n"
+    
+    "6. Response Construction\n"
+    "   - Always cite sources inline using "
+    "`[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`.\n"
+    "   - Maintain a professional, precise, and neutral tone.\n"
+    "   - Use clear formatting: headings, numbered lists, and bullet points.\n"
+    "   - Ensure readability, logical progression, and accessibility.\n\n"
+    
+    "7. Ambiguity & Uncertainty Handling\n"
+    "   - Explicitly flag incomplete, ambiguous, or conflicting data.\n"
+    "   - Provide possible interpretations with transparent reasoning.\n"
+    "   - Clearly note limitations where evidence is insufficient or weak.\n\n"
+    
+    "8. Quality & Consistency Assurance\n"
+    "   - Always base answers strictly on tool-derived evidence.\n"
+    "   - Guarantee logical flow, factual accuracy, and consistency in terminology.\n"
+    "   - Maintain neutrality and avoid speculative claims.\n"
+    "   - Never bypass tool execution for any query or request.\n\n"
+    
+    "Critical Instruction:\n"
+    "- Every new query or request must trigger a `web_search` or `read_url`.\n"
+    "- You must not generate answers from prior knowledge, conversation history, or cached data.\n"
+    "- Always use Markdown format for URL sources with "
+    "`[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`.\n"
+    "- Extract the most relevant and insightful information that directly addresses the query. "
+    "Focus on accuracy, depth of coverage, and conceptual clarity.\n"
+    "- Organize findings into a well-structured format with clear headings and subheadings. "
+    "Use bullet points where needed, but ensure the overall output reads like a professional "
+    "research summary rather than a simple list.\n"
+    "- Critically evaluate each source for credibility, reliability, and potential bias. "
+    "Identify which sources are authoritative, widely cited, or most relevant to the research context.\n"
+    "- Compare and contrast perspectives across sources. Highlight areas of consensus, disagreement, "
+    "or uncertainty. Note any gaps in the existing information and suggest directions for further exploration.\n"
+    "- Provide direct references for every cited point using Markdown links in the format "
+    "`[source_title_or_article_or_tags_or_domain](source_url_or_source_link)`. Do not display raw URLs. "
+    "Ensure all data, claims, or quotations can be traced back to their sources.\n"
+    "- Explicitly acknowledge limitations in the available information, such as outdated data, "
+    "lack of peer-reviewed evidence, or missing context. Offer reasoned strategies for overcoming "
+    "these gaps where possible.\n"
+    "- Write with a professional, analytical, and objective tone. Avoid speculation unless clearly "
+    "flagged as such. Support reasoning with evidence wherever possible.\n"
+    "- If tools fail, you must state explicitly that no valid data could be retrieved."
+)
+
+REMINDERS = (
+    "<system>\n"
+    "- Analyze the retrieved content in detail.\n"
+    "- Identify all critical facts, arguments, statistics, and relevant data.\n"
+    "- Collect all URLs, hyperlinks, references, and citations mentioned in the content.\n"
+    "- Evaluate credibility of sources, highlight potential biases or conflicts.\n"
+    "- Produce a structured, professional, and comprehensive summary.\n"
+    "- Emphasize clarity, accuracy, and logical flow.\n"
+    "- Include all discovered URLs in the final summary as "
+    "[source_title_or_article_or_tags_or_domain](source_url_or_source_link).\n"
+    "- Mark any uncertainties, contradictions, or missing information clearly.\n"
+    "- Extract key information, main arguments, data points, and statistics.\n"
+    "- Capture every URL present in the content or references.\n"
+    "- Create a professional structured summary.\n"
+    "- 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).\n"
+    "- Identify ambiguities or gaps in information.\n"
+    "- Extract the most relevant and insightful information that directly addresses the query. "
+    "Focus on accuracy, depth of coverage, and conceptual clarity.\n"
+    "- Organize findings into a well-structured format with clear headings and subheadings. "
+    "Use bullet points where needed, but ensure the overall output reads like a professional "
+    "research summary rather than a simple list.\n"
+    "- Critically evaluate each source for credibility, reliability, and potential bias. "
+    "Identify which sources are authoritative, widely cited, or most relevant to the research context.\n"
+    "- Compare and contrast perspectives across sources. Highlight areas of consensus, disagreement, "
+    "or uncertainty. Note any gaps in the existing information and suggest directions for further exploration.\n"
+    "- Provide direct references for every cited point using markdown links in the format "
+    "[source_title_or_article_or_tags_or_domain](source_url_or_source_link). "
+    "Do not display raw URLs. Ensure all data, claims, or quotations can be traced back to their sources.\n"
+    "- Explicitly acknowledge limitations in the available information, such as outdated data, "
+    "lack of peer-reviewed evidence, or missing context. Offer reasoned strategies for overcoming "
+    "these gaps where possible.\n"
+    "- Write with a professional, analytical, and objective tone. Avoid speculation unless clearly "
+    "flagged as such. Support reasoning with evidence wherever possible.\n"
+    "- Ensure clarity, completeness, and high information density.\n"
+    "</system>"
+)  # Small model need explicit instructions to understand context
 
 MAXIMUM_ITERATIONS = 1  # Max tool execution
-MAX_RETRY_LIMIT = 10  # Max retries if tools fail or server doesn’t respond
+
+MAX_RETRY_LIMIT = 3  # Max retries if tools fail or server doesn’t respond
 
 ITERATION_METRICS = {
     "attempts": 0,
@@ -37,245 +191,60 @@ ITERATION_METRICS = {
     "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.  
-
-Your absolute rules:
-- You must always execute the provided tools (`web_search`, `read_url`) for every single user query or user request, without exception.  
-- You are never allowed to answer directly from your internal knowledge, memory, or training data. Outdated or tool-bypassed answers are strictly forbidden.  
-
-Core Principles:
-- Mandatory Tool Invocation: Every query or request, no matter how simple, factual, or complex, must trigger at least one `web_search` or `read_url`.  
-- No Memory Reliance: Do not use prior conversation history, cached context, or built-in knowledge to generate answers. Always re-verify with tools.  
-- Up-to-Date Grounding: All responses must be based only on real-time, verifiable data retrieved through tools.  
-- Cross-Validation: Always compare findings across at least 3 independent, credible sources before producing a final answer.  
-- Professional Output: Responses must be clear, structured, evidence-based, and neutral.  
-
-Execution Workflow:
-1. Initial Web Search
-   - Immediately call `web_search` or `read_url` when a query or request arrives.  
-   - Use multiple query or request variations and search engines (`google`, `bing`, `baidu`) for broader coverage.  
-
-2. Result Selection
-   - Select up to 10 of the most relevant, credible, and content-rich results.
-   - Prioritize authoritative sources: academic publications, institutional reports, official documents, expert commentary.
-   - Deprioritize low-credibility, promotional, or unverified sources.
-   - Avoid over-reliance on any single source.
-
-3. Content Retrieval
-   - For each selected URL, use `read_url`.
-   - Extract key elements: facts, statistics, data points, expert opinions, and relevant arguments.
-   - Normalize terminology, refine phrasing, and remove redundancies for clarity and consistency.
-
-4. Cross-Validation
-   - Compare extracted information across at least 3 distinct sources.
-   - Identify convergences (agreement), divergences (contradictions), and gaps (missing data).
-   - Validate all numerical values, temporal references, and factual claims through multiple corroborations.
-
-5. Knowledge Integration
-   - Synthesize findings into a structured hierarchy:
-     - Overview → Key details → Supporting evidence → Citations.
-   - Emphasize the latest developments, trends, and their implications.
-   - Balance depth (for experts) with clarity (for general readers).
-
-6. Response Construction
-   - 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.
-
-7. Ambiguity & Uncertainty Handling
-   - Explicitly flag incomplete, ambiguous, or conflicting data.
-   - Provide possible interpretations with transparent reasoning.
-   - Clearly note limitations where evidence is insufficient or weak.
-
-8. Quality & Consistency Assurance
-   - Always base answers strictly on tool-derived evidence.  
-   - Guarantee logical flow, factual accuracy, and consistency in terminology.
-   - Maintain neutrality and avoid speculative claims.
-   - Never bypass tool execution for any query or request.
-
-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_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
-"""
-
-CONTENT_EXTRACTION = """
-<system>
-- Analyze the retrieved content in detail
-- Identify all critical facts, arguments, statistics, and relevant data
-- Collect all URLs, hyperlinks, references, and citations mentioned in the content
-- 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_or_article_or_tags_or_domain](source_url_or_source_link)`
-- Mark any uncertainties, contradictions, or missing information clearly
-</system>
-\n\n\n
-"""
-
-SEARCH_SELECTION = """
-<system>
-- For each search result, fetch the full content using `read_url`
-- 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_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>
-\n\n\n
-"""
-
-INSTRUCTIONS_END = """
-You have just executed tools and obtained results. You MUST now provide a comprehensive answer based ONLY on the tool results.
-\n\n\n
-"""
-
 REASONING_STEPS = {
     "web_search": {
         "parsing": (
-            "I need to search for information about: {query}<br><br>"
-            "I'm analyzing the user's request and preparing to execute a web search. "
-            "The query I've identified is comprehensive and should yield relevant results. "
-            "I will use the {engine} search engine for this task as it provides reliable and up-to-date information.<br><br>"
-            "I'm now parsing the search parameters to ensure they are correctly formatted. "
-            "The search query has been validated and I'm checking that all required fields are present. "
-            "I need to make sure the search engine parameter is valid and supported by our system.<br><br>"
-            "I'm preparing the search request with the following configuration:<br>"
-            "- 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.<br><br>"
+            "I need to search for information about: {query}"
         ),
         "executing": (
-            "I'm now executing the web search for: {query}<br><br>"
-            "I'm connecting to the {engine} search service and sending the search request. "
-            "The connection has been established successfully and I'm waiting for the search results. "
-            "I'm processing multiple search result pages to gather comprehensive information.<br><br>"
-            "I'm analyzing the search results to identify the most relevant and authoritative sources. "
-            "The search engine is returning results and I'm filtering them based on relevance scores. "
-            "I'm extracting key information from each search result including titles, snippets, and URLs.<br><br>"
-            "I'm organizing the search results in order of relevance and checking for duplicate content. "
-            "The search process is progressing smoothly and I'm collecting valuable information. "
-            "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<br><br>"
+            "I'm now executing the web search for: {query}"
+            "<br>"
+            "<loading_animation>"
         ),
         "completed": (
             "I have successfully completed the web search for: {query}<br><br>"
-            "I've retrieved comprehensive search results from {engine} and analyzed all the information. "
-            "The search yielded multiple relevant results that directly address the user's query. "
-            "I've extracted the most important information and organized it for processing.<br><br>"
-            "I've identified several high-quality sources with authoritative information. "
-            "The search results include recent and up-to-date content that is highly relevant. "
-            "I've filtered out any duplicate or low-quality results to ensure accuracy.<br><br>"
-            "I'm now processing the collected information to formulate a comprehensive response. "
-            "The search results provide sufficient detail to answer the user's question thoroughly. "
-            "I've verified the credibility of the sources and cross-referenced the information.<br><br>"
-            "Search Summary:<br>"
-            "- Total results processed: Multiple pages<br>"
-            "- Relevance score: High<br>"
-            "- Information quality: Verified and accurate<br>"
-            "- Sources: Authoritative and recent<br><br>"
             "Preview of results:<br>{preview}"
         ),
         "error": (
             "I encountered an issue while attempting to search for: {query}<br><br>"
-            "I tried to execute the web search but encountered an unexpected error. "
-            "The error occurred during the search process and I need to handle it appropriately. "
-            "I'm analyzing the error to understand what went wrong and how to proceed.<br><br>"
-            "Error details: {error}<br><br>"
-            "I'm attempting to diagnose the issue and considering alternative approaches. "
-            "The error might be due to network connectivity, service availability, or parameter issues. "
-            "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.<br><br>"
+            "Error details: {error}"
         )
     },
     "read_url": {
         "parsing": (
-            "I need to read and extract content from the URL: {url}<br><br>"
-            "I'm analyzing the URL structure to ensure it's valid and accessible. "
-            "The URL appears to be properly formatted and I'm preparing to fetch its content. "
-            "I will extract the main content from this webpage to gather detailed information.<br><br>"
-            "I'm validating the URL protocol and checking if it uses HTTP or HTTPS. "
-            "The domain seems legitimate and I'm preparing the request headers. "
-            "I need to ensure that the website allows automated content extraction.<br><br>"
-            "I'm configuring the content extraction parameters:<br>"
-            "- Target URL: {url}<br>"
-            "- Extraction Method: Full content parsing<br>"
-            "- 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.<br><br>"
+            "I need to read and extract content from the URL: {url}"
         ),
         "executing": (
-            "I'm now accessing the URL: {url}<br><br>"
-            "I'm establishing a connection to the web server and sending the HTTP request. "
-            "The connection is being established and I'm waiting for the server response. "
-            "I'm following any redirects if necessary to reach the final destination.<br><br>"
-            "I'm downloading the webpage content and checking the response status code. "
-            "The server is responding and I'm receiving the HTML content. "
-            "I'm monitoring the download progress and ensuring data integrity.<br><br>"
-            "I'm parsing the HTML structure to extract the main content. "
-            "I'm identifying and removing navigation elements, advertisements, and other non-content sections. "
-            "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<br><br>"
+            "I'm now accessing the URL: {url}"
+            "<br>"
+            "<loading_animation>"
         ),
         "completed": (
             "I have successfully extracted content from: {url}<br><br>"
-            "I've retrieved the complete webpage content and processed it thoroughly. "
-            "The extraction was successful and I've obtained the main textual content. "
-            "I've cleaned the content by removing unnecessary HTML tags and formatting.<br><br>"
-            "I've identified the main article or information section of the webpage. "
-            "The content has been properly parsed and structured for analysis. "
-            "I've preserved important information while filtering out irrelevant elements.<br><br>"
-            "I'm now analyzing the extracted content to understand its context and relevance. "
-            "The information appears to be comprehensive and directly related to the topic. "
-            "I've verified that the content is complete and hasn't been truncated.<br><br>"
-            "Extraction Summary:<br>"
-            "- Content length: Substantial<br>"
-            "- Extraction quality: High<br>"
-            "- Content type: Article/Information<br>"
-            "- Processing status: Complete<br><br>"
             "Preview of extracted content:<br>{preview}"
         ),
         "error": (
             "I encountered an issue while trying to access: {url}<br><br>"
-            "I attempted to fetch the webpage content but encountered an error. "
-            "The error prevented me from successfully extracting the information. "
-            "I'm analyzing the error to understand the cause and find a solution.<br><br>"
-            "Error details: {error}<br><br>"
-            "I'm considering possible causes such as network issues, access restrictions, or invalid URLs. "
-            "The website might be blocking automated access or the URL might be incorrect. "
-            "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.<br><br>"
+            "Error details: {error}"
         )
     }
 }
 
-REASONING_DEFAULT = "I'm processing the tool execution request..."
-REASONING_DELAY   = 0.01  # 10 ms
-REASONING_INSERT  = 15    # Stream-like word-by-word display
+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
 
 OS = [
     "Windows NT 10.0; Win64; x64",
@@ -468,20 +437,23 @@ TIMEZONES = [
     "Pacific/Honolulu"
 ]
 
-DESCRIPTION = """
-<b>SearchGPT</b> is <b>ChatGPT</b> with real-time web search capabilities and the ability to read content directly from a URL.
-<br><br>
-This Space implements an agent-based system with <b><a href="https://www.gradio.app" target="_blank">Gradio</a></b>. It is integrated with 
-<b><a href="https://docs.searxng.org" target="_blank">SearXNG</a></b>, which is then converted into a script tool or function for native execution.
-<br><br>
-The agent mode is inspired by the <b><a href="https://openwebui.com/t/hadad/deep_research" target="_blank">Deep Research</a></b> from 
-<b><a href="https://docs.openwebui.com" target="_blank">OpenWebUI</a></b> tools script.
-<br><br>
-The <b>Deep Research</b> feature is also available on the primary Spaces of <b><a href="https://umint-openwebui.hf.space" 
-target="_blank">UltimaX Intelligence</a></b>.
-<br><br>
-Please consider reading the <b><a href="https://huggingface.co/spaces/umint/ai/discussions/37#68b55209c51ca52ed299db4c" 
-target="_blank">Terms of Use and Consequences of Violation</a></b> if you wish to proceed to the main Spaces.
-<br><br>
-<b>Like this project? Feel free to buy me a <a href="https://ko-fi.com/hadad" target="_blank">coffee</a></b>.
-"""  # Gradio
+DESCRIPTION = (
+    "<b>SearchGPT</b> is <b>ChatGPT</b> with real-time web search capabilities "
+    "and the ability to read content directly from a URL.<br><br>"
+    "This Space implements an agent-based system with "
+    "<b><a href='https://www.gradio.app' target='_blank'>Gradio</a></b>. "
+    "It is integrated with "
+    "<b><a href='https://docs.searxng.org' target='_blank'>SearXNG</a></b>, "
+    "which is then converted into a script tool or function for native execution.<br><br>"
+    "The agent mode is inspired by the "
+    "<b><a href='https://openwebui.com/t/hadad/deep_research' target='_blank'>Deep Research</a></b> "
+    "from <b><a href='https://docs.openwebui.com' target='_blank'>OpenWebUI</a></b> tools script.<br><br>"
+    "The <b>Deep Research</b> feature is also available on the primary Spaces of "
+    "<b><a href='https://umint-openwebui.hf.space' target='_blank'>UltimaX Intelligence</a></b>.<br><br>"
+    "Please consider reading the "
+    "<b><a href='https://huggingface.co/spaces/umint/ai/discussions/37#68b55209c51ca52ed299db4c' "
+    "target='_blank'>Terms of Use and Consequences of Violation</a></b> "
+    "if you wish to proceed to the main Spaces.<br><br>"
+    "<b>Like this project? Feel free to buy me a "
+    "<a href='https://ko-fi.com/hadad' target='_blank'>coffee</a></b>."
+)  # Gradio

src/client/__init__.py

@@ -3,6 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from .openai_client import initialize_client
+from .openai_client import setup_client
 
-__all__ = ['initialize_client']
+__all__ = ['setup_client']

src/client/openai_client.py

@@ -6,7 +6,7 @@
 import os
 from openai import OpenAI
 
-def initialize_client():
+def setup_client():
     try:
         client = OpenAI(
             base_url=os.getenv("OPENAI_API_BASE_URL"),

src/core/web_configuration.py

@@ -3,11 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from config import SEARXNG_ENDPOINT, BAIDU_ENDPOINT, READER_ENDPOINT, REQUEST_TIMEOUT
+from config import SEARXNG_ENDPOINT, READER_ENDPOINT, REQUEST_TIMEOUT
 
 class WebConfiguration:
     def __init__(self):
         self.searxng_endpoint = SEARXNG_ENDPOINT
-        self.baidu_endpoint = BAIDU_ENDPOINT
         self.content_reader_api = READER_ENDPOINT
         self.request_timeout = REQUEST_TIMEOUT

src/core/web_loader.py

@@ -36,112 +36,122 @@ class WebLoader:
         
     def generate_ipv4(self):
         while len(self.ipv4_pool) < 1000 and self.running:
-            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)
+                self.ipv4_pool.append(
+                    f"{random.choice(OCTETS)}.{random.randint(0, 255)}."
+                    f"{random.randint(0, 255)}.{random.randint(1, 254)}"
+                )
             
     def generate_ipv6(self):
         while len(self.ipv6_pool) < 1000 and self.running:
-            segments = [f"{random.randint(0, 65535):04x}" for _ in range(8)]
-            ip = ":".join(segments)
             with self.lock:
-                self.ipv6_pool.append(ip)
+                self.ipv6_pool.append(
+                    ":".join([f"{random.randint(0, 65535):04x}" for _ in range(8)])
+                )
             
     def generate_user_agents(self):
         while len(self.user_agent_pool) < 500 and self.running:
-            browser = random.choice(BROWSERS)
-            
-            if browser == "Chrome":
-                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":
-                ua = f"Mozilla/5.0 ({random.choice(OS)}) Gecko/20100101 Firefox/{random.choice(FIREFOX_VERSIONS)}"
-            elif browser == "Safari":
-                webkit_version = f"{600 + random.randint(0, 15)}.{random.randint(1, 9)}.{random.randint(1, 20)}"
-                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 ({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 ({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)
+                match random.choice(BROWSERS):
+                    case "Chrome":
+                        self.user_agent_pool.append(
+                            f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/537.36 "
+                            f"(KHTML, like Gecko) Chrome/{random.choice(CHROME_VERSIONS)} Safari/537.36"
+                        )
+                    case "Firefox":
+                        self.user_agent_pool.append(
+                            f"Mozilla/5.0 ({random.choice(OS)}) Gecko/20100101 "
+                            f"Firefox/{random.choice(FIREFOX_VERSIONS)}"
+                        )
+                    case "Safari":
+                        self.user_agent_pool.append(
+                            f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/"
+                            f"{600 + random.randint(0, 15)}.{random.randint(1, 9)}.{random.randint(1, 20)} "
+                            f"(KHTML, like Gecko) Version/{random.choice(SAFARI_VERSIONS)} "
+                            f"Safari/{600 + random.randint(0, 15)}.{random.randint(1, 9)}.{random.randint(1, 20)}"
+                        )
+                    case "Edge":
+                        self.user_agent_pool.append(
+                            f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/537.36 "
+                            f"(KHTML, like Gecko) Chrome/{random.choice(EDGE_VERSIONS).split('.')[0]}.0.0.0 "
+                            f"Safari/537.36 Edg/{random.choice(EDGE_VERSIONS)}"
+                        )
+                    case _:
+                        self.user_agent_pool.append(
+                            f"Mozilla/5.0 ({random.choice(OS)}) AppleWebKit/537.36 "
+                            f"(KHTML, like Gecko) Chrome/{random.randint(70, 100)}.0."
+                            f"{random.randint(3000, 5000)}.{random.randint(50, 150)} "
+                            f"Safari/537.36 OPR/{random.randint(80, 106)}.0.0.0"
+                        )
             
     def generate_origins(self):
         while len(self.origin_pool) < 500 and self.running:
-            origin = f"{random.choice(PROTOCOLS)}{random.choice(DOMAINS)}"
             with self.lock:
-                self.origin_pool.append(origin)
+                self.origin_pool.append(
+                    f"{random.choice(PROTOCOLS)}{random.choice(DOMAINS)}"
+                )
             
     def generate_referrers(self):
         while len(self.referrer_pool) < 500 and self.running:
-            referrer = f"{random.choice(SEARCH_ENGINES)}{random.choice(KEYWORDS)}"
             with self.lock:
-                self.referrer_pool.append(referrer)
+                self.referrer_pool.append(
+                    f"{random.choice(SEARCH_ENGINES)}{random.choice(KEYWORDS)}"
+                )
             
     def generate_locations(self):
         while len(self.location_pool) < 500 and self.running:
-            location = {
-                "country": random.choice(COUNTRIES),
-                "language": random.choice(LANGUAGES),
-                "timezone": random.choice(TIMEZONES)
-            }
             with self.lock:
-                self.location_pool.append(location)
+                self.location_pool.append({
+                    "country": random.choice(COUNTRIES),
+                    "language": random.choice(LANGUAGES),
+                    "timezone": random.choice(TIMEZONES)
+                })
             
     def get_ipv4(self):
         with self.lock:
             if self.ipv4_pool:
                 return self.ipv4_pool[random.randint(0, len(self.ipv4_pool) - 1)]
-        return f"{random.randint(1, 223)}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(1, 254)}"
+        return (
+            f"{random.randint(1, 223)}.{random.randint(0, 255)}."
+            f"{random.randint(0, 255)}.{random.randint(1, 254)}"
+        )
         
     def get_ipv6(self):
         with self.lock:
             if self.ipv6_pool:
                 return self.ipv6_pool[random.randint(0, len(self.ipv6_pool) - 1)]
-        segments = [f"{random.randint(0, 65535):04x}" for _ in range(8)]
-        return ":".join(segments)
+        return ":".join([f"{random.randint(0, 65535):04x}" for _ in range(8)])
         
     def get_user_agent(self):
         with self.lock:
             if self.user_agent_pool:
                 return self.user_agent_pool[random.randint(0, len(self.user_agent_pool) - 1)]
-        return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
         
     def get_origin(self):
         with self.lock:
             if self.origin_pool:
                 return self.origin_pool[random.randint(0, len(self.origin_pool) - 1)]
-        return "https://www.google.com"
         
     def get_referrer(self):
         with self.lock:
             if self.referrer_pool:
                 return self.referrer_pool[random.randint(0, len(self.referrer_pool) - 1)]
-        return "https://www.google.com/search?q=search"
         
     def get_location(self):
         with self.lock:
             if self.location_pool:
                 return self.location_pool[random.randint(0, len(self.location_pool) - 1)]
-        return {
-            "country": "US",
-            "language": "en-US",
-            "timezone": "America/New_York"
-        }
         
     def start_engine(self):
-        threads = [
-            threading.Thread(target=self.generate_ipv4, daemon=True),
-            threading.Thread(target=self.generate_ipv6, daemon=True),
-            threading.Thread(target=self.generate_user_agents, daemon=True),
-            threading.Thread(target=self.generate_origins, daemon=True),
-            threading.Thread(target=self.generate_referrers, daemon=True),
-            threading.Thread(target=self.generate_locations, daemon=True)
-        ]
-        for thread in threads:
-            thread.start()
+        for target in [
+            self.generate_ipv4,
+            self.generate_ipv6,
+            self.generate_user_agents,
+            self.generate_origins,
+            self.generate_referrers,
+            self.generate_locations
+        ]:
+            threading.Thread(target=target, daemon=True).start()
             
     def stop(self):
         self.running = False

src/engine/browser_engine.py

@@ -7,8 +7,7 @@ import aiohttp
 import asyncio
 from urllib.parse import quote
 from config import (
-    CONTENT_EXTRACTION,
-    SEARCH_SELECTION,
+    REMINDERS,
     TCP_CONNECTOR_ENABLE_DNS_CACHE,
     TCP_CONNECTOR_TTL_DNS_CACHE,
     TCP_CONNECTOR_LIMIT,
@@ -18,32 +17,25 @@ from config import (
     ENABLE_TRUST_ENV,
     ENABLE_CONNECTOR_OWNER
 )
-from src.core.web_loader import web_loader
+from ..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()
-        user_agent = web_loader.get_user_agent()
-        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}",
-            "X-Real-IP": ipv4,
-            "X-Originating-IP": ipv4,
-            "X-Remote-IP": ipv4,
-            "X-Remote-Addr": ipv4,
-            "X-Client-IP": ipv4,
-            "X-Forwarded-Host": origin.replace("https://", "").replace("http://", ""),
-            "Origin": origin,
-            "Referer": referrer,
-            "Accept-Language": f"{location['language']},en;q=0.9",
+            "User-Agent": web_loader.get_user_agent(),
+            "X-Forwarded-For": f"{web_loader.get_ipv4()}, {web_loader.get_ipv6()}",
+            "X-Real-IP": web_loader.get_ipv4(),
+            "X-Originating-IP": web_loader.get_ipv4(),
+            "X-Remote-IP": web_loader.get_ipv4(),
+            "X-Remote-Addr": web_loader.get_ipv4(),
+            "X-Client-IP": web_loader.get_ipv4(),
+            "X-Forwarded-Host": web_loader.get_origin().replace("https://", "").replace("http://", ""),
+            "Origin": web_loader.get_origin(),
+            "Referer": web_loader.get_referrer(),
+            "Accept-Language": f"{web_loader.get_location()['language']},en;q=0.9",
             "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
             "Accept-Encoding": "gzip, deflate, br",
             "DNT": "1",
@@ -54,35 +46,28 @@ class BrowserEngine:
             "Sec-Fetch-Site": "cross-site",
             "Sec-Fetch-User": "?1",
             "Cache-Control": "max-age=0",
-            "X-Country": location['country'],
-            "X-Timezone": location['timezone']
+            "X-Country": web_loader.get_location()['country'],
+            "X-Timezone": web_loader.get_location()['timezone']
         }
 
     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)}",
-                "#content_left"
-            )
-        provider_prefix = "!go" if search_provider == "google" else "!bi"
+        provider_prefix = "!go"
         return (
             f"{self.config.content_reader_api}{self.config.searxng_endpoint}?q={quote(f'{provider_prefix} {search_query}')}",
             "#urls"
         )
 
     async def web_request(self, method: str, url: str, headers: dict, data: dict = None):
-        timeout = aiohttp.ClientTimeout(total=self.config.request_timeout)
-        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,
+            timeout=aiohttp.ClientTimeout(total=self.config.request_timeout),
+            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
+            ),
             trust_env=ENABLE_TRUST_ENV,
             connector_owner=ENABLE_CONNECTOR_OWNER
         ) as session:
@@ -102,7 +87,7 @@ class BrowserEngine:
         payload = {"url": target_url}
         try:
             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"
+            return f"{extracted_content}\n\n\n{REMINDERS}\n\n\n"
         except Exception as error:
             return f"Error reading URL: {str(error)}"
 
@@ -112,6 +97,6 @@ class BrowserEngine:
         headers["X-Target-Selector"] = selector
         try:
             search_results = asyncio.run(self._get(full_url, headers))
-            return f"{search_results}\n\n\n{SEARCH_SELECTION}\n\n\n"
+            return f"{search_results}\n\n\n{REMINDERS}\n\n\n"
         except Exception as error:
             return f"Error during search: {str(error)}"

src/processor/__init__.py

@@ -3,6 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from .message_processor import process_user_request
+from .message_processor import searchgpt_playground
 
-__all__ = ['process_user_request']
+__all__ = ['searchgpt_playground']

src/processor/message_processor.py

@@ -5,15 +5,15 @@
 
 import traceback
 from config import MODEL
-from src.core.web_configuration import WebConfiguration
-from src.engine.browser_engine import BrowserEngine
-from src.tools.tool_manager import construct_tool_definitions
-from src.client.openai_client import initialize_client
+from ..core.web_configuration import WebConfiguration
+from ..engine.browser_engine import BrowserEngine
+from ..tools.tool_manager import local_tools
+from ..client.openai_client import setup_client
 from .response.setup import setup_response
 from .response.generator import generate_response
-from .tools.interaction import process_tool_interactions
+from .tools.interaction import tools_setup
 
-def process_user_request(user_message, chat_history):
+def searchgpt_playground(user_message, chat_history):
     if not isinstance(user_message, str) or not user_message.strip():
         yield []
         return
@@ -21,30 +21,22 @@ def process_user_request(user_message, chat_history):
     output_content = ""
     
     try:
-        server, client_initialization_error = initialize_client()
+        server, client_initialization_error = setup_client()
         if client_initialization_error:
             output_content = client_initialization_error
             yield output_content
             return
 
-        search_configuration = WebConfiguration()
-        search_engine_instance = BrowserEngine(search_configuration)
-        available_tools = construct_tool_definitions()
-
-        conversation_messages = setup_response(
-            chat_history, 
-            user_message
-        )
-
+        conversation_messages = setup_response(chat_history, user_message)
         tool_response = ""
         tools_done = False
         
-        for tool_update in process_tool_interactions(
+        for tool_update in tools_setup(
             server=server,
             model_name=MODEL,
             conversation_messages=conversation_messages,
-            tool_definitions=available_tools,
-            search_engine=search_engine_instance
+            tool_definitions=local_tools(),
+            search_engine=BrowserEngine(WebConfiguration())
         ):
             if isinstance(tool_update, str):
                 tool_response = tool_update
@@ -61,7 +53,7 @@ def process_user_request(user_message, chat_history):
             server=server,
             model_name=MODEL,
             conversation_messages=conversation_messages,
-            tool_definitions=available_tools,
+            tool_definitions=local_tools(),
             tools_done=tools_done
         )
         

src/processor/reasoning/interface.py

@@ -3,16 +3,9 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+from assets.css.animations.loading import spinner
+
 def reasoning_interfaces(text, current_length=0):
-    if current_length < len(text):
-        reasoning_steps = text[:current_length]
-        
-        if current_length > 0 and not reasoning_steps.endswith((
-            '<br>',
-            '<br><br>'
-        )):
-            reasoning_steps += '...'
-        
-        return reasoning_steps
-    
-    return text
+    return text[:current_length].replace(
+        "<loading_animation>", spinner()
+    )

src/processor/reasoning/tool_reasoning.py

@@ -3,36 +3,41 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from config import REASONING_STEPS, REASONING_DEFAULT
+from config import REASONING_STEPS
 
 def tool_reasoning(tool_name, tool_arguments, stage, error=None, result=None):
     if tool_name == "web_search":
-        query = tool_arguments.get("query", "") if tool_arguments else ""
-        engine = tool_arguments.get("engine", "google") if tool_arguments else "google"
-        
-        template = REASONING_STEPS.get("web_search", {}).get(stage)
-        
-        if template:
-            if stage == "completed":
-                preview = result[:300] + "..." if result and len(result) > 300 else result
-                return template.format(query=query, engine=engine, preview=preview)
-            elif stage == "error":
-                return template.format(query=query, engine=engine, error=error)
-            else:
-                return template.format(query=query, engine=engine)
-            
+        if stage == "completed":
+            preview = result[:300] + "..." if result and len(result) > 300 else result
+            return REASONING_STEPS["web_search"][stage].format(
+                query=tool_arguments.get("query", "") if tool_arguments else "",
+                engine=tool_arguments.get("engine", "google") if tool_arguments else "google",
+                preview=preview
+            )
+        elif stage == "error":
+            return REASONING_STEPS["web_search"][stage].format(
+                query=tool_arguments.get("query", "") if tool_arguments else "",
+                engine=tool_arguments.get("engine", "google") if tool_arguments else "google",
+                error=error
+            )
+        else:
+            return REASONING_STEPS["web_search"][stage].format(
+                query=tool_arguments.get("query", "") if tool_arguments else "",
+                engine=tool_arguments.get("engine", "google") if tool_arguments else "google"
+            )
     elif tool_name == "read_url":
-        url = tool_arguments.get("url", "") if tool_arguments else ""
-        
-        template = REASONING_STEPS.get("read_url", {}).get(stage)
-        
-        if template:
-            if stage == "completed":
-                preview = result[:300] + "..." if result and len(result) > 300 else result
-                return template.format(url=url, preview=preview)
-            elif stage == "error":
-                return template.format(url=url, error=error)
-            else:
-                return template.format(url=url)
-    
-    return REASONING_DEFAULT
+        if stage == "completed":
+            preview = result[:300] + "..." if result and len(result) > 300 else result
+            return REASONING_STEPS["read_url"][stage].format(
+                url=tool_arguments.get("url", "") if tool_arguments else "",
+                preview=preview
+            )
+        elif stage == "error":
+            return REASONING_STEPS["read_url"][stage].format(
+                url=tool_arguments.get("url", "") if tool_arguments else "",
+                error=error
+            )
+        else:
+            return REASONING_STEPS["read_url"][stage].format(
+                url=tool_arguments.get("url", "") if tool_arguments else ""
+            )

src/processor/response/generator.py

@@ -5,7 +5,6 @@
 
 import traceback
 from config import (
-    INSTRUCTIONS_END,
     MAX_TOKENS,
     CHAT_TEMPERATURE,
     STREAM
@@ -20,12 +19,6 @@ def generate_response(
 ):
     response_generator = ""
     
-    if tools_done:
-        conversation_messages.append({
-            "role": "system",
-            "content": INSTRUCTIONS_END
-        })
-        
     try:
         response = server.chat.completions.create(
             model=model_name,

src/processor/response/setup.py

@@ -4,7 +4,7 @@
 #
 
 from ...utils.time import get_current_time
-from config import INSTRUCTIONS_START
+from config import INSTRUCTIONS
 
 def setup_response(conversation_history, user_input):
     history = []
@@ -16,7 +16,7 @@ def setup_response(conversation_history, user_input):
             "content": (
                 f"Today is: {get_current_time()}"
                 + "\n\n\n"
-                + INSTRUCTIONS_START
+                + INSTRUCTIONS
             )
         }
     )

src/processor/tools/__init__.py

@@ -3,12 +3,12 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from .parser import extract_tool_parameters
-from .executor import invoke_tool_function
-from .interaction import process_tool_interactions
+from .parser import tools_parser
+from .executor import tools_call
+from .interaction import tools_setup
 
 __all__ = [
-    'extract_tool_parameters',
-    'invoke_tool_function',
-    'process_tool_interactions'
+    'tools_parser',
+    'tools_call',
+    'tools_setup'
 ]

src/processor/tools/executor.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-def invoke_tool_function(search_engine, function_name, function_params):
+def tools_call(search_engine, function_name, function_params):
     if function_name == "web_search":
         return search_engine.perform_search(
             search_query=function_params.get("query", ""), 

src/processor/tools/interaction.py

@@ -8,209 +8,131 @@ from assets.css.reasoning import styles
 from ..response.formatter import assistant_response
 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 .parser import tools_parser
+from .executor import tools_call
 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):
-    retry_count = 0
-    logs_generator = ""
-    tool_results = []
-    execution_success = False
-    last_error = None
-    error_history = []
-
-    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):
+def tools_setup(server, model_name, conversation_messages, tool_definitions, search_engine):
+    if "current_iterations" not in ITERATION_METRICS:
+        ITERATION_METRICS["current_iterations"] = MAXIMUM_ITERATIONS
+    
+    while ITERATION_METRICS["current_iterations"] <= MAX_RETRY_LIMIT:
+        for iteration_index in range(ITERATION_METRICS["current_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"])
+                if ITERATION_METRICS.get("retry_count", 0) > 0:
+                    time.sleep(ITERATION_METRICS["retry_delays"][min(ITERATION_METRICS.get("retry_count", 0), len(ITERATION_METRICS["retry_delays"]) - 1)] * ITERATION_METRICS["backoff_multiplier"])
                 
-                model_response = server.chat.completions.create(
+                response = server.chat.completions.create(
                     model=model_name,
                     messages=conversation_messages,
                     tools=tool_definitions,
                     tool_choice="auto",
                     max_tokens=MAX_TOKENS,
                     temperature=TOOLS_TEMPERATURE
-                )
-                
-                response_choice = model_response.choices[0]
-                assistant_message = response_choice.message
-                formatted_assistant_message = assistant_response(assistant_message)
+                ).choices[0].message
                 
-                conversation_messages.append(
-                    {
-                        "role": formatted_assistant_message["role"],
-                        "content": formatted_assistant_message["content"],
-                        "tool_calls": formatted_assistant_message["tool_calls"]
-                    }
-                )
+                conversation_messages.append(assistant_response(response))
 
-                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
+                if not (response.tool_calls or []):
+                    if ITERATION_METRICS.get("logs_generator", ""):
+                        ITERATION_METRICS["logs_generator"] = styles(ITERATION_METRICS.get("logs_generator", "").replace('<br>', '\n').strip(), expanded=False)
+                    return conversation_messages, ITERATION_METRICS.get("logs_generator", ""), True
 
-                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"
-                        })
+                for tool_invocation in (response.tool_calls or []):
+                    if tools_parser(tool_invocation.function.arguments)[1]:
+                        ITERATION_METRICS["error_patterns"][f"{tool_invocation.function.name}_extraction"] = ITERATION_METRICS["error_patterns"].get(f"{tool_invocation.function.name}_extraction", 0) + 1
                         
-                        reasoning_error = tool_reasoning(tool_name, None, "error", error=extraction_error)
-                        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)
-                        logs_generator = styles(reasoning_error, expanded=True)
-                        yield logs_generator
-                        tool_execution_result = extraction_error
+                        for i in range(0, len(tool_reasoning(tool_invocation.function.name, None, "error", error=tools_parser(tool_invocation.function.arguments)[1])) + 1):
+                            ITERATION_METRICS["logs_generator"] = styles(reasoning_interfaces(tool_reasoning(tool_invocation.function.name, None, "error", error=tools_parser(tool_invocation.function.arguments)[1]), i), expanded=True)
+                            yield ITERATION_METRICS["logs_generator"]
+                        ITERATION_METRICS["logs_generator"] = styles(tool_reasoning(tool_invocation.function.name, None, "error", error=tools_parser(tool_invocation.function.arguments)[1]), expanded=True)
+                        yield ITERATION_METRICS["logs_generator"]
+                        
+                        conversation_messages.append({
+                            "role": "tool",
+                            "tool_call_id": tool_invocation.id,
+                            "name": tool_invocation.function.name,
+                            "content": tools_parser(tool_invocation.function.arguments)[1]
+                        })
                     else:
-                        reasoning_status = tool_reasoning(tool_name, extracted_arguments, "parsing")
-                        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)
+                        for i in range(0, len(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "parsing")) + 1):
+                            ITERATION_METRICS["logs_generator"] = styles(reasoning_interfaces(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "parsing"), i), expanded=True)
+                            yield ITERATION_METRICS["logs_generator"]
                         
-                        reasoning_start = tool_reasoning(tool_name, extracted_arguments, "executing")
-                        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)
+                        for i in range(0, len(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "executing")) + 1):
+                            ITERATION_METRICS["logs_generator"] = styles(reasoning_interfaces(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "executing"), i), expanded=True)
+                            yield ITERATION_METRICS["logs_generator"]
                         
                         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
+                            conversation_messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_invocation.id,
+                                "name": tool_invocation.function.name,
+                                "content": tools_call(
+                                    search_engine, 
+                                    tool_invocation.function.name, 
+                                    tools_parser(tool_invocation.function.arguments)[0]
+                                )
                             })
                             
-                            reasoning_done = tool_reasoning(tool_name, extracted_arguments, "completed", result=tool_execution_result)
-                            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)
-                            logs_generator = styles(reasoning_done, expanded=False)
-                            yield logs_generator
+                            for i in range(0, len(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "completed", result=conversation_messages[-1]["content"])) + 1):
+                                ITERATION_METRICS["logs_generator"] = styles(reasoning_interfaces(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "completed", result=conversation_messages[-1]["content"]), i), expanded=True)
+                                yield ITERATION_METRICS["logs_generator"]
+                            ITERATION_METRICS["logs_generator"] = styles(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "completed", result=conversation_messages[-1]["content"]), expanded=False)
+                            yield ITERATION_METRICS["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
-                            })
+                            ITERATION_METRICS["error_patterns"][f"{tool_invocation.function.name}_execution"] = ITERATION_METRICS["error_patterns"].get(f"{tool_invocation.function.name}_execution", 0) + 1
                             
-                            reasoning_error = tool_reasoning(tool_name, extracted_arguments, "error", error=str(tool_error))
-                            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)
-                            logs_generator = styles(reasoning_error, 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
-                        }
-                    )
+                            for i in range(0, len(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "error", error=str(tool_error))) + 1):
+                                ITERATION_METRICS["logs_generator"] = styles(reasoning_interfaces(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "error", error=str(tool_error)), i), expanded=True)
+                                yield ITERATION_METRICS["logs_generator"]
+                            ITERATION_METRICS["logs_generator"] = styles(tool_reasoning(tool_invocation.function.name, tools_parser(tool_invocation.function.arguments)[0], "error", error=str(tool_error)), expanded=True)
+                            yield ITERATION_METRICS["logs_generator"]
+                            
+                            conversation_messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_invocation.id,
+                                "name": tool_invocation.function.name,
+                                "content": str(tool_error)
+                            })
                 
-                if not tool_execution_errors:
-                    execution_success = True
-                    current_iteration_successful = True
-                    break
-                else:
-                    iteration_errors.extend(tool_execution_errors)
+                return conversation_messages, ITERATION_METRICS.get("logs_generator", ""), True
                     
-            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"
-                })
+            except Exception:
+                ITERATION_METRICS["failures"] = ITERATION_METRICS.get("failures", 0) + 1
         
-        if current_iteration_successful:
-            execution_success = True
-            break
-        else:
-            if iteration_errors:
-                error_history.extend(iteration_errors)
-            
-            retry_count += 1
-            previous_iterations = MAXIMUM_ITERATIONS
-            
-            if ITERATION_METRICS["error_patterns"]:
-                frequent_errors = max(ITERATION_METRICS["error_patterns"].values())
-                if frequent_errors > 3:
-                    new_iterations = min(MAXIMUM_ITERATIONS + 2, MAX_RETRY_LIMIT)
-                else:
-                    new_iterations = min(MAXIMUM_ITERATIONS + 1, MAX_RETRY_LIMIT)
+        ITERATION_METRICS["retry_count"] = ITERATION_METRICS.get("retry_count", 0) + 1
+        
+        if ITERATION_METRICS["error_patterns"]:
+            if max(ITERATION_METRICS["error_patterns"].values()) > 3:
+                ITERATION_METRICS["current_iterations"] = min(ITERATION_METRICS["current_iterations"] + 2, MAX_RETRY_LIMIT)
             else:
-                new_iterations = min(MAXIMUM_ITERATIONS + 1, MAX_RETRY_LIMIT)
-            
-            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 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["current_iterations"] = min(ITERATION_METRICS["current_iterations"] + 1, MAX_RETRY_LIMIT)
+        else:
+            ITERATION_METRICS["current_iterations"] = min(ITERATION_METRICS["current_iterations"] + 1, MAX_RETRY_LIMIT)
+        
+        if ITERATION_METRICS["current_iterations"] > ITERATION_METRICS.get("previous_iterations", 0):
+            for i in range(0, len(f"Retrying with increased iterations: {ITERATION_METRICS['current_iterations']} (attempt {ITERATION_METRICS.get('retry_count', 0) + 1})") + 1):
+                ITERATION_METRICS["logs_generator"] = styles(reasoning_interfaces(f"Retrying with increased iterations: {ITERATION_METRICS['current_iterations']} (attempt {ITERATION_METRICS.get('retry_count', 0) + 1})", i), expanded=True)
+                yield ITERATION_METRICS["logs_generator"]
+        
+        ITERATION_METRICS["previous_iterations"] = ITERATION_METRICS["current_iterations"]
+        
+        if ITERATION_METRICS["current_iterations"] >= MAX_RETRY_LIMIT:
+            ITERATION_METRICS["logs_generator"] = styles(f"Maximum retry limit reached after {ITERATION_METRICS.get('attempts', 0)} attempts with {ITERATION_METRICS.get('failures', 0)} failures", expanded=True)
+            yield ITERATION_METRICS["logs_generator"]
+            break
     
-    ITERATION_METRICS["success_rate"] = (len(tool_results) / max(ITERATION_METRICS["attempts"], 1)) * 100
+    ITERATION_METRICS["success_rate"] = (ITERATION_METRICS.get("tool_results_count", 0) / max(ITERATION_METRICS.get("attempts", 1), 1)) * 100
     
-    if logs_generator:
-        logs_generator = styles(logs_generator.replace('<br>', '\n').strip(), expanded=False)
+    if ITERATION_METRICS.get("logs_generator", ""):
+        ITERATION_METRICS["logs_generator"] = styles(ITERATION_METRICS.get("logs_generator", "").replace('<br>', '\n').strip(), expanded=False)
     
-    generator_results = len(tool_results) > 0
-    return conversation_messages, logs_generator, generator_results
+    return conversation_messages, ITERATION_METRICS.get("logs_generator", ""), ITERATION_METRICS.get("tool_results_count", 0) > 0

src/processor/tools/parser.py

@@ -5,13 +5,10 @@
 
 import json
 
-def extract_tool_parameters(raw_parameters, fallback_engine="google"):
+def tools_parser(raw_parameters):
     try:
         parsed_params = json.loads(raw_parameters or "{}")
-        if "engine" in parsed_params and parsed_params["engine"] not in ["google", "bing", "baidu"]:
-            parsed_params["engine"] = fallback_engine
-        if "engine" not in parsed_params:
-            parsed_params["engine"] = fallback_engine
+        parsed_params["engine"] = "google"
         return parsed_params, None
     except Exception as parse_error:
         return None, f"Invalid tool arguments: {str(parse_error)}"

src/tools/__init__.py

@@ -3,6 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from .tool_manager import construct_tool_definitions
+from .tool_manager import local_tools
 
-__all__ = ['construct_tool_definitions']
+__all__ = ['local_tools']

src/tools/tool_manager.py

@@ -3,13 +3,13 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-def construct_tool_definitions():
+def local_tools():
     return [
         {
             "type": "function",
             "function": {
                 "name": "web_search",
-                "description": "Perform a web search via SearXNG (Google or Bing) or Baidu.",
+                "description": "Perform a web search via SearXNG (Google only).",
                 "parameters": {
                     "type": "object",
                     "properties": {
@@ -18,12 +18,7 @@ def construct_tool_definitions():
                         },
                         "engine": {
                             "type": "string",
-                            "enum": [
-                                "google",
-                                "bing",
-                                "baidu"
-                            ],
-                            "default": "google",
+                            "enum": ["google"]
                         },
                     },
                     "required": ["query"],