Upload folder using huggingface_hub

.github/README.md

@@ -1,45 +1,48 @@
 <div align="center">
 <a href="https://t.me/neurogen_news">
-  <img src="https://readme-typing-svg.herokuapp.com?font=Jura&weight=700&size=30&duration=4000&pause=1000&color=1BED29&center=true&width=435&lines=NeuroGPT+by+NeurogenAI" alt="NeuroGPT" />
+  <img src="https://readme-typing-svg.herokuapp.com?font=Inconsolata&weight=700&size=30&duration=4000&pause=1000&color=1BED29&center=true&width=435&lines=NeuroGPT+by+Neurogen...;Opening..." alt="NeuroGPT" />
 </a>
 
-<strong> <a href="https://github.com/Em1tSan/NeuroGPT/blob/main/.github/README_RU.md">Русский</a> | English </strong>
+<strong> Русский | <a href="https://github.com/Em1tSan/NeuroGPT/blob/main/.github/README_EN.md">English </a></strong>
 
-> ### The project is currently undergoing a transition to another client and reconstruction of the API. Technical work is continuing. We apologize for any inconvenience.
-  
-<p> Free API service providing access to GPT-3.5, GPT-4, and other language models. Before using it, please make sure you check out our <a href="https://github.com/Em1tSan/NeuroGPT/wiki#english-language">wiki</a>. The project utilizes a modified version of <a href="https://github.com/xtekky/gpt4free">gpt4free</a>, as well as <a href="https://github.com/GaiZhenbiao/ChuanhuChatGPT">ChuanhuChatGPT</a> as a web interface. We extend our gratitude to the authors.</p>
+<p> NeuroGPT позволяет простому пользователю получить бесплатный доступ к gpt-3.5, gpt-4 и другим языковым моделям без VPN и регистрации аккаунта. В стабильном режиме на данный момент функционирует только gpt-3.5-turbo 4097. Постоянный доступ к остальным моделям не гарантируется.
+
+Проект основан на модифицированных версиях <a href="https://github.com/xtekky/gpt4free">gpt4free</a> и <a href="https://github.com/GaiZhenbiao/ChuanhuChatGPT">ChuanhuChatGPT</a></p>
+Благодарность авторам.
 
-<p>
 <a href="https://github.com/Em1tSan/NeuroGPT/blob/main/LICENSE">
-  <img src="https://img.shields.io/badge/license-GPL_3.0-darkgreen.svg" alt="license"/>
+  <img src="https://img.shields.io/badge/license-GPL_3.0-indigo.svg" alt="license"/>
 </a>
 <a href="https://github.com/Em1tSan/NeuroGPT/commits/main">
-  <img src="https://img.shields.io/badge/latest-v1.5.4-darkgreen.svg" alt="latest"/>
-</a></p>
+  <img src="https://img.shields.io/badge/latest-v1.4.6-indigo.svg" alt="latest"/>
+</a>
+
+<br> Перед использованием обязательно ознакомьтесь с <a href="https://github.com/Em1tSan/NeuroGPT/wiki#%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9-%D1%8F%D0%B7%D1%8B%D0%BA">wiki проекта</a><br/>
+<br> Инструкции по установке: <br/>
 
-<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#windows">
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA#windows">
   <img src="https://img.shields.io/badge/-Windows-1371c3?logo=windows" alt="windows"/>
 </a>
-<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#linux">
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA#linux">
   <img src="https://img.shields.io/badge/-Linux-F1502F?logo=linux" alt="linux"/>
 </a>
-<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#macos">
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA#macos">
   <img src="https://img.shields.io/badge/-MacOS-C0BFC0?logo=apple" alt="macos"/>
-</a>
-<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#portable-version">
-  <img src="https://img.shields.io/badge/-Portable version-8080ff?logo=portable" alt="portable"/>
+</a> </p>
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/%D0%A3%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA#%D0%BF%D0%BE%D1%80%D1%82%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F-%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F">
+  <img src="https://img.shields.io/badge/-Портативная версия-008000?logo=portable" alt="portable"/>
 </a>
 
-<br> News and feedback: <br/>
+<br> Новости и обратная связь: <br/>
 
 <a href="https://t.me/neurogen_news">
-  <img src="https://img.shields.io/badge/-Telegram channel-0088CC?logo=telegram" alt="telegram"/>
+  <img src="https://img.shields.io/badge/-Telegram канал-0088CC?logo=telegram" alt="telegram"/>
 </a>
 <a href="https://t.me/neurogen_chat">
-  <img src="https://img.shields.io/badge/-Telegram chat-0088CC?logo=telegram" alt="telegram_chat"/>
+  <img src="https://img.shields.io/badge/-Telegram чат-0088CC?logo=telegram" alt="telegram_chat"/>
 </a>
 
-<br> Support the project: <br/>
+<br> Поддержать проект: <br/>
 
 <a href="https://boosty.to/neurogen">
   <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/9/92/Boosty_logo.svg/512px-Boosty_logo.svg.png?20230209172145" alt="neurogen_boosty" width="20%">
@@ -47,16 +50,20 @@
 
 </div>
 
-## Features
+## Дисклеймер:
+
+Поскольку данный проект функционирует не через официальное API, а благодаря доступу, полученному путем обратной инженерии, то API провайдеры могут падать, а различные модели отключаться. Пожалуйста, учтите это. Если вам необходима высокая стабильность для работы, то стоит обойти этот проект стороной. Также важно помнить, что поддержка осуществляется на чистом энтузиазме.
+
+## Возможности:
 
-- Web search
-- [Model list](https://status.neuroapi.host/v1/status)
-- Dialog context
-- No-logs
-- API endpoint
-- Dialog history
-- Setting generation parameters for GPT models
-- Built-in prompt templates and jailbreaks for various tasks
+- Веб-поиск
+- [Список моделей](https://status.neuroapi.host/v1/status)
+- Встроенные шаблоны промптов под разные задачи
+- Встроенные джейлбрейки для снятия цензуры
+- Контекст беседы
+- Режим endpoint для работы с API
+- Изменение параметров генерации для gpt-моделей
+- Сохранение и загрузка истории диалогов
 
 <div align="center">
   <img src="https://github.com/NealBelov/screenshots/blob/main/img_03.png?raw=true" width="100%">

.github/README_EN.md

@@ -0,0 +1,75 @@
+<div align="center">
+<a href="https://t.me/neurogen_news">
+  <img src="https://readme-typing-svg.herokuapp.com?font=Inconsolata&weight=700&size=30&duration=4000&pause=1000&color=1BED29&center=true&width=435&lines=NeuroGPT+by+Neurogen...;Opening..." alt="NeuroGPT" />
+</a>
+
+<strong> <a href="https://github.com/Em1tSan/NeuroGPT#readme">Русский</a> | English </strong>
+
+<p> NeuroGPT allows free use of gpt-3.5, gpt-4, and other language models without VPN and account registration. It operates through API Reverse Engineering. At the moment, only gpt-3.5-turbo 4097 is functioning in stable mode. Continuous access to other models is not guaranteed.
+
+The project is based on modified versions of <a href="https://github.com/xtekky/gpt4free">gpt4free</a> and <a href="https://github.com/GaiZhenbiao/ChuanhuChatGPT">ChuanhuChatGPT</a></p>
+We extend our gratitude to the authors.
+
+<a href="https://github.com/Em1tSan/NeuroGPT/blob/main/LICENSE">
+  <img src="https://img.shields.io/badge/license-GPL_3.0-indigo.svg" alt="license"/>
+</a>
+<a href="https://github.com/Em1tSan/NeuroGPT/commits/main">
+  <img src="https://img.shields.io/badge/latest-v1.4.6-indigo.svg" alt="latest"/>
+</a>
+
+<br> Before using NeuroGPT, be sure to check out <a href="https://github.com/Em1tSan/NeuroGPT/wiki#english-language">our project's wiki</a><br/>
+<br> Installation instructions: <br/>
+
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#windows">
+  <img src="https://img.shields.io/badge/-Windows-1371c3?logo=windows" alt="windows"/>
+</a>
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#linux">
+  <img src="https://img.shields.io/badge/-Linux-F1502F?logo=linux" alt="linux"/>
+</a>
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#macos">
+  <img src="https://img.shields.io/badge/-MacOS-C0BFC0?logo=apple" alt="macos"/>
+</a> </p>
+<a href="https://github.com/Em1tSan/NeuroGPT/wiki/Installing-and-running#portable-version">
+  <img src="https://img.shields.io/badge/-Portable version-008000?logo=portable" alt="portable"/>
+</a>
+
+<br> News and feedback: <br/>
+
+<a href="https://t.me/neurogen_news">
+  <img src="https://img.shields.io/badge/-Telegram channel-0088CC?logo=telegram" alt="telegram"/>
+</a>
+<a href="https://t.me/neurogen_chat">
+  <img src="https://img.shields.io/badge/-Telegram chat-0088CC?logo=telegram" alt="telegram_chat"/>
+</a>
+
+<br> Support the project: <br/>
+
+<a href="https://boosty.to/neurogen">
+  <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/9/92/Boosty_logo.svg/512px-Boosty_logo.svg.png?20230209172145" alt="neurogen_boosty" width="20%">
+</a>
+
+</div>
+
+## Disclaimer:
+
+Given that this project doesn't use an official API but relies on reverse-engineered method, there's a risk of API providers failing and certain models disconnecting. Consider this if you need high stability for your work. Remember, support is provided solely out of enthusiasm.
+
+## Features:
+
+- Web search
+- [List of models](https://status.neuroapi.host/v1/status)
+- Built-in prompt templates for various tasks
+- Built-in jailbreaks for removing censorship
+- Conversation context
+- API endpoint
+- Setting generation parameters for GPT models
+- Saving and loading dialogue history
+
+<div align="center">
+  <img src="https://github.com/NealBelov/screenshots/blob/main/img_03.png?raw=true" width="100%">
+
+***
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Em1tSan/NeuroGPT&type=Date)](https://star-history.com/#Em1tSan/NeuroGPT&Date)
+
+</div>

backend/backend.py

@@ -4,13 +4,12 @@ import json
 import random
 import string
 import socket
-import nest_asyncio
 
 import requests
-from typing       import Any
 
-from flask import Flask, request, jsonify, Response
+from flask import Flask, request, jsonify, Response, stream_with_context
 from flask_cors import CORS
+from threading import Thread
 import logging
 from .embedding_processing import embedding_processing
 
@@ -18,11 +17,8 @@ import g4f
 from g4f import ChatCompletion, Provider, BaseProvider, models
 from g4f.models import ModelUtils
 
-nest_asyncio.apply()
-
 app = Flask(__name__)
 CORS(app)
-
 LOG = logging.getLogger(__name__)
 embedding_proc = embedding_processing()
     
@@ -71,48 +67,35 @@ def chat_completions():
             },
         }
 
-    def streaming():
-        for chunk in response:
+    def stream():
+        nonlocal response
+        for token in response:
+            completion_timestamp = int(time.time())
+            completion_id = ''.join(random.choices(
+                'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
+
             completion_data = {
                 'id': f'chatcmpl-{completion_id}',
                 'object': 'chat.completion.chunk',
                 'created': completion_timestamp,
-                'model': model,
                 'choices': [
                     {
-                        'index': 0,
                         'delta': {
-                            'content': chunk,
+                            'content': token
                         },
-                        'finish_reason': None,
+                        'index': 0,
+                        'finish_reason': None
                     }
-                ],
+                ]
             }
+            #print(token)
+            #print(completion_data)
+            #print('data: %s\n\n' % json.dumps(completion_data, separators=(',' ':')))
+            yield 'data: %s\n\n' % json.dumps(completion_data, separators=(',' ':'))
+            time.sleep(0.02)
+    print('===Start Streaming===')
+    return app.response_class(stream(), mimetype='text/event-stream')
 
-            content = json.dumps(completion_data, separators=(',', ':'))
-            yield f'data: {content}\n\n'
-            time.sleep(0.05)
-
-        end_completion_data: dict[str, Any] = {
-            'id': f'chatcmpl-{completion_id}',
-            'object': 'chat.completion.chunk',
-            'created': completion_timestamp,
-            'model': model,
-            'choices': [
-                {
-                    'index': 0,
-                    'delta': {},
-                    'finish_reason': 'stop',
-                }
-            ],
-        }
-        content = json.dumps(end_completion_data, separators=(',', ':'))
-        yield f'data: {content}\n\n'
-
-    return app.response_class(streaming(), mimetype='text/event-stream')
-
-@app.route("/engines/text-embedding-ada-002/embeddings", methods=["POST"])
-@app.route("/engines/text-similarity-davinci-001/embeddings", methods=["POST"])
 @app.route('/v1/embeddings', methods=['POST'])
 @app.route('/embeddings', methods=['POST'])
 def create_embedding():

backend/embedding_processing.py

@@ -49,7 +49,7 @@ class embedding_processing:
         response_embedding = self.transform_embedding_to_dict(embeddings_list,text_list)
         return response_embedding
 
-    def transform_embedding_to_dict(self, embedding_list, text_list, model_name="text-embedding-ada-002"):
+    def transform_embedding_to_dict(self, embedding_list, text_list, model_name="text-embedding-elmo-002"):
         prompt_tokens = sum(len(text) for text in text_list)
         total_tokens = sum(len(embedding) for embedding in embedding_list)
 

docker-compose/docker-compose.traefik.yml

@@ -39,8 +39,6 @@ services:
       dockerfile: Dockerfile
     container_name: neurogengpt
     hostname: neurogengpt
-    environment:
-      - SUBF=/sub
     env_file:
       - .env
     networks:

docker-compose/docker-compose.yml

@@ -6,11 +6,9 @@ services:
       context: ../
       dockerfile: Dockerfile
     ports:
-      - "7860:7860"
-      - "1337:1337"
+      - "7861:7860"
+      - "1338:1337"
     volumes:
       - ../config.json:/app/config.json
-    environment:
-      - SUBF=/sub
     env_file:
       - .env

endpoint.py

@@ -1,21 +1,22 @@
+import fastwsgi
 import socket
-import nest_asyncio
 from backend.backend import app
-from waitress import serve
+from multiprocessing import Process
 
-nest_asyncio.apply()
+def run_api_server():
+    fastwsgi.run(wsgi_app=app, host='0.0.0.0', port=1337)
 
-site_config = {
-        'host': '0.0.0.0',
-        'port': 1337,
-        'debug': False
-         }
 
 if __name__ == "__main__":
     hostname = socket.gethostname()
     ip_address = socket.gethostbyname(hostname)
-
+    site_config = {
+        'host': '0.0.0.0',
+        'port': 1337,
+        'debug': False
+         }
     print(f"Running on http://127.0.0.1:{site_config['port']}")
     print(f"Running on http://{ip_address}:{site_config['port']}")
 
-    serve(app, host='0.0.0.0', port=site_config['port'],threads=4)
+    api_process = Process(target=run_api_server) 
+    api_process.start()

g4f/Provider/AItianhu.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import json
+from aiohttp import ClientSession, http
 
-from ..typing import AsyncResult, Messages
-from ..requests import StreamSession
-from .base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
+from ..typing import AsyncGenerator
+from .base_provider import AsyncGeneratorProvider, format_prompt
 
 
 class AItianhu(AsyncGeneratorProvider):
@@ -16,50 +16,46 @@ class AItianhu(AsyncGeneratorProvider):
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
-        cookies: dict = None,
-        timeout: int = 120,
         **kwargs
-    ) -> AsyncResult:
-        if not cookies:
-            cookies = get_cookies("www.aitianhu.com")
-        data = {
-            "prompt": format_prompt(messages),
-            "options": {},
-            "systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully.",
-            "temperature": 0.8,
-            "top_p": 1,
-            **kwargs
-        }
+    ) -> AsyncGenerator:
         headers = {
-            "Authority": cls.url,
+            "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/116.0",
             "Accept": "application/json, text/plain, */*",
+            "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
+            "Content-Type": "application/json",
             "Origin": cls.url,
-            "Referer": f"{cls.url}/"
+            "Connection": "keep-alive",
+            "Referer": cls.url + "/",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
         }
-        async with StreamSession(
+        async with ClientSession(
             headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            proxies={"https": proxy},
-            impersonate="chrome107",
-            verify=False
+            version=http.HttpVersion10
         ) as session:
-            async with session.post(f"{cls.url}/api/chat-process", json=data) as response:
+            data = {
+                "prompt": format_prompt(messages),
+                "options": {},
+                "systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully.",
+                "temperature": 0.8,
+                "top_p": 1,
+                **kwargs
+            }
+            async with session.post(
+                cls.url + "/api/chat-process",
+                proxy=proxy,
+                json=data,
+                ssl=False,
+            ) as response:
                 response.raise_for_status()
-                async for line in response.iter_lines():
-                    if line == b"<script>":
-                        raise RuntimeError("Solve challenge and pass cookies")
-                    if b"platform's risk control" in line:
-                        raise RuntimeError("Platform's Risk Control")
-                    line = json.loads(line)
-                    if "detail" in line:
-                        content = line["detail"]["choices"][0]["delta"].get("content")
-                        if content:
-                            yield content
-                    else:
-                        raise RuntimeError(f"Response: {line}")
+                async for line in response.content:
+                    line = json.loads(line.decode('utf-8'))
+                    token = line["detail"]["choices"][0]["delta"].get("content")
+                    if token:
+                        yield token
 
 
     @classmethod

g4f/Provider/AItianhu2.py

@@ -0,0 +1,54 @@
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class AItianhu2(BaseProvider):
+    url = "https://0vbix.aitianhu.site/api/chat-proces"
+    working = True
+    supports_gpt_4 = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = ""
+        for message in messages:
+            base += "%s: %s\n" % (message["role"], message["content"])
+        base += "assistant:"
+
+        headers = {
+            "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: dict[str, Any] = {
+            "prompt": base,
+            "options": {},
+            "systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
+            "temperature": kwargs.get("temperature", 0.8),
+            "top_p": kwargs.get("top_p", 1),
+        }
+        url = "https://0vbix.aitianhu.site/api/chat-proces"
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        lines = response.text.strip().split("\n")
+        res = json.loads(lines[-1])
+        yield res["text"]
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Acytoo.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from aiohttp import ClientSession
 
-from ..typing import AsyncResult, Messages
+from ..typing import AsyncGenerator
 from .base_provider import AsyncGeneratorProvider
 
 
@@ -15,15 +15,16 @@ class Acytoo(AsyncGeneratorProvider):
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
+
         async with ClientSession(
             headers=_create_header()
         ) as session:
             async with session.post(
-                f'{cls.url}/api/completions',
+                cls.url + '/api/completions',
                 proxy=proxy,
                 json=_create_payload(messages, **kwargs)
             ) as response:
@@ -40,7 +41,7 @@ def _create_header():
     }
 
 
-def _create_payload(messages: Messages, temperature: float = 0.5, **kwargs):
+def _create_payload(messages: list[dict[str, str]], temperature: float = 0.5, **kwargs):
     return {
         'key'         : '',
         'model'       : 'gpt-3.5-turbo',

g4f/Provider/AiService.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class AiService(BaseProvider):
+    url = "https://aiservice.vercel.app/"
+    working = False
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
+        base += "\nassistant: "
+
+        headers = {
+            "accept": "*/*",
+            "content-type": "text/plain;charset=UTF-8",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "Referer": "https://aiservice.vercel.app/chat",
+        }
+        data = {"input": base}
+        url = "https://aiservice.vercel.app/api/chat/answer"
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        yield response.json()["data"]

g4f/Provider/Aichat.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from aiohttp import ClientSession
 
-from ..typing import Messages
 from .base_provider import AsyncProvider, format_prompt
 
 
@@ -14,7 +13,7 @@ class Aichat(AsyncProvider):
     @staticmethod
     async def create_async(
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs
     ) -> str:

g4f/Provider/Ails.py

@@ -7,7 +7,7 @@ import json
 from datetime import datetime
 from aiohttp import ClientSession
 
-from ..typing import SHA256, AsyncResult, Messages
+from ..typing import SHA256, AsyncGenerator
 from .base_provider import AsyncGeneratorProvider
 
 
@@ -19,11 +19,11 @@ class Ails(AsyncGeneratorProvider):
     @staticmethod
     async def create_async_generator(
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         stream: bool,
         proxy: str = None,
         **kwargs
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
         headers = {
             "authority": "api.caipacity.com",
             "accept": "*/*",

g4f/Provider/Aivvm.py

@@ -1,84 +1,78 @@
 from __future__ import annotations
-import requests
 
-from .base_provider import BaseProvider
-from ..typing import CreateResult
-from json import dumps
+from aiohttp import ClientSession
+
+from .base_provider import AsyncGeneratorProvider
+from ..typing import AsyncGenerator
 
-# 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'},
+    "gpt-4": {
+        "id": "gpt-4",
+        "name": "GPT-4",
+    },
+    "gpt-3.5-turbo": {
+        "id": "gpt-3.5-turbo",
+        "name": "GPT-3.5",
+    },
+    "gpt-3.5-turbo-16k": {
+        "id": "gpt-3.5-turbo-16k",
+        "name": "GPT-3.5-16k",
+    },
 }
 
-class Aivvm(BaseProvider):
-    url                   = 'https://chat.aivvm.com'
-    supports_stream       = True
-    working               = False
+class Aivvm(AsyncGeneratorProvider):
+    url                   = "https://chat.aivvm.com"
+    working               = True
     supports_gpt_35_turbo = True
     supports_gpt_4        = True
 
+
     @classmethod
-    def create_completion(cls,
+    async def create_async_generator(
+        cls,
         model: str,
         messages: list[dict[str, str]],
-        stream: bool,
+        proxy: str = None,
         **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 = dumps(json_data)
-
+    ) -> AsyncGenerator:
+        model = model if model else "gpt-3.5-turbo"
+        if model not in models:
+            raise ValueError(f"Model are not supported: {model}")
         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"
+            "User-Agent"         : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
+            "Accept"             : "*/*",
+            "Accept-language"    : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "Origin"             : cls.url,
+            "Referer"            : cls.url + "/",
+            "Sec-Fetch-Dest"     : "empty",
+            "Sec-Fetch-Mode"     : "cors",
+            "Sec-Fetch-Site"     : "same-origin",
         }
+        async with ClientSession(
+            headers=headers
+        ) as session:
+            data = {
+                "temperature": 1,
+                "key": "",
+                "messages": messages,
+                "model": models[model],
+                "prompt": "",
+                **kwargs
+            }
+            async with session.post(cls.url + "/api/chat", json=data, proxy=proxy) as response:
+                response.raise_for_status()
+                async for stream in response.content.iter_any():
+                    yield stream.decode()
 
-        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")
 
     @classmethod
     @property
     def params(cls):
         params = [
-            ('model', 'str'),
-            ('messages', 'list[dict[str, str]]'),
-            ('stream', 'bool'),
-            ('temperature', 'float'),
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
         ]
-        param = ', '.join([': '.join(p) for p in params])
-        return f'g4f.provider.{cls.__name__} supports: ({param})'
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Aiwang.py

@@ -0,0 +1,105 @@
+import random, requests, json
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Aiwang(BaseProvider):
+    url = "https://ai-wang.vercel.app"
+    supports_stream = True
+    supports_gpt_35_turbo = True
+    supports_gpt_35_turbo_16k = True
+    supports_gpt_35_turbo_16k_0613 = True
+    supports_gpt_4 = True
+    supports_gpt_4_0613 = True
+    supports_gpt_4_32k = True
+    supports_gpt_4_32k_0613 = True
+
+    working = False
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = ''
+        for message in messages:
+            base += '%s: %s\n' % (message['role'], message['content'])
+        base += 'assistant:'
+        
+        headers = {
+            "authority": "ai-wang.vercel.app",
+            "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,fa=0.2",
+            "content-type": "application/json",
+            "path":  "v1/chat/completions",
+            "origin": f"{server}",
+            "referer": f"{server}/",
+            "x-requested-with": "XMLHttpRequest",
+            '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',
+        }
+
+        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),
+            "max_tokens": kwargs.get("max_tokens", 4096),
+        }
+
+        session = requests.Session()
+        # init cookies from server
+        session.get(f"{server}/")
+
+        response = session.post(
+            f"{server}/api/chat-stream",
+            headers=headers,
+            json=json_data,
+            stream=stream,
+        )
+        response.encoding = "utf-8"
+    
+        try:
+            # Find the first opening brace and the last closing brace
+            start = response.text.find('{')
+            end = response.text.rfind('}') + 1  # +1 to include the brace itself
+    
+            # Extract the JSON text
+            json_text = response.text[start:end]
+    
+            # Convert the cleaned text to a Python dictionary
+            response_dict = json.loads(json_text)
+        except json.JSONDecodeError:
+            print(f"Failed to decode JSON. Response text was: {response.text}")
+            raise
+    
+        # Extract the desired message
+        yield response_dict['choices'][0]['message']['content']
+   
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+            ("max_tokens", "int"),
+            ("active_server", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Bard.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import random
+import re
+
+from aiohttp import ClientSession
+
+from .base_provider import AsyncProvider, format_prompt, get_cookies
+
+
+class Bard(AsyncProvider):
+    url = "https://bard.google.com"
+    needs_auth = True
+    working = True
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        cookies: dict = None,
+        **kwargs
+    ) -> str:
+        prompt = format_prompt(messages)
+        if proxy and "://" not in proxy:
+            proxy = f"http://{proxy}"
+        if not cookies:
+            cookies = get_cookies(".google.com")
+
+        headers = {
+            'authority': 'bard.google.com',
+            'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            'origin': 'https://bard.google.com',
+            'referer': 'https://bard.google.com/',
+            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
+            'x-same-domain': '1',
+        }
+
+        async with ClientSession(
+            cookies=cookies,
+            headers=headers
+        ) as session:
+            async with session.get(cls.url, proxy=proxy) as response:
+                text = await response.text()
+
+            match = re.search(r'SNlM0e\":\"(.*?)\"', text)
+            if not match:
+                raise RuntimeError("No snlm0e value.")
+            snlm0e = match.group(1)
+            
+            params = {
+                'bl': 'boq_assistant-bard-web-server_20230326.21_p0',
+                '_reqid': random.randint(1111, 9999),
+                'rt': 'c'
+            }
+
+            data = {
+                'at': snlm0e,
+                'f.req': json.dumps([None, json.dumps([[prompt]])])
+            }
+
+            intents = '.'.join([
+                'assistant',
+                'lamda',
+                'BardFrontendService'
+            ])
+
+            async with session.post(
+                f'{cls.url}/_/BardChatUi/data/{intents}/StreamGenerate',
+                data=data,
+                params=params,
+                proxy=proxy
+            ) as response:
+                response = await response.text()
+                response = json.loads(response.splitlines()[3])[0][2]
+                response = json.loads(response)[4][0][1][0]
+                return response
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Bing.py

@@ -3,25 +3,10 @@ from __future__ import annotations
 import random
 import json
 import os
-import uuid
-import urllib.parse
 from aiohttp        import ClientSession, ClientTimeout
-from ..typing       import AsyncResult, Messages
-from .base_provider import AsyncGeneratorProvider
+from ..typing       import AsyncGenerator
+from .base_provider import AsyncGeneratorProvider, get_cookies
 
-class Tones():
-    creative = "Creative"
-    balanced = "Balanced"
-    precise = "Precise"
-
-default_cookies = {
-    'SRCHD'         : 'AF=NOFORM',
-    'PPLState'      : '1',
-    'KievRPSSecAuth': '',
-    'SUID'          : '',
-    'SRCHUSR'       : '',
-    'SRCHHPGUSR'    : '',
-}
 
 class Bing(AsyncGeneratorProvider):
     url             = "https://bing.com/chat"
@@ -30,13 +15,12 @@ class Bing(AsyncGeneratorProvider):
         
     @staticmethod
     def create_async_generator(
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        cookies: dict = None,
-        tone: str = Tones.creative,
-        **kwargs
-    ) -> AsyncResult:
+            model: str,
+            messages: list[dict[str, str]],
+            cookies: dict = None, **kwargs) -> AsyncGenerator:
+        
+        if not cookies:
+            cookies = get_cookies(".bing.com")
         if len(messages) < 2:
             prompt = messages[0]["content"]
             context = None
@@ -45,10 +29,17 @@ class Bing(AsyncGeneratorProvider):
             context = create_context(messages[:-1])
         
         if not cookies or "SRCHD" not in cookies:
-            cookies = default_cookies
-        return stream_generate(prompt, tone, context, proxy, cookies)
+            cookies = {
+                'SRCHD'         : 'AF=NOFORM',
+                'PPLState'      : '1',
+                'KievRPSSecAuth': '',
+                'SUID'          : '',
+                'SRCHUSR'       : '',
+                'SRCHHPGUSR'    : '',
+            }
+        return stream_generate(prompt, context, cookies)
 
-def create_context(messages: Messages):
+def create_context(messages: list[dict[str, str]]):
     context = "".join(f"[{message['role']}](#message)\n{message['content']}\n\n" for message in messages)
 
     return context
@@ -59,15 +50,13 @@ class Conversation():
         self.clientId = clientId
         self.conversationSignature = conversationSignature
 
-async def create_conversation(session: ClientSession, proxy: str = None) -> Conversation:
-    url = 'https://www.bing.com/turing/conversation/create?bundleVersion=1.1150.3'
-    
-    async with await session.get(url, proxy=proxy) as response:
-        data = await response.json()
-        
-        conversationId = data.get('conversationId')
-        clientId = data.get('clientId')
-        conversationSignature = response.headers.get('X-Sydney-Encryptedconversationsignature')
+async def create_conversation(session: ClientSession) -> Conversation:
+    url = 'https://www.bing.com/turing/conversation/create'
+    async with await session.get(url) as response:
+        response = await response.json()
+        conversationId = response.get('conversationId')
+        clientId = response.get('clientId')
+        conversationSignature = response.get('conversationSignature')
 
         if not conversationId or not clientId or not conversationSignature:
             raise Exception('Failed to create conversation.')
@@ -80,7 +69,7 @@ async def list_conversations(session: ClientSession) -> list:
         response = await response.json()
         return response["chats"]
         
-async def delete_conversation(session: ClientSession, conversation: Conversation, proxy: str = None) -> list:
+async def delete_conversation(session: ClientSession, conversation: Conversation) -> list:
     url = "https://sydney.bing.com/sydney/DeleteSingleConversation"
     json = {
         "conversationId": conversation.conversationId,
@@ -89,7 +78,7 @@ async def delete_conversation(session: ClientSession, conversation: Conversation
         "source": "cib",
         "optionsSets": ["autosave"]
     }
-    async with session.post(url, json=json, proxy=proxy) as response:
+    async with session.post(url, json=json) as response:
         response = await response.json()
         return response["result"]["value"] == "Success"
 
@@ -172,56 +161,53 @@ class Defaults:
         'x-forwarded-for': ip_address,
     }
 
-    optionsSets = [
-        'saharasugg',
-        'enablenewsfc',
-        'clgalileo',
-        'gencontentv3',
-        "nlu_direct_response_filter",
-        "deepleo",
-        "disable_emoji_spoken_text",
-        "responsible_ai_policy_235",
-        "enablemm",
-        "h3precise"
-        "dtappid",
-        "cricinfo",
-        "cricinfov2",
-        "dv3sugg",
-        "nojbfedge"
-    ]
+    optionsSets = {
+        "optionsSets": [
+            'saharasugg',
+            'enablenewsfc',
+            'clgalileo',
+            'gencontentv3',
+            "nlu_direct_response_filter",
+            "deepleo",
+            "disable_emoji_spoken_text",
+            "responsible_ai_policy_235",
+            "enablemm",
+            "h3precise"
+            "dtappid",
+            "cricinfo",
+            "cricinfov2",
+            "dv3sugg",
+            "nojbfedge"
+        ]
+    }
 
 def format_message(msg: dict) -> str:
     return json.dumps(msg, ensure_ascii=False) + Defaults.delimiter
 
-def create_message(conversation: Conversation, prompt: str, tone: str, context: str=None) -> str:
-    request_id = str(uuid.uuid4())
+def create_message(conversation: Conversation, prompt: str, context: str=None) -> str:
     struct = {
         'arguments': [
             {
+                **Defaults.optionsSets,
                 'source': 'cib',
-                'optionsSets': Defaults.optionsSets,
                 'allowedMessageTypes': Defaults.allowedMessageTypes,
                 'sliceIds': Defaults.sliceIds,
                 'traceId': os.urandom(16).hex(),
                 'isStartOfSession': True,
-                'requestId': request_id,
                 'message': Defaults.location | {
                     'author': 'user',
                     'inputMethod': 'Keyboard',
                     'text': prompt,
-                    'messageType': 'Chat',
-                    'requestId': request_id,
-                    'messageId': request_id,
+                    'messageType': 'Chat'
                 },
-                'tone': tone,
-                'spokenTextMode': 'None',
-                'conversationId': conversation.conversationId,
+                'conversationSignature': conversation.conversationSignature,
                 'participant': {
                     'id': conversation.clientId
                 },
+                'conversationId': conversation.conversationId
             }
         ],
-        'invocationId': '1',
+        'invocationId': '0',
         'target': 'chat',
         'type': 4
     }
@@ -238,30 +224,28 @@ def create_message(conversation: Conversation, prompt: str, tone: str, context:
 
 async def stream_generate(
         prompt: str,
-        tone: str,
-        context: str = None,
-        proxy: str = None,
-        cookies: dict = None
+        context: str=None,
+        cookies: dict=None
     ):
     async with ClientSession(
         timeout=ClientTimeout(total=900),
         cookies=cookies,
         headers=Defaults.headers,
     ) as session:
-        conversation = await create_conversation(session, proxy)
+        conversation = await create_conversation(session)
         try:
             async with session.ws_connect(
-                f'wss://sydney.bing.com/sydney/ChatHub',
+                'wss://sydney.bing.com/sydney/ChatHub',
                 autoping=False,
-                params={'sec_access_token': conversation.conversationSignature},
-                proxy=proxy
             ) as wss:
                 
                 await wss.send_str(format_message({'protocol': 'json', 'version': 1}))
-                await wss.receive(timeout=900)
-                await wss.send_str(create_message(conversation, prompt, tone, context))
+                msg = await wss.receive(timeout=900)
+
+                await wss.send_str(create_message(conversation, prompt, context))
 
                 response_txt = ''
+                result_text = ''
                 returned_text = ''
                 final = False
 
@@ -271,23 +255,19 @@ async def stream_generate(
                     for obj in objects:
                         if obj is None or not obj:
                             continue
-                        
+
                         response = json.loads(obj)
                         if response.get('type') == 1 and response['arguments'][0].get('messages'):
                             message = response['arguments'][0]['messages'][0]
                             if (message['contentOrigin'] != 'Apology'):
-                                if 'adaptiveCards' in message:
-                                    card = message['adaptiveCards'][0]['body'][0]
-                                    if "text" in card:
-                                        response_txt = card.get('text')
-                                    if message.get('messageType'):
-                                        inline_txt = card['inlines'][0].get('text')
-                                        response_txt += inline_txt + '\n'
-                                elif message.get('contentType') == "IMAGE":
-                                    query = urllib.parse.quote(message.get('text'))
-                                    url = f"\nhttps://www.bing.com/images/create?q={query}"
-                                    response_txt += url
-                                    final = True
+                                response_txt = result_text + \
+                                    message['adaptiveCards'][0]['body'][0].get('text', '')
+                                
+                                if message.get('messageType'):
+                                    inline_txt = message['adaptiveCards'][0]['body'][0]['inlines'][0].get('text')
+                                    response_txt += inline_txt + '\n'
+                                    result_text += inline_txt + '\n'
+
                             if response_txt.startswith(returned_text):
                                 new = response_txt[len(returned_text):]
                                 if new != "\n":
@@ -297,6 +277,7 @@ async def stream_generate(
                             result = response['item']['result']
                             if result.get('error'):
                                 raise Exception(f"{result['value']}: {result['message']}")
-                            return
+                            final = True
+                            break
         finally:
-            await delete_conversation(session, conversation, proxy)
+            await delete_conversation(session, conversation)

g4f/Provider/CaffCat.py

@@ -0,0 +1,101 @@
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class CaffCat(BaseProvider):
+    url = "https://caffcat.com"
+    supports_stream = True
+    supports_gpt_35_turbo = True
+    supports_gpt_35_turbo_16k = True
+    working = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        active_servers = [
+            "https://coffeecat.ai",
+            "https://caffcat.com",
+            "https://www.jinwangyile.xyz",
+        ]
+        server = active_servers[kwargs.get("active_server", 2)]
+        headers = {
+            "authority": f"{server}".replace("https://", ""),
+            "accept": "text/event-stream",
+            "accept-language": "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3,fa=0.2",
+            "content-type": "application/json",
+            "origin": f"{server}",
+            "referer": f"{server}/",
+            "x-requested-with": "XMLHttpRequest",
+            'plugins': '0',
+            'sec-ch-ua': '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-origin',
+            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
+            'usesearch': 'false',
+            'x-requested-with': 'XMLHttpRequest'
+        }
+
+        json_data = {
+            "messages": messages,
+            "stream": stream,
+            "model": model,
+            "temperature": kwargs.get("temperature", 0.5),
+            "presence_penalty": kwargs.get("presence_penalty", 0),
+            "frequency_penalty": kwargs.get("frequency_penalty", 0),
+            "top_p": kwargs.get("top_p", 1),
+        }
+
+        session = requests.Session()
+        # init cookies from server
+        session.get(f"{server}/")
+
+        response = session.post(
+            f"{server}/api/openai/v1/chat/completions",
+            headers=headers,
+            json=json_data,
+            stream=stream,
+        )
+        if response.status_code == 200:
+            if stream == False:
+                json_data = response.json()
+                if "choices" in json_data:
+                    yield json_data["choices"][0]["message"]["content"]
+                else:
+                    yield Exception("No response from server")
+            else:
+                
+                for chunk in response.iter_lines():
+                    if b"content" in chunk:
+                        splitData = chunk.decode().split("data: ")
+                        if len(splitData) > 1:
+                            yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
+        else:
+            yield Exception(f"Error {response.status_code} from server")
+      
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+            ("active_server", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/ChatBase.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from aiohttp import ClientSession
 
-from ..typing       import AsyncResult, Messages
+from ..typing       import AsyncGenerator
 from .base_provider import AsyncGeneratorProvider
 
 
@@ -16,10 +16,9 @@ class ChatBase(AsyncGeneratorProvider):
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
-        proxy: str = None,
+        messages: list[dict[str, str]],
         **kwargs
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
         if model == "gpt-4":
             chat_id = "quran---tafseer-saadi-pdf-wbgknt7zn"
         elif model == "gpt-3.5-turbo" or not model:
@@ -45,7 +44,7 @@ class ChatBase(AsyncGeneratorProvider):
                 "chatId": chat_id,
                 "conversationId": f"kcXpqEnqUie3dnJlsRi_O-{chat_id}"
             }
-            async with session.post("https://www.chatbase.co/api/fe/chat", json=data, proxy=proxy) as response:
+            async with session.post("https://www.chatbase.co/api/fe/chat", json=data) as response:
                 response.raise_for_status()
                 async for stream in response.content.iter_any():
                     yield stream.decode()

g4f/Provider/ChatgptAi.py

@@ -1,28 +1,28 @@
 from __future__ import annotations
 
 import re
+import html
+import json
 from aiohttp import ClientSession
 
-from ..typing import Messages
-from .base_provider import AsyncProvider, format_prompt
+from ..typing       import AsyncGenerator
+from .base_provider import AsyncGeneratorProvider
 
 
-class ChatgptAi(AsyncProvider):
+class ChatgptAi(AsyncGeneratorProvider):
     url: str = "https://chatgpt.ai/"
     working = True
     supports_gpt_35_turbo  = True
-    _nonce = None
-    _post_id = None
-    _bot_id = None
+    _system_data = None
 
     @classmethod
-    async def create_async(
+    async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs
-    ) -> str:
+    ) -> AsyncGenerator:
         headers = {
             "authority"          : "chatgpt.ai",
             "accept"             : "*/*",
@@ -42,34 +42,34 @@ class ChatgptAi(AsyncProvider):
         async with ClientSession(
             headers=headers
         ) as session:
-            if not cls._nonce:
+            if not cls._system_data:
                 async with session.get(cls.url, proxy=proxy) as response:
                     response.raise_for_status()
-                    text = await response.text()
-                result = re.search(r'data-nonce="(.*?)"', text)
-                if result:
-                    cls._nonce = result.group(1)
-                result = re.search(r'data-post-id="(.*?)"', text)
-                if result:
-                    cls._post_id = result.group(1)
-                result = re.search(r'data-bot-id="(.*?)"', text)
-                if result:
-                    cls._bot_id = result.group(1)
-                if not cls._nonce or not cls._post_id or not cls._bot_id:
-                    raise RuntimeError("Nonce, post-id or bot-id not found")
+                    match = re.findall(r"data-system='([^']+)'", await response.text())
+                    if not match:
+                        raise RuntimeError("No system data")
+                    cls._system_data = json.loads(html.unescape(match[0]))
 
             data = {
-                "_wpnonce": cls._nonce,
-                "post_id": cls._post_id,
-                "url": "https://chatgpt.ai",
-                "action": "wpaicg_chat_shortcode_message",
-                "message": format_prompt(messages),
-                "bot_id": cls._bot_id
+                "botId":      cls._system_data["botId"],
+                "clientId":   "",
+                "contextId":  cls._system_data["contextId"],
+                "id":         cls._system_data["id"],
+                "messages":   messages[:-1],
+                "newMessage": messages[-1]["content"],
+                "session":    cls._system_data["sessionId"],
+                "stream":     True
             }
             async with session.post(
-                "https://chatgpt.ai/wp-admin/admin-ajax.php",
+                "https://chatgpt.ai/wp-json/mwai-ui/v1/chats/submit",
                 proxy=proxy,
-                data=data
+                json=data
             ) as response:
                 response.raise_for_status()
-                return (await response.json())["data"]
+                start = "data: "
+                async for line in response.content:
+                    line = line.decode('utf-8')
+                    if line.startswith(start):
+                        line = json.loads(line[len(start):-1])
+                        if line["type"] == "live":
+                            yield line["data"]

g4f/Provider/ChatgptLogin.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import os, re
+from aiohttp import ClientSession
+
+from .base_provider import AsyncProvider, format_prompt
+
+
+class ChatgptLogin(AsyncProvider):
+    url                   = "https://opchatgpts.net"
+    supports_gpt_35_turbo = True
+    working               = True
+    _nonce                = None
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ) -> str:
+        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"             : "https://opchatgpts.net",
+            "Alt-Used"           : "opchatgpts.net",
+            "Referer"            : "https://opchatgpts.net/chatgpt-free-use/",
+            "Sec-Fetch-Dest"     : "empty",
+            "Sec-Fetch-Mode"     : "cors",
+            "Sec-Fetch-Site"     : "same-origin",
+        }
+        async with ClientSession(
+            headers=headers
+        ) as session:
+            if not cls._nonce:
+                async with session.get(
+                    "https://opchatgpts.net/chatgpt-free-use/",
+                    params={"id": os.urandom(6).hex()},
+                ) as response:
+                    result = re.search(r'data-nonce="(.*?)"', await response.text())
+                if not result:
+                    raise RuntimeError("No nonce value")
+                cls._nonce = result.group(1)
+            data = {
+                "_wpnonce": cls._nonce,
+                "post_id": 28,
+                "url": "https://opchatgpts.net/chatgpt-free-use",
+                "action": "wpaicg_chat_shortcode_message",
+                "message": format_prompt(messages),
+                "bot_id": 0
+            }
+            async with session.post("https://opchatgpts.net/wp-admin/admin-ajax.php", data=data) as response:
+                response.raise_for_status()
+                return (await response.json())["data"]
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/CodeLinkAva.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from aiohttp import ClientSession
+import json
+
+from ..typing       import AsyncGenerator
+from .base_provider import AsyncGeneratorProvider
+
+
+class CodeLinkAva(AsyncGeneratorProvider):
+    url                   = "https://ava-ai-ef611.web.app"
+    supports_gpt_35_turbo = True
+    working               = True
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ) -> AsyncGenerator:
+        headers = {
+            "User-Agent"         : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
+            "Accept"             : "*/*",
+            "Accept-language"    : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "Origin"             : cls.url,
+            "Referer"            : cls.url + "/",
+            "Sec-Fetch-Dest"     : "empty",
+            "Sec-Fetch-Mode"     : "cors",
+            "Sec-Fetch-Site"     : "same-origin",
+        }
+        async with ClientSession(
+            headers=headers
+        ) as session:
+            data = {
+                "messages": messages,
+                "temperature": 0.6,
+                "stream": True,
+                **kwargs
+            }
+            async with session.post("https://ava-alpha-api.codelink.io/api/chat", json=data) as response:
+                response.raise_for_status()
+                start = "data: "
+                async for line in response.content:
+                    line = line.decode()
+                    if line.startswith("data: ") and not line.startswith("data: [DONE]"):
+                        line = json.loads(line[len(start):-1])
+                        content = line["choices"][0]["delta"].get("content")
+                        if content:
+                            yield content
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/DeepAi.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+import js2py
+from aiohttp import ClientSession
+
+from ..typing       import AsyncGenerator
+from .base_provider import AsyncGeneratorProvider
+
+
+class DeepAi(AsyncGeneratorProvider):
+    url: str              = "https://deepai.org"
+    working               = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    async def create_async_generator(
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        **kwargs
+    ) -> AsyncGenerator:
+        
+        token_js = """
+var 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'
+var a, b, c, d, e, h, f, l, g, k, m, n, r, x, C, E, N, F, T, O, P, w, D, G, Q, R, W, I, aa, fa, na, oa, ha, ba, X, ia, ja, ka, J, la, K, L, ca, S, U, M, ma, B, da, V, Y;
+h = Math.round(1E11 * Math.random()) + "";
+f = function () {
+    for (var p = [], q = 0; 64 > q;) p[q] = 0 | 4294967296 * Math.sin(++q % Math.PI);
+    
+    return function (t) {
+        var v, y, H, ea = [v = 1732584193, y = 4023233417, ~v, ~y],
+            Z = [],
+            A = unescape(encodeURI(t)) + "\u0080",
+            z = A.length;
+        t = --z / 4 + 2 | 15;
+        for (Z[--t] = 8 * z; ~z;) Z[z >> 2] |= A.charCodeAt(z) << 8 * z--;
+        for (q = A = 0; q < t; q += 16) {
+            for (z = ea; 64 > A; z = [H = z[3], v + ((H = z[0] + [v & y | ~v & H, H & v | ~H & y, v ^ y ^ H, y ^ (v | ~H)][z = A >> 4] + p[A] + ~~Z[q | [A, 5 * A + 1, 3 * A + 5, 7 * A][z] & 15]) << (z = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21][4 * z + A++ % 4]) | H >>> -z), v, y]) v = z[1] | 0, y = z[2];
+            for (A = 4; A;) ea[--A] += z[A]
+        }
+        for (t = ""; 32 > A;) t += (ea[A >> 3] >> 4 * (1 ^ A++) & 15).toString(16);
+        return t.split("").reverse().join("")
+    }
+}();
+
+"tryit-" + h + "-" + f(agent + f(agent + f(agent + h + "x")));
+"""
+
+        payload = {"chas_style": "chat", "chatHistory": json.dumps(messages)}
+        api_key = js2py.eval_js(token_js)
+        headers = {
+            "api-key": api_key,
+            "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",
+        }
+        async with ClientSession(
+            headers=headers
+        ) as session:
+            async with session.post("https://api.deepai.org/make_me_a_pizza", proxy=proxy, data=payload) as response:
+                response.raise_for_status()
+                async for stream in response.content.iter_any():
+                    if stream:
+                        yield stream.decode()

g4f/Provider/DfeHub.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class DfeHub(BaseProvider):
+    url                   = "https://chat.dfehub.com/"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        headers = {
+            "authority"         : "chat.dfehub.com",
+            "accept"            : "*/*",
+            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "content-type"      : "application/json",
+            "origin"            : "https://chat.dfehub.com",
+            "referer"           : "https://chat.dfehub.com/",
+            "sec-ch-ua"         : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
+            "sec-ch-ua-mobile"  : "?0",
+            "sec-ch-ua-platform": '"macOS"',
+            "sec-fetch-dest"    : "empty",
+            "sec-fetch-mode"    : "cors",
+            "sec-fetch-site"    : "same-origin",
+            "user-agent"        : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
+            "x-requested-with"  : "XMLHttpRequest",
+        }
+
+        json_data = {
+            "messages"          : messages,
+            "model"             : "gpt-3.5-turbo",
+            "temperature"       : kwargs.get("temperature", 0.5),
+            "presence_penalty"  : kwargs.get("presence_penalty", 0),
+            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
+            "top_p"             : kwargs.get("top_p", 1),
+            "stream"            : True
+        }
+        
+        response = requests.post("https://chat.dfehub.com/api/openai/v1/chat/completions",
+            headers=headers, json=json_data, timeout=3)
+
+        for chunk in response.iter_lines():
+            if b"detail" in chunk:
+                delay = re.findall(r"\d+\.\d+", chunk.decode())
+                delay = float(delay[-1])
+                time.sleep(delay)
+                yield from DfeHub.create_completion(model, messages, stream, **kwargs)
+            if b"content" in chunk:
+                data = json.loads(chunk.decode().split("data: ")[1])
+                yield (data["choices"][0]["delta"]["content"])
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/EasyChat.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+import random
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class EasyChat(BaseProvider):
+    url: str              = "https://free.easychat.work"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+    working               = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        active_servers = [
+            "https://chat10.fastgpt.me",
+            "https://chat9.fastgpt.me",
+            "https://chat1.fastgpt.me",
+            "https://chat2.fastgpt.me",
+            "https://chat3.fastgpt.me",
+            "https://chat4.fastgpt.me",
+            "https://gxos1h1ddt.fastgpt.me"
+        ]
+        
+        server  = active_servers[kwargs.get("active_server", random.randint(0, 5))]
+        headers = {
+            "authority"         : f"{server}".replace("https://", ""),
+            "accept"            : "text/event-stream",
+            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3,fa=0.2",
+            "content-type"      : "application/json",
+            "origin"            : f"{server}",
+            "referer"           : f"{server}/",
+            "x-requested-with"  : "XMLHttpRequest",
+            'plugins'           : '0',
+            'sec-ch-ua'         : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
+            'usesearch'         : 'false',
+            'x-requested-with'  : 'XMLHttpRequest'
+        }
+
+        json_data = {
+            "messages"          : messages,
+            "stream"            : stream,
+            "model"             : model,
+            "temperature"       : kwargs.get("temperature", 0.5),
+            "presence_penalty"  : kwargs.get("presence_penalty", 0),
+            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
+            "top_p"             : kwargs.get("top_p", 1)
+        }
+
+        session = requests.Session()
+        # init cookies from server
+        session.get(f"{server}/")
+
+        response = session.post(f"{server}/api/openai/v1/chat/completions",
+            headers=headers, json=json_data, stream=stream)
+        
+        if response.status_code == 200:
+            
+            if stream == False:
+                json_data = response.json()
+                
+                if "choices" in json_data:
+                    yield json_data["choices"][0]["message"]["content"]
+                else:
+                    raise Exception("No response from server")
+            
+            else:
+                
+                for chunk in response.iter_lines():
+                    
+                    if b"content" in chunk:
+                        splitData = chunk.decode().split("data:")
+                        
+                        if len(splitData) > 1:
+                            yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
+                        else:
+                            continue
+        else:
+            raise Exception(f"Error {response.status_code} from server : {response.reason}")
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+            ("active_server", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Equing.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+
+import requests
+
+from ..typing import Any, CreateResult
+
+
+class Equing(ABC):
+    url: str              = 'https://next.eqing.tech/'
+    working               = True
+    needs_auth            = False
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+    supports_gpt_4        = False
+
+    @staticmethod
+    @abstractmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        headers = {
+            'authority'         : 'next.eqing.tech',
+            'accept'            : 'text/event-stream',
+            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'cache-control'     : 'no-cache',
+            'content-type'      : 'application/json',
+            'origin'            : 'https://next.eqing.tech',
+            'plugins'           : '0',
+            'pragma'            : 'no-cache',
+            'referer'           : 'https://next.eqing.tech/',
+            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"macOS"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
+            'usesearch'         : 'false',
+            'x-requested-with'  : 'XMLHttpRequest'
+        }
+
+        json_data = {
+            'messages'          : messages,
+            'stream'            : stream,
+            'model'             : model,
+            'temperature'       : kwargs.get('temperature', 0.5),
+            'presence_penalty'  : kwargs.get('presence_penalty', 0),
+            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+            'top_p'             : kwargs.get('top_p', 1),
+        }
+
+        response = requests.post('https://next.eqing.tech/api/openai/v1/chat/completions',
+            headers=headers, json=json_data, stream=stream)
+        
+        if not stream:
+            yield response.json()["choices"][0]["message"]["content"]
+            return
+        
+        for line in response.iter_content(chunk_size=1024):
+            if line:
+                if b'content' in line:
+                        line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                        token = line_json['choices'][0]['delta'].get('content')
+                        if token:
+                            yield token
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/FastGpt.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+import random
+from abc import ABC, abstractmethod
+
+import requests
+
+from ..typing import Any, CreateResult
+
+
+class FastGpt(ABC):
+    url: str                = 'https://chat9.fastgpt.me/'
+    working                 = False
+    needs_auth              = False
+    supports_stream         = True
+    supports_gpt_35_turbo   = True
+    supports_gpt_4          = False
+
+    @staticmethod
+    @abstractmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        headers = {
+            'authority'         : 'chat9.fastgpt.me',
+            'accept'            : 'text/event-stream',
+            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'cache-control'     : 'no-cache',
+            'content-type'      : 'application/json',
+            'origin'            : 'https://chat9.fastgpt.me',
+            'plugins'           : '0',
+            'pragma'            : 'no-cache',
+            'referer'           : 'https://chat9.fastgpt.me/',
+            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"macOS"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
+            'usesearch'         : 'false',
+            'x-requested-with'  : 'XMLHttpRequest',
+        }
+
+        json_data = {
+            'messages'          : messages,
+            'stream'            : stream,
+            'model'             : model,
+            'temperature'       : kwargs.get('temperature', 0.5),
+            'presence_penalty'  : kwargs.get('presence_penalty', 0),
+            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+            'top_p'             : kwargs.get('top_p', 1),
+        }
+        
+        subdomain = random.choice([
+            'jdaen979ew',
+            'chat9'
+        ])
+
+        response = requests.post(f'https://{subdomain}.fastgpt.me/api/openai/v1/chat/completions',
+                                 headers=headers, json=json_data, stream=stream)
+        
+        for line in response.iter_lines():
+            if line:
+                try:
+                    if b'content' in line:
+                            line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                            token = line_json['choices'][0]['delta'].get('content')
+                            if token:
+                                yield token
+                except:
+                    continue
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Forefront.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Forefront(BaseProvider):
+    url                   = "https://forefront.com"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        json_data = {
+            "text"          : messages[-1]["content"],
+            "action"        : "noauth",
+            "id"            : "",
+            "parentId"      : "",
+            "workspaceId"   : "",
+            "messagePersona": "607e41fe-95be-497e-8e97-010a59b2e2c0",
+            "model"         : "gpt-4",
+            "messages"      : messages[:-1] if len(messages) > 1 else [],
+            "internetMode"  : "auto",
+        }
+
+        response = requests.post("https://streaming.tenant-forefront-default.knative.chi.coreweave.com/free-chat",
+            json=json_data, stream=True)
+        
+        response.raise_for_status()
+        for token in response.iter_lines():
+            if b"delta" in token:
+                yield json.loads(token.decode().split("data: ")[1])["delta"]

g4f/Provider/Freet.py

@@ -0,0 +1,109 @@
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Freet(BaseProvider):
+    url = "https://biwjo6q8.freet.to"
+    supports_stream = True
+
+    supports_gpt_35_turbo = True
+    supports_gpt_35_turbo_16k = True
+    supports_gpt_35_turbo_16k_0613 = True
+    supports_gpt_4 = True
+    supports_gpt_4_0613 = True
+    supports_gpt_4_32k = True
+    supports_gpt_4_32k_0613 = True
+
+    working = True
+
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        active_servers = [
+            "https://biwjo6q8.freet.to",
+        ]
+        server = active_servers[kwargs.get("active_server", 0)]
+        headers = {
+            "authority": f"{server}".replace("https://", ""),
+            "authorization:": "Bearer nk-Tmd-Ni-xiang-Gou=Sb-90807rqHgl8b3jrNkSjEvt90EiMEoCsbKJ2kggV1iHzTKEDWv1tcgazgdsuw0S4pZ1W",
+            "accept": "text/event-stream",
+            "accept-language": "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3,fa=0.2",
+            "content-type": "application/json",
+            "origin": f"{server}",
+            "referer": f"{server}/",
+            "x-requested-with": "XMLHttpRequest",
+            'plugins': '0',
+            'sec-ch-ua': '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-origin',
+            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
+            'usesearch': 'false',
+            'x-requested-with': 'XMLHttpRequest'
+        }
+
+        json_data = {
+            "messages": messages,
+            "stream": stream,
+            "model": model,
+            "temperature": kwargs.get("temperature", 0.5),
+            "presence_penalty": kwargs.get("presence_penalty", 0),
+            "frequency_penalty": kwargs.get("frequency_penalty", 0),
+            "top_p": kwargs.get("top_p", 1),
+        }
+
+        session = requests.Session()
+        # init cookies from server
+        session.get(f"{server}/")
+
+        response = session.post(
+            f"{server}/api/openai/v1/chat/completions",
+            headers=headers,
+            json=json_data,
+            stream=stream,
+        )
+        if response.status_code == 200:
+            if stream == False:
+                json_data = response.json()
+                if "choices" in json_data:
+                    yield json_data["choices"][0]["message"]["content"]
+                else:
+                    raise Exception("No response from server")
+            else:
+                
+                for chunk in response.iter_lines():
+                    if b"content" in chunk:
+                        splitData = chunk.decode().split("data:")
+                        if len(splitData) > 1:
+                            yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
+                        else:
+                            continue
+        else:
+            raise Exception(f"Error {response.status_code} from server : {response.reason}")
+        
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int"),
+            ("active_server", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/GetGpt.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import json
+import os
+import uuid
+
+import requests
+from Crypto.Cipher import AES
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class GetGpt(BaseProvider):
+    url                   = 'https://chat.getgpt.world/'
+    supports_stream       = True
+    working               = True
+    supports_gpt_35_turbo = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        headers = {
+            'Content-Type'  : 'application/json',
+            'Referer'       : 'https://chat.getgpt.world/',
+            'user-agent'    : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
+        }
+        
+        data = json.dumps(
+            {
+                'messages'          : messages,
+                'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+                'max_tokens'        : kwargs.get('max_tokens', 4000),
+                'model'             : 'gpt-3.5-turbo',
+                'presence_penalty'  : kwargs.get('presence_penalty', 0),
+                'temperature'       : kwargs.get('temperature', 1),
+                'top_p'             : kwargs.get('top_p', 1),
+                'stream'            : True,
+                'uuid'              : str(uuid.uuid4())
+            }
+        )
+
+        res = requests.post('https://chat.getgpt.world/api/chat/stream',
+            headers=headers, json={'signature': _encrypt(data)}, stream=True)
+
+        res.raise_for_status()
+        for line in res.iter_lines():
+            if b'content' in line:
+                line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                yield (line_json['choices'][0]['delta']['content'])
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ('model', 'str'),
+            ('messages', 'list[dict[str, str]]'),
+            ('stream', 'bool'),
+            ('temperature', 'float'),
+            ('presence_penalty', 'int'),
+            ('frequency_penalty', 'int'),
+            ('top_p', 'int'),
+            ('max_tokens', 'int'),
+        ]
+        param = ', '.join([': '.join(p) for p in params])
+        return f'g4f.provider.{cls.__name__} supports: ({param})'
+
+
+def _encrypt(e: str):
+    t = os.urandom(8).hex().encode('utf-8')
+    n = os.urandom(8).hex().encode('utf-8')
+    r = e.encode('utf-8')
+    
+    cipher     = AES.new(t, AES.MODE_CBC, n)
+    ciphertext = cipher.encrypt(_pad_data(r))
+    
+    return ciphertext.hex() + t.decode('utf-8') + n.decode('utf-8')
+
+
+def _pad_data(data: bytes) -> bytes:
+    block_size   = AES.block_size
+    padding_size = block_size - len(data) % block_size
+    padding      = bytes([padding_size] * padding_size)
+    
+    return data + padding

g4f/Provider/H2o.py

@@ -5,25 +5,25 @@ import uuid
 
 from aiohttp import ClientSession
 
-from ..typing import AsyncResult, Messages
+from ..typing import AsyncGenerator
 from .base_provider import AsyncGeneratorProvider, format_prompt
 
 
 class H2o(AsyncGeneratorProvider):
     url = "https://gpt-gm.h2o.ai"
-    working = False
+    working = True
     model = "h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1"
 
     @classmethod
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
         model = model if model else cls.model
-        headers = {"Referer": cls.url + "/"}
+        headers = {"Referer": "https://gpt-gm.h2o.ai/"}
 
         async with ClientSession(
             headers=headers
@@ -36,14 +36,14 @@ class H2o(AsyncGeneratorProvider):
                 "searchEnabled": "true",
             }
             async with session.post(
-                f"{cls.url}/settings",
+                "https://gpt-gm.h2o.ai/settings",
                 proxy=proxy,
                 data=data
             ) as response:
                 response.raise_for_status()
 
             async with session.post(
-                f"{cls.url}/conversation",
+                "https://gpt-gm.h2o.ai/conversation",
                 proxy=proxy,
                 json={"model": model},
             ) as response:
@@ -71,7 +71,7 @@ class H2o(AsyncGeneratorProvider):
                 },
             }
             async with session.post(
-                f"{cls.url}/conversation/{conversationId}",
+                f"https://gpt-gm.h2o.ai/conversation/{conversationId}",
                 proxy=proxy,
                 json=data
              ) as response:
@@ -83,14 +83,6 @@ class H2o(AsyncGeneratorProvider):
                         if not line["token"]["special"]:
                             yield line["token"]["text"]
 
-            async with session.delete(
-                f"{cls.url}/conversation/{conversationId}",
-                proxy=proxy,
-                json=data
-            ) as response:
-                response.raise_for_status()
-
-
     @classmethod
     @property
     def params(cls):

g4f/Provider/HuggingChat.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import json
+
+from aiohttp import ClientSession
+
+from ..typing import AsyncGenerator
+from .base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
+
+
+class HuggingChat(AsyncGeneratorProvider):
+    url = "https://huggingface.co/chat/"
+    needs_auth = True
+    working = True
+    model = "OpenAssistant/oasst-sft-6-llama-30b-xor"
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool = True,
+        proxy: str = None,
+        cookies: dict = None,
+        **kwargs
+    ) -> AsyncGenerator:
+        model = model if model else cls.model
+        if not cookies:
+            cookies = get_cookies(".huggingface.co")
+        if proxy and "://" not in proxy:
+            proxy = f"http://{proxy}"
+
+        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://huggingface.co/chat/conversation", proxy=proxy, json={"model": model}) as response:
+                conversation_id = (await response.json())["conversationId"]
+
+            send = {
+                "inputs": format_prompt(messages),
+                "parameters": {
+                    "temperature": 0.2,
+                    "truncate": 1000,
+                    "max_new_tokens": 1024,
+                    "stop": ["</s>"],
+                    "top_p": 0.95,
+                    "repetition_penalty": 1.2,
+                    "top_k": 50,
+                    "return_full_text": False,
+                    **kwargs
+                },
+                "stream": stream,
+                "options": {
+                    "id": "9e9b8bc4-6604-40c6-994e-8eb78fa32e37",
+                    "response_id": "04ce2602-3bea-45e8-8efc-cef00680376a",
+                    "is_retry": False,
+                    "use_cache": False,
+                    "web_search_id": ""
+                }
+            }
+            async with session.post(f"https://huggingface.co/chat/conversation/{conversation_id}", proxy=proxy, json=send) as response:
+                if not stream:
+                    data = await response.json()
+                    if "error" in data:
+                        raise RuntimeError(data["error"])
+                    elif isinstance(data, list):
+                        yield data[0]["generated_text"].strip()
+                    else:
+                        raise RuntimeError(f"Response: {data}")
+                else:
+                    start = "data:"
+                    first = True
+                    async for line in response.content:
+                        line = line.decode("utf-8")
+                        if not line:
+                            continue
+                        if line.startswith(start):
+                            line = json.loads(line[len(start):-1])
+                            if "token" not in line:
+                                raise RuntimeError(f"Response: {line}")
+                            if not line["token"]["special"]:
+                                if first:
+                                    yield line["token"]["text"].lstrip()
+                                    first = False
+                                else:
+                                    yield line["token"]["text"]
+                
+            async with session.delete(f"https://huggingface.co/chat/conversation/{conversation_id}", proxy=proxy) as response:
+                response.raise_for_status()
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/I207m.py

@@ -0,0 +1,73 @@
+import uuid
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class I207m(BaseProvider):
+    url = "https://gpt3.i207m.top"
+    supports_stream = True
+    needs_auth = False
+    supports_gpt_4 = True
+    supports_gpt_4_32k = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        headers = {
+            "authority": "gpt3.i207m.top",
+            "content-type": "application/json",
+            "origin": "https://gpt3.i207m.top",
+            "referer": "https://gpt3.i207m.top/",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36",
+            "x-auth-code": str(kwargs.get("auth")),
+        }
+        models = {
+            "gpt-4": {
+                "id": "gpt-4",
+                "name": "GPT-4",
+                "maxLength": 24000,
+                "tokenLimit": 8000,
+            },
+             "gpt-4-32k": {
+                 "id":"gpt-4-32k",
+                 "name":"GPT-4-32k",
+                 "maxLength":96000,
+                 "tokenLimit":32000
+             },
+        }
+        json_data = {
+            "conversationId": str(uuid.uuid4()),
+            "model": models[model],
+            "messages": messages,
+            "key": "",
+            "prompt": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
+        }
+
+        response = requests.post(
+            "https://gpt3.i207m.top/api/chat",
+            headers=headers,
+            json=json_data,
+            stream=True,
+        )
+        response.raise_for_status()
+        for token in response.iter_content(chunk_size=2046):
+            yield token.decode("utf-8")
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("auth", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Liaobots.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import json
 import uuid
 
 from aiohttp import ClientSession
 
-from ..typing import AsyncResult, Messages
+from ..typing import AsyncGenerator
 from .base_provider import AsyncGeneratorProvider
 
 models = {
@@ -29,7 +30,7 @@ models = {
 }
 
 class Liaobots(AsyncGeneratorProvider):
-    url = "https://liaobots.site"
+    url = "https://liaobots.com"
     working = True
     supports_gpt_35_turbo = True
     supports_gpt_4 = True
@@ -39,12 +40,14 @@ class Liaobots(AsyncGeneratorProvider):
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         auth: str = None,
         proxy: str = None,
         **kwargs
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
         model = model if model in models else "gpt-3.5-turbo"
+        if proxy and "://" not in proxy:
+            proxy = f"http://{proxy}"
         headers = {
             "authority": "liaobots.com",
             "content-type": "application/json",
@@ -55,23 +58,11 @@ class Liaobots(AsyncGeneratorProvider):
         async with ClientSession(
             headers=headers
         ) as session:
-            cls._auth_code = auth if isinstance(auth, str) else cls._auth_code
-            if not cls._auth_code:
-                async with session.post(
-                    "https://liaobots.work/recaptcha/api/login",
-                    proxy=proxy,
-                    data={"token": "abcdefghijklmnopqrst"},
-                    verify_ssl=False
-                ) as response:
+            auth_code = auth if isinstance(auth, str) else cls._auth_code
+            if not auth_code:
+                async with session.post(cls.url + "/api/user", proxy=proxy, json={"authcode": ""}) as response:
                     response.raise_for_status()
-                async with session.post(
-                    "https://liaobots.work/api/user",
-                    proxy=proxy,
-                    json={"authcode": ""},
-                    verify_ssl=False
-                ) as response:
-                    response.raise_for_status()
-                    cls._auth_code = (await response.json(content_type=None))["authCode"]
+                    auth_code = cls._auth_code = json.loads(await response.text())["authCode"]
             data = {
                 "conversationId": str(uuid.uuid4()),
                 "model": models[model],
@@ -79,13 +70,7 @@ class Liaobots(AsyncGeneratorProvider):
                 "key": "",
                 "prompt": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully.",
             }
-            async with session.post(
-                "https://liaobots.work/api/chat",
-                proxy=proxy,
-                json=data,
-                headers={"x-auth-code": cls._auth_code},
-                verify_ssl=False
-            ) as response:
+            async with session.post(cls.url + "/api/chat", proxy=proxy, json=data, headers={"x-auth-code": auth_code}) as response:
                 response.raise_for_status()
                 async for stream in response.content.iter_any():
                     if stream:

g4f/Provider/Lockchat.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Lockchat(BaseProvider):
+    url: str              = "http://supertest.lockchat.app"
+    supports_stream       = True
+    supports_gpt_35_turbo = True
+    supports_gpt_4        = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        temperature = float(kwargs.get("temperature", 0.7))
+        payload = {
+            "temperature": temperature,
+            "messages"   : messages,
+            "model"      : model,
+            "stream"     : True,
+        }
+
+        headers = {
+            "user-agent": "ChatX/39 CFNetwork/1408.0.4 Darwin/22.5.0",
+        }
+        response = requests.post("http://supertest.lockchat.app/v1/chat/completions",
+                                 json=payload, headers=headers, stream=True)
+        
+        response.raise_for_status()
+        for token in response.iter_lines():
+            if b"The model: `gpt-4` does not exist" in token:
+                print("error, retrying...")
+                Lockchat.create_completion(
+                    model       = model,
+                    messages    = messages,
+                    stream      = stream,
+                    temperature = temperature,
+                    **kwargs)
+            
+            if b"content" in token:
+                token = json.loads(token.decode("utf-8").split("data: ")[1])
+                token = token["choices"][0]["delta"].get("content")
+                if token:
+                    yield (token)
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Opchatgpts.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from .ChatgptLogin import ChatgptLogin
+
+
+class Opchatgpts(ChatgptLogin):
+    url     = "https://opchatgpts.net"
+    working = True

g4f/Provider/OpenAssistant.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+
+from aiohttp import ClientSession
+
+from ..typing import Any, AsyncGenerator
+from .base_provider import AsyncGeneratorProvider, format_prompt, get_cookies
+
+
+class OpenAssistant(AsyncGeneratorProvider):
+    url = "https://open-assistant.io/chat"
+    needs_auth = True
+    working = True
+    model = "OA_SFT_Llama_30B_6"
+
+    @classmethod
+    async def create_async_generator(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        cookies: dict = None,
+        **kwargs: Any
+    ) -> AsyncGenerator:
+        if proxy and "://" not in proxy:
+            proxy = f"http://{proxy}"
+        if not cookies:
+            cookies = get_cookies("open-assistant.io")
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
+        }
+        async with ClientSession(
+            cookies=cookies,
+            headers=headers
+        ) as session:
+            async with session.post("https://open-assistant.io/api/chat", proxy=proxy) as response:
+                chat_id = (await response.json())["id"]
+
+            data = {
+                "chat_id": chat_id,
+                "content": f"<s>[INST]\n{format_prompt(messages)}\n[/INST]",
+                "parent_id": None
+            }
+            async with session.post("https://open-assistant.io/api/chat/prompter_message", proxy=proxy, json=data) as response:
+                parent_id = (await response.json())["id"]
+
+            data = {
+                "chat_id": chat_id,
+                "parent_id": parent_id,
+                "model_config_name": model if model else cls.model,
+                "sampling_parameters":{
+                    "top_k": 50,
+                    "top_p": None,
+                    "typical_p": None,
+                    "temperature": 0.35,
+                    "repetition_penalty": 1.1111111111111112,
+                    "max_new_tokens": 1024,
+                    **kwargs
+                },
+                "plugins":[]
+            }
+            async with session.post("https://open-assistant.io/api/chat/assistant_message", proxy=proxy, json=data) as response:
+                data = await response.json()
+                if "id" in  data:
+                    message_id = data["id"]
+                elif "message" in data:
+                    raise RuntimeError(data["message"])
+                else:
+                    response.raise_for_status()
+            
+            params = {
+                'chat_id': chat_id,
+                'message_id': message_id,
+            }
+            async with session.post("https://open-assistant.io/api/chat/events", proxy=proxy, params=params) as response:
+                start = "data: "
+                async for line in response.content:
+                    line = line.decode("utf-8")
+                    if line and line.startswith(start):
+                        line = json.loads(line[len(start):])
+                        if line["event_type"] == "token":
+                            yield line["text"]
+
+            params = {
+                'chat_id': chat_id,
+            }
+            async with session.delete("https://open-assistant.io/api/chat", proxy=proxy, params=params) as response:
+                response.raise_for_status()
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/OpenaiChat.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from curl_cffi.requests import AsyncSession
+import uuid
+import json
+
+from .base_provider import AsyncProvider, get_cookies, format_prompt
+from ..typing import AsyncGenerator
+
+
+class OpenaiChat(AsyncProvider):
+    url                   = "https://chat.openai.com"
+    needs_auth            = True
+    working               = True
+    supports_gpt_35_turbo = True
+    _access_token         = None
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: list[dict[str, str]],
+        proxy: str = None,
+        access_token: str = None,
+        cookies: dict = None,
+        **kwargs: dict
+    ) -> AsyncGenerator:
+        proxies = None
+        if proxy:
+            if "://" not in proxy:
+                proxy = f"http://{proxy}"
+            proxies = {
+                "http": proxy,
+                "https": proxy
+            }
+        if not access_token:
+            access_token = await cls.get_access_token(cookies, proxies)
+        headers = {
+            "Accept": "text/event-stream",
+            "Authorization": f"Bearer {access_token}",
+        }
+        async with AsyncSession(proxies=proxies, headers=headers, impersonate="chrome107") as session:
+            messages = [
+                {
+                    "id": str(uuid.uuid4()),
+                    "author": {"role": "user"},
+                    "content": {"content_type": "text", "parts": [format_prompt(messages)]},
+                },
+            ]
+            data = {
+                "action": "next",
+                "messages": messages,
+                "conversation_id": None,
+                "parent_message_id": str(uuid.uuid4()),
+                "model": "text-davinci-002-render-sha",
+                "history_and_training_disabled": True,
+            }
+            response = await session.post("https://chat.openai.com/backend-api/conversation", json=data)
+            response.raise_for_status()
+            last_message = None
+            for line in response.content.decode().splitlines():
+                if line.startswith("data: "):
+                    line = line[6:]
+                    if line != "[DONE]":
+                        line = json.loads(line)
+                        if "message" in line:
+                            last_message = line["message"]["content"]["parts"][0]
+            return last_message
+
+
+    @classmethod
+    async def get_access_token(cls, cookies: dict = None, proxies: dict = None):
+        if not cls._access_token:
+            cookies = cookies if cookies else get_cookies("chat.openai.com")
+            async with AsyncSession(proxies=proxies, cookies=cookies, impersonate="chrome107") as session:
+                response = await session.get("https://chat.openai.com/api/auth/session")
+                response.raise_for_status()
+                cls._access_token = response.json()["accessToken"]
+        return cls._access_token
+
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("proxy", "str"),
+            ("access_token", "str"),
+            ("cookies", "dict[str, str]")
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Providers/Forefront.py

@@ -0,0 +1,33 @@
+import os
+import json
+import requests
+from ...typing import sha256, Dict, get_type_hints
+
+url = 'https://forefront.com'
+model = ['gpt-3.5-turbo']
+supports_stream = True
+needs_auth = False
+working = False
+
+
+def _create_completion(model: str, messages: list, stream: bool, **kwargs):
+    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)
+    for token in response.iter_lines(): 
+        if b'delta' in token:
+            token = json.loads(token.decode().split('data: ')[1])['delta']
+            yield (token)
+            
+params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
+    '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

g4f/Provider/Qidinam.py

@@ -0,0 +1,57 @@
+import json, random, string, time
+
+from aiohttp import ClientSession
+from ..typing import Any, CreateResult
+from .base_provider import AsyncProvider, format_prompt
+
+class Qidinam(AsyncProvider):
+    url = "https://ai.qidianym.net/api/chat-process"
+    working = True
+    supports_gpt_35_turbo = True
+    supports_stream = True
+
+    @classmethod
+    async def create_async(
+        cls,
+        model: str,
+        messages: dict[str, str],
+        **kwargs: Any,
+    ) -> CreateResult:
+        
+        base = ""
+        for message in messages:
+            base += "%s: %s\n" % (message["role"], message["content"])
+        base += "assistant:"
+
+        headers = {
+            "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: dict[str, Any] = {
+            "prompt": base,
+            "options": {},
+            "systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
+            "temperature": kwargs.get("temperature", 0.8),
+            "top_p": kwargs.get("top_p", 1),
+        }
+        url = "https://ai.qidianym.net/api/chat-process"
+
+        # Use aiohttp for asynchronous HTTP requests
+        async with ClientSession() as session:
+            async with session.post(url, headers=headers, json=data) as response:
+                response.raise_for_status()
+                lines = response.text.strip().split("\n")
+                res = json.loads(lines[-1])
+                return await res["text"]
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Raycast.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Raycast(BaseProvider):
+    url                     = "https://raycast.com"
+    supports_gpt_35_turbo   = True
+    supports_gpt_4          = True
+    supports_stream         = True
+    needs_auth              = True
+    working                 = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        auth = kwargs.get('auth')
+        headers = {
+            'Accept': 'application/json',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Authorization': f'Bearer {auth}',
+            'Content-Type': 'application/json',
+            'User-Agent': 'Raycast/0 CFNetwork/1410.0.3 Darwin/22.6.0',
+        }
+        parsed_messages = []
+        for message in messages:
+            parsed_messages.append({
+                'author': message['role'],
+                'content': {'text': message['content']}
+            })
+        data = {
+            "debug": False,
+            "locale": "en-CN",
+            "messages": parsed_messages,
+            "model": model,
+            "provider": "openai",
+            "source": "ai_chat",
+            "system_instruction": "markdown",
+            "temperature": 0.5
+        }
+        response = requests.post("https://backend.raycast.com/api/v1/ai/chat_completions", headers=headers, json=data, stream=True)
+        for token in response.iter_lines():
+            if b'data: ' not in token:
+                continue
+            completion_chunk = json.loads(token.decode().replace('data: ', ''))
+            token = completion_chunk['text']
+            if token != None:
+                yield token
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+            ("model", "str"),
+            ("auth", "str"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Theb.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+import random
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Theb(BaseProvider):
+    url                     = "https://theb.ai"
+    working                 = True
+    supports_stream         = True
+    supports_gpt_35_turbo   = True
+    needs_auth              = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
+        conversation += "\nassistant: "
+        
+        auth = kwargs.get("auth", {
+            "bearer_token":"free",
+            "org_id":"theb",
+        })
+        
+        bearer_token = auth["bearer_token"]
+        org_id       = auth["org_id"]
+        
+        headers = {
+            'authority'         : 'beta.theb.ai',
+            'accept'            : 'text/event-stream',
+            'accept-language'   : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
+            'authorization'     : 'Bearer '+bearer_token,
+            'content-type'      : 'application/json',
+            'origin'            : 'https://beta.theb.ai',
+            'referer'           : 'https://beta.theb.ai/home',
+            'sec-ch-ua'         : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            'sec-ch-ua-mobile'  : '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
+            'x-ai-model'        : 'ee8d4f29cb7047f78cbe84313ed6ace8',
+        }
+        
+        req_rand = random.randint(100000000, 9999999999)
+
+        json_data: dict[str, Any] = {
+            "text"      : conversation,
+            "category"  : "04f58f64a4aa4191a957b47290fee864",
+            "model"     : "ee8d4f29cb7047f78cbe84313ed6ace8",
+            "model_params": {
+                "system_prompt"     : "You are ChatGPT, a large language model trained by OpenAI, based on the GPT-3.5 architecture.\nKnowledge cutoff: 2021-09\nCurrent date: {{YYYY-MM-DD}}",
+                "temperature"       : kwargs.get("temperature", 1),
+                "top_p"             : kwargs.get("top_p", 1),
+                "frequency_penalty" : kwargs.get("frequency_penalty", 0),
+                "presence_penalty"  : kwargs.get("presence_penalty", 0),
+                "long_term_memory"  : "auto"
+            }
+        }
+        
+        response = requests.post(f"https://beta.theb.ai/api/conversation?org_id={org_id}&req_rand={req_rand}",
+                                 headers=headers, json=json_data, stream=True)
+        
+        response.raise_for_status()
+        content = ""
+        next_content = ""
+        for chunk in response.iter_lines():
+            if b"content" in chunk:
+                next_content = content
+                data = json.loads(chunk.decode().split("data: ")[1])
+                content = data["content"]
+                yield data["content"].replace(next_content, "")
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("auth", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("presence_penalty", "int"),
+            ("frequency_penalty", "int"),
+            ("top_p", "int")
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/V50.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import uuid
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class V50(BaseProvider):
+    url                     = 'https://p5.v50.ltd'
+    supports_gpt_35_turbo   = True
+    supports_stream         = False
+    needs_auth              = False
+    working                 = False
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
+        conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
+        conversation += "\nassistant: "
+
+        payload = {
+            "prompt"        : conversation,
+            "options"       : {},
+            "systemMessage" : ".",
+            "temperature"   : kwargs.get("temperature", 0.4),
+            "top_p"         : kwargs.get("top_p", 0.4),
+            "model"         : model,
+            "user"          : str(uuid.uuid4())
+        }
+        
+        headers = {
+            'authority'         : 'p5.v50.ltd',
+            'accept'            : 'application/json, text/plain, */*',
+            'accept-language'   : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
+            'content-type'      : 'application/json',
+            'origin'            : 'https://p5.v50.ltd',
+            'referer'           : 'https://p5.v50.ltd/',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest'    : 'empty',
+            'sec-fetch-mode'    : 'cors',
+            'sec-fetch-site'    : 'same-origin',
+            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36'
+        }
+        response = requests.post("https://p5.v50.ltd/api/chat-process", 
+                                json=payload, headers=headers, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
+        
+        if "https://fk1.v50.ltd" not in response.text:
+            yield response.text
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool"),
+            ("temperature", "float"),
+            ("top_p", "int"),
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Vercel.py

@@ -1,381 +1,358 @@
 from __future__ import annotations
+import os
+import asyncio
 
-import json, base64, requests, execjs, random, uuid
+import base64, json, uuid, quickjs, random
+from curl_cffi.requests import AsyncSession
 
-from ..typing       import Messages, TypedDict, CreateResult
-from .base_provider import BaseProvider
-from abc            import abstractmethod
+from ..typing       import Any, TypedDict
+from .base_provider import AsyncProvider
 
 
-class Vercel(BaseProvider):
-    url = 'https://sdk.vercel.ai'
+class Vercel(AsyncProvider):
+    url                   = "https://sdk.vercel.ai"
     working               = True
     supports_gpt_35_turbo = True
-    supports_stream       = True
+    model                 = "replicate:replicate/llama-2-70b-chat"
 
-    @staticmethod
-    @abstractmethod
-    def create_completion(
+    @classmethod
+    async def create_async(
+        cls,
         model: str,
-        messages: Messages,
-        stream: bool,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs
-    ) -> CreateResult:
-        if not model:
-            model = "gpt-3.5-turbo"
-        elif model not in model_info:
-            raise ValueError(f"Model are not supported: {model}")
+    ) -> str:
+        if model in ["gpt-3.5-turbo", "gpt-4"]:
+            model = "openai:" + model
+        model = model if model else cls.model
+        proxies = None
+        if proxy:
+            if "://" not in proxy:
+                proxy = "http://" + proxy
+            proxies = {"http": proxy, "https": proxy}
+        if os.name == 'nt':
+            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) 
 
         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'        :  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.%s.%s Safari/537.36' % (
-                random.randint(99, 999),
-                random.randint(99, 999)
-            )
+            "User-Agent": "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.{rand1}.{rand2} Safari/537.36".format(
+                rand1=random.randint(0,9999),
+                rand2=random.randint(0,9999)
+            ),
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept-Language": "en-US,en;q=0.5",
+            "TE": "trailers",
         }
+        async with AsyncSession(headers=headers, proxies=proxies, impersonate="chrome107") as session:
+            response = await session.get(cls.url + "/openai.jpeg")
+            response.raise_for_status()
+            custom_encoding = _get_custom_encoding(response.text)
+            headers = {
+                "Content-Type": "application/json",
+                "Custom-Encoding": custom_encoding,
+            }
+            data = _create_payload(model, messages)
+            response = await session.post(cls.url + "/api/generate", json=data, headers=headers)
+            response.raise_for_status()
+            return response.text
 
-        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 i in range(max_retries):
-            response = requests.post('https://sdk.vercel.ai/api/generate', 
-                                    headers=headers, json=json_data, stream=True, proxies={"https": proxy})
-            try:
-                response.raise_for_status()
-            except Exception:
-                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'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.%s.%s Safari/537.36' % (
-            random.randint(99, 999), 
-            random.randint(99, 999)
-        )
-    }
-
-    response = requests.get('https://sdk.vercel.ai/openai.jpeg', 
-                            headers=headers).text
 
-    raw_data = json.loads(base64.b64decode(response, 
-                                    validate=True))
+def _create_payload(model: str, messages: list[dict[str, str]]) -> dict[str, Any]:
+    if model not in model_info:
+        raise ValueError(f'Model are not supported: {model}')
+    default_params = model_info[model]["default_params"]
+    return {
+        "messages": messages,
+        "playgroundId": str(uuid.uuid4()),
+        "chatIndex": 0,
+        "model": model
+    } | default_params
 
-    js_script = '''const globalThis={marker:"mark"};String.prototype.fontcolor=function(){return `<font>${this}</font>`};
-        return (%s)(%s)''' % (raw_data['c'], raw_data['a'])
+# based on https://github.com/ading2210/vercel-llm-api
+def _get_custom_encoding(text: str) -> str:
+    data = json.loads(base64.b64decode(text, validate=True))
+    script = """
+      String.prototype.fontcolor = function() {{
+        return `<font>${{this}}</font>`
+      }}
+      var globalThis = {{marker: "mark"}};
+      ({script})({key})
+    """.format(
+        script=data["c"], key=data["a"]
+    )
+    context = quickjs.Context()  # type: ignore
+    token_data = json.loads(context.eval(script).json())  # type: ignore
+    token_data[2] = "mark"
+    token = {"r": token_data, "t": data["t"]}
+    token_str = json.dumps(token, separators=(",", ":")).encode("utf-16le")
+    return base64.b64encode(token_str).decode()
 
-    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:'],
+    "anthropic:claude-instant-v1": {
+        "id": "anthropic:claude-instant-v1",
+        "default_params": {
+            "temperature": 1,
+            "maxTokens": 200,
+            "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:'],
+    "anthropic:claude-v1": {
+        "id": "anthropic:claude-v1",
+        "default_params": {
+            "temperature": 1,
+            "maxTokens": 200,
+            "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:'],
+    "anthropic:claude-v2": {
+        "id": "anthropic:claude-v2",
+        "default_params": {
+            "temperature": 1,
+            "maxTokens": 200,
+            "topP": 1,
+            "topK": 1,
+            "presencePenalty": 1,
+            "frequencyPenalty": 1,
+            "stopSequences": ["\n\nHuman:"],
         },
     },
-    'a16z-infra/llama7b-v2-chat': {
-        'id': 'replicate:a16z-infra/llama7b-v2-chat',
-        'default_params': {
-            'temperature': 0.75,
-            'maximumLength': 3000,
-            'topP': 1,
-            'repetitionPenalty': 1,
+    "replicate:a16z-infra/llama7b-v2-chat": {
+        "id": "replicate:a16z-infra/llama7b-v2-chat",
+        "default_params": {
+            "temperature": 0.75,
+            "maxTokens": 500,
+            "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:a16z-infra/llama13b-v2-chat": {
+        "id": "replicate:a16z-infra/llama13b-v2-chat",
+        "default_params": {
+            "temperature": 0.75,
+            "maxTokens": 500,
+            "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,
+    "replicate:replicate/llama-2-70b-chat": {
+        "id": "replicate:replicate/llama-2-70b-chat",
+        "default_params": {
+            "temperature": 0.75,
+            "maxTokens": 1000,
+            "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,
+    "huggingface:bigscience/bloom": {
+        "id": "huggingface:bigscience/bloom",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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,
+    "huggingface:google/flan-t5-xxl": {
+        "id": "huggingface:google/flan-t5-xxl",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "huggingface:EleutherAI/gpt-neox-20b": {
+        "id": "huggingface:EleutherAI/gpt-neox-20b",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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,
-        },
+    "huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5": {
+        "id": "huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
+        "default_params": {"maxTokens": 200, "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,
-        },
+    "huggingface:OpenAssistant/oasst-sft-1-pythia-12b": {
+        "id": "huggingface:OpenAssistant/oasst-sft-1-pythia-12b",
+        "default_params": {"maxTokens": 200, "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,
+    "huggingface:bigcode/santacoder": {
+        "id": "huggingface:bigcode/santacoder",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "cohere:command-light-nightly": {
+        "id": "cohere:command-light-nightly",
+        "default_params": {
+            "temperature": 0.9,
+            "maxTokens": 200,
+            "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': [],
+    "cohere:command-nightly": {
+        "id": "cohere:command-nightly",
+        "default_params": {
+            "temperature": 0.9,
+            "maxTokens": 200,
+            "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': [],
+    "openai:gpt-4": {
+        "id": "openai:gpt-4",
+        "default_params": {
+            "temperature": 0.7,
+            "maxTokens": 500,
+            "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': [],
+    "openai:gpt-4-0613": {
+        "id": "openai:gpt-4-0613",
+        "default_params": {
+            "temperature": 0.7,
+            "maxTokens": 500,
+            "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': [],
+    "openai:code-davinci-002": {
+        "id": "openai:code-davinci-002",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "openai:gpt-3.5-turbo": {
+        "id": "openai:gpt-3.5-turbo",
+        "default_params": {
+            "temperature": 0.7,
+            "maxTokens": 500,
+            "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': [],
+    "openai:gpt-3.5-turbo-16k": {
+        "id": "openai:gpt-3.5-turbo-16k",
+        "default_params": {
+            "temperature": 0.7,
+            "maxTokens": 500,
+            "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': [],
+    "openai:gpt-3.5-turbo-16k-0613": {
+        "id": "openai:gpt-3.5-turbo-16k-0613",
+        "default_params": {
+            "temperature": 0.7,
+            "maxTokens": 500,
+            "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': [],
+    "openai:text-ada-001": {
+        "id": "openai:text-ada-001",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "openai:text-babbage-001": {
+        "id": "openai:text-babbage-001",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "openai:text-curie-001": {
+        "id": "openai:text-curie-001",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "openai:text-davinci-002": {
+        "id": "openai:text-davinci-002",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "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': [],
+    "openai:text-davinci-003": {
+        "id": "openai:text-davinci-003",
+        "default_params": {
+            "temperature": 0.5,
+            "maxTokens": 200,
+            "topP": 1,
+            "presencePenalty": 0,
+            "frequencyPenalty": 0,
+            "stopSequences": [],
         },
     },
-}
+}

g4f/Provider/Vitalentum.py

@@ -4,7 +4,7 @@ import json
 from aiohttp import ClientSession
 
 from .base_provider import AsyncGeneratorProvider
-from ..typing import AsyncResult, Messages
+from ..typing import AsyncGenerator
 
 class Vitalentum(AsyncGeneratorProvider):
     url                   = "https://app.vitalentum.io"
@@ -16,10 +16,10 @@ class Vitalentum(AsyncGeneratorProvider):
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs
-    ) -> AsyncResult:
+    ) -> 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"             : "text/event-stream",
@@ -42,13 +42,11 @@ class Vitalentum(AsyncGeneratorProvider):
         async with ClientSession(
             headers=headers
         ) as session:
-            async with session.post(f"{cls.url}/api/converse-edge", json=data, proxy=proxy) as response:
+            async with session.post(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
+                    if line.startswith("data: ") and not line.startswith("data: [DONE]"):
                         line = json.loads(line[6:-1])
                         content = line["choices"][0]["delta"].get("content")
                         if content:
@@ -62,7 +60,6 @@ class Vitalentum(AsyncGeneratorProvider):
             ("model", "str"),
             ("messages", "list[dict[str, str]]"),
             ("stream", "bool"),
-            ("proxy", "str"),
             ("temperature", "float"),
         ]
         param = ", ".join([": ".join(p) for p in params])

g4f/Provider/Wewordle.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import random, string, time
+from aiohttp import ClientSession
+
+from .base_provider import AsyncProvider
+
+
+class Wewordle(AsyncProvider):
+    url                    = "https://wewordle.org"
+    working                = True
+    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

g4f/Provider/Wuguokai.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import random
+
+import requests
+
+from ..typing import Any, CreateResult
+from .base_provider import BaseProvider
+
+
+class Wuguokai(BaseProvider):
+    url = 'https://chat.wuguokai.xyz'
+    supports_gpt_35_turbo = True
+    working = True
+
+    @staticmethod
+    def create_completion(
+        model: str,
+        messages: list[dict[str, str]],
+        stream: bool,
+        **kwargs: Any,
+    ) -> CreateResult:
+        base = ''
+        for message in messages:
+            base += '%s: %s\n' % (message['role'], message['content'])
+        base += 'assistant:'
+
+        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": base,
+            "options": {},
+            "userId": f"#/chat/{random.randint(1,99999999)}",
+            "usingContext": True
+        }
+        response = requests.post("https://ai-api20.wuguokai.xyz/api/chat-process", headers=headers, timeout=3, json=data, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
+        _split = response.text.split("> 若回答失败请重试或多刷新几次界面后重试")
+        if response.status_code == 200:
+            if len(_split) > 1:
+                yield _split[1].strip()
+            else:
+                yield _split[0].strip()
+        else:
+            raise Exception(f"Error: {response.status_code} {response.reason}")
+
+    @classmethod
+    @property
+    def params(cls):
+        params = [
+            ("model", "str"),
+            ("messages", "list[dict[str, str]]"),
+            ("stream", "bool")
+        ]
+        param = ", ".join([": ".join(p) for p in params])
+        return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/Ylokh.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import json
+from aiohttp import ClientSession
 
-from ..requests import StreamSession
 from .base_provider import AsyncGeneratorProvider
-from ..typing import AsyncResult, Messages
+from ..typing import AsyncGenerator
 
 class Ylokh(AsyncGeneratorProvider):
     url                   = "https://chat.ylokh.xyz"
@@ -16,16 +16,21 @@ class Ylokh(AsyncGeneratorProvider):
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         stream: bool = True,
         proxy: str = None,
-        timeout: int = 120,
         **kwargs
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
         model = model if model else "gpt-3.5-turbo"
         headers = {
-            "Origin" : cls.url,
-            "Referer": cls.url + "/",
+            "User-Agent"         : "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/116.0",
+            "Accept"             : "*/*",
+            "Accept-language"    : "de,en-US;q=0.7,en;q=0.3",
+            "Origin"             : cls.url,
+            "Referer"            : cls.url + "/",
+            "Sec-Fetch-Dest"     : "empty",
+            "Sec-Fetch-Mode"     : "cors",
+            "Sec-Fetch-Site"     : "same-origin",
         }
         data = {
             "messages": messages,
@@ -38,20 +43,16 @@ class Ylokh(AsyncGeneratorProvider):
             "stream": stream,
             **kwargs
         }
-        async with StreamSession(
-            headers=headers,
-            proxies={"https": proxy},
-            timeout=timeout
+        async with ClientSession(
+            headers=headers
         ) as session:
-            async with session.post("https://chatapi.ylokh.xyz/v1/chat/completions", json=data) as response:
+            async with session.post("https://chatapi.ylokh.xyz/v1/chat/completions", json=data, proxy=proxy) as response:
                 response.raise_for_status()
                 if stream:
-                    async for line in response.iter_lines():
+                    async for line in response.content:
                         line = line.decode()
-                        if line.startswith("data: "):
-                            if line.startswith("data: [DONE]"):
-                                break
-                            line = json.loads(line[6:])
+                        if line.startswith("data: ") and not line.startswith("data: [DONE]"):
+                            line = json.loads(line[6:-1])
                             content = line["choices"][0]["delta"].get("content")
                             if content:
                                 yield content
@@ -69,9 +70,7 @@ class Ylokh(AsyncGeneratorProvider):
             ("messages", "list[dict[str, str]]"),
             ("stream", "bool"),
             ("proxy", "str"),
-            ("timeout", "int"),
             ("temperature", "float"),
-            ("top_p", "float"),
         ]
         param = ", ".join([": ".join(p) for p in params])
         return f"g4f.provider.{cls.__name__} supports: ({param})"

g4f/Provider/You.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import json
 
-from ..requests import StreamSession
-from ..typing import AsyncGenerator, Messages
+from curl_cffi.requests import AsyncSession
+
+from ..typing import AsyncGenerator
 from .base_provider import AsyncGeneratorProvider, format_prompt
 
 
@@ -11,30 +12,29 @@ class You(AsyncGeneratorProvider):
     url = "https://you.com"
     working = True
     supports_gpt_35_turbo = True
+    supports_stream = False
 
 
     @classmethod
     async def create_async_generator(
         cls,
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
-        timeout: int = 120,
         **kwargs,
     ) -> AsyncGenerator:
-        async with StreamSession(proxies={"https": proxy}, impersonate="chrome107", timeout=timeout) as session:
+        async with AsyncSession(proxies={"https": proxy}, impersonate="chrome107") as session:
             headers = {
                 "Accept": "text/event-stream",
-                "Referer": f"{cls.url}/search?fromSearchBar=true&tbm=youchat",
+                "Referer": "https://you.com/search?fromSearchBar=true&tbm=youchat",
             }
-            data = {"q": format_prompt(messages), "domain": "youchat", "chat": ""}
-            async with session.get(
-                f"{cls.url}/api/streamingSearch",
-                params=data,
+            response = await session.get(
+                "https://you.com/api/streamingSearch",
+                params={"q": format_prompt(messages), "domain": "youchat", "chat": ""},
                 headers=headers
-            ) as response:
-                response.raise_for_status()
-                start = b'data: {"youChatToken": '
-                async for line in response.iter_lines():
-                    if line.startswith(start):
-                        yield json.loads(line[len(start):-1])
+            )
+            response.raise_for_status()
+            start = 'data: {"youChatToken": '
+            for line in response.text.splitlines():
+                if line.startswith(start):
+                    yield json.loads(line[len(start): -1])

g4f/Provider/Yqcloud.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-import random
 from aiohttp import ClientSession
 
-from ..typing import AsyncResult, Messages
+from ..typing import AsyncGenerator
 from .base_provider import AsyncGeneratorProvider, format_prompt
 
 
@@ -15,22 +14,19 @@ class Yqcloud(AsyncGeneratorProvider):
     @staticmethod
     async def create_async_generator(
         model: str,
-        messages: Messages,
+        messages: list[dict[str, str]],
         proxy: str = None,
         **kwargs,
-    ) -> AsyncResult:
+    ) -> AsyncGenerator:
         async with ClientSession(
             headers=_create_header()
         ) as session:
-            payload = _create_payload(messages, **kwargs)
+            payload = _create_payload(messages)
             async with session.post("https://api.aichatos.cloud/api/generateStream", proxy=proxy, json=payload) as response:
                 response.raise_for_status()
-                async for chunk in response.content.iter_any():
-                    if chunk:
-                        chunk = chunk.decode()
-                        if "sorry, 您的ip已由于触发防滥用检测而被封禁" in chunk:
-                            raise RuntimeError("IP address is blocked by abuse detection.")
-                        yield chunk
+                async for stream in response.content.iter_any():
+                    if stream:
+                        yield stream.decode()
 
 
 def _create_header():
@@ -41,19 +37,12 @@ def _create_header():
     }
 
 
-def _create_payload(
-    messages: Messages,
-    system_message: str = "",
-    user_id: int = None,
-    **kwargs
-):
-    if not user_id:
-        user_id = random.randint(1690000544336, 2093025544336)
+def _create_payload(messages: list[dict[str, str]]):
     return {
         "prompt": format_prompt(messages),
         "network": True,
-        "system": system_message,
+        "system": "",
         "withoutContext": False,
         "stream": True,
-        "userId": f"#/chat/{user_id}"
+        "userId": "#/chat/1693025544336"
     }