:gem: [Feature] Enable chat with Bing from unauthenticated users

.gitignore

@@ -0,0 +1 @@
+__pycache__

README.md

@@ -0,0 +1,3 @@
+## Bing-Chat-API
+
+A successor of [EdgeGPT](https://github.com/acheong08/EdgeGPT) by [acheong08](https://github.com/acheong08).

chathub_request_constructor.py

@@ -0,0 +1,178 @@
+import random
+import uuid
+from datetime import datetime
+
+
+def generate_random_hex_str(length: int = 32) -> str:
+    return "".join(random.choice("0123456789abcdef") for _ in range(length))
+
+
+def generate_random_uuid():
+    return str(uuid.uuid4())
+
+
+def get_locale():
+    return "en-US"
+
+
+def get_timestamp_str():
+    now = datetime.now()
+    now_utc = datetime.utcnow()
+    timezone_offset = now - now_utc
+    offset_seconds = timezone_offset.total_seconds()
+    offset_hours = int(offset_seconds // 3600)
+    offset_minutes = int((offset_seconds % 3600) // 60)
+    offset_string = f"{offset_hours:+03d}:{offset_minutes:02d}"
+    timestamp_str = datetime.now().strftime("%Y-%m-%dT%H:%M:%S") + offset_string
+    # print(timestamp_str)
+    return timestamp_str
+
+
+def get_prompt():
+    return "Hello, who are you?"
+
+
+class ChathubRequestConstructor:
+    def __init__(
+        self,
+        conversation_style: str,
+        client_id: str,
+        conversation_id: str,
+        invocation_id: int = 0,
+    ):
+        self.client_id = client_id
+        self.conversation_id = conversation_id
+        self.message_id = generate_random_uuid()
+        self.invocation_id = invocation_id
+        self.conversation_style = conversation_style
+        self.construct()
+
+    def construct(self):
+        self.request_message = {
+            "arguments": [
+                {
+                    "source": "cib",
+                    "optionsSets": [
+                        "nlu_direct_response_filter",
+                        "deepleo",
+                        "disable_emoji_spoken_text",
+                        "responsible_ai_policy_235",
+                        "enablemm",
+                        "dv3sugg",
+                        "autosave",
+                        "uquopt",
+                        "enelecintl",
+                        "gndeleccf",
+                        "gndlogcf",
+                        "logprobsc",
+                        "fluxprod",
+                        "eredirecturl",
+                    ],
+                    "allowedMessageTypes": [
+                        "ActionRequest",
+                        "Chat",
+                        "ConfirmationCard",
+                        "Context",
+                        "InternalSearchQuery",
+                        "InternalSearchResult",
+                        "Disengaged",
+                        "InternalLoaderMessage",
+                        "InvokeAction",
+                        "Progress",
+                        "RenderCardRequest",
+                        "RenderContentRequest",
+                        "AdsQuery",
+                        "SemanticSerp",
+                        "GenerateContentQuery",
+                        "SearchQuery",
+                    ],
+                    "sliceIds": [
+                        "cruisecf",
+                        "adssqovr",
+                        "gbacf",
+                        "bggrey",
+                        "1366cf",
+                        "vnextvoice",
+                        "caccnctat3",
+                        "specedgecf",
+                        "inosanewsmob",
+                        "wrapnoins",
+                        "readaloud",
+                        "autotts",
+                        "styleoffall",
+                        "rwt2",
+                        "dismmaslp",
+                        "1117gndelecs0",
+                        "713logprobsc",
+                        "1118wcpdcl",
+                        "1119backos",
+                        "1103gndlog",
+                        "1107reviewss0",
+                        "fluxnosearch",
+                        "727nrprdrt3",
+                        "codecreator1",
+                        "kchero50cf",
+                        "cacmuidarb",
+                    ],
+                    "verbosity": "verbose",
+                    "scenario": "SERP",
+                    "plugins": [
+                        {"id": "c310c353-b9f0-4d76-ab0d-1dd5e979cf68"},
+                    ],
+                    "traceId": generate_random_hex_str(),
+                    "conversationHistoryOptionsSets": [
+                        "autosave",
+                        "savemem",
+                        "uprofupd",
+                        "uprofgen",
+                    ],
+                    "isStartOfSession": self.invocation_id == 0,
+                    "requestId": self.message_id,
+                    "message": {
+                        "locale": get_locale(),  # "en-US"
+                        "market": get_locale(),  # "en-US"
+                        "region": get_locale()[-2:],  # "US"
+                        "location": "lat:47.639557;long:-122.128159;re=1000m;",
+                        "locationHints": [
+                            {
+                                "SourceType": 1,
+                                "RegionType": 2,
+                                "Center": {
+                                    "Latitude": 38.668399810791016,
+                                    "Longitude": -121.14900207519531,
+                                },
+                                "Radius": 24902,
+                                "Name": "Folsom, California",
+                                "Accuracy": 24902,
+                                "FDConfidence": 0.5,
+                                "CountryName": "United States",
+                                "CountryConfidence": 8,
+                                "Admin1Name": "California",
+                                "PopulatedPlaceName": "Folsom",
+                                "PopulatedPlaceConfidence": 5,
+                                "PostCodeName": "95630",
+                                "UtcOffset": -8,
+                                "Dma": 862,
+                            }
+                        ],
+                        "userIpAddress": "192.55.55.51",
+                        "timestamp": get_timestamp_str(),  # "2023-11-20T12:50:17+08:00",
+                        "author": "user",
+                        "inputMethod": "Keyboard",
+                        "text": get_prompt(),
+                        "messageType": "Chat",
+                        "requestId": self.message_id,  # "a6ecd3aa-1007-6959-52fb-9e23f34e86be",
+                        "messageId": self.message_id,  # "a6ecd3aa-1007-6959-52fb-9e23f34e86be",
+                    },
+                    "tone": self.conversation_style.capitalize(),
+                    "spokenTextMode": "None",
+                    "conversationId": self.conversation_id,  # "51D|BingProd|30FA137663F2BDBA514A0F31EE0A99E082B5AF8C0DA05696D2A5C6B56C10CF99",
+                    "participant": {
+                        "id": self.client_id,  # "1055519195774559",
+                    },
+                }
+            ],
+            "invocationId": str(self.invocation_id),
+            "target": "chat",
+            "type": 4,
+        }

conversation_creater.py

@@ -0,0 +1,160 @@
+import aiohttp
+import asyncio
+import certifi
+import httpx
+import json
+import pprint
+import ssl
+import urllib
+
+from chathub_request_constructor import ChathubRequestConstructor
+from cookies_constructor import CookiesConstructor
+
+ssl_context = ssl.create_default_context()
+ssl_context.load_verify_locations(certifi.where())
+
+http_proxy = "http://localhost:11111"
+
+
+class ConversationCreator:
+    conversation_create_url = "https://www.bing.com/turing/conversation/create"
+
+    def __init__(self, cookies={}):
+        self.cookies = cookies
+        self.construct_cookies()
+
+    def construct_cookies(self):
+        self.httpx_cookies = httpx.Cookies()
+        for key, val in self.cookies.items():
+            self.httpx_cookies.set(key, val)
+
+    def create(self, proxy=None):
+        self.response = httpx.get(
+            self.conversation_create_url,
+            proxies=http_proxy if proxy is None else proxy,
+            cookies=self.httpx_cookies,
+        )
+        self.response_content = json.loads(self.response.content.decode("utf-8"))
+        self.response_headers = dict(self.response.headers)
+        pprint.pprint(self.response_content)
+        # pprint.pprint(self.response_headers)
+
+
+def serialize_websockets_message(msg: dict) -> str:
+    return json.dumps(msg, ensure_ascii=False) + "\x1e"
+
+
+class ConversationChatter:
+    def __init__(
+        self,
+        sec_access_token=None,
+        client_id=None,
+        conversation_id=None,
+        invocation_id=0,
+        cookies={},
+    ):
+        self.sec_access_token = sec_access_token
+        self.client_id = client_id
+        self.conversation_id = conversation_id
+        self.invocation_id = invocation_id
+        self.cookies = cookies
+        self.ws_url = (
+            "wss://sydney.bing.com/sydney/ChatHub"
+            + f"?sec_access_token={urllib.parse.quote(self.sec_access_token)}"
+        )
+        # print(f"sec_access_token: {self.sec_access_token}")
+
+    async def init_handshake(self, wss):
+        await wss.send_str(
+            serialize_websockets_message({"protocol": "json", "version": 1})
+        )
+        await wss.receive_str()
+        await wss.send_str(serialize_websockets_message({"type": 6}))
+
+    async def stream_chat(self, prompt=""):
+        self.aio_session = aiohttp.ClientSession(cookies=self.cookies)
+        request_headers = {
+            "Accept-Encoding": " gzip, deflate, br",
+            "Accept-Language": "en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7",
+            "Cache-Control": "no-cache",
+            "Connection": "Upgrade",
+            "Host": "sydney.bing.com",
+            "Origin": "https://www.bing.com",
+            "Pragma": "no-cache",
+            "Sec-Websocket-Extensions": "permessage-deflate; client_max_window_bits",
+            # "Sec-Websocket-Key": "**********************==",
+            "Sec-Websocket-Version": "13",
+            "Upgrade": "websocket",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+        }
+        wss = await self.aio_session.ws_connect(
+            self.ws_url,
+            headers=request_headers,
+            ssl=ssl_context,
+            proxy=http_proxy,
+        )
+
+        await self.init_handshake(wss)
+        chathub_request_construtor = ChathubRequestConstructor(
+            conversation_style="precise",
+            client_id=self.client_id,
+            conversation_id=self.conversation_id,
+            invocation_id=self.invocation_id,
+        )
+        chathub_request_construtor.construct()
+
+        await wss.send_str(
+            serialize_websockets_message(chathub_request_construtor.request_message)
+        )
+        while not wss.closed:
+            response_lines_str = await wss.receive_str()
+            if isinstance(response_lines_str, str):
+                response_lines = response_lines_str.split("\x1e")
+            else:
+                continue
+            for line in response_lines:
+                if not line:
+                    continue
+                data = json.loads(line)
+                if data.get("type") == 1:
+                    arguments = data["arguments"][0]
+                    if arguments.get("throttling"):
+                        throttling = arguments.get("throttling")
+                        pprint.pprint(throttling)
+                    if arguments.get("messages"):
+                        messages = arguments.get("messages")[0]
+                        html_str = messages["adaptiveCards"][0]["body"][0]["text"]
+                        # pprint.pprint(html_str)
+                elif data.get("type") == 2:
+                    if data.get("item"):
+                        item = data.get("item")
+                        for message in item.get("messages"):
+                            author = message["author"]
+                            message_text = message["text"]
+                            print(f"[{author}]: {message_text}")
+                elif data.get("type") == 3:
+                    print("[Finished]")
+                    await wss.close()
+                    break
+                else:
+                    # pprint.pprint(data)
+                    continue
+
+
+if __name__ == "__main__":
+    # cookies_constructor = CookiesConstructor()
+    # cookies_constructor.construct()
+
+    creator = ConversationCreator()
+    creator.create()
+
+    chatter = ConversationChatter(
+        sec_access_token=creator.response_headers[
+            "x-sydney-encryptedconversationsignature"
+        ],
+        client_id=creator.response_content["clientId"],
+        conversation_id=creator.response_content["conversationId"],
+    )
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(chatter.stream_chat())
+    loop.close()

cookies_constructor.py

@@ -0,0 +1,9 @@
+class CookiesConstructor:
+    def __init__(self) -> None:
+        self.cookies_list = [
+        ]
+
+    def construct(self):
+        self.cookies = {}
+        for cookie in self.cookies_list:
+            self.cookies[cookie["name"]] = cookie["value"]