From 2e531d227c5672c169c26251368c925abb775c80 Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <hlohaus@users.noreply.github.com>
Date: Mon, 6 Jan 2025 23:20:29 +0100
Subject: [PATCH 1/5] Fix invalid escape in requests module Add none auth with
 OpenAI using nodriver Fix missing 1 required positional argument: 'cls'
 Update count tokens in GUI Fix streaming example in requests guide Remove
 ChatGptEs as default model

---
 docs/requests.md                      |  41 +++----
 g4f/Provider/DDG.py                   |   2 +-
 g4f/Provider/needs_auth/OpenaiChat.py |  42 ++++----
 g4f/Provider/openai/har_file.py       |   2 +-
 g4f/api/__init__.py                   |   4 +-
 g4f/client/__init__.py                |  39 +++++--
 g4f/client/stubs.py                   |   7 +-
 g4f/gui/client/index.html             |   3 +-
 g4f/gui/client/static/js/chat.v1.js   | 150 ++++++++++++++++----------
 g4f/gui/server/api.py                 |   4 +-
 g4f/models.py                         |   5 +-
 g4f/providers/base_provider.py        |  58 +++++++---
 g4f/providers/response.py             |   3 +
 g4f/providers/retry_provider.py       |  31 +++---
 g4f/requests/__init__.py              |   5 +-
 g4f/tools/files.py                    |   4 +-
 16 files changed, 238 insertions(+), 162 deletions(-)

diff --git a/docs/requests.md b/docs/requests.md
index e185cec54b2..8de78963154 100644
--- a/docs/requests.md
+++ b/docs/requests.md
@@ -73,7 +73,6 @@ For scenarios where you want to receive partial responses or stream data as it's
 ```python
 import requests
 import json
-from queue import Queue
 
 def fetch_response(url, model, messages):
     """
@@ -87,7 +86,7 @@ def fetch_response(url, model, messages):
     Returns:
         requests.Response: The streamed response object.
     """
-    payload = {"model": model, "messages": messages}
+    payload = {"model": model, "messages": messages, "stream": True}
     headers = {
         "Content-Type": "application/json",
         "Accept": "text/event-stream",
@@ -99,7 +98,7 @@ def fetch_response(url, model, messages):
         )
     return response
 
-def process_stream(response, output_queue):
+def process_stream(response):
     """
     Processes the streamed response and extracts messages.
 
@@ -111,37 +110,31 @@ def process_stream(response, output_queue):
         if line:
             line = line.decode("utf-8")
             if line == "data: [DONE]":
+                print("\n\nConversation completed.")
                 break
             if line.startswith("data: "):
                 try:
                     data = json.loads(line[6:])
-                    message = data.get("message", "")
+                    message = data.get("choices", [{}])[0].get("delta", {}).get("content")
                     if message:
-                        output_queue.put(message)
-                except json.JSONDecodeError:
+                        print(message, end="", flush=True)
+                except json.JSONDecodeError as e:
+                    print(f"Error decoding JSON: {e}")
                     continue
 
 # Define the API endpoint
-chat_url = "http://localhost/v1/chat/completions"
+chat_url = "http://localhost:8080/v1/chat/completions"
 
 # Define the payload
-model = "gpt-4o"
-messages = [{"role": "system", "content": "Hello, how are you?"}]
-
-# Initialize the queue to store output messages
-output_queue = Queue()
+model = ""
+messages = [{"role": "user", "content": "Hello, how are you?"}]
 
 try:
     # Fetch the streamed response
     response = fetch_response(chat_url, model, messages)
     
     # Process the streamed response
-    process_stream(response, output_queue)
-    
-    # Retrieve messages from the queue
-    while not output_queue.empty():
-        msg = output_queue.get()
-        print(msg)
+    process_stream(response)
 
 except Exception as e:
     print(f"An error occurred: {e}")
@@ -150,23 +143,21 @@ except Exception as e:
 **Explanation:**
 - **`fetch_response` Function:**
   - Sends a POST request to the streaming chat completions endpoint with the specified model and messages.
-  - Sets the `Accept` header to `text/event-stream` to enable streaming.
+  - Sets `stream` parameter to `true` to enable streaming.
   - Raises an exception if the request fails.
 
 - **`process_stream` Function:**
   - Iterates over each line in the streamed response.
   - Decodes the line and checks for the termination signal `"data: [DONE]"`.
   - Parses lines that start with `"data: "` to extract the message content.
-  - Enqueues the extracted messages into `output_queue` for further processing.
 
 - **Main Execution:**
   - Defines the API endpoint, model, and messages.
-  - Initializes a `Queue` to store incoming messages.
   - Fetches and processes the streamed response.
-  - Retrieves and prints messages from the queue.
+  - Retrieves and prints messages.
 
 **Usage Tips:**
-- Ensure your local server supports streaming and the `Accept` header appropriately.
+- Ensure your local server supports streaming.
 - Adjust the `chat_url` if your local server runs on a different port or path.
 - Use threading or asynchronous programming for handling streams in real-time applications.
 
@@ -286,7 +277,7 @@ async def fetch_response_async(url, model, messages, output_queue):
         messages (list): A list of message dictionaries.
         output_queue (Queue): A queue to store the extracted messages.
     """
-    payload = {"model": model, "messages": messages}
+    payload = {"model": model, "messages": messages, "stream": True}
     headers = {
         "Content-Type": "application/json",
         "Accept": "text/event-stream",
@@ -305,7 +296,7 @@ async def fetch_response_async(url, model, messages, output_queue):
                 if decoded_line.startswith("data: "):
                     try:
                         data = json.loads(decoded_line[6:])
-                        message = data.get("message", "")
+                        message = data.get("choices", [{}])[0].get("delta", {}).get("content")
                         if message:
                             output_queue.put(message)
                     except json.JSONDecodeError:
diff --git a/g4f/Provider/DDG.py b/g4f/Provider/DDG.py
index 78e13568cdc..19ba747a868 100644
--- a/g4f/Provider/DDG.py
+++ b/g4f/Provider/DDG.py
@@ -73,7 +73,7 @@ async def create_async_generator(
             "Content-Type": "application/json",
         },
         cookies: dict = None,
-        max_retries: int = 3,
+        max_retries: int = 0,
         **kwargs
     ) -> AsyncResult:
         if cookies is None and conversation is not None:
diff --git a/g4f/Provider/needs_auth/OpenaiChat.py b/g4f/Provider/needs_auth/OpenaiChat.py
index 0fe7cafe7eb..72465ec2659 100644
--- a/g4f/Provider/needs_auth/OpenaiChat.py
+++ b/g4f/Provider/needs_auth/OpenaiChat.py
@@ -106,9 +106,8 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
 
     @classmethod
     async def on_auth_async(cls, **kwargs) -> AsyncIterator:
-        if cls.needs_auth:
-            async for chunk in cls.login():
-                yield chunk
+        async for chunk in cls.login():
+            yield chunk
         yield AuthResult(
             api_key=cls._api_key,
             cookies=cls._cookies or RequestConfig.cookies or {},
@@ -335,11 +334,11 @@ async def create_authed(
                         cls._update_request_args(auth_result, session)
                         await raise_for_status(response)
             else:
-                if cls._headers is None:
+                if cls._headers is None and getattr(auth_result, "cookies", None):
                     cls._create_request_args(auth_result.cookies, auth_result.headers)
-                    if not cls._set_api_key(auth_result.api_key):
-                        raise MissingAuthError("Access token is not valid")
-                async with session.get(cls.url, headers=auth_result.headers) as response:
+                if not cls._set_api_key(getattr(auth_result, "api_key", None)):
+                    raise MissingAuthError("Access token is not valid")
+                async with session.get(cls.url, headers=cls._headers) as response:
                     cls._update_request_args(auth_result, session)
                     await raise_for_status(response)
                 try:
@@ -349,9 +348,11 @@ async def create_authed(
                     debug.log(f"{e.__class__.__name__}: {e}")
             model = cls.get_model(model)
             if conversation is None:
-                conversation = Conversation(conversation_id, str(uuid.uuid4()))
+                conversation = Conversation(conversation_id, str(uuid.uuid4()), getattr(auth_result, "cookies", {}).get("oai-did"))
             else:
                 conversation = copy(conversation)
+            if getattr(auth_result, "cookies", {}).get("oai-did") != conversation.user_id:
+                conversation = Conversation(None, str(uuid.uuid4()))
             if cls._api_key is None:
                 auto_continue = False
             conversation.finish_reason = None
@@ -361,11 +362,11 @@ async def create_authed(
                     f"{cls.url}/backend-anon/sentinel/chat-requirements"
                     if cls._api_key is None else
                     f"{cls.url}/backend-api/sentinel/chat-requirements",
-                    json={"p": None if not getattr(auth_result, "proof_token") else get_requirements_token(auth_result.proof_token)},
+                    json={"p": None if not getattr(auth_result, "proof_token", None) else get_requirements_token(getattr(auth_result, "proof_token", None))},
                     headers=cls._headers
                 ) as response:
-                    if response.status == 401:
-                        cls._headers = cls._api_key = None
+                    if response.status in (401, 403):
+                        auth_result.reset()
                     else:
                         cls._update_request_args(auth_result, session)
                     await raise_for_status(response)
@@ -380,14 +381,13 @@ async def create_authed(
                 #     cls._set_api_key(auth_result.access_token)
                 #     if auth_result.arkose_token is None:
                 #         raise MissingAuthError("No arkose token found in .har file")
-
                 if "proofofwork" in chat_requirements:
-                    if auth_result.proof_token is None:
+                    if getattr(auth_result, "proof_token") is None:
                         auth_result.proof_token = get_config(auth_result.headers.get("user-agent"))
                     proofofwork = generate_proof_token(
                         **chat_requirements["proofofwork"],
-                        user_agent=auth_result.headers.get("user-agent"),
-                        proof_token=getattr(auth_result, "proof_token")
+                        user_agent=getattr(auth_result, "headers", {}).get("user-agent"),
+                        proof_token=getattr(auth_result, "proof_token", None)
                     )
                 [debug.log(text) for text in (
                     #f"Arkose: {'False' if not need_arkose else auth_result.arkose_token[:12]+'...'}",
@@ -434,7 +434,7 @@ async def create_authed(
                 #    headers["openai-sentinel-arkose-token"] = RequestConfig.arkose_token
                 if proofofwork is not None:
                     headers["openai-sentinel-proof-token"] = proofofwork
-                if need_turnstile and auth_result.turnstile_token is not None:
+                if need_turnstile and getattr(auth_result, "turnstile_token", None) is not None:
                     headers['openai-sentinel-turnstile-token'] = auth_result.turnstile_token
                 async with session.post(
                     f"{cls.url}/backend-anon/conversation"
@@ -653,7 +653,7 @@ def on_request(event: nodriver.cdp.network.RequestWillBeSent):
         await page.evaluate("document.getElementById('prompt-textarea').innerText = 'Hello'")
         await page.evaluate("document.querySelector('[data-testid=\"send-button\"]').click()")
         while True:
-            if cls._api_key is not None:
+            if cls._api_key is not None or not cls.needs_auth:
                 break
             body = await page.evaluate("JSON.stringify(window.__remixContext)")
             if body:
@@ -689,8 +689,9 @@ def _create_request_args(cls, cookies: Cookies = None, headers: dict = None, use
 
     @classmethod
     def _update_request_args(cls, auth_result: AuthResult, session: StreamSession):
-        for c in session.cookie_jar if hasattr(session, "cookie_jar") else session.cookies.jar:
-            auth_result.cookies[getattr(c, "key", getattr(c, "name", ""))] = c.value
+        if hasattr(auth_result, "cookies"):
+            for c in session.cookie_jar if hasattr(session, "cookie_jar") else session.cookies.jar:
+                auth_result.cookies[getattr(c, "key", getattr(c, "name", ""))] = c.value
         cls._update_cookie_header()
 
     @classmethod
@@ -717,12 +718,13 @@ class Conversation(JsonConversation):
     """
     Class to encapsulate response fields.
     """
-    def __init__(self, conversation_id: str = None, message_id: str = None, finish_reason: str = None, parent_message_id: str = None):
+    def __init__(self, conversation_id: str = None, message_id: str = None, user_id: str = None, finish_reason: str = None, parent_message_id: str = None):
         self.conversation_id = conversation_id
         self.message_id = message_id
         self.finish_reason = finish_reason
         self.is_recipient = False
         self.parent_message_id = message_id if parent_message_id is None else parent_message_id
+        self.user_id = user_id
 
 def get_cookies(
     urls: Optional[Iterator[str]] = None
diff --git a/g4f/Provider/openai/har_file.py b/g4f/Provider/openai/har_file.py
index 989a9efc44a..2acd34fbad7 100644
--- a/g4f/Provider/openai/har_file.py
+++ b/g4f/Provider/openai/har_file.py
@@ -32,7 +32,7 @@ class RequestConfig:
     arkose_token: str = None
     headers: dict = {}
     cookies: dict = {}
-    data_build: str = "prod-697873d7e78bb14df6e13af3a91fa237cc4db415"
+    data_build: str = "prod-db8e51e8414e068257091cf5003a62d3d4ee6ed0"
 
 class arkReq:
     def __init__(self, arkURL, arkBx, arkHeader, arkBody, arkCookies, userAgent):
diff --git a/g4f/api/__init__.py b/g4f/api/__init__.py
index 73a9f64e64e..d4a3bd76a77 100644
--- a/g4f/api/__init__.py
+++ b/g4f/api/__init__.py
@@ -432,7 +432,7 @@ def upload_cookies(files: List[UploadFile]):
             HTTP_404_NOT_FOUND: {"model": ErrorResponseModel},
         })
         def read_files(request: Request, bucket_id: str, delete_files: bool = True, refine_chunks_with_spacy: bool = False):
-            bucket_dir = os.path.join(get_cookies_dir(), bucket_id)
+            bucket_dir = os.path.join(get_cookies_dir(), "buckets", bucket_id)
             event_stream = "text/event-stream" in request.headers.get("accept", "")
             if not os.path.isdir(bucket_dir):
                 return ErrorResponse.from_message("Bucket dir not found", 404)
@@ -443,7 +443,7 @@ def read_files(request: Request, bucket_id: str, delete_files: bool = True, refi
             HTTP_200_OK: {"model": UploadResponseModel}
         })
         def upload_files(bucket_id: str, files: List[UploadFile]):
-            bucket_dir = os.path.join(get_cookies_dir(), bucket_id)
+            bucket_dir = os.path.join(get_cookies_dir(), "buckets", bucket_id)
             os.makedirs(bucket_dir, exist_ok=True)
             filenames = []
             for file in files:
diff --git a/g4f/client/__init__.py b/g4f/client/__init__.py
index cca85db4de1..cd2a43feee0 100644
--- a/g4f/client/__init__.py
+++ b/g4f/client/__init__.py
@@ -63,7 +63,7 @@ def iter_response(
             tool_calls = chunk.get_list()
             continue
         elif isinstance(chunk, Usage):
-            usage = chunk.get_dict()
+            usage = chunk
             continue
         elif isinstance(chunk, BaseConversation):
             yield chunk
@@ -90,19 +90,23 @@ def iter_response(
 
         idx += 1
     if usage is None:
-        usage = Usage(prompt_tokens=0, completion_tokens=idx, total_tokens=idx).get_dict()
+        usage = Usage(prompt_tokens=0, completion_tokens=idx, total_tokens=idx)
+
     finish_reason = "stop" if finish_reason is None else finish_reason
 
     if stream:
-        yield ChatCompletionChunk.model_construct(None, finish_reason, completion_id, int(time.time()))
+        yield ChatCompletionChunk.model_construct(
+            None, finish_reason, completion_id, int(time.time()),
+            usage=usage.get_dict()
+        )
     else:
         if response_format is not None and "type" in response_format:
             if response_format["type"] == "json_object":
                 content = filter_json(content)
-        yield ChatCompletion.model_construct(content, finish_reason, completion_id, int(time.time()), **filter_none(
-            tool_calls=tool_calls,
-            usage=usage
-        ))
+        yield ChatCompletion.model_construct(
+            content, finish_reason, completion_id, int(time.time()),
+            usage=usage.get_dict(), **filter_none(tool_calls=tool_calls)
+        )
 
 # Synchronous iter_append_model_and_provider function
 def iter_append_model_and_provider(response: ChatCompletionResponseType, last_model: str, last_provider: ProviderType) -> ChatCompletionResponseType:
@@ -126,6 +130,8 @@ async def async_iter_response(
     finish_reason = None
     completion_id = ''.join(random.choices(string.ascii_letters + string.digits, k=28))
     idx = 0
+    tool_calls = None
+    usage = None
 
     try:
         async for chunk in response:
@@ -135,6 +141,12 @@ async def async_iter_response(
             elif isinstance(chunk, BaseConversation):
                 yield chunk
                 continue
+            elif isinstance(chunk, ToolCalls):
+                tool_calls = chunk.get_list()
+                continue
+            elif isinstance(chunk, Usage):
+                usage = chunk
+                continue
             elif isinstance(chunk, SynthesizeData) or not chunk:
                 continue
 
@@ -158,13 +170,22 @@ async def async_iter_response(
 
         finish_reason = "stop" if finish_reason is None else finish_reason
 
+        if usage is None:
+            usage = Usage(prompt_tokens=0, completion_tokens=idx, total_tokens=idx)
+
         if stream:
-            yield ChatCompletionChunk.model_construct(None, finish_reason, completion_id, int(time.time()))
+            yield ChatCompletionChunk.model_construct(
+                None, finish_reason, completion_id, int(time.time()),
+                usage=usage.get_dict()
+            )
         else:
             if response_format is not None and "type" in response_format:
                 if response_format["type"] == "json_object":
                     content = filter_json(content)
-            yield ChatCompletion.model_construct(content, finish_reason, completion_id, int(time.time()))
+            yield ChatCompletion.model_construct(
+                content, finish_reason, completion_id, int(time.time()),
+                usage=usage.get_dict(), **filter_none(tool_calls=tool_calls)
+            )
     finally:
         await safe_aclose(response)
 
diff --git a/g4f/client/stubs.py b/g4f/client/stubs.py
index 8f3425de9b4..f1d07fe703d 100644
--- a/g4f/client/stubs.py
+++ b/g4f/client/stubs.py
@@ -36,6 +36,7 @@ class ChatCompletionChunk(BaseModel):
     model: str
     provider: Optional[str]
     choices: List[ChatCompletionDeltaChoice]
+    usage: Usage
 
     @classmethod
     def model_construct(
@@ -43,7 +44,8 @@ def model_construct(
         content: str,
         finish_reason: str,
         completion_id: str = None,
-        created: int = None
+        created: int = None,
+        usage: Usage = None
     ):
         return super().model_construct(
             id=f"chatcmpl-{completion_id}" if completion_id else None,
@@ -54,7 +56,8 @@ def model_construct(
             choices=[ChatCompletionDeltaChoice.model_construct(
                 ChatCompletionDelta.model_construct(content),
                 finish_reason
-            )]
+            )],
+            **filter_none(usage=usage)
         )
 
 class ChatCompletionMessage(BaseModel):
diff --git a/g4f/gui/client/index.html b/g4f/gui/client/index.html
index b06da6fbada..09f27063559 100644
--- a/g4f/gui/client/index.html
+++ b/g4f/gui/client/index.html
@@ -36,6 +36,7 @@
         import llamaTokenizer from "llama-tokenizer-js"
     </script>
     <script src="https://cdn.jsdelivr.net/npm/gpt-tokenizer/dist/cl100k_base.js" async></script>
+    <script src="https://cdn.jsdelivr.net/npm/gpt-tokenizer/dist/o200k_base.js" async></script>
     <script type="module" async>
         import PhotoSwipeLightbox from 'https://cdn.jsdelivr.net/npm/photoswipe/dist/photoswipe-lightbox.esm.js';
         const lightbox = new PhotoSwipeLightbox({
@@ -138,7 +139,7 @@ <h3>Settings</h3>
             </div>
             <div class="field">
                 <span class="label">Refine files with spaCy</span>
-                <input type="checkbox" id="refine" checked/>
+                <input type="checkbox" id="refine"/>
                 <label for="refine" class="toogle" title=""></label>
             </div>
             <div class="field box">
diff --git a/g4f/gui/client/static/js/chat.v1.js b/g4f/gui/client/static/js/chat.v1.js
index fc4b0c5b803..cb32f5da9c7 100644
--- a/g4f/gui/client/static/js/chat.v1.js
+++ b/g4f/gui/client/static/js/chat.v1.js
@@ -34,6 +34,7 @@ let synthesize_storage = {};
 let title_storage = {};
 let parameters_storage = {};
 let finish_storage = {};
+let usage_storage = {};
 
 messageInput.addEventListener("blur", () => {
     window.scrollTo(0, 0);
@@ -60,7 +61,7 @@ if (window.markdownit) {
             .replaceAll(/<!-- generated images start -->|<!-- generated images end -->/gm, "")
             .replaceAll(/<img data-prompt="[^>]+">/gm, "")
             .replaceAll(/{"bucket_id":"([^"]+)"}/gm, (match, p1) => {
-                size = appStorage.getItem(`bucket:${p1}`);
+                size = parseInt(appStorage.getItem(`bucket:${p1}`), 10);
                 return `**Bucket:** [[${p1}]](/backend-api/v2/files/${p1})${size ? ` (${formatFileSize(size)})` : ""}`;
             })
         )
@@ -449,7 +450,7 @@ document.querySelector(".media_player .fa-x").addEventListener("click", ()=>{
     media_player.removeChild(audio);
 });
 
-const prepare_messages = (messages, message_index = -1, do_continue = false) => {
+const prepare_messages = (messages, message_index = -1, do_continue = false, do_filter = true) => {
     messages = [ ...messages ]
     if (message_index != null) {
         // Removes messages after selected
@@ -493,7 +494,7 @@ const prepare_messages = (messages, message_index = -1, do_continue = false) =>
     }
 
     // Remove history, if it's selected
-    if (document.getElementById('history')?.checked) {
+    if (document.getElementById('history')?.checked && do_filter) {
         if (message_index == null) {
             messages = [messages.pop(), messages.pop()];
         } else {
@@ -509,7 +510,7 @@ const prepare_messages = (messages, message_index = -1, do_continue = false) =>
             delete new_message.regenerate;
         }
         // Include only not regenerated messages
-        if (new_message && !new_message.regenerate) {
+        if (new_message) {
             // Remove generated images from history
             if (new_message.content) {
                 new_message.content = filter_message(new_message.content);
@@ -518,10 +519,15 @@ const prepare_messages = (messages, message_index = -1, do_continue = false) =>
             delete new_message.provider;
             delete new_message.synthesize;
             delete new_message.finish;
+            delete new_message.usage;
             delete new_message.conversation;
             delete new_message.continue;
             // Append message to new messages
-            new_messages.push(new_message)
+            if (do_filter && !new_message.regenerate) {
+                new_messages.push(new_message)
+            } else if (!do_filter) {
+                new_messages.push(new_message)
+            }
         }
     });
 
@@ -714,6 +720,8 @@ async function add_message_chunk(message, message_id, provider, scroll) {
         update_message(content_map, message_id, message.login, scroll);
     } else if (message.type == "finish") {
         finish_storage[message_id] = message.finish;
+    } else if (message.type == "usage") {
+        usage_storage[message_id] = message.usage;
     } else if (message.type == "parameters") {
         if (!parameters_storage[provider]) {
             parameters_storage[provider] = {};
@@ -836,6 +844,7 @@ const ask_gpt = async (message_id, message_index = -1, regenerate = false, provi
             regenerate,
             title_storage[message_id],
             finish_storage[message_id],
+            usage_storage[message_id],
             action=="continue"
         );
         delete message_storage[message_id];
@@ -983,6 +992,32 @@ const new_conversation = async () => {
     say_hello();
 };
 
+function merge_messages(message1, message2) {
+    let newContent = message2;
+    if (newContent.startsWith("```")) {
+        const index = str.indexOf("\n");
+        newContent = newContent.substring(index);
+    } else if (newContent.startsWith("...")) {
+        newContent = " " + newContent.substring(3);
+    }
+    // Remove duplicate words
+    if (newContent.indexOf(" ") > 0) {
+        let words = message1.trim().split(" ");
+        let lastWord = words[words.length - 1];
+        if (newContent.startsWith(lastWord)) {
+            newContent = newContent.substring(lastWord.length);
+        }
+    }
+    // Remove duplicate lines
+    let lines = message1.trim().split("\n");
+    let lastLine = lines[lines.length - 1];
+    while (newContent && lastLine && newContent.startsWith(lastLine)) {
+        newContent = newContent.substring(lastLine.length);
+        lastLine = lines[lines.length - 1];
+    }
+    return message1 + newContent;
+}
+
 const load_conversation = async (conversation_id, scroll=true) => {
     let conversation = await get_conversation(conversation_id);
     let messages = conversation?.items || [];
@@ -1004,6 +1039,9 @@ const load_conversation = async (conversation_id, scroll=true) => {
     let last_model = null;
     let providers = [];
     let buffer = "";
+    let last_usage = null;
+    let completion_tokens = 0;
+
     messages.forEach((item, i) => {
         if (item.continue) {
             elements.pop();
@@ -1011,26 +1049,9 @@ const load_conversation = async (conversation_id, scroll=true) => {
             buffer = "";
         }
         buffer = buffer.replace(/ \[aborted\]$/g, "").replace(/ \[error\]$/g, "");
-        let lines = buffer.trim().split("\n");
-        let lastLine = lines[lines.length - 1];
-        let newContent = item.content;
-        if (newContent.startsWith("```")) {
-            const index = str.indexOf("\n");
-            newContent = newContent.substring(index);
-        } else if (newContent.startsWith("...")) {
-            newContent = " " + newContent.substring(3);
-        }
-        if (newContent.startsWith(lastLine)) {
-            newContent = newContent.substring(lastLine.length);
-        } else {
-            let words = buffer.trim().split(" ");
-            let lastWord = words[words.length - 1];
-            if (newContent.startsWith(lastWord)) {
-                newContent = newContent.substring(lastWord.length);
-            }
-        }
-        buffer += newContent;
+        buffer += merge_messages(buffer, item.content);
         last_model = item.provider?.model;
+        last_usage = item.usage;
         providers.push(item.provider?.name);
         let next_i = parseInt(i) + 1;
         let next_provider = item.provider ? item.provider : (messages.length > next_i ? messages[next_i].provider : null);
@@ -1055,11 +1076,12 @@ const load_conversation = async (conversation_id, scroll=true) => {
         const objectUrl = URL.createObjectURL(file);
 
         let add_buttons = [];
-        // Add continue button if possible
+        // Find buttons to add
         actions = ["variant"]
         if (item.finish && item.finish.actions) {
             actions = item.finish.actions
         }
+        // Add continue button if possible
         if (item.role == "assistant" && !actions.includes("continue")) {
             let reason = "stop";
             // Read finish reason from conversation
@@ -1071,20 +1093,9 @@ const load_conversation = async (conversation_id, scroll=true) => {
             // Has a stop or error token at the end
             if (lastLine.endsWith("[aborted]") || lastLine.endsWith("[error]")) {
                 reason = "error";
-                // Has an even number of start or end code tags
-            } else if (buffer.split("```").length - 1 % 2 === 1) {
+            // Has an even number of start or end code tags
+            } else if (reason = "stop" && buffer.split("```").length - 1 % 2 === 1) {
                 reason = "length";
-                // Has a end token at the end
-            } else if (lastLine.endsWith("```") || lastLine.endsWith(".") || lastLine.endsWith("?") || lastLine.endsWith("!")
-              || lastLine.endsWith('"') || lastLine.endsWith("'") || lastLine.endsWith(")")
-              || lastLine.endsWith(">") || lastLine.endsWith("]") || lastLine.endsWith("}") ) {
-                reason = "stop"
-            } else {
-                // Has an emoji at the end
-                const regex = /\p{Emoji}$/u;
-                if (regex.test(lastLine)) {
-                    reason = "stop"
-                }
             }
             if (reason == "length" || reason == "max_tokens" || reason == "error") {
                 actions.push("continue")
@@ -1117,6 +1128,13 @@ const load_conversation = async (conversation_id, scroll=true) => {
             }
         }
 
+        if (!item.continue) {
+            completion_tokens = 0;
+        }
+        completion_tokens += item.usage?.completion_tokens ? item.usage.completion_tokens : 0;
+        let next_usage = messages.length > next_i ? messages[next_i].usage : null;
+        let prompt_tokens = next_usage?.prompt_tokens ? next_usage?.prompt_tokens : 0
+
         elements.push(`
             <div class="message${item.regenerate ? " regenerate": ""}" data-index="${i}" data-object_url="${objectUrl}" data-synthesize_url="${synthesize_url}">
                 <div class="${item.role}">
@@ -1131,7 +1149,7 @@ const load_conversation = async (conversation_id, scroll=true) => {
                     ${provider}
                     <div class="content_inner">${markdown_render(buffer)}</div>
                     <div class="count">
-                        ${count_words_and_tokens(buffer, next_provider?.model)}
+                        ${count_words_and_tokens(buffer, next_provider?.model, completion_tokens, prompt_tokens)}
                         ${add_buttons.join("")}
                     </div>
                 </div>
@@ -1140,8 +1158,11 @@ const load_conversation = async (conversation_id, scroll=true) => {
     });
 
     if (window.GPTTokenizer_cl100k_base) {
-        const filtered = prepare_messages(messages, null);
+        const filtered = prepare_messages(messages, null, true, false);
         if (filtered.length > 0) {
+            if (GPTTokenizer_o200k_base && last_model?.startsWith("gpt-4o") || last_model?.startsWith("o1")) {
+                return GPTTokenizer_o200k_base?.encodeChat(filtered, last_model).length;
+            }
             last_model = last_model?.startsWith("gpt-3") ? "gpt-3.5-turbo" : "gpt-4"
             let count_total = GPTTokenizer_cl100k_base?.encodeChat(filtered, last_model).length
             if (count_total > 0) {
@@ -1259,6 +1280,7 @@ const add_message = async (
     regenerate = false,
     title = null,
     finish = null,
+    usage = null,
     do_continue = false
 ) => {
     const conversation = await get_conversation(conversation_id);
@@ -1287,6 +1309,9 @@ const add_message = async (
     if (finish) {
         new_message.finish = finish;
     }
+    if (usage) {
+        new_message.usage = usage;
+    }
     if (do_continue) {
         new_message.continue = true;
     }
@@ -1493,7 +1518,7 @@ const say_hello = async () => {
     }
 }
 
-function count_tokens(model, text) {
+function count_tokens(model, text, prompt_tokens = 0) {
     if (model) {
         if (window.llamaTokenizer)
         if (model.startsWith("llama") || model.startsWith("codellama")) {
@@ -1504,10 +1529,16 @@ function count_tokens(model, text) {
             return mistralTokenizer.encode(text).length;
         }
     }
-    if (window.GPTTokenizer_cl100k_base) {
-        return GPTTokenizer_cl100k_base.encode(text).length;
+    if (window.GPTTokenizer_cl100k_base && window.GPTTokenizer_o200k_base) {
+        if (model?.startsWith("gpt-4o") || model?.startsWith("o1")) {
+            return GPTTokenizer_o200k_base?.encode(text, model).length;
+        } else {
+            model = model?.startsWith("gpt-3") ? "gpt-3.5-turbo" : "gpt-4"
+            return GPTTokenizer_cl100k_base?.encode(text, model).length;
+        }
+    } else {
+        return prompt_tokens;
     }
-    return 0;
 }
 
 function count_words(text) {
@@ -1518,9 +1549,9 @@ function count_chars(text) {
     return text.match(/[^\s\p{P}]/gu)?.length || 0;
 }
 
-function count_words_and_tokens(text, model) {
+function count_words_and_tokens(text, model, completion_tokens, prompt_tokens) {
     text = filter_message(text);
-    return `(${count_words(text)} words, ${count_chars(text)} chars, ${count_tokens(model, text)} tokens)`;
+    return `(${count_words(text)} words, ${count_chars(text)} chars, ${completion_tokens ? completion_tokens : count_tokens(model, text, prompt_tokens)} tokens)`;
 }
 
 function update_message(content_map, message_id, content = null, scroll = true) {
@@ -1553,16 +1584,12 @@ function update_message(content_map, message_id, content = null, scroll = true)
 };
 
 let countFocus = messageInput;
-let timeoutId;
 const count_input = async () => {
-    if (timeoutId) clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => {
-        if (countFocus.value) {
-            inputCount.innerText = count_words_and_tokens(countFocus.value, get_selected_model()?.value);
-        } else {
-            inputCount.innerText = "";
-        }
-    }, 100);
+    if (countFocus.value) {
+        inputCount.innerText = count_words_and_tokens(countFocus.value, get_selected_model()?.value);
+    } else {
+        inputCount.innerText = "";
+    }
 };
 messageInput.addEventListener("keyup", count_input);
 systemPrompt.addEventListener("keyup", count_input);
@@ -2115,15 +2142,19 @@ if (SpeechRecognition) {
     let buffer;
     let lastDebounceTranscript;
     recognition.onstart = function() {
-        microLabel.classList.add("recognition");
         startValue = messageInput.value;
         lastDebounceTranscript = "";
         messageInput.readOnly = true;
+        buffer = "";
     };
     recognition.onend = function() {
         messageInput.value = `${startValue ? startValue + "\n" : ""}${buffer}`;
-        messageInput.readOnly = false;
-        messageInput.focus();
+        if (!microLabel.classList.contains("recognition")) {
+            recognition.start();
+        } else {
+            messageInput.readOnly = false;
+            messageInput.focus();
+        }
     };
     recognition.onresult = function(event) {
         if (!event.results) {
@@ -2148,10 +2179,11 @@ if (SpeechRecognition) {
 
     microLabel.addEventListener("click", (e) => {
         if (microLabel.classList.contains("recognition")) {
+            microLabel.classList.remove("recognition");
             recognition.stop();
             messageInput.value = `${startValue ? startValue + "\n" : ""}${buffer}`;
-            microLabel.classList.remove("recognition");
         } else {
+            microLabel.classList.add("recognition");
             const lang = document.getElementById("recognition-language")?.value;
             recognition.lang = lang || navigator.language;
             recognition.start();
diff --git a/g4f/gui/server/api.py b/g4f/gui/server/api.py
index eb04f9b649c..7801287b390 100644
--- a/g4f/gui/server/api.py
+++ b/g4f/gui/server/api.py
@@ -13,7 +13,7 @@
 from ...Provider import ProviderUtils, __providers__
 from ...providers.base_provider import ProviderModelMixin
 from ...providers.retry_provider import IterListProvider
-from ...providers.response import BaseConversation, JsonConversation, FinishReason
+from ...providers.response import BaseConversation, JsonConversation, FinishReason, Usage
 from ...providers.response import SynthesizeData, TitleGeneration, RequestLogin, Parameters
 from ... import version, models
 from ... import ChatCompletion, get_model_and_provider
@@ -201,6 +201,8 @@ def decorated_log(text: str):
                     yield self._format_json("parameters", chunk.get_dict())
                 elif isinstance(chunk, FinishReason):
                     yield self._format_json("finish", chunk.get_dict())
+                elif isinstance(chunk, Usage):
+                    yield self._format_json("usage", chunk.get_dict())
                 else:
                     yield self._format_json("content", str(chunk))
                 if debug.logs:
diff --git a/g4f/models.py b/g4f/models.py
index b041ab6abfc..ffb80d5bf95 100644
--- a/g4f/models.py
+++ b/g4f/models.py
@@ -74,7 +74,6 @@ class ImageModel(Model):
         Airforce,
         Cloudflare,
         PollinationsAI,
-        ChatGptEs,
         OpenaiChat,
         Mhystical,
         ClaudeSon,
@@ -104,13 +103,13 @@ class ImageModel(Model):
 gpt_4o = Model(
     name          = 'gpt-4o',
     base_provider = 'OpenAI',
-    best_provider = IterListProvider([Blackbox, ChatGptEs, PollinationsAI, DarkAI, ChatGpt, Liaobots, OpenaiChat])
+    best_provider = IterListProvider([Blackbox, PollinationsAI, DarkAI, ChatGpt, Liaobots, OpenaiChat])
 )
 
 gpt_4o_mini = Model(
     name          = 'gpt-4o-mini',
     base_provider = 'OpenAI',
-    best_provider = IterListProvider([DDG, ChatGptEs, Pizzagpt, ChatGpt, RubiksAI, Liaobots, OpenaiChat])
+    best_provider = IterListProvider([DDG, Pizzagpt, ChatGpt, RubiksAI, Liaobots, OpenaiChat])
 )
 
 # o1
diff --git a/g4f/providers/base_provider.py b/g4f/providers/base_provider.py
index eade5ec73ca..291a6f0e26e 100644
--- a/g4f/providers/base_provider.py
+++ b/g4f/providers/base_provider.py
@@ -385,7 +385,10 @@ async def on_auth_async(cls, **kwargs) -> AuthResult:
 
     @classmethod
     def on_auth(cls, **kwargs) -> AuthResult:
-        return asyncio.run(cls.on_auth_async(**kwargs))
+        auth_result = cls.on_auth_async(**kwargs)
+        if hasattr(auth_result, "__aiter__"):
+            return to_sync_generator(auth_result)
+        return asyncio.run(auth_result)
 
     @classmethod
     def get_create_function(cls) -> callable:
@@ -414,22 +417,35 @@ def create_completion(
                     auth_result = AuthResult(**json.load(f))
             else:
                 auth_result = cls.on_auth(**kwargs)
-                if hasattr(auth_result, "_iter__"):
-                    for chunk in auth_result:
-                        if isinstance(chunk, AsyncResult):
-                            auth_result = chunk
-                        else:
-                            yield chunk
+            try:
+                for chunk in auth_result:
+                    if hasattr(chunk, "get_dict"):
+                        auth_result = chunk
+                    else:
+                        yield chunk
+            except TypeError:
+                pass
             yield from to_sync_generator(cls.create_authed(model, messages, auth_result, **kwargs))
         except (MissingAuthError, NoValidHarFileError):
-            if cache_file.exists():
-                cache_file.unlink()
             auth_result = cls.on_auth(**kwargs)
+            try:
+                for chunk in auth_result:
+                    if hasattr(chunk, "get_dict"):
+                        auth_result = chunk
+                    else:
+                        yield chunk
+            except TypeError:
+                pass
             yield from to_sync_generator(cls.create_authed(model, messages, auth_result, **kwargs))
         finally:
-                cache_file.parent.mkdir(parents=True, exist_ok=True)
-                cache_file.write_text(json.dumps(auth_result.get_dict()))
+                if hasattr(auth_result, "get_dict"):
+                    data = auth_result.get_dict()
+                    cache_file.parent.mkdir(parents=True, exist_ok=True)
+                    cache_file.write_text(json.dumps(data))
+                elif cache_file.exists():
+                    cache_file.unlink()
 
+    @classmethod
     async def create_async_generator(
         cls,
         model: str,
@@ -443,24 +459,36 @@ async def create_async_generator(
                 with cache_file.open("r") as f:
                     auth_result = AuthResult(**json.load(f))
             else:
-                auth_result = await cls.on_auth_async(**kwargs)
+                auth_result = cls.on_auth_async(**kwargs)
                 if hasattr(auth_result, "_aiter__"):
                     async for chunk in auth_result:
                         if isinstance(chunk, AsyncResult):
                             auth_result = chunk
                         else:
                             yield chunk
+                else:
+                    auth_result = await auth_result
             response = to_async_iterator(cls.create_authed(model, messages, **kwargs, auth_result=auth_result))
             async for chunk in response:
                 yield chunk
         except (MissingAuthError, NoValidHarFileError):
             if cache_file.exists():
                 cache_file.unlink()
-            auth_result = await cls.on_auth_async(**kwargs)
+            auth_result = cls.on_auth_async(**kwargs)
+            if hasattr(auth_result, "_aiter__"):
+                async for chunk in auth_result:
+                    if isinstance(chunk, AsyncResult):
+                        auth_result = chunk
+                    else:
+                        yield chunk
+            else:
+                auth_result = await auth_result
             response = to_async_iterator(cls.create_authed(model, messages, **kwargs, auth_result=auth_result))
             async for chunk in response:
                 yield chunk
         finally:
-            if auth_result is not None:
+            if hasattr(auth_result, "get_dict"):
                 cache_file.parent.mkdir(parents=True, exist_ok=True)
-                cache_file.write_text(json.dumps(auth_result.get_dict()))
\ No newline at end of file
+                cache_file.write_text(json.dumps(auth_result.get_dict()))
+            elif cache_file.exists():
+                cache_file.unlink()
\ No newline at end of file
diff --git a/g4f/providers/response.py b/g4f/providers/response.py
index a676b16cdb1..76456299be1 100644
--- a/g4f/providers/response.py
+++ b/g4f/providers/response.py
@@ -85,6 +85,9 @@ def get_dict(self):
             if not key.startswith("__")
         }
 
+    def reset(self):
+        self.__dict__ = {}
+
 class FinishReason(ResponseType, JsonMixin):
     def __init__(self, reason: str, actions: list[str] = None) -> None:
         self.reason = reason
diff --git a/g4f/providers/retry_provider.py b/g4f/providers/retry_provider.py
index b64155fe991..f702c8fdda6 100644
--- a/g4f/providers/retry_provider.py
+++ b/g4f/providers/retry_provider.py
@@ -4,6 +4,7 @@
 
 from ..typing import Type, List, CreateResult, Messages, AsyncResult
 from .types import BaseProvider, BaseRetryProvider, ProviderType
+from .response import ImageResponse
 from .. import debug
 from ..errors import RetryProviderError, RetryNoProviderError
 
@@ -54,15 +55,11 @@ def create_completion(
             debug.log(f"Using {provider.__name__} provider")
             try:
                 response = provider.get_create_function()(model, messages, stream=stream, **kwargs)
-                if hasattr(response, "__iter__"):
-                    for chunk in response:
-                        if chunk:
-                            yield chunk
-                            if isinstance(chunk, str):
-                                started = True
-                elif response:
-                    yield response
-                    return
+                for chunk in response:
+                    if chunk:
+                        yield chunk
+                        if isinstance(chunk, str) or isinstance(chunk, ImageResponse):
+                            started = True
                 if started:
                     return
             except Exception as e:
@@ -94,7 +91,7 @@ async def create_async_generator(
                     async for chunk in response:
                         if chunk:
                             yield chunk
-                            if isinstance(chunk, str):
+                            if isinstance(chunk, str) or isinstance(chunk, ImageResponse):
                                 started = True
                 elif response:
                     response = await response
@@ -171,14 +168,10 @@ def create_completion(
                     if debug.logging:
                         print(f"Using {provider.__name__} provider (attempt {attempt + 1})")
                     response = provider.get_create_function()(model, messages, stream=stream, **kwargs)
-                    if hasattr(response, "__iter__"):
-                        for chunk in response:
-                            if chunk:
-                                yield chunk
-                                started = True
-                    elif response:
-                        yield response
-                        started = True
+                    for chunk in response:
+                        if isinstance(chunk, str) or isinstance(chunk, ImageResponse):
+                            yield chunk
+                            started = True
                     if started:
                         return
                 except Exception as e:
@@ -210,7 +203,7 @@ async def create_async_generator(
                     response = provider.get_async_create_function()(model, messages, stream=stream, **kwargs)
                     if hasattr(response, "__aiter__"):
                         async for chunk in response:
-                            if chunk:
+                            if isinstance(chunk, str) or isinstance(chunk, ImageResponse):
                                 yield chunk
                                 started = True
                     else:
diff --git a/g4f/requests/__init__.py b/g4f/requests/__init__.py
index 2783f1e3238..d8f5a000569 100644
--- a/g4f/requests/__init__.py
+++ b/g4f/requests/__init__.py
@@ -127,8 +127,9 @@ async def get_nodriver(proxy: str = None, user_data_dir = "nodriver", browser_ex
             browser_executable_path = find_chrome_executable()
         except FileNotFoundError:
             # Default to Edge if Chrome is not found
-            if os.path.exists("C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"):
-                browser_executable_path = "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
+            browser_executable_path = "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
+            if not os.path.exists(browser_executable_path):
+                browser_executable_path = None
     debug.log(f"Open nodriver with user_dir: {user_data_dir}")
     return await nodriver.start(
         user_data_dir=user_data_dir,
diff --git a/g4f/tools/files.py b/g4f/tools/files.py
index b12ad511bcd..8f10c4b7e9e 100644
--- a/g4f/tools/files.py
+++ b/g4f/tools/files.py
@@ -487,7 +487,7 @@ def read_and_download_urls(bucket_dir: Path, event_stream: bool = False) -> Iter
     urls = get_downloads_urls(bucket_dir)
     if urls:
         count = 0
-        with open(os.path.join(bucket_dir, FILE_LIST), 'w') as f:
+        with open(os.path.join(bucket_dir, FILE_LIST), 'a') as f:
             for filename in to_sync_generator(download_urls(bucket_dir, urls)):
                 f.write(f"{filename}\n")
                 if event_stream:
@@ -498,7 +498,7 @@ async def async_read_and_download_urls(bucket_dir: Path, event_stream: bool = Fa
     urls = get_downloads_urls(bucket_dir)
     if urls:
         count = 0
-        with open(os.path.join(bucket_dir, FILE_LIST), 'w') as f:
+        with open(os.path.join(bucket_dir, FILE_LIST), 'a') as f:
             async for filename in download_urls(bucket_dir, urls):
                 f.write(f"{filename}\n")
                 if event_stream:

From 2360cc3330df821711637c9274b4ae154d2f7cc5 Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <hlohaus@users.noreply.github.com>
Date: Tue, 7 Jan 2025 00:26:01 +0100
Subject: [PATCH 2/5] Fix issue with old conversations

---
 g4f/Provider/needs_auth/OpenaiChat.py | 4 ++--
 g4f/tools/files.py                    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/g4f/Provider/needs_auth/OpenaiChat.py b/g4f/Provider/needs_auth/OpenaiChat.py
index 72465ec2659..79aac591fa0 100644
--- a/g4f/Provider/needs_auth/OpenaiChat.py
+++ b/g4f/Provider/needs_auth/OpenaiChat.py
@@ -351,7 +351,7 @@ async def create_authed(
                 conversation = Conversation(conversation_id, str(uuid.uuid4()), getattr(auth_result, "cookies", {}).get("oai-did"))
             else:
                 conversation = copy(conversation)
-            if getattr(auth_result, "cookies", {}).get("oai-did") != conversation.user_id:
+            if getattr(auth_result, "cookies", {}).get("oai-did") != getattr(conversation, "user_id", None):
                 conversation = Conversation(None, str(uuid.uuid4()))
             if cls._api_key is None:
                 auto_continue = False
@@ -587,7 +587,7 @@ async def login(
         cookies: Cookies = None,
         headers: dict = None,
         **kwargs
-    ) -> AsyncIterator[str]:
+    ) -> AsyncIterator:
         if cls._expires is not None and (cls._expires - 60*10) < time.time():
             cls._headers = cls._api_key = None
         if cls._headers is None or headers is not None:
diff --git a/g4f/tools/files.py b/g4f/tools/files.py
index 8f10c4b7e9e..d1d45e13692 100644
--- a/g4f/tools/files.py
+++ b/g4f/tools/files.py
@@ -353,7 +353,7 @@ async def get_filename(response: ClientResponse) -> str:
             sha256_hash = hashlib.sha256(url.encode()).digest()
             base32_encoded = base64.b32encode(sha256_hash).decode()
             url_hash = base32_encoded[:24].lower()
-            return f"{parsed_url.netloc} {parsed_url.path[1:].replace('/', '_')} {url_hash}{extension}"
+            return f"{parsed_url.netloc}+{parsed_url.path[1:].replace('/', '_')}+{url_hash}{extension}"
 
     return None
 
@@ -494,7 +494,7 @@ def read_and_download_urls(bucket_dir: Path, event_stream: bool = False) -> Iter
                     count += 1
                     yield f'data: {json.dumps({"action": "download", "count": count})}\n\n'
 
-async def async_read_and_download_urls(bucket_dir: Path, event_stream: bool = False) -> Iterator[str]:
+async def async_read_and_download_urls(bucket_dir: Path, event_stream: bool = False) -> AsyncIterator[str]:
     urls = get_downloads_urls(bucket_dir)
     if urls:
         count = 0

From ba6c47f46e6aba5ad938242ef6077dad4f84ea3f Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <hlohaus@users.noreply.github.com>
Date: Tue, 7 Jan 2025 00:36:22 +0100
Subject: [PATCH 3/5] Fix import in LocalClient

---
 g4f/Provider/needs_auth/OpenaiChat.py | 1 +
 g4f/local/__init__.py                 | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/g4f/Provider/needs_auth/OpenaiChat.py b/g4f/Provider/needs_auth/OpenaiChat.py
index 79aac591fa0..6fd88782d91 100644
--- a/g4f/Provider/needs_auth/OpenaiChat.py
+++ b/g4f/Provider/needs_auth/OpenaiChat.py
@@ -692,6 +692,7 @@ def _update_request_args(cls, auth_result: AuthResult, session: StreamSession):
         if hasattr(auth_result, "cookies"):
             for c in session.cookie_jar if hasattr(session, "cookie_jar") else session.cookies.jar:
                 auth_result.cookies[getattr(c, "key", getattr(c, "name", ""))] = c.value
+            cls._cookies = auth_result.cookies
         cls._update_cookie_header()
 
     @classmethod
diff --git a/g4f/local/__init__.py b/g4f/local/__init__.py
index 117cd48daca..6809e0c10ef 100644
--- a/g4f/local/__init__.py
+++ b/g4f/local/__init__.py
@@ -3,7 +3,7 @@
 from ..typing import Union, Messages
 from ..locals.provider import LocalProvider
 from ..locals.models import get_models
-from ..client.client import iter_response, filter_none
+from ..client import iter_response, filter_none
 from ..client.types import IterResponse
 
 class LocalClient():

From ef642f5baf2b75e17940b11c0df7c40b4b3183c2 Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <hlohaus@users.noreply.github.com>
Date: Tue, 7 Jan 2025 15:21:43 +0100
Subject: [PATCH 4/5] Improve merge_messages in GUI

---
 g4f/gui/client/static/js/chat.v1.js | 52 +++++++++++++++++++----------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/g4f/gui/client/static/js/chat.v1.js b/g4f/gui/client/static/js/chat.v1.js
index cb32f5da9c7..036bca14534 100644
--- a/g4f/gui/client/static/js/chat.v1.js
+++ b/g4f/gui/client/static/js/chat.v1.js
@@ -994,30 +994,48 @@ const new_conversation = async () => {
 
 function merge_messages(message1, message2) {
     let newContent = message2;
+    // Remove start tokens
     if (newContent.startsWith("```")) {
-        const index = str.indexOf("\n");
-        newContent = newContent.substring(index);
+        const index = newContent.indexOf("\n");
+        if (index != -1) {
+            newContent = newContent.substring(index);
+        }
     } else if (newContent.startsWith("...")) {
         newContent = " " + newContent.substring(3);
-    }
-    // Remove duplicate words
-    if (newContent.indexOf(" ") > 0) {
-        let words = message1.trim().split(" ");
-        let lastWord = words[words.length - 1];
-        if (newContent.startsWith(lastWord)) {
-            newContent = newContent.substring(lastWord.length);
+    } else {
+        // Remove duplicate lines
+        let lines = message1.trim().split("\n");
+        let lastLine = lines[lines.length - 1];
+        let foundLastLine = newContent.indexOf(lastLine + "\n");
+        if (foundLastLine != -1) {
+            foundLastLine += 1;
+        } else {
+            foundLastLine = newContent.indexOf(lastLine);
+        }
+        if (foundLastLine != -1) {
+            newContent = newContent.substring(foundLastLine + lastLine.length);
+        }
+        // Remove duplicate words
+        if (foundLastLine == -1 && newContent.indexOf(" ") > 0) {
+            let words = message1.trim().split(" ");
+            let lastWord = words[words.length - 1];
+            if (newContent.startsWith(lastWord)) {
+                newContent = newContent.substring(lastWord.length);
+            }
         }
-    }
-    // Remove duplicate lines
-    let lines = message1.trim().split("\n");
-    let lastLine = lines[lines.length - 1];
-    while (newContent && lastLine && newContent.startsWith(lastLine)) {
-        newContent = newContent.substring(lastLine.length);
-        lastLine = lines[lines.length - 1];
     }
     return message1 + newContent;
 }
 
+// console.log(merge_messages("Hello", "Hello,\nhow are you?"));
+// console.log(merge_messages("Hello", "Hello, how are you?"));
+// console.log(merge_messages("Hello", "Hello,\nhow are you?"));
+// console.log(merge_messages("Hello,\n", "Hello,\nhow are you?"));
+// console.log(merge_messages("Hello,\n", "how are you?"));
+// console.log(merge_messages("1 != 2", "1 != 2;"));
+// console.log(merge_messages("1 != 2", "```python\n1 != 2;"));
+// console.log(merge_messages("1 != 2;\n1 != 3;\n", "1 != 2;\n1 != 3;\n"));
+
 const load_conversation = async (conversation_id, scroll=true) => {
     let conversation = await get_conversation(conversation_id);
     let messages = conversation?.items || [];
@@ -1039,7 +1057,6 @@ const load_conversation = async (conversation_id, scroll=true) => {
     let last_model = null;
     let providers = [];
     let buffer = "";
-    let last_usage = null;
     let completion_tokens = 0;
 
     messages.forEach((item, i) => {
@@ -1051,7 +1068,6 @@ const load_conversation = async (conversation_id, scroll=true) => {
         buffer = buffer.replace(/ \[aborted\]$/g, "").replace(/ \[error\]$/g, "");
         buffer += merge_messages(buffer, item.content);
         last_model = item.provider?.model;
-        last_usage = item.usage;
         providers.push(item.provider?.name);
         let next_i = parseInt(i) + 1;
         let next_provider = item.provider ? item.provider : (messages.length > next_i ? messages[next_i].provider : null);

From f05d06989679ae7ca0b920fce6d50e6ae50cb361 Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <hlohaus@users.noreply.github.com>
Date: Tue, 7 Jan 2025 17:09:10 +0100
Subject: [PATCH 5/5] Add DeepSeek Provider Add get api keys urls to GUI

---
 g4f/Provider/GizAI.py                |  1 -
 g4f/Provider/Mhystical.py            |  4 ++-
 g4f/Provider/PollinationsAI.py       | 23 +++++++------
 g4f/Provider/needs_auth/DeepInfra.py |  1 +
 g4f/Provider/needs_auth/DeepSeek.py  | 14 ++++++++
 g4f/Provider/needs_auth/GlhfChat.py  |  1 +
 g4f/Provider/needs_auth/OpenaiAPI.py |  2 +-
 g4f/Provider/needs_auth/__init__.py  |  1 +
 g4f/gui/client/index.html            | 48 ----------------------------
 g4f/gui/client/static/css/style.css  |  4 +++
 g4f/gui/client/static/js/chat.v1.js  | 31 ++++++++++++++++++
 g4f/gui/server/api.py                |  1 +
 g4f/models.py                        |  2 +-
 13 files changed, 69 insertions(+), 64 deletions(-)
 create mode 100644 g4f/Provider/needs_auth/DeepSeek.py

diff --git a/g4f/Provider/GizAI.py b/g4f/Provider/GizAI.py
index c33f82df3ee..a8401b43b95 100644
--- a/g4f/Provider/GizAI.py
+++ b/g4f/Provider/GizAI.py
@@ -6,7 +6,6 @@
 from .base_provider import AsyncGeneratorProvider, ProviderModelMixin
 from .helper import format_prompt
 
-
 class GizAI(AsyncGeneratorProvider, ProviderModelMixin):
     url = "https://app.giz.ai/assistant"
     api_endpoint = "https://app.giz.ai/api/data/users/inferenceServer.infer"
diff --git a/g4f/Provider/Mhystical.py b/g4f/Provider/Mhystical.py
index 42a7039623b..570cc85cd5f 100644
--- a/g4f/Provider/Mhystical.py
+++ b/g4f/Provider/Mhystical.py
@@ -18,6 +18,7 @@ class Mhystical(OpenaiAPI):
     label = "Mhystical"
     url = "https://mhystical.cc"
     api_endpoint = "https://api.mhystical.cc/v1/completions"
+    login_url = "https://mhystical.cc/dashboard"
     working = True
     needs_auth = False
     supports_stream = False  # Set to False, as streaming is not specified in ChatifyAI
@@ -37,11 +38,12 @@ def create_async_generator(
         model: str,
         messages: Messages,
         stream: bool = False,
+        api_key: str = "mhystical",
         **kwargs
     ) -> AsyncResult:
         model = cls.get_model(model)
         headers = {
-            "x-api-key": "mhystical",
+            "x-api-key": api_key,
             "Content-Type": "application/json",
             "accept": "*/*",
             "cache-control": "no-cache",
diff --git a/g4f/Provider/PollinationsAI.py b/g4f/Provider/PollinationsAI.py
index 3df3fafd7df..4990a86961e 100644
--- a/g4f/Provider/PollinationsAI.py
+++ b/g4f/Provider/PollinationsAI.py
@@ -7,12 +7,12 @@
 from typing import Optional
 from aiohttp import ClientSession
 
+from .base_provider import AsyncGeneratorProvider, ProviderModelMixin
 from ..requests.raise_for_status import raise_for_status
 from ..typing import AsyncResult, Messages
 from ..image import ImageResponse
-from .needs_auth.OpenaiAPI import OpenaiAPI
 
-class PollinationsAI(OpenaiAPI):
+class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
     label = "Pollinations AI"
     url = "https://pollinations.ai"
     
@@ -21,21 +21,21 @@ class PollinationsAI(OpenaiAPI):
     supports_stream = True
     supports_system_message = True
     supports_message_history = True
-    
+
     # API endpoints base
     api_base = "https://text.pollinations.ai/openai"
-    
+
     # API endpoints
     text_api_endpoint = "https://text.pollinations.ai"
     image_api_endpoint = "https://image.pollinations.ai"
-    
+
     # Models configuration
     default_model = "openai"
     default_image_model = "flux"
-    
+
     image_models = []
     models = []
-    
+
     additional_models_image = ["midjourney", "dall-e-3"]
     additional_models_text = ["sur", "sur-mistral", "claude"]
     model_aliases = {
@@ -100,7 +100,7 @@ async def create_async_generator(
         **kwargs
     ) -> AsyncResult:
         model = cls.get_model(model)
-        
+
         # Check if models
         # Image generation
         if model in cls.image_models:
@@ -151,7 +151,6 @@ async def _generate_image(
         if seed is None:
             seed = random.randint(0, 10000)
 
-		
         headers = {
             'Accept': '*/*',
             'Accept-Language': 'en-US,en;q=0.9',
@@ -177,7 +176,7 @@ async def _generate_image(
 
             async with session.head(url, proxy=proxy) as response:
                 if response.status == 200:
-                    image_response = ImageResponse(images=url, alt=messages[-1]["content"])
+                    image_response = ImageResponse(images=url, alt=messages[-1]["content"] if prompt is None else prompt)
                     yield image_response
 
     @classmethod
@@ -195,7 +194,7 @@ async def _generate_text(
     ) -> AsyncResult:
         if api_key is None:
             api_key = "dummy"  # Default value if api_key is not provided
-            
+
         headers = {
             "accept": "*/*",
             "accept-language": "en-US,en;q=0.9",
@@ -215,7 +214,7 @@ async def _generate_text(
                 "jsonMode": False,
                 "stream": stream
             }
-            
+
             async with session.post(cls.text_api_endpoint, json=data, proxy=proxy) as response:
                 response.raise_for_status()
                 async for chunk in response.content:
diff --git a/g4f/Provider/needs_auth/DeepInfra.py b/g4f/Provider/needs_auth/DeepInfra.py
index c5ebac1e0fd..ea114a1b659 100644
--- a/g4f/Provider/needs_auth/DeepInfra.py
+++ b/g4f/Provider/needs_auth/DeepInfra.py
@@ -7,6 +7,7 @@
 class DeepInfra(OpenaiAPI):
     label = "DeepInfra"
     url = "https://deepinfra.com"
+    login_url = "https://deepinfra.com/dash/api_keys"
     working = True
     api_base = "https://api.deepinfra.com/v1/openai",
     needs_auth = True
diff --git a/g4f/Provider/needs_auth/DeepSeek.py b/g4f/Provider/needs_auth/DeepSeek.py
new file mode 100644
index 00000000000..88b187be52a
--- /dev/null
+++ b/g4f/Provider/needs_auth/DeepSeek.py
@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from .OpenaiAPI import OpenaiAPI
+
+class DeepSeek(OpenaiAPI):
+    label = "DeepSeek"
+    url = "https://platform.deepseek.com"
+    login_url = "https://platform.deepseek.com/api_keys"
+    working = True
+    api_base = "https://api.deepseek.com"
+    needs_auth = True
+    supports_stream = True
+    supports_message_history = True
+    default_model = "deepseek-chat"
\ No newline at end of file
diff --git a/g4f/Provider/needs_auth/GlhfChat.py b/g4f/Provider/needs_auth/GlhfChat.py
index c0bf8e7e02b..f3a578af17f 100644
--- a/g4f/Provider/needs_auth/GlhfChat.py
+++ b/g4f/Provider/needs_auth/GlhfChat.py
@@ -5,6 +5,7 @@
 class GlhfChat(OpenaiAPI):
     label = "GlhfChat"
     url = "https://glhf.chat"
+    login_url = "https://glhf.chat/users/settings/api"
     api_base = "https://glhf.chat/api/openai/v1"
     working = True
     model_aliases = {
diff --git a/g4f/Provider/needs_auth/OpenaiAPI.py b/g4f/Provider/needs_auth/OpenaiAPI.py
index 7ff9b555ed1..75c3574fd28 100644
--- a/g4f/Provider/needs_auth/OpenaiAPI.py
+++ b/g4f/Provider/needs_auth/OpenaiAPI.py
@@ -8,7 +8,7 @@
 from ...typing import Union, Optional, AsyncResult, Messages, ImagesType
 from ...requests import StreamSession, raise_for_status
 from ...providers.response import FinishReason, ToolCalls, Usage
-from ...errors import MissingAuthError, ResponseError
+from ...errors import MissingAuthError
 from ...image import to_data_uri
 from ... import debug
 
diff --git a/g4f/Provider/needs_auth/__init__.py b/g4f/Provider/needs_auth/__init__.py
index 24282f0f3ec..4b800ff45ad 100644
--- a/g4f/Provider/needs_auth/__init__.py
+++ b/g4f/Provider/needs_auth/__init__.py
@@ -5,6 +5,7 @@
 from .CopilotAccount    import CopilotAccount
 from .DeepInfra         import DeepInfra
 from .DeepInfraImage    import DeepInfraImage
+from .DeepSeek          import DeepSeek
 from .Gemini            import Gemini
 from .GeminiPro         import GeminiPro
 from .GithubCopilot     import GithubCopilot
diff --git a/g4f/gui/client/index.html b/g4f/gui/client/index.html
index 09f27063559..de604a1b18a 100644
--- a/g4f/gui/client/index.html
+++ b/g4f/gui/client/index.html
@@ -154,54 +154,6 @@ <h3>Settings</h3>
                 <label for="BingCreateImages-api_key" class="label" title="">Microsoft Designer in Bing:</label>
                 <textarea id="BingCreateImages-api_key" name="BingCreateImages[api_key]" placeholder="&quot;_U&quot; cookie"></textarea>
             </div>
-            <div class="field box hidden">
-                <label for="Cerebras-api_key" class="label" title="">Cerebras Inference:</label>
-                <textarea id="Cerebras-api_key" name="Cerebras[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="Anthropic-api_key" class="label" title="">Anthropic API:</label>
-                <textarea id="Anthropic-api_key" name="Anthropic[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="DeepInfra-api_key" class="label" title="">DeepInfra:</label>
-                <textarea id="DeepInfra-api_key" name="DeepInfra[api_key]" class="DeepInfraImage-api_key" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="GeminiPro-api_key" class="label" title="">Gemini API:</label>
-                <textarea id="GeminiPro-api_key" name="GeminiPro[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="Groq-api_key" class="label" title="">Groq:</label>
-                <textarea id="Groq-api_key" name="Groq[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="GlhfChat-api_key" class="label" title="">GlhfChat:</label>
-                <textarea id="GlhfChat-api_key" name="GlhfChat[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="HuggingFace-api_key" class="label" title="">HuggingFace:</label>
-                <textarea id="HuggingFace-api_key" name="HuggingFace[api_key]" class="HuggingFaceAPI-api_key" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="OpenaiAPI-api_key" class="label" title="">OpenAI API:</label>
-                <textarea id="OpenaiAPI-api_key" name="OpenaiAPI[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="OpenRouter-api_key" class="label" title="">OpenRouter:</label>
-                <textarea id="OpenRouter-api_key" name="OpenRouter[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="PerplexityApi-api_key" class="label" title="">Perplexity API:</label>
-                <textarea id="PerplexityApi-api_key" name="PerplexityApi[api_key]" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="Replicate-api_key" class="label" title="">Replicate:</label>
-                <textarea id="Replicate-api_key" name="Replicate[api_key]" class="ReplicateImage-api_key" placeholder="api_key"></textarea>
-            </div>
-            <div class="field box hidden">
-                <label for="xAI-api_key" class="label" title="">xAI:</label>
-                <textarea id="xAI-api_key" name="xAI[api_key]" placeholder="api_key"></textarea>
-            </div>
             </div>
             <div class="bottom_buttons">
                 <button onclick="delete_conversations()">
diff --git a/g4f/gui/client/static/css/style.css b/g4f/gui/client/static/css/style.css
index db185e4107f..b6da51440dd 100644
--- a/g4f/gui/client/static/css/style.css
+++ b/g4f/gui/client/static/css/style.css
@@ -1312,6 +1312,10 @@ form textarea {
     padding: 6px;
 }
 
+.field a {
+    text-wrap: nowrap;
+}
+
 form .field .fa-xmark {
     line-height: 20px;
     cursor: pointer;
diff --git a/g4f/gui/client/static/js/chat.v1.js b/g4f/gui/client/static/js/chat.v1.js
index 036bca14534..258bcd4c788 100644
--- a/g4f/gui/client/static/js/chat.v1.js
+++ b/g4f/gui/client/static/js/chat.v1.js
@@ -1710,6 +1710,7 @@ async function on_api() {
         });
         providers = await api("providers")
         providers.sort((a, b) => a.label.localeCompare(b.label));
+        let login_urls = {};
         providers.forEach((provider) => {
             let option = document.createElement("option");
             option.value = provider.name;
@@ -1723,6 +1724,36 @@ async function on_api() {
                 option.dataset.parent = provider.parent;
             providerSelect.appendChild(option);
 
+            if (provider.login_url) {
+                if (!login_urls[provider.name]) {
+                    login_urls[provider.name] = [provider.label, provider.login_url, []];
+                } else {
+                    login_urls[provider.name][0] = provider.label;
+                    login_urls[provider.name][1] = provider.login_url;
+                }
+            } else if (provider.parent) {
+                if (!login_urls[provider.parent]) {
+                    login_urls[provider.parent] = [provider.label, provider.login_url, [provider.name]];
+                } else {
+                    login_urls[provider.parent][2].push(provider.name);
+                }
+            }
+        });
+        for (let [name, [label, login_url, childs]] of Object.entries(login_urls)) {
+            if (!login_url) {
+                continue;
+            }
+            option = document.createElement("div");
+            option.classList.add("field", "box", "hidden");
+            childs = childs.map((child)=>`${child}-api_key`).join(" ");
+            option.innerHTML = `
+                <label for="${name}-api_key" class="label" title="">${label}:</label>
+                <textarea id="${name}-api_key" name="${name}[api_key]" class="${childs}" placeholder="api_key"></textarea>
+                <a href="${login_url}" target="_blank" title="Login to ${label}">Get API key</a>
+            `;
+            settings.querySelector(".paper").appendChild(option);
+        }
+        providers.forEach((provider) => {
             if (!provider.parent) {
                 option = document.createElement("div");
                 option.classList.add("field");
diff --git a/g4f/gui/server/api.py b/g4f/gui/server/api.py
index 7801287b390..f7f0f565c29 100644
--- a/g4f/gui/server/api.py
+++ b/g4f/gui/server/api.py
@@ -65,6 +65,7 @@ def get_providers() -> dict[str, str]:
             "image": getattr(provider, "image_models", None) is not None,
             "vision": getattr(provider, "default_vision_model", None) is not None,
             "auth": provider.needs_auth,
+            "login_url": getattr(provider, "login_url", None),
         } for provider in __providers__ if provider.working]
 
     @staticmethod
diff --git a/g4f/models.py b/g4f/models.py
index ffb80d5bf95..6ceb9ed587a 100644
--- a/g4f/models.py
+++ b/g4f/models.py
@@ -168,7 +168,7 @@ class ImageModel(Model):
 llama_3_1_70b = Model(
     name          = "llama-3.1-70b",
     base_provider = "Meta Llama",
-    best_provider = IterListProvider([DDG, DeepInfraChat, Blackbox, BlackboxCreateAgent, TeachAnything, PollinationsAI, DarkAI, Airforce, RubiksAI, PerplexityLabs])
+    best_provider = IterListProvider([DDG, DeepInfraChat, Blackbox, BlackboxCreateAgent, TeachAnything, DarkAI, Airforce, RubiksAI, PerplexityLabs])
 )
 
 # llama 3.2