38 files changed, 0 insertions, 2972 deletions

diff --git a/g4f/Provider/deprecated/Acytoo.py b/g4f/Provider/deprecated/Acytoo.py
deleted file mode 100644
index f75821ce..00000000
--- a/g4f/Provider/deprecated/Acytoo.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-
-
-class Acytoo(AsyncGeneratorProvider):
-    url                      = 'https://chat.acytoo.com'
-    working                  = False
-    supports_message_history = True
-    supports_gpt_35_turbo    = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        async with ClientSession(
-            headers=_create_header()
-        ) as session:
-            async with session.post(
-                f'{cls.url}/api/completions',
-                proxy=proxy,
-                json=_create_payload(messages, **kwargs)
-            ) as response:
-                response.raise_for_status()
-                async for stream in response.content.iter_any():
-                    if stream:
-                        yield stream.decode()
-
-
-def _create_header():
-    return {
-        'accept': '*/*',
-        'content-type': 'application/json',
-    }
-
-
-def _create_payload(messages: Messages, temperature: float = 0.5, **kwargs):
-    return {
-        'key'         : '',
-        'model'       : 'gpt-3.5-turbo',
-        'messages'    : messages,
-        'temperature' : temperature,
-        'password'    : ''
-    }
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/AiAsk.py b/g4f/Provider/deprecated/AiAsk.py
deleted file mode 100644
index 6ea5f3e0..00000000
--- a/g4f/Provider/deprecated/AiAsk.py
+++ /dev/null
@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-
-class AiAsk(AsyncGeneratorProvider):
-    url = "https://e.aiask.me"
-    supports_message_history = True
-    supports_gpt_35_turbo = True
-    working = False
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "accept": "application/json, text/plain, */*",
-            "origin": cls.url,
-            "referer": f"{cls.url}/chat",
-        }
-        async with ClientSession(headers=headers) as session:
-            data = {
-                "continuous": True,
-                "id": "fRMSQtuHl91A4De9cCvKD",
-                "list": messages,
-                "models": "0",
-                "prompt": "",
-                "temperature": kwargs.get("temperature", 0.5),
-                "title": "",
-            }
-            buffer = ""
-            rate_limit = "您的免费额度不够使用这个模型啦，请点击右上角登录继续使用！"
-            async with session.post(f"{cls.url}/v1/chat/gpt/", json=data, proxy=proxy) as response:
-                response.raise_for_status()
-                async for chunk in response.content.iter_any():
-                    buffer += chunk.decode()
-                    if not rate_limit.startswith(buffer):
-                        yield buffer
-                        buffer = ""
-                    elif buffer == rate_limit:
-                        raise RuntimeError("Rate limit reached")
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/AiService.py b/g4f/Provider/deprecated/AiService.py
deleted file mode 100644
index acd7f5ea..00000000
--- a/g4f/Provider/deprecated/AiService.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-import requests
-
-from ...typing import Any, CreateResult, Messages
-from ..base_provider import AbstractProvider
-
-
-class AiService(AbstractProvider):
-    url = "https://aiservice.vercel.app/"
-    working = False
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: Messages,
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        base = (
-            "\n".join(
-                f"{message['role']}: {message['content']}" for message in messages
-            )
-            + "\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/Aibn.py b/g4f/Provider/deprecated/Aibn.py
deleted file mode 100644
index 0bbfb436..00000000
--- a/g4f/Provider/deprecated/Aibn.py
+++ /dev/null
@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-import time
-import hashlib
-
-from ...typing import AsyncResult, Messages
-from ...requests import StreamSession
-from ..base_provider import AsyncGeneratorProvider
-
-
-class Aibn(AsyncGeneratorProvider):
-    url = "https://aibn.cc"
-    working = False
-    supports_message_history = True
-    supports_gpt_35_turbo = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 120,
-        **kwargs
-    ) -> AsyncResult:
-        async with StreamSession(
-            impersonate="chrome107",
-            proxies={"https": proxy},
-            timeout=timeout
-        ) as session:
-            timestamp = int(time.time())
-            data = {
-                "messages": messages,
-                "pass": None,
-                "sign": generate_signature(timestamp, messages[-1]["content"]),
-                "time": timestamp
-            }
-            async with session.post(f"{cls.url}/api/generate", json=data) as response:
-                response.raise_for_status()
-                async for chunk in response.iter_content():
-                    yield chunk.decode()
-    
-
-def generate_signature(timestamp: int, message: str, secret: str = "undefined"):
-    data = f"{timestamp}:{message}:{secret}"
-    return hashlib.sha256(data.encode()).hexdigest()
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Aichat.py b/g4f/Provider/deprecated/Aichat.py
deleted file mode 100644
index 68c9c546..00000000
--- a/g4f/Provider/deprecated/Aichat.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from ...typing import Messages
-from ..base_provider import AsyncProvider, format_prompt
-from ..helper import get_cookies
-from ...requests import StreamSession
-
-class Aichat(AsyncProvider):
-    url = "https://chat-gpt.org/chat"
-    working = False
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    async def create_async(
-        model: str,
-        messages: Messages,
-        proxy: str = None, **kwargs) -> str:
-        
-        cookies = get_cookies('chat-gpt.org') if not kwargs.get('cookies') else kwargs.get('cookies')
-        if not cookies:
-            raise RuntimeError(
-                "g4f.provider.Aichat requires cookies, [refresh https://chat-gpt.org on chrome]"
-            )
-
-        headers = {
-            'authority': 'chat-gpt.org',
-            '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-gpt.org',
-            'referer': 'https://chat-gpt.org/chat',
-            'sec-ch-ua': '"Chromium";v="118", "Google Chrome";v="118", "Not=A?Brand";v="99"',
-            '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/118.0.0.0 Safari/537.36',
-        }
-
-        async with StreamSession(headers=headers,
-                                    cookies=cookies,
-                                    timeout=6,
-                                    proxies={"https": proxy} if proxy else None,
-                                    impersonate="chrome110", verify=False) as session:
-
-            json_data = {
-                "message": format_prompt(messages),
-                "temperature": kwargs.get('temperature', 0.5),
-                "presence_penalty": 0,
-                "top_p": kwargs.get('top_p', 1),
-                "frequency_penalty": 0,
-            }
-
-            async with session.post("https://chat-gpt.org/api/text",
-                                    json=json_data) as response:
-
-                response.raise_for_status()
-                result = await response.json()
-
-                if not result['response']:
-                    raise Exception(f"Error Response: {result}")
-
-                return result["message"]
diff --git a/g4f/Provider/deprecated/Ails.py b/g4f/Provider/deprecated/Ails.py
deleted file mode 100644
index e87ceb32..00000000
--- a/g4f/Provider/deprecated/Ails.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import time
-import uuid
-import json
-from datetime import datetime
-from aiohttp import ClientSession
-
-from ...typing import SHA256, AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-
-
-class Ails(AsyncGeneratorProvider):
-    url = "https://ai.ls"
-    working = False
-    supports_message_history = True
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    async def create_async_generator(
-        model: str,
-        messages: Messages,
-        stream: bool,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "authority": "api.caipacity.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",
-            "authorization": "Bearer free",
-            "client-id": str(uuid.uuid4()),
-            "client-v": "0.1.278",
-            "content-type": "application/json",
-            "origin": "https://ai.ls",
-            "referer": "https://ai.ls/",
-            "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": "cross-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",
-            "from-url": "https://ai.ls/?chat=1"
-        }
-        async with ClientSession(
-                headers=headers
-            ) as session:
-            timestamp = _format_timestamp(int(time.time() * 1000))
-            json_data = {
-                "model": "gpt-3.5-turbo",
-                "temperature": kwargs.get("temperature", 0.6),
-                "stream": True,
-                "messages": messages,
-                "d": datetime.now().strftime("%Y-%m-%d"),
-                "t": timestamp,
-                "s": _hash({"t": timestamp, "m": messages[-1]["content"]}),
-            }
-            async with session.post(
-                        "https://api.caipacity.com/v1/chat/completions",
-                        proxy=proxy,
-                        json=json_data
-                    ) as response:
-                response.raise_for_status()
-                start = "data: "
-                async for line in response.content:
-                    line = line.decode('utf-8')
-                    if line.startswith(start) and line != "data: [DONE]":
-                        line = line[len(start):-1]
-                        line = json.loads(line)
-                        token = line["choices"][0]["delta"].get("content")
-                        
-                        if token:
-                            if "ai.ls" in token or "ai.ci" in token:
-                                raise Exception(f"Response Error: {token}")
-                            yield token
-
-
-def _hash(json_data: dict[str, str]) -> SHA256:
-    base_string: str = f'{json_data["t"]}:{json_data["m"]}:WI,2rU#_r:r~aF4aJ36[.Z(/8Rv93Rf:{len(json_data["m"])}'
-
-    return SHA256(hashlib.sha256(base_string.encode()).hexdigest())
-
-
-def _format_timestamp(timestamp: int) -> str:
-    e = timestamp
-    n = e % 10
-    r = n + 1 if n % 2 == 0 else n
-    return str(e - n + r)
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Aivvm.py b/g4f/Provider/deprecated/Aivvm.py
deleted file mode 100644
index c973adf8..00000000
--- a/g4f/Provider/deprecated/Aivvm.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import requests
-import json
-
-from ..base_provider import AbstractProvider
-from ...typing import CreateResult, Messages
-
-# to recreate this easily, send a post request to https://chat.aivvm.com/api/models
-models = {
-    'gpt-3.5-turbo': {'id': 'gpt-3.5-turbo', 'name': 'GPT-3.5'},
-    'gpt-3.5-turbo-0613': {'id': 'gpt-3.5-turbo-0613', 'name': 'GPT-3.5-0613'},
-    'gpt-3.5-turbo-16k': {'id': 'gpt-3.5-turbo-16k', 'name': 'GPT-3.5-16K'},
-    'gpt-3.5-turbo-16k-0613': {'id': 'gpt-3.5-turbo-16k-0613', 'name': 'GPT-3.5-16K-0613'},
-    'gpt-4': {'id': 'gpt-4', 'name': 'GPT-4'},
-    'gpt-4-0613': {'id': 'gpt-4-0613', 'name': 'GPT-4-0613'},
-    'gpt-4-32k': {'id': 'gpt-4-32k', 'name': 'GPT-4-32K'},
-    'gpt-4-32k-0613': {'id': 'gpt-4-32k-0613', 'name': 'GPT-4-32K-0613'},
-}
-
-class Aivvm(AbstractProvider):
-    url                   = 'https://chat.aivvm.com'
-    supports_stream       = True
-    working               = False
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = True
-
-    @classmethod
-    def create_completion(cls,
-        model: str,
-        messages: Messages,
-        stream: bool,
-        **kwargs
-    ) -> CreateResult:
-        if not model:
-            model = "gpt-3.5-turbo"
-        elif model not in models:
-            raise ValueError(f"Model is not supported: {model}")
-
-        json_data = {
-            "model"       : models[model],
-            "messages"    : messages,
-            "key"         : "",
-            "prompt"      : kwargs.get("system_message", "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown."),
-            "temperature" : kwargs.get("temperature", 0.7)
-        }
-
-        data = json.dumps(json_data)
-
-        headers = {
-            "accept"            : "text/event-stream",
-            "accept-language"   : "en-US,en;q=0.9",
-            "content-type"      : "application/json",
-            "content-length"    : str(len(data)),
-            "sec-ch-ua"         : "\"Chrome\";v=\"117\", \"Not;A=Brand\";v=\"8\", \"Chromium\";v=\"117\"",
-            "sec-ch-ua-mobile"  : "?0",
-            "sec-ch-ua-platform": "\"Windows\"",
-            "sec-fetch-dest"    : "empty",
-            "sec-fetch-mode"    : "cors",
-            "sec-fetch-site"    : "same-origin",
-            "sec-gpc"           : "1",
-            "referrer"          : "https://chat.aivvm.com/",
-            "user-agent"        : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36"
-        }
-
-        response = requests.post("https://chat.aivvm.com/api/chat", headers=headers, data=data, stream=True)
-        response.raise_for_status()
-
-        for chunk in response.iter_content(chunk_size=4096):
-            try:
-                yield chunk.decode("utf-8")
-            except UnicodeDecodeError:
-                yield chunk.decode("unicode-escape")
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Berlin.py b/g4f/Provider/deprecated/Berlin.py
deleted file mode 100644
index 5e81705a..00000000
--- a/g4f/Provider/deprecated/Berlin.py
+++ /dev/null
@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-import secrets
-import uuid
-import json
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import format_prompt
-
-
-class Berlin(AsyncGeneratorProvider):
-    url = "https://ai.berlin4h.top"
-    working = False
-    supports_gpt_35_turbo = True
-    _token = None
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        if not model:
-            model = "gpt-3.5-turbo"
-        headers = {
-            "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
-            "Accept": "*/*",
-            "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Referer": f"{cls.url}/",
-            "Content-Type": "application/json",
-            "Origin": cls.url,
-            "Alt-Used": "ai.berlin4h.top",
-            "Connection": "keep-alive",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "Pragma": "no-cache",
-            "Cache-Control": "no-cache",
-            "TE": "trailers",
-        }
-        async with ClientSession(headers=headers) as session:
-            if not cls._token:
-                data = {
-                    "account": '免费使用GPT3.5模型@163.com',
-                    "password": '659e945c2d004686bad1a75b708c962f'
-                }
-                async with session.post(f"{cls.url}/api/login", json=data, proxy=proxy) as response:
-                    response.raise_for_status()
-                    cls._token = (await response.json())["data"]["token"]
-            headers = {
-                "token": cls._token
-            }
-            prompt = format_prompt(messages)
-            data = {
-                "prompt": prompt,
-                "parentMessageId": str(uuid.uuid4()),
-                "options": {
-                    "model": model,
-                    "temperature": 0,
-                    "presence_penalty": 0,
-                    "frequency_penalty": 0,
-                    "max_tokens": 1888,
-                    **kwargs
-                },
-            }
-            async with session.post(f"{cls.url}/api/chat/completions", json=data, proxy=proxy, headers=headers) as response:
-                response.raise_for_status()
-                async for chunk in response.content:
-                    if chunk.strip():
-                        try:
-                            yield json.loads(chunk)["content"]
-                        except:
-                            raise RuntimeError(f"Response: {chunk.decode()}")
diff --git a/g4f/Provider/deprecated/ChatAnywhere.py b/g4f/Provider/deprecated/ChatAnywhere.py
deleted file mode 100644
index d035eaf0..00000000
--- a/g4f/Provider/deprecated/ChatAnywhere.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession, ClientTimeout
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-
-
-class ChatAnywhere(AsyncGeneratorProvider):
-    url = "https://chatanywhere.cn"
-    supports_gpt_35_turbo = True
-    supports_message_history = True
-    working = False
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 120,
-        temperature: float = 0.5,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
-            "Accept": "application/json, text/plain, */*",
-            "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Content-Type": "application/json",
-            "Referer": f"{cls.url}/",
-            "Origin": cls.url,
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "Authorization": "",
-            "Connection": "keep-alive",
-            "TE": "trailers"
-        }
-        async with ClientSession(headers=headers, timeout=ClientTimeout(timeout)) as session:
-            data = {
-                "list": messages,
-                "id": "s1_qYuOLXjI3rEpc7WHfQ",
-                "title": messages[-1]["content"],
-                "prompt": "",
-                "temperature": temperature,
-                "models": "61490748",
-                "continuous": True
-            }
-            async with session.post(f"{cls.url}/v1/chat/gpt/", json=data, proxy=proxy) as response:
-                response.raise_for_status()
-                async for chunk in response.content.iter_any():
-                    if chunk:
-                        yield chunk.decode()
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/ChatgptDuo.py b/g4f/Provider/deprecated/ChatgptDuo.py
deleted file mode 100644
index bd9e195d..00000000
--- a/g4f/Provider/deprecated/ChatgptDuo.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-from ...typing import Messages
-from ...requests import StreamSession
-from ..base_provider import AsyncProvider, format_prompt
-
-
-class ChatgptDuo(AsyncProvider):
-    url                   = "https://chatgptduo.com"
-    supports_gpt_35_turbo = True
-    working               = False
-
-    @classmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 120,
-        **kwargs
-    ) -> str:
-        async with StreamSession(
-            impersonate="chrome107",
-            proxies={"https": proxy},
-            timeout=timeout
-        ) as session:
-            prompt = format_prompt(messages),
-            data = {
-                "prompt": prompt,
-                "search": prompt,
-                "purpose": "ask",
-            }
-            response = await session.post(f"{cls.url}/", data=data)
-            response.raise_for_status()
-            data = response.json()
-
-            cls._sources = [{
-                "title": source["title"],
-                "url": source["link"],
-                "snippet": source["snippet"]
-            } for source in data["results"]]
-
-            return data["answer"]
-
-    @classmethod
-    def get_sources(cls):
-        return cls._sources
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/CodeLinkAva.py b/g4f/Provider/deprecated/CodeLinkAva.py
deleted file mode 100644
index 22f4468a..00000000
--- a/g4f/Provider/deprecated/CodeLinkAva.py
+++ /dev/null
@@ -1,52 +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               = 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": f"{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
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Cromicle.py b/g4f/Provider/deprecated/Cromicle.py
deleted file mode 100644
index 9f986cb5..00000000
--- a/g4f/Provider/deprecated/Cromicle.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-from hashlib import sha256
-from ...typing import AsyncResult, Messages, Dict
-
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import format_prompt
-
-
-class Cromicle(AsyncGeneratorProvider):
-    url: str = 'https://cromicle.top'
-    working: bool = False
-    supports_gpt_35_turbo: bool = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        async with ClientSession(
-            headers=_create_header()
-        ) as session:
-            async with session.post(
-                f'{cls.url}/chat',
-                proxy=proxy,
-                json=_create_payload(format_prompt(messages))
-            ) as response:
-                response.raise_for_status()
-                async for stream in response.content.iter_any():
-                    if stream:
-                        yield stream.decode()
-
-
-def _create_header() -> Dict[str, str]:
-    return {
-        'accept': '*/*',
-        'content-type': 'application/json',
-    }
-
-
-def _create_payload(message: str) -> Dict[str, str]:
-    return {
-        'message': message,
-        'token': 'abc',
-        'hash': sha256('abc'.encode() + message.encode()).hexdigest()
-    }
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/DfeHub.py b/g4f/Provider/deprecated/DfeHub.py
deleted file mode 100644
index e6d13444..00000000
--- a/g4f/Provider/deprecated/DfeHub.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-import time
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class DfeHub(AbstractProvider):
-    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"])
diff --git a/g4f/Provider/deprecated/EasyChat.py b/g4f/Provider/deprecated/EasyChat.py
deleted file mode 100644
index 7a00f523..00000000
--- a/g4f/Provider/deprecated/EasyChat.py
+++ /dev/null
@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class EasyChat(AbstractProvider):
-    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:
-            raise Exception(f"Error {response.status_code} from server : {response.reason}")
-        if not stream:
-            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"]
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Equing.py b/g4f/Provider/deprecated/Equing.py
deleted file mode 100644
index 5fd9797b..00000000
--- a/g4f/Provider/deprecated/Equing.py
+++ /dev/null
@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-import json
-from abc import ABC, abstractmethod
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class Equing(AbstractProvider):
-    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
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/FakeGpt.py b/g4f/Provider/deprecated/FakeGpt.py
deleted file mode 100644
index 99b6bb1a..00000000
--- a/g4f/Provider/deprecated/FakeGpt.py
+++ /dev/null
@@ -1,91 +0,0 @@
-from __future__ import annotations
-
-import uuid, time, random, json
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import format_prompt, get_random_string
-
-
-class FakeGpt(AsyncGeneratorProvider):
-    url                   = "https://chat-shared2.zhile.io"
-    supports_gpt_35_turbo = True
-    working               = False
-    _access_token         = None
-    _cookie_jar           = None
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "Accept-Language": "en-US",
-            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36",
-            "Referer": "https://chat-shared2.zhile.io/?v=2",
-            "sec-ch-ua": '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"',
-            "sec-ch-ua-platform": '"Linux"',
-            "sec-ch-ua-mobile": "?0",
-        }
-        async with ClientSession(headers=headers, cookie_jar=cls._cookie_jar) as session:
-            if not cls._access_token:
-                async with session.get(f"{cls.url}/api/loads", params={"t": int(time.time())}, proxy=proxy) as response:
-                    response.raise_for_status()
-                    list = (await response.json())["loads"]
-                    token_ids = [t["token_id"] for t in list]
-                data = {
-                    "token_key": random.choice(token_ids),
-                    "session_password": get_random_string()
-                }
-                async with session.post(f"{cls.url}/auth/login", data=data, proxy=proxy) as response:
-                    response.raise_for_status()
-                async with session.get(f"{cls.url}/api/auth/session", proxy=proxy) as response:
-                    response.raise_for_status()
-                    cls._access_token = (await response.json())["accessToken"]
-                    cls._cookie_jar = session.cookie_jar
-            headers = {
-                "Content-Type": "application/json",
-                "Accept": "text/event-stream",
-                "X-Authorization": f"Bearer {cls._access_token}",
-            }
-            prompt = format_prompt(messages)
-            data = {
-                "action": "next",
-                "messages": [
-                    {
-                        "id": str(uuid.uuid4()),
-                        "author": {"role": "user"},
-                        "content": {"content_type": "text", "parts": [prompt]},
-                        "metadata": {},
-                    }
-                ],
-                "parent_message_id": str(uuid.uuid4()),
-                "model": "text-davinci-002-render-sha",
-                "plugin_ids": [],
-                "timezone_offset_min": -120,
-                "suggestions": [],
-                "history_and_training_disabled": True,
-                "arkose_token": "",
-                "force_paragen": False,
-            }
-            last_message = ""
-            async with session.post(f"{cls.url}/api/conversation", json=data, headers=headers, proxy=proxy) as response:
-                async for line in response.content:
-                    if line.startswith(b"data: "):
-                        line = line[6:]
-                        if line == b"[DONE]":
-                            break
-                        try:
-                            line = json.loads(line)
-                            if line["message"]["metadata"]["message_type"] == "next":
-                                new_message = line["message"]["content"]["parts"][0]
-                                yield new_message[len(last_message):]
-                                last_message = new_message
-                        except:
-                            continue
-            if not last_message:
-                raise RuntimeError("No valid response")
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/FastGpt.py b/g4f/Provider/deprecated/FastGpt.py
deleted file mode 100644
index 6a79d9aa..00000000
--- a/g4f/Provider/deprecated/FastGpt.py
+++ /dev/null
@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import json
-import random
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class FastGpt(AbstractProvider):
-    url: str                = 'https://chat9.fastgpt.me/'
-    working                 = False
-    needs_auth              = False
-    supports_stream         = True
-    supports_gpt_35_turbo   = True
-    supports_gpt_4          = False
-
-    @staticmethod
-    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
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Forefront.py b/g4f/Provider/deprecated/Forefront.py
deleted file mode 100644
index 39654b2c..00000000
--- a/g4f/Provider/deprecated/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 AbstractProvider
-
-
-class Forefront(AbstractProvider):
-    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/GPTalk.py b/g4f/Provider/deprecated/GPTalk.py
deleted file mode 100644
index 5b36d37b..00000000
--- a/g4f/Provider/deprecated/GPTalk.py
+++ /dev/null
@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import secrets, time, json
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import format_prompt
-
-
-class GPTalk(AsyncGeneratorProvider):
-    url = "https://gptalk.net"
-    working = False
-    supports_gpt_35_turbo = True
-    _auth = None
-    used_times = 0
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        if not model:
-            model = "gpt-3.5-turbo"
-        timestamp = int(time.time())
-        headers = {
-            'authority': 'gptalk.net',
-            'accept': '*/*',
-            'accept-language': 'de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US;q=0.6,nl;q=0.5,zh-CN;q=0.4,zh-TW;q=0.3,zh;q=0.2',
-            'content-type': 'application/json',
-            'origin': 'https://gptalk.net',
-            'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"',
-            'sec-ch-ua-mobile': '?0',
-            'sec-ch-ua-platform': '"Linux"',
-            'sec-fetch-dest': 'empty',
-            'sec-fetch-mode': 'cors',
-            'sec-fetch-site': 'same-origin',
-            'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36',
-            'x-auth-appid': '2229',
-            'x-auth-openid': '',
-            'x-auth-platform': '',
-            'x-auth-timestamp': f"{timestamp}",
-        }
-        async with ClientSession(headers=headers) as session:
-            if not cls._auth or cls._auth["expires_at"] < timestamp or cls.used_times == 5:
-                data = {
-                    "fingerprint": secrets.token_hex(16).zfill(32),
-                    "platform": "fingerprint"
-                }
-                async with session.post(f"{cls.url}/api/chatgpt/user/login", json=data, proxy=proxy) as response:
-                    response.raise_for_status()
-                    cls._auth = (await response.json())["data"]
-                cls.used_times = 0
-            data = {
-                "content": format_prompt(messages),
-                "accept": "stream",
-                "from": 1,
-                "model": model,
-                "is_mobile": 0,
-                "user_agent": headers["user-agent"],
-                "is_open_ctx": 0,
-                "prompt": "",
-                "roid": 111,
-                "temperature": 0,
-                "ctx_msg_count": 3,
-                "created_at": timestamp
-            }
-            headers = {
-                'authorization': f'Bearer {cls._auth["token"]}',
-            }
-            async with session.post(f"{cls.url}/api/chatgpt/chatapi/text", json=data, headers=headers, proxy=proxy) as response:
-                response.raise_for_status()
-                token = (await response.json())["data"]["token"]
-                cls.used_times += 1
-            last_message = ""
-            async with session.get(f"{cls.url}/api/chatgpt/chatapi/stream", params={"token": token}, proxy=proxy) as response:
-                response.raise_for_status()
-                async for line in response.content:
-                    if line.startswith(b"data: "):
-                        if line.startswith(b"data: [DONE]"):
-                            break
-                        message = json.loads(line[6:-1])["content"]
-                        yield message[len(last_message):]
-                        last_message = message
diff --git a/g4f/Provider/deprecated/GeekGpt.py b/g4f/Provider/deprecated/GeekGpt.py
deleted file mode 100644
index 7a460083..00000000
--- a/g4f/Provider/deprecated/GeekGpt.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from __future__ import annotations
-import requests, json
-
-from ..base_provider import AbstractProvider
-from ...typing       import CreateResult, Messages
-from json           import dumps
-
-
-class GeekGpt(AbstractProvider):
-    url = 'https://chat.geekgpt.org'
-    working = False
-    supports_message_history = True
-    supports_stream = True
-    supports_gpt_35_turbo = True
-    supports_gpt_4 = True
-
-    @classmethod
-    def create_completion(
-        cls,
-        model: str,
-        messages: Messages,
-        stream: bool,
-        **kwargs
-    ) -> CreateResult:
-        if not model:
-            model = "gpt-3.5-turbo"
-        json_data = {
-            'messages': messages,
-            'model': model,
-            'temperature': kwargs.get('temperature', 0.9),
-            'presence_penalty': kwargs.get('presence_penalty', 0),
-            'top_p': kwargs.get('top_p', 1),
-            'frequency_penalty': kwargs.get('frequency_penalty', 0),
-            'stream': True
-        }
-
-        data = dumps(json_data, separators=(',', ':'))
-
-        headers = {
-            'authority': 'ai.fakeopen.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',
-            'authorization': 'Bearer pk-this-is-a-real-free-pool-token-for-everyone',
-            'content-type': 'application/json',
-            'origin': 'https://chat.geekgpt.org',
-            'referer': 'https://chat.geekgpt.org/',
-            'sec-ch-ua': '"Chromium";v="118", "Google Chrome";v="118", "Not=A?Brand";v="99"',
-            'sec-ch-ua-mobile': '?0',
-            'sec-ch-ua-platform': '"macOS"',
-            'sec-fetch-dest': 'empty',
-            'sec-fetch-mode': 'cors',
-            'sec-fetch-site': 'cross-site',
-            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
-        }
-
-        response = requests.post("https://ai.fakeopen.com/v1/chat/completions", 
-                                 headers=headers, data=data, stream=True)
-        response.raise_for_status()
-
-        for chunk in response.iter_lines():
-            if b'content' in chunk:
-                json_data = chunk.decode().replace("data: ", "")
-
-                if json_data == "[DONE]":
-                    break
-                
-                try:
-                    content = json.loads(json_data)["choices"][0]["delta"].get("content")
-                except Exception as e:
-                    raise RuntimeError(f'error | {e} :', json_data)
-                
-                if content:
-                    yield content
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/GetGpt.py b/g4f/Provider/deprecated/GetGpt.py
deleted file mode 100644
index dd586569..00000000
--- a/g4f/Provider/deprecated/GetGpt.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import uuid
-
-import requests
-# try:
-#     from Crypto.Cipher import AES
-# except ImportError:
-#     from Cryptodome.Cipher import AES
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class GetGpt(AbstractProvider):
-    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'])
-
-
-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')
-    return
-
-
-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
-    return
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/H2o.py b/g4f/Provider/deprecated/H2o.py
deleted file mode 100644
index ba4ca507..00000000
--- a/g4f/Provider/deprecated/H2o.py
+++ /dev/null
@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-import json
-import uuid
-
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider, format_prompt
-
-
-class H2o(AsyncGeneratorProvider):
-    url = "https://gpt-gm.h2o.ai"
-    model = "h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1"
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        model = model if model else cls.model
-        headers = {"Referer": f"{cls.url}/"}
-
-        async with ClientSession(
-            headers=headers
-        ) as session:
-            data = {
-                "ethicsModalAccepted": "true",
-                "shareConversationsWithModelAuthors": "true",
-                "ethicsModalAcceptedAt": "",
-                "activeModel": model,
-                "searchEnabled": "true",
-            }
-            async with session.post(
-                f"{cls.url}/settings",
-                proxy=proxy,
-                data=data
-            ) as response:
-                response.raise_for_status()
-
-            async with session.post(
-                f"{cls.url}/conversation",
-                proxy=proxy,
-                json={"model": model},
-            ) as response:
-                response.raise_for_status()
-                conversationId = (await response.json())["conversationId"]
-
-            data = {
-                "inputs": format_prompt(messages),
-                "parameters": {
-                    "temperature": 0.4,
-                    "truncate": 2048,
-                    "max_new_tokens": 1024,
-                    "do_sample":  True,
-                    "repetition_penalty": 1.2,
-                    "return_full_text": False,
-                    **kwargs
-                },
-                "stream": True,
-                "options": {
-                    "id": str(uuid.uuid4()),
-                    "response_id": str(uuid.uuid4()),
-                    "is_retry": False,
-                    "use_cache": False,
-                    "web_search_id": "",
-                },
-            }
-            async with session.post(
-                f"{cls.url}/conversation/{conversationId}",
-                proxy=proxy,
-                json=data
-             ) 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):-1])
-                        if not line["token"]["special"]:
-                            yield line["token"]["text"]
-
-            async with session.delete(
-                f"{cls.url}/conversation/{conversationId}",
-                proxy=proxy,
-            ) as response:
-                response.raise_for_status()
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Hashnode.py b/g4f/Provider/deprecated/Hashnode.py
deleted file mode 100644
index c2c0ffb7..00000000
--- a/g4f/Provider/deprecated/Hashnode.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import get_random_hex
-
-class SearchTypes():
-    quick = "quick"
-    code = "code"
-    websearch = "websearch"
-
-class Hashnode(AsyncGeneratorProvider):
-    url = "https://hashnode.com"
-    working = False
-    supports_message_history = True
-    supports_gpt_35_turbo = True
-    _sources = []
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        search_type: str = SearchTypes.websearch,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0",
-            "Accept": "*/*",
-            "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Referer": f"{cls.url}/rix",
-            "Content-Type": "application/json",
-            "Origin": cls.url,
-            "Connection": "keep-alive",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "Pragma": "no-cache",
-            "Cache-Control": "no-cache",
-            "TE": "trailers",
-        }
-        async with ClientSession(headers=headers) as session:
-            prompt = messages[-1]["content"]
-            cls._sources = []
-            if search_type == "websearch":
-                async with session.post(
-                    f"{cls.url}/api/ai/rix/search",
-                    json={"prompt": prompt},
-                    proxy=proxy,
-                ) as response:
-                    response.raise_for_status()
-                    cls._sources = (await response.json())["result"]
-            data = {
-                "chatId": get_random_hex(),
-                "history": messages,
-                "prompt": prompt,
-                "searchType": search_type,
-                "urlToScan": None,
-                "searchResults": cls._sources,
-            }
-            async with session.post(
-                f"{cls.url}/api/ai/rix/completion",
-                json=data,
-                proxy=proxy,
-            ) as response:
-                response.raise_for_status()
-                async for chunk in response.content.iter_any():
-                    if chunk:
-                        yield chunk.decode()
-
-    @classmethod
-    def get_sources(cls) -> list:
-        return [{
-            "title": source["name"],
-            "url": source["url"]
-        } for source in cls._sources]
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Lockchat.py b/g4f/Provider/deprecated/Lockchat.py
deleted file mode 100644
index edab0bd4..00000000
--- a/g4f/Provider/deprecated/Lockchat.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class Lockchat(AbstractProvider):
-    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)
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Myshell.py b/g4f/Provider/deprecated/Myshell.py
deleted file mode 100644
index 2487440d..00000000
--- a/g4f/Provider/deprecated/Myshell.py
+++ /dev/null
@@ -1,165 +0,0 @@
-# not using WS anymore
-
-from __future__ import annotations
-
-import json, uuid, hashlib, time, random
-
-from aiohttp import ClientSession
-from aiohttp.http import WSMsgType
-import asyncio
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider, format_prompt
-
-
-models = {
-    "samantha": "1e3be7fe89e94a809408b1154a2ee3e1",
-    "gpt-3.5-turbo": "8077335db7cd47e29f7de486612cc7fd",
-    "gpt-4": "01c8de4fbfc548df903712b0922a4e01",
-}
-
-
-class Myshell(AsyncGeneratorProvider):
-    url = "https://app.myshell.ai/chat"
-    working               = False
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 90,
-        **kwargs
-    ) -> AsyncResult:
-        if not model:
-            bot_id = models["samantha"]
-        elif model in models:
-            bot_id = models[model]
-        else:
-            raise ValueError(f"Model are not supported: {model}")
-        
-        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'
-        visitor_id = generate_visitor_id(user_agent)
-
-        async with ClientSession(
-            headers={'User-Agent': user_agent}
-        ) as session:
-            async with session.ws_connect(
-                "wss://api.myshell.ai/ws/?EIO=4&transport=websocket",
-                autoping=False,
-                timeout=timeout,
-                proxy=proxy
-            ) as wss:
-                # Send and receive hello message
-                await wss.receive_str()
-                message = json.dumps({"token": None, "visitorId": visitor_id})
-                await wss.send_str(f"40/chat,{message}")
-                await wss.receive_str()
-
-                # Fix "need_verify_captcha" issue
-                await asyncio.sleep(5)
-
-                # Create chat message
-                text = format_prompt(messages)
-                chat_data = json.dumps(["text_chat",{
-                    "reqId": str(uuid.uuid4()),
-                    "botUid": bot_id,
-                    "sourceFrom": "myshellWebsite",
-                    "text": text,
-                    **generate_signature(text)
-                }])
-
-                # Send chat message
-                chat_start = "42/chat,"
-                chat_message = f"{chat_start}{chat_data}"
-                await wss.send_str(chat_message)
-
-                # Receive messages
-                async for message in wss:
-                    if message.type != WSMsgType.TEXT:
-                        continue
-                    # Ping back
-                    if message.data == "2":
-                        await wss.send_str("3")
-                        continue
-                    # Is not chat message
-                    if not message.data.startswith(chat_start):
-                        continue
-                    data_type, data = json.loads(message.data[len(chat_start):])
-                    if data_type == "text_stream":
-                        if data["data"]["text"]:
-                            yield data["data"]["text"]
-                        elif data["data"]["isFinal"]:
-                            break
-                    elif data_type in ("message_replied", "need_verify_captcha"):
-                        raise RuntimeError(f"Received unexpected message: {data_type}")
-
-
-def generate_timestamp() -> str:
-    return str(
-        int(
-            str(int(time.time() * 1000))[:-1]
-            + str(
-                sum(
-                    2 * int(digit)
-                    if idx % 2 == 0
-                    else 3 * int(digit)
-                    for idx, digit in enumerate(str(int(time.time() * 1000))[:-1])
-                )
-                % 10
-            )
-        )
-    )
-
-def generate_signature(text: str):
-    timestamp = generate_timestamp()
-    version = 'v1.0.0'
-    secret = '8@VXGK3kKHr!u2gA' 
-    data = f"{version}#{text}#{timestamp}#{secret}"
-    signature = hashlib.md5(data.encode()).hexdigest()
-    signature = signature[::-1]
-    return {
-        "signature": signature,
-        "timestamp": timestamp,
-        "version": version
-    }
-
-def xor_hash(B: str):
-    r = []
-    i = 0
-    
-    def o(e, t):
-        o_val = 0
-        for i in range(len(t)):
-            o_val |= r[i] << (8 * i)
-        return e ^ o_val
-    
-    for e in range(len(B)):
-        t = ord(B[e])
-        r.insert(0, 255 & t)
-        
-        if len(r) >= 4:
-            i = o(i, r)
-            r = []
-    
-    if len(r) > 0:
-        i = o(i, r)
-    
-    return hex(i)[2:]
-
-def performance() -> str:
-    t = int(time.time() * 1000)
-    e = 0
-    while t == int(time.time() * 1000):
-        e += 1
-    return hex(t)[2:] + hex(e)[2:]
-
-def generate_visitor_id(user_agent: str) -> str:
-    f = performance()
-    r = hex(int(random.random() * (16**16)))[2:-2]
-    d = xor_hash(user_agent)
-    e = hex(1080 * 1920)[2:]
-    return f"{f}-{r}-{d}-{e}-{f}"
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/NoowAi.py b/g4f/Provider/deprecated/NoowAi.py
deleted file mode 100644
index dba87273..00000000
--- a/g4f/Provider/deprecated/NoowAi.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-import json
-from aiohttp import ClientSession
-
-from ..typing import AsyncResult, Messages
-from .base_provider import AsyncGeneratorProvider
-from .helper import get_random_string
-
-class NoowAi(AsyncGeneratorProvider):
-    url = "https://noowai.com"
-    supports_message_history = True
-    supports_gpt_35_turbo = True
-    working = False
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0",
-            "Accept": "*/*",
-            "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Referer": f"{cls.url}/",
-            "Content-Type": "application/json",
-            "Origin": cls.url,
-            "Alt-Used": "noowai.com",
-            "Connection": "keep-alive",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "Pragma": "no-cache",
-            "Cache-Control": "no-cache",
-            "TE": "trailers"
-        }
-        async with ClientSession(headers=headers) as session:
-            data = {
-                "botId": "default",
-                "customId": "d49bc3670c3d858458576d75c8ea0f5d",
-                "session": "N/A",
-                "chatId": get_random_string(),
-                "contextId": 25,
-                "messages": messages,
-                "newMessage": messages[-1]["content"],
-                "stream": True
-            }
-            async with session.post(f"{cls.url}/wp-json/mwai-ui/v1/chats/submit", json=data, proxy=proxy) as response:
-                response.raise_for_status()
-                async for line in response.content:
-                    if line.startswith(b"data: "):
-                        try:
-                            line = json.loads(line[6:])
-                            assert "type" in line
-                        except:
-                            raise RuntimeError(f"Broken line: {line.decode()}")
-                        if line["type"] == "live":
-                            yield line["data"]
-                        elif line["type"] == "end":
-                            break
-                        elif line["type"] == "error":
-                            raise RuntimeError(line["data"])
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Opchatgpts.py b/g4f/Provider/deprecated/Opchatgpts.py
deleted file mode 100644
index 94b1d099..00000000
--- a/g4f/Provider/deprecated/Opchatgpts.py
+++ /dev/null
@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-import random, string, json
-from aiohttp import ClientSession
-
-from ...typing import Messages, AsyncResult
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import get_random_string
-
-class Opchatgpts(AsyncGeneratorProvider):
-    url = "https://opchatgpts.net"
-    working = False
-    supports_message_history = True
-    supports_gpt_35_turbo = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None, **kwargs) -> AsyncResult:
-        
-        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"    : "de,en-US;q=0.7,en;q=0.3",
-            "Origin"             : cls.url,
-            "Alt-Used"           : "opchatgpts.net",
-            "Referer"            : f"{cls.url}/chatgpt-free-use/",
-            "Sec-Fetch-Dest"     : "empty",
-            "Sec-Fetch-Mode"     : "cors",
-            "Sec-Fetch-Site"     : "same-origin",
-        }
-        async with ClientSession(
-            headers=headers
-        ) as session:
-            data = {
-                "botId": "default",
-                "chatId": get_random_string(),
-                "contextId": 28,
-                "customId": None,
-                "messages": messages,
-                "newMessage": messages[-1]["content"],
-                "session": "N/A",
-                "stream": True
-            }
-            async with session.post(f"{cls.url}/wp-json/mwai-ui/v1/chats/submit", json=data, proxy=proxy) as response:
-                response.raise_for_status()
-                async for line in response.content:
-                    if line.startswith(b"data: "):
-                        try:
-                            line = json.loads(line[6:])
-                            assert "type" in line
-                        except:
-                            raise RuntimeError(f"Broken line: {line.decode()}")
-                        if line["type"] == "live":
-                            yield line["data"]
-                        elif line["type"] == "end":
-                            break
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/OpenAssistant.py b/g4f/Provider/deprecated/OpenAssistant.py
deleted file mode 100644
index 80cae3c2..00000000
--- a/g4f/Provider/deprecated/OpenAssistant.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import json
-
-from aiohttp import ClientSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-from ..helper import 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: Messages,
-        proxy: str = None,
-        cookies: dict = None,
-        **kwargs
-    ) -> AsyncResult:
-        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()
diff --git a/g4f/Provider/deprecated/Phind.py b/g4f/Provider/deprecated/Phind.py
deleted file mode 100644
index c72bf09e..00000000
--- a/g4f/Provider/deprecated/Phind.py
+++ /dev/null
@@ -1,140 +0,0 @@
-from __future__ import annotations
-
-import re
-import json
-from urllib import parse
-from datetime import datetime
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider
-from ...requests import StreamSession
-
-class Phind(AsyncGeneratorProvider):
-    url = "https://www.phind.com"
-    working = False
-    lockdown = True
-    supports_stream = True
-    supports_message_history = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 120,
-        creative_mode: bool = False,
-        **kwargs
-    ) -> AsyncResult:
-        headers = {
-            "Accept": "*/*",
-            "Origin": cls.url,
-            "Referer": f"{cls.url}/search",
-            "Sec-Fetch-Dest": "empty", 
-            "Sec-Fetch-Mode": "cors", 
-            "Sec-Fetch-Site": "same-origin",
-        }
-        async with StreamSession(
-            headers=headers,
-            impersonate="chrome",
-            proxies={"https": proxy},
-            timeout=timeout
-        ) as session:
-            url = "https://www.phind.com/search?home=true"
-            async with session.get(url) as response:
-                text = await response.text()
-                match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(?P<json>[\S\s]+?)</script>', text)
-                data = json.loads(match.group("json"))
-                challenge_seeds = data["props"]["pageProps"]["challengeSeeds"]
-                
-            prompt = messages[-1]["content"]
-            data = {
-                "question": prompt,
-                "question_history": [
-                    message["content"] for message in messages[:-1] if message["role"] == "user"
-                ],
-                "answer_history": [
-                    message["content"] for message in messages if message["role"] == "assistant"
-                ],
-                "webResults": [],
-                "options": {
-                    "date": datetime.now().strftime("%d.%m.%Y"),
-                    "language": "en-US",
-                    "detailed": True,
-                    "anonUserId": "",
-                    "answerModel": "GPT-4" if model.startswith("gpt-4") else "Phind-34B",
-                    "creativeMode": creative_mode,
-                    "customLinks": []
-                },
-                "context": "\n".join([message["content"] for message in messages if message["role"] == "system"]),
-            }
-            data["challenge"] = generate_challenge(data, **challenge_seeds)
-            async with session.post(f"https://https.api.phind.com/infer/", headers=headers, json=data) as response:
-                new_line = False
-                async for line in response.iter_lines():
-                    if line.startswith(b"data: "):
-                        chunk = line[6:]
-                        if chunk.startswith(b'<PHIND_DONE/>'):
-                            break
-                        if chunk.startswith(b'<PHIND_BACKEND_ERROR>'):
-                            raise RuntimeError(f"Response: {chunk.decode()}")
-                        if chunk.startswith(b'<PHIND_WEBRESULTS>') or chunk.startswith(b'<PHIND_FOLLOWUP>'):
-                            pass
-                        elif chunk.startswith(b"<PHIND_METADATA>") or chunk.startswith(b"<PHIND_INDICATOR>"):
-                            pass
-                        elif chunk.startswith(b"<PHIND_SPAN_BEGIN>") or chunk.startswith(b"<PHIND_SPAN_END>"):
-                            pass
-                        elif chunk:
-                            yield chunk.decode()
-                        elif new_line:
-                            yield "\n"
-                            new_line = False
-                        else:
-                            new_line = True
-
-def deterministic_stringify(obj):
-    def handle_value(value):
-        if isinstance(value, (dict, list)):
-            if isinstance(value, list):
-                return '[' + ','.join(sorted(map(handle_value, value))) + ']'
-            else:  # It's a dict
-                return '{' + deterministic_stringify(value) + '}'
-        elif isinstance(value, bool):
-            return 'true' if value else 'false'
-        elif isinstance(value, (int, float)):
-            return format(value, '.8f').rstrip('0').rstrip('.')
-        elif isinstance(value, str):
-            return f'"{value}"'
-        else:
-            return 'null'
-
-    items = sorted(obj.items(), key=lambda x: x[0])
-    return ','.join([f'{k}:{handle_value(v)}' for k, v in items if handle_value(v) is not None])
-
-def prng_general(seed, multiplier, addend, modulus):
-    a = seed * multiplier + addend
-    if a < 0:
-        return ((a%modulus)-modulus)/modulus
-    else:
-        return a%modulus/modulus
-
-def generate_challenge_seed(l):
-    I = deterministic_stringify(l)
-    d = parse.quote(I, safe='')
-    return simple_hash(d)
-
-def simple_hash(s):
-    d = 0
-    for char in s:
-        if len(char) > 1 or ord(char) >= 256:
-            continue
-        d = ((d << 5) - d + ord(char[0])) & 0xFFFFFFFF
-        if d > 0x7FFFFFFF: # 2147483647
-            d -= 0x100000000 # Subtract 2**32
-    return d
-
-def generate_challenge(obj, **kwargs):
-    return prng_general(
-        seed=generate_challenge_seed(obj),
-        **kwargs
-    )
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/V50.py b/g4f/Provider/deprecated/V50.py
deleted file mode 100644
index 456445f7..00000000
--- a/g4f/Provider/deprecated/V50.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import uuid
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider
-
-
-class V50(AbstractProvider):
-    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
-            )
-            + "\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.get('proxy', {}),
-        )
-
-        if "https://fk1.v50.ltd" not in response.text:
-            yield response.text
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Vercel.py b/g4f/Provider/deprecated/Vercel.py
deleted file mode 100644
index adf7b208..00000000
--- a/g4f/Provider/deprecated/Vercel.py
+++ /dev/null
@@ -1,392 +0,0 @@
-from __future__ import annotations
-
-import json, base64, requests, random, uuid
-
-try:
-    import execjs
-    has_requirements = True
-except ImportError:
-    has_requirements = False
-
-from ...typing       import Messages, TypedDict, CreateResult, Any
-from ..base_provider import AbstractProvider
-from ...errors       import MissingRequirementsError
-
-class Vercel(AbstractProvider):
-    url = 'https://sdk.vercel.ai'
-    working = False
-    supports_message_history = True 
-    supports_gpt_35_turbo = True
-    supports_stream = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: Messages,
-        stream: bool,
-        proxy: str = None,
-        **kwargs
-    ) -> CreateResult:
-        if not has_requirements:
-            raise MissingRequirementsError('Install "PyExecJS" package')
-
-        if not model:
-            model = "gpt-3.5-turbo"
-        elif model not in model_info:
-            raise ValueError(f"Vercel does not support {model}")
-
-        headers = {
-            'authority': 'sdk.vercel.ai',
-            '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',
-            'cache-control': 'no-cache',
-            'content-type': 'application/json',
-            'custom-encoding': get_anti_bot_token(),
-            'origin': 'https://sdk.vercel.ai',
-            'pragma': 'no-cache',
-            'referer': 'https://sdk.vercel.ai/',
-            'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"',
-            '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': f'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.{random.randint(99, 999)}.{random.randint(99, 999)} Safari/537.36',
-        }
-
-        json_data = {
-            'model'       : model_info[model]['id'],
-            'messages'    : messages,
-            'playgroundId': str(uuid.uuid4()),
-            'chatIndex'   : 0,
-            **model_info[model]['default_params'],
-            **kwargs
-        }
-
-        max_retries  = kwargs.get('max_retries', 20)
-        for _ in range(max_retries):
-            response = requests.post('https://chat.vercel.ai/api/chat', 
-                                    headers=headers, json=json_data, stream=True, proxies={"https": proxy})
-            try:
-                response.raise_for_status()
-            except:
-                continue
-            for token in response.iter_content(chunk_size=None):
-                yield token.decode()
-            break
-
-
-def get_anti_bot_token() -> str:
-    headers = {
-        'authority': 'sdk.vercel.ai',
-        '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',
-        'cache-control': 'no-cache',
-        'pragma': 'no-cache',
-        'referer': 'https://sdk.vercel.ai/',
-        'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"',
-        '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': f'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.{random.randint(99, 999)}.{random.randint(99, 999)} Safari/537.36',
-    }
-
-    response = requests.get('https://sdk.vercel.ai/openai.jpeg', 
-                            headers=headers).text
-
-    raw_data = json.loads(base64.b64decode(response, 
-                                    validate=True))
-
-    js_script = '''const globalThis={marker:"mark"};String.prototype.fontcolor=function(){return `<font>${this}</font>`};
-        return (%s)(%s)''' % (raw_data['c'], raw_data['a'])
-
-    raw_token = json.dumps({'r': execjs.compile(js_script).call(''), 't': raw_data['t']}, 
-                        separators = (",", ":"))
-
-    return base64.b64encode(raw_token.encode('utf-16le')).decode()
-
-class ModelInfo(TypedDict):
-    id: str
-    default_params: dict[str, Any]
-
-model_info: dict[str, ModelInfo] = {
-    # 'claude-instant-v1': {
-    #     'id': 'anthropic:claude-instant-v1',
-    #     'default_params': {
-    #         'temperature': 1,
-    #         'maximumLength': 1024,
-    #         'topP': 1,
-    #         'topK': 1,
-    #         'presencePenalty': 1,
-    #         'frequencyPenalty': 1,
-    #         'stopSequences': ['\n\nHuman:'],
-    #     },
-    # },
-    # 'claude-v1': {
-    #     'id': 'anthropic:claude-v1',
-    #     'default_params': {
-    #         'temperature': 1,
-    #         'maximumLength': 1024,
-    #         'topP': 1,
-    #         'topK': 1,
-    #         'presencePenalty': 1,
-    #         'frequencyPenalty': 1,
-    #         'stopSequences': ['\n\nHuman:'],
-    #     },
-    # },
-    # 'claude-v2': {
-    #     'id': 'anthropic:claude-v2',
-    #     'default_params': {
-    #         'temperature': 1,
-    #         'maximumLength': 1024,
-    #         'topP': 1,
-    #         'topK': 1,
-    #         'presencePenalty': 1,
-    #         'frequencyPenalty': 1,
-    #         'stopSequences': ['\n\nHuman:'],
-    #     },
-    # },
-    'replicate/llama70b-v2-chat': {
-        'id': 'replicate:replicate/llama-2-70b-chat',
-        'default_params': {
-            'temperature': 0.75,
-            'maximumLength': 3000,
-            'topP': 1,
-            'repetitionPenalty': 1,
-        },
-    },
-    'a16z-infra/llama7b-v2-chat': {
-        'id': 'replicate:a16z-infra/llama7b-v2-chat',
-        'default_params': {
-            'temperature': 0.75,
-            'maximumLength': 3000,
-            'topP': 1,
-            'repetitionPenalty': 1,
-        },
-    },
-    'a16z-infra/llama13b-v2-chat': {
-        'id': 'replicate:a16z-infra/llama13b-v2-chat',
-        'default_params': {
-            'temperature': 0.75,
-            'maximumLength': 3000,
-            'topP': 1,
-            'repetitionPenalty': 1,
-        },
-    },
-    'replicate/llama-2-70b-chat': {
-        'id': 'replicate:replicate/llama-2-70b-chat',
-        'default_params': {
-            'temperature': 0.75,
-            'maximumLength': 3000,
-            'topP': 1,
-            'repetitionPenalty': 1,
-        },
-    },
-    'bigscience/bloom': {
-        'id': 'huggingface:bigscience/bloom',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 0.95,
-            'topK': 4,
-            'repetitionPenalty': 1.03,
-        },
-    },
-    'google/flan-t5-xxl': {
-        'id': 'huggingface:google/flan-t5-xxl',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 0.95,
-            'topK': 4,
-            'repetitionPenalty': 1.03,
-        },
-    },
-    'EleutherAI/gpt-neox-20b': {
-        'id': 'huggingface:EleutherAI/gpt-neox-20b',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 0.95,
-            'topK': 4,
-            'repetitionPenalty': 1.03,
-            'stopSequences': [],
-        },
-    },
-    'OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5': {
-        'id': 'huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5',
-        'default_params': {
-            'maximumLength': 1024,
-            'typicalP': 0.2,
-            'repetitionPenalty': 1,
-        },
-    },
-    'OpenAssistant/oasst-sft-1-pythia-12b': {
-        'id': 'huggingface:OpenAssistant/oasst-sft-1-pythia-12b',
-        'default_params': {
-            'maximumLength': 1024,
-            'typicalP': 0.2,
-            'repetitionPenalty': 1,
-        },
-    },
-    'bigcode/santacoder': {
-        'id': 'huggingface:bigcode/santacoder',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 0.95,
-            'topK': 4,
-            'repetitionPenalty': 1.03,
-        },
-    },
-    'command-light-nightly': {
-        'id': 'cohere:command-light-nightly',
-        'default_params': {
-            'temperature': 0.9,
-            'maximumLength': 1024,
-            'topP': 1,
-            'topK': 0,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    'command-nightly': {
-        'id': 'cohere:command-nightly',
-        'default_params': {
-            'temperature': 0.9,
-            'maximumLength': 1024,
-            'topP': 1,
-            'topK': 0,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    # 'gpt-4': {
-    #     'id': 'openai:gpt-4',
-    #     'default_params': {
-    #         'temperature': 0.7,
-    #         'maximumLength': 8192,
-    #         'topP': 1,
-    #         'presencePenalty': 0,
-    #         'frequencyPenalty': 0,
-    #         'stopSequences': [],
-    #     },
-    # },
-    # 'gpt-4-0613': {
-    #     'id': 'openai:gpt-4-0613',
-    #     'default_params': {
-    #         'temperature': 0.7,
-    #         'maximumLength': 8192,
-    #         'topP': 1,
-    #         'presencePenalty': 0,
-    #         'frequencyPenalty': 0,
-    #         'stopSequences': [],
-    #     },
-    # },
-    'code-davinci-002': {
-        'id': 'openai:code-davinci-002',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 1,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    'gpt-3.5-turbo': {
-        'id': 'openai:gpt-3.5-turbo',
-        'default_params': {
-            'temperature': 0.7,
-            'maximumLength': 4096,
-            'topP': 1,
-            'topK': 1,
-            'presencePenalty': 1,
-            'frequencyPenalty': 1,
-            'stopSequences': [],
-        },
-    },
-    'gpt-3.5-turbo-16k': {
-        'id': 'openai:gpt-3.5-turbo-16k',
-        'default_params': {
-            'temperature': 0.7,
-            'maximumLength': 16280,
-            'topP': 1,
-            'topK': 1,
-            'presencePenalty': 1,
-            'frequencyPenalty': 1,
-            'stopSequences': [],
-        },
-    },
-    'gpt-3.5-turbo-16k-0613': {
-        'id': 'openai:gpt-3.5-turbo-16k-0613',
-        'default_params': {
-            'temperature': 0.7,
-            'maximumLength': 16280,
-            'topP': 1,
-            'topK': 1,
-            'presencePenalty': 1,
-            'frequencyPenalty': 1,
-            'stopSequences': [],
-        },
-    },
-    'text-ada-001': {
-        'id': 'openai:text-ada-001',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 1,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    'text-babbage-001': {
-        'id': 'openai:text-babbage-001',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 1,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    'text-curie-001': {
-        'id': 'openai:text-curie-001',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 1,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    'text-davinci-002': {
-        'id': 'openai:text-davinci-002',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 1024,
-            'topP': 1,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-    'text-davinci-003': {
-        'id': 'openai:text-davinci-003',
-        'default_params': {
-            'temperature': 0.5,
-            'maximumLength': 4097,
-            'topP': 1,
-            'presencePenalty': 0,
-            'frequencyPenalty': 0,
-            'stopSequences': [],
-        },
-    },
-}
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Vitalentum.py b/g4f/Provider/deprecated/Vitalentum.py
deleted file mode 100644
index 8f466a52..00000000
--- a/g4f/Provider/deprecated/Vitalentum.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-import json
-from aiohttp import ClientSession
-
-from ..base_provider import AsyncGeneratorProvider
-from ...typing import AsyncResult, Messages
-
-class Vitalentum(AsyncGeneratorProvider):
-    url                   = "https://app.vitalentum.io"
-    supports_gpt_35_turbo = True
-
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        **kwargs
-    ) -> AsyncResult:
-        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": "text/event-stream",
-            "Accept-language": "de,en-US;q=0.7,en;q=0.3",
-            "Origin": cls.url,
-            "Referer": f"{cls.url}/",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-        }
-        conversation = json.dumps({"history": [{
-            "speaker": "human" if message["role"] == "user" else "bot",
-            "text": message["content"],
-        } for message in messages]})
-        data = {
-            "conversation": conversation,
-            "temperature": 0.7,
-            **kwargs
-        }
-        async with ClientSession(
-                headers=headers
-            ) as session:
-            async with session.post(f"{cls.url}/api/converse-edge", json=data, proxy=proxy) 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
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/VoiGpt.py b/g4f/Provider/deprecated/VoiGpt.py
deleted file mode 100644
index 9b061e63..00000000
--- a/g4f/Provider/deprecated/VoiGpt.py
+++ /dev/null
@@ -1,91 +0,0 @@
-from __future__ import annotations
-
-import json
-import requests
-from ..base_provider import AbstractProvider
-from ...typing import Messages, CreateResult
-
-
-class VoiGpt(AbstractProvider):
-    """
-    VoiGpt - A provider for VoiGpt.com
-
-    **Note** : to use this provider you have to get your csrf token/cookie from the voigpt.com website
-
-    Args:
-        model: The model to use
-        messages: The messages to send
-        stream: Whether to stream the response
-        proxy: The proxy to use
-        access_token: The access token to use
-        **kwargs: Additional keyword arguments
-
-    Returns:
-        A CreateResult object
-    """
-    url = "https://voigpt.com"
-    working = False
-    supports_gpt_35_turbo = True
-    supports_message_history = True
-    supports_stream = False
-    _access_token: str = None
-
-    @classmethod
-    def create_completion(
-        cls,
-        model: str,
-        messages: Messages,
-        stream: bool,
-        proxy: str = None,
-        access_token: str = None,
-        **kwargs
-    ) -> CreateResult:
-        
-        if not model:
-            model = "gpt-3.5-turbo"
-        if not access_token:
-            access_token = cls._access_token
-        if not access_token:
-            headers = {
-                "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-                "accept-language": "de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US;q=0.6",
-                "sec-ch-ua": "\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"",
-                "sec-ch-ua-mobile": "?0",
-                "sec-ch-ua-platform": "\"Linux\"",
-                "sec-fetch-dest": "document",
-                "sec-fetch-mode": "navigate",
-                "sec-fetch-site": "none",
-                "sec-fetch-user": "?1",
-                "upgrade-insecure-requests": "1",
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
-            }
-            req_response = requests.get(cls.url, headers=headers)
-            access_token = cls._access_token = req_response.cookies.get("csrftoken")
-
-        headers = {
-            "Accept-Encoding": "gzip, deflate, br",
-            "Accept-Language": "de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US;q=0.6",
-            "Cookie": f"csrftoken={access_token};",
-            "Origin": "https://voigpt.com",
-            "Referer": "https://voigpt.com/",
-            "Sec-Ch-Ua": "'Google Chrome';v='119', 'Chromium';v='119', 'Not?A_Brand';v='24'",
-            "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/119.0.0.0 Safari/537.36",
-            "X-Csrftoken": access_token,
-        }
-
-        payload = {
-            "messages": messages,
-        }
-        request_url = f"{cls.url}/generate_response/"
-        req_response = requests.post(request_url, headers=headers, json=payload)
-        try:
-            response = json.loads(req_response.text)
-            yield response["response"]
-        except:
-            raise RuntimeError(f"Response: {req_response.text}")
-    
diff --git a/g4f/Provider/deprecated/Wewordle.py b/g4f/Provider/deprecated/Wewordle.py
deleted file mode 100644
index c30887fb..00000000
--- a/g4f/Provider/deprecated/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/deprecated/Wuguokai.py b/g4f/Provider/deprecated/Wuguokai.py
deleted file mode 100644
index f12d1bfe..00000000
--- a/g4f/Provider/deprecated/Wuguokai.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import random
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import AbstractProvider, format_prompt
-
-
-class Wuguokai(AbstractProvider):
-    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.get('proxy', {}),
-        )
-        _split = response.text.split("> 若回答失败请重试或多刷新几次界面后重试")
-        if response.status_code != 200:
-            raise Exception(f"Error: {response.status_code} {response.reason}")
-        if len(_split) > 1:
-            yield _split[1].strip()
-        else:
-            yield _split[0].strip()
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Ylokh.py b/g4f/Provider/deprecated/Ylokh.py
deleted file mode 100644
index dbff4602..00000000
--- a/g4f/Provider/deprecated/Ylokh.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import json
-
-from ...requests import StreamSession
-from ..base_provider import AsyncGeneratorProvider
-from ...typing import AsyncResult, Messages
-
-class Ylokh(AsyncGeneratorProvider):
-    url = "https://chat.ylokh.xyz"
-    working = False
-    supports_message_history = True 
-    supports_gpt_35_turbo = True
-
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        stream: bool = True,
-        proxy: str = None,
-        timeout: int = 120,
-        **kwargs
-    ) -> AsyncResult:
-        model = model if model else "gpt-3.5-turbo"
-        headers = {"Origin": cls.url, "Referer": f"{cls.url}/"}
-        data = {
-            "messages": messages,
-            "model": model,
-            "temperature": 1,
-            "presence_penalty": 0,
-            "top_p": 1,
-            "frequency_penalty": 0,
-            "allow_fallback": True,
-            "stream": stream,
-            **kwargs
-        }
-        async with StreamSession(
-                headers=headers,
-                proxies={"https": proxy},
-                timeout=timeout
-            ) as session:
-            async with session.post("https://chatapi.ylokh.xyz/v1/chat/completions", json=data) as response:
-                response.raise_for_status()
-                if stream:
-                    async for line in response.iter_lines():
-                        line = line.decode()
-                        if line.startswith("data: "):
-                            if line.startswith("data: [DONE]"):
-                                break
-                            line = json.loads(line[6:])
-                            content = line["choices"][0]["delta"].get("content")
-                            if content:
-                                yield content
-                else:
-                    chat = await response.json()
-                    yield chat["choices"][0]["message"].get("content")
\ No newline at end of file
diff --git a/g4f/Provider/deprecated/Yqcloud.py b/g4f/Provider/deprecated/Yqcloud.py
deleted file mode 100644
index 227f8995..00000000
--- a/g4f/Provider/deprecated/Yqcloud.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import random
-from ...requests import StreamSession
-
-from ...typing import AsyncResult, Messages
-from ..base_provider import AsyncGeneratorProvider, format_prompt
-
-
-class Yqcloud(AsyncGeneratorProvider):
-    url = "https://chat9.yqcloud.top/"
-    working = False
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    async def create_async_generator(
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 120,
-        **kwargs,
-    ) -> AsyncResult:
-        async with StreamSession(
-            headers=_create_header(), proxies={"https": proxy}, timeout=timeout
-        ) as session:
-            payload = _create_payload(messages, **kwargs)
-            async with session.post("https://api.aichatos.cloud/api/generateStream", json=payload) as response:
-                response.raise_for_status()
-                async for chunk in response.iter_content():
-                    if chunk:
-                        chunk = chunk.decode()
-                        if "sorry, 您的ip已由于触发防滥用检测而被封禁" in chunk:
-                            raise RuntimeError("IP address is blocked by abuse detection.")
-                        yield chunk
-
-
-def _create_header():
-    return {
-        "accept"        : "application/json, text/plain, */*",
-        "content-type"  : "application/json",
-        "origin"        : "https://chat9.yqcloud.top",
-        "referer"       : "https://chat9.yqcloud.top/"
-    }
-
-
-def _create_payload(
-    messages: Messages,
-    system_message: str = "",
-    user_id: int = None,
-    **kwargs
-):
-    if not user_id:
-        user_id = random.randint(1690000544336, 2093025544336)
-    return {
-        "prompt": format_prompt(messages),
-        "network": True,
-        "system": system_message,
-        "withoutContext": False,
-        "stream": True,
-        "userId": f"#/chat/{user_id}"
-    }
diff --git a/g4f/Provider/deprecated/__init__.py b/g4f/Provider/deprecated/__init__.py
deleted file mode 100644
index bf923f2a..00000000
--- a/g4f/Provider/deprecated/__init__.py
+++ /dev/null
@@ -1,35 +0,0 @@
-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 .Lockchat      import Lockchat
-from .Wewordle      import Wewordle
-from .Equing        import Equing
-from .Wuguokai      import Wuguokai
-from .V50           import V50
-from .FastGpt       import FastGpt
-from .Aivvm         import Aivvm
-from .Vitalentum    import Vitalentum
-from .H2o           import H2o
-from .Myshell       import Myshell
-from .Acytoo        import Acytoo
-from .Aibn          import Aibn
-from .Ails          import Ails 
-from .ChatgptDuo    import ChatgptDuo
-from .Cromicle      import Cromicle
-from .Opchatgpts    import Opchatgpts
-from .Yqcloud       import Yqcloud
-from .Aichat        import Aichat
-from .Berlin        import Berlin
-from .Phind         import Phind
-from .AiAsk         import AiAsk
-from ..AiChatOnline  import AiChatOnline
-from .ChatAnywhere  import ChatAnywhere
-from .FakeGpt       import FakeGpt
-from .GeekGpt       import GeekGpt
-from .GPTalk        import GPTalk
-from .Hashnode      import Hashnode
-from .Ylokh         import Ylokh
-from .OpenAssistant import OpenAssistant
\ No newline at end of file