webscout 2025.10.19.3__py3-none-any.whl → 2025.10.22.1__py3-none-any.whl

webscout/Provider/DeepAI.py

@@ -18,7 +18,7 @@ class DeepAI(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
+    required_auth = True
     AVAILABLE_MODELS = [
         "standard", 
         "genius", 

webscout/Provider/Flowith.py

@@ -19,7 +19,7 @@ class Flowith(Provider):
     AVAILABLE_MODELS = [
         "gpt-5-nano", "gpt-5-mini", "glm-4.5", "gpt-oss-120b", "gpt-oss-20b", "kimi-k2",
         "gpt-4.1", "gpt-4.1-mini", "deepseek-chat", "deepseek-reasoner",
-        "gemini-2.5-flash", "grok-3-mini"
+        "gemini-2.5-flash", "grok-3-mini", "claude-haiku-4.5"
     ]
 
     def __init__(

webscout/Provider/GMI.py

@@ -29,7 +29,10 @@ class GMI(Provider):
         "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
         "zai-org/GLM-4.5-Air-FP8",
         "zai-org/GLM-4.5-FP8",
-        "zai-org/GLM-4.6"
+        "zai-org/GLM-4.6",
+        "openai/gpt-oss-20b",
+        "openai/gpt-oss-120b"
+
     ]
 
     def __init__(

webscout/Provider/OLLAMA.py

@@ -5,9 +5,10 @@ from webscout.AIbase import Provider
 from typing import AsyncGenerator, Dict, List, Optional, Union
 
 try:
-    from ollama import AsyncClient, Client, ResponseError
+    from ollama import AsyncClient, Client, ResponseError # type: ignore
 except ImportError as e:
-    pass
+    print("Please install the 'ollama' package to use the OLLAMA provider: pip install ollama")
+    raise e
 
 class OLLAMA(Provider):
     required_auth = True

webscout/Provider/OPENAI/flowith.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 from typing import List, Dict, Optional, Union, Generator, Any
 import time
 import json
@@ -152,7 +153,7 @@ class Flowith(OpenAICompatibleProvider):
     AVAILABLE_MODELS = [
         "gpt-5-nano", "gpt-5-mini", "glm-4.5", "gpt-oss-120b", "gpt-oss-20b", "kimi-k2",
         "gpt-4.1", "gpt-4.1-mini", "deepseek-chat", "deepseek-reasoner",
-        "gemini-2.5-flash", "grok-3-mini"
+        "gemini-2.5-flash", "grok-3-mini", "claude-haiku-4.5"
     ]
 
     chat: Chat
@@ -171,7 +172,7 @@ if __name__ == "__main__":
     client = Flowith()
     messages = [{"role": "user", "content": "Hello, how are you?"}]
     response = client.chat.completions.create(
-        model="gpt-5-nano",
+        model="gpt-oss-120b",
         messages=messages,
         stream=True
     )

webscout/Provider/OPENAI/gmi.py

@@ -261,7 +261,10 @@ class GMI(OpenAICompatibleProvider):
         "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
         "zai-org/GLM-4.5-Air-FP8",
         "zai-org/GLM-4.5-FP8",
-        "zai-org/GLM-4.6"
+        "zai-org/GLM-4.6",
+        "openai/gpt-oss-20b",
+        "openai/gpt-oss-120b"
+
     ]
 
     def __init__(self, browser: str = "chrome", api_key: str = None, **kwargs):

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "2025.10.19.3"
+__version__ = "2025.10.22.1"
 __prog__ = "webscout"

webscout/version.py.bak

@@ -1,2 +1,2 @@
-__version__ = "2025.10.19.2"
+__version__ = "2025.10.22"
 __prog__ = "webscout"

{webscout-2025.10.19.3.dist-info → webscout-2025.10.22.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 2025.10.19.3
+Version: 2025.10.22.1
 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.3.dist-info → webscout-2025.10.22.1.dist-info}/RECORD

@@ -14,8 +14,8 @@ webscout/prompt_manager.py,sha256=ysKFgPhkV3uqrOCilqcS9rG8xhzdU_d2wx0grC9WCCc,98
 webscout/sanitize.py,sha256=pw2Dzn-Jw9mOD4mpALYAvAf-medA-9AqdzsOmdXQbl0,46577
 webscout/update_checker.py,sha256=bz0TzRxip9DOIVMFyNz9HsGj4RKB0xZgo57AUVSJINo,3708
 webscout/utils.py,sha256=o2hU3qaVPk25sog3e4cyVZO3l8xwaZpYRziZPotEzNo,3075
-webscout/version.py,sha256=HrZ0YXrvSmy_XwCklNU3PpzJN38H-NfnCifb4qFvY1g,53
-webscout/version.py.bak,sha256=N_VqqQ31d_XNbPVnrX8RC1vAP0b8CdNu1xPPZHxN33A,53
+webscout/version.py,sha256=tpDfve30bR6-BnhG1CAgIUu7vn3hmQXpXe5Hbzdr_hg,53
+webscout/version.py.bak,sha256=nfux5jrqPs5E5KYUPEBPASSB2Z1rinLgUlMZThId2uo,51
 webscout/Extra/Act.md,sha256=_C2VW_Dc-dc7eejpGYKAOZhImHKPiQ7NSwE3bkzr6fg,18952
 webscout/Extra/__init__.py,sha256=KvJRsRBRO-fZp2jSCl6KQnPppi93hriA6O_U1O1s31c,177
 webscout/Extra/gguf.md,sha256=McXGz5sTfzOO9X4mH8yIqu5K3CgjzyXKi4_HQtezdZ4,12435
@@ -70,12 +70,12 @@ webscout/Provider/ChatSandbox.py,sha256=Hl8vOQzij7VyYVoL3DvJO6HGUs6tXZY3xrbCLKrF
 webscout/Provider/ClaudeOnline.py,sha256=3J5LEjvxzpYgIcycCq1aG_kFjks7ECkJS6l0HQ5bEyQ,12748
 webscout/Provider/Cloudflare.py,sha256=nrHCZ9SYNNRIxxzR_QRU1fy-jh31WnErxIimF0aDZms,14155
 webscout/Provider/Cohere.py,sha256=wPULeG_2JZdhN8oTBjs_QNqs6atjkYkjCa01mRmg8Fw,8082
-webscout/Provider/DeepAI.py,sha256=z7TBsidQkxfrGvlBGARcdUDclQnLBq5wC1euzHLiEI8,12661
+webscout/Provider/DeepAI.py,sha256=eKPauGUMdWG14v4593HwfLKmAFhWE90WZ6_X5LCby9Q,12660
 webscout/Provider/Deepinfra.py,sha256=Z3FNMaaVd4KiitDG8LBgGWycNuT6Y1Z06sCFURd0Ynw,15882
 webscout/Provider/ExaAI.py,sha256=HQ0BH1lInjsrpPSfIZkZf52q_gbHmnFnMJtRiZoxTXw,9548
 webscout/Provider/ExaChat.py,sha256=6ryax7zFeUrFTBa3inMrOGPxY-tfbavDQIgOTZr0-cY,11700
-webscout/Provider/Flowith.py,sha256=5Foxpx1Jj4HhMkWrPNo8hZDMhtC-YfCCKgTCXsPhUoQ,8497
-webscout/Provider/GMI.py,sha256=NkFVwrGFPu_dqy4YWPAjgPHmNVX-jltYuBH623ooZvs,11366
+webscout/Provider/Flowith.py,sha256=GUYdf_AFR2qWx_OHtSPzAK5vTcaBfgv0GeWVMoAQnC8,8517
+webscout/Provider/GMI.py,sha256=fB2yIDel5MRQd_mjhh8mrbwqXKIkoLZDrIkRbxgNymc,11428
 webscout/Provider/Gemini.py,sha256=Idpl9B_2yF2hK8agb6B4Qnvg6jmaQT008aOx8M2w2O4,6288
 webscout/Provider/GeminiProxy.py,sha256=JzOnUMNEcriTXbVZvp9SauYWx4ekgCj2DyRyD-jUj9M,6515
 webscout/Provider/GithubChat.py,sha256=FeRQfy1C9gxPlDmfH0VfBgd6CSCmN1XI6YES1Mp9mQM,14374
@@ -88,7 +88,7 @@ webscout/Provider/Koboldai.py,sha256=jv0zVxMp_Y56qZGZY8K_2DY9ysB0GzneEujTNd8W-Hw
 webscout/Provider/LambdaChat.py,sha256=SrvKTlEiqTX-e6ixCQ68e7DJVyDmd9MBnWMlnfcvQOk,18983
 webscout/Provider/Nemotron.py,sha256=Sj2D3Vng6icocejV45wWKvXYh8NG_pYMkfH-F1UL4CA,8838
 webscout/Provider/Netwrck.py,sha256=Wni4zV1J2MLt_G-sKwEdgsSwQTlGCZ1nKrD8akdG9LY,10295
-webscout/Provider/OLLAMA.py,sha256=1FEXxOwPX67Hl022aHyQipk_MLptCiNkyZSSwxOqIOA,14692
+webscout/Provider/OLLAMA.py,sha256=PSnRnxiW18L3Gy827D2JPsOBNTJDfOTG-8whR-jHj9E,14806
 webscout/Provider/OpenGPT.py,sha256=R2H0iewJmaaW-KeHVOCPaL1lMyagy1KvrTALxhOBgQU,9389
 webscout/Provider/Openai.py,sha256=yxPXvACdA7cOyBEUN_fCbDujCzhpzXHVXlhteeg6JRo,9381
 webscout/Provider/PI.py,sha256=CFD_z6UFm0FKMvALSSefCdQ_fM-fRqpLRuXVmMJ2s3w,16230
@@ -111,7 +111,6 @@ webscout/Provider/akashgpt.py,sha256=PjRgZL0hxfhZPydn4a6tOVCa18SCseV6QJjXu7LZauY
 webscout/Provider/cerebras.py,sha256=C0rbHL65sVFUHe7zx0UbIlWhA06qUKvip5txgRsp_bU,17030
 webscout/Provider/chatglm.py,sha256=hAWtwlAUefQLc9zh3ji3-IJwH7z2fV-4tLN5_Wi0VAM,15887
 webscout/Provider/cleeai.py,sha256=WpSOoJZ69ttEosbJNH3J4UAkoOTOCy1hXyTjZsAzMTw,7782
-webscout/Provider/deepseek_assistant.py,sha256=7jxTWEUwvGwvj8NsSjk8PSvNKUgxQXPp8GwD7JcufC0,14582
 webscout/Provider/elmo.py,sha256=tjqB8zxmpKb_Ps0zJ_nd63KQ8FbwzUEEKWR0_Mhc20Y,12618
 webscout/Provider/geminiapi.py,sha256=xvxQzTX36MTb2ukiKjhfzomGR3OXOmtg40eMrYLB5rA,8321
 webscout/Provider/granite.py,sha256=u5-kyemo3lmPMc_R-OWCfusZMy-olmKo1hhzJ9ZYWLQ,11015
@@ -145,7 +144,6 @@ webscout/Provider/AISEARCH/stellar_search.py,sha256=BFEGmcOHZUtFx-Z4tqUIrgZ-qgdz
 webscout/Provider/AISEARCH/webpilotai_search.py,sha256=C7j-xe2If6FwS-YyXkn8U5-Uw09eG7ZrESiCFJo9eYo,11256
 webscout/Provider/OPENAI/Cloudflare.py,sha256=RGf1aH08UzkxRq9hF3nmKbkOrDzGXU_KFkdtsE8SVpY,14454
 webscout/Provider/OPENAI/DeepAI.py,sha256=IeGpsbsW8URM3Lulfp3VGetZOqVEq9wK-AjfZA7d9Lw,13743
-webscout/Provider/OPENAI/FalconH1.py,sha256=SlMZF-2TzquEsKFTuPGR039OnJ3Z4ro49nuLyNFT0Sk,21880
 webscout/Provider/OPENAI/FreeGemini.py,sha256=C8ZdV0FxzP4D2g5scW1Fp7zG4BmV-Cjztdp0KeuQqIw,10919
 webscout/Provider/OPENAI/GeminiProxy.py,sha256=9_6VHFylM3-ct0m5XDvxfZ1tmd70RnyZl5HT-qv1g4E,11266
 webscout/Provider/OPENAI/K2Think.py,sha256=bNdq-oy2ie8PH7r6RDX7ZosYKFGjqzLSBvC2d_HAWAg,14822
@@ -165,10 +163,10 @@ webscout/Provider/OPENAI/deepinfra.py,sha256=RzlBVBTsrLeRpTV8PrZxlqEN0XTRgnL2Jtm
 webscout/Provider/OPENAI/e2b.py,sha256=1Eg70mzeh31kyCfctvVLQVODLBz3LPPtUPcQBbksYZ4,72311
 webscout/Provider/OPENAI/exaai.py,sha256=NKsmz8mka3jncDe7S-jeJpRbw26ds2fqAvChd9ltNpM,14646
 webscout/Provider/OPENAI/exachat.py,sha256=xxT-COXVbCgjUYyi4Zu469eUSSwABYYLdQ7HljLm6a8,15409
-webscout/Provider/OPENAI/flowith.py,sha256=ZNgVFeEBf0Pj4Ey11-RrEP8qlLKNzJul6FA-Tg-Y8hA,6638
+webscout/Provider/OPENAI/flowith.py,sha256=LMof65tofDbYfg4oqzvjolC1DEpSj_4BOUEAhzsHWnY,6683
 webscout/Provider/OPENAI/friendli.py,sha256=NlTNz-3nBFPKA1xXwZx8aJPsuQh-_QB3AzM14x5Z3Qw,10214
 webscout/Provider/OPENAI/generate_api_key.py,sha256=yh8rUBbNLdbe-uetelw2sVfPaNNx7CYIHoDfcyEjRy4,1490
-webscout/Provider/OPENAI/gmi.py,sha256=cUuSsi0kAvTxp1RbhwfKIX2UAIqyv2uKssRs57cB4Bo,13009
+webscout/Provider/OPENAI/gmi.py,sha256=oNAiEiJkxBAR7Vmw0kqmGlasV17f9hRkNqY6f6EV3VE,13071
 webscout/Provider/OPENAI/groq.py,sha256=Kw5mm___iKDte1XXumEd0aCWQSDr9WioX_lpL07KGx4,14200
 webscout/Provider/OPENAI/heckai.py,sha256=XCh_D8KccmLtDATcp9WJ0RuE0tXhklq9dBrmVctcVto,11457
 webscout/Provider/OPENAI/llmchatco.py,sha256=izvK7XENNZCm6QugZ4f6DfALuMCjO4tLlg2izpyO3fM,15034
@@ -332,9 +330,9 @@ webscout/zeroart/__init__.py,sha256=Cy9AUtXnOaFBQjNvCpN19IXJo7Lg15VTaNcTBxOTFek,
 webscout/zeroart/base.py,sha256=I-xhDEfArBb6q7hiF5oPoyXeu2hzL6orp7uWgS_YtG8,2299
 webscout/zeroart/effects.py,sha256=XUNZY1-wMPd6GNL3glFXtWaF9wDis_z55qTyCdnzHDo,5063
 webscout/zeroart/fonts.py,sha256=S7qDhUmDXl1makMreZl_eVW_7-sqVQiGn-kQKl0Hg_A,51006
-webscout-2025.10.19.3.dist-info/licenses/LICENSE.md,sha256=hyfFlVn7pWcrvuvs-piB8k4J8DlXdOsYje9RyPxc6Ik,7543
-webscout-2025.10.19.3.dist-info/METADATA,sha256=c2w2uSFFgwSBIFHKH1w3qRtTWAaAYtHICbOvJhm1Lp0,21640
-webscout-2025.10.19.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-webscout-2025.10.19.3.dist-info/entry_points.txt,sha256=4xAgKHWwNhAvJyShLCFs_IU8Reb8zR3wqf8egrsDr8g,118
-webscout-2025.10.19.3.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
-webscout-2025.10.19.3.dist-info/RECORD,,
+webscout-2025.10.22.1.dist-info/licenses/LICENSE.md,sha256=hyfFlVn7pWcrvuvs-piB8k4J8DlXdOsYje9RyPxc6Ik,7543
+webscout-2025.10.22.1.dist-info/METADATA,sha256=hOXQdp-SN7a864HFBckSK_EUBn-ZfauOnxTnK0AP4Gk,21640
+webscout-2025.10.22.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+webscout-2025.10.22.1.dist-info/entry_points.txt,sha256=4xAgKHWwNhAvJyShLCFs_IU8Reb8zR3wqf8egrsDr8g,118
+webscout-2025.10.22.1.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
+webscout-2025.10.22.1.dist-info/RECORD,,

webscout/Provider/OPENAI/FalconH1.py

@@ -1,452 +0,0 @@
-import requests
-import json
-import time
-import uuid
-from typing import List, Dict, Optional, Union, Generator, Any
-
-from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from webscout.Provider.OPENAI.utils import (
-    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage,
-    get_system_prompt,
-    count_tokens,
-    format_prompt
-)
-from webscout.litagent import LitAgent
-
-def convert_openai_to_falcon_history(messages: List[Dict[str, str]]) -> list:
-    """
-    Converts a list of OpenAI-style chat messages to Falcon/Gradio chat history format.
-
-    Args:
-        messages (List[Dict[str, str]]):
-            A list of message dictionaries, each with 'role' and 'content' keys, following the OpenAI API format.
-
-    Returns:
-        list: A single-turn Falcon/Gradio chat history in the format [[prompt, None]].
-    """
-    prompt = format_prompt(messages, add_special_tokens=False, do_continue=True, include_system=True)
-    return [[prompt, None]]
-
-class Completions(BaseCompletions):
-    """
-    Handles text completion requests for the FalconH1 provider, supporting both streaming and non-streaming modes.
-
-    Attributes:
-        _client (Any): Reference to the FalconH1 client instance.
-        _last_yielded_content_stream (str): Tracks the last yielded content in streaming mode.
-    """
-    def __init__(self, client):
-        """
-        Initializes the Completions handler.
-
-        Args:
-            client: The FalconH1 client instance.
-        """
-        self._client = client
-        self._last_yielded_content_stream = ""
-
-    def create(
-        self,
-        *,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: Optional[int] = 1024,
-        stream: bool = False,
-        temperature: Optional[float] = 0.1,
-        top_p: Optional[float] = 1.0,
-        timeout: Optional[int] = None,
-        proxies: Optional[dict] = None,
-        **kwargs: Any
-    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        """
-        Creates a chat completion using the FalconH1 API, supporting both streaming and non-streaming responses.
-
-        Args:
-            model (str): The model identifier to use for completion.
-            messages (List[Dict[str, str]]): List of chat messages in OpenAI format.
-            max_tokens (Optional[int]): Maximum number of tokens to generate in the completion.
-            stream (bool): Whether to stream the response as chunks.
-            temperature (Optional[float]): Sampling temperature.
-            top_p (Optional[float]): Nucleus sampling probability.
-            timeout (Optional[int]): Request timeout in seconds.
-            proxies (Optional[dict]): Optional proxy settings for the request.
-            **kwargs: Additional keyword arguments for advanced options (e.g., top_k, repetition_penalty).
-
-        Returns:
-            Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]: The chat completion result or a generator yielding streamed chunks.
-        """
-        session_hash = str(uuid.uuid4()).replace('-', '')
-        chat_history = convert_openai_to_falcon_history(messages)
-        if not chat_history or chat_history[-1][0] is None:
-            raise ValueError("Messages must contain at least one user message for Falcon API.")
-        resolved_model_name = self._client.get_model(model)
-        payload_data = [
-            chat_history,
-            resolved_model_name,
-            temperature,
-            max_tokens,
-            top_p,
-            kwargs.get("top_k", 20),
-            kwargs.get("repetition_penalty", 1.2)
-        ]
-        payload = {
-            "data": payload_data,
-            "event_data": None,
-            "fn_index": 5,
-            "trigger_id": 12,
-            "session_hash": session_hash
-        }
-        request_id = f"chatcmpl-{uuid.uuid4()}"
-        created_time = int(time.time())
-        if stream:
-            self._last_yielded_content_stream = ""
-            return self._create_stream(request_id, created_time, resolved_model_name, payload, session_hash, timeout=timeout, proxies=proxies)
-        else:
-            return self._create_non_stream(request_id, created_time, resolved_model_name, payload, session_hash, timeout=timeout, proxies=proxies)
-
-    def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], session_hash: str,
-        timeout: Optional[int] = None, proxies: Optional[dict] = None
-    ) -> Generator[ChatCompletionChunk, None, None]:
-        """
-        Internal method to handle streaming chat completions from the FalconH1 API.
-
-        Args:
-            request_id (str): Unique request identifier.
-            created_time (int): Timestamp of request creation.
-            model (str): Model identifier.
-            payload (Dict[str, Any]): Request payload for the API.
-            session_hash (str): Unique session hash for the request.
-            timeout (Optional[int]): Request timeout in seconds.
-            proxies (Optional[dict]): Optional proxy settings.
-
-        Yields:
-            ChatCompletionChunk: Chunks of the chat completion as they are received from the API.
-        """
-        original_proxies = self._client.session.proxies.copy()
-        if proxies is not None:
-            self._client.session.proxies = proxies
-        else:
-            self._client.session.proxies = {}
-        try:
-            session = self._client.session
-            join_resp = session.post(
-                self._client.api_join_endpoint,
-                headers=self._client.headers,
-                json=payload,
-                timeout=timeout if timeout is not None else self._client.timeout
-            )
-            join_resp.raise_for_status()
-            data_url = f"{self._client.api_data_endpoint}?session_hash={session_hash}"
-            stream_resp = session.get(
-                data_url,
-                headers=self._client.stream_headers,
-                stream=True,
-                timeout=timeout if timeout is not None else self._client.timeout
-            )
-            stream_resp.raise_for_status()
-            for line in stream_resp.iter_lines():
-                if line:
-                    decoded_line = line.decode('utf-8')
-                    if decoded_line.startswith('data: '):
-                        try:
-                            json_data = json.loads(decoded_line[6:])
-                            msg_type = json_data.get('msg')
-                            if msg_type == 'process_generating':
-                                output_field = json_data.get('output', {})
-                                data_field = output_field.get('data')
-                                if data_field and isinstance(data_field, list) and len(data_field) > 0:
-                                    inner_data = data_field[0]
-                                    content_to_yield = None
-                                    if isinstance(inner_data, list) and len(inner_data) > 0:
-                                        if isinstance(inner_data[0], list) and len(inner_data[0]) == 3 and inner_data[0][0] == "append":
-                                            content_to_yield = inner_data[0][2]
-                                        elif isinstance(inner_data[0], list) and len(inner_data[0]) == 2 and \
-                                             isinstance(inner_data[0][1], str):
-                                            current_full_response = inner_data[0][1]
-                                            if current_full_response.startswith(self._last_yielded_content_stream):
-                                                content_to_yield = current_full_response[len(self._last_yielded_content_stream):]
-                                            else:
-                                                content_to_yield = current_full_response
-                                            self._last_yielded_content_stream = current_full_response
-                                    if content_to_yield:
-                                        delta = ChoiceDelta(content=content_to_yield, role="assistant")
-                                        yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-                            elif msg_type == 'process_completed' or msg_type == 'close_stream':
-                                break
-                        except json.JSONDecodeError:
-                            continue
-                        except Exception as e:
-                            continue
-        finally:
-            self._client.session.proxies = original_proxies
-
-    def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], session_hash: str,
-        timeout: Optional[int] = None, proxies: Optional[dict] = None
-    ) -> ChatCompletion:
-        """
-        Internal method to handle non-streaming chat completions from the FalconH1 API.
-
-        Args:
-            request_id (str): Unique request identifier.
-            created_time (int): Timestamp of request creation.
-            model (str): Model identifier.
-            payload (Dict[str, Any]): Request payload for the API.
-            session_hash (str): Unique session hash for the request.
-            timeout (Optional[int]): Request timeout in seconds.
-            proxies (Optional[dict]): Optional proxy settings.
-
-        Returns:
-            ChatCompletion: The full chat completion result.
-        """
-        original_proxies = self._client.session.proxies.copy()
-        if proxies is not None:
-            self._client.session.proxies = proxies
-        else:
-            self._client.session.proxies = {}
-        full_response_content = ""
-        last_full_response_chunk_ns = ""
-        response_parts = []
-        try:
-            session = self._client.session
-            join_resp = session.post(
-                self._client.api_join_endpoint, headers=self._client.headers, json=payload,
-                timeout=timeout if timeout is not None else self._client.timeout
-            )
-            join_resp.raise_for_status()
-            data_url = f"{self._client.api_data_endpoint}?session_hash={session_hash}"
-            overall_start_time = time.time()
-            effective_timeout = timeout if timeout is not None else self._client.timeout
-            while True:
-                if time.time() - overall_start_time > effective_timeout:
-                    raise TimeoutError("Timeout waiting for non-stream response completion.")
-                stream_resp = session.get(
-                    data_url, headers=self._client.stream_headers, stream=True,
-                    timeout=effective_timeout
-                )
-                stream_resp.raise_for_status()
-                found_completion_message = False
-                for line in stream_resp.iter_lines():
-                    if time.time() - overall_start_time > effective_timeout:
-                        raise TimeoutError("Timeout during non-stream response processing.")
-                    if line:
-                        decoded_line = line.decode('utf-8')
-                        if decoded_line.startswith('data: '):
-                            try:
-                                json_data = json.loads(decoded_line[6:])
-                                msg_type = json_data.get('msg')
-                                if msg_type == 'process_generating':
-                                    output_field = json_data.get('output', {})
-                                    data_field = output_field.get('data')
-                                    if data_field and isinstance(data_field, list) and len(data_field) > 0:
-                                        inner_data = data_field[0]
-                                        current_chunk_text = None
-                                        if isinstance(inner_data, list) and len(inner_data) > 0:
-                                            if isinstance(inner_data[0], list) and len(inner_data[0]) == 3 and inner_data[0][0] == "append":
-                                                current_chunk_text = inner_data[0][2]
-                                            elif isinstance(inner_data[0], list) and len(inner_data[0]) == 2 and isinstance(inner_data[0][1], str):
-                                                current_full_response = inner_data[0][1]
-                                                if current_full_response.startswith(last_full_response_chunk_ns):
-                                                    current_chunk_text = current_full_response[len(last_full_response_chunk_ns):]
-                                                else:
-                                                    current_chunk_text = current_full_response
-                                                last_full_response_chunk_ns = current_full_response
-                                        if current_chunk_text:
-                                            response_parts.append(current_chunk_text)
-                                elif msg_type == 'process_completed' or msg_type == 'close_stream':
-                                    if msg_type == 'process_completed':
-                                        output_field = json_data.get('output', {})
-                                        data_field = output_field.get('data')
-                                        if data_field and isinstance(data_field, list) and len(data_field) > 0:
-                                            inner_data = data_field[0]
-                                            if isinstance(inner_data, list) and len(inner_data) > 0 and \
-                                               isinstance(inner_data[0], list) and len(inner_data[0]) == 2 and \
-                                               isinstance(inner_data[0][1], str):
-                                                final_full_response = inner_data[0][1]
-                                                if final_full_response != last_full_response_chunk_ns:
-                                                    if final_full_response.startswith(last_full_response_chunk_ns):
-                                                        response_parts.append(final_full_response[len(last_full_response_chunk_ns):])
-                                                    else:
-                                                        response_parts = [final_full_response]
-                                                    last_full_response_chunk_ns = final_full_response
-                                    found_completion_message = True
-                                    break
-                            except json.JSONDecodeError:
-                                continue
-                            except Exception as e:
-                                raise e
-                if found_completion_message:
-                    break
-            full_response_content = "".join(response_parts)
-            message = ChatCompletionMessage(role="assistant", content=full_response_content)
-            choice = Choice(index=0, message=message, finish_reason="stop")
-            
-            # Simplified token counting without history iteration
-            chat_history = payload['data'][0]
-            prompt = chat_history[0][0] if chat_history and chat_history[0] and chat_history[0][0] else ""
-            prompt_tokens = count_tokens(prompt)
-            completion_tokens = count_tokens(full_response_content)
-            usage = CompletionUsage(
-                prompt_tokens=prompt_tokens,
-                completion_tokens=completion_tokens,
-                total_tokens=prompt_tokens + completion_tokens
-            )
-            return ChatCompletion(
-                id=request_id, choices=[choice], created=created_time,
-                model=model, usage=usage
-            )
-        finally:
-            self._client.session.proxies = original_proxies
-
-class Chat(BaseChat):
-    """
-    Provides a chat interface for the FalconH1 provider, exposing the completions API.
-
-    Attributes:
-        completions (Completions): The completions handler for chat requests.
-    """
-    def __init__(self, client):
-        """
-        Initializes the Chat interface for FalconH1.
-
-        Args:
-            client: The FalconH1 client instance.
-        """
-        self.completions = Completions(client)
-
-class FalconH1(OpenAICompatibleProvider):
-    """
-    FalconH1 provider implementation compatible with the OpenAI API interface.
-    Handles chat completions using FalconH1 models via the Hugging Face Spaces API.
-
-    Attributes:
-        base_url (str): Base URL for the FalconH1 API.
-        api_join_endpoint (str): Endpoint for joining the chat queue.
-        api_data_endpoint (str): Endpoint for retrieving chat data.
-        AVAILABLE_MODELS (List[str]): List of supported FalconH1 model identifiers.
-        timeout (int): Default request timeout in seconds.
-        session (requests.Session): HTTP session for API requests.
-        headers (dict): Default HTTP headers for requests.
-        stream_headers (dict): HTTP headers for streaming requests.
-        chat (Chat): Chat interface for completions.
-    """
-    base_url = "https://tiiuae-falcon-h1-playground.hf.space"
-    api_join_endpoint = f"{base_url}/gradio_api/queue/join?__theme=dark"
-    api_data_endpoint = f"{base_url}/gradio_api/queue/data"
-    AVAILABLE_MODELS = [
-        "Falcon-H1-34B-Instruct",
-        "Falcon-H1-7B-Instruct",
-        "Falcon-H1-3B-Instruct",
-        "Falcon-H1-1.5B-Deep-Instruct",
-        "Falcon-H1-1.5B-Instruct",
-        "Falcon-H1-0.5B-Instruct",
-    ]
-    def __init__(self, timeout: int = 120, proxies: Optional[dict] = None):
-        """
-        Initializes the FalconH1 provider with optional timeout and proxy settings.
-
-        Args:
-            timeout (int): Default request timeout in seconds (default: 120).
-            proxies (Optional[dict]): Optional proxy settings for HTTP requests.
-        """
-        super().__init__(proxies=proxies)
-        self.timeout = timeout
-        self.headers = {
-            'User-Agent': LitAgent().random(),
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.9,en-IN;q=0.8',
-            'Accept-Encoding': 'gzip, deflate, br, zstd',
-            'Referer': f'{self.base_url}/?__theme=dark',
-            'Content-Type': 'application/json',
-            'Origin': self.base_url,
-            'Connection': 'keep-alive',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-            'DNT': '1',
-            'Sec-GPC': '1',
-        }
-        self.stream_headers = {
-            'Accept': 'text/event-stream',
-            'Accept-Language': self.headers['Accept-Language'],
-            'Referer': self.headers['Referer'],
-            'User-Agent': self.headers['User-Agent'],
-            'Connection': 'keep-alive',
-            'Cache-Control': 'no-cache',
-        }
-        self.session.headers.update(self.headers)
-        self.chat = Chat(self)
-    def get_model(self, model_identifier: str) -> str:
-        """
-        Returns the resolved model name for the given identifier.
-
-        Args:
-            model_identifier (str): The model identifier string.
-
-        Returns:
-            str: The resolved model name (currently returns the identifier as-is).
-        """
-        return model_identifier
-    @property
-    def models(self):
-        """
-        Returns a list-like object containing available FalconH1 models.
-
-        Returns:
-            ModelList: An object with a .list() method returning model data objects.
-        """
-        class ModelData:
-            def __init__(self, id_str):
-                self.id = id_str
-        class ModelList:
-            def __init__(self, models_available):
-                self.data = [ModelData(m) for m in models_available]
-            def list(self):
-                return self.data
-        return ModelList(self.AVAILABLE_MODELS)
-
-if __name__ == "__main__":
-    """
-    Example usage of the FalconH1 provider for both non-streaming and streaming chat completions.
-    """
-    print("FalconH1 Provider Example")
-    client = FalconH1()
-    print("\n--- Non-Streaming Example ---")
-    try:
-        response = client.chat.completions.create(
-            model="Falcon-H1-34B-Instruct",
-            messages=[
-                {"role": "system", "content": "You are a helpful AI assistant named Falcon."},
-                {"role": "user", "content": "Hello, what is your name and what can you do?"}
-            ]
-        )
-        print(f"ID: {response.id}")
-        print(f"Model: {response.model}")
-        if response.choices:
-            print(f"Response: {response.choices[0].message.content}")
-        if response.usage:
-            print(f"Usage: {response.usage}")
-    except Exception as e:
-        print(f"Error in non-streaming example: {e}")
-    print("\n--- Streaming Example ---")
-    try:
-        stream_response = client.chat.completions.create(
-            model="Falcon-H1-34B-Instruct",
-            messages=[
-                {"role": "user", "content": "Tell me a short story about a brave falcon."}
-            ],
-            stream=True,
-            max_tokens=150
-        )
-        print("Streaming response:")
-        full_streamed_content = ""
-        for chunk in stream_response:
-            if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content:
-                content_piece = chunk.choices[0].delta.content
-                print(content_piece, end="", flush=True)
-                full_streamed_content += content_piece
-        print("\n--- End of Stream ---")
-    except Exception as e:
-        print(f"Error in streaming example: {e}")

webscout/Provider/deepseek_assistant.py

@@ -1,378 +0,0 @@
-from curl_cffi.requests import Session
-from curl_cffi import CurlError
-import json
-import re
-from typing import Any, Dict, Optional, Generator, Union, List
-
-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 DeepSeekAssistant(Provider):
-    """
-    A class to interact with the DeepSeek Assistant API.
-    
-    This provider interfaces with the deepseek-assistant.com API to provide
-    AI chat completions using the V3 model.
-    
-    Attributes:
-        AVAILABLE_MODELS (list): List of available models for the provider.
-    
-    Examples:
-        >>> from webscout.Provider.deepseek_assistant import DeepSeekAssistant
-        >>> ai = DeepSeekAssistant()
-        >>> response = ai.chat("What's the weather today?")
-        >>> print(response)
-        'I can help you with weather information...'
-    """
-
-    AVAILABLE_MODELS = ["V3 model", "R1 model"]
-    required_auth = False
-    @staticmethod
-    def _deepseek_assistant_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Extracts content from DeepSeek Assistant stream JSON objects."""
-        if isinstance(chunk, dict):
-            return chunk.get("choices", [{}])[0].get("delta", {}).get("content")
-        return None
-
-    def __init__(
-        self,
-        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 = "V3 model",
-        system_prompt: str = "You are a helpful assistant.",
-        browser: str = "chrome"
-    ):
-        """
-        Initializes the DeepSeek Assistant API client.
-        
-        Args:
-            is_conversation (bool): Whether the provider is in conversation mode.
-            max_tokens (int): Maximum number of tokens to sample.
-            timeout (int): Timeout for API requests.
-            intro (str): Introduction message for the conversation.
-            filepath (str): Filepath for storing conversation history.
-            update_file (bool): Whether to update the conversation history file.
-            proxies (dict): Proxies for the API requests.
-            history_offset (int): Offset for conversation history.
-            act (str): Act for the conversation.
-            model (str): The model to use for completions.
-            system_prompt (str): The system prompt to define the assistant's role.
-            browser (str): Browser type for fingerprinting.
-        
-        Examples:
-            >>> ai = DeepSeekAssistant(model="V3 model")
-            >>> print(ai.model)
-            'V3 model'
-        """
-        if model not in self.AVAILABLE_MODELS:
-            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
-
-        self.url = "https://deepseek-assistant.com/api/search-stream-deep-chat-testing.php"
-
-        # Initialize LitAgent for user agent generation
-        self.agent = LitAgent()
-        self.fingerprint = self.agent.generate_fingerprint(browser)
-
-        # Headers based on the JavaScript code
-        self.headers = {
-            "accept": "*/*",
-            "accept-language": "id-ID,id;q=0.9",
-            "cache-control": "no-cache",
-            "content-type": "application/json",
-            "cookie": "click_id=OS3Hz0E1yKfu4YnZNwedESMEdKEgMTzL; organic_user_deepseek_assistant_ch=%7B%22pixel%22%3A%22OS3Hz0E1yKfu4YnZNwedESMEdKEgMTzL%22%2C%22cc%22%3A%22ID%22%2C%22channel%22%3A%22organic_flag%22%7D",
-            "origin": "https://deepseek-assistant.com",
-            **self.fingerprint
-
-        }
-
-        # Initialize curl_cffi Session
-        self.session = Session()
-        self.session.headers.update(self.headers)
-        self.session.proxies = proxies
-        
-        self.system_prompt = system_prompt
-        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 user-agent header with new fingerprint
-        self.headers.update({
-            "user-agent": self.fingerprint.get("user_agent", self.headers["user-agent"])
-        })
-
-        # Update session headers
-        self.session.headers.update(self.headers)
-
-        return self.fingerprint
-
-    def _parse_chat_response(self, input_text: str) -> str:
-        """
-        Parses the chat response from the API, similar to the JavaScript parseChatResponse method.
-        
-        Args:
-            input_text (str): The raw response text from the API
-            
-        Returns:
-            str: The parsed content from the response
-        """
-        lines = input_text.strip().split("\n")
-        result = ""
-        
-        for line in lines:
-            trimmed_line = line.strip()
-            if trimmed_line.startswith("data: {") and trimmed_line.endswith("}"):
-                try:
-                    # Extract JSON from the line
-                    json_start = trimmed_line.find("{")
-                    if json_start != -1:
-                        json_str = trimmed_line[json_start:]
-                        parsed_data = json.loads(json_str)
-                        
-                        # Extract content from the parsed data
-                        content = parsed_data.get("choices", [{}])[0].get("delta", {}).get("content")
-                        if content is not None:
-                            result += content
-                except (json.JSONDecodeError, KeyError, IndexError):
-                    # Skip malformed JSON or missing keys
-                    continue
-        
-        return result.strip()
-
-    def ask(
-        self,
-        prompt: str,
-        stream: bool = False,
-        raw: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Union[Dict[str, Any], Generator]:
-        """
-        Sends a prompt to the DeepSeek Assistant API and returns the response.
-
-        Args:
-            prompt (str): The prompt to send to the API.
-            stream (bool): Whether to stream the response.
-            raw (bool): Whether to return the raw response.
-            optimizer (str): Optimizer to use for the prompt.
-            conversationally (bool): Whether to generate the prompt conversationally.
-
-        Returns:
-            Union[Dict[str, Any], Generator]: The API response.
-
-        Examples:
-            >>> ai = DeepSeekAssistant()
-            >>> response = ai.ask("Tell me a joke!")
-            >>> print(response)
-            {'text': 'Why did the scarecrow win an award? Because he was outstanding in his field!'}
-        """
-        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 = {
-            "model": self.model,
-            "messages": [
-                {"role": "system", "content": self.system_prompt},  # Add system role
-                {"role": "user", "content": conversation_prompt}
-            ]
-        }
-
-        def for_stream():
-            streaming_text = ""
-            try:
-                response = self.session.post(
-                    self.url,
-                    data=json.dumps(payload),
-                    stream=True,
-                    timeout=self.timeout,
-                    impersonate="chrome110"
-                )
-                response.raise_for_status()
-
-                # Use sanitize_stream to process the response
-                processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None),
-                    intro_value="data:",
-                    to_json=True,
-                    skip_markers=["[DONE]"],
-                    content_extractor=self._deepseek_assistant_extractor,
-                    yield_raw_on_error=False
-                )
-
-                for content_chunk in processed_stream:
-                    if content_chunk and isinstance(content_chunk, str):
-                        streaming_text += content_chunk
-                        resp = dict(text=content_chunk)
-                        yield resp if not raw else content_chunk
-
-            except CurlError as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
-            except Exception as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {str(e)}") from e
-            finally:
-                # Update history after stream finishes or fails
-                if streaming_text:
-                    self.last_response = {"text": streaming_text}
-                    self.conversation.update_chat_history(prompt, streaming_text)
-
-        def for_non_stream():
-            try:
-                response = self.session.post(
-                    self.url,
-                    data=json.dumps(payload),
-                    timeout=self.timeout,
-                    impersonate="chrome110"
-                )
-                response.raise_for_status()
-
-                # Parse the response using the custom parser
-                content = self._parse_chat_response(response.text)
-
-                self.last_response = {"text": content}
-                self.conversation.update_chat_history(prompt, content)
-                return self.last_response if not raw else content
-
-            except CurlError as e:
-                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
-            except Exception as e:
-                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
-                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {e} - {err_text}") from e
-
-        return for_stream() if stream else for_non_stream()
-
-    def chat(
-        self,
-        prompt: str,
-        stream: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Union[str, Generator[str, None, None]]:
-        """
-        Initiates a chat with the DeepSeek Assistant API using the provided prompt.
-
-        Args:
-            prompt (str): The prompt to send to the API.
-            stream (bool): Whether to stream the response.
-            optimizer (str): Optimizer to use for the prompt.
-            conversationally (bool): Whether to generate the prompt conversationally.
-
-        Returns:
-            Union[str, Generator[str, None, None]]: The chat response.
-
-        Examples:
-            >>> ai = DeepSeekAssistant()
-            >>> response = ai.chat("Tell me a joke")
-            >>> print(response)
-            'Why did the scarecrow win an award? Because he was outstanding in his field!'
-        """
-        def for_stream_chat():
-            gen = self.ask(
-                prompt, stream=True, raw=False,
-                optimizer=optimizer, conversationally=conversationally
-            )
-            for response_dict in gen:
-                yield self.get_message(response_dict)
-
-        def for_non_stream_chat():
-            response_data = self.ask(
-                prompt, stream=False, raw=False,
-                optimizer=optimizer, conversationally=conversationally
-            )
-            return self.get_message(response_data)
-
-        return for_stream_chat() if stream else for_non_stream_chat()
-
-    def get_message(self, response: dict) -> str:
-        """
-        Extracts the message content from the API response.
-
-        Args:
-            response (dict): The API response.
-
-        Returns:
-            str: The message content.
-
-        Examples:
-            >>> ai = DeepSeekAssistant()
-            >>> response = ai.ask("Tell me a joke!")
-            >>> message = ai.get_message(response)
-            >>> print(message)
-            'Why did the scarecrow win an award? Because he was outstanding in his field!'
-        """
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
-
-
-if __name__ == "__main__":
-    # Test the provider
-    print("-" * 80)
-    print(f"{'Model':<50} {'Status':<10} {'Response'}")
-    print("-" * 80)
-
-    for model in DeepSeekAssistant.AVAILABLE_MODELS:
-        try:
-            test_ai = DeepSeekAssistant(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"\r{model:<50} {status:<10} {display_text}")
-        except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}")