Update app.py

app.py

@@ -1,577 +1,273 @@
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, session
 import requests
-import random
-import string
+import json
 import time
 import os
-import json
-from datetime import datetime, timedelta
+import uuid
+import threading
+import base64
+from flask_cors import CORS
+from flask_session import Session
 
 app = Flask(__name__)
+CORS(app)
+
+# Configure server-side session
+app.config["SECRET_KEY"] = os.urandom(24)
+app.config["SESSION_TYPE"] = "filesystem"
+app.config["SESSION_PERMANENT"] = True
+Session(app)
+
+# Global variables
+UPLOAD_FOLDER = 'temp_audio'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# API endpoints and headers
+TTS_API_URL = "https://nanoxbot-voice.hf.space/synthesize"
+TTS_HEADERS = {"Content-Type": "application/json"}
+TTS_VOICE_ID = "PVL:db1ba8fe-9c80-4c13-b8b0-32c8163a581e"  # Ana de Armas voice
+
+STT_API_BASE_URL = "https://corvo-ai-transcript.hf.space"
+STT_AUTH_COOKIE = "spaces-jwt=eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sIm9uQmVoYWxmT2YiOnsia2luZCI6InVzZXIiLCJfaWQiOiI2NzQ2ZTcwYzQ5MGM3M2EwOTdiMzBiMTAiLCJ1c2VyIjoiQ09SVk8tQUkiLCJzZXNzaW9uSWQiOiI2NzQ2ZTcwYzQ5MGM3M2EwOTdiMzBiMWQifSwiaWF0IjoxNzQ3NjUxMzk2LCJzdWIiOiIvc3BhY2VzL0NPUlZPLUFJL3RyYW5zY3JpcHQiLCJleHAiOjE3NDc3Mzc3OTYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.yuFQOp57OzdyNw8GsJ7MUgxUTaaXPQKUWbW72LmxE3NYwC0wbSl2zvs9LB8lC8dLNwmrDd8GckhTMJIfCgMVAQ"
+STT_HEADERS = {"Cookie": STT_AUTH_COOKIE}
+
+AI_API_URL = "https://corvo-ai-xx-xy.hf.space/chat"
+AI_HEADERS = {
+    "Content-Type": "application/json",
+    "cookie": "spaces-jwt=eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sIm9uQmVoYWxmT2YiOnsia2luZCI6InVzZXIiLCJfaWQiOiI2NzQ2ZTcwYzQ5MGM3M2EwOTdiMzBiMTAiLCJ1c2VyIjoiQ09SVk8tQUkiLCJzZXNzaW9uSWQiOiI2NzQ2ZTcwYzQ5MGM3M2EwOTdiMzBiMWQifSwiaWF0IjoxNzQ3NTc5NjM0LCJzdWIiOiIvc3BhY2VzL0NPUlZPLUFJL1hYLVhZIiwiZXhwIjoxNzQ3NjY2MDM0LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.Yl67KHhOYDmY6atPWO01Q3sRNhal8BGWhgR8dR-CJGSTFKODs41GrB-_THHyuafodCnEb0_Yf5QnGltCsvUwBw"
+}
+
+# Helper function for thinking animation (not used in API but kept for reference)
+def thinking_animation():
+    for _ in range(3):
+        print(".", end="", flush=True)
+        time.sleep(0.5)
+    print("\r", end="", flush=True)
+
+# AI text generation function
+def gpt4o_ai(user_input, chat_history, username):
+    """Function to interact with the AI API in a chat format"""
+
+    # Format chat history with roles
+    formatted_chat_history = []
+    for entry in chat_history:
+        formatted_chat_history.append({"role": entry['role'], "content": entry['content']})
+
+    # Append the current user input to the chat history
+    formatted_chat_history.append({"role": "user", "content": f"{username}: {user_input}"})
 
-# Global variables to store workspace and bot IDs
-GLOBAL_WORKSPACE_ID = None
-GLOBAL_BOT_ID = None
-
-# Cookie value used in requests (should be updated with a valid cookie)
-AUTH_COOKIE = "pscd=try.botpress.com; _hjSessionUser_2931810=eyJpZCI6ImQ2MGMzYjhkLTlkMjQtNTA0OS1hMzlmLWEzNmI0NzA0NzUxNCIsImNyZWF0ZWQiOjE3MzU3MTg0MDcwNTAsImV4aXN0aW5nIjp0cnVlfQ==; hubspotutk=75739411a4d011b2164c4f3d944ecb94; intercom-device-id-bjzkw2xf=afd0a36b-b229-44e3-828e-60483c80c10c; _hjSessionUser_3339867=eyJpZCI6IjU4ODlmMTY4LWRkNGEtNTJhZS1hZTUzLWZlYWQwM2ZmMTVjNyIsImNyZWF0ZWQiOjE3MzU3MTg1ODM4MDgsImV4aXN0aW5nIjp0cnVlfQ==; __hstc=59821234.75739411a4d011b2164c4f3d944ecb94.1735718442141.1746194848836.1746538539919.88; mp_1195923e954ce61d822842b5832047cd_mixpanel=%7B%22distinct_id%22%3A%20%22d403ad7b-ea73-4d29-b977-5fd95afd585c%22%2C%22%24device_id%22%3A%20%22d403ad7b-ea73-4d29-b977-5fd95afd585c%22%2C%22%24initial_referrer%22%3A%20%22https%3A%2F%2Fapp.botpress.cloud%2F%22%2C%22%24initial_referring_domain%22%3A%20%22app.botpress.cloud%22%2C%22__mps%22%3A%20%7B%7D%2C%22__mpso%22%3A%20%7B%22%24initial_referrer%22%3A%20%22https%3A%2F%2Fapp.botpress.cloud%2F%22%2C%22%24initial_referring_domain%22%3A%20%22app.botpress.cloud%22%7D%2C%22__mpus%22%3A%20%7B%7D%2C%22__mpa%22%3A%20%7B%7D%2C%22__mpu%22%3A%20%7B%7D%2C%22__mpr%22%3A%20%5B%5D%2C%22__mpap%22%3A%20%5B%5D%2C%22%24user_id%22%3A%20%22d403ad7b-ea73-4d29-b977-5fd95afd585c%22%7D; intercom-session-bjzkw2xf=TTdnZGNWUC9xNXMreE80NXhRZFNZS0pyUEdsbkJRc2JMcXdGZmcveVRPYkxZTmVnVnhqMUhJTWlDcEpVcWljeDZVYVVSblN4YnV5S0xBdWxDd2swQjZiaUZTeWl5M1psRmtoUWJwUU9FSFE9LS1Bay9zNldJTmVhUFdwMFNReFRmcXB3PT0=--68abc5394d7aab99748f3e451637cab5d9152a4c; _ga=GA1.2.1726154447.1735718383; _gid=GA1.2.1619749406.1746821934; _gat_UA-226900660-1=1; _gat_UA-226900660-2=1; _ga_W6YT9YSNLH=GS2.2.s1746821948$o89$g0$t1746821948$j0$l0$h0; _ga_CYSS87Q508=GS2.2.s1746821949$o89$g0$t1746821949$j0$l0$h0; _hjSession_2931810=eyJpZCI6IjA1YTlkMzY3LWNiZWEtNGQ3OC04YzNiLTEzNTFjNjkxYzViZSIsImMiOjE3NDY4MjE5NTU2NjYsInMiOjAsInIiOjAsInNiIjowLCJzciI6MCwic2UiOjAsImZzIjowLCJzcCI6MH0=; _ga_PCC6TBWJY6=GS2.1.s1746821926$o120$g1$t1746821960$j0$l0$h0; _ga_HKHSWES9V9=GS2.1.s1746821929$o120$g1$t1746821960$j29$l0$h193244206; csrf_token_bd9ac21c34b9f0915e733c3e5305d737d0722c1168be7376b889426b5ec2a298=pIDxu4npODUGEpo7JHVQrKZ4GFaa3U+3BpgxaV5hcVw=; ory_kratos_session=MTc0NjgyMjAyOHxfUmdMaVlTQXVfSmxlT1lJSGpyU2FhbjVUTHg0R0ZsQWgtVm00M3pHcXZwVG9yNW1qRDJheUFGaFZvNmFEUVdBOThQR014RjJJbmhUMmhIV1I1ME5UVHZkTDNpMUMtQlRjZ1ZTbE55M19Pb2dHTF9vQlJoSGlBQnRRWUp0M1ZUdnVvcENLeVhOTllWNk1zMk11bFVPOWFrTzJMTTdxMmVteUozVVRDMWE5TVIxbDgzU3dUY2VQaDBRWDN4bDJUVm8yUkZQa19sb09GbzlFZHF2MDFQcVR6bVVWVVpDLXVoQ1lXMEh2LV9Sd2VNZXM1cjM4TGZPVTJqdW5xNTBETTBDYkppU0xNU2xicUk3Z2EyMnFkVmdyQT09fEYiv7pXcfXVnpIFi4JLGgDObQAchyJCoAwGDSkFkoX7; ajs_user_id=d403ad7b-ea73-4d29-b977-5fd95afd585c; ajs_anonymous_id=cda6139d-cb82-4906-bfac-adaea115b097"
-
-# -------------------------------------------------------------------
-# 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",
-        "Cookie": AUTH_COOKIE
+    payload = {
+        "chat_history": formatted_chat_history
     }
-    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
+    max_retries = 5
+    retry_delay = 10
+    timeout = 600
 
+    for attempt in range(max_retries):
+        try:
+            print("AI THINKING...")
+            response = requests.post(AI_API_URL, headers=AI_HEADERS, data=json.dumps(payload), timeout=timeout)
+            response.raise_for_status()
+            assistant_response = response.json().get("assistant_response", "No response received.")
+
+            # Append the assistant's response to the chat history
+            formatted_chat_history.append({"role": "assistant", "content": assistant_response})
+            return assistant_response, formatted_chat_history
+        except requests.exceptions.Timeout:
+            print(f"Timeout on attempt {attempt + 1}, retrying...")
+            time.sleep(retry_delay)
+        except Exception as e:
+            print(f"Error on attempt {attempt + 1}: {e}, retrying...")
+            time.sleep(retry_delay)
 
-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
+    return "Error processing request. Please try again.", formatted_chat_history
 
-    bot_url = "https://api.botpress.cloud/v1/admin/bots"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Cookie": AUTH_COOKIE,
-        "Content-Type": "application/json"
+# Text-to-Speech function
+def text_to_speech(text):
+    """Convert text to speech using the TTS API"""
+    payload = {
+        "text": text,
+        "voice_id": TTS_VOICE_ID
     }
-    payload = {"name": generate_random_name()}
 
     try:
-        response = requests.post(bot_url, headers=headers, json=payload)
+        response = requests.post(TTS_API_URL, headers=TTS_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
+            # Return the audio content as base64
+            return base64.b64encode(response.content).decode('utf-8')
         else:
-            print(f"Bot creation failed with: {response.status_code}, {response.text}")
+            print(f"Error getting TTS audio: {response.status_code}")
             return None
     except Exception as e:
-        print(f"Error creating bot: {str(e)}")
+        print(f"Error in TTS API call: {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",
-        "Cookie": AUTH_COOKIE,
-        "Content-Type": "application/json",
-        "x-bot-id": bot_id,
-        "x-workspace-id": workspace_id
-    }
-    # Integration payload
-    payload = {
-        "integrations": {
-            "intver_01JSERFV00FYHW4SM6TEKZ9RWS": {
-                "enabled": True
-            }
-        }
-    }
-
+# Speech-to-Text function
+def speech_to_text(audio_file_path):
+    """Convert speech to text using the STT API"""
     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 delete_bot(bot_id, workspace_id):
-    """Delete a bot from the specified workspace"""
-    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,
-        "Cookie": AUTH_COOKIE
-    }
-
-    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 delete_workspace(workspace_id):
-    """Delete a workspace"""
-    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",
-        "Cookie": AUTH_COOKIE
-    }
-
-    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
-
-
-# -------------------------------------------------------------------
-# Function to upload audio file and get URL
-# -------------------------------------------------------------------
-def upload_audio_file(file_path, bot_id, workspace_id):
-    """Upload an audio file and return its URL"""
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # API endpoint
-    url = "https://api.botpress.cloud/v1/files"
-
-    # Get file name from path
-    file_name = os.path.basename(file_path)
-
-    # Get file size
-    file_size = os.path.getsize(file_path)
-
-    # Get file content type
-    content_type = "audio/mpeg"
-
-    # Calculate expiration date (3 days from now) with proper timezone format
-    now = datetime.now()
-    expires_at = (now + timedelta(days=3)).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "+02:00"
-
-    # Prepare headers
-    headers = {
-        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-        "x-bot-id": bot_id,
-        "x-workspace-id": workspace_id,
-        "Content-Type": "application/json",
-        "cookie": AUTH_COOKIE
-    }
+        # Step 1: Upload the MP3 file
+        with open(audio_file_path, 'rb') as file:
+            files = {'audio': (os.path.basename(audio_file_path), file, 'audio/mpeg')}
+            upload_response = requests.post(
+                f"{STT_API_BASE_URL}/upload",
+                files=files,
+                headers=STT_HEADERS
+            )
+
+        # Check if upload was successful
+        if upload_response.status_code != 200:
+            print(f"Upload failed with status code {upload_response.status_code}")
+            return None
 
-    # Prepare payload
-    payload = {
-        "key": file_name,
-        "tags": {
-            "purpose": "emulator",
-            "system": "true"
-        },
-        "size": file_size,
-        "accessPolicies": ["public_content"],
-        "contentType": content_type,
-        "expiresAt": expires_at,
-        "publicContentImmediatelyAccessible": True
-    }
+        # Get the file URL from the response
+        upload_data = upload_response.json()
+        file_url = upload_data.get('file_url')
 
-    # Make the PUT request to get the upload URL
-    response = requests.put(url, headers=headers, data=json.dumps(payload))
-
-    if response.status_code == 200:
-        response_data = response.json()
-
-        # Extract the URL and upload URL
-        file_url = response_data.get("file", {}).get("url", "")
-        upload_url = response_data.get("file", {}).get("uploadUrl", "")
-
-        # Now upload the actual file to the upload URL
-        if upload_url:
-            # Read the binary content of the audio file
-            with open(file_path, 'rb') as audio_file:
-                file_content = audio_file.read()
-
-            # Set headers for the upload request with all the headers you provided
-            upload_headers = {
-                "accept": "application/json, text/plain, */*",
-                "accept-encoding": "gzip, deflate, br, zstd",
-                "accept-language": "en-US,en;q=0.9,ar;q=0.8",
-                "connection": "keep-alive",
-                "content-length": str(file_size),
-                "content-type": "audio/mpeg",
-                "host": "s3.us-east-1.amazonaws.com",
-                "origin": "https://studio.botpress.cloud",
-                "referer": "https://studio.botpress.cloud/",
-                "sec-ch-ua": '"Chromium";v="136", "Google Chrome";v="136", "Not.A/Brand";v="99"',
-                "sec-ch-ua-mobile": "?0",
-                "sec-ch-ua-platform": '"Windows"',
-                "sec-fetch-dest": "empty",
-                "sec-fetch-mode": "cors",
-                "sec-fetch-site": "cross-site",
-                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-                "x-amz-tagging": "public=true"
-            }
-
-            # Make the PUT request to upload the file
-            upload_response = requests.put(upload_url, headers=upload_headers, data=file_content)
-
-            if upload_response.status_code == 200:
-                return file_url, bot_id, workspace_id
-            else:
-                return f"Error uploading file: {upload_response.status_code} - {upload_response.text}", bot_id, workspace_id
-        else:
-            return "No upload URL provided in response", bot_id, workspace_id
-    elif response.status_code == 403:
-        # If we get a 403 error, we need to delete and recreate the bot and workspace
-        print("Received 403 error during file upload. Recreating bot and workspace...")
-
-        # Delete bot first, then workspace
-        if bot_id and workspace_id:
-            delete_bot(bot_id, workspace_id)
-            delete_workspace(workspace_id)
-
-        # Create new workspace and bot
-        new_workspace_id = create_workspace()
-        if not new_workspace_id:
-            return "Failed to create a new workspace after 403 error", bot_id, workspace_id
-
-        new_bot_id = create_bot(new_workspace_id)
-        if not new_bot_id:
-            return "Failed to create a new bot after 403 error", new_workspace_id, workspace_id
-
-        # Update global variables
-        GLOBAL_WORKSPACE_ID = new_workspace_id
-        GLOBAL_BOT_ID = new_bot_id
-
-        # Try again with the new IDs
-        result, _, _ = upload_audio_file(file_path, new_bot_id, new_workspace_id)
-        return result, new_bot_id, new_workspace_id
-    else:
-        return f"Error: {response.status_code} - {response.text}", bot_id, workspace_id
-
-
-# -------------------------------------------------------------------
-# Main function that calls the Botpress API endpoint for audio transcription
-# -------------------------------------------------------------------
-def transcribe_audio(file_url, prompt, bot_id, workspace_id):
-    """
-    Sends the audio file URL to the Botpress API endpoint for transcription,
-    returns the transcription text and (possibly updated) bot/workspace IDs.
-    """
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # Prepare the headers
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-bot-id": bot_id,
-        "x-workspace-id": workspace_id,
-        "Content-Type": "application/json",
-        "Cookie": AUTH_COOKIE
-    }
+        if not file_url:
+            print("No file URL in response")
+            return None
 
-    # Prepare the payload for the API
-    payload = {
-        "type": "openai:transcribeAudio",
-        "input": {
-            "fileUrl": file_url,
-            "prompt": prompt,
-            "temperature": 0
+        # Step 2: Send the file URL for transcription
+        transcribe_payload = {
+            "file_url": file_url,
+            "prompt": "get all text with his lang and extract (DON'T translate)."
         }
-    }
-
-    botpress_url = "https://api.botpress.cloud/v1/chat/actions"
-    max_retries = 3
-    timeout = 120  # Increased timeout for long audio files
 
-    # Attempt to send the request
-    for attempt in range(max_retries):
-        try:
-            print(f"Attempt {attempt+1}: Sending transcription 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()
-
-                # Extract all text segments from the response
-                transcription_text = ""
-                segments = data.get('output', {}).get('segments', [])
-                for segment in segments:
-                    segment_text = segment.get('text', '')
-                    if segment_text:
-                        transcription_text += segment_text + " "
-
-                transcription_text = transcription_text.strip()
-                print(f"Successfully received transcription from Botpress API")
-                return transcription_text, bot_id, workspace_id
-
-            # If we get a 403 error, delete and recreate workspace/bot
-            elif response.status_code == 403:
-                print(f"Received 403 error. Deleting and recreating workspace/bot...")
-                break  # Break out of the retry loop to handle 403 specially
-
-            # 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 transcribe the audio (Error {response.status_code}).", bot_id, workspace_id
+        transcribe_response = requests.post(
+            f"{STT_API_BASE_URL}/transcribe",
+            json=transcribe_payload,
+            headers=STT_HEADERS
+        )
 
-        except requests.exceptions.Timeout:
-            print(f"Request timed out. Retrying...")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return "The transcription is taking too long. Please try again with a shorter audio file.", 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 transcribe the audio: {str(e)}", bot_id, workspace_id
-
-    # If we got a 403 error, delete and recreate resources
-    # First delete the bot, then the workspace (in that order)
-    if bot_id and workspace_id:
-        print(f"Deleting bot {bot_id} first...")
-        delete_success = delete_bot(bot_id, workspace_id)
-        if delete_success:
-            print(f"Successfully deleted bot {bot_id}")
-        else:
-            print(f"Failed to delete bot {bot_id}")
-
-        print(f"Now deleting workspace {workspace_id}...")
-        ws_delete_success = delete_workspace(workspace_id)
-        if ws_delete_success:
-            print(f"Successfully deleted workspace {workspace_id}")
-        else:
-            print(f"Failed to delete workspace {workspace_id}")
-
-    # Create new workspace
-    new_workspace_id = create_workspace()
-    if not new_workspace_id:
-        return "Failed to create a new workspace. 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. Please try again later.", new_workspace_id, workspace_id
-
-    # Update global variables
-    GLOBAL_WORKSPACE_ID = new_workspace_id
-    GLOBAL_BOT_ID = new_bot_id
+        # Check if transcription was successful
+        if transcribe_response.status_code != 200:
+            print(f"Transcription failed with status code {transcribe_response.status_code}")
+            return None
 
-    # Update headers with new bot ID and workspace ID
-    headers["x-bot-id"] = new_bot_id
-    headers["x-workspace-id"] = new_workspace_id
-
-    # Try one more time with the new IDs
-    try:
-        print(f"Retrying with new bot_id={new_bot_id}, workspace_id={new_workspace_id}")
-        retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
-
-        if retry_response.status_code == 200:
-            data = retry_response.json()
-
-            # Extract all text segments from the response
-            transcription_text = ""
-            segments = data.get('output', {}).get('segments', [])
-            for segment in segments:
-                segment_text = segment.get('text', '')
-                if segment_text:
-                    transcription_text += segment_text + " "
-
-            transcription_text = transcription_text.strip()
-            print(f"Successfully received transcription with new IDs")
-            return transcription_text, new_bot_id, new_workspace_id
-        else:
-            print(f"Failed with new IDs: {retry_response.status_code}, {retry_response.text}")
-            return f"Unable to transcribe the audio with new credentials.", new_bot_id, new_workspace_id
+        # Get the transcription from the response
+        transcribe_data = transcribe_response.json()
+        transcription = transcribe_data.get('transcription')
 
+        return transcription
     except Exception as e:
-        print(f"Error with new IDs: {str(e)}")
-        return f"Unable to transcribe the audio with new credentials: {str(e)}", new_bot_id, new_workspace_id
-
-# -------------------------------------------------------------------
-# Flask Endpoints
-# -------------------------------------------------------------------
-@app.route("/transcribe", methods=["POST"])
-def transcribe_endpoint():
-    """
-    Expects JSON with:
-    {
-      "file_url": "string",
-      "prompt": "string"
-    }
-    Returns JSON with:
-    {
-      "transcription": "string"
-    }
-    """
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # Parse JSON from request
-    data = request.get_json(force=True)
-    file_url = data.get("file_url", "")
-    prompt = data.get("prompt", "get all text with his lang and exatract (DON'T translate) .")
-
-    if not file_url:
-        return jsonify({"error": "Missing file_url parameter"}), 400
-
-    # 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({"error": "I'm currently unavailable. Please try again later."}), 500
-
-    # Call our function that interacts with Botpress API
-    print(f"Sending transcription request with existing bot_id={GLOBAL_BOT_ID}, workspace_id={GLOBAL_WORKSPACE_ID}")
-    transcription, updated_bot_id, updated_workspace_id = transcribe_audio(
-        file_url,
-        prompt,
-        GLOBAL_BOT_ID,
-        GLOBAL_WORKSPACE_ID
-    )
-
-    # 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
-
-    # Check if we got an error string back
-    if isinstance(transcription, str) and (
-        transcription.startswith("Failed") or
-        transcription.startswith("Unable") or
-        transcription.startswith("The transcription is taking too long")
-    ):
-        return jsonify({"error": transcription}), 500
-
-    return jsonify({"transcription": transcription})
-
-
-@app.route("/upload", methods=["POST"])
-def upload_endpoint():
-    """
-    Endpoint to upload an audio file and get its URL
-    Expects form data with a file field named 'audio'
-    Returns JSON with the file URL
-    """
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # Check if file was uploaded
+        print(f"Error in STT API call: {str(e)}")
+        return None
+
+# Routes
+@app.route('/api/start-session', methods=['POST'])
+def start_session():
+    """Initialize a new session for a user"""
+    data = request.json
+    username = data.get('username', 'User')
+
+    # Initialize chat history for this user
+    session['username'] = username
+    session['chat_history'] = []
+
+    # Generate initial AI greeting
+    initial_prompt = "Hello! I'm your AI assistant. How can I help you today?"
+    ai_response, chat_history = gpt4o_ai(initial_prompt, [], username)
+    session['chat_history'] = chat_history
+
+    # Convert AI response to speech
+    audio_base64 = text_to_speech(ai_response)
+
+    return jsonify({
+        'success': True,
+        'message': 'Session started',
+        'username': username,
+        'ai_response': ai_response,
+        'audio': audio_base64
+    })
+
+@app.route('/api/send-text', methods=['POST'])
+def send_text():
+    """Process text input from user and get AI response"""
+    data = request.json
+    user_input = data.get('text', '')
+
+    # Get session data
+    username = session.get('username', 'User')
+    chat_history = session.get('chat_history', [])
+
+    # Get AI response
+    ai_response, chat_history = gpt4o_ai(user_input, chat_history, username)
+    session['chat_history'] = chat_history
+
+    # Convert AI response to speech
+    audio_base64 = text_to_speech(ai_response)
+
+    return jsonify({
+        'success': True,
+        'ai_response': ai_response,
+        'audio': audio_base64
+    })
+
+@app.route('/api/send-audio', methods=['POST'])
+def send_audio():
+    """Process audio input from user and get AI response"""
     if 'audio' not in request.files:
-        return jsonify({"error": "No audio file provided"}), 400
+        return jsonify({'success': False, 'error': 'No audio file provided'})
 
     audio_file = request.files['audio']
 
-    # Check if filename is empty
-    if audio_file.filename == '':
-        return jsonify({"error": "No audio file selected"}), 400
+    # Save the audio file temporarily
+    filename = f"{uuid.uuid4()}.mp3"
+    file_path = os.path.join(UPLOAD_FOLDER, filename)
+    audio_file.save(file_path)
 
-    # 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({"error": "I'm currently unavailable. Please try again later."}), 500
-
-    # Save the file temporarily
-    temp_path = f"/tmp/{audio_file.filename}"
-    audio_file.save(temp_path)
-
-    # Upload the file
-    file_url, updated_bot_id, updated_workspace_id = upload_audio_file(temp_path, GLOBAL_BOT_ID, GLOBAL_WORKSPACE_ID)
-
-    # Remove the temporary file
-    os.remove(temp_path)
-
-    # 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
-
-    # Check if we got an error string back
-    if isinstance(file_url, str) and (file_url.startswith("Error") or file_url.startswith("Failed") or file_url.startswith("No upload")):
-        return jsonify({"error": file_url}), 500
-
-    return jsonify({"file_url": file_url})
-
-
-# -------------------------------------------------------------------
-# Run the Flask app
-# -------------------------------------------------------------------
-
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=True)
+    try:
+        # Convert speech to text
+        user_input = speech_to_text(file_path)
+
+        if not user_input:
+            return jsonify({'success': False, 'error': 'Failed to transcribe audio'})
+
+        # Get session data
+        username = session.get('username', 'User')
+        chat_history = session.get('chat_history', [])
+
+        # Get AI response
+        ai_response, chat_history = gpt4o_ai(user_input, chat_history, username)
+        session['chat_history'] = chat_history
+
+        # Convert AI response to speech
+        audio_base64 = text_to_speech(ai_response)
+
+        return jsonify({
+            'success': True,
+            'transcription': user_input,
+            'ai_response': ai_response,
+            'audio': audio_base64
+        })
+    finally:
+        # Clean up the temporary file
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+@app.route('/api/interrupt', methods=['POST'])
+def interrupt():
+    """Handle user interruption during AI speech"""
+    # This endpoint would be called when the user starts speaking while the AI is talking
+    # In a real implementation, you might need WebSockets for this kind of real-time interaction
+    return jsonify({
+        'success': True,
+        'message': 'AI speech interrupted'
+    })
+
+@app.route('/api/end-session', methods=['POST'])
+def end_session():
+    """End the current session"""
+    # Clear session data
+    session.clear()
+
+    return jsonify({
+        'success': True,
+        'message': 'Session ended'
+    })
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5000)