app.py

from flask import Flask, request, jsonify
import requests
import random
import string
import time
import json

app = Flask(__name__)

# Global variables to store workspace and bot IDs
GLOBAL_WORKSPACE_ID = None
GLOBAL_BOT_ID = None


# Authorization value used in requests (should be updated with a valid Authorization),
TOKEN = "Bearer bp_pat_WZQdxRvCHeUMbn9ssYa1PoOoQXsQ0czWOzTK"
# -------------------------------------------------------------------
# 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))

# -------------------------------------------------------------------
# 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 = {
        "User-Agent": "Mozilla/5.0",
        "Authorization": TOKEN
    }
    payload = {"name": generate_random_name()}

    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 = {
        "User-Agent": "Mozilla/5.0",
        "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 = {
        "User-Agent": "Mozilla/5.0",
        "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 = {
        "User-Agent": "Mozilla/5.0",
        "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 = {
        "User-Agent": "Mozilla/5.0",
        "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 = {
        "User-Agent": "Mozilla/5.0",
        "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)