webscout 2025.10.18__tar.gz → 2025.10.19__tar.gz

{webscout-2025.10.18/webscout.egg-info → webscout-2025.10.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 2025.10.18
+Version: 2025.10.19
 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-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI

webscout-2025.10.19/webscout/Provider/DeepAI.py

@@ -0,0 +1,362 @@
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+import json
+from typing import Any, Dict, List, Optional, Union, Iterator
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import Provider
+from webscout import exceptions
+from webscout.litagent import LitAgent
+
+
+class DeepAI(Provider):
+    """
+    DeepAI Chat Provider
+
+    A provider for DeepAI's chat functionality, supporting both streaming and non-streaming responses.
+    Structured similarly to other providers like DeepInfra and X0GPT.
+    """
+    required_auth = False
+    AVAILABLE_MODELS = [
+        "standard", 
+        "genius", 
+        "online",
+        "supergenius",
+        "onlinegenius",
+        "deepseek-v3.2",
+        "gemini-2.5-flash-lite",
+        "qwen3-30b-a3b",
+        "gpt-5-nano",
+        "gpt-oss-120b",
+        "gpt-5-chat-latest",
+        "claude-opus-4-1",
+        "llama-4-scout",
+        "claude-4.5-sonnet",
+        "deepseek-v3.1-terminus",
+        "llama-3.3-70b-instruct",
+        "grok-4",
+        "claude-sonnet-4",
+        "qwen3-coder",
+        "gpt-5",
+        "kimi-k2-0905",
+        "claude-opus-4",
+        "gpt-5-mini",
+        "gemini-2.5-pro",
+        "grok-code-fast-1",
+        "gpt-4.1",
+
+    ]
+
+    def __init__(
+        self,
+        api_key: str = "tryit-53926507126-2c8a2543c7b5638ca6b92b6e53ef2d2b",
+        timeout: int = 30,
+        proxies: Optional[Dict[str, str]] = None,
+        model: str = "standard",
+        chat_style: str = "chat",
+        enabled_tools: Optional[List[str]] = None,
+        is_conversation: bool = True,
+        max_tokens: int = 2048,
+        intro: Optional[str] = None,
+        filepath: Optional[str] = None,
+        update_file: bool = True,
+        history_offset: int = 10250,
+        act: Optional[str] = None,
+        system_prompt: str = "You are a helpful assistant.",
+        browser: str = "chrome",
+        **kwargs
+    ):
+        """
+        Initialize the DeepAI provider.
+
+        Args:
+            api_key: API key for authentication (trial key provided by default)
+            timeout: Request timeout in seconds
+            proxies: Proxy configuration
+            model: Model to use (default: "standard")
+            chat_style: Chat style (default: "chat")
+            enabled_tools: List of enabled tools (default: ["image_generator"])
+            is_conversation: Whether to maintain conversation history
+            max_tokens: Maximum tokens for conversation
+            intro: Introduction prompt
+            filepath: Path to conversation history file
+            update_file: Whether to update history file
+            history_offset: History offset for truncation
+            act: Act prompt from AwesomePrompts
+            system_prompt: System prompt for the AI
+            browser: Browser type for fingerprinting
+            **kwargs: Additional arguments
+        """
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+
+        self.url = "https://api.deepai.org/hacking_is_a_serious_crime"
+        self.api_key = api_key
+        self.proxies = proxies or {}
+        self.model = model
+        self.chat_style = chat_style
+        self.enabled_tools = enabled_tools or ["image_generator"]
+        self.system_prompt = system_prompt
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+
+        # LitAgent for fingerprinting
+        self.agent = LitAgent()
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+
+        # Setup headers similar to other providers
+        self.headers = {
+            "User-Agent": self.fingerprint.get("user_agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"),
+            "Accept": "*/*",
+            "Accept-Language": self.fingerprint.get("accept_language", "en-US,en;q=0.9"),
+            "Origin": "https://deepai.org",
+            "Referer": "https://deepai.org/",
+            "Sec-CH-UA": self.fingerprint.get("sec_ch_ua", '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"'),
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": f'"{self.fingerprint.get("platform", "Windows")}"',
+            "api-key": self.api_key
+        }
+
+        # Setup session
+        self.session = Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies = self.proxies
+
+        # Optimizers
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+
+        # Conversation setup similar to other providers
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def refresh_identity(self, browser: str = None):
+        """
+        Refreshes the browser identity fingerprint.
+
+        Args:
+            browser: Specific browser to use for the new fingerprint
+        """
+        browser = browser or self.fingerprint.get("browser_type", "chrome")
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+
+        # Update relevant headers
+        self.headers.update({
+            "User-Agent": self.fingerprint.get("user_agent"),
+            "Accept-Language": self.fingerprint.get("accept_language"),
+            "Sec-CH-UA": self.fingerprint.get("sec_ch_ua"),
+            "Sec-CH-UA-Platform": f'"{self.fingerprint.get("platform")}"',
+        })
+
+        self.session.headers.update(self.headers)
+        return self.fingerprint
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+        **kwargs
+    ) -> Union[Dict[str, Any], Iterator[Dict[str, Any]]]:
+        """
+        Send a prompt to DeepAI and get the response.
+
+        Args:
+            prompt: The prompt to send
+            stream: Whether to stream the response (fake streaming: yields full response in one chunk)
+            raw: Whether to return raw response
+            optimizer: Optimizer to use
+            conversationally: Whether to apply optimizer to full conversation
+            **kwargs: Additional arguments
+
+        Returns:
+            Response dictionary with the AI response or generator for streaming
+        """
+        # Generate conversation prompt similar to other providers
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(f"Optimizer is not one of {list(self.__available_optimizers)}")
+
+        # Prepare form data
+        # Use conversation_prompt as user content in chatHistory
+        chat_history = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": conversation_prompt}
+        ]
+        data = {
+            "chat_style": self.chat_style,
+            "chatHistory": json.dumps(chat_history),
+            "model": self.model,
+            "hacker_is_stinky": "very_stinky",
+            "enabled_tools": json.dumps(self.enabled_tools)
+        }
+
+        # Always perform non-streaming request
+        try:
+            # Make request with curl_cffi
+            response = self.session.post(
+                self.url,
+                data=data,
+                timeout=self.timeout,
+                impersonate="chrome110"
+            )
+            response.raise_for_status()
+
+            # Get response text
+            result = response.text.strip()
+
+            # Update last response and conversation history
+            self.last_response = {"text": result}
+            self.conversation.update_chat_history(prompt, result)
+
+            if stream:
+                # Fake streaming: yield the full response in one chunk
+                if raw:
+                    yield result
+                else:
+                    yield self.last_response
+            else:
+                return self.last_response if not raw else result
+
+        except CurlError as e:
+            raise exceptions.FailedToGenerateResponseError(f"DeepAI API request failed (CurlError): {str(e)}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"DeepAI API request failed ({type(e).__name__}): {str(e)}")
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+        raw: bool = False,
+        **kwargs
+    ) -> Union[str, Iterator[str]]:
+        """
+        Send a chat message to DeepAI and get the response.
+
+        Args:
+            prompt: The prompt to send
+            stream: Whether to stream the response (fake streaming: yields full response in one chunk)
+            optimizer: Optimizer to use
+            conversationally: Whether to apply optimizer to full conversation
+            raw: Whether to return raw response
+            **kwargs: Additional arguments
+
+        Returns:
+            The AI response as a string or generator for streaming
+        """
+        if stream:
+            for resp in self.ask(
+                prompt=prompt,
+                stream=True,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                **kwargs
+            ):
+                if raw:
+                    yield resp
+                else:
+                    yield self.get_message(resp)
+        else:
+            response = self.ask(
+                prompt=prompt,
+                stream=False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                **kwargs
+            )
+            if raw:
+                return response
+            else:
+                return self.get_message(response)
+
+    def get_message(self, response: Union[Dict[str, Any], str]) -> str:
+        """
+        Extract the message from the response.
+
+        Args:
+            response: Response dictionary from ask method or str if raw
+
+        Returns:
+            The message text
+        """
+        if isinstance(response, dict):
+            return response.get("text", "")
+        elif isinstance(response, str):
+            return response
+        else:
+            raise ValueError(f"Unexpected response type: {type(response)}")
+
+    @classmethod
+    def get_models(cls) -> List[str]:
+        """
+        Get available models.
+
+        Returns:
+            List of available model names
+        """
+        return cls.AVAILABLE_MODELS
+
+    @classmethod
+    def get_chat_styles(cls) -> List[str]:
+        """
+        Get available chat styles.
+
+        Returns:
+            List of available chat styles
+        """
+        return ["chat"]
+
+
+if __name__ == "__main__":
+    # Test similar to other providers, using stream=True for consistency
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    for model in DeepAI.AVAILABLE_MODELS:
+        try:
+            test_ai = DeepAI(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Clean and truncate response
+                clean_text = response_text.strip().encode('utf-8', errors='ignore').decode('utf-8')
+                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"{model:<50} {'✗':<10} {str(e)}")

webscout-2025.10.19/webscout/Provider/OPENAI/DeepAI.py

@@ -0,0 +1,300 @@
+"""
+DeepAI Chat Provider for webscout
+
+This provider implements the DeepAI chat API discovered through reverse engineering.
+The API uses a POST endpoint with multipart/form-data containing chat history and parameters.
+
+API Details:
+- Endpoint: https://api.deepai.org/hacking_is_a_serious_crime
+- Method: POST
+- Authentication: api-key header (trial key provided)
+- Content-Type: multipart/form-data
+- Response: Plain text AI response
+
+Features:
+- Streaming and non-streaming support
+- Conversation history management
+- Error handling and retries
+- Configurable model and chat style
+"""
+
+from typing import List, Dict, Optional, Union, Generator, Any
+
+# Import requests for HTTP requests
+import requests
+
+# Standard library imports
+import json
+import time
+import uuid
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage
+)
+
+# Attempt to import LitAgent, fallback if not available
+try:
+    from webscout.litagent import LitAgent
+except ImportError:
+    LitAgent = None
+
+# --- DeepAI Client ---
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'DeepAI'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = 2049,
+        stream: bool = False,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        tools: Optional[List[Union[Dict[str, Any], Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Creates a model response for the given chat conversation.
+        Mimics openai.chat.completions.create
+        """
+        payload = {
+            "chat_style": self._client.chat_style,
+            "chatHistory": json.dumps(messages),
+            "model": model,
+            "hacker_is_stinky": "very_stinky",
+            "enabled_tools": json.dumps(self._client.enabled_tools)
+        }
+
+        # Add optional parameters if provided
+        if max_tokens is not None and max_tokens > 0:
+            payload["max_tokens"] = max_tokens
+
+        if temperature is not None:
+            payload["temperature"] = temperature
+
+        if top_p is not None:
+            payload["top_p"] = top_p
+
+        # Add any additional parameters
+        payload.update(kwargs)
+
+        request_id = f"chatcmpl-{uuid.uuid4()}"
+        created_time = int(time.time())
+
+        if stream:
+            return self._create_stream(request_id, created_time, model, payload)
+        else:
+            return self._create_non_stream(request_id, created_time, model, payload)
+
+    def _create_stream(
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        # DeepAI doesn't actually support streaming, but we'll implement it for compatibility
+        # For now, just yield the non-stream response as a single chunk
+        try:
+            response = self._client.session.post(
+                "https://api.deepai.org/hacking_is_a_serious_crime",
+                data=payload,
+                timeout=self._client.timeout,
+                impersonate="chrome110"  # Use impersonate for better compatibility
+            )
+
+            if response.status_code != 200:
+                raise IOError(f"DeepAI request failed with status code {response.status_code}: {response.text}")
+
+            # Get response text
+            content = response.text.strip()
+
+            # Create the delta object
+            delta = ChoiceDelta(
+                content=content,
+                role="assistant",
+                tool_calls=None
+            )
+
+            # Create the choice object
+            choice = Choice(
+                index=0,
+                delta=delta,
+                finish_reason="stop",
+                logprobs=None
+            )
+
+            # Create the chunk object
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                system_fingerprint=None
+            )
+
+            # Set usage directly on the chunk object (estimated)
+            chunk.usage = {
+                "prompt_tokens": len(json.dumps(payload.get("chatHistory", []))),
+                "completion_tokens": len(content),
+                "total_tokens": len(json.dumps(payload.get("chatHistory", []))) + len(content),
+                "estimated_cost": None
+            }
+
+            yield chunk
+
+        except Exception as e:
+            print(f"Error during DeepAI stream request: {e}")
+            raise IOError(f"DeepAI request failed: {e}") from e
+
+    def _create_non_stream(
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+    ) -> ChatCompletion:
+        try:
+            response = self._client.session.post(
+                "https://api.deepai.org/hacking_is_a_serious_crime",
+                data=payload,
+                timeout=self._client.timeout,
+                impersonate="chrome110"  # Use impersonate for better compatibility
+            )
+
+            if response.status_code != 200:
+                raise IOError(f"DeepAI request failed with status code {response.status_code}: {response.text}")
+
+            # Get response text
+            content = response.text.strip()
+
+            # Create the message object
+            message = ChatCompletionMessage(
+                role="assistant",
+                content=content
+            )
+
+            # Create the choice object
+            choice = Choice(
+                index=0,
+                message=message,
+                finish_reason="stop"
+            )
+
+            # Create the usage object (estimated)
+            usage = CompletionUsage(
+                prompt_tokens=len(json.dumps(payload.get("chatHistory", []))),
+                completion_tokens=len(content),
+                total_tokens=len(json.dumps(payload.get("chatHistory", []))) + len(content)
+            )
+
+            # Create the completion object
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                usage=usage,
+            )
+            return completion
+
+        except Exception as e:
+            print(f"Error during DeepAI non-stream request: {e}")
+            raise IOError(f"DeepAI request failed: {e}") from e
+
+class Chat(BaseChat):
+    def __init__(self, client: 'DeepAI'):
+        self.completions = Completions(client)
+
+class DeepAI(OpenAICompatibleProvider):
+    AVAILABLE_MODELS = [
+        "standard", 
+        "genius", 
+        "online",
+        "supergenius",
+        "onlinegenius",
+        "deepseek-v3.2",
+        "gemini-2.5-flash-lite",
+        "qwen3-30b-a3b",
+        "gpt-5-nano",
+        "gpt-oss-120b",
+        "gpt-5-chat-latest",
+        "claude-opus-4-1",
+        "llama-4-scout",
+        "claude-4.5-sonnet",
+        "deepseek-v3.1-terminus",
+        "llama-3.3-70b-instruct",
+        "grok-4",
+        "claude-sonnet-4",
+        "qwen3-coder",
+        "gpt-5",
+        "kimi-k2-0905",
+        "claude-opus-4",
+        "gpt-5-mini",
+        "gemini-2.5-pro",
+        "grok-code-fast-1",
+        "gpt-4.1",
+
+    ]
+
+    def __init__(
+        self,
+        api_key: str = "tryit-53926507126-2c8a2543c7b5638ca6b92b6e53ef2d2b",
+        timeout: Optional[int] = 30,
+        browser: str = "chrome",
+        model: str = "standard",
+        chat_style: str = "chat",
+        enabled_tools: Optional[List[str]] = None,
+        **kwargs
+    ):
+        self.timeout = timeout
+        self.api_key = api_key
+        self.model = model
+        self.chat_style = chat_style
+        self.enabled_tools = enabled_tools or ["image_generator"]
+
+        # Initialize requests Session
+        self.session = requests.Session()
+        
+        # Set up headers with API key
+        self.headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "api-key": self.api_key,
+            "Accept": "text/plain, */*",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept-Language": "en-US,en;q=0.9",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        }
+        
+        # Update session headers
+        self.session.headers.update(self.headers)        # Initialize chat interface
+        self.chat = Chat(self)
+
+    @classmethod
+    def get_models(cls, api_key: str = None):
+        """Fetch available models from DeepAI API.
+
+        Args:
+            api_key (str, optional): DeepAI API key. If not provided, returns default models.
+
+        Returns:
+            list: List of available model IDs
+        """
+        return cls.AVAILABLE_MODELS
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
+
+if __name__ == "__main__":
+    client = DeepAI()
+    response = client.chat.completions.create(
+        model="standard",
+        messages=[{"role": "user", "content": "Hello!"}],
+        stream=False
+    )
+    print(response.choices[0].message.content)

webscout-2025.10.19/webscout/version.py

@@ -0,0 +1,2 @@
+__version__ = "2025.10.19"
+__prog__ = "webscout"

{webscout-2025.10.18 → webscout-2025.10.19/webscout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 2025.10.18
+Version: 2025.10.19
 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-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI