Upload 103 files

api/chat/__init__.py

@@ -0,0 +1,4 @@
+from .chat_config import ChatConfig
+from .chat_api import ChatAPI
+
+__all__ = ['ChatConfig', 'ChatAPI']

api/chat/chat_api.py

@@ -0,0 +1,276 @@
+import binascii
+import json
+from typing import List, Optional, AsyncGenerator
+from time import time
+
+# Remove aioredis import
+# from aioredis import Redis
+
+# import tiktoken
+from api.chat import ChatConfig
+from api.telemetry import TelemetryAPI
+from auth.jwt_handler import JWTHandler
+from config.constants import ENCRYPTION_KEY
+from utils.encrypt import encrypt
+from utils.http import HTTPClient
+from config.constants import (
+    APP_LANGUAGE,
+    APP_NAME,
+    APP_VERSION,
+    DISPLAY_NAME,
+    HADWARE_INFO,
+    INFERENCE_URL,
+    SYSTEM_INFO,
+)
+from utils.compression import decompress_chunks
+
+from protos import request_pb2, response_pb2
+
+
+class ChatAPI:
+    def __init__(self, api_key: str, http_client: HTTPClient = HTTPClient()):
+        self.api_key = api_key
+        self.jwt_token = None
+        self.jwt_token_timestamp = 0
+        self.http_client = http_client
+        
+    async def renew_jwt_token(self):
+        """Renew JWT token asynchronously if it's expired or missing"""
+        current_time = time()
+        
+        # Check if token is still valid (within 2500 seconds)
+        if self.jwt_token and current_time - self.jwt_token_timestamp < 2500:
+            return
+            
+        jwt_handler = JWTHandler(api_key=self.api_key, http_client=self.http_client)
+        jwt_token = await jwt_handler.get_jwt_token()
+        tele = TelemetryAPI(api_key=self.api_key)
+        await tele.do_telemetry()
+
+        if jwt_token:
+            self.jwt_token = jwt_token
+            self.jwt_token_timestamp = current_time
+
+    async def _create_chat_request(
+        self,
+        messages: List[dict],
+        config: ChatConfig,
+        system_prompt: str = "You are a helpful assistant.",
+    ) -> request_pb2.ChatRequestMessage:
+        try:
+            await self.renew_jwt_token()
+        except Exception as e:
+            print(e)
+            ...
+
+        msg = request_pb2.ChatRequestMessage()
+
+        # Set client info
+        self._set_client_info(msg)
+
+        # Set system prompt and model config
+        msg.system_prompt = system_prompt
+        msg.model_id = config.model_id.value
+        msg.idk13.idk13nn = 1
+        msg.idk_id = 5
+        self._set_model_config(msg, config)
+
+        # Set tool config
+        # self._set_tool_config(msg)
+
+        # Convert messages
+        self._add_messages(msg, messages)
+
+        return msg
+
+    def _set_client_info(self, msg: request_pb2.ChatRequestMessage) -> None:
+        """Set client information in the request message"""
+        msg.client_info.api_key = self.api_key
+        msg.client_info.user_jwt = self.jwt_token
+        msg.client_info.locale = APP_LANGUAGE
+        msg.client_info.extension_name = APP_NAME
+        msg.client_info.ide_name = APP_NAME
+        msg.client_info.extension_version = APP_VERSION
+        msg.client_info.os = SYSTEM_INFO
+        msg.client_info.ide_version = DISPLAY_NAME
+        msg.client_info.hardware = HADWARE_INFO
+
+    def _set_model_config(
+        self, msg: request_pb2.ChatRequestMessage, config: ChatConfig
+    ) -> None:
+        """Set model configuration"""
+        msg.model_config.parallel_stream = 1
+        msg.model_config.max_tokens = config.max_tokens
+        msg.model_config.temperature = config.temperature
+        msg.model_config.top_k = config.top_k
+        msg.model_config.top_P = config.top_p
+
+    def _set_special_tokens(self, msg: request_pb2.ChatRequestMessage) -> None:
+        msg.model_config.special_tokens.extend(
+            [
+                "<|user|>",
+                "<|bot|>",
+                "<|context_request|>",
+                "<|endoftext|>",
+                "<|end_of_turn|>",
+            ]
+        )
+
+    def _set_tool_config(self, msg: request_pb2.ChatRequestMessage) -> None:
+        """Set tool configuration"""
+        msg.tool_use.mode = "auto"
+        msg.tool_config.tool_name = "do_not_call"
+        msg.tool_config.description = "Do not call this tool."
+        msg.tool_config.schema = '{"$schema":"https://json-schema.org/draft/2020-12/schema","properties":{},"additionalProperties":false,"type":"object"}'
+
+    def _add_messages(
+        self, msg: request_pb2.ChatRequestMessage, messages: List[dict]
+    ) -> None:
+        """Add chat messages to the request"""
+        role_map = {"user": 1, "assistant": 2, "system": 3}
+
+        for chat_msg in messages:
+            role = role_map.get(chat_msg["role"], 1)
+            content = chat_msg["content"]
+
+            # Override system prompt
+            if role == 3:
+                if isinstance(content, str):
+                    msg.system_prompt = content
+
+                elif isinstance(content, list):
+                    for item in content:
+                        if item.get("type", "") == "text" and "text" in item and isinstance(item["text"], str):
+                            msg.system_prompt = item["text"]
+                        break
+                continue
+
+            if isinstance(content, list):
+                pb_msg = self._create_multipart_message(role, content)
+            else:
+                pb_msg = self._create_text_message(role, content)
+
+            msg.chat_messages.append(pb_msg)
+
+    def _create_multipart_message(
+        self, role: int, content: List[dict]
+    ) -> request_pb2.ChatMessage:
+        """Create a message with multiple parts (text and images)"""
+        text_parts = []
+        image_parts = []
+
+        for item in content:
+            if item["type"] == "text":
+                text_parts.append(item["text"])
+            elif item["type"] == "image_url":
+                image_url = item["image_url"]["url"]
+                if image_url.startswith("data:image/") and "base64," in image_url:
+                    prefix, image_data = image_url.split("base64,", 1)
+                    mime_type = prefix.split("data:")[1].split(";")[0]
+                    image_parts.append(
+                        request_pb2.ImagePart(
+                            image_data=image_data, image_mime_type=mime_type
+                        )
+                    )
+
+        return self._create_message(role, " ".join(text_parts), image_parts)
+
+    def _create_text_message(self, role: int, content: str) -> request_pb2.ChatMessage:
+        """Create a simple text message"""
+        return self._create_message(role, content)
+
+    def _create_message(
+        self, role: int, content: str, image_parts: List[request_pb2.ImagePart] = None
+    ) -> request_pb2.ChatMessage:
+        """Create a chat message with common attributes"""
+        pb_msg = request_pb2.ChatMessage(
+            role=role, content=content
+        )
+        if role == 1: pb_msg.idk2 = 1
+        # pb_msg.cache_control.prompt_caching = 1
+
+        if image_parts:
+            pb_msg.image_parts.extend(image_parts)
+        return pb_msg
+
+    async def _process_chat_response(self, type: int, data: bytes) -> tuple[str, int]:
+        """Process a single chat response chunk and return (message, count)"""
+        if type == 3:  # end of message
+            try:
+                response = json.loads(data)
+                return (encrypt(str(response), ENCRYPTION_KEY), 0) if response else ("", 0)
+            except Exception as e:
+                raise e
+        
+        try:
+            search_response = response_pb2.ChatResponse()
+            search_response.ParseFromString(data)
+            return (search_response.message, search_response.count) if search_response.message else ("", 0)
+        except:
+            return ("", 0)
+
+    async def _handle_stream_response(self, chunk_iterator) -> AsyncGenerator[tuple[str, int], None]:
+        """Handle streaming response chunks"""
+        async for chunk in chunk_iterator:
+            for type, data in decompress_chunks(chunk):
+                result = await self._process_chat_response(type, data)
+                yield result
+
+    async def _handle_response(self, chunk) -> AsyncGenerator[tuple[str, int], None]:
+        """Handle non-streaming response chunks"""
+        for type, data in decompress_chunks(chunk):
+            result = await self._process_chat_response(type, data)
+            yield result
+
+    async def send_message(
+        self,
+        messages: List[dict],
+        config: Optional[ChatConfig] = None,
+        system_prompt: str = "You are a helpful assistant.",
+        stream: bool = False,
+    ) -> AsyncGenerator[tuple[str, int], None]:
+        """Send chat messages and yield response chunks"""
+        if config is None:
+            config = ChatConfig()
+
+        request = await self._create_chat_request(messages, config, system_prompt)
+        
+        headers = {
+            "User-Agent": "connect-go/1.16.2 (go1.23.2 X:nocoverageredesign)",
+            "Connect-Accept-Encoding": "gzip",
+            "Connect-Content-Encoding": "gzip",
+            "Connect-Protocol-Version": "1",
+            "Content-Type": "application/connect+proto",
+        }
+
+        url = f"{INFERENCE_URL}/exa.api_server_pb.ApiServerService/GetChatMessage"
+        request_data = request.SerializeToString()
+
+        if stream:
+            stream_iterator = self.http_client.stream_post(
+                url=url,
+                data=request_data,
+                headers=headers,
+                compress=True,
+            )
+            async for result in self._handle_stream_response(stream_iterator):
+                yield result
+        else:
+            response = await self.http_client.post(
+                url=url,
+                data=request_data,
+                headers=headers,
+                compress=True,
+            )
+
+            if response.status_code != 200:
+                raise Exception(f"Chat request failed: {response.status_code}")
+
+            if response.headers.get("connect-content-encoding") == "gzip":
+                async for result in self._handle_response(response.content):
+                    yield result
+            else:
+                search_response = response_pb2.ChatResponse()
+                search_response.ParseFromString(response.content)
+                if search_response.message:
+                    yield (search_response.message, search_response.count)

api/chat/chat_config.py

@@ -0,0 +1,21 @@
+
+from dataclasses import dataclass
+
+from config.models import ModelID
+
+
+@dataclass
+class ChatConfig:
+    def __init__(
+        self,
+        model_id: ModelID = ModelID.MODEL_CLAUDE_3_5_HAIKU_20241022,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        top_p: float = 1.0,
+        top_k: int = 50
+    ):
+        self.model_id = model_id
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.top_p = top_p
+        self.top_k = top_k

api/telemetry.py

@@ -0,0 +1,92 @@
+import json
+import httpx
+import uuid
+from config.constants import (
+    APP_LANGUAGE,
+    BASE_URL,
+    APP_NAME,
+    APP_VERSION,
+    DISPLAY_NAME,
+    HADWARE_INFO,
+    SYSTEM_INFO,
+)
+from protos import telemetry_pb2
+
+
+class TelemetryAPI:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.client = httpx.AsyncClient(verify=False, timeout=3)
+
+    async def do_telemetry(self):
+        await self.send_telemetry()
+        await self.send_ping()
+        await self.send_unleash_request()
+
+    async def send_telemetry(self):
+        telemetry = telemetry_pb2.TelemetryData()
+
+        # System info
+        system_info = telemetry.system_info
+        system_info.api_key = self.api_key
+        system_info.locale = APP_LANGUAGE
+        system_info.extension_name = APP_NAME
+        system_info.ide_name = APP_NAME
+        system_info.extension_version = APP_VERSION
+        system_info.os = SYSTEM_INFO
+        system_info.ide_version = DISPLAY_NAME
+        system_info.hardware = HADWARE_INFO
+
+        system_info.session_id = str(uuid.uuid4())
+
+        response = await self.client.post(
+            url=f"{BASE_URL}/exa.api_server_pb.ApiServerService/RecordAsyncTelemetry",
+            headers={
+                "Content-Type": "application/proto",
+            },
+            content=telemetry.SerializeToString(),
+        )
+
+        return response.status_code == 200
+
+    async def send_ping(self):
+        url = f"{BASE_URL}/exa.api_server_pb.ApiServerService/Ping"
+        
+        headers = {
+            'User-Agent': 'connect-go/1.16.2 (go1.23.2 X:nocoverageredesign)',
+            'Accept-Encoding': 'gzip',
+            'Connect-Protocol-Version': '1',
+            'Content-Type': 'application/proto'
+        }
+
+        try:
+            response = await self.client.post(url, headers=headers)
+            print(f"Ping Status Code: {response.status_code}")
+        except httpx.RequestError as e:
+            print(f"请求发生错误: {e}")
+
+    async def send_unleash_request(self):
+        url = f"{BASE_URL}/exa.api_server_pb.ApiServerService/GetUnleashContextFields"
+        
+        headers = {
+            'User-Agent': 'connect-go/1.16.2 (go1.23.2 X:nocoverageredesign)',
+            'Accept-Encoding': 'gzip',
+            'Connect-Protocol-Version': '1',
+            'Content-Type': 'application/proto'
+        }
+        
+        try:
+            response = await self.client.post(url, headers=headers)
+            
+            print(f"GetUnleashContextFields Status Code: {response.status_code}")
+            print(f"地区：")
+            print(f"{response.text}")
+            
+        except httpx.RequestError as e:
+            print(f"请求发生错误: {e}")
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client.aclose()

auth/jwt_handler.py

@@ -0,0 +1,41 @@
+from utils.http import HTTPClient
+from config.constants import APP_LANGUAGE, BASE_URL, APP_NAME, APP_VERSION, DISPLAY_NAME
+from protos import jwt_pb2
+
+
+class JWTHandler:
+    def __init__(self, api_key: str, server_url: str = BASE_URL, http_client: HTTPClient = HTTPClient()):
+        self.server_url = server_url
+        self.api_key = api_key
+        self.jwt_token = None
+        self.http_client = http_client
+
+    async def get_jwt_token(self) -> str:
+        """Get JWT token from server"""
+        request = jwt_pb2.jwt_request(
+            surfwind_jwt_request=jwt_pb2.surfwind_jwt_request(
+                app_name=APP_NAME,
+                version=APP_VERSION,
+                api_key=self.api_key,
+                language=APP_LANGUAGE,
+                display_name=DISPLAY_NAME,
+                app_identifier=APP_NAME,
+            )
+        )
+
+        response = await self.http_client.post(
+            url=f"{self.server_url}/exa.auth_pb.AuthService/GetUserJwt",
+            headers={
+                "Content-Type": "application/proto",
+            },
+            data=request.SerializeToString(),
+        )
+
+        if response.status_code == 200:
+            jwt_response = jwt_pb2.jwt_response()
+            jwt_response.ParseFromString(response.content)
+            self.jwt_token = jwt_response.jwt_token
+            return self.jwt_token
+
+        print(response.content)
+        raise Exception(f"Failed to get JWT token: {response.status_code}")

auth/login.py

@@ -0,0 +1,27 @@
+import uuid
+import webbrowser
+from config.constants import WINDSURF_ID
+
+
+def open_auth_url() -> str:
+    """Open authentication URL in browser"""
+    state = str(uuid.uuid4())
+    base_url = "https://www.codeium.com/windsurf/signin"
+
+    auth_url = (
+        f"{base_url}?"
+        f"response_type=token&"
+        f"client_id={WINDSURF_ID}&"
+        f"redirect_uri=show-auth-token&"
+        f"state={state}&"
+        f"prompt=login&"
+        f"redirect_parameters_type=query&"
+        f"workflow="
+    )
+
+    try:
+        webbrowser.open(auth_url)
+        return state
+    except Exception as e:
+        print(f"Failed to open browser: {e}")
+        return None

auth/register.py

@@ -0,0 +1,33 @@
+from utils.http import HTTPClient
+from config.constants import API_URL
+
+
+class Registration:
+    @staticmethod
+    async def register_user(firebase_token: str) -> str:
+        """
+        Register user with firebase token and return API key
+        """
+        headers = {
+            "User-Agent": "Go-http-client/1.1",
+            "Content-Type": "application/json",
+            "Accept-Encoding": "gzip",
+        }
+
+        data = {"firebase_id_token": firebase_token}
+
+        response = await HTTPClient().post(
+            f"{API_URL}/register_user/", headers=headers, default_headers=False, json=data, verify=False
+        )
+
+        if response.status_code != 200:
+            print(response.text)
+            raise Exception(f"Registration failed: {response.status_code}")
+
+        response_json = response.json()
+        api_key = response_json.get("api_key")
+
+        if not api_key:
+            raise Exception("No API key in response")
+
+        return api_key

boot.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# start.sh
+
+# 初始化聊天队列
+# pypy/bin/python init_pool.py
+
+# 启动 Gunicorn 服务器
+
+pypy/bin/gunicorn service.server:app \
+    --worker-class uvicorn.workers.UvicornWorker \
+    --workers 16 \
+    --bind 0.0.0.0:8000 \
+    --timeout 30 \
+    --keep-alive 5 \
+    --access-logfile - \
+    --error-logfile - 

config/api_keys.py

@@ -0,0 +1,62 @@
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Optional, List
+
+
+class APIKeyManager:
+    def __init__(self, config_path: str = "config/api_keys.xml"):
+        self.config_path = Path(config_path)
+        self._api_keys: List[str] = []
+        self._load_keys()
+
+    def _load_keys(self):
+        """Load API keys from XML file"""
+        if not self.config_path.exists():
+            self._create_default_config()
+
+        tree = ET.parse(self.config_path)
+        root = tree.getroot()
+
+        self._api_keys = [key.text for key in root.findall("key")]
+
+    def _create_default_config(self):
+        """Create default XML config file"""
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        root = ET.Element("api_keys")
+        tree = ET.ElementTree(root)
+        tree.write(self.config_path, encoding="utf-8", xml_declaration=True)
+
+    def get_key(self, index: int = 0) -> Optional[str]:
+        """Get API key by index"""
+        try:
+            return self._api_keys[index]
+        except IndexError:
+            return None
+
+    def add_key(self, api_key: str):
+        """Add new API key"""
+        root = ET.parse(self.config_path).getroot()
+        new_key = ET.SubElement(root, "key")
+        new_key.text = api_key
+
+        tree = ET.ElementTree(root)
+        tree.write(self.config_path, encoding="utf-8", xml_declaration=True)
+
+        self._api_keys.append(api_key)
+
+    def remove_key(self, index: int):
+        """Remove API key by index"""
+        root = ET.parse(self.config_path).getroot()
+        keys = root.findall("key")
+
+        if 0 <= index < len(keys):
+            root.remove(keys[index])
+            tree = ET.ElementTree(root)
+            tree.write(self.config_path, encoding="utf-8", xml_declaration=True)
+
+            self._api_keys.pop(index)
+
+    def list_keys(self) -> List[str]:
+        """List all API keys"""
+        return self._api_keys.copy()

config/api_keys.xml

@@ -0,0 +1,2 @@
+<?xml version='1.0' encoding='utf-8'?>
+<api_keys><key>33cbbd76-bdb4-4d28-bc65-38c56dca3768</key><key>7e5ab17a-ec08-4037-8b30-186e86d8595a</key><key>637b9327-cfef-4808-bdeb-3d83e8ecca1b</key><key>82651d96-5d2c-4387-886f-70d501865994</key></api_keys>

config/constants.py

@@ -0,0 +1,96 @@
+# API endpoints
+import json
+
+from config.models import ModelID
+
+DEFAULT_API_ACCOUNT_EXPIRATION_SECONDS = 4 * 24 * 60 * 60
+
+ENCRYPTION_KEY = "1923a821"
+BASE_URL = "https://server.codeium.com"
+API_URL = "https://api.codeium.com"
+INFERENCE_URL = "https://inference.codeium.com"
+
+# API keys and identifiers
+WINDSURF_ID = "3GUryQ7ldAeKEuD2obYnppsnmj58eP5u"
+
+# Application info
+APP_NAME = "windsurf"
+APP_VERSION = "1.30.0"
+DISPLAY_NAME = "Windsurf 1.94.0"
+APP_LANGUAGE = "en"
+
+HADWARE_INFO = json.dumps(
+    {
+        "NumSockets": 1,
+        "NumCores": 8,
+        "NumThreads": 16,
+        "VendorID": "GenuineIntel",
+        "Family": "6",
+        "Model": "158",
+        "ModelName": "Intel(R) Core(TM) i9-12900K CPU @ 3.60GHz",
+        "Memory": 34359738368,
+    }
+)
+SYSTEM_INFO = json.dumps(
+    {
+        "Os": "windows",
+        "Arch": "amd64",
+        "Version": "11",
+        "ProductName": "Windows 11 Pro",
+        "MajorVersionNumber": 11,
+        "MinorVersionNumber": 0,
+        "Build": "26100",
+    }
+)
+
+# HTTP headers
+DEFAULT_HEADERS = {
+    "User-Agent": "connect-go/1.16.2 (go1.23.2 X:nocoverageredesign)",
+    "Connect-Protocol-Version": "1",
+    "Accept-Encoding": "identity",
+    "Connection": "keep-alive",
+    "Keep-Alive": "timeout=120, max=10000"
+}
+
+REDIS_URL = "redis://localhost:6379"
+REDIS_PASSWORD = "$546a"
+JWT_SECRET_INFO = "0982d83c-969a-4a53-8243-9d215a2fe7a2"
+ALLOWED_HOSTS = ["*"]
+BLOCK_DURATION = 3600
+OPTIONS_DURATION = 600
+THREE_MIN_LIMIT = 90
+HOURLY_LIMIT = 550
+BLOCK_LIMIT = 600
+MAX_UPLOAD_SIZE = 1048576 * 100  # 100 MB
+MAX_REQUEST_SIZE = 1048576 * 8  # 8 MB
+
+# Model mappings can also be placed here if applicable
+MODEL_MAPPING = {
+    # OpenAI Models
+    "gpt-3.5-turbo": ModelID.MODEL_CHAT_3_5_TURBO,
+    "gpt-4": ModelID.MODEL_CHAT_GPT_4,
+    "gpt-4o": ModelID.MODEL_CHAT_GPT_4O_2024_08_06,
+    "gpt-4o-2024-08-06": ModelID.MODEL_CHAT_GPT_4O_2024_08_06,
+    "gpt-4o-mini-2024-07-18": ModelID.MODEL_CHAT_GPT_4O_MINI_2024_07_18,
+    "gpt-4o-mini": ModelID.MODEL_CHAT_GPT_4O_MINI_2024_07_18,
+    "gpt-4-turbo-preview": ModelID.MODEL_CHAT_GPT_4_1106_PREVIEW,
+    # Claude Models
+    "claude-3-opus-20240229": ModelID.MODEL_CLAUDE_3_OPUS_20240229,
+    "claude-3-opus": ModelID.MODEL_CLAUDE_3_OPUS_20240229,
+    # "claude-3-sonnet-20240229": ModelID.MODEL_CLAUDE_3_SONNET_20240229,
+    "claude-3.5-sonnet-20240620": ModelID.MODEL_CLAUDE_3_5_SONNET_20240620,
+    "claude-3.5-sonnet-20241022": ModelID.MODEL_CLAUDE_3_5_SONNET_20241022,
+    "claude-3.5-sonnet": ModelID.MODEL_CLAUDE_3_5_SONNET_20241022,
+    "claude-3.5-haiku": ModelID.MODEL_CLAUDE_3_5_HAIKU_20241022,
+    "claude-3-haiku": ModelID.MODEL_CLAUDE_3_HAIKU_20240307,
+    "claude": ModelID.MODEL_CLAUDE_3_5_SONNET_20241022,
+    # O1 Models
+    "o1-mini": ModelID.MODEL_CHAT_O1_MINI,
+    "o1-preview": ModelID.MODEL_CHAT_O1_PREVIEW,
+    # "o1": ModelID.MODEL_CHAT_O1,
+}
+
+# Authorization keys for API access
+AUTH_KEYS = [
+    "sk-upuyyds"
+]

config/models.py

@@ -0,0 +1,93 @@
+from enum import Enum
+
+
+class ModelID(Enum):
+    MODEL_UNSPECIFIED = 0
+    MODEL_EMBED_6591 = 20
+    MODEL_8341 = 33
+    MODEL_8528 = 42
+    MODEL_9024 = 41
+    MODEL_14602 = 112
+    MODEL_15133 = 115
+    MODEL_15302 = 119
+    MODEL_15335 = 121
+    MODEL_15336 = 122
+    MODEL_15931 = 167
+    MODEL_QUERY_9905 = 48
+    MODEL_QUERY_11791 = 66
+    MODEL_CHAT_11120 = 57
+    MODEL_CHAT_11121 = 58
+    MODEL_CHAT_12119 = 70
+    MODEL_CHAT_12121 = 69
+    MODEL_CHAT_12437 = 74
+    MODEL_CHAT_12491 = 76
+    MODEL_CHAT_12623 = 78
+    MODEL_CHAT_12950 = 79
+    MODEL_CHAT_12968 = 101
+    MODEL_CHAT_13404 = 102
+    MODEL_CHAT_13566 = 103
+    MODEL_CHAT_13930 = 108
+    MODEL_CHAT_14255 = 110
+    MODEL_CHAT_14256 = 111
+    MODEL_CHAT_14942 = 114
+    MODEL_CHAT_15305 = 120
+    MODEL_CHAT_15600 = 123
+    MODEL_CHAT_16718 = 175
+    MODEL_CHAT_15729 = 168
+    MODEL_CHAT_16579 = 173
+    MODEL_CHAT_16579_CRUSOE = 174
+    MODEL_DRAFT_11408 = 65
+    MODEL_DRAFT_CHAT_11883 = 67
+    MODEL_DRAFT_CHAT_12196 = 72
+    MODEL_DRAFT_CHAT_12413 = 73
+    MODEL_DRAFT_CHAT_13175 = 104
+    MODEL_CHAT_3_5_TURBO = 28
+    MODEL_CHAT_GPT_4 = 30
+    MODEL_CHAT_GPT_4_1106_PREVIEW = 37
+    MODEL_TEXT_EMBEDDING_OPENAI_ADA = 91
+    MODEL_TEXT_EMBEDDING_OPENAI_3_SMALL = 163
+    MODEL_TEXT_EMBEDDING_OPENAI_3_LARGE = 164
+    MODEL_CHAT_GPT_4O_2024_05_13 = 71
+    MODEL_CHAT_GPT_4O_2024_08_06 = 109
+    MODEL_CHAT_GPT_4O_MINI_2024_07_18 = 113
+    MODEL_CHAT_O1_PREVIEW = 117
+    MODEL_CHAT_O1_MINI = 118
+    MODEL_CHAT_O1 = 170
+    MODEL_GOOGLE_GEMINI_1_0_PRO = 61
+    MODEL_GOOGLE_GEMINI_1_5_PRO = 62
+    MODEL_CLAUDE_3_OPUS_20240229 = 63
+    MODEL_CLAUDE_3_SONNET_20240229 = 64
+    MODEL_CLAUDE_3_5_SONNET_20240620 = 80
+    MODEL_CLAUDE_3_5_SONNET_20241022 = 166
+    MODEL_CLAUDE_3_5_HAIKU_20241022 = 171
+    MODEL_CLAUDE_3_HAIKU_20240307 = 172
+    MODEL_TOGETHERAI_TEXT_EMBEDDING_M2_BERT = 81
+    MODEL_TOGETHERAI_LLAMA_3_1_8B_INSTRUCT = 165
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_M2_BERT = 82
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_UAE_CODE = 83
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_BGE = 84
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_BLADE = 85
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_ARCTIC_LARGE = 86
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_E5_BASE = 87
+    MODEL_HUGGING_FACE_TEXT_EMBEDDING_MXBAI = 88
+    MODEL_LLAMA_3_1_8B_INSTRUCT = 106
+    MODEL_LLAMA_3_1_70B_INSTRUCT = 107
+    MODEL_LLAMA_3_1_405B_INSTRUCT = 105
+    MODEL_LLAMA_3_1_70B_INSTRUCT_LONG_CONTEXT = 116
+    MODEL_NOMIC_TEXT_EMBEDDING_V1 = 89
+    MODEL_NOMIC_TEXT_EMBEDDING_V1_5 = 90
+    MODEL_MISTRAL_7B = 77
+    MODEL_SALESFORCE_EMBEDDING_2R = 99
+    MODEL_TEI_BGE_M3 = 92
+    MODEL_TEI_NOMIC_EMBED_TEXT_V1 = 93
+    MODEL_TEI_INTFLOAT_E5_LARGE_INSTRUCT = 94
+    MODEL_TEI_SNOWFLAKE_ARCTIC_EMBED_L = 95
+    MODEL_TEI_UAE_CODE_LARGE_V1 = 96
+    MODEL_TEI_B1ADE = 97
+    MODEL_TEI_WHEREISAI_UAE_LARGE_V1 = 98
+    MODEL_TEI_WHEREISAI_UAE_CODE_LARGE_V1 = 100
+    MODEL_OPENAI_COMPATIBLE = 200
+    MODEL_ANTHROPIC_COMPATIBLE = 201
+    MODEL_VERTEX_COMPATIBLE = 202
+    MODEL_BEDROCK_COMPATIBLE = 203
+    MODEL_AZURE_COMPATIBLE = 204

docker.txt

@@ -0,0 +1,9 @@
+docker run -d \
+  -p 127.0.0.1:9000:8080 \
+  -v open-webui:/app/backend/data \
+  -e OPENAI_API_BASE_URLS="http://host.docker.internal:8000/v1" \
+  -e OPENAI_API_KEYS="Ga_test_key1" \
+  --add-host=host.docker.internal:host-gateway \
+  --name open-webui \
+  --restart unless-stopped \
+  ghcr.io/open-webui/open-webui:main

gen_account.py

@@ -0,0 +1,232 @@
+from time import time
+import httpx
+import asyncio
+from faker import Faker
+import random
+import string
+import base64
+import json
+from datetime import datetime
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import print as rprint
+from typing import List
+
+from auth.register import Registration
+from config.api_keys import APIKeyManager
+from protos import request_pb2, response_pb2
+
+console = Console()
+
+async def generate_firebase_client():
+    # Create heartbeat data with current date
+    heartbeat_data = {
+        "version": 2,
+        "heartbeats": [{
+            "agent": "fire-core/0.10.2 fire-core-esm2017/0.10.2 fire-js/ fire-auth/1.7.2 fire-auth-esm2017/1.7.2 fire-js-all-app/10.11.1",
+            "dates": [datetime.now().strftime("%Y-%m-%d")]
+        }]
+    }
+    return base64.b64encode(json.dumps(heartbeat_data).encode()).decode()
+
+async def generate_account():
+    faker = Faker()
+    
+    # Generate random email and password
+    email = faker.email(safe=True, domain='outlook.com')
+    password = ''.join(random.choices(string.ascii_letters + string.digits, k=random.randint(9, 15)))
+    
+    firebase_client = await generate_firebase_client()
+    
+    async with httpx.AsyncClient() as client:
+        # Step 1: Firebase Sign Up
+        signup_response = await client.post(
+            'https://identitytoolkit.googleapis.com/v1/accounts:signUp',
+            params={'key': 'AIzaSyDsOl-1XpT5err0Tcnx8FFod1H8gVGIycY'},
+            headers={
+                'X-Firebase-Client': firebase_client,
+                'Content-Type': 'application/json',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36'
+            },
+            json={
+                'returnSecureToken': True,
+                'email': email,
+                'password': password,
+                'clientType': 'CLIENT_TYPE_WEB'
+            }
+        )
+        
+        id_token = signup_response.json()['idToken']
+
+        # Step 2: Get Current User
+        current_user = request_pb2.CurrentUser()
+        current_user.jwt = id_token
+        current_user.f1 = 1
+        current_user.f2 = 1
+
+        current_user_response = await client.post(      
+            'https://web-backend.codeium.com/exa.seat_management_pb.SeatManagementService/GetCurrentUser',
+            headers={
+                'Content-Type': 'application/proto',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36',
+                'Accept-Language': 'en',
+                'Sec-Ch-Ua-Platform': '"Windows"',
+                'Sec-Ch-Ua': '"Not?A_Brand";v="99", "Chromium";v="130"',
+                'Sec-Ch-Ua-Mobile': '?0',
+                'Connect-Protocol-Version': '1',
+                'Accept': '*/*',
+                'Origin': 'https://codeium.com',
+                'Sec-Fetch-Site': 'same-site',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Dest': 'empty',
+                'Referer': 'https://codeium.com/',
+                "X-Auth-Token": id_token,
+                'Accept-Encoding': 'gzip, deflate, br',
+            },
+            content=current_user.SerializeToString()
+        )
+        assert current_user_response.status_code == 200
+        response_proto = response_pb2.CurrentUserResponse()
+        response_proto.ParseFromString(current_user_response.content)
+        console.print(Panel(f"[bold green]User Created[/bold green]\nName: {response_proto.user.name}\nStatus: {response_proto.status.status}"))
+
+        # Step 3: Get Preapproval For User
+        get_preapproval_for_user = request_pb2.GetPreapprovalForUser()
+        get_preapproval_for_user.jwt = id_token
+        get_preapproval_for_user_response = await client.post(
+            'https://web-backend.codeium.com/exa.seat_management_pb.SeatManagementService/GetPreapprovalForUser',
+            headers={
+                'Content-Type': 'application/proto',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36',
+                'Accept-Language': 'en',
+                'Sec-Ch-Ua-Platform': '"Windows"',
+                'Sec-Ch-Ua': '"Not?A_Brand";v="99", "Chromium";v="130"',
+                'Sec-Ch-Ua-Mobile': '?0',
+                'Connect-Protocol-Version': '1',
+                'Accept': '*/*',
+                'Origin': 'https://codeium.com',
+                'Sec-Fetch-Site': 'same-site',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Dest': 'empty',
+                'Referer': 'https://codeium.com/',
+                'Accept-Encoding': 'gzip, deflate, br',
+                "X-Auth-Token": id_token,
+                'Priority': 'u=1, i'
+            },
+            content=get_preapproval_for_user.SerializeToString()
+        )
+        assert get_preapproval_for_user_response.status_code == 200
+        
+        # Step 4: Update Name using Protobuf
+        change_name = request_pb2.ChangeName()
+        change_name.jwt = id_token
+        change_name.name = faker.name()
+        
+        name_response = await client.post(
+            'https://web-backend.codeium.com/exa.seat_management_pb.SeatManagementService/UpdateName',
+            headers={
+                'Content-Type': 'application/proto',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36',
+                'Accept-Language': 'en',
+                'Sec-Ch-Ua-Platform': '"Windows"',
+                'Sec-Ch-Ua': '"Not?A_Brand";v="99", "Chromium";v="130"',
+                'Sec-Ch-Ua-Mobile': '?0',
+                'Connect-Protocol-Version': '1',
+                'Accept': '*/*',
+                'Origin': 'https://codeium.com',
+                'Sec-Fetch-Site': 'same-site',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Dest': 'empty',
+                'Referer': 'https://codeium.com/',
+                'Accept-Encoding': 'gzip, deflate, br',
+                'Priority': 'u=1, i'
+            },
+            content=change_name.SerializeToString()
+        )
+        
+        return {
+            'email': email,
+            'password': password,
+            'id_token': id_token,
+            'name_response': name_response.status_code
+        }
+
+async def generate_multiple_accounts(num_accounts: int):
+    tasks = []
+    for _ in range(num_accounts):
+        tasks.append(generate_account())
+    
+    results = await asyncio.gather(*tasks)
+    return results
+
+async def main():
+    # 获取命令行参数，默认创建3个账号
+    num_accounts = 3
+    
+    with console.status(f"[bold green]Generating {num_accounts} accounts...", spinner="dots"):
+        results = await generate_multiple_accounts(num_accounts)
+    
+    for result in results:
+        id_token = result['id_token']
+        email = result['email']
+        name_response = result['name_response']
+        
+        if name_response != 200:
+            console.print(f"[bold red]Failed to update name. Status code: {name_response}[/bold red]")
+            continue
+
+        key_manager = APIKeyManager()
+        
+        with console.status("[bold green]Registering user...", spinner="dots"):
+            api_key = await Registration.register_user(id_token.strip())
+        
+        # Add GetCurrentUser call after registration
+        async with httpx.AsyncClient() as client:
+            current_user = request_pb2.CurrentUser()
+            current_user.jwt = id_token
+            current_user.f1 = 1
+            current_user.f2 = 1
+
+            current_user_response = await client.post(      
+                'https://web-backend.codeium.com/exa.seat_management_pb.SeatManagementService/GetCurrentUser',
+                headers={
+                    'Content-Type': 'application/proto',
+                    'X-Auth-Token': id_token,
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.70 Safari/537.36',
+                    'Accept-Language': 'en',
+                    'Sec-Ch-Ua-Platform': '"Windows"',
+                    'Sec-Ch-Ua': '"Not?A_Brand";v="99", "Chromium";v="130"',
+                    'Sec-Ch-Ua-Mobile': '?0',
+                    'Connect-Protocol-Version': '1',
+                    'Accept': '*/*',
+                    'Origin': 'https://codeium.com',
+                    'Sec-Fetch-Site': 'same-site',
+                    'Sec-Fetch-Mode': 'cors',
+                    'Sec-Fetch-Dest': 'empty',
+                    'Referer': 'https://codeium.com/',
+                    'Accept-Encoding': 'gzip, deflate, br',
+                },
+                content=current_user.SerializeToString()
+            )
+            
+            response_proto = response_pb2.CurrentUserResponse()
+            response_proto.ParseFromString(current_user_response.content)
+        
+        key_manager.add_key(api_key)
+        
+        # Update table to include password
+        table = Table(title=f"Registration Results - {email}")
+        table.add_column("Field", style="cyan")
+        table.add_column("Value", style="green")
+        
+        table.add_row("Email", email)
+        table.add_row("Password", result['password'])
+        table.add_row("API Key", api_key)
+        table.add_row("Status", str(response_proto.status.status))
+        
+        console.print(table)
+        console.print("\n")  # Add a blank line between tables
+
+if __name__ == "__main__":
+    asyncio.run(main())

init_pool.py

@@ -0,0 +1,21 @@
+from managers.global_chat_manager import GlobalChatManager
+import uvicorn
+import signal
+import sys
+import multiprocessing
+import asyncio
+from rich.console import Console
+
+console = Console()
+
+async def init_chat_queue():
+    # 初始化全局chat manager
+    chat_manager = GlobalChatManager(
+        console=console,
+        queue_type="deque",
+    )
+    
+    await chat_manager.initialize_queue()
+
+if __name__ == "__main__":
+    asyncio.run(init_chat_queue())

main.py

@@ -0,0 +1,119 @@
+from managers.chat_manager import ChatManager
+from api.telemetry import TelemetryAPI
+from config.api_keys import APIKeyManager
+from config.models import ModelID
+from auth.register import Registration
+from auth.login import open_auth_url
+from api.chat.chat_api import ChatAPI, ChatConfig
+
+import urllib3
+import asyncio
+
+urllib3.disable_warnings()
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+console = Console()
+
+
+def select_api_key(key_manager: APIKeyManager) -> str:
+    """Let user select an API key from available keys"""
+    keys = key_manager.list_keys()
+    if not keys:
+        return None
+
+    console.print("\n[bold cyan]Available API keys:[/]")
+    for i, key in enumerate(keys):
+        console.print(f"[green]{i + 1}[/]. {key}")
+
+    while True:
+        try:
+            choice = int(input("\nSelect API key (number) or 0 for new login: "))
+            if choice == 0:
+                return None
+            if 1 <= choice <= len(keys):
+                return keys[choice - 1]
+        except ValueError:
+            return keys[0]
+        print("Invalid selection. Please try again.")
+
+
+async def main():
+    key_manager = APIKeyManager()
+    chat_manager = ChatManager()
+    api_key = select_api_key(key_manager)
+
+    # If no API key selected or available, do registration
+    if api_key is None:
+        _ = open_auth_url()
+        firebase_token = input("Please paste your firebase token: ")
+        api_key = await Registration.register_user(firebase_token.strip())
+        key_manager.add_key(api_key)
+        print(f"Registered successfully. API key: {api_key}")
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task("Initializing Chat API...", total=None)
+        tele = TelemetryAPI(api_key=api_key)
+        await tele.do_telemetry()
+
+        await chat_manager.add_chat(api_key)
+
+        progress.stop()
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            _ = progress.add_task("Sending message...", total=None)
+
+            config = ChatConfig(
+                model_id=ModelID.MODEL_CLAUDE_3_OPUS_20240229,
+                temperature=0.7,
+                max_tokens=8192,
+            )
+
+            message = [
+                {"role": "user", "content": "1234567890"},
+                {"role": "assistant", "content": "1234567890"},
+                {"role": "user", "content": "1234567890"},
+                {"role": "assistant", "content": "1234567890"},
+                {"role": "user", "content": "1234567890"},
+                {"role": "assistant", "content": "1234567890"},
+                {"role": "user", "content": "1234567890"},
+                {"role": "assistant", "content": "1234567890"},
+                {"role": "user", "content": "1234567890"},
+                {"role": "assistant", "content": "1234567890"},
+                {"role": "user", "content": "tell me a joke"},
+            ]
+            first_chunk = True
+            chat = await chat_manager.get_chat()
+
+            tokens = 0
+
+            async for chunk, token_count in chat.send_message(
+                messages=message,
+                config=config,
+                system_prompt="You are a helpful assistant.",
+                stream=True,
+            ):
+                if first_chunk:
+                    progress.stop()
+                    first_chunk = False
+                    console.print("=" * 20)
+                if chunk:
+                    console.print(
+                        chunk, end="", markup=True, highlight=True, emoji=True
+                    )
+                    tokens += token_count
+
+            console.print(f"\n[bold green]Tokens: {tokens}[/]")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

managers/chat_manager.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from managers.queue.base import ChatQueueBase
+from managers.queue.deque_queue import DequeQueue
+
+from api.chat.chat_api import ChatAPI
+
+
+class ChatManager:
+    def __init__(self, queue_type: str = "deque", **kwargs):
+        self.queue: ChatQueueBase = self._create_queue(queue_type, **kwargs)
+
+    def _create_queue(self, queue_type: str, **kwargs) -> ChatQueueBase:
+        queue_types = {
+            "deque": DequeQueue,
+        }
+
+        if queue_type not in queue_types:
+            raise ValueError(f"Unsupported queue type: {queue_type}")
+
+        return queue_types[queue_type](**kwargs)
+
+    async def add_chat(self, api_key: str):
+        """添加一个新的chat实例到队列"""
+        await self.queue.add(api_key)
+
+    async def get_chat(self) -> Optional[ChatAPI]:
+        """获取队列中的下一个chat实例"""
+        return await self.queue.get()
+
+    async def length(self) -> int:
+        """获取队列长度"""
+        return await self.queue.length()

managers/global_chat_manager.py

@@ -0,0 +1,106 @@
+from typing import Optional, List
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from managers.chat_manager import ChatManager
+from api.telemetry import TelemetryAPI
+from config.api_keys import APIKeyManager
+
+
+class GlobalChatManager:
+    """
+    全局聊天管理器
+    专注于管理分布式队列(Redis/RabbitMQ)中的API密钥
+    """
+
+    _instance: Optional["GlobalChatManager"] = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, console: Console, queue_type: str = "deque", **kwargs):
+        # 防止重复初始化
+        if hasattr(self, "initialized"):
+            return
+
+        self.console = console
+        self.queue_type = queue_type
+
+        if queue_type != "deque":
+            raise ValueError("GlobalChatManager only supports 'deque' queue type")
+
+        self.chat_manager = ChatManager(queue_type=queue_type, **kwargs)
+        self.key_manager = APIKeyManager()
+        self.initialized = True
+
+    async def _register_single_key(self, api_key: str) -> None:
+        """注册单个API key到队列"""
+        try:
+            await self.chat_manager.add_chat(api_key)
+            await self._send_registration_signals(api_key)
+            self.console.log(
+                f"[bold green]✓[/] API key registered successfully: {api_key[:8]}..."
+            )
+        except Exception as e:
+            self.console.log(
+                f"[bold red]✗[/] Failed to register API key {api_key[:8]}\n"
+                f"   Error: {str(e)}"
+            )
+            raise
+        finally:
+            self.console.log("─" * 80)
+
+    async def _send_registration_signals(self, api_key: str) -> None:
+        """发送注册相关的信号"""
+        self.console.log(
+            f"[bold yellow]⚡[/] Sending registration signals for {api_key[:8]}..."
+        )
+        await TelemetryAPI(api_key=api_key).do_telemetry()
+
+    async def initialize_queue(self, api_keys: List[str] = None) -> None:
+        """初始化分布式队列"""
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console,
+        ) as progress:
+            task = progress.add_task(
+                f"[bold blue]Initializing {self.queue_type.upper()} queue...[/]", 
+                total=None
+            )
+
+            # 如果没有提供API keys，则从配置中读取
+            if not api_keys:
+                api_keys = self.key_manager.list_keys()
+                # 对API keys进行去重
+                api_keys = list(dict.fromkeys(api_keys))
+
+            if not api_keys:
+                raise ValueError("No API keys provided or found in configuration")
+
+            # 注册所有API keys
+            for api_key in api_keys:
+                await self._register_single_key(api_key)
+                progress.update(task, advance=1)
+
+            # 验证队列状态
+            queue_size = await self.chat_manager.length()
+            if queue_size == 0:
+                raise RuntimeError(f"Failed to initialize {self.queue_type} queue")
+
+            self.console.log(f"号池已初始化，当前容量: {queue_size} 个API密钥")
+
+            progress.update(
+                task,
+                description=f"{self.queue_type.upper()} queue initialized with {queue_size} keys",
+            )
+
+    async def add_api_key(self, api_key: str) -> None:
+        """添加新的API key到队列"""
+        await self._register_single_key(api_key)
+
+    async def get_queue_size(self) -> int:
+        """获取当前队列大小"""
+        return await self.chat_manager.length()

managers/queue/base.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+from api.chat.chat_api import ChatAPI
+
+class ChatQueueBase(ABC):
+    @abstractmethod
+    async def add(self, api_key: str) -> None:
+        pass
+    
+    @abstractmethod
+    async def get(self) -> Optional[ChatAPI]:
+        pass
+    
+    @abstractmethod
+    async def length(self) -> int:
+        pass 

managers/queue/deque_queue.py

@@ -0,0 +1,21 @@
+from collections import deque
+from typing import Optional
+from api.chat.chat_api import ChatAPI
+from .base import ChatQueueBase
+
+class DequeQueue(ChatQueueBase):
+    def __init__(self):
+        self.queue = deque()
+        
+    async def add(self, api_key: str) -> None:
+        self.queue.append(ChatAPI(api_key=api_key))
+        
+    async def get(self) -> Optional[ChatAPI]:
+        if not self.queue:
+            return None
+        chat = self.queue.popleft()
+        self.queue.append(chat)
+        return chat
+        
+    async def length(self) -> int:
+        return len(self.queue)