g4f 6.9.8__py3-none-any.whl → 6.9.10__py3-none-any.whl

g4f/Provider/PollinationsAI.py

@@ -44,9 +44,9 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
     gen_text_api_endpoint = "https://gen.pollinations.ai/v1/chat/completions"
     image_models_endpoint = "https://gen.pollinations.ai/image/models"
     text_models_endpoint = "https://gen.pollinations.ai/text/models"
-    balance_endpoint = "https://api.gpt4free.workers.dev/api/pollinations/account/balance"
-    worker_api_endpoint = "https://api.gpt4free.workers.dev/api/pollinations/chat/completions"
-    worker_models_endpoint = "https://api.gpt4free.workers.dev/api/pollinations/text/models"
+    balance_endpoint = "https://g4f.space/api/pollinations/account/balance"
+    worker_api_endpoint = "https://g4f.space/api/pollinations/chat/completions"
+    worker_models_endpoint = "https://g4f.space/api/pollinations/models"
 
     # Models configuration
     default_model = "openai"
@@ -263,6 +263,8 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
                         has_audio = True
                         break
             model = "openai-audio" if has_audio else cls.default_model
+        if not api_key:
+            api_key = AuthManager.load_api_key(cls)
         if cls.get_models(api_key=api_key, timeout=kwargs.get("timeout", 15)):
             if model in cls.model_aliases:
                 model = cls.model_aliases[model]
@@ -379,7 +381,7 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
             return f"{url}&seed={seed}" if seed else url
 
         headers = None
-        if api_key and api_key.startswith("g4f_") or api_key.startswith("gfs_"):
+        if api_key and (api_key.startswith("g4f_") or api_key.startswith("gfs_")):
             headers = {"authorization": f"Bearer {api_key}"}
         async with ClientSession(
             headers=DEFAULT_HEADERS,

g4f/Provider/Yupp.py

@@ -6,12 +6,15 @@ import re
 import time
 import uuid
 from concurrent.futures import ThreadPoolExecutor
+from typing import Optional, Dict, Any, List
 
 try:
     import cloudscraper
     from cloudscraper import CloudScraper
+    has_cloudscraper = True
 except ImportError:
     from typing import Type as CloudScraper
+    has_cloudscraper = False
 
 from .helper import get_last_user_message
 from .yupp.models import YuppModelManager
@@ -20,17 +23,27 @@ from ..debug import log
 from ..errors import RateLimitError, ProviderException, MissingAuthError, MissingRequirementsError
 from ..image import is_accepted_format, to_bytes
 from ..providers.base_provider import AsyncGeneratorProvider, ProviderModelMixin
-from ..providers.response import Reasoning, PlainTextResponse, PreviewResponse, JsonConversation, ImageResponse, \
-    ProviderInfo, FinishReason, JsonResponse, VariantResponse
+from ..providers.response import (
+    Reasoning,
+    PlainTextResponse,
+    PreviewResponse,
+    JsonConversation,
+    ImageResponse,
+    ProviderInfo,
+    FinishReason,
+    JsonResponse,
+    VariantResponse,
+)
 from ..tools.auth import AuthManager
 from ..tools.media import merge_media
-from ..typing import AsyncResult, Messages, Optional, Dict, Any, List
+from ..typing import AsyncResult, Messages
 
 YUPP_ACCOUNTS: List[Dict[str, Any]] = []
 account_rotation_lock = asyncio.Lock()
 ImagesCache: Dict[str, dict] = {}
 _accounts_loaded = False
-_executor = ThreadPoolExecutor(max_workers=10)
+_executor = ThreadPoolExecutor(max_workers=32)
+MAX_CACHE_SIZE = 1000
 
 
 def create_scraper():
@@ -87,10 +100,10 @@ async def get_best_yupp_account() -> Optional[Dict[str, Any]]:
             acc
             for acc in YUPP_ACCOUNTS
             if acc["is_valid"]
-               and (
-                       acc["error_count"] < max_error_count
-                       or now - acc["last_used"] > error_cooldown
-               )
+            and (
+                acc["error_count"] < max_error_count
+                or now - acc["last_used"] > error_cooldown
+            )
         ]
 
         if not valid_accounts:
@@ -98,8 +111,8 @@ async def get_best_yupp_account() -> Optional[Dict[str, Any]]:
 
         for acc in valid_accounts:
             if (
-                    acc["error_count"] >= max_error_count
-                    and now - acc["last_used"] > error_cooldown
+                acc["error_count"] >= max_error_count
+                and now - acc["last_used"] > error_cooldown
             ):
                 acc["error_count"] = 0
 
@@ -109,11 +122,11 @@ async def get_best_yupp_account() -> Optional[Dict[str, Any]]:
         return account
 
 
-def sync_claim_yupp_reward(scraper: CloudScraper, account: Dict[str, Any], reward_id: str):
+def sync_claim_yupp_reward(scraper: CloudScraper, account: Dict[str, Any], eval_id: str):
     try:
-        log_debug(f"Claiming reward {reward_id}...")
+        log_debug(f"Claiming reward {eval_id}...")
         url = "https://yupp.ai/api/trpc/reward.claim?batch=1"
-        payload = {"0": {"json": {"rewardId": reward_id}}}
+        payload = {"0": {"json": {"evalId": eval_id}}}
         scraper.cookies.set("__Secure-yupp.session-token", account['token'])
         response = scraper.post(url, json=payload)
         response.raise_for_status()
@@ -122,13 +135,104 @@ def sync_claim_yupp_reward(scraper: CloudScraper, account: Dict[str, Any], rewar
         log_debug(f"Reward claimed successfully. New balance: {balance}")
         return balance
     except Exception as e:
-        log_debug(f"Failed to claim reward {reward_id}. Error: {e}")
+        log_debug(f"Failed to claim reward {eval_id}. Error: {e}")
+        return None
+
+
+async def claim_yupp_reward(scraper: CloudScraper, account: Dict[str, Any], eval_id: str):
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(_executor, sync_claim_yupp_reward, scraper, account, eval_id)
+
+
+def sync_record_model_feedback(
+    scraper: CloudScraper,
+    account: Dict[str, Any],
+    turn_id: str,
+    left_message_id: str,
+    right_message_id: str
+) -> Optional[str]:
+    try:
+        log_debug(f"Recording model feedback for turn {turn_id}...")
+        url = "https://yupp.ai/api/trpc/evals.recordModelFeedback?batch=1"
+        payload = {
+            "0": {
+                "json": {
+                    "turnId": turn_id,
+                    "evalType": "SELECTION",
+                    "messageEvals": [
+                        {
+                            "messageId": right_message_id,
+                            "rating": "GOOD",
+                            "reasons": ["Fast"]
+                        },
+                        {
+                            "messageId": left_message_id,
+                            "rating": "BAD",
+                            "reasons": []
+                        }
+                    ],
+                    "comment": "",
+                    "requireReveal": False
+                }
+            }
+        }
+        scraper.cookies.set("__Secure-yupp.session-token", account['token'])
+        response = scraper.post(url, json=payload)
+        response.raise_for_status()
+        data = response.json()
+
+        for result in data:
+            json_data = result.get("result", {}).get("data", {}).get("json", {})
+            eval_id = json_data.get("evalId")
+            final_reward = json_data.get("finalRewardAmount")
+            log_debug(f"Feedback recorded - evalId: {eval_id}, reward: {final_reward}")
+
+            if final_reward:
+                return eval_id
+        return None
+    except Exception as e:
+        log_debug(f"Failed to record model feedback. Error: {e}")
         return None
 
 
-async def claim_yupp_reward(scraper: CloudScraper, account: Dict[str, Any], reward_id: str):
+async def record_model_feedback(
+    scraper: CloudScraper,
+    account: Dict[str, Any],
+    turn_id: str,
+    left_message_id: str,
+    right_message_id: str
+) -> Optional[str]:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        _executor, sync_record_model_feedback, scraper, account, turn_id, left_message_id, right_message_id
+    )
+
+
+def sync_delete_chat(scraper: CloudScraper, account: Dict[str, Any], chat_id: str) -> bool:
+    try:
+        log_debug(f"Deleting chat {chat_id}...")
+        url = "https://yupp.ai/api/trpc/chat.deleteChat?batch=1"
+        payload = {"0": {"json": {"chatId": chat_id}}}
+        scraper.cookies.set("__Secure-yupp.session-token", account['token'])
+        response = scraper.post(url, json=payload)
+        response.raise_for_status()
+        data = response.json()
+        if (
+            isinstance(data, list) and len(data) > 0
+            and data[0].get("result", {}).get("data", {}).get("json") is None
+        ):
+            log_debug(f"Chat {chat_id} deleted successfully")
+            return True
+        log_debug(f"Unexpected response while deleting chat: {data}")
+        return False
+    except Exception as e:
+        log_debug(f"Failed to delete chat {chat_id}: {e}")
+        return False
+
+
+async def delete_chat(scraper: CloudScraper, account: Dict[str, Any], chat_id: str) -> bool:
     loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(_executor, sync_claim_yupp_reward, scraper, account, reward_id)
+    return await loop.run_in_executor(_executor, sync_delete_chat, scraper, account, chat_id)
 
 
 def sync_make_chat_private(scraper: CloudScraper, account: Dict[str, Any], chat_id: str) -> bool:
@@ -148,8 +252,8 @@ def sync_make_chat_private(scraper: CloudScraper, account: Dict[str, Any], chat_
         response.raise_for_status()
         data = response.json()
         if (
-                isinstance(data, list) and len(data) > 0
-                and "json" in data[0].get("result", {}).get("data", {})
+            isinstance(data, list) and len(data) > 0
+            and "json" in data[0].get("result", {}).get("data", {})
         ):
             log_debug(f"Chat {chat_id} is now PRIVATE")
             return True
@@ -205,10 +309,18 @@ def format_messages_for_yupp(messages: Messages) -> str:
     return result
 
 
+def evict_cache_if_needed():
+    global ImagesCache
+    if len(ImagesCache) > MAX_CACHE_SIZE:
+        keys_to_remove = list(ImagesCache.keys())[:len(ImagesCache) - MAX_CACHE_SIZE + 100]
+        for key in keys_to_remove:
+            del ImagesCache[key]
+
+
 class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
     url = "https://yupp.ai"
     login_url = "https://discord.gg/qXA4Wf4Fsm"
-    working = CloudScraper is not None
+    working = has_cloudscraper
     active_by_default = True
     supports_stream = True
     image_cache = True
@@ -228,8 +340,10 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                 cls.models_tags = {model.get("name"): manager.processor.generate_tags(model) for model in models}
                 cls.models = [model.get("name") for model in models]
                 cls.image_models = [model.get("name") for model in models if model.get("isImageGeneration")]
-                cls.vision_models = [model.get("name") for model in models if
-                                     "image/*" in model.get("supportedAttachmentMimeTypes", [])]
+                cls.vision_models = [
+                    model.get("name") for model in models
+                    if "image/*" in model.get("supportedAttachmentMimeTypes", [])
+                ]
         return cls.models
 
     @classmethod
@@ -271,8 +385,15 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
 
             attachment_resp = scraper.post(
                 "https://yupp.ai/api/trpc/chat.createAttachmentForUploadedFile?batch=1",
-                json={"0": {"json": {"fileName": name, "contentType": is_accepted_format(data),
-                                     "fileId": upload_info["fileId"]}}},
+                json={
+                    "0": {
+                        "json": {
+                            "fileName": name,
+                            "contentType": is_accepted_format(data),
+                            "fileId": upload_info["fileId"]
+                        }
+                    }
+                },
                 cookies={"__Secure-yupp.session-token": account["token"]}
             )
             attachment_resp.raise_for_status()
@@ -283,6 +404,7 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                 "attachmentId": attachment["attachment_id"],
                 "chatMessageId": ""
             }
+            evict_cache_if_needed()
             ImagesCache[image_hash] = file_info
             files.append(file_info)
         return files
@@ -305,8 +427,8 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
             }
         )
         resp.raise_for_status()
-        data = resp.json()
-        return data[0]["result"]["data"]["json"]["signed_url"]
+        data = resp.json()[0]["result"]["data"]["json"]
+        return data.get("signed_url", data.get("signedURL"))
 
     @classmethod
     async def get_signed_image(cls, scraper: CloudScraper, image_id: str) -> str:
@@ -314,23 +436,26 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
         return await loop.run_in_executor(_executor, cls.sync_get_signed_image, scraper, image_id)
 
     @classmethod
-    def sync_stream_request(cls, scraper: CloudScraper, url: str, payload: list, headers: dict,
-                            timeout: int):
+    def sync_stream_request(cls, scraper: CloudScraper, url: str, payload: list, headers: dict, timeout: int):
         response = scraper.post(url, json=payload, headers=headers, stream=True, timeout=timeout)
         response.raise_for_status()
         return response
 
     @classmethod
     async def create_async_generator(
-            cls,
-            model: str,
-            messages: Messages,
-            proxy: str = None,
-            **kwargs,
+        cls,
+        model: str,
+        messages: Messages,
+        proxy: str = None,
+        api_key: str = None,
+        **kwargs,
     ) -> AsyncResult:
-        if  CloudScraper is None:
-            raise MissingRequirementsError("cloudscraper library is required for Yupp provider | install it via 'pip install cloudscraper'")
-        api_key = kwargs.get("api_key")
+        if not has_cloudscraper:
+            raise MissingRequirementsError(
+                "cloudscraper library is required for Yupp provider | install it via 'pip install cloudscraper'"
+            )
+        if not api_key:
+            api_key = AuthManager.load_api_key(cls)
         if not api_key:
             api_key = get_cookies("yupp.ai", False).get("__Secure-yupp.session-token")
         if api_key:
@@ -351,7 +476,8 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                 prompt = get_last_user_message(messages, prompt)
 
         log_debug(
-            f"Use url_uuid: {url_uuid}, Formatted prompt length: {len(prompt)}, Is new conversation: {is_new_conversation}")
+            f"Use url_uuid: {url_uuid}, Formatted prompt length: {len(prompt)}, Is new conversation: {is_new_conversation}"
+        )
 
         max_attempts = len(YUPP_ACCOUNTS)
         for attempt in range(max_attempts):
@@ -437,10 +563,13 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                     timeout
                 )
 
-                asyncio.create_task(make_chat_private(scraper, account, url_uuid))
-
-                async for chunk in cls._process_stream_response(response, account, scraper, prompt, model):
-                    yield chunk
+                try:
+                    async for chunk in cls._process_stream_response(response, account, scraper, prompt, model):
+                        yield chunk
+                finally:
+                    response.close()
+                    if not kwargs.get("conversation"):
+                        asyncio.create_task(delete_chat(scraper, account, url_uuid))
                 return
 
             except RateLimitError:
@@ -462,7 +591,8 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                 log_debug(f"Unexpected error with account ...{account['token'][-4:]}: {str(e)}")
                 error_str = str(e).lower()
                 if "500" in error_str or "internal server error" in error_str:
-                    account["is_valid"] = False
+                    async with account_rotation_lock:
+                        account["error_count"] += 1
                     continue
                 async with account_rotation_lock:
                     account["error_count"] += 1
@@ -472,12 +602,12 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
 
     @classmethod
     async def _process_stream_response(
-            cls,
-            response,
-            account: Dict[str, Any],
-            scraper: CloudScraper,
-            prompt: str,
-            model_id: str
+        cls,
+        response,
+        account: Dict[str, Any],
+        scraper: CloudScraper,
+        prompt: str,
+        model_id: str
     ) -> AsyncResult:
         line_pattern = re.compile(b"^([0-9a-fA-F]+):(.*)")
         target_stream_id = None
@@ -562,6 +692,7 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
             is_started: bool = False
             variant_image: Optional[ImageResponse] = None
             reward_id = "a"
+            reward_kw = {}
             routing_id = "e"
             turn_id = None
             persisted_turn_id = None
@@ -642,7 +773,8 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                         right_stream = data.get("rightStream", {})
                         if data.get("quickResponse", {}) != "$undefined":
                             quick_response_id = extract_ref_id(
-                                data.get("quickResponse", {}).get("stream", {}).get("next"))
+                                data.get("quickResponse", {}).get("stream", {}).get("next")
+                            )
 
                         if data.get("turnId", {}) != "$undefined":
                             turn_id = extract_ref_id(data.get("turnId", {}).get("next"))
@@ -693,20 +825,20 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                                 if ref_name in image_blocks:
                                     img_block_text = image_blocks[ref_name]
                                     async for chunk in process_content_chunk(
-                                            img_block_text,
-                                            ref_name,
-                                            line_count,
-                                            for_target=True
+                                        img_block_text,
+                                        ref_name,
+                                        line_count,
+                                        for_target=True
                                     ):
                                         stream["target"].append(chunk)
                                         is_started = True
                                         yield chunk
                             else:
                                 async for chunk in process_content_chunk(
-                                        content,
-                                        chunk_id,
-                                        line_count,
-                                        for_target=True
+                                    content,
+                                    chunk_id,
+                                    line_count,
+                                    for_target=True
                                 ):
                                     stream["target"].append(chunk)
                                     is_started = True
@@ -719,10 +851,10 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                         content = data.get("curr", "")
                         if content:
                             async for chunk in process_content_chunk(
-                                    content,
-                                    chunk_id,
-                                    line_count,
-                                    for_target=False
+                                content,
+                                chunk_id,
+                                line_count,
+                                for_target=False
                             ):
                                 stream["variant"].append(chunk)
                                 if isinstance(chunk, ImageResponse):
@@ -738,32 +870,35 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
                         content = data.get("curr", "")
                         if content:
                             async for chunk in process_content_chunk(
-                                    content,
-                                    chunk_id,
-                                    line_count,
-                                    for_target=False
+                                content,
+                                chunk_id,
+                                line_count,
+                                for_target=False
                             ):
                                 stream["quick"].append(chunk)
                             quick_content += content
                             yield PreviewResponse(content)
 
-                elif chunk_id in [turn_id, persisted_turn_id]:
+                elif chunk_id == turn_id:
+                    reward_kw["turn_id"] = data.get("curr", "")
+
+                elif chunk_id == persisted_turn_id:
                     pass
 
                 elif chunk_id == right_message_id:
-                    pass
+                    reward_kw["right_message_id"] = data.get("curr", "")
 
                 elif chunk_id == left_message_id:
-                    pass
+                    reward_kw["left_message_id"] = data.get("curr", "")
 
                 elif isinstance(data, dict) and "curr" in data:
                     content = data.get("curr", "")
                     if content:
                         async for chunk in process_content_chunk(
-                                content,
-                                chunk_id,
-                                line_count,
-                                for_target=False
+                            content,
+                            chunk_id,
+                            line_count,
+                            for_target=False
                         ):
                             stream["extra"].append(chunk)
                             if isinstance(chunk, str) and "<streaming stopped unexpectedly" in chunk:
@@ -779,7 +914,14 @@ class Yupp(AsyncGeneratorProvider, ProviderModelMixin):
             log_debug(f"Finished processing {line_count} lines")
 
         finally:
-            if reward_info and "unclaimedRewardInfo" in reward_info:
-                rid = reward_info["unclaimedRewardInfo"].get("rewardId")
-                if rid:
-                    await claim_yupp_reward(scraper, account, rid)
+            log_debug(f"Get Reward: {reward_kw}")
+            if reward_kw.get("turn_id") and reward_kw.get("left_message_id") and reward_kw.get("right_message_id"):
+                eval_id = await record_model_feedback(
+                    scraper,
+                    account,
+                    reward_kw["turn_id"],
+                    reward_kw["left_message_id"],
+                    reward_kw["right_message_id"]
+                )
+                if eval_id:
+                    await claim_yupp_reward(scraper, account, eval_id)

g4f/Provider/__init__.py

@@ -49,9 +49,7 @@ from .OperaAria            import OperaAria
 from .Perplexity           import Perplexity
 from .PollinationsAI       import PollinationsAI
 from .PollinationsImage    import PollinationsImage
-from .Startnest            import Startnest
 from .Qwen                 import Qwen
-from .StringableInference  import StringableInference
 from .TeachAnything        import TeachAnything
 from .WeWordle             import WeWordle
 from .Yqcloud              import Yqcloud

g4f/Provider/local/Ollama.py

@@ -13,6 +13,7 @@ from ...typing import AsyncResult, Messages
 class Ollama(OpenaiTemplate):
     label = "Ollama 🦙"
     url = "https://ollama.com"
+    base_url = "https://g4f.space/api/ollama"
     login_url = "https://ollama.com/settings/keys"
     needs_auth = False
     working = True
@@ -34,7 +35,7 @@ class Ollama(OpenaiTemplate):
                 cls.live += 1
             cls.models = [model["name"] for model in models]
             if base_url is None:
-                host = os.getenv("OLLAMA_HOST", "127.0.0.1")
+                host = os.getenv("OLLAMA_HOST", "localhost")
                 port = os.getenv("OLLAMA_PORT", "11434")
                 url = f"http://{host}:{port}/api/tags"
             else:
@@ -66,7 +67,7 @@ class Ollama(OpenaiTemplate):
             base_url: str = f"http://{host}:{port}/v1"
         if model in cls.local_models:
             async with StreamSession(headers={"Authorization": f"Bearer {api_key}"}, proxy=proxy) as session:
-                async with session.post(f"{base_url}/api/chat", json={
+                async with session.post(f"{base_url.replace('/v1', '')}/api/chat", json={
                     "model": model,
                     "messages": messages,
                 }) as response:

g4f/Provider/needs_auth/Azure.py

@@ -14,7 +14,7 @@ from ..helper import format_media_prompt
 class Azure(OpenaiTemplate):
     label = "Azure ☁️"
     url = "https://ai.azure.com"
-    base_url = "https://g4f.dev/api/azure"
+    base_url = "https://g4f.space/api/azure"
     working = True
     active_by_default = False
     login_url = "https://discord.gg/qXA4Wf4Fsm"

g4f/Provider/needs_auth/Claude.py

@@ -9,7 +9,7 @@ from ..template import OpenaiTemplate
 class Claude(OpenaiTemplate):
     label = "Claude 💥"
     url = "https://claude.ai"
-    base_url = "https://g4f.dev/api/claude"
+    base_url = "https://g4f.space/api/claude"
     working = True
     active_by_default = True
     login_url = "https://discord.gg/qXA4Wf4Fsm"

g4f/Provider/needs_auth/GeminiPro.py

@@ -7,7 +7,7 @@ class GeminiPro(OpenaiTemplate):
     url = "https://ai.google.dev"
     login_url = "https://aistudio.google.com/u/0/apikey"
     base_url = "https://generativelanguage.googleapis.com/v1beta/openai"
-    backup_url = "https://g4f.dev/custom/srv_mjnryskw9fe0567fa267"
+    backup_url = "https://g4f.space/api/gemini-v1beta"
     active_by_default = True
     working = True
     default_model = "models/gemini-2.5-flash"

g4f/Provider/needs_auth/Groq.py

@@ -7,6 +7,7 @@ class Groq(OpenaiTemplate):
     url = "https://console.groq.com/playground"
     login_url = "https://console.groq.com/keys"
     base_url = "https://api.groq.com/openai/v1"
+    backup_url = "https://g4f.space/api/groq"
     working = True
     active_by_default = True
     default_model = DEFAULT_MODEL

g4f/Provider/needs_auth/Nvidia.py

@@ -6,6 +6,7 @@ from ...config import DEFAULT_MODEL
 class Nvidia(OpenaiTemplate):
     label = "Nvidia"
     base_url = "https://integrate.api.nvidia.com/v1"
+    backup_url = "https://g4f.space/api/nvidia"
     login_url = "https://google.com"
     url = "https://build.nvidia.com"
     working = True

g4f/Provider/needs_auth/OpenRouter.py

@@ -13,6 +13,7 @@ class OpenRouter(OpenaiTemplate):
 
 class OpenRouterFree(OpenRouter):
     label = "OpenRouter (free)"
+    base_url = "https://g4f.space/api/openrouter"
     max_tokens = 4096
     active_by_default = True
 

g4f/client/__init__.py

@@ -821,7 +821,7 @@ class ClientFactory:
         elif provider.startswith("custom:"):
             if provider.startswith("custom:"):
                 serverId = provider[7:]
-                base_url = f"https://api.gpt4free.workers.dev/custom/{serverId}"
+                base_url = f"https://g4f.space/custom/{serverId}"
             if not base_url:
                 raise ValueError("base_url is required for custom providers")
             provider = create_custom_provider(base_url, api_key, name=name, **kwargs)

g4f/gui/server/backend_api.py

@@ -331,7 +331,7 @@ class Backend_Api(Api):
                         for chunk in response:
                             if isinstance(chunk, FinishReason):
                                 yield f"[{chunk.reason}]" if chunk.reason != "stop" else ""
-                            elif not isinstance(chunk, Exception):
+                            elif not isinstance(chunk, (Exception, JsonResponse)):
                                 chunk = str(chunk)
                                 if chunk:
                                     yield chunk

g4f/mcp/server.py

@@ -10,13 +10,21 @@ The server exposes tools for:
 
 from __future__ import annotations
 
+import os
+import re
 import sys
 import json
 import asyncio
+import hashlib
+from email.utils import formatdate
 from typing import Any, Dict, List, Optional, Union
 from dataclasses import dataclass
+from urllib.parse import unquote_plus
 
 from ..debug import enable_logging
+from ..cookies import read_cookie_files
+from ..image import EXTENSIONS_MAP
+from ..image.copy_images import get_media_dir, copy_media, get_source_url
 
 from .tools import MarkItDownTool, TextToAudioTool, WebSearchTool, WebScrapeTool, ImageGenerationTool
 from .tools import WebSearchTool, WebScrapeTool, ImageGenerationTool
@@ -214,6 +222,7 @@ class MCPServer:
             sys.exit(1)
 
         enable_logging()
+        read_cookie_files()
         
         async def handle_mcp_request(request: web.Request) -> web.Response:
             nonlocal origin
@@ -273,17 +282,120 @@ class MCPServer:
                 "server": self.server_info
             })
         
+        async def handle_media(request: web.Request) -> web.Response:
+            """Serve media files from generated_media directory"""
+            filename = request.match_info.get('filename', '')
+            if not filename:
+                return web.Response(status=404, text="File not found")
+            
+            def get_timestamp(s):
+                m = re.match("^[0-9]+", s)
+                return int(m.group(0)) if m else 0
+            
+            target = os.path.join(get_media_dir(), os.path.basename(filename))
+            
+            # Try URL-decoded filename if not found
+            if not os.path.isfile(target):
+                other_name = os.path.join(get_media_dir(), os.path.basename(unquote_plus(filename)))
+                if os.path.isfile(other_name):
+                    target = other_name
+            
+            # Get file extension and mime type
+            ext = os.path.splitext(filename)[1][1:].lower()
+            mime_type = EXTENSIONS_MAP.get(ext, "application/octet-stream")
+            
+            # Try to fetch from backend if file doesn't exist
+            if not os.path.isfile(target) and mime_type != "application/octet-stream":
+                source_url = get_source_url(str(request.query_string))
+                ssl = None
+                if source_url is not None:
+                    try:
+                        await copy_media([source_url], target=target, ssl=ssl)
+                        sys.stderr.write(f"File copied from {source_url}\n")
+                    except Exception as e:
+                        sys.stderr.write(f"Download failed: {source_url} - {e}\n")
+                        raise web.HTTPFound(location=source_url)
+            
+            if not os.path.isfile(target):
+                return web.Response(status=404, text="File not found")
+            
+            # Build response headers
+            stat_result = os.stat(target)
+            headers = {
+                "cache-control": "public, max-age=31536000",
+                "last-modified": formatdate(get_timestamp(filename), usegmt=True),
+                "etag": f'"{hashlib.md5(filename.encode()).hexdigest()}"',
+                "content-length": str(stat_result.st_size),
+                "content-type": mime_type,
+                "access-control-allow-origin": "*",
+            }
+            
+            # Check for conditional request
+            if_none_match = request.headers.get("if-none-match")
+            if if_none_match:
+                etag = headers["etag"]
+                if etag in [tag.strip(" W/") for tag in if_none_match.split(",")]:
+                    return web.Response(status=304, headers=headers)
+            
+            # Serve the file
+            return web.FileResponse(target, headers=headers)
+        
+        async def handle_synthesize(request: web.Request) -> web.Response:
+            """Handle synthesize requests for text-to-speech"""
+            provider_name = request.match_info.get('provider', '')
+            if not provider_name:
+                return web.Response(status=400, text="Provider not specified")
+            
+            try:
+                from ..Provider import ProviderUtils
+                provider_handler = ProviderUtils.convert.get(provider_name)
+                if provider_handler is None:
+                    return web.Response(status=404, text=f"Provider not found: {provider_name}")
+            except Exception as e:
+                return web.Response(status=404, text=f"Provider not found: {provider_name}")
+            
+            if not hasattr(provider_handler, "synthesize"):
+                return web.Response(status=500, text=f"Provider doesn't support synthesize: {provider_name}")
+            
+            # Get query parameters
+            params = dict(request.query)
+            
+            try:
+                # Call the synthesize method
+                response_data = provider_handler.synthesize(params)
+                
+                # Handle async generator
+                async def generate():
+                    async for chunk in response_data:
+                        yield chunk
+                
+                content_type = getattr(provider_handler, "synthesize_content_type", "application/octet-stream")
+                return web.Response(
+                    body=b"".join([chunk async for chunk in generate()]),
+                    content_type=content_type,
+                    headers={
+                        "cache-control": "max-age=604800",
+                        "access-control-allow-origin": "*",
+                    }
+                )
+            except Exception as e:
+                sys.stderr.write(f"Synthesize error: {e}\n")
+                return web.Response(status=500, text=f"Synthesize error: {str(e)}")
+        
         # Create aiohttp application
         app = web.Application()
         app.router.add_options('/mcp', lambda request: web.Response(headers={"access-control-allow-origin": "*", "access-control-allow-methods": "POST, OPTIONS", "access-control-allow-headers": "Content-Type"}))
         app.router.add_post('/mcp', handle_mcp_request)
         app.router.add_get('/health', handle_health)
+        app.router.add_get('/media/{filename:.*}', handle_media)
+        app.router.add_get('/backend-api/v2/synthesize/{provider}', handle_synthesize)
         
         # Start server
         sys.stderr.write(f"Starting {self.server_info['name']} v{self.server_info['version']} (HTTP mode)\n")
         sys.stderr.write(f"Listening on http://{host}:{port}\n")
         sys.stderr.write(f"MCP endpoint: http://{host}:{port}/mcp\n")
         sys.stderr.write(f"Health check: http://{host}:{port}/health\n")
+        sys.stderr.write(f"Media files: http://{host}:{port}/media/{{filename}}\n")
         sys.stderr.flush()
         
         runner = web.AppRunner(app)

g4f/mcp/tools.py

@@ -241,8 +241,7 @@ class ImageGenerationTool(MCPTool):
                 model=model,
                 prompt=prompt,
                 width=width,
-                height=height,
-                response_format="url"
+                height=height
             )
             
             # Get the image data with proper validation

g4f/models.py

@@ -19,7 +19,6 @@ from .Provider import (
     OIVSCodeSer0501,
     OperaAria,
     Perplexity,
-    Startnest,
     OpenAIFM,
     PollinationsAI,
     PollinationsImage,
@@ -157,7 +156,6 @@ default = Model(
         Copilot,
         DeepInfra,
         OperaAria,
-        Startnest,
         GLM,
         PollinationsAI,
         Qwen,
@@ -179,7 +177,6 @@ default_vision = VisionModel(
         OIVSCodeSer2,
         PollinationsAI,
         OperaAria,
-        Startnest,
         Together,
         HuggingSpace,
         GeminiPro,
@@ -207,7 +204,7 @@ gpt_4o = VisionModel(
 gpt_4o_mini = Model(
     name          = 'gpt-4o-mini',
     base_provider = 'OpenAI',
-    best_provider = IterListProvider([Chatai, OIVSCodeSer2, Startnest, OpenaiChat])
+    best_provider = IterListProvider([Chatai, OIVSCodeSer2, OpenaiChat])
 )
 
 # gpt_4o_mini_audio = AudioModel(

{g4f-6.9.8.dist-info → g4f-6.9.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: g4f
-Version: 6.9.8
+Version: 6.9.10
 Summary: The official gpt4free repository | various collection of powerful language models
 Home-page: https://github.com/xtekky/gpt4free
 Author: Tekky
@@ -42,6 +42,7 @@ Requires-Dist: setuptools; extra == "all"
 Requires-Dist: markitdown[all]; extra == "all"
 Requires-Dist: python-dotenv; extra == "all"
 Requires-Dist: aiofile; extra == "all"
+Requires-Dist: cloudscraper; extra == "all"
 Provides-Extra: slim
 Requires-Dist: curl_cffi>=0.6.2; extra == "slim"
 Requires-Dist: certifi; extra == "slim"
@@ -61,6 +62,7 @@ Requires-Dist: pypdf2; extra == "slim"
 Requires-Dist: python-docx; extra == "slim"
 Requires-Dist: python-dotenv; extra == "slim"
 Requires-Dist: aiofile; extra == "slim"
+Requires-Dist: cloudscraper; extra == "slim"
 Provides-Extra: image
 Requires-Dist: pillow; extra == "image"
 Requires-Dist: cairosvg; extra == "image"

{g4f-6.9.8.dist-info → g4f-6.9.10.dist-info}/RECORD

@@ -5,7 +5,7 @@ g4f/cookies.py,sha256=gx68OX5he2bYvsvvIQEESMUfwnVI18DOMJt9KvQrM8g,7915
 g4f/debug.py,sha256=Dh0cmlxUydMDfjJBiPWrO9dAuvv2sTElb3R036ax-34,1021
 g4f/errors.py,sha256=8Mp77UMW9_c8Flr1Z0Cvdrv0ixOF9CE0j1QX-cc5Zfc,2368
 g4f/files.py,sha256=JzlWe3V6Xc7FN4eag7Utc4P9dHN1s1sMKFvYSaM0NQg,907
-g4f/models.py,sha256=95ZV0HaQF7faPcEV7D_g9pjZc09tWU1oOF0ip78yKt8,24991
+g4f/models.py,sha256=QZV4UAis0QYaWGVO4Nv6n_3wMrLQvWHJ9V11Lo1EmBQ,24927
 g4f/typing.py,sha256=fBBb74HkxtLa358vjcd1U5yr3ThlKzP2DfE8wdx01lA,2388
 g4f/version.py,sha256=Lt6aOvuLBfDOHUSAtmncRMuNoDtisb1m8a447o7DkoM,4382
 g4f/Provider/ApiAirforce.py,sha256=gYaq0MjLDVtzfXpnkhGWdKAZqnfC2UK1dji5u_EvhsQ,1148
@@ -23,16 +23,14 @@ g4f/Provider/Mintlify.py,sha256=3Bvy1oh6scg4xs9pw5RY4mmi8XEvQDelnNp664TefbU,7937
 g4f/Provider/OIVSCodeSer.py,sha256=clebON7Ssd9syewh3BWT59XOeB-WORXF6FPOwbzfRmo,1366
 g4f/Provider/OperaAria.py,sha256=sLnTOKzbW9BxTxNmHXJ-YDnhPU6Dj6MBdDfqDh-Zz-c,14662
 g4f/Provider/Perplexity.py,sha256=GUebbVin9hCg4FDei9RX2N6WboFcDDPm061WnnpPRaI,13236
-g4f/Provider/PollinationsAI.py,sha256=pbZSxqezkGma80OXno_bFecvrdD9EUCGQPkscPYI6ZU,21786
+g4f/Provider/PollinationsAI.py,sha256=8LMR8wl3Lh-pzhUHJW71rObSHgBeo7p4LL5GD6IWe3Y,21814
 g4f/Provider/PollinationsImage.py,sha256=wdGY9kbPGlqAkyeJcjXgWOG3HLVPU4QK-JENwg3gmwk,2297
 g4f/Provider/Qwen.py,sha256=XPJHRlobijqjdDGVqA-aVyRx2SeM28zSWf-NmzxJtgE,23876
-g4f/Provider/Startnest.py,sha256=OocXEAK3pKG-tC_D_chGE7GD22dZr67J1m7JBhLxniM,9526
-g4f/Provider/StringableInference.py,sha256=ZohMZrVAn6G82zrYpLTvELkzfds4nxu09lx7wizFnbk,999
 g4f/Provider/TeachAnything.py,sha256=ST87YdOdxtIc5JMaKzGdVy9J9wlhdhYIchRtXBljIBU,2843
 g4f/Provider/WeWordle.py,sha256=ocKEfMYBKWPzv2WoDntn-WC-DkrSg5b_ipL9VYhTgsw,7007
 g4f/Provider/Yqcloud.py,sha256=xzX-G-Lv0pyOHTypSJdavmbm3GPxnL-wRoT3VmjzUIM,3213
-g4f/Provider/Yupp.py,sha256=flSbW_PDMqdnJU7jCyg1wWmHr-QV3DHIzdlEI5w6-TY,32365
-g4f/Provider/__init__.py,sha256=l6qxw1XlGgFqTTI2Q8YjlP-Yr17viOiPj1eaU8K9LEo,2782
+g4f/Provider/Yupp.py,sha256=E3ft5HshW-IfGdE2KtdpNOmbBkBmBeyl-c8xM-BTpEo,36906
+g4f/Provider/__init__.py,sha256=2azA2zjXZjkH3yDJSoWKeB3SCGB7SIa_0_DN44Lf39g,2684
 g4f/Provider/base_provider.py,sha256=lAd80-2hO1kzs9n9TUKv6fR4zHjSdZBqVErpm_gna9o,199
 g4f/Provider/helper.py,sha256=_4fO_b2U8BnpuF6kijUM4SaFbX2Pcz6mksxK9mVXhP4,111
 g4f/Provider/audio/EdgeTTS.py,sha256=VXcLCZDdf8DL0jIEO3tvduPK4NguUMEDJg9U5MkNvJk,2822
@@ -55,16 +53,16 @@ g4f/Provider/hf_space/StabilityAI_SD35Large.py,sha256=-VT4qa_K6MshG2TX6y7k01NMGH
 g4f/Provider/hf_space/__init__.py,sha256=licdlcuTs0yPwADmjBUA5uoN4ao-FnCUmlKiMWoHJ2g,3602
 g4f/Provider/hf_space/raise_for_status.py,sha256=xoVwrZSwJUvqQkSfeUAMUst8SyobpSKPux1iYu4SNH0,935
 g4f/Provider/local/Local.py,sha256=b6vSZcr5CfEXD5GMqNtwCfXNJtKyWKPg3jqBWJEZEwQ,1251
-g4f/Provider/local/Ollama.py,sha256=ukgvoCSDiXEqhPc6i-awylqiuSnFLpau0uMX9YfsJuA,3770
+g4f/Provider/local/Ollama.py,sha256=MtB36eUcn6iyJ9XZWfEHIrkCGeZ0Z6Hysm7AgHQUwE0,3835
 g4f/Provider/local/__init__.py,sha256=cEFsdfkq0bgVAIM__Sxc6WfIoGa3_Ymol26kQb6x14k,73
 g4f/Provider/needs_auth/AIBadgr.py,sha256=Oc05Cs-x40sF7tcrAyUqyoZ-TbtmV4wnMIm5aEjQ0xw,420
 g4f/Provider/needs_auth/Anthropic.py,sha256=-8hRSpSGaC3-AzhkuIsf1K1w8ZVKKb_T6Pwy3N8JPak,10200
-g4f/Provider/needs_auth/Azure.py,sha256=XPgC4ffl8AitnzQB4K77v2eyXm_rLznz1VUiHIeRqaA,6107
+g4f/Provider/needs_auth/Azure.py,sha256=q8Un1ouuG57-9WDyHnRdMfhTjfYM8ky0_8SIYOIkPck,6109
 g4f/Provider/needs_auth/BingCreateImages.py,sha256=_GrPx7KuttKrQ4IKX0fFwDPVsiCW9xTLycULNClZ6KQ,2066
 g4f/Provider/needs_auth/BlackboxPro.py,sha256=BA-eiaVGczyB7BHQ47jehq6dTkEslithw1nN2whceZo,270382
 g4f/Provider/needs_auth/CablyAI.py,sha256=113DsXPXAq3DO2QPHPJ0UJwMpXxomb7BM07RrcV6YQk,1253
 g4f/Provider/needs_auth/Cerebras.py,sha256=WcPgAVW9QRqoDJ9-KgWYDl08buEVRl1pWiwy7giAGlE,1753
-g4f/Provider/needs_auth/Claude.py,sha256=Mg9_g3S60WU-po4C1rYwLJuRPU9wq-9U0qp_hg8oufA,1398
+g4f/Provider/needs_auth/Claude.py,sha256=Xk6kXNhygZ62DbTuDNDo2K8qD_8CZMqc_IwCQBuaoR0,1400
 g4f/Provider/needs_auth/Cohere.py,sha256=NhHzZrYD2uLxFtEsBKR1FR6UywT3hhie5jIh2Ppvbrg,5851
 g4f/Provider/needs_auth/CopilotAccount.py,sha256=VCjfUzlPZxU-SduLy3V-YFrUN_KOLZoT2b-OZmZD4rw,394
 g4f/Provider/needs_auth/Custom.py,sha256=bD6ao9IkIG_oW7bYAHCSEZrMEnDX9u2X96q9LkCMbWc,347
@@ -73,19 +71,19 @@ g4f/Provider/needs_auth/DeepSeekAPI.py,sha256=UaN4W5b_1nXsyB5MN81NzHkQLz1V6DOzte
 g4f/Provider/needs_auth/FenayAI.py,sha256=2NkDnhdEVDMD1Xk13rp78nRt7oGwbgsX0jlonWt-Ym8,519
 g4f/Provider/needs_auth/Gemini.py,sha256=p0idmlvIbjg3kMEGsOv5N9b-j5b-blNT2yxO2xnAmiQ,22853
 g4f/Provider/needs_auth/GeminiCLI.py,sha256=BNQv_Hqzu3E0GtVRbZDZdcq--ZHpJDdLRF5ssG4yX9o,23554
-g4f/Provider/needs_auth/GeminiPro.py,sha256=zZBvjc7N313aqp08s8OyNb0kZDn_YTpVdFvSo2GuqD8,767
+g4f/Provider/needs_auth/GeminiPro.py,sha256=Q2G8tuZEZQOUSE-m3PoIs5NMyXuOO55784kXk8rFdsM,755
 g4f/Provider/needs_auth/GigaChat.py,sha256=2IqQlav_-g-4ZUMJ0tO8KGpvchg9_0ap6rzGP_5dLRI,6325
 g4f/Provider/needs_auth/GithubCopilot.py,sha256=AUoapqX6lwgC5WPIpKdKdhXcuXo4Stq7I0W5bVHMEbI,6093
 g4f/Provider/needs_auth/GithubCopilotAPI.py,sha256=O-8Bq6eWrVZTYFS5QufMDJ9SiSFsd0Pz91yejb6spOI,353
 g4f/Provider/needs_auth/GlhfChat.py,sha256=qSPKXnQ7igjF6_kiBnFhwq-YAqGmpZg_yu4OMRliSP4,1189
 g4f/Provider/needs_auth/Grok.py,sha256=3uwt0vjsSNHLZKS2DcUHTztiNqPIemwW82E2x0AQRTw,12884
-g4f/Provider/needs_auth/Groq.py,sha256=30XyhPJYnZG-_t_gZx8vkLmJK-sYyvUE03edEJjbPbE,548
+g4f/Provider/needs_auth/Groq.py,sha256=zErhEO8-oo4dOZY1u2uz0Xcxb3N76epEBhbuiOjYbx0,594
 g4f/Provider/needs_auth/LMArena.py,sha256=dKwHEgdvEY9ctjNZzi-COdV8RHqV_z7qEoKiLGGhxus,121399
 g4f/Provider/needs_auth/MetaAI.py,sha256=Bz9pvJUVH7RtCAP1Huvay-EgO057fL362mhx3GtVAqM,10653
 g4f/Provider/needs_auth/MetaAIAccount.py,sha256=D4LnhAt2MuKx1a4uSgX2lUbQrzAkeIYm8JCnZieZiak,672
 g4f/Provider/needs_auth/MicrosoftDesigner.py,sha256=4sJdjBPgiW9TEh4CeplCTNPXv6ZtZtFh0SYAiVfnrqk,7178
-g4f/Provider/needs_auth/Nvidia.py,sha256=URMUSrLxUAA9YpI_DsdgQ3QlaOJ0JYRSClmYbTwXWM4,391
-g4f/Provider/needs_auth/OpenRouter.py,sha256=KxALUf-mdoHHdYxEU53Rviyw7DRooFz39UMupDl-9V8,850
+g4f/Provider/needs_auth/Nvidia.py,sha256=RcVVSpTZM9VCMhLZ4z3g6j9yxHPQETeWQJb24SPfaII,439
+g4f/Provider/needs_auth/OpenRouter.py,sha256=KKWKKrzw2BGscd05m3BVw21TOHWRMkFETzOPQ1o5YNA,900
 g4f/Provider/needs_auth/OpenaiAPI.py,sha256=KpJ6qvUlFsFqpQbcwikNYLVsFx6K9h393Pu-yf_uS3g,362
 g4f/Provider/needs_auth/OpenaiAccount.py,sha256=vSe6Je-DoNbdGGEE-gNaW0Sa81rL8FPMaNyYr1U4PcI,209
 g4f/Provider/needs_auth/OpenaiChat.py,sha256=dVSm-HAzlvb3KZqZNf0XYFxvIBTfXajKQfe8-JuO-vM,67285
@@ -148,7 +146,7 @@ g4f/api/stubs.py,sha256=9xoJDAmRyUtL_jlqhVI8Q8G-gF9zTse46iNBGEYvD9s,4252
 g4f/cli/__init__.py,sha256=GUr_JFjLQDmDHmEyafHPvjaPYCQ5oeJclSazoEfRcxA,9167
 g4f/cli/__main__.py,sha256=SYf3GG2ZCYygnpZ25muxdmT40Dfbx-J0ionEAnfBxuI,94
 g4f/cli/client.py,sha256=azUTVzdOtfwj8Z6twhODzBQsONiwBBGq90h61Wu_PyY,11859
-g4f/client/__init__.py,sha256=dji7F8Xx5YdzsDVR9Yc3LKQQPooLxkh72RZkoyvkOok,35516
+g4f/client/__init__.py,sha256=Cx6-yGyo4rkeIJq6Q5ECA0GINkvdbXhIkkr0cpUQk-4,35501
 g4f/client/helper.py,sha256=SwdS7I7CkWBG05INo04eMuukLRPUTkX4awgMHGPLpPI,1852
 g4f/client/models.py,sha256=H8wu1UMFu8oCw7jy6x5B46GjPJPUa35h42Pq87Dp6lI,2318
 g4f/client/service.py,sha256=lElAhe0y0ZzllkKjX2CBzy_kqgkwYw8P9fZWHivgWqw,5330
@@ -161,7 +159,7 @@ g4f/gui/webview.py,sha256=OcXnxG41h4RFSAQqq7pUBUv2UL3rbLlU3_RsOydabgs,1338
 g4f/gui/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 g4f/gui/server/api.py,sha256=a0Yt2r-JpL6roGEZUCGKO20v1x8dY2jQ6uqCVWzd4tA,16641
 g4f/gui/server/app.py,sha256=HwJeICAyMkrSQdrUiW2DhZGwe_l40Qb21dF_HiTgMv0,92
-g4f/gui/server/backend_api.py,sha256=ZQv3OOtvGstky5mcOYcdH-yI1J7feJqQSBHvTDIZGrI,29960
+g4f/gui/server/backend_api.py,sha256=cfgwrKaEA-efmKKt3Lm8uVfngSzHDCKgpC4ZeRFHthk,29976
 g4f/gui/server/config.py,sha256=RCpWrnnfJ5Lmq63r6_rz2cxicCadLUgCxoRFZUgUs3s,15354
 g4f/gui/server/crypto.py,sha256=6irNKqjlKfwnk4MY3TOhFlBWM2mZ6zjZaDmnanub_rc,2786
 g4f/gui/server/internet.py,sha256=NSItPuwLwIegcUmfjw5SBOtBQroNQp7osd2pCNFGx6g,109
@@ -185,8 +183,8 @@ g4f/locals/models.py,sha256=9uzKnQwLBjtjGU6G3f13jAY5Y9aI2PD4hTi4_bFMqa4,1674
 g4f/locals/provider.py,sha256=2Wk2PKzB005kYjHEABF_5a4j3qgxxIzgKMK28ewi3sg,2858
 g4f/mcp/__init__.py,sha256=9S6ReeCAJIiWTpkLRvrk1KwfEsT1GKO7_chQoue0J5Q,573
 g4f/mcp/__main__.py,sha256=zmnb03P5of2g8IZymmrRrYpMo6kKgQWD-0QemIcguOc,184
-g4f/mcp/server.py,sha256=8JOumIkT-GEY89LFnsgYTMpmnlZUYIo958qnbBsrPaI,11580
-g4f/mcp/tools.py,sha256=H_DSRryz2zM7G_XOnXw0tUc-8ExJ9ZaAkSGIxO5UpTw,15348
+g4f/mcp/server.py,sha256=zZq4moxcp0sI2w3t1kt3JAC529yfbClchgWK4Y0V7Rw,16900
+g4f/mcp/tools.py,sha256=G09YfVemVsPbkMLIr5iiE0jHvIUj2Of8Rc02dUaHzzU,15309
 g4f/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 g4f/providers/any_model_map.py,sha256=Go7AaJUyvI3NFA5AwjzT7sL8Suk7B0OhtqpzHb512g0,230475
 g4f/providers/any_provider.py,sha256=EnK9VvBGEUGEe66QsDXEaxL7tvrnNea1ZKukbnMX2uc,19250
@@ -210,9 +208,9 @@ g4f/tools/files.py,sha256=bUTbeNp8ujTZQiW3GLTtFcgl3-1AnH3cDyIKHfh6Mjc,23397
 g4f/tools/media.py,sha256=AE9hGVRxQBVZzQ_Ylzeoo2TJUGXSBXO5RbLwj1I2ZTE,4701
 g4f/tools/run_tools.py,sha256=Yb0osWdDt4wUnkvwln4R6qcLapdddC3n2giZMPXWkzM,16662
 g4f/tools/web_search.py,sha256=vAZJD-qy15llsgAbkXzoEltqdFB6TlKLbqDJ1DS-6vs,2086
-g4f-6.9.8.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-g4f-6.9.8.dist-info/METADATA,sha256=MeXnOddLJO79rAsc_cNZWoW0GgQMNdRqPXTp9sIqaIA,23255
-g4f-6.9.8.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-g4f-6.9.8.dist-info/entry_points.txt,sha256=J7Usl6dNjXJlvuzGAUEm6cuDXWpVdGq7SfK-tPoiZSI,67
-g4f-6.9.8.dist-info/top_level.txt,sha256=bMRlTupWYCcLWy80AnnKZkhpBsXsF8gI3BaMhSZSgRo,4
-g4f-6.9.8.dist-info/RECORD,,
+g4f-6.9.10.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+g4f-6.9.10.dist-info/METADATA,sha256=sblmkzCLywyAXtzAFD9ORBJ4QAb4sGt6jylU28Vpa6I,23345
+g4f-6.9.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+g4f-6.9.10.dist-info/entry_points.txt,sha256=J7Usl6dNjXJlvuzGAUEm6cuDXWpVdGq7SfK-tPoiZSI,67
+g4f-6.9.10.dist-info/top_level.txt,sha256=bMRlTupWYCcLWy80AnnKZkhpBsXsF8gI3BaMhSZSgRo,4
+g4f-6.9.10.dist-info/RECORD,,

{g4f-6.9.8.dist-info → g4f-6.9.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

g4f/Provider/Startnest.py

@@ -1,215 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-import json
-import time
-import hashlib
-
-from ..typing import AsyncResult, Messages, MediaListType
-from .base_provider import AsyncGeneratorProvider, ProviderModelMixin
-from .helper import format_prompt
-from ..tools.media import merge_media
-from ..image import to_data_uri
-from ..providers.response import FinishReason
-
-
-class Startnest(AsyncGeneratorProvider, ProviderModelMixin):
-    label = "Startnest"
-    url = "https://play.google.com/store/apps/details?id=starnest.aitype.aikeyboard.chatbot.chatgpt"
-    api_endpoint = "https://api.startnest.uk/api/completions/stream"
-    
-    working = False
-    needs_auth = False
-    supports_stream = True
-    supports_system_message = True
-    supports_message_history = True
-    
-    default_model = 'gpt-4o-mini'
-    models = [default_model]
-    vision_models = models
-
-    @classmethod
-    def generate_signature(cls, timestamp: int) -> str:
-        """
-        Generate signature for authorization header
-        You may need to adjust this based on the actual signature algorithm
-        """
-        # This is a placeholder - the actual signature generation might involve:
-        # - A secret key
-        # - Specific string formatting
-        # - Different hash input
-        
-        # Example implementation (adjust as needed):
-        kid = "36ccfe00-78fc-4cab-9c5b-5460b0c78513"
-        algorithm = "sha256"
-        validity = 90
-        user_id = ""
-        
-        # The actual signature generation logic needs to be determined
-        # This is just a placeholder that creates a hash from timestamp
-        signature_input = f"{kid}{timestamp}{validity}".encode()
-        signature_value = hashlib.sha256(signature_input).hexdigest()
-        
-        return f"Signature kid={kid}&algorithm={algorithm}&timestamp={timestamp}&validity={validity}&userId={user_id}&value={signature_value}"
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        media: MediaListType = None,
-        stream: bool = True,
-        max_tokens: int = None,
-        **kwargs
-    ) -> AsyncResult:
-        model = cls.get_model(model)
-        
-        # Generate current timestamp
-        timestamp = int(time.time())
-        
-        headers = {
-            "Accept-Encoding": "gzip",
-            "app_name": "AIKEYBOARD",
-            "Authorization": cls.generate_signature(timestamp),
-            "Connection": "Keep-Alive",
-            "Content-Type": "application/json; charset=UTF-8",
-            "Host": "api.startnest.uk",
-            "User-Agent": "okhttp/4.9.0",
-        }
-        
-        async with ClientSession() as session:
-            # Merge media with messages
-            media = list(merge_media(media, messages))
-            
-            # Convert messages to the required format
-            formatted_messages = []
-            for i, msg in enumerate(messages):
-                if isinstance(msg, dict):
-                    role = msg.get("role", "user")
-                    content = msg.get("content", "")
-                    
-                    # Create content array
-                    content_array = []
-                    
-                    # Add images if this is the last user message and media exists
-                    if media and role == "user" and i == len(messages) - 1:
-                        for image, _ in media:
-                            image_data_uri = to_data_uri(image)
-                            content_array.append({
-                                "image_url": {
-                                    "url": image_data_uri
-                                },
-                                "type": "image_url"
-                            })
-                    
-                    # Add text content
-                    if content:
-                        content_array.append({
-                            "text": content,
-                            "type": "text"
-                        })
-                    
-                    formatted_messages.append({
-                        "role": role,
-                        "content": content_array
-                    })
-            
-            # If only one message and no media, use format_prompt as requested
-            if len(messages) == 1 and not media:
-                prompt_text = format_prompt(messages)
-                formatted_messages = [{
-                    "role": "user",
-                    "content": [{"text": prompt_text, "type": "text"}]
-                }]
-            
-            data = {
-                "isVip": True,
-                "max_tokens": max_tokens,
-                "messages": formatted_messages,
-                "stream": stream
-            }
-            
-            # Add advanceToolType if media is present
-            if media:
-                data["advanceToolType"] = "upload_and_ask"
-            
-            async with session.post(cls.api_endpoint, json=data, headers=headers, proxy=proxy) as response:
-                response.raise_for_status()
-                
-                if stream:
-                    # Handle streaming response (SSE format)
-                    async for line in response.content:
-                        if line:
-                            line = line.decode('utf-8').strip()
-                            if line.startswith("data: "):
-                                data_str = line[6:]
-                                if data_str == "[DONE]":
-                                    break
-                                try:
-                                    json_data = json.loads(data_str)
-                                    if "choices" in json_data and len(json_data["choices"]) > 0:
-                                        choice = json_data["choices"][0]
-                                        
-                                        # Handle content
-                                        delta = choice.get("delta", {})
-                                        content = delta.get("content", "")
-                                        if content:
-                                            yield content
-                                        
-                                        # Handle finish_reason
-                                        if "finish_reason" in choice and choice["finish_reason"] is not None:
-                                            yield FinishReason(choice["finish_reason"])
-                                            break
-                                            
-                                except json.JSONDecodeError:
-                                    continue
-                else:
-                    # Handle non-streaming response (regular JSON)
-                    response_text = await response.text()
-                    try:
-                        json_data = json.loads(response_text)
-                        if "choices" in json_data and len(json_data["choices"]) > 0:
-                            choice = json_data["choices"][0]
-                            if "message" in choice and "content" in choice["message"]:
-                                content = choice["message"]["content"]
-                                if content:
-                                    yield content.strip()
-                            
-                            # Handle finish_reason for non-streaming
-                            if "finish_reason" in choice and choice["finish_reason"] is not None:
-                                yield FinishReason(choice["finish_reason"])
-                                return
-                                
-                    except json.JSONDecodeError:
-                        # If it's still SSE format even when stream=False, handle it
-                        lines = response_text.strip().split('\n')
-                        full_content = []
-                        finish_reason_value = None
-                        
-                        for line in lines:
-                            if line.startswith("data: "):
-                                data_str = line[6:]
-                                if data_str == "[DONE]":
-                                    break
-                                try:
-                                    json_data = json.loads(data_str)
-                                    if "choices" in json_data and len(json_data["choices"]) > 0:
-                                        choice = json_data["choices"][0]
-                                        delta = choice.get("delta", {})
-                                        content = delta.get("content", "")
-                                        if content:
-                                            full_content.append(content)
-                                        
-                                        # Store finish_reason
-                                        if "finish_reason" in choice and choice["finish_reason"] is not None:
-                                            finish_reason_value = choice["finish_reason"]
-                                            
-                                except json.JSONDecodeError:
-                                    continue
-                        
-                        if full_content:
-                            yield ''.join(full_content)
-                        
-                        if finish_reason_value:
-                            yield FinishReason(finish_reason_value)

g4f/Provider/StringableInference.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import secrets
-import string
-
-from .template import OpenaiTemplate
-
-class StringableInference(OpenaiTemplate):
-    label = "Stringable Inference"
-    url = "https://stringable-inference.onrender.com"
-    base_url = "https://stringableinf.com/api"
-    api_endpoint = "https://stringableinf.com/api/v1/chat/completions"
-
-    working = False
-    active_by_default = True
-    default_model = "deepseek-v3.2"
-    default_vision_model = "gpt-oss-120b"
-
-    @classmethod
-    def get_headers(cls, stream: bool, api_key: str = None, headers: dict = None) -> dict:
-        return {
-            "Accept": "text/event-stream" if stream else "application/json",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://g4f.dev/",
-            "X-Title": "G4F Python",
-            **(
-                {"Authorization": f"Bearer {api_key}"}
-                if api_key else {}
-            ),
-            **({} if headers is None else headers)
-        }