Update app.py

app.py

@@ -177,13 +177,27 @@ def delete_workspace(workspace_id):
 
 
 # -------------------------------------------------------------------
-# Main function that calls the Botpress API endpoint
+# Web Search Function
 # -------------------------------------------------------------------
-def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperature=0.9, top_p=0.95, max_tokens=None):
+def web_search(query, count=3, include_sites=None, exclude_sites=None, bot_id=None, workspace_id=None):
     """
-    Sends the user input and chat history to the Botpress API endpoint,
-    returns the assistant's response and (possibly updated) bot/workspace IDs.
+    Performs a web search using the Botpress API
+
+    Args:
+        query (str): The search query
+        count (int): Number of search results to return
+        include_sites (list): List of sites to include in the search
+        exclude_sites (list): List of sites to exclude from the search
+        bot_id (str): The bot ID to use for the request
+        workspace_id (str): The workspace ID to use for the request
+
+    Returns:
+        tuple: (search_results, bot_id, workspace_id)
     """
+    if not bot_id or not workspace_id:
+        print("Cannot perform search: Missing bot ID or workspace ID")
+        return {"error": "Missing bot ID or workspace ID"}, bot_id, workspace_id
+
     # Prepare the headers
     headers = {
         "User-Agent": "Mozilla/5.0",
@@ -192,49 +206,24 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
         "Cookie": AUTH_COOKIE
     }
 
-    # Process chat history into the format expected by the API
-    messages = []
-    system_prompt = ""
-    for msg in chat_history:
-        if msg["role"] == "system":
-            system_prompt = msg["content"]
-        else:
-            messages.append({
-                "role": msg["role"],
-                "content": msg["content"],
-                "type": "text"
-            })
-
-    # Add the latest user input if not already in chat history
-    if user_input and (not messages or messages[-1]["role"] != "user" or messages[-1]["content"] != user_input):
-        messages.append({
-            "role": "user",
-            "content": user_input,
-            "type": "text"
-        })
+    # Prepare include/exclude sites
+    include_sites = include_sites or []
+    exclude_sites = exclude_sites or []
 
     # Prepare the payload for the API
     payload = {
-        "type": "openai:generateContent",
+        "type": "browser:webSearch",
         "input": {
-            "model": {
-                "id": "gpt-4.1-2025-04-14"
-            },
-            "systemPrompt": system_prompt,
-            "messages": messages,
-            "temperature": temperature,
-            
-            "debug": False,
+            "query": query,
+            "includeSites": include_sites,
+            "excludeSites": exclude_sites,
+            "count": count
         }
     }
 
-    # Add maxTokens to the payload if provided
-    if max_tokens is not None:
-        payload["input"]["maxTokens"] = max_tokens
-
     botpress_url = "https://api.botpress.cloud/v1/chat/actions"
     max_retries = 3
-    timeout = 120  # Increased timeout for long messages
+    timeout = 60
 
     # Flag to track if we need to create new IDs due to quota exceeded
     quota_exceeded = False
@@ -242,15 +231,14 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
     # Attempt to send the request
     for attempt in range(max_retries):
         try:
-            print(f"Attempt {attempt+1}: Sending request to Botpress API with bot_id={bot_id}, workspace_id={workspace_id}")
+            print(f"Attempt {attempt+1}: Sending search request to Botpress API with bot_id={bot_id}, workspace_id={workspace_id}")
             response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
 
             # If successful (200)
             if response.status_code == 200:
                 data = response.json()
-                assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                print(f"Successfully received response from Botpress API")
-                return assistant_content, bot_id, workspace_id
+                print(f"Successfully received search results from Botpress API")
+                return data, bot_id, workspace_id
 
             # Check for quota exceeded error specifically
             elif response.status_code == 403:
@@ -268,7 +256,7 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
                         time.sleep(2)
                         continue
                     else:
-                        return f"Unable to get a response from the assistant (Error 403).", bot_id, workspace_id
+                        return {"error": f"Unable to get search results (Error 403)."}, bot_id, workspace_id
 
             # Handle network errors or timeouts (just retry)
             elif response.status_code in [404, 408, 502, 503, 504]:
@@ -283,7 +271,7 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
                     time.sleep(2)
                     continue
                 else:
-                    return f"Unable to get a response from the assistant (Error {response.status_code}).", bot_id, workspace_id
+                    return {"error": f"Unable to get search results (Error {response.status_code})."}, bot_id, workspace_id
 
         except requests.exceptions.Timeout:
             print(f"Request timed out. Retrying...")
@@ -291,7 +279,7 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
                 time.sleep(2)
                 continue
             else:
-                return "The assistant is taking too long to respond. Please try again with a shorter message.", bot_id, workspace_id
+                return {"error": "The search request timed out. Please try again."}, bot_id, workspace_id
 
         except Exception as e:
             print(f"Error during request: {str(e)}")
@@ -299,7 +287,7 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
                 time.sleep(2)
                 continue
             else:
-                return f"Unable to get a response from the assistant: {str(e)}", bot_id, workspace_id
+                return {"error": f"Unable to get search results: {str(e)}"}, bot_id, workspace_id
 
     # If quota exceeded, we need to create new resources
     if quota_exceeded:
@@ -328,12 +316,12 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
         # Create new workspace
         new_workspace_id = create_workspace()
         if not new_workspace_id:
-            return "Failed to create a new workspace after quota exceeded. Please try again later.", bot_id, workspace_id
+            return {"error": "Failed to create a new workspace after quota exceeded. Please try again later."}, bot_id, workspace_id
 
         # Create new bot in the new workspace
         new_bot_id = create_bot(new_workspace_id)
         if not new_bot_id:
-            return "Failed to create a new bot after quota exceeded. Please try again later.", new_workspace_id, workspace_id
+            return {"error": "Failed to create a new bot after quota exceeded. Please try again later."}, new_workspace_id, workspace_id
 
         # Update headers with new bot ID
         headers["x-bot-id"] = new_bot_id
@@ -345,85 +333,58 @@ def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperat
 
             if retry_response.status_code == 200:
                 data = retry_response.json()
-                assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                print(f"Successfully received response with new IDs")
-                return assistant_content, new_bot_id, new_workspace_id
+                print(f"Successfully received search results with new IDs")
+                return data, new_bot_id, new_workspace_id
             else:
                 print(f"Failed with new IDs: {retry_response.status_code}, {retry_response.text}")
-                return f"Unable to get a response from the assistant with new credentials.", new_bot_id, new_workspace_id
+                return {"error": f"Unable to get search results with new credentials."}, new_bot_id, new_workspace_id
 
         except Exception as e:
             print(f"Error with new IDs: {str(e)}")
-            return f"Unable to get a response from the assistant with new credentials: {str(e)}", new_bot_id, new_workspace_id
+            return {"error": f"Unable to get search results with new credentials: {str(e)}"}, new_bot_id, new_workspace_id
 
     # Should not reach here due to the handling in the loop
-    return "Unable to get a response from the assistant.", bot_id, workspace_id
+    return {"error": "Unable to get search results."}, bot_id, workspace_id
 
 
 # -------------------------------------------------------------------
-# Flask Endpoint
+# Flask Endpoints
 # -------------------------------------------------------------------
-@app.route("/chat", methods=["POST"])
-def chat_endpoint():
+@app.route("/search", methods=["POST"])
+def search_endpoint():
     """
+    Endpoint for web search.
     Expects JSON with:
     {
-      "user_input": "string",
-      "chat_history": [
-         {"role": "system", "content": "..."},
-         {"role": "user",   "content": "..."},
-         ...
-      ],
-      "temperature": 0.9,  // Optional, defaults to 0.9
-      "top_p": 0.95,       // Optional, defaults to 0.95
-      "max_tokens": 1000   // Optional, defaults to null (no limit)
-    }
-    Returns JSON with:
-    {
-      "assistant_response": "string"
+      "query": "search query",
+      "count": 3,                // Optional, defaults to 3
+      "include_sites": [],       // Optional, defaults to empty list
+      "exclude_sites": []        // Optional, defaults to empty list
     }
+    Returns the raw search results JSON from the Botpress API
     """
     global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
 
     # Parse JSON from request
     data = request.get_json(force=True)
-    user_input = data.get("user_input", "")
-    chat_history = data.get("chat_history", [])
+    query = data.get("query", "")
+    count = data.get("count", 3)
+    include_sites = data.get("include_sites", [])
+    exclude_sites = data.get("exclude_sites", [])
 
-    # Get temperature, top_p, and max_tokens from request, or use defaults
-    temperature = data.get("temperature", 0.9)
-    top_p = data.get("top_p", 0.95)
-    max_tokens = data.get("max_tokens", None)
+    # Validate query
+    if not query:
+        return jsonify({"error": "Query parameter is required"}), 400
 
-    # Validate temperature and top_p values
+    # Validate count
     try:
-        temperature = float(temperature)
-        if not 0 <= temperature <= 2:
-            temperature = 0.9
-            print(f"Invalid temperature value. Using default: {temperature}")
+        count = int(count)
+        if count <= 0:
+            count = 3
+            print(f"Invalid count value. Using default: {count}")
     except (ValueError, TypeError):
-        temperature = 0.9
-        print(f"Invalid temperature format. Using default: {temperature}")
-
-    try:
-        top_p = float(top_p)
-        if not 0 <= top_p <= 1:
-            top_p = 0.95
-            print(f"Invalid top_p value. Using default: {top_p}")
-    except (ValueError, TypeError):
-        top_p = 0.95
-        print(f"Invalid top_p format. Using default: {top_p}")
-
-    # Validate max_tokens if provided
-    if max_tokens is not None:
-        try:
-            max_tokens = int(max_tokens)
-            if max_tokens <= 0:
-                print("Invalid max_tokens value (must be positive). Not using max_tokens.")
-                max_tokens = None
-        except (ValueError, TypeError):
-            print("Invalid max_tokens format. Not using max_tokens.")
-            max_tokens = None
+        count = 3
+        print(f"Invalid count format. Using default: {count}")
 
     # If we don't yet have a workspace or bot, create them
     if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
@@ -434,20 +395,19 @@ def chat_endpoint():
 
         # If creation failed
         if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-            return jsonify({"assistant_response": "I'm currently unavailable. Please try again later."}), 500
+            return jsonify({"error": "Failed to initialize search capability. Please try again later."}), 500
 
-    # Call our function that interacts with Botpress API
-    print(f"Sending chat request with existing bot_id={GLOBAL_BOT_ID}, workspace_id={GLOBAL_WORKSPACE_ID}")
-    print(f"Using temperature={temperature}, top_p={top_p}, max_tokens={max_tokens}")
+    # Call our search function
+    print(f"Sending search request with query='{query}', count={count}")
+    print(f"Using existing bot_id={GLOBAL_BOT_ID}, workspace_id={GLOBAL_WORKSPACE_ID}")
 
-    assistant_response, updated_bot_id, updated_workspace_id = chat_with_assistant(
-        user_input,
-        chat_history,
+    search_results, updated_bot_id, updated_workspace_id = web_search(
+        query,
+        count,
+        include_sites,
+        exclude_sites,
         GLOBAL_BOT_ID,
-        GLOBAL_WORKSPACE_ID,
-        temperature,
-        top_p,
-        max_tokens
+        GLOBAL_WORKSPACE_ID
     )
 
     # Update global IDs if they changed
@@ -456,7 +416,8 @@ def chat_endpoint():
         GLOBAL_BOT_ID = updated_bot_id
         GLOBAL_WORKSPACE_ID = updated_workspace_id
 
-    return jsonify({"assistant_response": assistant_response})
+    # Return the raw API response
+    return jsonify(search_results)
 
 
 # -------------------------------------------------------------------