webscout 8.3.3__py3-none-any.whl → 8.3.4__py3-none-any.whl

webscout/Provider/OPENAI/scirachat.py

@@ -321,36 +321,88 @@ class SciraChat(OpenAICompatibleProvider):
             messages=[{"role": "user", "content": "Hello!"}]
         )
     """
-    # List of model display names for registration (aliases)
-    AVAILABLE_MODELS = [
-        "Grok3-mini (thinking)",
-        "Grok3",
-        "Claude 4 Sonnet",
-        "Claude 4 Sonnet Thinking",
-        "Grok2-Vision (vision)",
-        "GPT4o",
-        "QWQ-32B",
-        "o4-mini",
-        "Gemini 2.5 Flash Thinking",
-        "Gemini 2.5 Pro",
-        "Llama 4 Maverick",
-    ]
-    # Mapping from display name to internal model key
-    MODEL_NAME_MAP = {
-        "Grok3-mini (thinking)": "scira-default",
-        "Grok3": "scira-grok-3",
-        "Claude 4 Sonnet": "scira-anthropic",
-        "Claude 4 Sonnet Thinking": "scira-anthropic-thinking",
-        "Grok2-Vision (vision)": "scira-vision",
-        "GPT4o": "scira-4o",
-        "QWQ-32B": "scira-qwq",
-        "o4-mini": "scira-o4-mini",
-        "Gemini 2.5 Flash Thinking": "scira-google",
-        "Gemini 2.5 Pro": "scira-google-pro",
-        "Llama 4 Maverick": "scira-llama-4",
+    # Model mapping: actual model names to Scira API format
+    MODEL_MAPPING = {
+        "grok-3-mini": "scira-default",
+        "grok-3-mini-fast": "scira-x-fast-mini",
+        "grok-3-fast": "scira-x-fast",
+        "gpt-4.1-nano": "scira-nano",
+        "grok-3": "scira-grok-3",
+        "grok-4": "scira-grok-4",
+        "grok-2-vision-1212": "scira-vision",
+        "grok-2-latest": "scira-g2",
+        "gpt-4o-mini": "scira-4o-mini",
+        "o4-mini-2025-04-16": "scira-o4-mini",
+        "o3": "scira-o3",
+        "qwen/qwen3-32b": "scira-qwen-32b",
+        "qwen3-30b-a3b": "scira-qwen-30b",
+        "deepseek-v3-0324": "scira-deepseek-v3",
+        "claude-3-5-haiku-20241022": "scira-haiku",
+        "mistral-small-latest": "scira-mistral",
+        "gemini-2.5-flash-lite-preview-06-17": "scira-google-lite",
+        "gemini-2.5-flash": "scira-google",
+        "gemini-2.5-pro": "scira-google-pro",
+        "claude-sonnet-4-20250514": "scira-anthropic",
+        "claude-sonnet-4-20250514-thinking": "scira-anthropic-thinking",
+        "claude-4-opus-20250514": "scira-opus",
+        "claude-4-opus-20250514-pro": "scira-opus-pro",
+        "meta-llama/llama-4-maverick-17b-128e-instruct": "scira-llama-4",
     }
+    # Reverse mapping: Scira format to actual model names
+    SCIRA_TO_MODEL = {v: k for k, v in MODEL_MAPPING.items()}
+    # Add special cases for aliases and duplicate mappings
+    SCIRA_TO_MODEL["scira-anthropic-thinking"] = "claude-sonnet-4-20250514"
+    SCIRA_TO_MODEL["scira-opus-pro"] = "claude-4-opus-20250514"
+    SCIRA_TO_MODEL["scira-x-fast"] = "grok-3-fast"
+    SCIRA_TO_MODEL["scira-x-fast-mini"] = "grok-3-mini-fast"
+    SCIRA_TO_MODEL["scira-nano"] = "gpt-4.1-nano"
+    SCIRA_TO_MODEL["scira-qwen-32b"] = "qwen/qwen3-32b"
+    SCIRA_TO_MODEL["scira-qwen-30b"] = "qwen3-30b-a3b"
+    SCIRA_TO_MODEL["scira-deepseek-v3"] = "deepseek-v3-0324"
+    SCIRA_TO_MODEL["scira-grok-4"] = "grok-4"
+    MODEL_MAPPING["claude-4-opus-20250514-pro"] = "scira-opus-pro"
+    # Available models list (actual model names + scira aliases)
+    AVAILABLE_MODELS = list(MODEL_MAPPING.keys()) + list(SCIRA_TO_MODEL.keys())
     # Optional: pretty display names for UI (reverse mapping)
-    MODEL_DISPLAY_NAMES = {v: k for k, v in MODEL_NAME_MAP.items()}
+    MODEL_DISPLAY_NAMES = {v: k for k, v in MODEL_MAPPING.items()}
+
+    @classmethod
+    def _resolve_model(cls, model: str) -> str:
+        """
+        Resolve a model name to its Scira API format.
+
+        Args:
+            model: Either an actual model name or a Scira alias
+
+        Returns:
+            The Scira API format model name
+
+        Raises:
+            ValueError: If the model is not supported
+        """
+        # If it's already a Scira format, return as-is
+        if model in cls.SCIRA_TO_MODEL:
+            return model
+        # If it's an actual model name, convert to Scira format
+        if model in cls.MODEL_MAPPING:
+            return cls.MODEL_MAPPING[model]
+        # Model not found
+        raise ValueError(f"Invalid model: {model}. Choose from: {cls.AVAILABLE_MODELS}")
+
+    def convert_model_name(self, model: str) -> str:
+        """
+        Convert model display names or internal keys to ones supported by SciraChat.
+        Args:
+            model: Model name or alias to convert
+        Returns:
+            SciraChat model name
+        """
+        # Use the new _resolve_model logic
+        try:
+            return self._resolve_model(model)
+        except Exception as e:
+            print(f"Warning: {e} Using 'scira-default' instead.")
+            return "scira-default"
 
     def __init__(
         self, 
@@ -447,25 +499,6 @@ class SciraChat(OpenAICompatibleProvider):
             print(f"Warning: Error formatting text: {e}")
             return text
     
-    def convert_model_name(self, model: str) -> str:
-        """
-        Convert model display names or internal keys to ones supported by SciraChat.
-        
-        Args:
-            model: Model name or alias to convert
-            
-        Returns:
-            SciraChat model name
-        """
-        # If model is a display name (alias), map to internal key
-        if model in self.MODEL_NAME_MAP:
-            return self.MODEL_NAME_MAP[model]
-        # If model is already an internal key, return it if valid
-        if model in self.MODEL_DISPLAY_NAMES:
-            return model
-        # Default to scira-default if model not found
-        print(f"Warning: Unknown model '{model}'. Using 'scira-default' instead.")
-        return "scira-default"
 
     @property
     def models(self):
@@ -478,9 +511,9 @@ class SciraChat(OpenAICompatibleProvider):
 if __name__ == "__main__":
     ai = SciraChat()
     response = ai.chat.completions.create(
-        model="Gemini 2.5 Pro",
+        model="grok-3-mini-fast-latest",
         messages=[
-            {"role": "user", "content": "who is pm of india?"}
+            {"role": "user", "content": "who are u?"}
         ],
         stream=True
     )

webscout/Provider/OPENAI/textpollinations.py

@@ -279,25 +279,26 @@ class TextPollinations(OpenAICompatibleProvider):
         "openai",
         "openai-fast",
         "openai-large",
+        "openai-reasoning",
         "openai-roblox",
-        "qwen-coder",
-        "llama",
+        "openai-audio",
+        "deepseek",
+        "deepseek-reasoning",
+        "grok",
         "llamascout",
         "mistral",
-        "unity",
-        "mirexa",
-        "midijourney",
-        "rtist",
+        "phi",
+        "qwen-coder",
         "searchgpt",
+        "bidara",
+        "elixposearch",
         "evil",
-        "deepseek-reasoning",
-        "phi",
-        "hormoz",
         "hypnosis-tracy",
-        "deepseek",
+        "midijourney",
+        "mirexa",
+        "rtist",
         "sur",
-        "bidara",
-        "openai-audio",
+        "unity",
     ]
 
     def __init__(

webscout/Provider/OPENAI/typegpt.py

@@ -288,10 +288,10 @@ class TypeGPT(OpenAICompatibleProvider):
         # Working Models (based on testing)
         "gpt-4o-mini",
         "chatgpt-4o-latest",
-        "deepseek-r1",
+        # "deepseek-r1",
         "deepseek-v3",
-        "uncensored-r1",
-        "Image-Generator",
+        # "uncensored-r1",
+        # "Image-Generator",
     ]
 
     def __init__(

webscout/Provider/Qodo.py

@@ -0,0 +1,454 @@
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+from typing import Any, Dict, Optional, Generator, Union
+import uuid
+import json
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import Provider
+from webscout import exceptions
+from webscout.litagent import LitAgent
+
+class QodoAI(Provider):
+    """
+    A class to interact with the Qodo AI API.
+    """
+
+    AVAILABLE_MODELS = [
+        "gpt-4.1",
+        "gpt-4o", 
+        "o3",
+        "o4-mini",
+        "claude-4-sonnet",
+        "gemini-2.5-pro",
+
+    ]
+
+    @staticmethod
+    def _qodo_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from Qodo stream JSON objects."""
+        if isinstance(chunk, dict):
+            data = chunk.get("data", {})
+            if isinstance(data, dict):
+                tool_args = data.get("tool_args", {})
+                if isinstance(tool_args, dict):
+                    return tool_args.get("content")
+        return None
+
+    def __init__(
+        self,
+        api_key: str = None,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "claude-4-sonnet",
+        browser: str = "chrome"
+    ):
+        """Initializes the Qodo AI API client."""
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+            
+        self.url = "https://api.cli.qodo.ai/v2/agentic/start-task"
+        self.info_url = "https://api.cli.qodo.ai/v2/info/get-things"
+        
+        # Initialize LitAgent for user agent generation
+        self.agent = LitAgent()
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        
+        # Store API key
+        self.api_key = api_key or "sk-dS7U-extxMWUxc8SbYYOuncqGUIE8-y2OY8oMCpu0eI-qnSUyH9CYWO_eAMpqwfMo7pXU3QNrclfZYMO0M6BJTM"
+        
+        # Generate session ID dynamically from API
+        self.session_id = self._get_session_id()
+        self.request_id = str(uuid.uuid4())
+        
+        # Use the fingerprint for headers
+        self.headers = {
+            "Accept": "text/plain",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Authorization": f"Bearer {self.api_key}",
+            "Connection": "close",
+            "Content-Type": "application/json",
+            "host": "api.cli.qodo.ai",
+            "Request-id": self.request_id,
+            "User-Agent": self.fingerprint["user_agent"],
+        }
+        
+        # Initialize curl_cffi Session
+        self.session = Session()
+        # Add Session-id to headers after getting it from API
+        self.headers["Session-id"] = self.session_id
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        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 headers with new fingerprint
+        self.headers.update({
+            "Accept-Language": self.fingerprint["accept_language"],
+            "User-Agent": self.fingerprint["user_agent"],
+        })
+        
+        # Update session headers
+        for header, value in self.headers.items():
+            self.session.headers[header] = value
+        
+        return self.fingerprint
+
+    def _build_payload(self, prompt: str):
+        """Build the payload for Qodo AI API."""
+        return {
+            "agent_type": "cli",
+            "session_id": self.session_id,
+            "user_data": {
+                "extension_version": "0.7.2",
+                "os_platform": "win32",
+                "os_version": "v23.9.0",
+                "editor_type": "cli"
+            },
+            "tools": {
+                "web_search": [
+                    {
+                        "name": "web_search",
+                        "description": "Searches the web and returns results based on the user's query (Powered by Nimble).",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "llm_description": {
+                                    "default": "Searches the web and returns results based on the user's query.",
+                                    "title": "Llm Description",
+                                    "type": "string"
+                                },
+                                "query": {
+                                    "description": "The search query to execute",
+                                    "title": "Query",
+                                    "type": "string"
+                                }
+                            },
+                            "required": ["query"],
+                            "title": "NimbleWebSearch"
+                        },
+                        "be_tool": True,
+                        "autoApproved": True
+                    },
+                    {
+                        "name": "web_fetch",
+                        "description": "Fetches content from a given URL (Powered by Nimble).",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "llm_description": {
+                                    "default": "Fetches content from a given URL.",
+                                    "title": "Llm Description",
+                                    "type": "string"
+                                },
+                                "url": {
+                                    "description": "The URL to fetch content from",
+                                    "title": "Url",
+                                    "type": "string"
+                                }
+                            },
+                            "required": ["url"],
+                            "title": "NimbleWebFetch"
+                        },
+                        "be_tool": True,
+                        "autoApproved": True
+                    }
+                ]
+            },
+            # "projects_root_path": ["C:\\Users\\koula"],
+            # "cwd": "C:\\Users\\koula",
+            "user_request": prompt,
+            "execution_strategy": "act",
+            "custom_model": self.model,
+            "stream": True
+        }
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        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 {self.__available_optimizers}")
+
+        payload = self._build_payload(conversation_prompt)
+        payload["stream"] = stream
+
+        def for_stream():
+            try:
+                response = self.session.post(
+                    self.url, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=self.timeout,
+                    impersonate=self.fingerprint.get("browser_type", "chrome110")
+                )
+                if response.status_code == 401:
+                    raise exceptions.FailedToGenerateResponseError(
+                        "Invalid API key. You need to provide your own API key.\n"
+                        "Usage: QodoAI(api_key='your_api_key_here')\n"
+                        "To get an API key, install Qodo CLI via: https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart"
+                    )
+                elif response.status_code != 200:
+                    raise exceptions.FailedToGenerateResponseError(f"HTTP {response.status_code}: {response.text}")
+
+                streaming_text = ""
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None),
+                    intro_value="",
+                    to_json=True,
+                    skip_markers=["[DONE]"],
+                    content_extractor=self._qodo_extractor,
+                    yield_raw_on_error=True,
+                    raw=raw
+                )
+                for content_chunk in processed_stream:
+                    if content_chunk:
+                        yield content_chunk if raw else {"text": content_chunk}
+                        if not raw:
+                            streaming_text += content_chunk
+
+                self.last_response = {"text": streaming_text}
+                self.conversation.update_chat_history(prompt, streaming_text)
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
+
+        def for_non_stream():
+            try:
+                payload["stream"] = False
+                response = self.session.post(
+                    self.url, 
+                    json=payload, 
+                    timeout=self.timeout,
+                    impersonate=self.fingerprint.get("browser_type", "chrome110")
+                )
+                if response.status_code == 401:
+                    raise exceptions.FailedToGenerateResponseError(
+                        "Invalid API key. You need to provide your own API key.\n"
+                        "Usage: QodoAI(api_key='your_api_key_here')\n"
+                        "To get an API key, install Qodo CLI via: https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart"
+                    )
+                elif response.status_code != 200:
+                    raise exceptions.FailedToGenerateResponseError(f"HTTP {response.status_code}: {response.text}")
+
+                response_text = response.text
+                processed_stream = sanitize_stream(
+                    data=response_text.splitlines(),
+                    intro_value=None,
+                    to_json=True,
+                    content_extractor=self._qodo_extractor,
+                    yield_raw_on_error=True,
+                    raw=raw
+                )
+                full_response = ""
+                for content in processed_stream:
+                    if content:
+                        full_response += content
+
+                self.last_response = {"text": full_response}
+                self.conversation.update_chat_history(prompt, full_response)
+                return {"text": full_response} if not raw else full_response
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {e}")
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        raw: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        def for_stream():
+            for response in self.ask(
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally
+            ):
+                if raw:
+                    yield response
+                else:
+                    yield response.get("text", "")
+
+        def for_non_stream():
+            result = self.ask(
+                prompt, False, raw=raw, optimizer=optimizer, conversationally=conversationally
+            )
+            if raw:
+                return result
+            else:
+                return self.get_message(result)
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        text = response.get("text", "")
+        return text.replace('\\n', '\n').replace('\\n\\n', '\n\n')
+
+    def _get_session_id(self) -> str:
+        """Get session ID from Qodo API."""
+        try:
+            # Create temporary session for the info request
+            temp_session = Session()
+            temp_headers = {
+                "Accept": "text/plain",
+                "Accept-Encoding": "gzip, deflate, br",
+                "Authorization": f"Bearer {self.api_key}",
+                "Connection": "close",
+                "Content-Type": "application/json",
+                "host": "api.cli.qodo.ai",
+                "Request-id": str(uuid.uuid4()),
+                "User-Agent": self.fingerprint["user_agent"] if hasattr(self, 'fingerprint') else "axios/1.10.0",
+            }
+            temp_session.headers.update(temp_headers)
+            
+            response = temp_session.get(
+                self.info_url,
+                timeout=self.timeout if hasattr(self, 'timeout') else 30,
+                impersonate="chrome110"
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                session_id = data.get("session-id")
+                if session_id:
+                    return session_id
+            elif response.status_code == 401:
+                # API key is invalid
+                raise exceptions.FailedToGenerateResponseError(
+                    "Invalid API key. You need to provide your own API key.\n"
+                    "Usage: QodoAI(api_key='your_api_key_here')\n"
+                    "To get an API key, install Qodo CLI via: https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart"
+                )
+            else:
+                # Other HTTP errors
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to authenticate with Qodo API (HTTP {response.status_code}). "
+                    "You may need to provide your own API key.\n"
+                    "Usage: QodoAI(api_key='your_api_key_here')\n"
+                    "To get an API key, install Qodo CLI via: https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart"
+                )
+                    
+            # Fallback to generated session ID if API call fails
+            return f"20250630-{str(uuid.uuid4())}"
+            
+        except exceptions.FailedToGenerateResponseError:
+            # Re-raise our custom exceptions
+            raise
+        except Exception as e:
+            # For other errors, show the API key message
+            raise exceptions.FailedToGenerateResponseError(
+                f"Failed to connect to Qodo API: {e}\n"
+                "You may need to provide your own API key.\n"
+                "Usage: QodoAI(api_key='your_api_key_here')\n"
+                "To get an API key, install Qodo CLI via: https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart"
+            )
+
+    def refresh_session(self):
+        """
+        Refreshes the session ID by calling the Qodo API.
+        
+        Returns:
+            str: The new session ID
+        """
+        old_session_id = self.session_id
+        self.session_id = self._get_session_id()
+        
+        # Update headers with new session ID
+        self.headers["Session-id"] = self.session_id
+        self.session.headers["Session-id"] = self.session_id
+        
+        return self.session_id
+
+    def get_available_models(self) -> Dict[str, Any]:
+        """
+        Get available models and info from Qodo API.
+        
+        Returns:
+            Dict containing models, default_model, version, and session info
+        """
+        try:
+            response = self.session.get(
+                self.info_url,
+                timeout=self.timeout,
+                impersonate=self.fingerprint.get("browser_type", "chrome110")
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 401:
+                raise exceptions.FailedToGenerateResponseError(
+                    "Invalid API key. You need to provide your own API key.\n"
+                    "Usage: QodoAI(api_key='your_api_key_here')\n"
+                    "To get an API key, install Qodo CLI via: https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart"
+                )
+            else:
+                raise exceptions.FailedToGenerateResponseError(f"Failed to get models: HTTP {response.status_code}")
+                
+        except CurlError as e:
+            raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Failed to get models ({type(e).__name__}): {e}")
+
+
+if __name__ == "__main__":
+    ai = QodoAI() # u will need to give your API key here to get api install qodo cli via https://docs.qodo.ai/qodo-documentation/qodo-gen-cli/getting-started/setup-and-quickstart
+    response = ai.chat("write a poem about india", raw=False, stream=True) 
+    for chunk in response:
+        print(chunk, end='', flush=True)