Update app.py

app.py

@@ -1,26 +1,465 @@
+from flask import Flask, request, jsonify
 import requests
+import random
+import string
+import time
 import json
 
-url = "https://api.botpress.cloud/v1/admin/workspaces"
+app = Flask(__name__)
 
-headers = {
-    "Authorization": "Bearer bp_pat_HsN5DOU9RjX2uWVwFWop76dwHDv0lHl2CKlZ",
-    "Content-Type": "application/json"
-}
+# Global variables to store workspace and bot IDs
+GLOBAL_WORKSPACE_ID = None
+GLOBAL_BOT_ID = None
 
-payload = {
-    "name": "vvfvf"
-}
 
-response = requests.post(
-    url,
-    headers=headers,
-    json=payload
-)
+# Authorization value used in requests (should be updated with a valid Authorization),
+TOKEN = "Bearer bp_pat_HsN5DOU9RjX2uWVwFWop76dwHDv0lHl2CKlZ"
+# -------------------------------------------------------------------
+# Helper functions for random bot/workspace names
+# -------------------------------------------------------------------
+def generate_random_name(length=5):
+    """Generate a random name for workspace or bot"""
+    return ''.join(random.choices(string.ascii_letters, k=length))
 
-print("Status Code:", response.status_code)
+# -------------------------------------------------------------------
+# Functions to create/delete workspaces and bots
+# -------------------------------------------------------------------
+def create_workspace():
+    """Create a new workspace and return its ID"""
+    ws_url = "https://api.botpress.cloud/v1/admin/workspaces"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": TOKEN
+    }
+    payload = {"name": generate_random_name()}
 
-try:
-    print(json.dumps(response.json(), indent=2))
-except Exception:
-    print(response.text)
+    try:
+        response = requests.post(ws_url, headers=headers, json=payload)
+        if response.status_code == 200:
+            response_json = response.json()
+            workspace_id = response_json.get('id')
+            print(f"Successfully created workspace: {workspace_id}")
+            return workspace_id
+        else:
+            print(f"Workspace creation failed with: {response.status_code}, {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error creating workspace: {str(e)}")
+        return None
+
+
+def create_bot(workspace_id):
+    """Create a new bot in the specified workspace and return its ID"""
+    if not workspace_id:
+        print("Cannot create bot: No workspace ID provided")
+        return None
+
+    bot_url = "https://api.botpress.cloud/v1/admin/bots"
+    headers = {
+        "x-workspace-id": workspace_id,
+        "Authorization": TOKEN,
+        "Content-Type": "application/json"
+    }
+    payload = {"name": generate_random_name()}
+
+    try:
+        response = requests.post(bot_url, headers=headers, json=payload)
+        if response.status_code == 200:
+            response_json = response.json()
+            bot_id = response_json.get("bot", {}).get("id")
+            if not bot_id:
+                print("Bot ID not found in the response.")
+                return None
+
+            print(f"Successfully created bot: {bot_id} in workspace: {workspace_id}")
+
+            # Install integration for the new bot
+            integration_success = install_bot_integration(bot_id, workspace_id)
+            if integration_success:
+                print(f"Successfully installed integration for bot {bot_id}")
+                return bot_id
+            else:
+                print(f"Failed to install integration for bot {bot_id}")
+                return bot_id  # Still return the bot ID even if integration fails
+        else:
+            print(f"Bot creation failed with: {response.status_code}, {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error creating bot: {str(e)}")
+        return None
+
+
+def install_bot_integration(bot_id, workspace_id):
+    """Install required integration for the bot to function properly"""
+    if not bot_id or not workspace_id:
+        print("Cannot install integration: Missing bot ID or workspace ID")
+        return False
+
+    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
+    headers = {
+        "Authorization": TOKEN,
+        "Content-Type": "application/json",
+        "x-bot-id": bot_id,
+        "x-workspace-id": workspace_id
+    }
+    # Integration payload
+    payload = {
+        "integrations": {
+            "intver_01KQABNSQ436DE5BD8Y2908R60": {
+                "enabled": True
+            }
+        }
+    }
+
+    try:
+        response = requests.put(url, headers=headers, json=payload)
+        if response.status_code == 200:
+            print(f"Successfully installed integration for bot {bot_id}")
+            return True
+        else:
+            print(f"Failed to install integration: {response.status_code}, {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error installing integration: {str(e)}")
+        return False
+
+
+def try_delete_bot(bot_id, workspace_id):
+    """Attempt to delete a bot from the specified workspace but continue if it fails"""
+    if not bot_id or not workspace_id:
+        print("Cannot delete bot: Missing bot ID or workspace ID")
+        return False
+
+    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
+    headers = {
+        "x-workspace-id": workspace_id,
+        "Authorization": TOKEN
+    }
+
+    try:
+        response = requests.delete(url, headers=headers)
+        if response.status_code in [200, 204]:
+            print(f"Successfully deleted bot: {bot_id}")
+            return True
+        else:
+            print(f"Failed to delete bot: {response.status_code}, {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error deleting bot: {str(e)}")
+        return False
+
+
+def try_delete_workspace(workspace_id):
+    """Attempt to delete a workspace but continue if it fails"""
+    if not workspace_id:
+        print("Cannot delete workspace: No workspace ID provided")
+        return False
+
+    url = f"https://api.botpress.cloud/v1/admin/workspaces/{workspace_id}"
+    headers = {
+        "Authorization": TOKEN
+    }
+
+    try:
+        response = requests.delete(url, headers=headers)
+        if response.status_code in [200, 204]:
+            print(f"Successfully deleted workspace: {workspace_id}")
+            return True
+        else:
+            print(f"Failed to delete workspace: {response.status_code}, {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error deleting workspace: {str(e)}")
+        return False
+
+
+# -------------------------------------------------------------------
+# Main function that calls the Botpress API endpoint
+# -------------------------------------------------------------------
+def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperature=0.9, top_p=0.95, max_tokens=None):
+    """
+    Sends the user input and chat history to the Botpress API endpoint,
+    returns the assistant's response and (possibly updated) bot/workspace IDs.
+    """
+    # Prepare the headers
+    headers = {
+        "x-bot-id": bot_id,
+        "Content-Type": "application/json",
+        "Authorization": TOKEN
+    }
+
+    # 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"]
+        elif msg["role"] in ["user", "assistant"]:
+            # Pass multipart messages directly without modifying their structure
+            if "type" in msg and msg["type"] == "multipart" and "content" in msg:
+                messages.append(msg)  # Keep the original multipart structure
+            # Handle regular text messages
+            else:
+                messages.append({
+                    "role": msg["role"],
+                    "content": msg["content"]
+                })
+
+    # Add the latest user input if not already in chat history
+    if user_input and isinstance(user_input, str) and (not messages or messages[-1]["role"] != "user" or messages[-1]["content"] != user_input):
+        messages.append({
+            "role": "user",
+            "content": user_input
+        })
+
+    # Prepare the payload for the API
+    payload = {
+        "type": "anthropic:generateContent",
+        "input": {
+            "model": {
+                "id": "claude-opus-4-7"
+            },
+            "systemPrompt": system_prompt,
+            "messages": messages,
+            "debug": False,
+        }
+    }
+
+    # 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
+
+    # For debugging
+    print("Payload being sent to Botpress:")
+    print(json.dumps(payload, indent=2))
+
+    # 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}")
+            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
+
+            # Check for authentication or permission errors (401, 403)
+            elif response.status_code in [401, 403]:
+                error_message = "Authentication error"
+                try:
+                    error_data = response.json()
+                    error_message = error_data.get('message', 'Authentication error')
+                except:
+                    pass
+
+                print(f"Authentication error detected: {error_message}")
+
+                # We need to create new resources immediately
+                print("Creating new workspace and bot...")
+                new_workspace_id = create_workspace()
+                if not new_workspace_id:
+                    print("Failed to create a new workspace")
+                    if attempt < max_retries - 1:
+                        time.sleep(3)
+                        continue
+                    else:
+                        return "Unable to create new resources. Please try again later.", bot_id, workspace_id
+
+                new_bot_id = create_bot(new_workspace_id)
+                if not new_bot_id:
+                    print("Failed to create a new bot")
+                    if attempt < max_retries - 1:
+                        time.sleep(3)
+                        continue
+                    else:
+                        return "Unable to create new bot. Please try again later.", new_workspace_id, workspace_id
+
+                print(f"Created new workspace: {new_workspace_id} and bot: {new_bot_id}")
+
+                # Try again with new IDs
+                headers["x-bot-id"] = new_bot_id
+                try:
+                    print(f"Retrying with new bot_id={new_bot_id}")
+                    retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
+
+                    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")
+
+                        # Try to clean up old resources in the background, but don't wait for result
+                        if bot_id and workspace_id:
+                            print(f"Attempting to clean up old resources in the background")
+                            try_delete_bot(bot_id, workspace_id)
+                            try_delete_workspace(workspace_id)
+
+                        return assistant_content, new_bot_id, new_workspace_id
+                    else:
+                        print(f"Failed with new IDs: {retry_response.status_code}")
+                        if attempt < max_retries - 1:
+                            time.sleep(2)
+                            continue
+                        else:
+                            return f"Unable to get a response even with new credentials.", new_bot_id, new_workspace_id
+
+                except Exception as e:
+                    print(f"Error with new IDs: {str(e)}")
+                    if attempt < max_retries - 1:
+                        time.sleep(2)
+                        continue
+                    else:
+                        return f"Error with new credentials: {str(e)}", new_bot_id, new_workspace_id
+
+            # Handle network errors or timeouts (just retry)
+            elif response.status_code in [404, 408, 502, 503, 504]:
+                print(f"Received error {response.status_code}. Retrying...")
+                time.sleep(3)  # Wait before retrying
+                continue
+
+            # Any other error status code
+            else:
+                print(f"Received unexpected error: {response.status_code}, {response.text}")
+                if attempt < max_retries - 1:
+                    time.sleep(2)
+                    continue
+                else:
+                    return f"Unable to get a response from the assistant (Error {response.status_code}).", bot_id, workspace_id
+
+        except requests.exceptions.Timeout:
+            print(f"Request timed out. Retrying...")
+            if attempt < max_retries - 1:
+                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
+
+        except Exception as e:
+            print(f"Error during request: {str(e)}")
+            if attempt < max_retries - 1:
+                time.sleep(2)
+                continue
+            else:
+                return f"Unable to get a response from the assistant: {str(e)}", bot_id, 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
+
+
+# -------------------------------------------------------------------
+# Flask Endpoint
+# -------------------------------------------------------------------
+@app.route("/chat", methods=["POST"])
+def chat_endpoint():
+    """
+    Expects JSON with:
+    {
+      "user_input": "string", // Can be null if multipart message is in chat_history
+      "chat_history": [
+         {"role": "system", "content": "..."},
+         {"role": "user",   "content": "..."},
+         // Or for images:
+         {"role": "user", "type": "multipart", "content": [
+            {"type": "image", "url": "https://example.com/image.jpg"},
+            {"type": "text", "text": "What's in this image?"}
+         ]},
+         ...
+      ],
+      "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"
+    }
+    """
+    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", [])
+
+    # 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 temperature and top_p values
+    try:
+        temperature = float(temperature)
+        if not 0 <= temperature <= 2:
+            temperature = 0.9
+            print(f"Invalid temperature value. Using default: {temperature}")
+    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
+
+    # If we don't yet have a workspace or bot, create them
+    if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
+        print("No existing IDs found. Creating new workspace and bot...")
+        GLOBAL_WORKSPACE_ID = create_workspace()
+        if GLOBAL_WORKSPACE_ID:
+            GLOBAL_BOT_ID = create_bot(GLOBAL_WORKSPACE_ID)
+
+        # 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
+
+    # 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}")
+
+    assistant_response, updated_bot_id, updated_workspace_id = chat_with_assistant(
+        user_input,
+        chat_history,
+        GLOBAL_BOT_ID,
+        GLOBAL_WORKSPACE_ID,
+        temperature,
+        top_p,
+        max_tokens
+    )
+
+    # Update global IDs if they changed
+    if updated_bot_id != GLOBAL_BOT_ID or updated_workspace_id != GLOBAL_WORKSPACE_ID:
+        print(f"Updating global IDs: bot_id={updated_bot_id}, workspace_id={updated_workspace_id}")
+        GLOBAL_BOT_ID = updated_bot_id
+        GLOBAL_WORKSPACE_ID = updated_workspace_id
+
+    return jsonify({"assistant_response": assistant_response})
+
+
+# -------------------------------------------------------------------
+# Run the Flask app
+# -------------------------------------------------------------------
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=True)