SearchGPT: Enhance. #5

config.py

@@ -8,76 +8,173 @@
 
 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 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`:  
+    - You must first execute `web_search` then `read_url`.  
+
+  - If using read_url directly:  
+    - You only need to execute `read_url`.  
+
+- Note: This applies to all queries and all requests.
+
 
 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.  
+- 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.
+- 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.  
+   - 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 `read_url` for each retrieved URLs or links to obtain images.
 
 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.
+   - Prioritize authoritative sources including academic publications, institutional reports, official documents, and 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.
+   - Extract key elements including facts, statistics, data points, expert opinions, and relevant arguments.
+   - Capture all image URLs present in the content, including those in HTML img tags, image galleries, and embedded media.
    - 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.
+   - Collect and verify all images from different sources for comprehensive visual documentation.
 
 5. Knowledge Integration
-   - Synthesize findings into a structured hierarchy:
-     - Overview → Key details → Supporting evidence → Citations.
+   - Synthesize findings into a structured hierarchy from overview to key details to supporting evidence to citations.
    - Emphasize the latest developments, trends, and their implications.
-   - Balance depth (for experts) with clarity (for general readers).
+   - 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 cite sources inline using `[Source Name/Title/Article/Tags/Domain](source_url_or_source_link)`.
+   - Display 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.
+   - Use clear formatting with headings, numbered lists, and bullet points.
    - Ensure readability, logical progression, and accessibility.
+   - Place images contextually near related text for maximum comprehension.
 
-7. Ambiguity & Uncertainty Handling
+7. Ambiguity and 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.  
+8. Quality and 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 them using markdown.
+
+
+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
+
 
 Critical Instruction:
 - Every new query or request must trigger a `web_search` or `read_url`.
 - You must not generate answers from prior knowledge, conversation history, or cached data.
-- Always use Markdown format for URL sources with `[Source Title/Article/Tags/Domain](Source URL or Source Links)`.
+- Always use Markdown format for URL sources with `[Source Name/Title/Article/Tags/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 to provide visual context and enhance understanding.
 - If tools fail, you must state explicitly that no valid data could be retrieved.
+- Never render example image URLs provided in instructions.
 \n\n\n
 """
 
@@ -89,8 +186,21 @@ CONTENT_EXTRACTION = """
 - Evaluate credibility of sources, highlight potential biases or conflicts
 - Produce a structured, professional, and comprehensive summary
 - Emphasize clarity, accuracy, and logical flow
-- Include all discovered URLs in the final summary as [Source Title](URL)
+- Include all discovered URLs in the final summary as `[Source Name/Title/Article/Tags/Domain](source_url_or_source_link)`
 - Mark any uncertainties, contradictions, or missing information clearly
+
+
+Image extraction from raw HTML:
+- 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="..." />`
+
+- Remember: URL must end with image extension to be valid
 </system>
 \n\n\n
 """
@@ -100,16 +210,33 @@ 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 title](link)
+- Create a professional structured summary
+- List each source at the end of the summary in the format `[Source Name/Title/Article/Tags/Domain](source_url_or_source_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
 </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
 \n\n\n
 """
 

src/core/web_loader.py

@@ -5,7 +5,6 @@
 
 import random
 import threading
-import time
 from collections import deque
 from config import (
     OS,
@@ -41,7 +40,6 @@ 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:
@@ -51,7 +49,6 @@ 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
@@ -84,7 +81,6 @@ class WebLoader:
                 
             with self.lock:
                 self.user_agent_pool.append(ua)
-            time.sleep(0.002)
             
     def generate_origins(self):
         domains = DOMAINS
@@ -96,7 +92,6 @@ 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
@@ -108,7 +103,6 @@ class WebLoader:
             referrer = f"{engine}{keyword}"
             with self.lock:
                 self.referrer_pool.append(referrer)
-            time.sleep(0.002)
             
     def generate_locations(self):
         countries = COUNTRIES
@@ -126,7 +120,6 @@ 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": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+            "Accept": "application/json,text/html,application/xhtml+xml,application/xml;q=0.9,image/*,*/*;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 MAX_TOKENS, INSTRUCTIONS_END
+from config import INSTRUCTIONS_END
 
 def generate_response(
     server,
@@ -16,11 +16,10 @@ def generate_response(
     response_generator = ""
     
     if tools_done:
-        system_reminder = {
+        conversation_messages.append({
             "role": "system",
             "content": INSTRUCTIONS_END
-        }
-        conversation_messages.append(system_reminder)
+        })
     
     try:
         response = server.chat.completions.create(
@@ -28,8 +27,6 @@ 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 MAX_TOKENS, REASONING_DELAY
+from config import REASONING_DELAY
 
 def process_tool_interactions(server, model_name, conversation_messages, tool_definitions, search_engine):
     maximum_iterations = 1
@@ -52,9 +52,7 @@ def process_tool_interactions(server, model_name, conversation_messages, tool_de
                     model=model_name,
                     messages=conversation_messages,
                     tools=tool_definitions,
-                    tool_choice="auto",
-                    max_tokens=MAX_TOKENS,
-                    temperature=0.6
+                    tool_choice="auto"
                 )
                 
                 response_choice = model_response.choices[0]