From 5b2efa4aaf00cb5b5b169c83f2690630495a962e Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <heiner@lohaus.eu>
Date: Tue, 3 Oct 2023 23:53:17 +0200
Subject: Fix fetch_access_token in openai

---
 g4f/Provider/OpenaiChat.py | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/g4f/Provider/OpenaiChat.py b/g4f/Provider/OpenaiChat.py
index fbd26d7c..ca148da2 100644
--- a/g4f/Provider/OpenaiChat.py
+++ b/g4f/Provider/OpenaiChat.py
@@ -63,7 +63,7 @@ class OpenaiChat(AsyncGeneratorProvider):
                             last_message = new_message
 
     @classmethod
-    def fetch_access_token(cls) -> str:
+    def browse_access_token(cls) -> str:
         try:
             from selenium.webdriver.common.by import By
             from selenium.webdriver.support.ui import WebDriverWait
@@ -85,19 +85,25 @@ class OpenaiChat(AsyncGeneratorProvider):
         finally:
             driver.quit()
 
+    @classmethod
+    async def fetch_access_token(cls, cookies: dict, proxies: dict = None) -> str:
+        async with StreamSession(proxies=proxies, cookies=cookies, impersonate="chrome107") as session:
+            async with session.get(f"{cls.url}/api/auth/session") as response:
+                response.raise_for_status()
+                auth = await response.json()
+                if "accessToken" in auth:
+                    return auth["accessToken"]
+
     @classmethod
     async def get_access_token(cls, cookies: dict = None, proxies: dict = None) -> str:
         if not cls._access_token:
             cookies = cookies if cookies else get_cookies("chat.openai.com")
-            async with StreamSession(proxies=proxies, cookies=cookies, impersonate="chrome107") as session:
-                async with session.get(f"{cls.url}/api/auth/session") as response:
-                    response.raise_for_status()
-                    auth = await response.json()
-                    if "accessToken" in auth:
-                        cls._access_token = auth["accessToken"]
-            cls._access_token = cls.fetch_access_token()
-            if not cls._access_token:
-                raise RuntimeError("Missing access token")
+            if cookies:
+                cls._access_token = await cls.fetch_access_token(cookies, proxies)
+        if not cls._access_token:
+            cls._access_token = cls.browse_access_token()
+        if not cls._access_token:
+            raise RuntimeError("Read access token failed")
         return cls._access_token
 
     @classmethod
-- 
cgit v1.2.3


From 136770e05b63fd1482665eac5f90eba5bd10e4c5 Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <heiner@lohaus.eu>
Date: Wed, 4 Oct 2023 03:15:17 +0200
Subject: Use custom user dir

---
 g4f/Provider/OpenaiChat.py | 19 +++++++++++--------
 g4f/Provider/helper.py     | 23 +++++------------------
 2 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/g4f/Provider/OpenaiChat.py b/g4f/Provider/OpenaiChat.py
index ca148da2..8f183fb9 100644
--- a/g4f/Provider/OpenaiChat.py
+++ b/g4f/Provider/OpenaiChat.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-import uuid
-import json
+import uuid, json, time
 
 from .base_provider import AsyncGeneratorProvider
 from .helper import get_browser, get_cookies, format_prompt
@@ -56,8 +55,13 @@ class OpenaiChat(AsyncGeneratorProvider):
                         line = line[6:]
                         if line == b"[DONE]":
                             break
-                        line = json.loads(line)
-                        if "message" in line and not line["message"]["end_turn"]:
+                        try:
+                            line = json.loads(line)
+                        except:
+                            continue
+                        if "message" not in line or "message_type" not in line["message"]["metadata"]:
+                            continue
+                        if line["message"]["metadata"]["message_type"] == "next":
                             new_message = line["message"]["content"]["parts"][0]
                             yield new_message[len(last_message):]
                             last_message = new_message
@@ -68,11 +72,9 @@ class OpenaiChat(AsyncGeneratorProvider):
             from selenium.webdriver.common.by import By
             from selenium.webdriver.support.ui import WebDriverWait
             from selenium.webdriver.support import expected_conditions as EC
-        except ImportError:
-            return
 
-        driver = get_browser()
-        if not driver:
+            driver = get_browser()
+        except ImportError:
             return
 
         driver.get(f"{cls.url}/")
@@ -83,6 +85,7 @@ class OpenaiChat(AsyncGeneratorProvider):
             javascript = "return (await (await fetch('/api/auth/session')).json())['accessToken']"
             return driver.execute_script(javascript)
         finally:
+            time.sleep(1)
             driver.quit()
 
     @classmethod
diff --git a/g4f/Provider/helper.py b/g4f/Provider/helper.py
index 8f09239a..c127f241 100644
--- a/g4f/Provider/helper.py
+++ b/g4f/Provider/helper.py
@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio, sys
 from asyncio import AbstractEventLoop
-
+from os import path
 import browser_cookie3
 
 # Change event loop policy on windows
@@ -60,24 +60,11 @@ def format_prompt(messages: list[dict[str, str]], add_special_tokens=False):
     
 
 def get_browser(user_data_dir: str = None):
-    try:
-        from undetected_chromedriver import Chrome
-    except ImportError:
-        return None
+    from undetected_chromedriver import Chrome
+    from platformdirs import user_config_dir
 
-    def get_user_data_dir():
-        dirs = [
-            '~/.config/google-chrome/Default',
-            '~/.var/app/com.google.Chrome/config/google-chrome/Default',
-            '%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default',
-            '~/Library/Application Support/Google/Chrome/Default',
-        ]
-        from os import path
-        for dir in dirs:
-            dir = path.expandvars(dir)
-            if path.exists(dir):
-                return dir
     if not user_data_dir:
-        user_data_dir = get_user_data_dir()
+        user_data_dir = user_config_dir("g4f")
+        user_data_dir = path.join(user_data_dir, "Default")
 
     return Chrome(user_data_dir=user_data_dir)
\ No newline at end of file
-- 
cgit v1.2.3


From 6a61cf811655fa87dbcb196025cc0b6040502293 Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <heiner@lohaus.eu>
Date: Wed, 4 Oct 2023 07:20:51 +0200
Subject: Sort providers in new dirs

---
 g4f/Provider/AItianhu.py                 |   2 +
 g4f/Provider/AItianhuSpace.py            |   2 +
 g4f/Provider/AiService.py                |  36 ---------
 g4f/Provider/Bard.py                     |  92 -----------------------
 g4f/Provider/CodeLinkAva.py              |  64 ----------------
 g4f/Provider/DeepAi.py                   |   4 +-
 g4f/Provider/DfeHub.py                   |  77 -------------------
 g4f/Provider/EasyChat.py                 | 111 ---------------------------
 g4f/Provider/Equing.py                   |  81 --------------------
 g4f/Provider/FastGpt.py                  |  86 ---------------------
 g4f/Provider/Forefront.py                |  40 ----------
 g4f/Provider/GetGpt.py                   |  88 ----------------------
 g4f/Provider/HuggingChat.py              |  74 ------------------
 g4f/Provider/Lockchat.py                 |  64 ----------------
 g4f/Provider/Opchatgpts.py               |   8 --
 g4f/Provider/OpenAssistant.py            | 100 -------------------------
 g4f/Provider/OpenaiChat.py               | 124 -------------------------------
 g4f/Provider/PerplexityAi.py             | 101 -------------------------
 g4f/Provider/Raycast.py                  |  72 ------------------
 g4f/Provider/Theb.py                     |  97 ------------------------
 g4f/Provider/V50.py                      |  67 -----------------
 g4f/Provider/Wewordle.py                 |  65 ----------------
 g4f/Provider/Wuguokai.py                 |  63 ----------------
 g4f/Provider/__init__.py                 |  22 +-----
 g4f/Provider/deprecated/AiService.py     |  36 +++++++++
 g4f/Provider/deprecated/CodeLinkAva.py   |  64 ++++++++++++++++
 g4f/Provider/deprecated/DfeHub.py        |  77 +++++++++++++++++++
 g4f/Provider/deprecated/EasyChat.py      | 111 +++++++++++++++++++++++++++
 g4f/Provider/deprecated/Equing.py        |  81 ++++++++++++++++++++
 g4f/Provider/deprecated/FastGpt.py       |  87 ++++++++++++++++++++++
 g4f/Provider/deprecated/Forefront.py     |  40 ++++++++++
 g4f/Provider/deprecated/GetGpt.py        |  88 ++++++++++++++++++++++
 g4f/Provider/deprecated/Lockchat.py      |  64 ++++++++++++++++
 g4f/Provider/deprecated/Opchatgpts.py    |   8 ++
 g4f/Provider/deprecated/PerplexityAi.py  | 101 +++++++++++++++++++++++++
 g4f/Provider/deprecated/V50.py           |  67 +++++++++++++++++
 g4f/Provider/deprecated/Wewordle.py      |  65 ++++++++++++++++
 g4f/Provider/deprecated/Wuguokai.py      |  63 ++++++++++++++++
 g4f/Provider/deprecated/__init__.py      |  14 ++++
 g4f/Provider/needs_auth/Bard.py          |  92 +++++++++++++++++++++++
 g4f/Provider/needs_auth/HuggingChat.py   |  74 ++++++++++++++++++
 g4f/Provider/needs_auth/OpenAssistant.py | 100 +++++++++++++++++++++++++
 g4f/Provider/needs_auth/OpenaiChat.py    | 124 +++++++++++++++++++++++++++++++
 g4f/Provider/needs_auth/Raycast.py       |  72 ++++++++++++++++++
 g4f/Provider/needs_auth/Theb.py          |  97 ++++++++++++++++++++++++
 g4f/Provider/needs_auth/__init__.py      |   6 ++
 g4f/models.py                            |   4 +-
 testing/test_providers.py                |  20 +----
 48 files changed, 1545 insertions(+), 1550 deletions(-)
 delete mode 100644 g4f/Provider/AiService.py
 delete mode 100644 g4f/Provider/Bard.py
 delete mode 100644 g4f/Provider/CodeLinkAva.py
 delete mode 100644 g4f/Provider/DfeHub.py
 delete mode 100644 g4f/Provider/EasyChat.py
 delete mode 100644 g4f/Provider/Equing.py
 delete mode 100644 g4f/Provider/FastGpt.py
 delete mode 100644 g4f/Provider/Forefront.py
 delete mode 100644 g4f/Provider/GetGpt.py
 delete mode 100644 g4f/Provider/HuggingChat.py
 delete mode 100644 g4f/Provider/Lockchat.py
 delete mode 100644 g4f/Provider/Opchatgpts.py
 delete mode 100644 g4f/Provider/OpenAssistant.py
 delete mode 100644 g4f/Provider/OpenaiChat.py
 delete mode 100644 g4f/Provider/PerplexityAi.py
 delete mode 100644 g4f/Provider/Raycast.py
 delete mode 100644 g4f/Provider/Theb.py
 delete mode 100644 g4f/Provider/V50.py
 delete mode 100644 g4f/Provider/Wewordle.py
 delete mode 100644 g4f/Provider/Wuguokai.py
 create mode 100644 g4f/Provider/deprecated/AiService.py
 create mode 100644 g4f/Provider/deprecated/CodeLinkAva.py
 create mode 100644 g4f/Provider/deprecated/DfeHub.py
 create mode 100644 g4f/Provider/deprecated/EasyChat.py
 create mode 100644 g4f/Provider/deprecated/Equing.py
 create mode 100644 g4f/Provider/deprecated/FastGpt.py
 create mode 100644 g4f/Provider/deprecated/Forefront.py
 create mode 100644 g4f/Provider/deprecated/GetGpt.py
 create mode 100644 g4f/Provider/deprecated/Lockchat.py
 create mode 100644 g4f/Provider/deprecated/Opchatgpts.py
 create mode 100644 g4f/Provider/deprecated/PerplexityAi.py
 create mode 100644 g4f/Provider/deprecated/V50.py
 create mode 100644 g4f/Provider/deprecated/Wewordle.py
 create mode 100644 g4f/Provider/deprecated/Wuguokai.py
 create mode 100644 g4f/Provider/deprecated/__init__.py
 create mode 100644 g4f/Provider/needs_auth/Bard.py
 create mode 100644 g4f/Provider/needs_auth/HuggingChat.py
 create mode 100644 g4f/Provider/needs_auth/OpenAssistant.py
 create mode 100644 g4f/Provider/needs_auth/OpenaiChat.py
 create mode 100644 g4f/Provider/needs_auth/Raycast.py
 create mode 100644 g4f/Provider/needs_auth/Theb.py
 create mode 100644 g4f/Provider/needs_auth/__init__.py

diff --git a/g4f/Provider/AItianhu.py b/g4f/Provider/AItianhu.py
index 42631d7e..1d8653b7 100644
--- a/g4f/Provider/AItianhu.py
+++ b/g4f/Provider/AItianhu.py
@@ -38,6 +38,8 @@ class AItianhu(AsyncGeneratorProvider):
             async with session.post(f"{cls.url}/api/chat-process", json=data) as response:
                 response.raise_for_status()
                 async for line in response.iter_lines():
+                    if line == b"<script>":
+                        raise RuntimeError("Solve Challenge")
                     if b"platform's risk control" in line:
                         raise RuntimeError("Platform's Risk Control")
                     line = json.loads(line)
diff --git a/g4f/Provider/AItianhuSpace.py b/g4f/Provider/AItianhuSpace.py
index a6bf9a58..27f2b1fa 100644
--- a/g4f/Provider/AItianhuSpace.py
+++ b/g4f/Provider/AItianhuSpace.py
@@ -52,6 +52,8 @@ class AItianhuSpace(AsyncGeneratorProvider):
             async with session.post(f"{url}/api/chat-process", json=data, headers=headers) as response:
                 response.raise_for_status()
                 async for line in response.iter_lines():
+                    if line == b"<script>":
+                        raise RuntimeError("Solve Challenge")
                     if b"platform's risk control" in line:
                         raise RuntimeError("Platform's Risk Control")
                     line = json.loads(line)
diff --git a/g4f/Provider/AiService.py b/g4f/Provider/AiService.py
deleted file mode 100644
index 2b5a6e7d..00000000
--- a/g4f/Provider/AiService.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class AiService(BaseProvider):
-    url = "https://aiservice.vercel.app/"
-    working = False
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        base = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
-        base += "\nassistant: "
-
-        headers = {
-            "accept": "*/*",
-            "content-type": "text/plain;charset=UTF-8",
-            "sec-fetch-dest": "empty",
-            "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin",
-            "Referer": "https://aiservice.vercel.app/chat",
-        }
-        data = {"input": base}
-        url = "https://aiservice.vercel.app/api/chat/answer"
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        yield response.json()["data"]
diff --git a/g4f/Provider/Bard.py b/g4f/Provider/Bard.py
deleted file mode 100644
index 4e076378..00000000
--- a/g4f/Provider/Bard.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-import re
-
-from aiohttp import ClientSession
-
-from .base_provider import AsyncProvider, format_prompt, get_cookies
-
-
-class Bard(AsyncProvider):
-    url = "https://bard.google.com"
-    needs_auth = True
-    working = True
-    _snlm0e = None
-
-    @classmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        proxy: str = None,
-        cookies: dict = None,
-        **kwargs
-    ) -> str:
-        prompt = format_prompt(messages)
-        if proxy and "://" not in proxy:
-            proxy = f"http://{proxy}"
-        if not cookies:
-            cookies = get_cookies(".google.com")
-
-        headers = {
-            'authority': 'bard.google.com',
-            'origin': 'https://bard.google.com',
-            'referer': 'https://bard.google.com/',
-            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
-            'x-same-domain': '1',
-        }
-
-        async with ClientSession(
-            cookies=cookies,
-            headers=headers
-        ) as session:
-            if not cls._snlm0e:
-                async with session.get(cls.url, proxy=proxy) as response:
-                    text = await response.text()
-
-                match = re.search(r'SNlM0e\":\"(.*?)\"', text)
-                if not match:
-                    raise RuntimeError("No snlm0e value.")
-                cls._snlm0e = match.group(1)
-            
-            params = {
-                'bl': 'boq_assistant-bard-web-server_20230326.21_p0',
-                '_reqid': random.randint(1111, 9999),
-                'rt': 'c'
-            }
-
-            data = {
-                'at': cls._snlm0e,
-                'f.req': json.dumps([None, json.dumps([[prompt]])])
-            }
-
-            intents = '.'.join([
-                'assistant',
-                'lamda',
-                'BardFrontendService'
-            ])
-
-            async with session.post(
-                f'{cls.url}/_/BardChatUi/data/{intents}/StreamGenerate',
-                data=data,
-                params=params,
-                proxy=proxy
-            ) as response:
-                response = await response.text()
-                response = json.loads(response.splitlines()[3])[0][2]
-                response = json.loads(response)[4][0][1][0]
-                return response
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/CodeLinkAva.py b/g4f/Provider/CodeLinkAva.py
deleted file mode 100644
index e3b3eb3e..00000000
--- a/g4f/Provider/CodeLinkAva.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-import json
-
-from ..typing       import AsyncGenerator
-from .base_provider import AsyncGeneratorProvider
-
-
-class CodeLinkAva(AsyncGeneratorProvider):
-    url                   = "https://ava-ai-ef611.web.app"
-    supports_gpt_35_turbo = True
-    working               = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        **kwargs
-    ) -> AsyncGenerator:
-        headers = {
-            "User-Agent"         : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
-            "Accept"             : "*/*",
-            "Accept-language"    : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
-            "Origin"             : cls.url,
-            "Referer"            : cls.url + "/",
-            "Sec-Fetch-Dest"     : "empty",
-            "Sec-Fetch-Mode"     : "cors",
-            "Sec-Fetch-Site"     : "same-origin",
-        }
-        async with ClientSession(
-            headers=headers
-        ) as session:
-            data = {
-                "messages": messages,
-                "temperature": 0.6,
-                "stream": True,
-                **kwargs
-            }
-            async with session.post("https://ava-alpha-api.codelink.io/api/chat", json=data) as response:
-                response.raise_for_status()
-                async for line in response.content:
-                    line = line.decode()
-                    if line.startswith("data: "):
-                        if line.startswith("data: [DONE]"):
-                            break
-                        line = json.loads(line[6:-1])
-                        content = line["choices"][0]["delta"].get("content")
-                        if content:
-                            yield content
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/DeepAi.py b/g4f/Provider/DeepAi.py
index 80126d20..676f901e 100644
--- a/g4f/Provider/DeepAi.py
+++ b/g4f/Provider/DeepAi.py
@@ -56,7 +56,9 @@ f = function () {
         async with ClientSession(
             headers=headers
         ) as session:
-            async with session.post("https://api.deepai.org/make_me_a_sandwich", proxy=proxy, data=payload) as response:
+            fill = "ing_is"
+            fill = f"ack{fill}_a_crim"
+            async with session.post(f"https://api.deepai.org/h{fill}e", proxy=proxy, data=payload) as response:
                 response.raise_for_status()
                 async for stream in response.content.iter_any():
                     if stream:
diff --git a/g4f/Provider/DfeHub.py b/g4f/Provider/DfeHub.py
deleted file mode 100644
index d40e0380..00000000
--- a/g4f/Provider/DfeHub.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-import time
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class DfeHub(BaseProvider):
-    url                   = "https://chat.dfehub.com/"
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        headers = {
-            "authority"         : "chat.dfehub.com",
-            "accept"            : "*/*",
-            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
-            "content-type"      : "application/json",
-            "origin"            : "https://chat.dfehub.com",
-            "referer"           : "https://chat.dfehub.com/",
-            "sec-ch-ua"         : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
-            "sec-ch-ua-mobile"  : "?0",
-            "sec-ch-ua-platform": '"macOS"',
-            "sec-fetch-dest"    : "empty",
-            "sec-fetch-mode"    : "cors",
-            "sec-fetch-site"    : "same-origin",
-            "user-agent"        : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
-            "x-requested-with"  : "XMLHttpRequest",
-        }
-
-        json_data = {
-            "messages"          : messages,
-            "model"             : "gpt-3.5-turbo",
-            "temperature"       : kwargs.get("temperature", 0.5),
-            "presence_penalty"  : kwargs.get("presence_penalty", 0),
-            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
-            "top_p"             : kwargs.get("top_p", 1),
-            "stream"            : True
-        }
-        
-        response = requests.post("https://chat.dfehub.com/api/openai/v1/chat/completions",
-            headers=headers, json=json_data, timeout=3)
-
-        for chunk in response.iter_lines():
-            if b"detail" in chunk:
-                delay = re.findall(r"\d+\.\d+", chunk.decode())
-                delay = float(delay[-1])
-                time.sleep(delay)
-                yield from DfeHub.create_completion(model, messages, stream, **kwargs)
-            if b"content" in chunk:
-                data = json.loads(chunk.decode().split("data: ")[1])
-                yield (data["choices"][0]["delta"]["content"])
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/EasyChat.py b/g4f/Provider/EasyChat.py
deleted file mode 100644
index dae5196d..00000000
--- a/g4f/Provider/EasyChat.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class EasyChat(BaseProvider):
-    url: str              = "https://free.easychat.work"
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-    working               = False
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        active_servers = [
-            "https://chat10.fastgpt.me",
-            "https://chat9.fastgpt.me",
-            "https://chat1.fastgpt.me",
-            "https://chat2.fastgpt.me",
-            "https://chat3.fastgpt.me",
-            "https://chat4.fastgpt.me",
-            "https://gxos1h1ddt.fastgpt.me"
-        ]
-        
-        server  = active_servers[kwargs.get("active_server", random.randint(0, 5))]
-        headers = {
-            "authority"         : f"{server}".replace("https://", ""),
-            "accept"            : "text/event-stream",
-            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3,fa=0.2",
-            "content-type"      : "application/json",
-            "origin"            : f"{server}",
-            "referer"           : f"{server}/",
-            "x-requested-with"  : "XMLHttpRequest",
-            'plugins'           : '0',
-            'sec-ch-ua'         : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
-            'sec-ch-ua-mobile'  : '?0',
-            'sec-ch-ua-platform': '"Windows"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
-            'usesearch'         : 'false',
-            'x-requested-with'  : 'XMLHttpRequest'
-        }
-
-        json_data = {
-            "messages"          : messages,
-            "stream"            : stream,
-            "model"             : model,
-            "temperature"       : kwargs.get("temperature", 0.5),
-            "presence_penalty"  : kwargs.get("presence_penalty", 0),
-            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
-            "top_p"             : kwargs.get("top_p", 1)
-        }
-
-        session = requests.Session()
-        # init cookies from server
-        session.get(f"{server}/")
-
-        response = session.post(f"{server}/api/openai/v1/chat/completions",
-            headers=headers, json=json_data, stream=stream)
-        
-        if response.status_code == 200:
-            
-            if stream == False:
-                json_data = response.json()
-                
-                if "choices" in json_data:
-                    yield json_data["choices"][0]["message"]["content"]
-                else:
-                    raise Exception("No response from server")
-            
-            else:
-                
-                for chunk in response.iter_lines():
-                    
-                    if b"content" in chunk:
-                        splitData = chunk.decode().split("data:")
-                        
-                        if len(splitData) > 1:
-                            yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
-                        else:
-                            continue
-        else:
-            raise Exception(f"Error {response.status_code} from server : {response.reason}")
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int"),
-            ("active_server", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/Equing.py b/g4f/Provider/Equing.py
deleted file mode 100644
index 261c53c0..00000000
--- a/g4f/Provider/Equing.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-import json
-from abc import ABC, abstractmethod
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class Equing(BaseProvider):
-    url: str              = 'https://next.eqing.tech/'
-    working               = False
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = False
-
-    @staticmethod
-    @abstractmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-
-        headers = {
-            'authority'         : 'next.eqing.tech',
-            'accept'            : 'text/event-stream',
-            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-            'cache-control'     : 'no-cache',
-            'content-type'      : 'application/json',
-            'origin'            : 'https://next.eqing.tech',
-            'plugins'           : '0',
-            'pragma'            : 'no-cache',
-            'referer'           : 'https://next.eqing.tech/',
-            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
-            'sec-ch-ua-mobile'  : '?0',
-            'sec-ch-ua-platform': '"macOS"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
-            'usesearch'         : 'false',
-            'x-requested-with'  : 'XMLHttpRequest'
-        }
-
-        json_data = {
-            'messages'          : messages,
-            'stream'            : stream,
-            'model'             : model,
-            'temperature'       : kwargs.get('temperature', 0.5),
-            'presence_penalty'  : kwargs.get('presence_penalty', 0),
-            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
-            'top_p'             : kwargs.get('top_p', 1),
-        }
-
-        response = requests.post('https://next.eqing.tech/api/openai/v1/chat/completions',
-            headers=headers, json=json_data, stream=stream)
-        
-        if not stream:
-            yield response.json()["choices"][0]["message"]["content"]
-            return
-        
-        for line in response.iter_content(chunk_size=1024):
-            if line:
-                if b'content' in line:
-                        line_json = json.loads(line.decode('utf-8').split('data: ')[1])
-                        token = line_json['choices'][0]['delta'].get('content')
-                        if token:
-                            yield token
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/FastGpt.py b/g4f/Provider/FastGpt.py
deleted file mode 100644
index ef47f752..00000000
--- a/g4f/Provider/FastGpt.py
+++ /dev/null
@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-from abc import ABC, abstractmethod
-
-import requests
-
-from ..typing import Any, CreateResult
-
-
-class FastGpt(ABC):
-    url: str                = 'https://chat9.fastgpt.me/'
-    working                 = False
-    needs_auth              = False
-    supports_stream         = True
-    supports_gpt_35_turbo   = True
-    supports_gpt_4          = False
-
-    @staticmethod
-    @abstractmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-
-        headers = {
-            'authority'         : 'chat9.fastgpt.me',
-            'accept'            : 'text/event-stream',
-            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-            'cache-control'     : 'no-cache',
-            'content-type'      : 'application/json',
-            'origin'            : 'https://chat9.fastgpt.me',
-            'plugins'           : '0',
-            'pragma'            : 'no-cache',
-            'referer'           : 'https://chat9.fastgpt.me/',
-            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
-            'sec-ch-ua-mobile'  : '?0',
-            'sec-ch-ua-platform': '"macOS"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
-            'usesearch'         : 'false',
-            'x-requested-with'  : 'XMLHttpRequest',
-        }
-
-        json_data = {
-            'messages'          : messages,
-            'stream'            : stream,
-            'model'             : model,
-            'temperature'       : kwargs.get('temperature', 0.5),
-            'presence_penalty'  : kwargs.get('presence_penalty', 0),
-            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
-            'top_p'             : kwargs.get('top_p', 1),
-        }
-        
-        subdomain = random.choice([
-            'jdaen979ew',
-            'chat9'
-        ])
-
-        response = requests.post(f'https://{subdomain}.fastgpt.me/api/openai/v1/chat/completions',
-                                 headers=headers, json=json_data, stream=stream)
-        
-        for line in response.iter_lines():
-            if line:
-                try:
-                    if b'content' in line:
-                            line_json = json.loads(line.decode('utf-8').split('data: ')[1])
-                            token = line_json['choices'][0]['delta'].get('content')
-                            if token:
-                                yield token
-                except:
-                    continue
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/Forefront.py b/g4f/Provider/Forefront.py
deleted file mode 100644
index 8f51fb57..00000000
--- a/g4f/Provider/Forefront.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class Forefront(BaseProvider):
-    url                   = "https://forefront.com"
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        json_data = {
-            "text"          : messages[-1]["content"],
-            "action"        : "noauth",
-            "id"            : "",
-            "parentId"      : "",
-            "workspaceId"   : "",
-            "messagePersona": "607e41fe-95be-497e-8e97-010a59b2e2c0",
-            "model"         : "gpt-4",
-            "messages"      : messages[:-1] if len(messages) > 1 else [],
-            "internetMode"  : "auto",
-        }
-
-        response = requests.post("https://streaming.tenant-forefront-default.knative.chi.coreweave.com/free-chat",
-            json=json_data, stream=True)
-        
-        response.raise_for_status()
-        for token in response.iter_lines():
-            if b"delta" in token:
-                yield json.loads(token.decode().split("data: ")[1])["delta"]
diff --git a/g4f/Provider/GetGpt.py b/g4f/Provider/GetGpt.py
deleted file mode 100644
index b96efaac..00000000
--- a/g4f/Provider/GetGpt.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import uuid
-
-import requests
-from Crypto.Cipher import AES
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class GetGpt(BaseProvider):
-    url                   = 'https://chat.getgpt.world/'
-    supports_stream       = True
-    working               = False
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        headers = {
-            'Content-Type'  : 'application/json',
-            'Referer'       : 'https://chat.getgpt.world/',
-            'user-agent'    : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
-        }
-        
-        data = json.dumps(
-            {
-                'messages'          : messages,
-                'frequency_penalty' : kwargs.get('frequency_penalty', 0),
-                'max_tokens'        : kwargs.get('max_tokens', 4000),
-                'model'             : 'gpt-3.5-turbo',
-                'presence_penalty'  : kwargs.get('presence_penalty', 0),
-                'temperature'       : kwargs.get('temperature', 1),
-                'top_p'             : kwargs.get('top_p', 1),
-                'stream'            : True,
-                'uuid'              : str(uuid.uuid4())
-            }
-        )
-
-        res = requests.post('https://chat.getgpt.world/api/chat/stream',
-            headers=headers, json={'signature': _encrypt(data)}, stream=True)
-
-        res.raise_for_status()
-        for line in res.iter_lines():
-            if b'content' in line:
-                line_json = json.loads(line.decode('utf-8').split('data: ')[1])
-                yield (line_json['choices'][0]['delta']['content'])
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ('model', 'str'),
-            ('messages', 'list[dict[str, str]]'),
-            ('stream', 'bool'),
-            ('temperature', 'float'),
-            ('presence_penalty', 'int'),
-            ('frequency_penalty', 'int'),
-            ('top_p', 'int'),
-            ('max_tokens', 'int'),
-        ]
-        param = ', '.join([': '.join(p) for p in params])
-        return f'g4f.provider.{cls.__name__} supports: ({param})'
-
-
-def _encrypt(e: str):
-    t = os.urandom(8).hex().encode('utf-8')
-    n = os.urandom(8).hex().encode('utf-8')
-    r = e.encode('utf-8')
-    
-    cipher     = AES.new(t, AES.MODE_CBC, n)
-    ciphertext = cipher.encrypt(_pad_data(r))
-    
-    return ciphertext.hex() + t.decode('utf-8') + n.decode('utf-8')
-
-
-def _pad_data(data: bytes) -> bytes:
-    block_size   = AES.block_size
-    padding_size = block_size - len(data) % block_size
-    padding      = bytes([padding_size] * padding_size)
-    
-    return data + padding
diff --git a/g4f/Provider/HuggingChat.py b/g4f/Provider/HuggingChat.py
deleted file mode 100644
index f1cec775..00000000
--- a/g4f/Provider/HuggingChat.py
+++ /dev/null
@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import json, uuid
-
-from aiohttp import ClientSession
-
-from ..typing import AsyncGenerator
-from .base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
-
-
-class HuggingChat(AsyncGeneratorProvider):
-    url = "https://huggingface.co/chat"
-    needs_auth = True
-    working = True
-    model = "meta-llama/Llama-2-70b-chat-hf"
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool = True,
-        proxy: str = None,
-        cookies: dict = None,
-        **kwargs
-    ) -> AsyncGenerator:
-        model = model if model else cls.model
-        if proxy and "://" not in proxy:
-            proxy = f"http://{proxy}"
-        if not cookies:
-            cookies = get_cookies(".huggingface.co")
-
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
-        }
-        async with ClientSession(
-            cookies=cookies,
-            headers=headers
-        ) as session:
-            async with session.post(f"{cls.url}/conversation", json={"model": model}, proxy=proxy) as response:
-                conversation_id = (await response.json())["conversationId"]
-
-            send = {
-                "id": str(uuid.uuid4()),
-                "inputs": format_prompt(messages),
-                "is_retry": False,
-                "response_id": str(uuid.uuid4()),
-                "web_search": False
-            }
-            async with session.post(f"{cls.url}/conversation/{conversation_id}", json=send, proxy=proxy) as response:
-                async for line in response.content:
-                    line = json.loads(line[:-1])
-                    if "type" not in line:
-                        raise RuntimeError(f"Response: {line}")
-                    elif line["type"] == "stream":
-                        yield line["token"]
-                    elif line["type"] == "finalAnswer":
-                        break
-                
-            async with session.delete(f"{cls.url}/conversation/{conversation_id}", proxy=proxy) as response:
-                response.raise_for_status()
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/Lockchat.py b/g4f/Provider/Lockchat.py
deleted file mode 100644
index c15eec8d..00000000
--- a/g4f/Provider/Lockchat.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class Lockchat(BaseProvider):
-    url: str              = "http://supertest.lockchat.app"
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-
-        temperature = float(kwargs.get("temperature", 0.7))
-        payload = {
-            "temperature": temperature,
-            "messages"   : messages,
-            "model"      : model,
-            "stream"     : True,
-        }
-
-        headers = {
-            "user-agent": "ChatX/39 CFNetwork/1408.0.4 Darwin/22.5.0",
-        }
-        response = requests.post("http://supertest.lockchat.app/v1/chat/completions",
-                                 json=payload, headers=headers, stream=True)
-        
-        response.raise_for_status()
-        for token in response.iter_lines():
-            if b"The model: `gpt-4` does not exist" in token:
-                print("error, retrying...")
-                Lockchat.create_completion(
-                    model       = model,
-                    messages    = messages,
-                    stream      = stream,
-                    temperature = temperature,
-                    **kwargs)
-            
-            if b"content" in token:
-                token = json.loads(token.decode("utf-8").split("data: ")[1])
-                token = token["choices"][0]["delta"].get("content")
-                if token:
-                    yield (token)
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/Opchatgpts.py b/g4f/Provider/Opchatgpts.py
deleted file mode 100644
index 166323bd..00000000
--- a/g4f/Provider/Opchatgpts.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-from .ChatgptLogin import ChatgptLogin
-
-
-class Opchatgpts(ChatgptLogin):
-    url     = "https://opchatgpts.net"
-    working = True
\ No newline at end of file
diff --git a/g4f/Provider/OpenAssistant.py b/g4f/Provider/OpenAssistant.py
deleted file mode 100644
index 1e9a0661..00000000
--- a/g4f/Provider/OpenAssistant.py
+++ /dev/null
@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-import json
-
-from aiohttp import ClientSession
-
-from ..typing import Any, AsyncGenerator
-from .base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
-
-
-class OpenAssistant(AsyncGeneratorProvider):
-    url = "https://open-assistant.io/chat"
-    needs_auth = True
-    working = True
-    model = "OA_SFT_Llama_30B_6"
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        proxy: str = None,
-        cookies: dict = None,
-        **kwargs: Any
-    ) -> AsyncGenerator:
-        if not cookies:
-            cookies = get_cookies("open-assistant.io")
-
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
-        }
-        async with ClientSession(
-            cookies=cookies,
-            headers=headers
-        ) as session:
-            async with session.post("https://open-assistant.io/api/chat", proxy=proxy) as response:
-                chat_id = (await response.json())["id"]
-
-            data = {
-                "chat_id": chat_id,
-                "content": f"<s>[INST]\n{format_prompt(messages)}\n[/INST]",
-                "parent_id": None
-            }
-            async with session.post("https://open-assistant.io/api/chat/prompter_message", proxy=proxy, json=data) as response:
-                parent_id = (await response.json())["id"]
-
-            data = {
-                "chat_id": chat_id,
-                "parent_id": parent_id,
-                "model_config_name": model if model else cls.model,
-                "sampling_parameters":{
-                    "top_k": 50,
-                    "top_p": None,
-                    "typical_p": None,
-                    "temperature": 0.35,
-                    "repetition_penalty": 1.1111111111111112,
-                    "max_new_tokens": 1024,
-                    **kwargs
-                },
-                "plugins":[]
-            }
-            async with session.post("https://open-assistant.io/api/chat/assistant_message", proxy=proxy, json=data) as response:
-                data = await response.json()
-                if "id" in  data:
-                    message_id = data["id"]
-                elif "message" in data:
-                    raise RuntimeError(data["message"])
-                else:
-                    response.raise_for_status()
-            
-            params = {
-                'chat_id': chat_id,
-                'message_id': message_id,
-            }
-            async with session.post("https://open-assistant.io/api/chat/events", proxy=proxy, params=params) as response:
-                start = "data: "
-                async for line in response.content:
-                    line = line.decode("utf-8")
-                    if line and line.startswith(start):
-                        line = json.loads(line[len(start):])
-                        if line["event_type"] == "token":
-                            yield line["text"]
-
-            params = {
-                'chat_id': chat_id,
-            }
-            async with session.delete("https://open-assistant.io/api/chat", proxy=proxy, params=params) as response:
-                response.raise_for_status()
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/OpenaiChat.py b/g4f/Provider/OpenaiChat.py
deleted file mode 100644
index 8f183fb9..00000000
--- a/g4f/Provider/OpenaiChat.py
+++ /dev/null
@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-import uuid, json, time
-
-from .base_provider import AsyncGeneratorProvider
-from .helper import get_browser, get_cookies, format_prompt
-from ..typing import AsyncGenerator
-from ..requests import StreamSession
-
-class OpenaiChat(AsyncGeneratorProvider):
-    url                   = "https://chat.openai.com"
-    needs_auth            = True
-    working               = True
-    supports_gpt_35_turbo = True
-    _access_token         = None
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        proxy: str = None,
-        access_token: str = None,
-        cookies: dict = None,
-        **kwargs: dict
-    ) -> AsyncGenerator:
-        proxies = {"https": proxy}
-        if not access_token:
-            access_token = await cls.get_access_token(cookies, proxies)
-        headers = {
-            "Accept": "text/event-stream",
-            "Authorization": f"Bearer {access_token}",
-        }
-        async with StreamSession(proxies=proxies, headers=headers, impersonate="chrome107") as session:
-            messages = [
-                {
-                    "id": str(uuid.uuid4()),
-                    "author": {"role": "user"},
-                    "content": {"content_type": "text", "parts": [format_prompt(messages)]},
-                },
-            ]
-            data = {
-                "action": "next",
-                "messages": messages,
-                "conversation_id": None,
-                "parent_message_id": str(uuid.uuid4()),
-                "model": "text-davinci-002-render-sha",
-                "history_and_training_disabled": True,
-            }
-            async with session.post(f"{cls.url}/backend-api/conversation", json=data) as response:
-                response.raise_for_status()
-                last_message = ""
-                async for line in response.iter_lines():
-                    if line.startswith(b"data: "):
-                        line = line[6:]
-                        if line == b"[DONE]":
-                            break
-                        try:
-                            line = json.loads(line)
-                        except:
-                            continue
-                        if "message" not in line or "message_type" not in line["message"]["metadata"]:
-                            continue
-                        if line["message"]["metadata"]["message_type"] == "next":
-                            new_message = line["message"]["content"]["parts"][0]
-                            yield new_message[len(last_message):]
-                            last_message = new_message
-
-    @classmethod
-    def browse_access_token(cls) -> str:
-        try:
-            from selenium.webdriver.common.by import By
-            from selenium.webdriver.support.ui import WebDriverWait
-            from selenium.webdriver.support import expected_conditions as EC
-
-            driver = get_browser()
-        except ImportError:
-            return
-
-        driver.get(f"{cls.url}/")
-        try:
-            WebDriverWait(driver, 1200).until(
-                EC.presence_of_element_located((By.ID, "prompt-textarea"))
-            )
-            javascript = "return (await (await fetch('/api/auth/session')).json())['accessToken']"
-            return driver.execute_script(javascript)
-        finally:
-            time.sleep(1)
-            driver.quit()
-
-    @classmethod
-    async def fetch_access_token(cls, cookies: dict, proxies: dict = None) -> str:
-        async with StreamSession(proxies=proxies, cookies=cookies, impersonate="chrome107") as session:
-            async with session.get(f"{cls.url}/api/auth/session") as response:
-                response.raise_for_status()
-                auth = await response.json()
-                if "accessToken" in auth:
-                    return auth["accessToken"]
-
-    @classmethod
-    async def get_access_token(cls, cookies: dict = None, proxies: dict = None) -> str:
-        if not cls._access_token:
-            cookies = cookies if cookies else get_cookies("chat.openai.com")
-            if cookies:
-                cls._access_token = await cls.fetch_access_token(cookies, proxies)
-        if not cls._access_token:
-            cls._access_token = cls.browse_access_token()
-        if not cls._access_token:
-            raise RuntimeError("Read access token failed")
-        return cls._access_token
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-            ("access_token", "str"),
-            ("cookies", "dict[str, str]")
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/PerplexityAi.py b/g4f/Provider/PerplexityAi.py
deleted file mode 100644
index c7e58ad3..00000000
--- a/g4f/Provider/PerplexityAi.py
+++ /dev/null
@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-import json
-import time
-import base64
-from curl_cffi.requests import AsyncSession
-
-from .base_provider import AsyncProvider, format_prompt, get_cookies
-
-
-class PerplexityAi(AsyncProvider):
-    url                   = "https://www.perplexity.ai"
-    working               = False
-    supports_gpt_35_turbo = True
-    _sources              = []
-
-    @classmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        proxy: str = None,
-        **kwargs
-    ) -> str:
-        url = cls.url + "/socket.io/?EIO=4&transport=polling"
-        headers = {
-            "Referer": f"{cls.url}/"
-        }
-        async with AsyncSession(headers=headers, proxies={"https": proxy}, impersonate="chrome107") as session:
-            url_session = "https://www.perplexity.ai/api/auth/session"
-            response = await session.get(url_session)
-            response.raise_for_status()
-
-            url_session = "https://www.perplexity.ai/api/auth/session"
-            response = await session.get(url_session)
-            response.raise_for_status()
-
-            response = await session.get(url, params={"t": timestamp()})
-            response.raise_for_status()
-            sid = json.loads(response.text[1:])["sid"]
-
-            response = await session.get(url, params={"t": timestamp(), "sid": sid})
-            response.raise_for_status()
-
-            data = '40{"jwt":"anonymous-ask-user"}'
-            response = await session.post(url, params={"t": timestamp(), "sid": sid}, data=data)
-            response.raise_for_status()
-
-            response = await session.get(url, params={"t": timestamp(), "sid": sid})
-            response.raise_for_status()
-
-            data = "424" + json.dumps([
-                "perplexity_ask",
-                format_prompt(messages),
-                {
-                    "version":"2.1",
-                    "source":"default",
-                    "language":"en",
-                    "timezone": time.tzname[0],
-                    "search_focus":"internet",
-                    "mode":"concise"
-                }
-            ])
-            response = await session.post(url, params={"t": timestamp(), "sid": sid}, data=data)
-            response.raise_for_status()
-
-            while True:
-                response = await session.get(url, params={"t": timestamp(), "sid": sid})
-                response.raise_for_status()
-                for line in response.text.splitlines():
-                    if line.startswith("434"):
-                        result = json.loads(json.loads(line[3:])[0]["text"])
-
-                        cls._sources = [{
-                            "title": source["name"],
-                            "url": source["url"],
-                            "snippet": source["snippet"]
-                        } for source in result["web_results"]]
-
-                        return result["answer"]
-
-    @classmethod
-    def get_sources(cls):
-        return cls._sources
-
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("proxy", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
-
-
-def timestamp() -> str:
-    return base64.urlsafe_b64encode(int(time.time()-1407782612).to_bytes(4, 'big')).decode()
\ No newline at end of file
diff --git a/g4f/Provider/Raycast.py b/g4f/Provider/Raycast.py
deleted file mode 100644
index 7ddc8acd..00000000
--- a/g4f/Provider/Raycast.py
+++ /dev/null
@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class Raycast(BaseProvider):
-    url                     = "https://raycast.com"
-    supports_gpt_35_turbo   = True
-    supports_gpt_4          = True
-    supports_stream         = True
-    needs_auth              = True
-    working                 = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        auth = kwargs.get('auth')
-        headers = {
-            'Accept': 'application/json',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Authorization': f'Bearer {auth}',
-            'Content-Type': 'application/json',
-            'User-Agent': 'Raycast/0 CFNetwork/1410.0.3 Darwin/22.6.0',
-        }
-        parsed_messages = []
-        for message in messages:
-            parsed_messages.append({
-                'author': message['role'],
-                'content': {'text': message['content']}
-            })
-        data = {
-            "debug": False,
-            "locale": "en-CN",
-            "messages": parsed_messages,
-            "model": model,
-            "provider": "openai",
-            "source": "ai_chat",
-            "system_instruction": "markdown",
-            "temperature": 0.5
-        }
-        response = requests.post("https://backend.raycast.com/api/v1/ai/chat_completions", headers=headers, json=data, stream=True)
-        for token in response.iter_lines():
-            if b'data: ' not in token:
-                continue
-            completion_chunk = json.loads(token.decode().replace('data: ', ''))
-            token = completion_chunk['text']
-            if token != None:
-                yield token
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("top_p", "int"),
-            ("model", "str"),
-            ("auth", "str"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/Theb.py b/g4f/Provider/Theb.py
deleted file mode 100644
index 72fce3ac..00000000
--- a/g4f/Provider/Theb.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class Theb(BaseProvider):
-    url                     = "https://theb.ai"
-    working                 = True
-    supports_stream         = True
-    supports_gpt_35_turbo   = True
-    needs_auth              = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
-        conversation += "\nassistant: "
-        
-        auth = kwargs.get("auth", {
-            "bearer_token":"free",
-            "org_id":"theb",
-        })
-        
-        bearer_token = auth["bearer_token"]
-        org_id       = auth["org_id"]
-        
-        headers = {
-            'authority'         : 'beta.theb.ai',
-            'accept'            : 'text/event-stream',
-            'accept-language'   : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
-            'authorization'     : 'Bearer '+bearer_token,
-            'content-type'      : 'application/json',
-            'origin'            : 'https://beta.theb.ai',
-            'referer'           : 'https://beta.theb.ai/home',
-            'sec-ch-ua'         : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
-            'sec-ch-ua-mobile'  : '?0',
-            'sec-ch-ua-platform': '"Windows"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
-            'x-ai-model'        : 'ee8d4f29cb7047f78cbe84313ed6ace8',
-        }
-        
-        req_rand = random.randint(100000000, 9999999999)
-
-        json_data: dict[str, Any] = {
-            "text"      : conversation,
-            "category"  : "04f58f64a4aa4191a957b47290fee864",
-            "model"     : "ee8d4f29cb7047f78cbe84313ed6ace8",
-            "model_params": {
-                "system_prompt"     : "You are ChatGPT, a large language model trained by OpenAI, based on the GPT-3.5 architecture.\nKnowledge cutoff: 2021-09\nCurrent date: {{YYYY-MM-DD}}",
-                "temperature"       : kwargs.get("temperature", 1),
-                "top_p"             : kwargs.get("top_p", 1),
-                "frequency_penalty" : kwargs.get("frequency_penalty", 0),
-                "presence_penalty"  : kwargs.get("presence_penalty", 0),
-                "long_term_memory"  : "auto"
-            }
-        }
-        
-        response = requests.post(f"https://beta.theb.ai/api/conversation?org_id={org_id}&req_rand={req_rand}",
-                                 headers=headers, json=json_data, stream=True)
-        
-        response.raise_for_status()
-        content = ""
-        next_content = ""
-        for chunk in response.iter_lines():
-            if b"content" in chunk:
-                next_content = content
-                data = json.loads(chunk.decode().split("data: ")[1])
-                content = data["content"]
-                yield data["content"].replace(next_content, "")
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("auth", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int")
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/V50.py b/g4f/Provider/V50.py
deleted file mode 100644
index 81a95ba8..00000000
--- a/g4f/Provider/V50.py
+++ /dev/null
@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-import uuid
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class V50(BaseProvider):
-    url                     = 'https://p5.v50.ltd'
-    supports_gpt_35_turbo   = True
-    supports_stream         = False
-    needs_auth              = False
-    working                 = False
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
-        conversation += "\nassistant: "
-
-        payload = {
-            "prompt"        : conversation,
-            "options"       : {},
-            "systemMessage" : ".",
-            "temperature"   : kwargs.get("temperature", 0.4),
-            "top_p"         : kwargs.get("top_p", 0.4),
-            "model"         : model,
-            "user"          : str(uuid.uuid4())
-        }
-        
-        headers = {
-            'authority'         : 'p5.v50.ltd',
-            'accept'            : 'application/json, text/plain, */*',
-            'accept-language'   : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
-            'content-type'      : 'application/json',
-            'origin'            : 'https://p5.v50.ltd',
-            'referer'           : 'https://p5.v50.ltd/',
-            'sec-ch-ua-platform': '"Windows"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36'
-        }
-        response = requests.post("https://p5.v50.ltd/api/chat-process", 
-                                json=payload, headers=headers, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
-        
-        if "https://fk1.v50.ltd" not in response.text:
-            yield response.text
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("top_p", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/Wewordle.py b/g4f/Provider/Wewordle.py
deleted file mode 100644
index 26d040c3..00000000
--- a/g4f/Provider/Wewordle.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-import random, string, time
-from aiohttp import ClientSession
-
-from .base_provider import AsyncProvider
-
-
-class Wewordle(AsyncProvider):
-    url                    = "https://wewordle.org"
-    working                = False
-    supports_gpt_35_turbo  = True
-
-    @classmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        proxy: str = None,
-        **kwargs
-    ) -> str:
-        
-        headers = {
-            "accept"        : "*/*",
-            "pragma"        : "no-cache",
-            "Content-Type"  : "application/json",
-            "Connection"    : "keep-alive"
-        }
-
-        _user_id = "".join(random.choices(f"{string.ascii_lowercase}{string.digits}", k=16))
-        _app_id = "".join(random.choices(f"{string.ascii_lowercase}{string.digits}", k=31))
-        _request_date = time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime())
-        data = {
-            "user"      : _user_id,
-            "messages"  : messages,
-            "subscriber": {
-                "originalPurchaseDate"          : None,
-                "originalApplicationVersion"    : None,
-                "allPurchaseDatesMillis"        : {},
-                "entitlements"                  : {"active": {}, "all": {}},
-                "allPurchaseDates"              : {},
-                "allExpirationDatesMillis"      : {},
-                "allExpirationDates"            : {},
-                "originalAppUserId"             : f"$RCAnonymousID:{_app_id}",
-                "latestExpirationDate"          : None,
-                "requestDate"                   : _request_date,
-                "latestExpirationDateMillis"    : None,
-                "nonSubscriptionTransactions"   : [],
-                "originalPurchaseDateMillis"    : None,
-                "managementURL"                 : None,
-                "allPurchasedProductIdentifiers": [],
-                "firstSeen"                     : _request_date,
-                "activeSubscriptions"           : [],
-            }
-        }
-
-
-        async with ClientSession(
-            headers=headers
-        ) as session:
-            async with session.post(f"{cls.url}/gptapi/v1/android/turbo", proxy=proxy, json=data) as response:
-                response.raise_for_status()
-                content = (await response.json())["message"]["content"]
-                if content:
-                    return content
\ No newline at end of file
diff --git a/g4f/Provider/Wuguokai.py b/g4f/Provider/Wuguokai.py
deleted file mode 100644
index 0a46f6ee..00000000
--- a/g4f/Provider/Wuguokai.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import random
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider, format_prompt
-
-
-class Wuguokai(BaseProvider):
-    url = 'https://chat.wuguokai.xyz'
-    supports_gpt_35_turbo = True
-    working = False
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        headers = {
-            'authority': 'ai-api.wuguokai.xyz',
-            'accept': 'application/json, text/plain, */*',
-            'accept-language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
-            'content-type': 'application/json',
-            'origin': 'https://chat.wuguokai.xyz',
-            'referer': 'https://chat.wuguokai.xyz/',
-            'sec-ch-ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
-            'sec-ch-ua-mobile': '?0',
-            'sec-ch-ua-platform': '"Windows"',
-            'sec-fetch-dest': 'empty',
-            'sec-fetch-mode': 'cors',
-            'sec-fetch-site': 'same-site',
-            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
-        }
-        data ={
-            "prompt": format_prompt(messages),
-            "options": {},
-            "userId": f"#/chat/{random.randint(1,99999999)}",
-            "usingContext": True
-        }
-        response = requests.post("https://ai-api20.wuguokai.xyz/api/chat-process", headers=headers, timeout=3, json=data, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
-        _split = response.text.split("> 若回答失败请重试或多刷新几次界面后重试")
-        if response.status_code == 200:
-            if len(_split) > 1:
-                yield _split[1].strip()
-            else:
-                yield _split[0].strip()
-        else:
-            raise Exception(f"Error: {response.status_code} {response.reason}")
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool")
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/__init__.py b/g4f/Provider/__init__.py
index 2ac4191b..72a459c2 100644
--- a/g4f/Provider/__init__.py
+++ b/g4f/Provider/__init__.py
@@ -3,50 +3,32 @@ from .Acytoo        import Acytoo
 from .Aibn          import Aibn
 from .Aichat        import Aichat
 from .Ails          import Ails
-from .AiService     import AiService
 from .AItianhu      import AItianhu
 from .AItianhuSpace import AItianhuSpace
 from .Aivvm         import Aivvm
-from .Bard          import Bard
 from .Bing          import Bing
 from .ChatBase      import ChatBase
 from .ChatForAi     import ChatForAi
 from .ChatgptAi     import ChatgptAi
 from .ChatgptDuo    import ChatgptDuo
 from .ChatgptLogin  import ChatgptLogin
-from .CodeLinkAva   import CodeLinkAva
 from .DeepAi        import DeepAi
-from .DfeHub        import DfeHub
-from .EasyChat      import EasyChat
-from .Forefront     import Forefront
 from .FreeGpt       import FreeGpt
-from .GetGpt        import GetGpt
 from .GptGo         import GptGo
 from .H2o           import H2o
-from .HuggingChat   import HuggingChat
 from .Liaobots      import Liaobots
-from .Lockchat      import Lockchat
 from .Myshell       import Myshell
-from .Opchatgpts    import Opchatgpts
-from .OpenaiChat    import OpenaiChat
-from .OpenAssistant import OpenAssistant
-from .PerplexityAi  import PerplexityAi
 from .Phind         import Phind
-from .Raycast       import Raycast
-from .Theb          import Theb
 from .Vercel        import Vercel
 from .Vitalentum    import Vitalentum
-from .Wewordle      import Wewordle
 from .Ylokh         import Ylokh
 from .You           import You
 from .Yqcloud       import Yqcloud
-from .Equing        import Equing
-from .FastGpt       import FastGpt
-from .V50           import V50
-from .Wuguokai      import Wuguokai
 
 from .base_provider  import BaseProvider, AsyncProvider, AsyncGeneratorProvider
 from .retry_provider import RetryProvider
+from .deprecated     import *
+from .needs_auth     import *
 
 __all__ = [
     'BaseProvider',
diff --git a/g4f/Provider/deprecated/AiService.py b/g4f/Provider/deprecated/AiService.py
new file mode 100644
index 00000000..9b41e3c8
--- /dev/null
+++ b/g4f/Provider/deprecated/AiService.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class AiService(BaseProvider):
+    url = "https://aiservice.vercel.app/"
+    working = False
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
+        base += "\nassistant: "
+
+        headers = {
+            "accept": "*/*",
+            "content-type": "text/plain;charset=UTF-8",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "Referer": "https://aiservice.vercel.app/chat",
+        }
+        data = {"input": base}
+        url = "https://aiservice.vercel.app/api/chat/answer"
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        yield response.json()["data"]
diff --git a/g4f/Provider/deprecated/CodeLinkAva.py b/g4f/Provider/deprecated/CodeLinkAva.py
new file mode 100644
index 00000000..8407ebb9
--- /dev/null
+++ b/g4f/Provider/deprecated/CodeLinkAva.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from aiohttp import ClientSession
+import json
+
+from ...typing       import AsyncGenerator
+from ..base_provider import AsyncGeneratorProvider
+
+
+class CodeLinkAva(AsyncGeneratorProvider):
+    url                   = "https://ava-ai-ef611.web.app"
+    supports_gpt_35_turbo = True
+    working               = False
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ) -> AsyncGenerator:
+        headers = {
+            "User-Agent"         : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
+            "Accept"             : "*/*",
+            "Accept-language"    : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "Origin"             : cls.url,
+            "Referer"            : cls.url + "/",
+            "Sec-Fetch-Dest"     : "empty",
+            "Sec-Fetch-Mode"     : "cors",
+            "Sec-Fetch-Site"     : "same-origin",
+        }
+        async with ClientSession(
+            headers=headers
+        ) as session:
+            data = {
+                "messages": messages,
+                "temperature": 0.6,
+                "stream": True,
+                **kwargs
+            }
+            async with session.post("https://ava-alpha-api.codelink.io/api/chat", json=data) as response:
+                response.raise_for_status()
+                async for line in response.content:
+                    line = line.decode()
+                    if line.startswith("data: "):
+                        if line.startswith("data: [DONE]"):
+                            break
+                        line = json.loads(line[6:-1])
+                        content = line["choices"][0]["delta"].get("content")
+                        if content:
+                            yield content
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/DfeHub.py b/g4f/Provider/deprecated/DfeHub.py
new file mode 100644
index 00000000..4ea7501f
--- /dev/null
+++ b/g4f/Provider/deprecated/DfeHub.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class DfeHub(BaseProvider):
+    url                   = "https://chat.dfehub.com/"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        headers = {
+            "authority"         : "chat.dfehub.com",
+            "accept"            : "*/*",
+            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "content-type"      : "application/json",
+            "origin"            : "https://chat.dfehub.com",
+            "referer"           : "https://chat.dfehub.com/",
+            "sec-ch-ua"         : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
+            "sec-ch-ua-mobile"  : "?0",
+            "sec-ch-ua-platform": '"macOS"',
+            "sec-fetch-dest"    : "empty",
+            "sec-fetch-mode"    : "cors",
+            "sec-fetch-site"    : "same-origin",
+            "user-agent"        : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
+            "x-requested-with"  : "XMLHttpRequest",
+        }
+
+        json_data = {
+            "messages"          : messages,
+            "model"             : "gpt-3.5-turbo",
+            "temperature"       : kwargs.get("temperature", 0.5),
+            "presence_penalty"  : kwargs.get("presence_penalty", 0),
+            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
+            "top_p"             : kwargs.get("top_p", 1),
+            "stream"            : True
+        }
+        
+        response = requests.post("https://chat.dfehub.com/api/openai/v1/chat/completions",
+            headers=headers, json=json_data, timeout=3)
+
+        for chunk in response.iter_lines():
+            if b"detail" in chunk:
+                delay = re.findall(r"\d+\.\d+", chunk.decode())
+                delay = float(delay[-1])
+                time.sleep(delay)
+                yield from DfeHub.create_completion(model, messages, stream, **kwargs)
+            if b"content" in chunk:
+                data = json.loads(chunk.decode().split("data: ")[1])
+                yield (data["choices"][0]["delta"]["content"])
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/deprecated/EasyChat.py b/g4f/Provider/deprecated/EasyChat.py
new file mode 100644
index 00000000..ffe9a785
--- /dev/null
+++ b/g4f/Provider/deprecated/EasyChat.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+import random
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class EasyChat(BaseProvider):
+    url: str              = "https://free.easychat.work"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+    working               = False
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        active_servers = [
+            "https://chat10.fastgpt.me",
+            "https://chat9.fastgpt.me",
+            "https://chat1.fastgpt.me",
+            "https://chat2.fastgpt.me",
+            "https://chat3.fastgpt.me",
+            "https://chat4.fastgpt.me",
+            "https://gxos1h1ddt.fastgpt.me"
+        ]
+        
+        server  = active_servers[kwargs.get("active_server", random.randint(0, 5))]
+        headers = {
+            "authority"         : f"{server}".replace("https://", ""),
+            "accept"            : "text/event-stream",
+            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3,fa=0.2",
+            "content-type"      : "application/json",
+            "origin"            : f"{server}",
+            "referer"           : f"{server}/",
+            "x-requested-with"  : "XMLHttpRequest",
+            'plugins'           : '0',
+            'sec-ch-ua'         : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
+            'usesearch'         : 'false',
+            'x-requested-with'  : 'XMLHttpRequest'
+        }
+
+        json_data = {
+            "messages"          : messages,
+            "stream"            : stream,
+            "model"             : model,
+            "temperature"       : kwargs.get("temperature", 0.5),
+            "presence_penalty"  : kwargs.get("presence_penalty", 0),
+            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
+            "top_p"             : kwargs.get("top_p", 1)
+        }
+
+        session = requests.Session()
+        # init cookies from server
+        session.get(f"{server}/")
+
+        response = session.post(f"{server}/api/openai/v1/chat/completions",
+            headers=headers, json=json_data, stream=stream)
+        
+        if response.status_code == 200:
+            
+            if stream == False:
+                json_data = response.json()
+                
+                if "choices" in json_data:
+                    yield json_data["choices"][0]["message"]["content"]
+                else:
+                    raise Exception("No response from server")
+            
+            else:
+                
+                for chunk in response.iter_lines():
+                    
+                    if b"content" in chunk:
+                        splitData = chunk.decode().split("data:")
+                        
+                        if len(splitData) > 1:
+                            yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
+                        else:
+                            continue
+        else:
+            raise Exception(f"Error {response.status_code} from server : {response.reason}")
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+            ("active_server", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/deprecated/Equing.py b/g4f/Provider/deprecated/Equing.py
new file mode 100644
index 00000000..794274f2
--- /dev/null
+++ b/g4f/Provider/deprecated/Equing.py
@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class Equing(BaseProvider):
+    url: str              = 'https://next.eqing.tech/'
+    working               = False
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+    supports_gpt_4        = False
+
+    @staticmethod
+    @abstractmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        headers = {
+            'authority'         : 'next.eqing.tech',
+            'accept'            : 'text/event-stream',
+            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'cache-control'     : 'no-cache',
+            'content-type'      : 'application/json',
+            'origin'            : 'https://next.eqing.tech',
+            'plugins'           : '0',
+            'pragma'            : 'no-cache',
+            'referer'           : 'https://next.eqing.tech/',
+            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"macOS"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
+            'usesearch'         : 'false',
+            'x-requested-with'  : 'XMLHttpRequest'
+        }
+
+        json_data = {
+            'messages'          : messages,
+            'stream'            : stream,
+            'model'             : model,
+            'temperature'       : kwargs.get('temperature', 0.5),
+            'presence_penalty'  : kwargs.get('presence_penalty', 0),
+            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+            'top_p'             : kwargs.get('top_p', 1),
+        }
+
+        response = requests.post('https://next.eqing.tech/api/openai/v1/chat/completions',
+            headers=headers, json=json_data, stream=stream)
+        
+        if not stream:
+            yield response.json()["choices"][0]["message"]["content"]
+            return
+        
+        for line in response.iter_content(chunk_size=1024):
+            if line:
+                if b'content' in line:
+                        line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                        token = line_json['choices'][0]['delta'].get('content')
+                        if token:
+                            yield token
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/FastGpt.py b/g4f/Provider/deprecated/FastGpt.py
new file mode 100644
index 00000000..65efa29d
--- /dev/null
+++ b/g4f/Provider/deprecated/FastGpt.py
@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+import random
+from abc import ABC, abstractmethod
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class FastGpt(BaseProvider):
+    url: str                = 'https://chat9.fastgpt.me/'
+    working                 = False
+    needs_auth              = False
+    supports_stream         = True
+    supports_gpt_35_turbo   = True
+    supports_gpt_4          = False
+
+    @staticmethod
+    @abstractmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        headers = {
+            'authority'         : 'chat9.fastgpt.me',
+            'accept'            : 'text/event-stream',
+            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'cache-control'     : 'no-cache',
+            'content-type'      : 'application/json',
+            'origin'            : 'https://chat9.fastgpt.me',
+            'plugins'           : '0',
+            'pragma'            : 'no-cache',
+            'referer'           : 'https://chat9.fastgpt.me/',
+            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"macOS"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
+            'usesearch'         : 'false',
+            'x-requested-with'  : 'XMLHttpRequest',
+        }
+
+        json_data = {
+            'messages'          : messages,
+            'stream'            : stream,
+            'model'             : model,
+            'temperature'       : kwargs.get('temperature', 0.5),
+            'presence_penalty'  : kwargs.get('presence_penalty', 0),
+            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+            'top_p'             : kwargs.get('top_p', 1),
+        }
+        
+        subdomain = random.choice([
+            'jdaen979ew',
+            'chat9'
+        ])
+
+        response = requests.post(f'https://{subdomain}.fastgpt.me/api/openai/v1/chat/completions',
+                                 headers=headers, json=json_data, stream=stream)
+        
+        for line in response.iter_lines():
+            if line:
+                try:
+                    if b'content' in line:
+                            line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                            token = line_json['choices'][0]['delta'].get('content')
+                            if token:
+                                yield token
+                except:
+                    continue
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Forefront.py b/g4f/Provider/deprecated/Forefront.py
new file mode 100644
index 00000000..2f807e91
--- /dev/null
+++ b/g4f/Provider/deprecated/Forefront.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import json
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class Forefront(BaseProvider):
+    url                   = "https://forefront.com"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        json_data = {
+            "text"          : messages[-1]["content"],
+            "action"        : "noauth",
+            "id"            : "",
+            "parentId"      : "",
+            "workspaceId"   : "",
+            "messagePersona": "607e41fe-95be-497e-8e97-010a59b2e2c0",
+            "model"         : "gpt-4",
+            "messages"      : messages[:-1] if len(messages) > 1 else [],
+            "internetMode"  : "auto",
+        }
+
+        response = requests.post("https://streaming.tenant-forefront-default.knative.chi.coreweave.com/free-chat",
+            json=json_data, stream=True)
+        
+        response.raise_for_status()
+        for token in response.iter_lines():
+            if b"delta" in token:
+                yield json.loads(token.decode().split("data: ")[1])["delta"]
diff --git a/g4f/Provider/deprecated/GetGpt.py b/g4f/Provider/deprecated/GetGpt.py
new file mode 100644
index 00000000..a5de1d29
--- /dev/null
+++ b/g4f/Provider/deprecated/GetGpt.py
@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import json
+import os
+import uuid
+
+import requests
+from Crypto.Cipher import AES
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class GetGpt(BaseProvider):
+    url                   = 'https://chat.getgpt.world/'
+    supports_stream       = True
+    working               = False
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        headers = {
+            'Content-Type'  : 'application/json',
+            'Referer'       : 'https://chat.getgpt.world/',
+            'user-agent'    : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
+        }
+        
+        data = json.dumps(
+            {
+                'messages'          : messages,
+                'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+                'max_tokens'        : kwargs.get('max_tokens', 4000),
+                'model'             : 'gpt-3.5-turbo',
+                'presence_penalty'  : kwargs.get('presence_penalty', 0),
+                'temperature'       : kwargs.get('temperature', 1),
+                'top_p'             : kwargs.get('top_p', 1),
+                'stream'            : True,
+                'uuid'              : str(uuid.uuid4())
+            }
+        )
+
+        res = requests.post('https://chat.getgpt.world/api/chat/stream',
+            headers=headers, json={'signature': _encrypt(data)}, stream=True)
+
+        res.raise_for_status()
+        for line in res.iter_lines():
+            if b'content' in line:
+                line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                yield (line_json['choices'][0]['delta']['content'])
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ('model', 'str'),
+            ('messages', 'list[dict[str, str]]'),
+            ('stream', 'bool'),
+            ('temperature', 'float'),
+            ('presence_penalty', 'int'),
+            ('frequency_penalty', 'int'),
+            ('top_p', 'int'),
+            ('max_tokens', 'int'),
+        ]
+        param = ', '.join([': '.join(p) for p in params])
+        return f'g4f.provider.{cls.__name__} supports: ({param})'
+
+
+def _encrypt(e: str):
+    t = os.urandom(8).hex().encode('utf-8')
+    n = os.urandom(8).hex().encode('utf-8')
+    r = e.encode('utf-8')
+    
+    cipher     = AES.new(t, AES.MODE_CBC, n)
+    ciphertext = cipher.encrypt(_pad_data(r))
+    
+    return ciphertext.hex() + t.decode('utf-8') + n.decode('utf-8')
+
+
+def _pad_data(data: bytes) -> bytes:
+    block_size   = AES.block_size
+    padding_size = block_size - len(data) % block_size
+    padding      = bytes([padding_size] * padding_size)
+    
+    return data + padding
diff --git a/g4f/Provider/deprecated/Lockchat.py b/g4f/Provider/deprecated/Lockchat.py
new file mode 100644
index 00000000..4bd7c5fe
--- /dev/null
+++ b/g4f/Provider/deprecated/Lockchat.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class Lockchat(BaseProvider):
+    url: str              = "http://supertest.lockchat.app"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+    supports_gpt_4        = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        temperature = float(kwargs.get("temperature", 0.7))
+        payload = {
+            "temperature": temperature,
+            "messages"   : messages,
+            "model"      : model,
+            "stream"     : True,
+        }
+
+        headers = {
+            "user-agent": "ChatX/39 CFNetwork/1408.0.4 Darwin/22.5.0",
+        }
+        response = requests.post("http://supertest.lockchat.app/v1/chat/completions",
+                                 json=payload, headers=headers, stream=True)
+        
+        response.raise_for_status()
+        for token in response.iter_lines():
+            if b"The model: `gpt-4` does not exist" in token:
+                print("error, retrying...")
+                Lockchat.create_completion(
+                    model       = model,
+                    messages    = messages,
+                    stream      = stream,
+                    temperature = temperature,
+                    **kwargs)
+            
+            if b"content" in token:
+                token = json.loads(token.decode("utf-8").split("data: ")[1])
+                token = token["choices"][0]["delta"].get("content")
+                if token:
+                    yield (token)
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/deprecated/Opchatgpts.py b/g4f/Provider/deprecated/Opchatgpts.py
new file mode 100644
index 00000000..3bfb96f1
--- /dev/null
+++ b/g4f/Provider/deprecated/Opchatgpts.py
@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from ..ChatgptLogin import ChatgptLogin
+
+
+class Opchatgpts(ChatgptLogin):
+    url     = "https://opchatgpts.net"
+    working = True
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/PerplexityAi.py b/g4f/Provider/deprecated/PerplexityAi.py
new file mode 100644
index 00000000..f4f71712
--- /dev/null
+++ b/g4f/Provider/deprecated/PerplexityAi.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+import time
+import base64
+from curl_cffi.requests import AsyncSession
+
+from ..base_provider import AsyncProvider, format_prompt, get_cookies
+
+
+class PerplexityAi(AsyncProvider):
+    url                   = "https://www.perplexity.ai"
+    working               = False
+    supports_gpt_35_turbo = True
+    _sources              = []
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        **kwargs
+    ) -> str:
+        url = cls.url + "/socket.io/?EIO=4&transport=polling"
+        headers = {
+            "Referer": f"{cls.url}/"
+        }
+        async with AsyncSession(headers=headers, proxies={"https": proxy}, impersonate="chrome107") as session:
+            url_session = "https://www.perplexity.ai/api/auth/session"
+            response = await session.get(url_session)
+            response.raise_for_status()
+
+            url_session = "https://www.perplexity.ai/api/auth/session"
+            response = await session.get(url_session)
+            response.raise_for_status()
+
+            response = await session.get(url, params={"t": timestamp()})
+            response.raise_for_status()
+            sid = json.loads(response.text[1:])["sid"]
+
+            response = await session.get(url, params={"t": timestamp(), "sid": sid})
+            response.raise_for_status()
+
+            data = '40{"jwt":"anonymous-ask-user"}'
+            response = await session.post(url, params={"t": timestamp(), "sid": sid}, data=data)
+            response.raise_for_status()
+
+            response = await session.get(url, params={"t": timestamp(), "sid": sid})
+            response.raise_for_status()
+
+            data = "424" + json.dumps([
+                "perplexity_ask",
+                format_prompt(messages),
+                {
+                    "version":"2.1",
+                    "source":"default",
+                    "language":"en",
+                    "timezone": time.tzname[0],
+                    "search_focus":"internet",
+                    "mode":"concise"
+                }
+            ])
+            response = await session.post(url, params={"t": timestamp(), "sid": sid}, data=data)
+            response.raise_for_status()
+
+            while True:
+                response = await session.get(url, params={"t": timestamp(), "sid": sid})
+                response.raise_for_status()
+                for line in response.text.splitlines():
+                    if line.startswith("434"):
+                        result = json.loads(json.loads(line[3:])[0]["text"])
+
+                        cls._sources = [{
+                            "title": source["name"],
+                            "url": source["url"],
+                            "snippet": source["snippet"]
+                        } for source in result["web_results"]]
+
+                        return result["answer"]
+
+    @classmethod
+    def get_sources(cls):
+        return cls._sources
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
+
+
+def timestamp() -> str:
+    return base64.urlsafe_b64encode(int(time.time()-1407782612).to_bytes(4, 'big')).decode()
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/V50.py b/g4f/Provider/deprecated/V50.py
new file mode 100644
index 00000000..9a8b032c
--- /dev/null
+++ b/g4f/Provider/deprecated/V50.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import uuid
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class V50(BaseProvider):
+    url                     = 'https://p5.v50.ltd'
+    supports_gpt_35_turbo   = True
+    supports_stream         = False
+    needs_auth              = False
+    working                 = False
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
+        conversation += "\nassistant: "
+
+        payload = {
+            "prompt"        : conversation,
+            "options"       : {},
+            "systemMessage" : ".",
+            "temperature"   : kwargs.get("temperature", 0.4),
+            "top_p"         : kwargs.get("top_p", 0.4),
+            "model"         : model,
+            "user"          : str(uuid.uuid4())
+        }
+        
+        headers = {
+            'authority'         : 'p5.v50.ltd',
+            'accept'            : 'application/json, text/plain, */*',
+            'accept-language'   : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
+            'content-type'      : 'application/json',
+            'origin'            : 'https://p5.v50.ltd',
+            'referer'           : 'https://p5.v50.ltd/',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36'
+        }
+        response = requests.post("https://p5.v50.ltd/api/chat-process", 
+                                json=payload, headers=headers, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
+        
+        if "https://fk1.v50.ltd" not in response.text:
+            yield response.text
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Wewordle.py b/g4f/Provider/deprecated/Wewordle.py
new file mode 100644
index 00000000..c30887fb
--- /dev/null
+++ b/g4f/Provider/deprecated/Wewordle.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import random, string, time
+from aiohttp import ClientSession
+
+from ..base_provider import AsyncProvider
+
+
+class Wewordle(AsyncProvider):
+    url                    = "https://wewordle.org"
+    working                = False
+    supports_gpt_35_turbo  = True
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        **kwargs
+    ) -> str:
+        
+        headers = {
+            "accept"        : "*/*",
+            "pragma"        : "no-cache",
+            "Content-Type"  : "application/json",
+            "Connection"    : "keep-alive"
+        }
+
+        _user_id = "".join(random.choices(f"{string.ascii_lowercase}{string.digits}", k=16))
+        _app_id = "".join(random.choices(f"{string.ascii_lowercase}{string.digits}", k=31))
+        _request_date = time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime())
+        data = {
+            "user"      : _user_id,
+            "messages"  : messages,
+            "subscriber": {
+                "originalPurchaseDate"          : None,
+                "originalApplicationVersion"    : None,
+                "allPurchaseDatesMillis"        : {},
+                "entitlements"                  : {"active": {}, "all": {}},
+                "allPurchaseDates"              : {},
+                "allExpirationDatesMillis"      : {},
+                "allExpirationDates"            : {},
+                "originalAppUserId"             : f"$RCAnonymousID:{_app_id}",
+                "latestExpirationDate"          : None,
+                "requestDate"                   : _request_date,
+                "latestExpirationDateMillis"    : None,
+                "nonSubscriptionTransactions"   : [],
+                "originalPurchaseDateMillis"    : None,
+                "managementURL"                 : None,
+                "allPurchasedProductIdentifiers": [],
+                "firstSeen"                     : _request_date,
+                "activeSubscriptions"           : [],
+            }
+        }
+
+
+        async with ClientSession(
+            headers=headers
+        ) as session:
+            async with session.post(f"{cls.url}/gptapi/v1/android/turbo", proxy=proxy, json=data) as response:
+                response.raise_for_status()
+                content = (await response.json())["message"]["content"]
+                if content:
+                    return content
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Wuguokai.py b/g4f/Provider/deprecated/Wuguokai.py
new file mode 100644
index 00000000..311131cf
--- /dev/null
+++ b/g4f/Provider/deprecated/Wuguokai.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import random
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider, format_prompt
+
+
+class Wuguokai(BaseProvider):
+    url = 'https://chat.wuguokai.xyz'
+    supports_gpt_35_turbo = True
+    working = False
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        headers = {
+            'authority': 'ai-api.wuguokai.xyz',
+            'accept': 'application/json, text/plain, */*',
+            'accept-language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
+            'content-type': 'application/json',
+            'origin': 'https://chat.wuguokai.xyz',
+            'referer': 'https://chat.wuguokai.xyz/',
+            'sec-ch-ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-site',
+            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
+        }
+        data ={
+            "prompt": format_prompt(messages),
+            "options": {},
+            "userId": f"#/chat/{random.randint(1,99999999)}",
+            "usingContext": True
+        }
+        response = requests.post("https://ai-api20.wuguokai.xyz/api/chat-process", headers=headers, timeout=3, json=data, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
+        _split = response.text.split("> 若回答失败请重试或多刷新几次界面后重试")
+        if response.status_code == 200:
+            if len(_split) > 1:
+                yield _split[1].strip()
+            else:
+                yield _split[0].strip()
+        else:
+            raise Exception(f"Error: {response.status_code} {response.reason}")
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool")
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/__init__.py b/g4f/Provider/deprecated/__init__.py
new file mode 100644
index 00000000..8d22a3c3
--- /dev/null
+++ b/g4f/Provider/deprecated/__init__.py
@@ -0,0 +1,14 @@
+from .AiService     import AiService
+from .CodeLinkAva   import CodeLinkAva
+from .DfeHub        import DfeHub
+from .EasyChat      import EasyChat
+from .Forefront     import Forefront
+from .GetGpt        import GetGpt
+from .Opchatgpts    import Opchatgpts
+from .Lockchat      import Lockchat
+from .PerplexityAi  import PerplexityAi
+from .Wewordle      import Wewordle
+from .Equing        import Equing
+from .Wuguokai      import Wuguokai
+from .V50           import V50
+from .FastGpt       import FastGpt
\ No newline at end of file
diff --git a/g4f/Provider/needs_auth/Bard.py b/g4f/Provider/needs_auth/Bard.py
new file mode 100644
index 00000000..7c42b680
--- /dev/null
+++ b/g4f/Provider/needs_auth/Bard.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import json
+import random
+import re
+
+from aiohttp import ClientSession
+
+from ..base_provider import AsyncProvider, format_prompt, get_cookies
+
+
+class Bard(AsyncProvider):
+    url = "https://bard.google.com"
+    needs_auth = True
+    working = True
+    _snlm0e = None
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        cookies: dict = None,
+        **kwargs
+    ) -> str:
+        prompt = format_prompt(messages)
+        if proxy and "://" not in proxy:
+            proxy = f"http://{proxy}"
+        if not cookies:
+            cookies = get_cookies(".google.com")
+
+        headers = {
+            'authority': 'bard.google.com',
+            'origin': 'https://bard.google.com',
+            'referer': 'https://bard.google.com/',
+            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
+            'x-same-domain': '1',
+        }
+
+        async with ClientSession(
+            cookies=cookies,
+            headers=headers
+        ) as session:
+            if not cls._snlm0e:
+                async with session.get(cls.url, proxy=proxy) as response:
+                    text = await response.text()
+
+                match = re.search(r'SNlM0e\":\"(.*?)\"', text)
+                if not match:
+                    raise RuntimeError("No snlm0e value.")
+                cls._snlm0e = match.group(1)
+            
+            params = {
+                'bl': 'boq_assistant-bard-web-server_20230326.21_p0',
+                '_reqid': random.randint(1111, 9999),
+                'rt': 'c'
+            }
+
+            data = {
+                'at': cls._snlm0e,
+                'f.req': json.dumps([None, json.dumps([[prompt]])])
+            }
+
+            intents = '.'.join([
+                'assistant',
+                'lamda',
+                'BardFrontendService'
+            ])
+
+            async with session.post(
+                f'{cls.url}/_/BardChatUi/data/{intents}/StreamGenerate',
+                data=data,
+                params=params,
+                proxy=proxy
+            ) as response:
+                response = await response.text()
+                response = json.loads(response.splitlines()[3])[0][2]
+                response = json.loads(response)[4][0][1][0]
+                return response
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/needs_auth/HuggingChat.py b/g4f/Provider/needs_auth/HuggingChat.py
new file mode 100644
index 00000000..1d500338
--- /dev/null
+++ b/g4f/Provider/needs_auth/HuggingChat.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json, uuid
+
+from aiohttp import ClientSession
+
+from ...typing import AsyncGenerator
+from ..base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
+
+
+class HuggingChat(AsyncGeneratorProvider):
+    url = "https://huggingface.co/chat"
+    needs_auth = True
+    working = True
+    model = "meta-llama/Llama-2-70b-chat-hf"
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool = True,
+        proxy: str = None,
+        cookies: dict = None,
+        **kwargs
+    ) -> AsyncGenerator:
+        model = model if model else cls.model
+        if proxy and "://" not in proxy:
+            proxy = f"http://{proxy}"
+        if not cookies:
+            cookies = get_cookies(".huggingface.co")
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
+        }
+        async with ClientSession(
+            cookies=cookies,
+            headers=headers
+        ) as session:
+            async with session.post(f"{cls.url}/conversation", json={"model": model}, proxy=proxy) as response:
+                conversation_id = (await response.json())["conversationId"]
+
+            send = {
+                "id": str(uuid.uuid4()),
+                "inputs": format_prompt(messages),
+                "is_retry": False,
+                "response_id": str(uuid.uuid4()),
+                "web_search": False
+            }
+            async with session.post(f"{cls.url}/conversation/{conversation_id}", json=send, proxy=proxy) as response:
+                async for line in response.content:
+                    line = json.loads(line[:-1])
+                    if "type" not in line:
+                        raise RuntimeError(f"Response: {line}")
+                    elif line["type"] == "stream":
+                        yield line["token"]
+                    elif line["type"] == "finalAnswer":
+                        break
+                
+            async with session.delete(f"{cls.url}/conversation/{conversation_id}", proxy=proxy) as response:
+                response.raise_for_status()
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/needs_auth/OpenAssistant.py b/g4f/Provider/needs_auth/OpenAssistant.py
new file mode 100644
index 00000000..3b0e0424
--- /dev/null
+++ b/g4f/Provider/needs_auth/OpenAssistant.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import json
+
+from aiohttp import ClientSession
+
+from ...typing import Any, AsyncGenerator
+from ..base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
+
+
+class OpenAssistant(AsyncGeneratorProvider):
+    url = "https://open-assistant.io/chat"
+    needs_auth = True
+    working = False
+    model = "OA_SFT_Llama_30B_6"
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        cookies: dict = None,
+        **kwargs: Any
+    ) -> AsyncGenerator:
+        if not cookies:
+            cookies = get_cookies("open-assistant.io")
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
+        }
+        async with ClientSession(
+            cookies=cookies,
+            headers=headers
+        ) as session:
+            async with session.post("https://open-assistant.io/api/chat", proxy=proxy) as response:
+                chat_id = (await response.json())["id"]
+
+            data = {
+                "chat_id": chat_id,
+                "content": f"<s>[INST]\n{format_prompt(messages)}\n[/INST]",
+                "parent_id": None
+            }
+            async with session.post("https://open-assistant.io/api/chat/prompter_message", proxy=proxy, json=data) as response:
+                parent_id = (await response.json())["id"]
+
+            data = {
+                "chat_id": chat_id,
+                "parent_id": parent_id,
+                "model_config_name": model if model else cls.model,
+                "sampling_parameters":{
+                    "top_k": 50,
+                    "top_p": None,
+                    "typical_p": None,
+                    "temperature": 0.35,
+                    "repetition_penalty": 1.1111111111111112,
+                    "max_new_tokens": 1024,
+                    **kwargs
+                },
+                "plugins":[]
+            }
+            async with session.post("https://open-assistant.io/api/chat/assistant_message", proxy=proxy, json=data) as response:
+                data = await response.json()
+                if "id" in  data:
+                    message_id = data["id"]
+                elif "message" in data:
+                    raise RuntimeError(data["message"])
+                else:
+                    response.raise_for_status()
+            
+            params = {
+                'chat_id': chat_id,
+                'message_id': message_id,
+            }
+            async with session.post("https://open-assistant.io/api/chat/events", proxy=proxy, params=params) as response:
+                start = "data: "
+                async for line in response.content:
+                    line = line.decode("utf-8")
+                    if line and line.startswith(start):
+                        line = json.loads(line[len(start):])
+                        if line["event_type"] == "token":
+                            yield line["text"]
+
+            params = {
+                'chat_id': chat_id,
+            }
+            async with session.delete("https://open-assistant.io/api/chat", proxy=proxy, params=params) as response:
+                response.raise_for_status()
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/needs_auth/OpenaiChat.py b/g4f/Provider/needs_auth/OpenaiChat.py
new file mode 100644
index 00000000..c57692d3
--- /dev/null
+++ b/g4f/Provider/needs_auth/OpenaiChat.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import uuid, json, time
+
+from ..base_provider import AsyncGeneratorProvider
+from ..helper import get_browser, get_cookies, format_prompt
+from ...typing import AsyncGenerator
+from ...requests import StreamSession
+
+class OpenaiChat(AsyncGeneratorProvider):
+    url                   = "https://chat.openai.com"
+    needs_auth            = True
+    working               = True
+    supports_gpt_35_turbo = True
+    _access_token         = None
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        access_token: str = None,
+        cookies: dict = None,
+        **kwargs: dict
+    ) -> AsyncGenerator:
+        proxies = {"https": proxy}
+        if not access_token:
+            access_token = await cls.get_access_token(cookies, proxies)
+        headers = {
+            "Accept": "text/event-stream",
+            "Authorization": f"Bearer {access_token}",
+        }
+        async with StreamSession(proxies=proxies, headers=headers, impersonate="chrome107") as session:
+            messages = [
+                {
+                    "id": str(uuid.uuid4()),
+                    "author": {"role": "user"},
+                    "content": {"content_type": "text", "parts": [format_prompt(messages)]},
+                },
+            ]
+            data = {
+                "action": "next",
+                "messages": messages,
+                "conversation_id": None,
+                "parent_message_id": str(uuid.uuid4()),
+                "model": "text-davinci-002-render-sha",
+                "history_and_training_disabled": True,
+            }
+            async with session.post(f"{cls.url}/backend-api/conversation", json=data) as response:
+                response.raise_for_status()
+                last_message = ""
+                async for line in response.iter_lines():
+                    if line.startswith(b"data: "):
+                        line = line[6:]
+                        if line == b"[DONE]":
+                            break
+                        try:
+                            line = json.loads(line)
+                        except:
+                            continue
+                        if "message" not in line or "message_type" not in line["message"]["metadata"]:
+                            continue
+                        if line["message"]["metadata"]["message_type"] == "next":
+                            new_message = line["message"]["content"]["parts"][0]
+                            yield new_message[len(last_message):]
+                            last_message = new_message
+
+    @classmethod
+    def browse_access_token(cls) -> str:
+        try:
+            from selenium.webdriver.common.by import By
+            from selenium.webdriver.support.ui import WebDriverWait
+            from selenium.webdriver.support import expected_conditions as EC
+
+            driver = get_browser()
+        except ImportError:
+            return
+
+        driver.get(f"{cls.url}/")
+        try:
+            WebDriverWait(driver, 1200).until(
+                EC.presence_of_element_located((By.ID, "prompt-textarea"))
+            )
+            javascript = "return (await (await fetch('/api/auth/session')).json())['accessToken']"
+            return driver.execute_script(javascript)
+        finally:
+            time.sleep(1)
+            driver.quit()
+
+    @classmethod
+    async def fetch_access_token(cls, cookies: dict, proxies: dict = None) -> str:
+        async with StreamSession(proxies=proxies, cookies=cookies, impersonate="chrome107") as session:
+            async with session.get(f"{cls.url}/api/auth/session") as response:
+                response.raise_for_status()
+                auth = await response.json()
+                if "accessToken" in auth:
+                    return auth["accessToken"]
+
+    @classmethod
+    async def get_access_token(cls, cookies: dict = None, proxies: dict = None) -> str:
+        if not cls._access_token:
+            cookies = cookies if cookies else get_cookies("chat.openai.com")
+            if cookies:
+                cls._access_token = await cls.fetch_access_token(cookies, proxies)
+        if not cls._access_token:
+            cls._access_token = cls.browse_access_token()
+        if not cls._access_token:
+            raise RuntimeError("Read access token failed")
+        return cls._access_token
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+            ("access_token", "str"),
+            ("cookies", "dict[str, str]")
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/needs_auth/Raycast.py b/g4f/Provider/needs_auth/Raycast.py
new file mode 100644
index 00000000..619b217b
--- /dev/null
+++ b/g4f/Provider/needs_auth/Raycast.py
@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class Raycast(BaseProvider):
+    url                     = "https://raycast.com"
+    supports_gpt_35_turbo   = True
+    supports_gpt_4          = True
+    supports_stream         = True
+    needs_auth              = True
+    working                 = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        auth = kwargs.get('auth')
+        headers = {
+            'Accept': 'application/json',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Authorization': f'Bearer {auth}',
+            'Content-Type': 'application/json',
+            'User-Agent': 'Raycast/0 CFNetwork/1410.0.3 Darwin/22.6.0',
+        }
+        parsed_messages = []
+        for message in messages:
+            parsed_messages.append({
+                'author': message['role'],
+                'content': {'text': message['content']}
+            })
+        data = {
+            "debug": False,
+            "locale": "en-CN",
+            "messages": parsed_messages,
+            "model": model,
+            "provider": "openai",
+            "source": "ai_chat",
+            "system_instruction": "markdown",
+            "temperature": 0.5
+        }
+        response = requests.post("https://backend.raycast.com/api/v1/ai/chat_completions", headers=headers, json=data, stream=True)
+        for token in response.iter_lines():
+            if b'data: ' not in token:
+                continue
+            completion_chunk = json.loads(token.decode().replace('data: ', ''))
+            token = completion_chunk['text']
+            if token != None:
+                yield token
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+            ("model", "str"),
+            ("auth", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
diff --git a/g4f/Provider/needs_auth/Theb.py b/g4f/Provider/needs_auth/Theb.py
new file mode 100644
index 00000000..c35ea592
--- /dev/null
+++ b/g4f/Provider/needs_auth/Theb.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+import random
+
+import requests
+
+from ...typing import Any, CreateResult
+from ..base_provider import BaseProvider
+
+
+class Theb(BaseProvider):
+    url                     = "https://theb.ai"
+    working                 = True
+    supports_stream         = True
+    supports_gpt_35_turbo   = True
+    needs_auth              = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
+        conversation += "\nassistant: "
+        
+        auth = kwargs.get("auth", {
+            "bearer_token":"free",
+            "org_id":"theb",
+        })
+        
+        bearer_token = auth["bearer_token"]
+        org_id       = auth["org_id"]
+        
+        headers = {
+            'authority'         : 'beta.theb.ai',
+            'accept'            : 'text/event-stream',
+            'accept-language'   : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
+            'authorization'     : 'Bearer '+bearer_token,
+            'content-type'      : 'application/json',
+            'origin'            : 'https://beta.theb.ai',
+            'referer'           : 'https://beta.theb.ai/home',
+            'sec-ch-ua'         : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
+            'x-ai-model'        : 'ee8d4f29cb7047f78cbe84313ed6ace8',
+        }
+        
+        req_rand = random.randint(100000000, 9999999999)
+
+        json_data: dict[str, Any] = {
+            "text"      : conversation,
+            "category"  : "04f58f64a4aa4191a957b47290fee864",
+            "model"     : "ee8d4f29cb7047f78cbe84313ed6ace8",
+            "model_params": {
+                "system_prompt"     : "You are ChatGPT, a large language model trained by OpenAI, based on the GPT-3.5 architecture.\nKnowledge cutoff: 2021-09\nCurrent date: {{YYYY-MM-DD}}",
+                "temperature"       : kwargs.get("temperature", 1),
+                "top_p"             : kwargs.get("top_p", 1),
+                "frequency_penalty" : kwargs.get("frequency_penalty", 0),
+                "presence_penalty"  : kwargs.get("presence_penalty", 0),
+                "long_term_memory"  : "auto"
+            }
+        }
+        
+        response = requests.post(f"https://beta.theb.ai/api/conversation?org_id={org_id}&req_rand={req_rand}",
+                                 headers=headers, json=json_data, stream=True)
+        
+        response.raise_for_status()
+        content = ""
+        next_content = ""
+        for chunk in response.iter_lines():
+            if b"content" in chunk:
+                next_content = content
+                data = json.loads(chunk.decode().split("data: ")[1])
+                content = data["content"]
+                yield data["content"].replace(next_content, "")
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("auth", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int")
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/g4f/Provider/needs_auth/__init__.py b/g4f/Provider/needs_auth/__init__.py
new file mode 100644
index 00000000..815194c4
--- /dev/null
+++ b/g4f/Provider/needs_auth/__init__.py
@@ -0,0 +1,6 @@
+from .Bard          import Bard
+from .Raycast       import Raycast
+from .Theb          import Theb
+from .HuggingChat   import HuggingChat
+from .OpenaiChat    import OpenaiChat
+from .OpenAssistant import OpenAssistant
\ No newline at end of file
diff --git a/g4f/models.py b/g4f/models.py
index 6b27645a..4a6c9faf 100644
--- a/g4f/models.py
+++ b/g4f/models.py
@@ -61,9 +61,7 @@ gpt_35_turbo = Model(
 gpt_4 = Model(
     name          = 'gpt-4',
     base_provider = 'openai',
-    best_provider = RetryProvider([
-        Myshell, Ylokh,
-    ])
+    best_provider = Bing
 )
 
 # Bard
diff --git a/testing/test_providers.py b/testing/test_providers.py
index 73b75f5d..462f19bc 100644
--- a/testing/test_providers.py
+++ b/testing/test_providers.py
@@ -33,22 +33,10 @@ def main():
 
 
 def get_providers() -> list[type[BaseProvider]]:
-    provider_names = dir(Provider)
-    ignore_names = [
-        "annotations",
-        "helper",
-        "base_provider",
-        "retry_provider",
-        "BaseProvider",
-        "AsyncProvider",
-        "AsyncGeneratorProvider",
-        "RetryProvider",
-    ]
-    return [
-        getattr(Provider, provider_name)
-        for provider_name in provider_names
-        if not provider_name.startswith("__") and provider_name not in ignore_names
-    ]
+    providers = dir(Provider)
+    providers = [getattr(Provider, provider) for provider in providers if provider != "RetryProvider"]
+    providers = [provider for provider in providers if isinstance(provider, type)]
+    return [provider for provider in providers if issubclass(provider, BaseProvider)]
 
 
 def create_response(_provider: type[BaseProvider]) -> str:
-- 
cgit v1.2.3