g4f 6.9.9__py3-none-any.whl → 7.0.0__py3-none-any.whl

g4f/Provider/PollinationsAI.py

@@ -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
@@ -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/errors.py

@@ -49,7 +49,7 @@ class MissingRequirementsError(G4FError):
 
 
 class NestAsyncioError(MissingRequirementsError):
-    """Raised when 'nest_asyncio' is missing."""
+    """Raised when 'nest_asyncio2' is missing."""
     pass
 
 

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/providers/asyncio.py

@@ -7,7 +7,7 @@ from typing import Optional, Callable, AsyncIterator, Iterator
 from ..errors import NestAsyncioError
 
 try:
-    import nest_asyncio
+    import nest_asyncio2 as nest_asyncio
     has_nest_asyncio = True
 except ImportError:
     has_nest_asyncio = False
@@ -28,7 +28,7 @@ def get_running_loop(check_nested: bool) -> Optional[AbstractEventLoop]:
             if has_nest_asyncio:
                 nest_asyncio.apply(loop)
             elif check_nested:
-                raise NestAsyncioError('Install "nest_asyncio" package | pip install -U nest_asyncio')
+                raise NestAsyncioError('Install "nest-asyncio2" package | pip install -U nest-asyncio2')
         return loop
     except RuntimeError:
         pass

{g4f-6.9.9.dist-info → g4f-7.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: g4f
-Version: 6.9.9
+Version: 7.0.0
 Summary: The official gpt4free repository | various collection of powerful language models
 Home-page: https://github.com/xtekky/gpt4free
 Author: Tekky
@@ -20,7 +20,7 @@ Requires-Dist: requests
 Requires-Dist: aiohttp
 Requires-Dist: brotli
 Requires-Dist: pycryptodome
-Requires-Dist: nest_asyncio
+Requires-Dist: nest-asyncio2
 Provides-Extra: all
 Requires-Dist: curl_cffi>=0.6.2; extra == "all"
 Requires-Dist: certifi; extra == "all"
@@ -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.9.dist-info → g4f-7.0.0.dist-info}/RECORD

@@ -3,7 +3,7 @@ g4f/__main__.py,sha256=HHFLPRNjEHse-6-i_58Y9AKtEtzGJtxsZPXhymCmIJg,63
 g4f/config.py,sha256=qnhX4a2J17CLkooHoMg8mETM8SjoeqJ-Lu1WiRVzIB0,1160
 g4f/cookies.py,sha256=gx68OX5he2bYvsvvIQEESMUfwnVI18DOMJt9KvQrM8g,7915
 g4f/debug.py,sha256=Dh0cmlxUydMDfjJBiPWrO9dAuvv2sTElb3R036ax-34,1021
-g4f/errors.py,sha256=8Mp77UMW9_c8Flr1Z0Cvdrv0ixOF9CE0j1QX-cc5Zfc,2368
+g4f/errors.py,sha256=FCD6ZkTdfxB4nBjubg7Y8cStGJ5PsYJoVwyUiHL46Z8,2369
 g4f/files.py,sha256=JzlWe3V6Xc7FN4eag7Utc4P9dHN1s1sMKFvYSaM0NQg,907
 g4f/models.py,sha256=QZV4UAis0QYaWGVO4Nv6n_3wMrLQvWHJ9V11Lo1EmBQ,24927
 g4f/typing.py,sha256=fBBb74HkxtLa358vjcd1U5yr3ThlKzP2DfE8wdx01lA,2388
@@ -23,13 +23,13 @@ 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=Mhrb-Ym9N6RXTONWOlElBOW__g4KPiwpyeUa9L72waI,21736
+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/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=StAyO9qFalvwOsj3RkkOJdkJMItvmBYwgwFx8GV0IT8,32392
+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
@@ -159,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
@@ -183,12 +183,12 @@ 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
-g4f/providers/asyncio.py,sha256=aZTeaUYf0wZmJ6r70gK4v4fkNEhuBA0cGmjrUFICAN4,2707
+g4f/providers/asyncio.py,sha256=LTbN0_S8Y5XJXIZcUhivbBpbcYjEOPxdOdEcPBOQTUs,2726
 g4f/providers/base_provider.py,sha256=AEoeJd1gkfhmlJ2AAz3QEh_8jE2xAVOp019ABBAaBIE,20010
 g4f/providers/create_images.py,sha256=yIDZvXUXqnBTQDzpq_NFmJRzxC7RI6VL5UDpN1YKbOU,6607
 g4f/providers/helper.py,sha256=L2k0BoFjNjj5DUlZUo59h6zZP6dKAKKKeBeZYAwCQHo,5603
@@ -208,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.9.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-g4f-6.9.9.dist-info/METADATA,sha256=dpbXvC6fuScpC1DzPLZsVooh8dnODUlQdonjYOzYx2U,23255
-g4f-6.9.9.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-g4f-6.9.9.dist-info/entry_points.txt,sha256=J7Usl6dNjXJlvuzGAUEm6cuDXWpVdGq7SfK-tPoiZSI,67
-g4f-6.9.9.dist-info/top_level.txt,sha256=bMRlTupWYCcLWy80AnnKZkhpBsXsF8gI3BaMhSZSgRo,4
-g4f-6.9.9.dist-info/RECORD,,
+g4f-7.0.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+g4f-7.0.0.dist-info/METADATA,sha256=LQ7GIFlNobe_iV344kFxuw-wDxECP2yW-hA1u5cLZcQ,23345
+g4f-7.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+g4f-7.0.0.dist-info/entry_points.txt,sha256=J7Usl6dNjXJlvuzGAUEm6cuDXWpVdGq7SfK-tPoiZSI,67
+g4f-7.0.0.dist-info/top_level.txt,sha256=bMRlTupWYCcLWy80AnnKZkhpBsXsF8gI3BaMhSZSgRo,4
+g4f-7.0.0.dist-info/RECORD,,

{g4f-6.9.9.dist-info → g4f-7.0.0.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