webscout 1.1.5__py3-none-any.whl → 1.1.7__py3-none-any.whl

webscout/AI.py

@@ -4,10 +4,8 @@ from selenium.webdriver.chrome.options import Options
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
-from halo import Halo
 import click
 import requests
-import json
 from requests import get
 from uuid import uuid4
 from re import findall
@@ -17,47 +15,908 @@ import g4f
 from random import randint
 from PIL import Image
 import io
+import re
+import json
+import yaml
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from Helpingai_T2 import Perplexity
+from typing import Any
+import logging
+#------------------------------------------------------OpenGPT-----------------------------------------------------------
+class OPENGPT:
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates OPENGPT
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = (
+            "https://opengpts-example-vz4y4ooboq-uc.a.run.app/runs/stream"
+        )
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.assistant_id = "bca37014-6f97-4f2b-8928-81ea8d478d88"
+        self.authority = "opengpts-example-vz4y4ooboq-uc.a.run.app"
+
+        self.headers = {
+            "authority": self.authority,
+            "accept": "text/event-stream",
+            "accept-language": "en-US,en;q=0.7",
+            "cache-control": "no-cache",
+            "content-type": "application/json",
+            "origin": "https://opengpts-example-vz4y4ooboq-uc.a.run.app",
+            "pragma": "no-cache",
+            "referer": "https://opengpts-example-vz4y4ooboq-uc.a.run.app/",
+            "sec-fetch-site": "same-origin",
+            "sec-gpc": "1",
+            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "messages": [
+                {
+                    "content": "Hello there",
+                    "additional_kwargs": {},
+                    "type": "human",
+                    "example": false
+                },
+                {
+                    "content": "Hello! How can I assist you today?",
+                    "additional_kwargs": {
+                    "agent": {
+                        "return_values": {
+                            "output": "Hello! How can I assist you today?"
+                            },
+                        "log": "Hello! How can I assist you today?",
+                        "type": "AgentFinish"
+                    }
+                },
+                "type": "ai",
+                "example": false
+                }]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        self.session.headers.update(
+            dict(
+                cookie=f"opengpts_user_id={uuid4().__str__()}",
+            )
+        )
+        payload = {
+            "input": [
+                {
+                    "content": conversation_prompt,
+                    "additional_kwargs": {},
+                    "type": "human",
+                    "example": False,
+                },
+            ],
+            "assistant_id": self.assistant_id,
+            "thread_id": "",
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/event-stream; charset=utf-8"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    modified_value = re.sub("data:", "", value)
+                    resp = json.loads(modified_value)
+                    if len(resp) == 1:
+                        continue
+                    self.last_response.update(resp[1])
+                    yield value if raw else resp[1]
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["content"]
+#------------------------------------------------------PERPLEXITY--------------------------------------------------------  
+class PERPLEXITY:
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 8000,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        quiet: bool = False,
+    ):
+        """Instantiates PERPLEXITY
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            quiet (bool, optional): Ignore web search-results and yield final response only. Defaults to False.
+        """
+        logging.getLogger("websocket").setLevel(logging.ERROR)
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.last_response = {}
+        self.web_results: dict = {}
+        self.quiet = quiet
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+                Args:
+                    prompt (str): Prompt to be send.
+                    stream (bool, optional): Flag for streaming response. Defaults to False.
+                    raw (bool, optional): Stream back raw response as received. Defaults to False.
+                    optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+                    conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+                Returns:
+                   dict : {}
+                ```json
+        {
+            "status": "pending",
+            "uuid": "3604dfcc-611f-4b7d-989d-edca2a7233c7",
+            "read_write_token": null,
+            "frontend_context_uuid": "f6d43119-5231-481d-b692-f52e1f52d2c6",
+            "final": false,
+            "backend_uuid": "a6d6ec9e-da69-4841-af74-0de0409267a8",
+            "media_items": [],
+            "widget_data": [],
+            "knowledge_cards": [],
+            "expect_search_results": "false",
+            "mode": "concise",
+            "search_focus": "internet",
+            "gpt4": false,
+            "display_model": "turbo",
+            "attachments": null,
+            "answer": "",
+            "web_results": [],
+            "chunks": [],
+            "extra_web_results": []
+        }
+                ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        def for_stream():
+            for response in Perplexity().generate_answer(conversation_prompt):
+                yield json.dumps(response) if raw else response
+                self.last_response.update(response)
+
+            self.conversation.update_chat_history(
+                prompt,
+                self.get_message(self.last_response),
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        text_str: str = response.get("answer", "")
+
+        def update_web_results(web_results: list) -> None:
+            for index, results in enumerate(web_results, start=1):
+                self.web_results[str(index) + ". " + results["name"]] = dict(
+                    url=results.get("url"), snippet=results.get("snippet")
+                )
+
+        if response.get("text"):
+            # last chunk
+            target: dict[str, Any] = json.loads(response.get("text"))
+            text_str = target.get("answer")
+            web_results: list[dict] = target.get("web_results")
+            self.web_results.clear()
+            update_web_results(web_results)
+
+            return (
+                text_str
+                if self.quiet or not self.web_results
+                else text_str + "\n\n# WEB-RESULTS\n\n" + yaml.dump(self.web_results)
+            )
+
+        else:
+            if str(response.get("expect_search_results")).lower() == "true":
+                return (
+                    text_str
+                    if self.quiet
+                    else text_str
+                    + "\n\n# WEB-RESULTS\n\n"
+                    + yaml.dump(response.get("web_results"))
+                )
+            else:
+                return text_str
+#------------------------------------------------------BLACKBOXAI--------------------------------------------------------  
+class BLACKBOXAI:
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 8000,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = None,
+    ):
+        """Instantiates BLACKBOXAI
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): Model name. Defaults to "Phind Model".
+        """
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = "https://www.blackbox.ai/api/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.previewToken: str = None
+        self.userId: str = ""
+        self.codeModelMode: bool = True
+        self.id: str = ""
+        self.agentMode: dict = {}
+        self.trendingAgentMode: dict = {}
+        self.isMicMode: bool = False
 
-#------------------------------------------------------phind--------------------------------------------------------   
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "",
+            "Accept": "*/*",
+            "Accept-Encoding": "Identity",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "text" : "print('How may I help you today?')"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "messages": [
+                # json.loads(prev_messages),
+                {"content": conversation_prompt, "role": "user"}
+            ],
+            "id": self.id,
+            "previewToken": self.previewToken,
+            "userId": self.userId,
+            "codeModelMode": self.codeModelMode,
+            "agentMode": self.agentMode,
+            "trendingAgentMode": self.trendingAgentMode,
+            "isMicMode": self.isMicMode,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/plain; charset=utf-8"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            streaming_text = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+                delimiter="\n",
+            ):
+                try:
+                    if bool(value):
+                        streaming_text += value + ("\n" if stream else "")
+
+                        resp = dict(text=streaming_text)
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+    @staticmethod
+    def chat_cli(prompt):
+        """Sends a request to the BLACKBOXAI API and processes the response."""
+        blackbox_ai = BLACKBOXAI()  # Initialize a BLACKBOXAI instance
+        response = blackbox_ai.ask(prompt)  # Perform a chat with the given prompt
+        processed_response = blackbox_ai.get_message(response)  # Process the response
+        print(processed_response)
+#------------------------------------------------------phind-------------------------------------------------------------
 class PhindSearch:
-    def __init__(self, query):
-        self.query = query
-        self.url = "https://www.phind.com/search?q=" + self.query
-        self.chrome_options = Options()
-        self.chrome_options.add_argument("--log-level=3")  # Fatal errors only
-        self.chrome_options.add_argument("--headless")
-        self.chrome_options.add_experimental_option('excludeSwitches', ['enable-logging'])
-        self.driver = webdriver.Chrome(options=self.chrome_options)
-
-    def search(self):
-        try:
-            spinner = Halo("Getting Answer from Phind...\n\n\n\n\n\n\n \n", spinner="dots")
-            spinner.start()
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 8000,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "Phind Model",
+        quiet: bool = False,
+    ):
+        """Instantiates PHIND
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): Model name. Defaults to "Phind Model".
+            quiet (bool, optional): Ignore web search-results and yield final response only. Defaults to False.
+        """
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = "https://https.extension.phind.com/agent/"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.quiet = quiet
 
-            self.driver.get(self.url)
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "",
+            "Accept": "*/*",
+            "Accept-Encoding": "Identity",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-r0wujizf2i2xb60mjiwt",
+            "object": "chat.completion.chunk",
+            "created": 1706775384,
+            "model": "trt-llm-phind-model-serving",
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {
+                        "content": "Hello! How can I assist you with your programming today?"
+                        },
+                    "finish_reason": null
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "additional_extension_context": "",
+            "allow_magic_buttons": True,
+            "is_vscode_extension": True,
+            "message_history": [
+                {"content": conversation_prompt, "metadata": {}, "role": "user"}
+            ],
+            "requested_model": self.model,
+            "user_input": prompt,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/event-stream; charset=utf-8"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            streaming_text = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    modified_value = re.sub("data:", "", value)
+                    json_modified_value = json.loads(modified_value)
+                    retrieved_text = self.get_message(json_modified_value)
+                    if not retrieved_text:
+                        continue
+                    streaming_text += retrieved_text
+                    json_modified_value["choices"][0]["delta"][
+                        "content"
+                    ] = streaming_text
+                    self.last_response.update(json_modified_value)
+                    yield value if raw else json_modified_value
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
 
-            WebDriverWait(self.driver, timeout=50).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
-            time.sleep(15)
-            answer_elements = self.driver.find_elements(By.CSS_SELECTOR, "main div.fs-5")
+        return for_stream() if stream else for_non_stream()
 
-            paragraph_texts = [answer_element.text.strip() for answer_element in answer_elements]
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        if response.get("type", "") == "metadata":
+            return
+
+        delta: dict = response["choices"][0]["delta"]
 
-            for text in paragraph_texts:
-                spinner.stop()
-                return text
+        if not delta:
+            return ""
 
-        finally:
-            self.driver.quit()
+        elif delta.get("function_call"):
+            if self.quiet:
+                return ""
 
-    def close(self):
-        self.driver.quit()
+            function_call: dict = delta["function_call"]
+            if function_call.get("name"):
+                return function_call["name"]
+            elif function_call.get("arguments"):
+                return function_call.get("arguments")
 
+        elif delta.get("metadata"):
+            if self.quiet:
+                return ""
+            return yaml.dump(delta["metadata"])
+
+        else:
+            return (
+                response["choices"][0]["delta"].get("content")
+                if response["choices"][0].get("finish_reason") is None
+                else ""
+            )
     @staticmethod
-    def search_cli(query):
-        """Use webscout.AI."""
-        search_instance = PhindSearch(query)
-        search_instance.search()
-#------------------------------------------------------yep.com--------------------------------------------------------   
+    def chat_cli(prompt):
+        """Sends a request to the Phind API and processes the response."""
+        phind_search = PhindSearch()  # Initialize a PhindSearch instance
+        response = phind_search.ask(prompt)  # Perform a search with the given prompt
+        processed_response = phind_search.get_message(response)  # Process the response
+        print(processed_response)
+#-------------------------------------------------------yep.com--------------------------------------------------------   
 class YepChat:
     def __init__(self, message="hello"):
         self.url = "https://api.yep.com/v1/chat/completions"
@@ -114,7 +973,7 @@ class YepChat:
         response = yep_chat.send_request()
         processed_response = yep_chat.process_response(response)
         print(processed_response)
-#------------------------------------------------------youchat--------------------------------------------------------   
+#-------------------------------------------------------youchat--------------------------------------------------------   
 class youChat:
     """
     This class provides methods for generating completions based on prompts.
@@ -173,7 +1032,7 @@ class youChat:
         you_chat = youChat()
         completion = you_chat.create(prompt)
         print(completion)
-#------------------------------------------------------Gemini--------------------------------------------------------        
+#-------------------------------------------------------Gemini--------------------------------------------------------        
 class Gemini:
     def __init__(self):
         self.messages = []
@@ -201,7 +1060,7 @@ class Gemini:
         """Generate completion based on the provided message"""
         gemini = Gemini()
         return gemini.chat(message)
-#------------------------------------------------Prodia-------------------------------------------------------------------------
+#-------------------------------------------------------Prodia-------------------------------------------------------------------------
 class Prodia:
     """
     This class provides methods for generating images based on prompts.
@@ -308,12 +1167,17 @@ class Pollinations:
 
 @click.group()
 def cli():
+    """Webscout AI command-line interface."""
     pass
 
 @cli.command()
-@click.option('--query', prompt='Enter your search query', help='The query to search.')
-def phindsearch(query):
-    PhindSearch.search_cli(query)
+@click.option('--prompt', prompt='Enter your search prompt', help='The prompt to send.')
+def phindsearch(prompt):
+    """Perform a search with the given prompt using PhindSearch."""
+    phind_search = PhindSearch() # Initialize a PhindSearch instance
+    response = phind_search.ask(prompt) # Perform a search with the given prompt
+    processed_response = phind_search.get_message(response) # Process the response
+    print(processed_response)
 
 @cli.command()
 @click.option('--message', prompt='Enter your message', help='The message to send.')
@@ -329,15 +1193,49 @@ def youchat(prompt):
 @click.option('--message', prompt='Enter your message', help='The message to send.')
 def gemini(message):
     Gemini.chat_cli(message)
+
 @cli.command()
 @click.option('--prompt', prompt='Enter your prompt', help='The prompt for generating the image.')
 def prodia(prompt):
     """Generate an image based on the provided prompt."""
     Prodia.prodia_cli(prompt)
+
 @cli.command()
 @click.option('--prompt', prompt='Enter your prompt', help='The prompt for generating the image.')
 def pollinations(prompt):
     """Generate an image based on the provided prompt."""
     Pollinations.pollinations_cli(prompt)
+    
+@cli.command()
+@click.option('--prompt', prompt='Enter your prompt', help='The prompt to send.')
+def blackboxai(prompt):
+    """Chat with BLACKBOXAI using the provided prompt."""
+    BLACKBOXAI.chat_cli(prompt)
+    
+@cli.command()
+@click.option('--prompt', prompt='Enter your prompt', help='The prompt to send.')
+@click.option('--stream', is_flag=True, help='Flag for streaming response.')
+@click.option('--raw', is_flag=True, help='Stream back raw response as received.')
+@click.option('--optimizer', type=str, help='Prompt optimizer name.')
+@click.option('--conversationally', is_flag=True, help='Chat conversationally when using optimizer.')
+def perplexity(prompt, stream, raw, optimizer, conversationally):
+    """Chat with PERPLEXITY using the provided prompt."""
+    perplexity_instance = PERPLEXITY() # Initialize a PERPLEXITY instance
+    response = perplexity_instance.ask(prompt, stream, raw, optimizer, conversationally)
+    processed_response = perplexity_instance.get_message(response) # Process the response
+    print(processed_response)
+   
+@cli.command()
+@click.option('--prompt', prompt='Enter your search prompt', help='The prompt to send.')
+@click.option('--stream', is_flag=True, help='Flag for streaming response.')
+def opengpt(prompt, stream):
+    """Chat with OPENGPT using the provided prompt."""
+    opengpt = OPENGPT(is_conversation=True, max_tokens=8000, timeout=30)
+    if stream:
+        for response in opengpt.chat(prompt, stream=True):
+            print(response)
+    else:
+        response_str = opengpt.chat(prompt)
+        print(response_str)
 if __name__ == '__main__':
-    cli()
+    cli()