Telegram Bot integration & Voice Prompt

.env.template

@@ -195,3 +195,26 @@ OPENAI_API_KEY=your-openai-api-key
 
 #ALLOWLISTED_PLUGINS - Sets the listed plugins that are allowed (Example: plugin1,plugin2,plugin3)
 ALLOWLISTED_PLUGINS=
+
+
+################################################################################
+### VOICE INPUT PROVIDER
+################################################################################
+
+### MAC OS
+# USE_MAC_OS_VOICE_INPUT - Use Mac OS voice input or not (Default: False)
+USE_MAC_OS_VOICE_INPUT=False
+
+### GOOGLE
+# GOOGLE_CLOUD_API_KEY - Google Cloud API key (Example: my-google-cloud-api-key)
+GOOGLE_CLOUD_API_KEY=your-google-cloud-api-key
+
+
+################################################################################
+### TELEGRAM BOT
+################################################################################
+# TELEGRAM_BOT_TOKEN - Telegram bot token (Example: my-telegram-bot-token)
+# TELEGRAM_BOT_CHAT_ID - Telegram bot chat ID (Example: my-telegram-bot-chat-id)
+TELEGRAM_ENABLED=False
+TELEGRAM_API_KEY=your-telegram-bot-token
+TELEGRAM_CHAT_ID=your-telegram-bot-chat-id

README.md

@@ -453,6 +453,22 @@ Use at your own risk.
 
 2. To exit the program, press Ctrl + C
 
+## Telegram Bot
+First setup a telegram bot by following the instructions [here](https://core.telegram.org/bots#6-botfather)
+
+Then set the following variables in your `.env`:
+
+```
+TELEGRAM_ENABLED=True
+TELEGRAM_API_KEY=your-telegram-bot-token
+TELEGRAM_CHAT_ID=your-telegram-bot-chat-id
+```
+to obtain your chat id, send a message to your bot and then use the following command:
+
+```
+curl https://api.telegram.org/bot<your-telegram-bot-token>/getUpdates
+```
+
 ## GPT3.5 ONLY Mode
 
 If you don't have access to the GPT4 api, this mode will allow you to use Auto-GPT!

autogpt/agent/agent.py

@@ -8,6 +8,7 @@
 from autogpt.logs import logger, print_assistant_thoughts
 from autogpt.speech import say_text
 from autogpt.spinner import Spinner
+from autogpt.telegram_chat import TelegramUtils
 from autogpt.utils import clean_input
 
 
@@ -80,7 +81,9 @@ def start_interaction_loop(self):
                     "Continuous Limit Reached: ", Fore.YELLOW, f"{cfg.continuous_limit}"
                 )
                 break
-
+            if cfg.telegram_enabled:
+                telegramUtils = TelegramUtils()
+                telegramUtils.send_message("Thinking... \n")
             # Send message to AI, get response
             with Spinner("Thinking... "):
                 assistant_reply = chat_with_ai(
@@ -107,29 +110,48 @@ def start_interaction_loop(self):
                     command_name, arguments = get_command(assistant_reply_json)
                     if cfg.speak_mode:
                         say_text(f"I want to execute {command_name}")
+                    if cfg.telegram_enabled:
+                        TelegramUtils().send_message(
+                            f"I want to execute {command_name} \n with arguments {arguments}"
+                        )
                 except Exception as e:
                     logger.error("Error: \n", str(e))
 
             if not cfg.continuous_mode and self.next_action_count == 0:
                 # ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
                 # Get key press: Prompt the user to press enter to continue or escape
                 # to exit
-                logger.typewriter_log(
-                    "NEXT ACTION: ",
-                    Fore.CYAN,
-                    f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}  "
-                    f"ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
-                )
+                self.user_input = ""
+                if cfg.telegram_enabled:
+                    telegramUtils = TelegramUtils()
+                    telegramUtils.send_message(
+                        "NEXT ACTION: \n " + f"COMMAND = {command_name} \n "
+                        f"ARGUMENTS = {arguments}"
+                    )
+                else:
+                    logger.typewriter_log(
+                        "NEXT ACTION: ",
+                        Fore.CYAN,
+                        f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}  "
+                        f"ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
+                    )
                 print(
                     "Enter 'y' to authorise command, 'y -N' to run N continuous "
                     "commands, 'n' to exit program, or enter feedback for "
                     f"{self.ai_name}...",
                     flush=True,
                 )
                 while True:
-                    console_input = clean_input(
-                        Fore.MAGENTA + "Input:" + Style.RESET_ALL
-                    )
+                    console_input = ""
+                    if cfg.telegram_enabled:
+                        telegramUtils = TelegramUtils()
+                        console_input = telegramUtils.ask_user(
+                            "Enter 'y' to authorise command, 'y -N' to run N continuous \n commands, 'n' to exit program, or enter feedback for me."
+                        )
+                    else:
+                        console_input = clean_input(
+                            Fore.MAGENTA + "Input:" + Style.RESET_ALL
+                        )
                     if console_input.lower().strip() == "y":
                         user_input = "GENERATE NEXT COMMAND JSON"
                         break
@@ -164,16 +186,26 @@ def start_interaction_loop(self):
                         "",
                     )
                 elif user_input == "EXIT":
+                    if cfg.telegram_enabled:
+                        telegramUtils = TelegramUtils()
+                        telegramUtils.send_message("Exiting...")
                     print("Exiting...", flush=True)
                     break
             else:
                 # Print command
-                logger.typewriter_log(
-                    "NEXT ACTION: ",
-                    Fore.CYAN,
-                    f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}"
-                    f"  ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
-                )
+                if cfg.telegram_enabled:
+                    telegramUtils = TelegramUtils()
+                    telegramUtils.send_message(
+                        "NEXT ACTION: \n " + f"COMMAND = {command_name} \n "
+                        f"ARGUMENTS = {arguments}"
+                    )
+                else:
+                    logger.typewriter_log(
+                        "NEXT ACTION: ",
+                        Fore.CYAN,
+                        f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}  "
+                        f"ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}",
+                    )
 
             # Execute command
             if command_name is not None and command_name.lower().startswith("error"):

autogpt/auto_gpt_workspace/instance_history.txt

@@ -0,0 +1,2 @@
+Auto-GPT instance history:
+- First instance created on Sat Apr 15 17:16:18 2023

autogpt/commands/web_selenium.py

@@ -84,7 +84,7 @@ def scrape_text_with_selenium(url: str) -> tuple[WebDriver, str]:
         # See https://developer.apple.com/documentation/webkit/testing_with_webdriver_in_safari
         driver = webdriver.Safari(options=options)
     else:
-        if platform == "linux" or platform == "linux2":
+        if platform == "linux" or platform == "linux2" or platform == "darwin":
             options.add_argument("--disable-dev-shm-usage")
             options.add_argument("--remote-debugging-port=9222")
 

autogpt/config/__init__.py

@@ -1,9 +1,14 @@
 """
 This module contains the configuration classes for AutoGPT.
 """
-from autogpt.config.ai_config import AIConfig
-from autogpt.config.config import Config, check_openai_api_key
-from autogpt.config.singleton import AbstractSingleton, Singleton
+try:
+    from autogpt.config.ai_config import AIConfig
+    from autogpt.config.config import Config, check_openai_api_key
+    from autogpt.config.singleton import AbstractSingleton, Singleton
+except ModuleNotFoundError:
+    from .ai_config import AIConfig
+    from .config import Config, check_openai_api_key
+    from .singleton import AbstractSingleton, Singleton
 
 __all__ = [
     "check_openai_api_key",

autogpt/config/config.py

@@ -8,7 +8,10 @@
 from colorama import Fore
 from dotenv import load_dotenv
 
-from autogpt.config.singleton import Singleton
+try:
+    from autogpt.config.singleton import Singleton
+except ModuleNotFoundError:
+    from config.singleton import Singleton
 
 load_dotenv(verbose=True)
 
@@ -58,9 +61,17 @@ def __init__(self) -> None:
         self.elevenlabs_voice_1_id = os.getenv("ELEVENLABS_VOICE_1_ID")
         self.elevenlabs_voice_2_id = os.getenv("ELEVENLABS_VOICE_2_ID")
 
+        self.use_mac_os_voice_input = False
+        self.use_mac_os_voice_input = os.getenv("USE_MAC_OS_VOICE_INPUT")
+
         self.use_mac_os_tts = False
         self.use_mac_os_tts = os.getenv("USE_MAC_OS_TTS")
 
+        self.telegram_enabled = os.getenv("TELEGRAM_ENABLED") == "True"
+        self.telegram_api_key = os.getenv("TELEGRAM_API_KEY")
+        self.telegram_chat_id = os.getenv("TELEGRAM_CHAT_ID")
+        self.telegram_voice_enabled = os.getenv("TELEGRAM_VOICE_ENABLED") == "False"
+
         self.use_brian_tts = False
         self.use_brian_tts = os.getenv("USE_BRIAN_TTS")
 

autogpt/logs.py

@@ -84,6 +84,13 @@ def typewriter_log(
         if speak_text and CFG.speak_mode:
             say_text(f"{title}. {content}")
 
+        if CFG.telegram_enabled:
+            from autogpt.telegram_chat import TelegramUtils
+
+            telegramUtils = TelegramUtils()
+            message = f"{title}. {content}"
+            telegramUtils.send_message(message)
+
         if content:
             if isinstance(content, list):
                 content = " ".join(content)

autogpt/start_bot.py

@@ -0,0 +1,115 @@
+import asyncio
+import os
+import sys
+import traceback
+from threading import Lock, Semaphore
+
+from telegram import Update
+from telegram.ext import Application, CallbackContext, CommandHandler
+
+try:
+    from autogpt.config.config import Config
+    from autogpt.telegram_chat import TelegramUtils, is_authorized_user
+except ModuleNotFoundError:
+    from config import Config
+    from telegram_chat import TelegramUtils, is_authorized_user
+
+cfg = Config()
+
+main_started = False
+
+mutex_lock = Lock()  # Ensure only one sound is played at a time
+# The amount of sounds to queue before blocking the main thread
+queue_semaphore = Semaphore(1)
+
+
+async def stop(update: Update, context: CallbackContext):
+    if is_authorized_user(update):
+        process = os.popen("ps -Af")
+        output = process.read()
+        process.close()
+        if "python -m autogpt" in output:
+            await update.message.reply_text("Stopping Auto-GPT now!")
+            os.system("pkill -f autogpt")
+            TelegramUtils.send_message("Auto-GPT was stopped.")
+        else:
+            TelegramUtils.send_message("Auto-GPT was not running.")
+
+
+async def start(update: Update, context: CallbackContext):
+    global main_started
+    print("Starting Auto-GPT...")
+    if is_authorized_user(update):
+        # Check if operating system is Windows
+        if os.name == "nt":
+            # Check if main is still running
+            process = os.popen("tasklist")
+        else:
+            # check if main is still running
+            process = os.popen("ps -Af")
+        output = process.read()
+        process.close()
+        if "python -m autogpt" in output:
+            await update.message.reply_text("Already started!")
+            return
+        else:
+            # check if python is installed, using python3 if not
+            if os.name == "nt":
+                # Check if main is still running
+                process = os.popen("where python")
+            else:
+                # check if main is still running
+                process = os.popen("which python")
+            output = process.read()
+            process.close
+            print(output)
+            if "python" in output:
+                os.system("python -m autogpt {}".format(" ".join(sys.argv[1:])))
+            else:
+                os.system("python3 -m autogpt {}".format(" ".join(sys.argv[1:])))
+
+
+def main():
+    print("Starting up...")
+
+    telegramUtils = TelegramUtils()
+    telegramUtils.send_message("Starting Auto-GPT...")
+
+    # Delete old messages
+    asyncio.run(telegramUtils.delete_old_messages())
+
+    TelegramUtils().send_message(
+        "Hello! I need you to confirm with /start to start me. <3"
+    )
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    application = Application.builder().token(cfg.telegram_api_key).build()
+    application.add_handler(CommandHandler("stop", stop))
+    application.add_handler(CommandHandler("start", start))
+    try:
+        print("Check your Telegram chat to start Auto-GPT! ;-)")
+        loop.run_until_complete(application.run_polling())
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    try:
+        main()
+        # queue_semaphore.acquire(True)
+        # thread = threading.Thread(target=main)
+        # thread.start()
+    except KeyboardInterrupt:
+        print("Exiting...")
+        TelegramUtils.send_message("I hope I could help! :) \n \n Bye bye! <3")
+
+        exit(0)
+    except Exception as e:
+        print(e)
+        print(traceback.format_exc())
+        TelegramUtils.send_message(
+            "Sorry, I have to stop. \n \n An error occurred: " + str(e)
+        )
+        exit(1)