webscout 8.2.2__tar.gz → 8.2.3__tar.gz

{webscout-8.2.2/webscout.egg-info → webscout-8.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 8.2.2
+Version: 8.2.3
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author: OEvortex
 Author-email: helpingai5@gmail.com

webscout-8.2.3/webscout/AIbase.py

@@ -0,0 +1,260 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import AsyncGenerator, List, Union, Generator, Optional
+from typing_extensions import TypeAlias
+
+# Type aliases for better readability
+Response: TypeAlias = dict[str, Union[str, bool, None]]
+ImageData: TypeAlias = Union[bytes, str, Generator[bytes, None, None]]
+AsyncImageData: TypeAlias = Union[bytes, str, AsyncGenerator[bytes, None]]
+
+class AIProviderError(Exception):
+    pass
+
+class Provider(ABC):
+
+    @abstractmethod
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> Response:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def get_message(self, response: Response) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AsyncProvider(ABC):
+
+    @abstractmethod
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> Response:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def get_message(self, response: Response) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class TTSProvider(ABC):
+
+    @abstractmethod
+    def tts(self, text: str, voice: str = None, verbose: bool = False) -> str:
+        """Convert text to speech and save to a temporary file.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the generated audio file
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """Save audio to a specific destination.
+
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the saved audio file
+        """
+        import shutil
+        import os
+        from pathlib import Path
+        import time
+
+        source_path = Path(audio_file)
+
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+
+        # Copy the file
+        shutil.copy2(source_path, destination)
+
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+
+        return destination
+
+    def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False) -> Generator[bytes, None, None]:
+        """Stream audio in chunks.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Yields:
+            Generator[bytes, None, None]: Audio data chunks
+        """
+        # Generate the audio file
+        audio_file = self.tts(text, voice=voice, verbose=verbose)
+
+        # Stream the file in chunks
+        with open(audio_file, 'rb') as f:
+            while chunk := f.read(chunk_size):
+                yield chunk
+
+class AsyncTTSProvider(ABC):
+
+    @abstractmethod
+    async def tts(self, text: str, voice: str = None, verbose: bool = False) -> str:
+        """Convert text to speech and save to a temporary file asynchronously.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the generated audio file
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    async def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """Save audio to a specific destination asynchronously.
+
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the saved audio file
+        """
+        import shutil
+        import os
+        from pathlib import Path
+        import time
+        import asyncio
+
+        source_path = Path(audio_file)
+
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+
+        # Copy the file using asyncio to avoid blocking
+        await asyncio.to_thread(shutil.copy2, source_path, destination)
+
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+
+        return destination
+
+    async def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False) -> AsyncGenerator[bytes, None]:
+        """Stream audio in chunks asynchronously.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Yields:
+            AsyncGenerator[bytes, None]: Audio data chunks
+        """
+        import aiofiles
+
+        # Generate the audio file
+        audio_file = await self.tts(text, voice=voice, verbose=verbose)
+
+        # Stream the file in chunks
+        async with aiofiles.open(audio_file, 'rb') as f:
+            while chunk := await f.read(chunk_size):
+                yield chunk
+
+class ImageProvider(ABC):
+
+    @abstractmethod
+    def generate(self, prompt: str, amount: int = 1) -> List[bytes]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def save(
+        self,
+        response: List[bytes],
+        name: Optional[str] = None,
+        dir: Optional[Union[str, Path]] = None
+    ) -> List[str]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AsyncImageProvider(ABC):
+
+    @abstractmethod
+    async def generate(
+        self,
+        prompt: str,
+        amount: int = 1
+    ) -> Union[AsyncGenerator[bytes, None], List[bytes]]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def save(
+        self,
+        response: Union[AsyncGenerator[bytes, None], List[bytes]],
+        name: Optional[str] = None,
+        dir: Optional[Union[str, Path]] = None
+    ) -> List[str]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AISearch(ABC):
+
+    @abstractmethod
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+    ) -> Response:
+        raise NotImplementedError("Method needs to be implemented in subclass")

{webscout-8.2.2 → webscout-8.2.3}/webscout/Provider/Cloudflare.py

@@ -23,6 +23,7 @@ class Cloudflare(Provider):
         "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b",
         "@cf/thebloke/discolm-german-7b-v1-awq",
         "@cf/tiiuae/falcon-7b-instruct",
+        "@cf/google/gemma-3-12b-it",
         "@hf/google/gemma-7b-it",
         "@hf/nousresearch/hermes-2-pro-mistral-7b",
         "@hf/thebloke/llama-2-13b-chat-awq",
@@ -37,12 +38,14 @@ class Cloudflare(Provider):
         "@cf/meta/llama-3.2-1b-instruct",
         "@cf/meta/llama-3.2-3b-instruct",
         "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+        "@cf/meta/llama-4-scout-17b-16e-instruct",
         "@cf/meta/llama-guard-3-8b",
         "@hf/thebloke/llamaguard-7b-awq",
         "@hf/meta-llama/meta-llama-3-8b-instruct",
         "@cf/mistral/mistral-7b-instruct-v0.1",
         "@hf/thebloke/mistral-7b-instruct-v0.1-awq",
         "@hf/mistral/mistral-7b-instruct-v0.2",
+        "@cf/mistralai/mistral-small-3.1-24b-instruct",
         "@hf/thebloke/neural-chat-7b-v3-1-awq",
         "@cf/openchat/openchat-3.5-0106",
         "@hf/thebloke/openhermes-2.5-mistral-7b-awq",
@@ -51,6 +54,8 @@ class Cloudflare(Provider):
         "@cf/qwen/qwen1.5-1.8b-chat",
         "@cf/qwen/qwen1.5-14b-chat-awq",
         "@cf/qwen/qwen1.5-7b-chat-awq",
+        "@cf/qwen/qwen2.5-coder-32b-instruct",
+        "@cf/qwen/qwq-32b",
         "@cf/defog/sqlcoder-7b-2",
         "@hf/nexusflow/starling-lm-7b-beta",
         "@cf/tinyllama/tinyllama-1.1b-chat-v1.0",

{webscout-8.2.2 → webscout-8.2.3}/webscout/Provider/OPENAI/textpollinations.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Optional, Union, Generator, Any
 from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from .utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage
+    ChatCompletionMessage, CompletionUsage, ToolCall, ToolFunction
 )
 
 # Import LitAgent for browser fingerprinting
@@ -32,6 +32,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -49,6 +51,10 @@ class Completions(BaseCompletions):
             payload["temperature"] = temperature
         if top_p is not None:
             payload["top_p"] = top_p
+        if tools is not None:
+            payload["tools"] = tools
+        if tool_choice is not None:
+            payload["tool_choice"] = tool_choice
 
         payload.update(kwargs)
 
@@ -95,16 +101,39 @@ class Completions(BaseCompletions):
                             json_data = json.loads(line[6:])
                             if 'choices' in json_data and len(json_data['choices']) > 0:
                                 choice = json_data['choices'][0]
-                                if 'delta' in choice and 'content' in choice['delta']:
-                                    content = choice['delta']['content']
-                                    full_response += content
+                                if 'delta' in choice:
+                                    delta_obj = ChoiceDelta()
+
+                                    # Handle content in delta
+                                    if 'content' in choice['delta']:
+                                        content = choice['delta']['content']
+                                        full_response += content
+                                        delta_obj.content = content
+
+                                    # Handle tool calls in delta
+                                    if 'tool_calls' in choice['delta']:
+                                        tool_calls = []
+                                        for tool_call_data in choice['delta']['tool_calls']:
+                                            if 'function' in tool_call_data:
+                                                function = ToolFunction(
+                                                    name=tool_call_data['function'].get('name', ''),
+                                                    arguments=tool_call_data['function'].get('arguments', '')
+                                                )
+                                                tool_call = ToolCall(
+                                                    id=tool_call_data.get('id', str(uuid.uuid4())),
+                                                    type=tool_call_data.get('type', 'function'),
+                                                    function=function
+                                                )
+                                                tool_calls.append(tool_call)
+
+                                        if tool_calls:
+                                            delta_obj.tool_calls = tool_calls
 
                                     # Create and yield a chunk
-                                    delta = ChoiceDelta(content=content)
-                                    choice = Choice(index=0, delta=delta, finish_reason=None)
+                                    choice_obj = Choice(index=0, delta=delta_obj, finish_reason=None)
                                     chunk = ChatCompletionChunk(
                                         id=request_id,
-                                        choices=[choice],
+                                        choices=[choice_obj],
                                         created=created_time,
                                         model=model
                                     )
@@ -155,18 +184,40 @@ class Completions(BaseCompletions):
 
             # Extract the content
             if 'choices' in response_json and len(response_json['choices']) > 0:
-                if 'message' in response_json['choices'][0]:
-                    full_content = response_json['choices'][0]['message']['content']
+                choice_data = response_json['choices'][0]
+                if 'message' in choice_data:
+                    message_data = choice_data['message']
+
+                    # Extract content
+                    full_content = message_data.get('content', '')
+
+                    # Create the completion message with potential tool calls
+                    message = ChatCompletionMessage(role="assistant", content=full_content)
+
+                    # Handle tool calls if present
+                    if 'tool_calls' in message_data:
+                        tool_calls = []
+                        for tool_call_data in message_data['tool_calls']:
+                            if 'function' in tool_call_data:
+                                function = ToolFunction(
+                                    name=tool_call_data['function'].get('name', ''),
+                                    arguments=tool_call_data['function'].get('arguments', '')
+                                )
+                                tool_call = ToolCall(
+                                    id=tool_call_data.get('id', str(uuid.uuid4())),
+                                    type=tool_call_data.get('type', 'function'),
+                                    function=function
+                                )
+                                tool_calls.append(tool_call)
+
+                        if tool_calls:
+                            message.tool_calls = tool_calls
                 else:
-                    full_content = ""
+                    # Fallback if no message is present
+                    message = ChatCompletionMessage(role="assistant", content="")
             else:
-                full_content = ""
-
-            # Create the completion message
-            message = ChatCompletionMessage(
-                role="assistant",
-                content=full_content
-            )
+                # Fallback if no choices are present
+                message = ChatCompletionMessage(role="assistant", content="")
 
             # Create the choice
             choice = Choice(
@@ -217,33 +268,28 @@ class TextPollinations(OpenAICompatibleProvider):
     """
 
     AVAILABLE_MODELS = [
-        "openai",
-        "openai-large",
-        "openai-reasoning",
-        "qwen-coder",
-        "llama",
-        "llamascout",
-        "mistral",
-        "unity",
-        "midijourney",
-        "rtist",
-        "searchgpt",
-        "evil",
-        "deepseek-reasoning",
-        "deepseek-reasoning-large",
-        "llamalight",
-        "phi",
-        "llama-vision",
-        "pixtral",
-        "gemini",
-        "hormoz",
-        "hypnosis-tracy",
-        "mistral-roblox",
-        "roblox-rp",
-        "deepseek",
-        "sur",
-        "llama-scaleway",
-        "openai-audio",
+        "openai",              # OpenAI GPT-4.1-nano (Azure) - vision capable
+        "openai-large",        # OpenAI GPT-4.1 mini (Azure) - vision capable
+        "openai-reasoning",    # OpenAI o4-mini (Azure) - vision capable, reasoning
+        "qwen-coder",          # Qwen 2.5 Coder 32B (Scaleway)
+        "llama",               # Llama 3.3 70B (Cloudflare)
+        "llamascout",          # Llama 4 Scout 17B (Cloudflare)
+        "mistral",             # Mistral Small 3 (Scaleway) - vision capable
+        "unity",               # Unity Mistral Large (Scaleway) - vision capable, uncensored
+        "midijourney",         # Midijourney (Azure)
+        "rtist",               # Rtist (Azure)
+        "searchgpt",           # SearchGPT (Azure) - vision capable
+        "evil",                # Evil (Scaleway) - vision capable, uncensored
+        "deepseek-reasoning",  # DeepSeek-R1 Distill Qwen 32B (Cloudflare) - reasoning
+        "deepseek-reasoning-large", # DeepSeek R1 - Llama 70B (Scaleway) - reasoning
+        "phi",                 # Phi-4 Instruct (Cloudflare) - vision and audio capable
+        "llama-vision",        # Llama 3.2 11B Vision (Cloudflare) - vision capable
+        "gemini",              # gemini-2.5-flash-preview-04-17 (Azure) - vision and audio capable
+        "hormoz",              # Hormoz 8b (Modal)
+        "hypnosis-tracy",      # Hypnosis Tracy 7B (Azure) - audio capable
+        "deepseek",            # DeepSeek-V3 (DeepSeek)
+        "sur",                 # Sur AI Assistant (Mistral) (Scaleway) - vision capable
+        "openai-audio",        # OpenAI GPT-4o-audio-preview (Azure) - vision and audio capable
     ]
 
     def __init__(

{webscout-8.2.2 → webscout-8.2.3}/webscout/Provider/OPENAI/toolbaz.py

@@ -284,20 +284,20 @@ class Toolbaz(OpenAICompatibleProvider):
     """
 
     AVAILABLE_MODELS = [
+        "gemini-2.5-flash",
         "gemini-2.0-flash-thinking",
         "gemini-2.0-flash",
         "gemini-1.5-flash",
         "gpt-4o-latest",
-        "gpt-4o-mini",
         "gpt-4o",
         "deepseek-r1",
+        "Llama-4-Maverick",
+        "Llama-4-Scout",
         "Llama-3.3-70B",
-        "Llama-3.1-405B",
-        "Llama-3.1-70B",
         "Qwen2.5-72B",
         "Qwen2-72B",
         "grok-2-1212",
-        "grok-beta",
+        "grok-3-beta",
         "toolbaz_v3.5_pro",
         "toolbaz_v3",
         "mixtral_8x22b",

{webscout-8.2.2 → webscout-8.2.3}/webscout/Provider/TTS/__init__.py

@@ -1,3 +1,4 @@
+from .base import BaseTTSProvider, AsyncBaseTTSProvider
 from .streamElements import *
 from .parler import *
 from .deepgram import *

webscout-8.2.3/webscout/Provider/TTS/base.py

@@ -0,0 +1,159 @@
+"""
+Base class for TTS providers with common functionality.
+"""
+import os
+import tempfile
+from pathlib import Path
+from typing import Generator, Optional
+from webscout.AIbase import TTSProvider
+
+class BaseTTSProvider(TTSProvider):
+    """
+    Base class for TTS providers with common functionality.
+    
+    This class implements common methods like save_audio and stream_audio
+    that can be used by all TTS providers.
+    """
+    
+    def __init__(self):
+        """Initialize the base TTS provider."""
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
+    
+    def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """
+        Save audio to a specific destination.
+        
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Returns:
+            str: Path to the saved audio file
+            
+        Raises:
+            FileNotFoundError: If the audio file doesn't exist
+        """
+        import shutil
+        import time
+        
+        source_path = Path(audio_file)
+        
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+        
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+        
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+        
+        # Copy the file
+        shutil.copy2(source_path, destination)
+        
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+            
+        return destination
+    
+    def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False) -> Generator[bytes, None, None]:
+        """
+        Stream audio in chunks.
+        
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Yields:
+            Generator[bytes, None, None]: Audio data chunks
+        """
+        # Generate the audio file
+        audio_file = self.tts(text, voice=voice, verbose=verbose)
+        
+        # Stream the file in chunks
+        with open(audio_file, 'rb') as f:
+            while chunk := f.read(chunk_size):
+                yield chunk
+
+
+class AsyncBaseTTSProvider:
+    """
+    Base class for async TTS providers with common functionality.
+    
+    This class implements common async methods like save_audio and stream_audio
+    that can be used by all async TTS providers.
+    """
+    
+    def __init__(self):
+        """Initialize the async base TTS provider."""
+        self.temp_dir = tempfile.mkdtemp(prefix="webscout_tts_")
+    
+    async def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """
+        Save audio to a specific destination asynchronously.
+        
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Returns:
+            str: Path to the saved audio file
+            
+        Raises:
+            FileNotFoundError: If the audio file doesn't exist
+        """
+        import shutil
+        import time
+        import asyncio
+        
+        source_path = Path(audio_file)
+        
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+        
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+        
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+        
+        # Copy the file using asyncio to avoid blocking
+        await asyncio.to_thread(shutil.copy2, source_path, destination)
+        
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+            
+        return destination
+    
+    async def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False):
+        """
+        Stream audio in chunks asynchronously.
+        
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+            
+        Yields:
+            AsyncGenerator[bytes, None]: Audio data chunks
+        """
+        try:
+            import aiofiles
+        except ImportError:
+            raise ImportError("The 'aiofiles' package is required for async streaming. Install it with 'pip install aiofiles'.")
+        
+        # Generate the audio file
+        audio_file = await self.tts(text, voice=voice, verbose=verbose)
+        
+        # Stream the file in chunks
+        async with aiofiles.open(audio_file, 'rb') as f:
+            while chunk := await f.read(chunk_size):
+                yield chunk