From 6e0bc147b52cb1e52d7fb3f8dd01d1f33dae201e Mon Sep 17 00:00:00 2001
From: Heiner Lohaus <hlohaus@users.noreply.github.com>
Date: Fri, 3 Jan 2025 20:35:46 +0100
Subject: [PATCH] Support continue messages in Airforce Add auth caching for
 OpenAI ChatGPT Some provider improvments

---
 g4f/Provider/Airforce.py               |  14 +-
 g4f/Provider/Copilot.py                |   4 +-
 g4f/Provider/needs_auth/Gemini.py      |   4 +-
 g4f/Provider/needs_auth/HuggingFace.py |   2 +-
 g4f/Provider/needs_auth/OpenaiChat.py  | 100 ++++++------
 g4f/__init__.py                        |  18 +--
 g4f/client/__init__.py                 |  25 +--
 g4f/client/helper.py                   |   7 +-
 g4f/gui/client/home.html               |  19 ++-
 g4f/gui/client/static/css/style.css    |   6 +-
 g4f/gui/client/static/js/chat.v1.js    |   4 +-
 g4f/providers/asyncio.py               |  27 +++-
 g4f/providers/base_provider.py         | 203 ++++++++++++-------------
 g4f/providers/retry_provider.py        | 144 +++++-------------
 g4f/providers/types.py                 |  38 +----
 g4f/tools/run_tools.py                 |   6 +-
 g4f/tools/web_search.py                |   4 +-
 17 files changed, 284 insertions(+), 341 deletions(-)

diff --git a/g4f/Provider/Airforce.py b/g4f/Provider/Airforce.py
index 1444882c001..7986984074c 100644
--- a/g4f/Provider/Airforce.py
+++ b/g4f/Provider/Airforce.py
@@ -7,6 +7,7 @@
 
 from ..typing import AsyncResult, Messages
 from ..image import ImageResponse
+from ..providers.response import FinishReason, Usage
 from ..requests.raise_for_status import raise_for_status
 from .base_provider import AsyncGeneratorProvider, ProviderModelMixin
 
@@ -232,17 +233,19 @@ async def generate_text(
         data = {
             "messages": final_messages,
             "model": model,
-            "max_tokens": max_tokens,
             "temperature": temperature,
             "top_p": top_p,
             "stream": stream,
         }
+        if max_tokens != 512:
+            data["max_tokens"] = max_tokens
 
         async with ClientSession(headers=headers) as session:
             async with session.post(cls.api_endpoint_completions, json=data, proxy=proxy) as response:
                 await raise_for_status(response)
 
                 if stream:
+                    idx = 0
                     async for line in response.content:
                         line = line.decode('utf-8').strip()
                         if line.startswith('data: '):
@@ -255,11 +258,18 @@ async def generate_text(
                                         chunk = cls._filter_response(delta['content'])
                                         if chunk:
                                             yield chunk
+                                            idx += 1
                             except json.JSONDecodeError:
                                 continue
+                    if idx == 512:
+                        yield FinishReason("length")
                 else:
                     # Non-streaming response
                     result = await response.json()
+                    if "usage" in result:
+                        yield Usage(**result["usage"])
+                        if result["usage"]["completion_tokens"] == 512:
+                            yield FinishReason("length")
                     if 'choices' in result and result['choices']:
                         message = result['choices'][0].get('message', {})
                         content = message.get('content', '')
@@ -273,7 +283,7 @@ async def create_async_generator(
         messages: Messages,
         prompt: str = None,
         proxy: str = None,
-        max_tokens: int = 4096,
+        max_tokens: int = 512,
         temperature: float = 1,
         top_p: float = 1,
         stream: bool = True,
diff --git a/g4f/Provider/Copilot.py b/g4f/Provider/Copilot.py
index 828ab7187bc..76365da160d 100644
--- a/g4f/Provider/Copilot.py
+++ b/g4f/Provider/Copilot.py
@@ -90,7 +90,7 @@ def create_completion(
                         cls._access_token, cls._cookies = asyncio.run(get_access_token_and_cookies(cls.url, proxy))
                     else:
                         raise h
-            yield Parameters(**{"api_key": cls._access_token, "cookies": cls._cookies})
+            yield Parameters(**{"api_key": cls._access_token, "cookies": cls._cookies if isinstance(cls._cookies, dict) else {c.name: c.value for c in cls._cookies}})
             websocket_url = f"{websocket_url}&accessToken={quote(cls._access_token)}"
             headers = {"authorization": f"Bearer {cls._access_token}"}
 
@@ -191,6 +191,8 @@ def create_completion(
                         yield ImageResponse(msg.get("url"), image_prompt, {"preview": msg.get("thumbnailUrl")})
                     elif msg.get("event") == "done":
                         break
+                    elif msg.get("event") == "replaceText":
+                        yield msg.get("text")
                     elif msg.get("event") == "error":
                         raise RuntimeError(f"Error: {msg}")
                     elif msg.get("event") not in ["received", "startMessage", "citation", "partCompleted"]:
diff --git a/g4f/Provider/needs_auth/Gemini.py b/g4f/Provider/needs_auth/Gemini.py
index 1b5f17d6925..498137e596e 100644
--- a/g4f/Provider/needs_auth/Gemini.py
+++ b/g4f/Provider/needs_auth/Gemini.py
@@ -323,13 +323,13 @@ async def iter_filter_base64(chunks: AsyncIterator[bytes]) -> AsyncIterator[byte
     async for chunk in chunks:
         if is_started:
             if end_with in chunk:
-                yield chunk.split(end_with, 1, maxsplit=1).pop(0)
+                yield chunk.split(end_with, maxsplit=1).pop(0)
                 break
             else:
                 yield chunk
         elif search_for in chunk:
             is_started = True
-            yield chunk.split(search_for, 1, maxsplit=1).pop()
+            yield chunk.split(search_for, maxsplit=1).pop()
         else:
             raise ValueError(f"Response: {chunk}")
 
diff --git a/g4f/Provider/needs_auth/HuggingFace.py b/g4f/Provider/needs_auth/HuggingFace.py
index fd6c74f0324..e9c861e369b 100644
--- a/g4f/Provider/needs_auth/HuggingFace.py
+++ b/g4f/Provider/needs_auth/HuggingFace.py
@@ -111,7 +111,7 @@ async def create_async_generator(
                             messages = [m for m in messages if m["role"] == "system"] + [messages[-1]]
                         inputs = get_inputs(messages, model_data, model_type, do_continue)
                         debug.log(f"New len: {len(inputs)}")
-                    if model_type == "gpt2" and max_new_tokens >= 1024:
+                    if model_type == "gpt2" and max_tokens >= 1024:
                         params["max_new_tokens"] = 512
                 payload = {"inputs": inputs, "parameters": params, "stream": stream}
 
diff --git a/g4f/Provider/needs_auth/OpenaiChat.py b/g4f/Provider/needs_auth/OpenaiChat.py
index f15431e4209..7718ef39ae7 100644
--- a/g4f/Provider/needs_auth/OpenaiChat.py
+++ b/g4f/Provider/needs_auth/OpenaiChat.py
@@ -17,14 +17,14 @@
 except ImportError:
     has_nodriver = False
 
-from ..base_provider import AsyncGeneratorProvider, ProviderModelMixin
+from ..base_provider import AsyncAuthedProvider, ProviderModelMixin
 from ...typing import AsyncResult, Messages, Cookies, ImagesType
 from ...requests.raise_for_status import raise_for_status
 from ...requests import StreamSession
 from ...requests import get_nodriver
 from ...image import ImageResponse, ImageRequest, to_image, to_bytes, is_accepted_format
 from ...errors import MissingAuthError, NoValidHarFileError
-from ...providers.response import JsonConversation, FinishReason, SynthesizeData
+from ...providers.response import JsonConversation, FinishReason, SynthesizeData, AuthResult
 from ...providers.response import Sources, TitleGeneration, RequestLogin, Parameters
 from ..helper import format_cookies
 from ..openai.har_file import get_request_config
@@ -85,7 +85,7 @@
     "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
 }
 
-class OpenaiChat(AsyncGeneratorProvider, ProviderModelMixin):
+class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
     """A class for creating and managing conversations with OpenAI chat service"""
 
     label = "OpenAI ChatGPT"
@@ -104,6 +104,20 @@ class OpenaiChat(AsyncGeneratorProvider, ProviderModelMixin):
     _cookies: Cookies = None
     _expires: int = None
 
+    @classmethod
+    async def on_auth_async(cls, **kwargs) -> AuthResult:
+        if cls.needs_auth:
+            async for _ in cls.login():
+                pass
+        return AuthResult(
+            api_key=cls._api_key,
+            cookies=cls._cookies or RequestConfig.cookies or {},
+            headers=cls._headers or RequestConfig.headers or cls.get_default_headers(),
+            expires=cls._expires,
+            proof_token=RequestConfig.proof_token,
+            turnstile_token=RequestConfig.turnstile_token
+        )
+
     @classmethod
     def get_models(cls, proxy: str = None, timeout: int = 180) -> List[str]:
         if not cls.models:
@@ -135,7 +149,7 @@ def get_models(cls, proxy: str = None, timeout: int = 180) -> List[str]:
     async def upload_images(
         cls,
         session: StreamSession,
-        headers: dict,
+        auth_result: AuthResult,
         images: ImagesType,
     ) -> ImageRequest:
         """
@@ -160,8 +174,8 @@ async def upload_image(image, image_name):
                 "use_case":	"multimodal"
             }
             # Post the image data to the service and get the image data
-            async with session.post(f"{cls.url}/backend-api/files", json=data, headers=headers) as response:
-                cls._update_request_args(session)
+            async with session.post(f"{cls.url}/backend-api/files", json=data, headers=auth_result.headers) as response:
+                cls._update_request_args(auth_result, session)
                 await raise_for_status(response, "Create file failed")
                 image_data = {
                     **data,
@@ -189,9 +203,9 @@ async def upload_image(image, image_name):
             async with session.post(
                 f"{cls.url}/backend-api/files/{image_data['file_id']}/uploaded",
                 json={},
-                headers=headers
+                headers=auth_result.headers
             ) as response:
-                cls._update_request_args(session)
+                cls._update_request_args(auth_result, session)
                 await raise_for_status(response, "Get download url failed")
                 image_data["download_url"] = (await response.json())["download_url"]
             return ImageRequest(image_data)
@@ -248,7 +262,7 @@ def create_messages(cls, messages: Messages, image_requests: ImageRequest = None
         return messages
 
     @classmethod
-    async def get_generated_image(cls, session: StreamSession, headers: dict, element: dict, prompt: str = None) -> ImageResponse:
+    async def get_generated_image(cls, auth_result: AuthResult, session: StreamSession, element: dict, prompt: str = None) -> ImageResponse:
         try:
             prompt = element["metadata"]["dalle"]["prompt"]
             file_id = element["asset_pointer"].split("file-service://", 1)[1]
@@ -257,8 +271,8 @@ async def get_generated_image(cls, session: StreamSession, headers: dict, elemen
         except Exception as e:
             raise RuntimeError(f"No Image: {e.__class__.__name__}: {e}")
         try:
-            async with session.get(f"{cls.url}/backend-api/files/{file_id}/download", headers=headers) as response:
-                cls._update_request_args(session)
+            async with session.get(f"{cls.url}/backend-api/files/{file_id}/download", headers=auth_result.headers) as response:
+                cls._update_request_args(auth_result, session)
                 await raise_for_status(response)
                 download_url = (await response.json())["download_url"]
                 return ImageResponse(download_url, prompt)
@@ -266,10 +280,11 @@ async def get_generated_image(cls, session: StreamSession, headers: dict, elemen
             raise RuntimeError(f"Error in downloading image: {e}")
 
     @classmethod
-    async def create_async_generator(
+    async def create_authed(
         cls,
         model: str,
         messages: Messages,
+        auth_result: AuthResult,
         proxy: str = None,
         timeout: int = 180,
         auto_continue: bool = False,
@@ -279,7 +294,7 @@ async def create_async_generator(
         conversation: Conversation = None,
         images: ImagesType = None,
         return_conversation: bool = False,
-        max_retries: int = 3,
+        max_retries: int = 0,
         web_search: bool = False,
         **kwargs
     ) -> AsyncResult:
@@ -306,9 +321,6 @@ async def create_async_generator(
         Raises:
             RuntimeError: If an error occurs during processing.
         """
-        if cls.needs_auth:
-            async for message in cls.login(proxy, **kwargs):
-                yield message
         async with StreamSession(
             proxy=proxy,
             impersonate="chrome",
@@ -319,15 +331,18 @@ async def create_async_generator(
                 if cls._headers is None:
                     cls._create_request_args(cls._cookies)
                     async with session.get(cls.url, headers=INIT_HEADERS) as response:
-                        cls._update_request_args(session)
+                        cls._update_request_args(auth_result, session)
                         await raise_for_status(response)
             else:
-                print(cls._headers)
-                async with session.get(cls.url, headers=cls._headers) as response:
-                    cls._update_request_args(session)
+                if cls._headers is 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:
+                    cls._update_request_args(auth_result, session)
                     await raise_for_status(response)
                 try:
-                    image_requests = await cls.upload_images(session, cls._headers, images) if images else None
+                    image_requests = await cls.upload_images(session, auth_result, images) if images else None
                 except Exception as e:
                     debug.log("OpenaiChat: Upload image failed")
                     debug.log(f"{e.__class__.__name__}: {e}")
@@ -345,36 +360,36 @@ async def create_async_generator(
                     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": get_requirements_token(RequestConfig.proof_token) if RequestConfig.proof_token else None},
+                    json={"p": None if auth_result.proof_token is None else get_requirements_token(auth_result.proof_token)},
                     headers=cls._headers
                 ) as response:
                     if response.status == 401:
                         cls._headers = cls._api_key = None
                     else:
-                        cls._update_request_args(session)
+                        cls._update_request_args(auth_result, session)
                     await raise_for_status(response)
                     chat_requirements = await response.json()
                     need_turnstile = chat_requirements.get("turnstile", {}).get("required", False)
                     need_arkose = chat_requirements.get("arkose", {}).get("required", False) 
                     chat_token = chat_requirements.get("token")  
 
-                if need_arkose and RequestConfig.arkose_token is None:
-                    await get_request_config(proxy)
-                    cls._create_request_args(RequestConfig.cookies, RequestConfig.headers)
-                    cls._set_api_key(RequestConfig.access_token)
-                    if RequestConfig.arkose_token is None:
-                        raise MissingAuthError("No arkose token found in .har file")
+                # if need_arkose and RequestConfig.arkose_token is None:
+                #     await get_request_config(proxy)
+                #     cls._create_request_args(auth_result.cookies, auth_result.headers)
+                #     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 RequestConfig.proof_token is None:
-                        RequestConfig.proof_token = get_config(cls._headers.get("user-agent"))
+                    if 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=cls._headers.get("user-agent"),
-                        proof_token=RequestConfig.proof_token
+                        user_agent=auth_result.headers.get("user-agent"),
+                        proof_token=auth_result.proof_token
                     )
                 [debug.log(text) for text in (
-                    f"Arkose: {'False' if not need_arkose else RequestConfig.arkose_token[:12]+'...'}",
+                    #f"Arkose: {'False' if not need_arkose else auth_result.arkose_token[:12]+'...'}",
                     f"Proofofwork: {'False' if proofofwork is None else proofofwork[:12]+'...'}",
                     f"AccessToken: {'False' if cls._api_key is None else cls._api_key[:12]+'...'}",
                 )]
@@ -414,12 +429,12 @@ async def create_async_generator(
                     "content-type": "application/json",
                     "openai-sentinel-chat-requirements-token": chat_token,
                 }
-                if RequestConfig.arkose_token:
-                    headers["openai-sentinel-arkose-token"] = RequestConfig.arkose_token
+                #if RequestConfig.arkose_token:
+                #    headers["openai-sentinel-arkose-token"] = RequestConfig.arkose_token
                 if proofofwork is not None:
                     headers["openai-sentinel-proof-token"] = proofofwork
-                if need_turnstile and RequestConfig.turnstile_token is not None:
-                    headers['openai-sentinel-turnstile-token'] = RequestConfig.turnstile_token
+                if need_turnstile and auth_result.turnstile_token is not None:
+                    headers['openai-sentinel-turnstile-token'] = auth_result.turnstile_token
                 async with session.post(
                     f"{cls.url}/backend-anon/conversation"
                     if cls._api_key is None else
@@ -427,7 +442,7 @@ async def create_async_generator(
                     json=data,
                     headers=headers
                 ) as response:
-                    cls._update_request_args(session)
+                    cls._update_request_args(auth_result, session)
                     if response.status in (403, 404) and max_retries > 0:
                         max_retries -= 1
                         debug.log(f"Retry: Error {response.status}: {await response.text()}")
@@ -462,7 +477,7 @@ def replacer(match):
                     yield sources
                 if return_conversation:
                     yield conversation
-                if not history_disabled and cls._api_key is not None:
+                if not history_disabled and auth_result.api_key is not None:
                     yield SynthesizeData(cls.__name__, {
                         "conversation_id": conversation.conversation_id,
                         "message_id": conversation.message_id,
@@ -587,7 +602,6 @@ async def login(
             try:
                 await get_request_config(proxy)
                 cls._create_request_args(RequestConfig.cookies, RequestConfig.headers)
-                print(RequestConfig.access_token)
                 if RequestConfig.access_token is not None or cls.needs_auth:
                     if not cls._set_api_key(RequestConfig.access_token):
                         raise NoValidHarFileError(f"Access token is not valid: {RequestConfig.access_token}")
@@ -673,9 +687,9 @@ def _create_request_args(cls, cookies: Cookies = None, headers: dict = None, use
         cls._update_cookie_header()
 
     @classmethod
-    def _update_request_args(cls, session: StreamSession):
+    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:
-            cls._cookies[getattr(c, "key", getattr(c, "name", ""))] = c.value
+            auth_result.cookies[getattr(c, "key", getattr(c, "name", ""))] = c.value
         cls._update_cookie_header()
 
     @classmethod
diff --git a/g4f/__init__.py b/g4f/__init__.py
index 86aa99504c0..17d10b8bae5 100644
--- a/g4f/__init__.py
+++ b/g4f/__init__.py
@@ -11,7 +11,7 @@
 from .errors import StreamNotSupportedError
 from .cookies import get_cookies, set_cookies
 from .providers.types import ProviderType
-from .providers.helper import concat_chunks
+from .providers.helper import concat_chunks, async_concat_chunks
 from .client.service import get_model_and_provider
 
 #Configure "g4f" logger
@@ -47,8 +47,7 @@ def create(model    : Union[Model, str],
         if ignore_stream:
             kwargs["ignore_stream"] = True
 
-        create_method = provider.create_authed if hasattr(provider, "create_authed") else provider.create_completion
-        result = create_method(model, messages, stream=stream, **kwargs)
+        result = provider.get_create_function()(model, messages, stream=stream, **kwargs)
 
         return result if stream else concat_chunks(result)
 
@@ -72,11 +71,10 @@ def create_async(model    : Union[Model, str],
         if ignore_stream:
             kwargs["ignore_stream"] = True
 
-        if stream:
-            if hasattr(provider, "create_async_authed_generator"):
-                return provider.create_async_authed_generator(model, messages, **kwargs)
-            elif hasattr(provider, "create_async_generator"):
-                return provider.create_async_generator(model, messages, **kwargs)
-            raise StreamNotSupportedError(f'{provider.__name__} does not support "stream" argument in "create_async"')
+        result = provider.get_async_create_function()(model, messages, stream=stream, **kwargs)
 
-        return provider.create_async(model, messages, **kwargs)
\ No newline at end of file
+        if not stream:
+            if hasattr(result, "__aiter__"):
+                result = async_concat_chunks(result)
+
+        return result
\ No newline at end of file
diff --git a/g4f/client/__init__.py b/g4f/client/__init__.py
index d38e923c792..cca85db4de1 100644
--- a/g4f/client/__init__.py
+++ b/g4f/client/__init__.py
@@ -15,14 +15,14 @@
 from ..providers.response import ResponseType, FinishReason, BaseConversation, SynthesizeData, ToolCalls, Usage
 from ..errors import NoImageResponseError
 from ..providers.retry_provider import IterListProvider
-from ..providers.asyncio import to_sync_generator, async_generator_to_list
+from ..providers.asyncio import to_sync_generator
 from ..Provider.needs_auth import BingCreateImages, OpenaiAccount
 from ..tools.run_tools import async_iter_run_tools, iter_run_tools
 from .stubs import ChatCompletion, ChatCompletionChunk, Image, ImagesResponse
 from .image_models import ImageModels
 from .types import IterResponse, ImageProvider, Client as BaseClient
 from .service import get_model_and_provider, convert_to_provider
-from .helper import find_stop, filter_json, filter_none, safe_aclose, to_async_iterator
+from .helper import find_stop, filter_json, filter_none, safe_aclose
 from .. import debug
 
 ChatCompletionResponseType = Iterator[Union[ChatCompletion, ChatCompletionChunk, BaseConversation]]
@@ -236,7 +236,7 @@ def create(
             kwargs["ignore_stream"] = True
 
         response = iter_run_tools(
-            provider.create_authed if hasattr(provider, "create_authed") else provider.create_completion,
+            provider.get_create_function(),
             model,
             messages,
             stream=stream,
@@ -248,12 +248,9 @@ def create(
             ),
             **kwargs
         )
-        if stream and hasattr(response, '__aiter__'):
-            # It's an async generator, wrap it into a sync iterator
-            response = to_sync_generator(response)
-        elif hasattr(response, '__aiter__'):
-            # If response is an async generator, collect it into a list
-            response = asyncio.run(async_generator_to_list(response))
+        if not hasattr(response, '__iter__'):
+            response = [response]
+
         response = iter_response(response, stream, response_format, max_tokens, stop)
         response = iter_append_model_and_provider(response, model, provider)
         if stream:
@@ -526,14 +523,8 @@ def create(
             kwargs["images"] = [(image, image_name)]
         if ignore_stream:
             kwargs["ignore_stream"] = True
-        if hasattr(provider, "create_async_authed_generator"):
-            create_handler = provider.create_async_authed_generator
-        if hasattr(provider, "create_async_generator"):
-            create_handler = provider.create_async_generator
-        else:
-            create_handler = provider.create_completion
         response = async_iter_run_tools(
-            create_handler,
+            provider.get_async_create_function(),
             model,
             messages,
             stream=stream,
@@ -545,8 +536,6 @@ def create(
             ),
             **kwargs
         )
-        if not hasattr(response, '__aiter__'):
-            response = to_async_iterator(response)
         response = async_iter_response(response, stream, response_format, max_tokens, stop)
         response = async_iter_append_model_and_provider(response, model, provider)
         return response if stream else anext(response)
diff --git a/g4f/client/helper.py b/g4f/client/helper.py
index 67bfac43bdb..d0975806ebb 100644
--- a/g4f/client/helper.py
+++ b/g4f/client/helper.py
@@ -62,9 +62,4 @@ async def safe_aclose(generator: AsyncGenerator) -> None:
         if generator and hasattr(generator, 'aclose'):
             await generator.aclose()
     except Exception as e:
-        logging.warning(f"Error while closing generator: {e}")
-
-# Helper function to convert a synchronous iterator to an async iterator
-async def to_async_iterator(iterator: Iterator) -> AsyncIterator:
-    for item in iterator:
-        yield item
\ No newline at end of file
+        logging.warning(f"Error while closing generator: {e}")
\ No newline at end of file
diff --git a/g4f/gui/client/home.html b/g4f/gui/client/home.html
index f8af0d02705..2ca678be876 100644
--- a/g4f/gui/client/home.html
+++ b/g4f/gui/client/home.html
@@ -175,6 +175,7 @@
             }
         }
     </style>
+    <script src="https://cdn.jsdelivr.net/npm/markdown-it@13.0.1/dist/markdown-it.min.js"></script>
 </head>
 <body>
     <iframe id="background"></iframe>
@@ -206,12 +207,24 @@
             <p>Powered by the G4F framework</p>
         </div>
 
-        <iframe id="stream-widget" class="stream" data-src="/backend-api/v2/create?prompt=Create of overview of the news in plain text&stream=1&web_search=news in " class="" frameborder="0"></iframe>
+        <iframe id="stream-widget" class="stream" frameborder="0"></iframe>
     </div>
     <script>
-        const iframe = document.getElementById('stream-widget');
-        iframe.src = iframe.dataset.src + navigator.language;
+        const iframe = document.getElementById('stream-widget');""
+        let search = (navigator.language == "de" ? "news in deutschland" : navigator.language == "en" ? "world news" : navigator.language);
+        if (Math.floor(Math.random() * 6) % 2 == 0) {
+            search = "xtekky/gpt4free releases";
+        }
+        const url = "/backend-api/v2/create?prompt=Create of overview of the news in plain text&stream=1&web_search=" + search;
+        iframe.src = url;
         setTimeout(()=>iframe.classList.add('show'), 3000);
+        iframe.onload = () => {
+            const iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
+            const iframeBody = iframeDocument.querySelector("body");
+            const iframeContent = iframeDocument.querySelector("pre");
+            const markdown = window.markdownit();
+            iframeBody.innerHTML = markdown.render(iframeContent.innerHTML);
+        }
 
         (async () => {
             const prompt = `
diff --git a/g4f/gui/client/static/css/style.css b/g4f/gui/client/static/css/style.css
index 6878766e231..1fefbf34078 100644
--- a/g4f/gui/client/static/css/style.css
+++ b/g4f/gui/client/static/css/style.css
@@ -564,7 +564,7 @@ body:not(.white) a:visited{
     height: 20px;
     width: 100px;
     transition: all 0.1s;
-    background: var(--colour-5);
+    background: var(--button-hover);
     margin-top: -30px;
     z-index: 1005;
     padding: 6px;
@@ -683,7 +683,7 @@ label[for="camera"] {
 #messages form {
     position: absolute;
     width: 100%;
-    background: var(--colour-5);
+    background: var(--button-hover);
     z-index: 2000;
 }
 
@@ -1354,7 +1354,7 @@ form .field.saved .fa-xmark {
 .settings .label, form .label, .settings label, form label {
     font-size: 15px;
     margin-left: var(--inner-gap);
-    min-width: 120px;
+    min-width: 200px;
 }
 
 .settings .label, form .label {
diff --git a/g4f/gui/client/static/js/chat.v1.js b/g4f/gui/client/static/js/chat.v1.js
index 5466c5788ec..8f995315253 100644
--- a/g4f/gui/client/static/js/chat.v1.js
+++ b/g4f/gui/client/static/js/chat.v1.js
@@ -2111,8 +2111,10 @@ if (SpeechRecognition) {
         microLabel.classList.add("recognition");
         startValue = messageInput.value;
         lastDebounceTranscript = "";
+        messageInput.readOnly = true;
     };
     recognition.onend = function() {
+        messageInput.readOnly = false;
         messageInput.focus();
     };
     recognition.onresult = function(event) {
@@ -2138,7 +2140,7 @@ if (SpeechRecognition) {
         }
     };
 
-    microLabel.addEventListener("click", () => {
+    microLabel.addEventListener("click", (e) => {
         if (microLabel.classList.contains("recognition")) {
             recognition.stop();
             microLabel.classList.remove("recognition");
diff --git a/g4f/providers/asyncio.py b/g4f/providers/asyncio.py
index 2b83bfeb6a9..bea57fb3bf3 100644
--- a/g4f/providers/asyncio.py
+++ b/g4f/providers/asyncio.py
@@ -2,7 +2,7 @@
 
 import asyncio
 from asyncio import AbstractEventLoop, runners
-from typing import Optional, Callable, AsyncGenerator, Generator
+from typing import Optional, Callable, AsyncIterator, Iterator
 
 from ..errors import NestAsyncioError
 
@@ -37,10 +37,14 @@ def get_running_loop(check_nested: bool) -> Optional[AbstractEventLoop]:
 async def await_callback(callback: Callable):
     return await callback()
 
-async def async_generator_to_list(generator: AsyncGenerator) -> list:
+async def async_generator_to_list(generator: AsyncIterator) -> list:
     return [item async for item in generator]
 
-def to_sync_generator(generator: AsyncGenerator) -> Generator:
+def to_sync_generator(generator: AsyncIterator, stream: bool = True) -> Iterator:
+    if not stream:
+        yield from asyncio.run(async_generator_to_list(generator))
+        return
+
     loop = get_running_loop(check_nested=False)
     new_loop = False
     if loop is None:
@@ -62,4 +66,19 @@ def to_sync_generator(generator: AsyncGenerator) -> Generator:
                     loop.run_until_complete(loop.shutdown_default_executor())
             finally:
                 asyncio.set_event_loop(None)
-                loop.close()
\ No newline at end of file
+                loop.close()
+
+# Helper function to convert a synchronous iterator to an async iterator
+async def to_async_iterator(iterator: Iterator) -> AsyncIterator:
+    if isinstance(iterator, str):
+        yield iterator
+    elif hasattr(iterator, "__await__"):
+        yield await iterator
+    elif hasattr(iterator, "__aiter__"):
+        async for item in iterator:
+            yield item
+    elif hasattr(iterator, "__iter__"):
+        for item in iterator:
+            yield item
+    else:
+        yield iterator
\ No newline at end of file
diff --git a/g4f/providers/base_provider.py b/g4f/providers/base_provider.py
index ec0f354bea1..82d1ea61df6 100644
--- a/g4f/providers/base_provider.py
+++ b/g4f/providers/base_provider.py
@@ -7,7 +7,7 @@
 from abc import abstractmethod
 import json
 from inspect import signature, Parameter
-from typing import Optional, Awaitable, _GenericAlias
+from typing import Optional, _GenericAlias
 from pathlib import Path
 try:
     from types import NoneType
@@ -16,11 +16,11 @@
 
 from ..typing import CreateResult, AsyncResult, Messages
 from .types import BaseProvider
-from .asyncio import get_running_loop, to_sync_generator
+from .asyncio import get_running_loop, to_sync_generator, to_async_iterator
 from .response import BaseConversation, AuthResult
 from .helper import concat_chunks, async_concat_chunks
 from ..cookies import get_cookies_dir
-from ..errors import ModelNotSupportedError, ResponseError, MissingAuthError
+from ..errors import ModelNotSupportedError, ResponseError, MissingAuthError, NoValidHarFileError
 from .. import debug
 
 SAFE_PARAMETERS = [
@@ -31,7 +31,7 @@
     "temperature",  "top_k", "top_p",
     "frequency_penalty", "presence_penalty",
     "max_tokens", "max_new_tokens", "stop",
-    "api_key", "seed", "width", "height",
+    "api_key", "api_base", "seed", "width", "height",
     "proof_token", "max_retries"
 ]
 
@@ -63,9 +63,29 @@
 }
 
 class AbstractProvider(BaseProvider):
-    """
-    Abstract class for providing asynchronous functionality to derived classes.
-    """
+
+    @classmethod
+    @abstractmethod
+    def create_completion(
+        cls,
+        model: str,
+        messages: Messages,
+        stream: bool,
+        **kwargs
+    ) -> CreateResult:
+        """
+        Create a completion with the given parameters.
+
+        Args:
+            model (str): The model to use.
+            messages (Messages): The messages to process.
+            stream (bool): Whether to use streaming.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            CreateResult: The result of the creation process.
+        """
+        raise NotImplementedError()
 
     @classmethod
     async def create_async(
@@ -92,16 +112,24 @@ async def create_async(
         Returns:
             str: The created result as a string.
         """
-        loop = loop or asyncio.get_running_loop()
+        loop = asyncio.get_running_loop() if loop is None else loop
 
         def create_func() -> str:
-            return concat_chunks(cls.create_completion(model, messages, False, **kwargs))
+            return concat_chunks(cls.create_completion(model, messages, **kwargs))
 
         return await asyncio.wait_for(
             loop.run_in_executor(executor, create_func),
             timeout=timeout
         )
-    
+
+    @classmethod
+    def get_create_function(cls) -> callable:
+        return cls.create_completion
+
+    @classmethod
+    def get_async_create_function(cls) -> callable:
+        return cls.create_async
+
     @classmethod
     def get_parameters(cls, as_json: bool = False) -> dict[str, Parameter]:
         params = {name: parameter for name, parameter in signature(
@@ -149,7 +177,7 @@ def get_type_as_var(annotation: type, key: str, default):
             ) for name, param in {
                 **BASIC_PARAMETERS,
                 **params,
-                **{"provider": cls.__name__, "stream": cls.supports_stream, "model": getattr(cls, "default_model", "")},
+                **{"provider": cls.__name__, "model": getattr(cls, "default_model", ""), "stream": cls.supports_stream},
             }.items()}
         return params
 
@@ -233,6 +261,14 @@ async def create_async(
         """
         raise NotImplementedError()
 
+    @classmethod
+    def get_create_function(cls) -> callable:
+        return cls.create_completion
+
+    @classmethod
+    def get_async_create_function(cls) -> callable:
+        return cls.create_async
+
 class AsyncGeneratorProvider(AsyncProvider):
     """
     Provides asynchronous generator functionality for streaming results.
@@ -262,30 +298,10 @@ def create_completion(
             CreateResult: The result of the streaming completion creation.
         """
         return to_sync_generator(
-            cls.create_async_generator(model, messages, stream=stream, **kwargs)
+            cls.create_async_generator(model, messages, stream=stream, **kwargs),
+            stream=stream
         )
 
-    @classmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: Messages,
-        **kwargs
-    ) -> str:
-        """
-        Asynchronously creates a result from a generator.
-
-        Args:
-            cls (type): The class on which this method is called.
-            model (str): The model to use for creation.
-            messages (Messages): The messages to process.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            str: The created result as a string.
-        """
-        return await async_concat_chunks(cls.create_async_generator(model, messages, stream=False, **kwargs))
-
     @staticmethod
     @abstractmethod
     async def create_async_generator(
@@ -311,11 +327,13 @@ async def create_async_generator(
         """
         raise NotImplementedError()
 
-    create_authed = create_completion
-
-    create_authed_async = create_async
+    @classmethod
+    def get_create_function(cls) -> callable:
+        return cls.create_completion
 
-    create_async_authed = create_async_generator
+    @classmethod
+    def get_async_create_function(cls) -> callable:
+        return cls.create_async_generator
 
 class ProviderModelMixin:
     default_model: str = None
@@ -357,97 +375,76 @@ def raise_error(data: dict):
             else:
                 raise ResponseError(data["error"])
 
-class AuthedMixin():
+class AsyncAuthedProvider(AsyncGeneratorProvider):
 
     @classmethod
-    def on_auth(cls, **kwargs) -> Optional[AuthResult]:
+    async def on_auth_async(cls, **kwargs) -> AuthResult:
        if "api_key" not in kwargs:
            raise MissingAuthError(f"API key is required for {cls.__name__}")
-       return None
+       return AuthResult()
 
     @classmethod
-    def create_authed(
-        cls,
-        model: str,
-        messages: Messages,
-        **kwargs
-    ) -> CreateResult:
-        auth_result = {}
-        cache_file = Path(get_cookies_dir()) / f"auth_{cls.__name__}.json"
-        if cache_file.exists():
-            with cache_file.open("r") as f:
-                auth_result = json.load(f)
-            return cls.create_completion(model, messages, **kwargs, **auth_result)
-        auth_result = cls.on_auth(**kwargs)
-        try:
-            return cls.create_completion(model, messages, **kwargs)
-        finally:
-            cache_file.parent.mkdir(parents=True, exist_ok=True)
-            cache_file.write_text(json.dumps(auth_result.get_dict()))
+    def on_auth(cls, **kwargs) -> AuthResult:
+        return asyncio.run(cls.on_auth_async(**kwargs))
 
-class AsyncAuthedMixin(AuthedMixin):
     @classmethod
-    async def create_async_authed(
-        cls,
-        model: str,
-        messages: Messages,
-        **kwargs
-    ) -> str:
-        cache_file = Path(get_cookies_dir()) / f"auth_{cls.__name__}.json"
-        if cache_file.exists():
-            auth_result = {}
-            with cache_file.open("r") as f:
-                auth_result = json.load(f)
-            return cls.create_completion(model, messages, **kwargs, **auth_result)
-        auth_result = cls.on_auth(**kwargs)
-        try:
-            return await cls.create_async(model, messages, **kwargs)
-        finally:
-            if auth_result is not None:
-                cache_file.parent.mkdir(parents=True, exist_ok=True)
-                cache_file.write_text(json.dumps(auth_result.get_dict()))
+    def get_create_function(cls) -> callable:
+        return cls.create_completion
 
-class AsyncAuthedGeneratorMixin(AsyncAuthedMixin):
+    @classmethod
+    def get_async_create_function(cls) -> callable:
+        return cls.create_async_generator
 
     @classmethod
-    async def create_async_authed(
+    def create_completion(
         cls,
         model: str,
         messages: Messages,
         **kwargs
-    ) -> str:
-        cache_file = Path(get_cookies_dir()) / f"auth_{cls.__name__}.json"
-        if cache_file.exists():
-            auth_result = {}
-            with cache_file.open("r") as f:
-                auth_result = json.load(f)
-            return cls.create_completion(model, messages, **kwargs, **auth_result)
-        auth_result = cls.on_auth(**kwargs)
+    ) -> CreateResult:
         try:
-            return await async_concat_chunks(cls.create_async_generator(model, messages, stream=False, **kwargs))
+            auth_result = AuthResult()
+            cache_file = Path(get_cookies_dir()) / f"auth_{cls.parent if hasattr(cls, 'parent') else cls.__name__}.json"
+            if cache_file.exists():
+                with cache_file.open("r") as f:
+                    auth_result = AuthResult(**json.load(f))
+            else:
+                auth_result = cls.on_auth(**kwargs)
+            return 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)
+            return to_sync_generator(cls.create_authed(model, messages, auth_result, **kwargs))
         finally:
-            if auth_result is not None:
                 cache_file.parent.mkdir(parents=True, exist_ok=True)
                 cache_file.write_text(json.dumps(auth_result.get_dict()))
 
-    @classmethod
-    def create_async_authed_generator(
+    async def create_async_generator(
         cls,
         model: str,
         messages: Messages,
-        stream: bool = True,
         **kwargs
-    ) -> Awaitable[AsyncResult]:
-        cache_file = Path(get_cookies_dir()) / f"auth_{cls.__name__}.json"
-        if cache_file.exists():
-            auth_result = {}
-            with cache_file.open("r") as f:
-                auth_result = json.load(f)
-            return cls.create_completion(model, messages, **kwargs, **auth_result)
-        auth_result = cls.on_auth(**kwargs)
+    ) -> AsyncResult:
         try:
-            return cls.create_async_generator(model, messages, stream=stream, **kwargs)
+            auth_result = AuthResult()
+            cache_file = Path(get_cookies_dir()) / f"auth_{cls.parent if hasattr(cls, 'parent') else cls.__name__}.json"
+            if cache_file.exists():
+                with cache_file.open("r") as f:
+                    auth_result = AuthResult(**json.load(f))
+            else:
+                auth_result = await cls.on_auth_async(**kwargs)
+            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)
+            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:
                 cache_file.parent.mkdir(parents=True, exist_ok=True)
-                cache_file.write_text(json.dumps(auth_result.get_dict()))
+                cache_file.write_text(json.dumps(auth_result.get_dict()))
\ No newline at end of file
diff --git a/g4f/providers/retry_provider.py b/g4f/providers/retry_provider.py
index 556da659b28..a24e820e201 100644
--- a/g4f/providers/retry_provider.py
+++ b/g4f/providers/retry_provider.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import random
 
 from ..typing import Type, List, CreateResult, Messages, AsyncResult
@@ -8,8 +7,6 @@
 from .. import debug
 from ..errors import RetryProviderError, RetryNoProviderError
 
-DEFAULT_TIMEOUT = 60
-
 class IterListProvider(BaseRetryProvider):
     def __init__(
         self,
@@ -56,10 +53,15 @@ def create_completion(
             self.last_provider = provider
             debug.log(f"Using {provider.__name__} provider")
             try:
-                for chunk in provider.create_completion(model, messages, stream, **kwargs):
-                    if chunk:
-                        yield chunk
-                        started = True
+                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
                 if started:
                     return
             except Exception as e:
@@ -70,41 +72,6 @@ def create_completion(
 
         raise_exceptions(exceptions)
 
-    async def create_async(
-        self,
-        model: str,
-        messages: Messages,
-        ignored: list[str] = [],
-        **kwargs,
-    ) -> str:
-        """
-        Asynchronously create a completion using available providers.
-        Args:
-            model (str): The model to be used for completion.
-            messages (Messages): The messages to be used for generating completion.
-        Returns:
-            str: The result of the asynchronous completion.
-        Raises:
-            Exception: Any exception encountered during the asynchronous completion process.
-        """
-        exceptions = {}
-
-        for provider in self.get_providers(False, ignored):
-            self.last_provider = provider
-            debug.log(f"Using {provider.__name__} provider")
-            try:
-                chunk = await asyncio.wait_for(
-                    provider.create_async(model, messages, **kwargs),
-                    timeout=kwargs.get("timeout", DEFAULT_TIMEOUT),
-                )
-                if chunk:
-                    return chunk
-            except Exception as e:
-                exceptions[provider.__name__] = e
-                debug.log(f"{provider.__name__}: {e.__class__.__name__}: {e}")
-
-        raise_exceptions(exceptions)
-
     async def create_async_generator(
         self,
         model: str,
@@ -121,22 +88,16 @@ async def create_async_generator(
             self.last_provider = provider
             debug.log(f"Using {provider.__name__} provider")
             try:
-                if not stream:
-                    chunk = await asyncio.wait_for(
-                        provider.create_async(model, messages, **kwargs),
-                        timeout=kwargs.get("timeout", DEFAULT_TIMEOUT),
-                    )
-                    if chunk:
-                        yield chunk
-                        started = True
-                elif hasattr(provider, "create_async_generator"):
-                    async for chunk in provider.create_async_generator(model, messages, stream=stream, **kwargs):
+                response = provider.get_async_create_function()(model, messages, stream=stream, **kwargs)
+                if hasattr(response, "__aiter__"):
+                    async for chunk in response:
                         if chunk:
                             yield chunk
                             started = True
-                else:
-                    for token in provider.create_completion(model, messages, stream, **kwargs):
-                        yield token
+                elif response:
+                    response = await response
+                    if response:
+                        yield response
                         started = True
                 if started:
                     return
@@ -148,6 +109,12 @@ async def create_async_generator(
 
         raise_exceptions(exceptions)
 
+    def get_create_function(self) -> callable:
+        return self.create_completion
+
+    def get_async_create_function(self) -> callable:
+        return self.create_async_generator
+
     def get_providers(self, stream: bool, ignored: list[str]) -> list[ProviderType]:
         providers = [p for p in self.providers if (p.supports_stream or not stream) and p.__name__ not in ignored]
         if self.shuffle:
@@ -201,8 +168,14 @@ def create_completion(
                 try:
                     if debug.logging:
                         print(f"Using {provider.__name__} provider (attempt {attempt + 1})")
-                    for token in provider.create_completion(model, messages, stream, **kwargs):
-                        yield token
+                    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
                     if started:
                         return
@@ -216,43 +189,6 @@ def create_completion(
         else:
             yield from super().create_completion(model, messages, stream, **kwargs)
 
-    async def create_async(
-        self,
-        model: str,
-        messages: Messages,
-        **kwargs,
-    ) -> str:
-        """
-        Asynchronously create a completion using available providers.
-        Args:
-            model (str): The model to be used for completion.
-            messages (Messages): The messages to be used for generating completion.
-        Returns:
-            str: The result of the asynchronous completion.
-        Raises:
-            Exception: Any exception encountered during the asynchronous completion process.
-        """
-        exceptions = {}
-
-        if self.single_provider_retry:
-            provider = self.providers[0]
-            self.last_provider = provider
-            for attempt in range(self.max_retries):
-                try:
-                    if debug.logging:
-                        print(f"Using {provider.__name__} provider (attempt {attempt + 1})")
-                    return await asyncio.wait_for(
-                        provider.create_async(model, messages, **kwargs),
-                        timeout=kwargs.get("timeout", 60),
-                    )
-                except Exception as e:
-                    exceptions[provider.__name__] = e
-                    if debug.logging:
-                        print(f"{provider.__name__}: {e.__class__.__name__}: {e}")
-            raise_exceptions(exceptions)
-        else:
-            return await super().create_async(model, messages, **kwargs)
-
     async def create_async_generator(
         self,
         model: str,
@@ -269,22 +205,16 @@ async def create_async_generator(
             for attempt in range(self.max_retries):
                 try:
                     debug.log(f"Using {provider.__name__} provider (attempt {attempt + 1})")
-                    if not stream:
-                        chunk = await asyncio.wait_for(
-                            provider.create_async(model, messages, **kwargs),
-                            timeout=kwargs.get("timeout", DEFAULT_TIMEOUT),
-                        )
-                        if chunk:
-                            yield chunk
-                            started = True
-                    elif hasattr(provider, "create_async_generator"):
-                        async for chunk in provider.create_async_generator(model, messages, stream=stream, **kwargs):
+                    response = provider.get_async_create_function()(model, messages, stream=stream, **kwargs)
+                    if hasattr(response, "__aiter__"):
+                        async for chunk in response:
                             if chunk:
                                 yield chunk
                                 started = True
                     else:
-                        for token in provider.create_completion(model, messages, stream, **kwargs):
-                            yield token
+                        response = await response
+                        if response:
+                            yield response
                             started = True
                     if started:
                         return
@@ -296,7 +226,7 @@ async def create_async_generator(
         else:
             async for chunk in super().create_async_generator(model, messages, stream, **kwargs):
                 yield chunk
-
+                
 def raise_exceptions(exceptions: dict) -> None:
     """
     Raise a combined exception if any occurred during retries.
diff --git a/g4f/providers/types.py b/g4f/providers/types.py
index 9af911ea806..44a3f0b3649 100644
--- a/g4f/providers/types.py
+++ b/g4f/providers/types.py
@@ -26,50 +26,26 @@ class BaseProvider(ABC):
     supports_system_message: bool = False
     params: str
 
-    @classmethod
     @abstractmethod
-    def create_completion(
-        cls,
-        model: str,
-        messages: Messages,
-        stream: bool,
-        **kwargs
-    ) -> CreateResult:
+    def get_create_function() -> callable:
         """
-        Create a completion with the given parameters.
-
-        Args:
-            model (str): The model to use.
-            messages (Messages): The messages to process.
-            stream (bool): Whether to use streaming.
-            **kwargs: Additional keyword arguments.
+        Get the create function for the provider.
 
         Returns:
-            CreateResult: The result of the creation process.
+            callable: The create function.
         """
         raise NotImplementedError()
 
-    @classmethod
     @abstractmethod
-    async def create_async(
-        cls,
-        model: str,
-        messages: Messages,
-        **kwargs
-    ) -> str:
+    def get_async_create_function() -> callable:
         """
-        Asynchronously create a completion with the given parameters.
-
-        Args:
-            model (str): The model to use.
-            messages (Messages): The messages to process.
-            **kwargs: Additional keyword arguments.
+        Get the async create function for the provider.
 
         Returns:
-            str: The result of the creation process.
+            callable: The create function.
         """
         raise NotImplementedError()
-    
+
     @classmethod
     def get_dict(cls) -> Dict[str, str]:
         """
diff --git a/g4f/tools/run_tools.py b/g4f/tools/run_tools.py
index 21e8c7bed2d..f52623e9a56 100644
--- a/g4f/tools/run_tools.py
+++ b/g4f/tools/run_tools.py
@@ -7,7 +7,7 @@
 
 from ..typing import Messages
 from ..providers.helper import filter_none
-from ..client.helper import to_async_iterator
+from ..providers.asyncio import to_async_iterator
 from .web_search import do_search, get_search_message
 from .files import read_bucket, get_bucket_dir
 from .. import debug
@@ -55,9 +55,7 @@ def on_bucket(match):
                     if has_bucket and isinstance(messages[-1]["content"], str):
                         messages[-1]["content"] += BUCKET_INSTRUCTIONS
 
-    response = async_iter_callback(model=model, messages=messages, **kwargs)
-    if not hasattr(response, "__aiter__"):
-        response = to_async_iterator(response)
+    response = to_async_iterator(async_iter_callback(model=model, messages=messages, **kwargs))
     async for chunk in response:
         yield chunk
 
diff --git a/g4f/tools/web_search.py b/g4f/tools/web_search.py
index 667d9ab6775..bc57e84eb33 100644
--- a/g4f/tools/web_search.py
+++ b/g4f/tools/web_search.py
@@ -122,7 +122,7 @@ async def fetch_and_scrape(session: ClientSession, url: str, max_words: int = No
                 with open(cache_file, "w") as f:
                     f.write(text)
                 return text
-    except ClientError:
+    except (ClientError, asyncio.TimeoutError):
         return
 
 async def search(query: str, max_results: int = 5, max_words: int = 2500, backend: str = "auto", add_text: bool = True, timeout: int = 5, region: str = "wt-wt") -> SearchResults:
@@ -138,7 +138,7 @@ async def search(query: str, max_results: int = 5, max_words: int = 2500, backen
                 max_results=max_results,
                 backend=backend,
             ):
-            if ".google.com" in result["href"]:
+            if ".google." in result["href"]:
                 continue
             results.append(SearchResultEntry(
                 result["title"],