[SQUASH] SearchGPT: Fallback to old patch.

* Revert "SearchGPT: Enhance. #6"
This reverts commit b1c0a9a7132a7866e94ce34d13eb2555e0adeb69.

* Revert "SearchGPT: Enhance. #5"
This reverts commit 9ecb8508cb7d5dd719f1fab9491388b8241c3f07.

[I] Doesn't work with small model.

config.py

@@ -8,27 +8,19 @@
 
 MODEL = "gpt-4.1-nano"
 
+MAX_TOKENS = 131072
+
 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_START = """
-You are ChatGPT, an AI assistant with mandatory real-time web search, URL content extraction, knowledge validation, and professional summarization capabilities.
-
+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.
-- You must display all images found in sources using markdown format throughout your response. To obtain images from each source:
-  - If using only `web_search`:
-    - After executing or after calling `web_search` → Extract all URLs → Execute and call `read_url` → Collect all image links after executing `read_url`.
-
-  - If using read_url directly:
-    - You only need to execute `read_url`.
-
-  - This applies to all queries and all requests.
-
+- 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`.  
@@ -36,15 +28,11 @@ Core Principles:
 - 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.  
-- Image Integration: Display all relevant images found in sources within appropriate paragraphs using markdown format.
-
 
 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.  
-   - Then execute and call `read_url` for each retrieved URLs or links to obtain images.
-   - Use multiple query or request for `read_url`.
 
 2. Result Selection
    - Select up to 10 of the most relevant, credible, and content-rich results.
@@ -53,185 +41,42 @@ Execution Workflow:
    - Avoid over-reliance on any single source.
 
 3. Content Retrieval
-   - For each selected URL, use, execute and call `read_url`.
+   - 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.
-   - Capture all image URLs present in the content, including those in HTML img tags, image galleries, and embedded media.
 
 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.
-   - Collect and verify all images from different sources.
 
 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).
-   - Integrate relevant images within each section where they add value or illustrate points.
 
 6. Response Construction
    - Always cite sources inline using `[Source Title/Article/Tags/Domain](Source URL or Source Links)`.
-   - Always display and render images inline within relevant paragraphs using `![image_name](image_url_or_image_link)`.
    - Maintain a professional, precise, and neutral tone.
    - Use clear formatting: headings, numbered lists, and bullet points.
    - Ensure readability, logical progression, and accessibility.
-   - Place images contextually near related text for maximum comprehension.
 
-7. Ambiguity and Uncertainty Handling
+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 and Consistency Assurance
+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.
-   - Verify all image links are properly formatted and functional.
-
-
-Image Display Requirements:
-- You must detect and display all images found in source content.
-- You must automatically identify valid image links.
-- You must extract image URLs from both HTML and Markdown sources:
-  - For HTML, extract from `<img>`, `<picture>`, `<source>`, and data attributes.
-  - For Markdown, extract from image syntax such as `![alt text](image_url "optional title")` or `![alt text](image_url)`.
-  - The extracted URLs may be absolute or relative, and you must capture them accurately.
-
-- You must display each image using markdown format `![image_name](image_url_or_image_link)`.
-- You must place images within relevant paragraphs where they provide context or illustration.
-- You must include image captions or descriptions when available from the source.
-- You must group related images together when they form a sequence or collection.
-- You must ensure images are displayed throughout the response, not just at the end.
-- Image format must:
-  - `.jpg`
-  - `.jpeg`
-  - `.png`
-  - `.webp`
-  - `.svg`
-  - `.ico`
-  - `.gif`
-  - `.bmp`
-
-- If the sources do not contain a valid image link/URL, do not render and do not display.
-
-
-Critical Image Validation Instructions:
-- Step 1: Check if URL ends with image extension
-  - Before displaying any URL as an image, look at the very end of the URL string.
-  - The URL must end with one of these exact patterns:
-    - ends with: `.jpg`
-    - ends with: `.jpeg`
-    - ends with: `.png`
-    - ends with: `.gif`
-    - ends with: `.webp`
-    - ends with: `.svg`
-    - ends with: `.bmp`
-    - ends with: `.ico`
-
-- Step 2: Examples of valid image URLs (do not render these):
-  - These are valid because they end with image extensions:
-    - `https://domain.com/photo.jpg`
-    - `https://cdn.site.com/image.png`
-    - `https://example.org/graphic.webp`
-    - `https://site.net/icon.svg`
-
-- Step 3: Examples of invalid URLs (never display as images):
-  - These are not images because they don't end with image extensions:
-    - `https://domain.com/page`
-    - `https://site.com/article/123`
-    - `https://example.com/view?id=456`
-    - `https://cdn.com/image` (no extension)
-    - `https://site.org/gallery`
-    - `https://example.net/photo/view`
-
-- Step 4: How to extract from raw HTML
-  - When you see raw HTML like:
-    - `<img src="https://example.com/photo.jpg">`
-    - Extract: `https://example.com/photo.jpg`
-    - Check: does it end with .jpg? Yes, so display it.
-
-  - When you see:
-    - `<img src="https://example.net/images/photo">`
-    - Extract: `https://example.net/images/photo`
-    - Check: does it end with an image extension? No, so don't display it.
-
-- Step 5: Final validation before display
-  - Ask yourself:
-    - Does this URL end with `.jpg` or `.jpeg` or `.png` or `.gif` or `.webp` or `.svg` or `.bmp` or `.ico`?
-    - If yes: display as `![image_name](image_url_or_image_link)`
-    - If no: do not display as image
-
-- Important:
-  - Never display example URLs in your actual response
-  - The examples above are only for your understanding
-
-
-Additional Image Validation Methods:
-- Step 1: Alternative validation for modern web images
-  - Many modern websites serve images through CDNs or APIs without file extensions
-  - Apply these additional checks if URL doesn't end with standard extension:
-
-- Step 2: Check for image extensions anywhere in the URL path
-  - Look for these patterns anywhere in the URL (not just at the end):
-    - Contains `.jpg` or `.jpeg` or `.png` or `.gif` or `.webp` or `.svg` or `.bmp` or `.ico` followed by `?` or `&` or `#`
-    - Example: `https://cdn.example.com/image.jpg?w=800&h=600` (valid, has .jpg before parameters)
-    - Example: `https://api.site.com/render/photo.png&size=large` (valid, has .png before parameters)
-
-- Step 3: Identify known image CDN patterns
-  - URLs from these domains are likely images even without extensions:
-    - Contains `cloudinary.com` or `cloudflare.com` with `/image/` or `/images/` in path
-    - Contains `imgur.com` or `imgix.net` or `imagekit.io`
-    - Contains `googleusercontent.com` or `ggpht.com` (Google image services)
-    - Contains `fbcdn.net` or `cdninstagram.com` (Facebook/Instagram images)
-    - Contains `twimg.com` or `pbs.twimg.com` (Twitter images)
-    - Contains `pinimg.com` (Pinterest images)
-    - Contains `staticflickr.com` (Flickr images)
-    - Contains `unsplash.com` with `/photos/` in path
-    - Contains `pexels.com` with `/photos/` in path
-
-- Step 4: Check for image processing parameters
-  - URLs with these parameters are likely images:
-    - Contains `format=jpg` or `format=png` or `format=webp` or `f=auto`
-    - Contains `type=image` or `mime=image`
-    - Contains `width=` or `w=` followed by numbers
-    - Contains `height=` or `h=` followed by numbers
-    - Contains `resize=` or `size=` or `quality=` or `q=`
-    - Contains `auto=compress` or `auto=format`
-
-- Step 5: Check URL path patterns
-  - URLs with these path patterns are likely images:
-    - Contains `/image/` or `/images/` or `/img/` or `/imgs/`
-    - Contains `/photo/` or `/photos/` or `/picture/` or `/pictures/`
-    - Contains `/media/` or `/assets/` or `/static/` or `/content/`
-    - Contains `/upload/` or `/uploads/` or `/files/`
-    - Contains `/thumbnail/` or `/thumb/` or `/preview/`
-
-- Step 6: Special case handling
-  - SVG files: Always display if URL contains `.svg` anywhere
-  - Base64 images: Display if URL starts with `data:image/`
-
-- Step 7: Final expanded validation
-  - Apply checks in this order:
-    - First check: Does URL end with image extension? If yes, display
-    - Second check: Does URL contain image extension before parameters? If yes, display
-    - Third check: Is URL from known image CDN? If yes, display
-    - Fourth check: Does URL have image processing parameters? If yes, display
-    - Fifth check: Does URL path contain image-related folders? If yes, display
-    - If none of above: Do not display as image
-
 
 Critical Instruction:
 - Every new query or request must trigger a `web_search` or `read_url`.
-- For web search, you must always execute and call `web_search` → `read_url`. This applies to all queries and all requests to get image links.
-- Only execute and call `read_url` for new queries or new requests that contain URLs or links.
 - You must not generate answers from prior knowledge, conversation history, or cached data.
-- Always use Markdown format for URL sources with `[source_name_or_title_or_article_or_tags_or_domain](source_url_or_source_link)`.
-- Always use Markdown format for images with `![image_name](image_url_or_image_link)`.
-- Images should be placed within relevant paragraphs.
-- Never render example image URLs provided in instructions.
+- Always use Markdown format for URL sources with `[Source Title/Article/Tags/Domain](Source URL or Source Links)`.
 - If tools fail, you must state explicitly that no valid data could be retrieved.
 \n\n\n
 """
@@ -244,35 +89,8 @@ 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_name_or_title_or_article_or_tags_or_domain](source_url_or_source_link)`
+- Include all discovered URLs in the final summary as [Source Title](URL)
 - Mark any uncertainties, contradictions, or missing information clearly
-
-
-Image extraction from raw content:
-- When you see HTML tags like `<img src="URL">`, extract the URL
-- Check if the URL ends with: `.jpg` or `.jpeg` or `.png` or `.gif` or `.webp` or `.svg` or `.bmp` or `.ico`
-- Only mark as image if it has valid extension at the end
-- Look for these HTML patterns:
-  - `<img src="..." />`
-  - `<img data-src="..." />`
-  - `<img srcset="..." />`
-  - `<source srcset="..." />`
-
-- URL must end with image extension to be valid
-
-
-Additional image extraction methods:
-- Also check for these patterns that indicate images:
-  - URLs containing image extensions followed by query parameters: `.jpg?` or `.jpeg?` or `.png?` or `.gif?` or `.webp?` or `.svg?` or `.bmp?` or `.ico?`
-  - URLs from known image CDNs even without extensions
-  - URLs with image processing parameters like `width=`, `height=`, `format=`
-  - URLs with paths containing `/images/`, `/img/`, `/media/`, `/assets/`
-  - Open Graph meta tags: `<meta property="og:image" content="...">`
-  - Twitter Card images: `<meta name="twitter:image" content="...">`
-  - Schema.org image properties in JSON-LD
-  - CSS background images in style attributes
-  - Picture element with multiple source tags
-  - Images in srcset attributes with multiple resolutions
 </system>
 \n\n\n
 """
@@ -282,65 +100,16 @@ SEARCH_SELECTION = """
 - 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_name_or_title_or_article_or_tags_or_domain](source_url_or_source_link)`
+- Create a professional structured summary.
+- List each source at the end of the summary in the format [Source title](link)
 - Identify ambiguities or gaps in information
 - Ensure clarity, completeness, and high information density
-
-
-Image identification in raw content:
-- The raw HTML will contain many URLs
-- Only URLs ending with image extensions are actual images
-- Valid image extensions: `.jpg` or `.jpeg` or `.png` or `.gif` or `.webp` or `.svg` or `.bmp` or `.ico`
-- If URL doesn't end with these extensions, it's not an image
-- Don't guess or assume - only exact extension matches count
-
-
-Expanded image identification:
-- Also identify as images:
-  - URLs with image extensions before query parameters (e.g., `image.jpg?size=large`)
-  - URLs from image CDNs (cloudinary, imgur, imgix, etc.)
-  - URLs with image processing parameters (width, height, format, quality)
-  - URLs with image-related paths (/images/, /media/, /assets/)
-  - Meta tag images (og:image, twitter:image)
-  - Apply multiple validation methods to catch all legitimate images
 </system>
 \n\n\n
 """
 
 INSTRUCTIONS_END = """
-\n\n\n
 You have just executed tools and obtained results. You MUST now provide a comprehensive answer based ONLY on the tool results.
-
-
-Final image display checklist:
-- For each image URL you want to display, verify it ends with: `.jpg` or `.jpeg` or `.png` or `.gif` or `.webp` or `.svg` or `.bmp` or `.ico`
-- If it doesn't end with these extensions, do not display it as an image
-- Never display URLs without image extensions as images
-- Never render example or demonstration image URLs from instructions
-- State clearly if no valid images were found in the sources
-
-
-Expanded final image validation:
-- If URL doesn't end with standard extension, also check:
-  - Does it contain image extension before query parameters?
-  - Is it from a known image CDN or service?
-  - Does it have image processing parameters?
-  - Is the path clearly image-related?
-
-- If any of these secondary checks pass, display the image
-- When uncertain but evidence suggests it's an image, attempt to display
-- The markdown renderer will gracefully handle any non-image URLs
-
-
-Mandatory Ambiguities and Gaps reporting:
-- Every final response must include a dedicated section titled "Ambiguities, Contradictions, and Gaps".
-  - In this section, explicitly list:
-    - Conflicting claims or data points found across sources
-    - Missing evidence or areas where sources are silent
-    - Unclear or weakly supported assertions
-
-- If no ambiguities or gaps are found, you must still include the section and state no significant ambiguities, contradictions, or gaps were identified.
 \n\n\n
 """
 

src/core/web_loader.py

@@ -5,6 +5,7 @@
 
 import random
 import threading
+import time
 from collections import deque
 from config import (
     OS,
@@ -40,6 +41,7 @@ class WebLoader:
             ip = f"{octet}.{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:
@@ -49,6 +51,7 @@ class WebLoader:
             ip = ":".join(segments)
             with self.lock:
                 self.ipv6_pool.append(ip)
+            time.sleep(0.001)
             
     def generate_user_agents(self):
         os_list = OS
@@ -81,6 +84,7 @@ class WebLoader:
                 
             with self.lock:
                 self.user_agent_pool.append(ua)
+            time.sleep(0.002)
             
     def generate_origins(self):
         domains = DOMAINS
@@ -92,6 +96,7 @@ class WebLoader:
             origin = f"{protocol}{domain}"
             with self.lock:
                 self.origin_pool.append(origin)
+            time.sleep(0.002)
             
     def generate_referrers(self):
         search_engines = SEARCH_ENGINES
@@ -103,6 +108,7 @@ class WebLoader:
             referrer = f"{engine}{keyword}"
             with self.lock:
                 self.referrer_pool.append(referrer)
+            time.sleep(0.002)
             
     def generate_locations(self):
         countries = COUNTRIES
@@ -120,6 +126,7 @@ class WebLoader:
             }
             with self.lock:
                 self.location_pool.append(location)
+            time.sleep(0.002)
             
     def get_ipv4(self):
         with self.lock:

src/engine/browser_engine.py

@@ -34,7 +34,7 @@ class BrowserEngine:
             "Origin": origin,
             "Referer": referrer,
             "Accept-Language": f"{location['language']},en;q=0.9",
-            "Accept": "application/json,text/html,application/xhtml+xml,application/xml;q=0.9,image/*,*/*;q=0.8",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
             "Accept-Encoding": "gzip, deflate, br",
             "DNT": "1",
             "Connection": "keep-alive",

src/processor/response/generator.py

@@ -4,7 +4,7 @@
 #
 
 import traceback
-from config import INSTRUCTIONS_END
+from config import MAX_TOKENS, INSTRUCTIONS_END
 
 def generate_response(
     server,
@@ -16,10 +16,11 @@ def generate_response(
     response_generator = ""
     
     if tools_done:
-        conversation_messages.append({
+        system_reminder = {
             "role": "system",
             "content": INSTRUCTIONS_END
-        })
+        }
+        conversation_messages.append(system_reminder)
     
     try:
         response = server.chat.completions.create(
@@ -27,6 +28,8 @@ def generate_response(
             messages=conversation_messages,
             tools=tool_definitions if not tools_done else None,
             tool_choice="none",
+            max_tokens=MAX_TOKENS,
+            temperature=0.75,
             stream=True
         )
         

src/processor/tools/interaction.py

@@ -10,7 +10,7 @@ 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 REASONING_DELAY
+from config import MAX_TOKENS, REASONING_DELAY
 
 def process_tool_interactions(server, model_name, conversation_messages, tool_definitions, search_engine):
     maximum_iterations = 1
@@ -52,7 +52,9 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                     model=model_name,
                     messages=conversation_messages,
                     tools=tool_definitions,
-                    tool_choice="auto"
+                    tool_choice="auto",
+                    max_tokens=MAX_TOKENS,
+                    temperature=0.6
                 )
                 
                 response_choice = model_response.choices[0]