camel-ai 0.2.58__py3-none-any.whl → 0.2.60__py3-none-any.whl

camel/toolkits/jina_reranker_toolkit.py

@@ -11,7 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from typing import List, Optional, Tuple
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+import requests
 
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
@@ -30,7 +34,9 @@ class JinaRerankerToolkit(BaseToolkit):
     def __init__(
         self,
         timeout: Optional[float] = None,
+        model_name: Optional[str] = "jinaai/jina-reranker-m0",
         device: Optional[str] = None,
+        use_api: bool = True,
     ) -> None:
         r"""Initializes a new instance of the JinaRerankerToolkit class.
 
@@ -38,31 +44,57 @@ class JinaRerankerToolkit(BaseToolkit):
             timeout (Optional[float]): The timeout value for API requests
                 in seconds. If None, no timeout is applied.
                 (default: :obj:`None`)
+            model_name (Optional[str]): The reranker model name. If None,
+                will use the default model.
+                (default: :obj:`None`)
             device (Optional[str]): Device to load the model on. If None,
                 will use CUDA if available, otherwise CPU.
+                Only effective when use_api=False.
                 (default: :obj:`None`)
+            use_api (bool): A flag to switch between local model and API.
+                (default: :obj:`True`)
         """
-        import torch
-        from transformers import AutoModel
 
         super().__init__(timeout=timeout)
 
-        self.model = AutoModel.from_pretrained(
-            'jinaai/jina-reranker-m0',
-            torch_dtype="auto",
-            trust_remote_code=True,
-        )
-        DEVICE = (
-            device
-            if device is not None
-            else ("cuda" if torch.cuda.is_available() else "cpu")
-        )
-        self.model.to(DEVICE)
-        self.model.eval()
+        self.use_api = use_api
+        self.model_name = model_name
+
+        if self.use_api:
+            self.model = None
+            self._api_key = os.environ.get("JINA_API_KEY", "None")
+            if self._api_key == "None":
+                raise ValueError(
+                    "Missing or empty required API keys in "
+                    "environment variables\n"
+                    "You can obtain the API key from https://jina.ai/reranker/"
+                )
+            self.url = 'https://api.jina.ai/v1/rerank'
+            self.headers = {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'Authorization': f'Bearer {self._api_key}',
+            }
+        else:
+            import torch
+            from transformers import AutoModel
+
+            self.model = AutoModel.from_pretrained(
+                self.model_name,
+                torch_dtype="auto",
+                trust_remote_code=True,
+            )
+            self.device = (
+                device
+                if device is not None
+                else ("cuda" if torch.cuda.is_available() else "cpu")
+            )
+            self.model.to(self.device)
+            self.model.eval()
 
     def _sort_documents(
         self, documents: List[str], scores: List[float]
-    ) -> List[Tuple[str, float]]:
+    ) -> List[Dict[str, object]]:
         r"""Sort documents by their scores in descending order.
 
         Args:
@@ -70,7 +102,7 @@ class JinaRerankerToolkit(BaseToolkit):
             scores (List[float]): Corresponding scores for each document.
 
         Returns:
-            List[Tuple[str, float]]: Sorted list of (document, score) pairs.
+            List[Dict[str, object]]: Sorted list of (document, score) pairs.
 
         Raises:
             ValueError: If documents and scores have different lengths.
@@ -80,14 +112,45 @@ class JinaRerankerToolkit(BaseToolkit):
         doc_score_pairs = list(zip(documents, scores))
         doc_score_pairs.sort(key=lambda x: x[1], reverse=True)
 
-        return doc_score_pairs
+        results = [
+            {'document': {'text': doc}, 'relevance_score': score}
+            for doc, score in doc_score_pairs
+        ]
+
+        return results
+
+    def _call_jina_api(self, data: Dict[str, Any]) -> List[Dict[str, object]]:
+        r"""Makes a call to the JINA API for reranking.
+
+        Args:
+            data (Dict[str]): The data to be passed into the api body.
+
+        Returns:
+            List[Dict[str, object]]: A list of dictionary containing
+                the reranked documents and their relevance scores.
+        """
+        try:
+            response = requests.post(
+                self.url,
+                headers=self.headers,
+                data=json.dumps(data),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            results = [
+                {key: value for key, value in _res.items() if key != 'index'}
+                for _res in response.json()['results']
+            ]
+            return results
+        except requests.exceptions.RequestException as e:
+            raise RuntimeError(f"Failed to get response from Jina AI: {e}")
 
     def rerank_text_documents(
         self,
         query: str,
         documents: List[str],
         max_length: int = 1024,
-    ) -> List[Tuple[str, float]]:
+    ) -> List[Dict[str, object]]:
         r"""Reranks text documents based on their relevance to a text query.
 
         Args:
@@ -97,21 +160,34 @@ class JinaRerankerToolkit(BaseToolkit):
                 (default: :obj:`1024`)
 
         Returns:
-            List[Tuple[str, float]]: A list of tuples containing
+            List[Dict[str, object]]: A list of dictionary containing
                 the reranked documents and their relevance scores.
         """
-        import torch
 
-        if self.model is None:
-            raise ValueError(
-                "Model has not been initialized or failed to initialize."
-            )
+        data = {
+            'model': self.model_name,
+            'query': query,
+            'top_n': len(documents),
+            'documents': documents,
+            'return_documents': True,
+        }
 
-        with torch.inference_mode():
-            text_pairs = [[query, doc] for doc in documents]
-            scores = self.model.compute_score(
-                text_pairs, max_length=max_length, doc_type="text"
-            )
+        if self.use_api:
+            return self._call_jina_api(data)
+
+        else:
+            import torch
+
+            if self.model is None:
+                raise ValueError(
+                    "Model has not been initialized or failed to initialize."
+                )
+
+            with torch.inference_mode():
+                text_pairs = [[query, doc] for doc in documents]
+                scores = self.model.compute_score(
+                    text_pairs, max_length=max_length, doc_type="text"
+                )
 
         return self._sort_documents(documents, scores)
 
@@ -120,7 +196,7 @@ class JinaRerankerToolkit(BaseToolkit):
         query: str,
         documents: List[str],
         max_length: int = 2048,
-    ) -> List[Tuple[str, float]]:
+    ) -> List[Dict[str, object]]:
         r"""Reranks image documents based on their relevance to a text query.
 
         Args:
@@ -130,21 +206,33 @@ class JinaRerankerToolkit(BaseToolkit):
                 (default: :obj:`2048`)
 
         Returns:
-            List[Tuple[str, float]]: A list of tuples containing
+            List[Dict[str, object]]: A list of dictionary containing
                 the reranked image URLs/paths and their relevance scores.
         """
-        import torch
-
-        if self.model is None:
-            raise ValueError(
-                "Model has not been initialized or failed to initialize."
-            )
-
-        with torch.inference_mode():
-            image_pairs = [[query, doc] for doc in documents]
-            scores = self.model.compute_score(
-                image_pairs, max_length=max_length, doc_type="image"
-            )
+        data = {
+            'model': self.model_name,
+            'query': query,
+            'top_n': len(documents),
+            'documents': documents,
+            'return_documents': True,
+        }
+
+        if self.use_api:
+            return self._call_jina_api(data)
+
+        else:
+            import torch
+
+            if self.model is None:
+                raise ValueError(
+                    "Model has not been initialized or failed to initialize."
+                )
+
+            with torch.inference_mode():
+                image_pairs = [[query, doc] for doc in documents]
+                scores = self.model.compute_score(
+                    image_pairs, max_length=max_length, doc_type="image"
+                )
 
         return self._sort_documents(documents, scores)
 
@@ -153,7 +241,7 @@ class JinaRerankerToolkit(BaseToolkit):
         image_query: str,
         documents: List[str],
         max_length: int = 2048,
-    ) -> List[Tuple[str, float]]:
+    ) -> List[Dict[str, object]]:
         r"""Reranks text documents based on their relevance to an image query.
 
         Args:
@@ -163,30 +251,45 @@ class JinaRerankerToolkit(BaseToolkit):
                 (default: :obj:`2048`)
 
         Returns:
-            List[Tuple[str, float]]: A list of tuples containing
+            List[Dict[str, object]]: A list of dictionary containing
                 the reranked documents and their relevance scores.
         """
-        import torch
-
-        if self.model is None:
-            raise ValueError("Model has not been initialized.")
-        with torch.inference_mode():
-            image_pairs = [[image_query, doc] for doc in documents]
-            scores = self.model.compute_score(
-                image_pairs,
-                max_length=max_length,
-                query_type="image",
-                doc_type="text",
-            )
-
-        return self._sort_documents(documents, scores)
+        data = {
+            'model': self.model_name,
+            'query': image_query,
+            'top_n': len(documents),
+            'documents': documents,
+            'return_documents': True,
+        }
+
+        if self.use_api:
+            return self._call_jina_api(data)
+
+        else:
+            import torch
+
+            if self.model is None:
+                raise ValueError(
+                    "Model has not been initialized or failed to initialize."
+                )
+
+            with torch.inference_mode():
+                image_pairs = [[image_query, doc] for doc in documents]
+                scores = self.model.compute_score(
+                    image_pairs,
+                    max_length=max_length,
+                    query_type="image",
+                    doc_type="text",
+                )
+
+            return self._sort_documents(documents, scores)
 
     def image_query_image_documents(
         self,
         image_query: str,
         documents: List[str],
         max_length: int = 2048,
-    ) -> List[Tuple[str, float]]:
+    ) -> List[Dict[str, object]]:
         r"""Reranks image documents based on their relevance to an image query.
 
         Args:
@@ -196,24 +299,38 @@ class JinaRerankerToolkit(BaseToolkit):
                 (default: :obj:`2048`)
 
         Returns:
-            List[Tuple[str, float]]: A list of tuples containing
+            List[Dict[str, object]]: A list of dictionary containing
                 the reranked image URLs/paths and their relevance scores.
         """
-        import torch
-
-        if self.model is None:
-            raise ValueError("Model has not been initialized.")
-
-        with torch.inference_mode():
-            image_pairs = [[image_query, doc] for doc in documents]
-            scores = self.model.compute_score(
-                image_pairs,
-                max_length=max_length,
-                query_type="image",
-                doc_type="image",
-            )
-
-        return self._sort_documents(documents, scores)
+        data = {
+            'model': self.model_name,
+            'query': image_query,
+            'top_n': len(documents),
+            'documents': documents,
+            'return_documents': True,
+        }
+
+        if self.use_api:
+            return self._call_jina_api(data)
+
+        else:
+            import torch
+
+            if self.model is None:
+                raise ValueError(
+                    "Model has not been initialized or failed to initialize."
+                )
+
+            with torch.inference_mode():
+                image_pairs = [[image_query, doc] for doc in documents]
+                scores = self.model.compute_score(
+                    image_pairs,
+                    max_length=max_length,
+                    query_type="image",
+                    doc_type="image",
+                )
+
+            return self._sort_documents(documents, scores)
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the

camel/toolkits/mcp_toolkit.py

@@ -34,6 +34,7 @@ from urllib.parse import urlparse
 if TYPE_CHECKING:
     from mcp import ClientSession, ListToolsResult, Tool
 
+
 from camel.logger import get_logger
 from camel.toolkits import BaseToolkit, FunctionTool
 
@@ -84,7 +85,6 @@ class MCPClient(BaseToolkit):
            await client.disconnect()
            ```
 
-
     Attributes:
         command_or_url (str): URL for SSE mode or command executable for stdio
             mode. (default: :obj:`None`)
@@ -96,6 +96,10 @@ class MCPClient(BaseToolkit):
             (default: :obj:`None`)
         headers (Dict[str, str]): Headers for the HTTP request.
             (default: :obj:`None`)
+        mode (Optional[str]): Connection mode. Can be "sse" for Server-Sent
+            Events, "streamable-http" for streaming HTTP,
+            or None for stdio mode.
+            (default: :obj:`None`)
         strict (Optional[bool]): Whether to enforce strict mode for the
             function call. (default: :obj:`False`)
     """
@@ -107,6 +111,7 @@ class MCPClient(BaseToolkit):
         env: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         headers: Optional[Dict[str, str]] = None,
+        mode: Optional[str] = None,
         strict: Optional[bool] = False,
     ):
         from mcp import Tool
@@ -118,6 +123,7 @@ class MCPClient(BaseToolkit):
         self.env = env or {}
         self.headers = headers or {}
         self.strict = strict
+        self.mode = mode
 
         self._mcp_tools: List[Tool] = []
         self._session: Optional['ClientSession'] = None
@@ -133,6 +139,7 @@ class MCPClient(BaseToolkit):
         from mcp.client.session import ClientSession
         from mcp.client.sse import sse_client
         from mcp.client.stdio import StdioServerParameters, stdio_client
+        from mcp.client.streamable_http import streamablehttp_client
 
         if self._is_connected:
             logger.warning("Server is already connected")
@@ -140,16 +147,37 @@ class MCPClient(BaseToolkit):
 
         try:
             if urlparse(self.command_or_url).scheme in ("http", "https"):
-                (
-                    read_stream,
-                    write_stream,
-                ) = await self._exit_stack.enter_async_context(
-                    sse_client(
-                        self.command_or_url,
-                        headers=self.headers,
-                        timeout=self.timeout,
+                if self.mode == "sse" or self.mode is None:
+                    (
+                        read_stream,
+                        write_stream,
+                    ) = await self._exit_stack.enter_async_context(
+                        sse_client(
+                            self.command_or_url,
+                            headers=self.headers,
+                            timeout=self.timeout,
+                        )
+                    )
+                elif self.mode == "streamable-http":
+                    try:
+                        (
+                            read_stream,
+                            write_stream,
+                            _,
+                        ) = await self._exit_stack.enter_async_context(
+                            streamablehttp_client(
+                                self.command_or_url,
+                                headers=self.headers,
+                                timeout=timedelta(seconds=self.timeout),
+                            )
+                        )
+                    except Exception as e:
+                        # Handle anyio task group errors
+                        logger.error(f"Streamable HTTP client error: {e}")
+                else:
+                    raise ValueError(
+                        f"Invalid mode '{self.mode}' for HTTP URL"
                     )
-                )
             else:
                 command = self.command_or_url
                 arguments = self.args
@@ -194,9 +222,18 @@ class MCPClient(BaseToolkit):
 
     async def disconnect(self):
         r"""Explicitly disconnect from the MCP server."""
+        # If the server is not connected, do nothing
+        if not self._is_connected:
+            return
         self._is_connected = False
-        await self._exit_stack.aclose()
-        self._session = None
+
+        try:
+            await self._exit_stack.aclose()
+        except Exception as e:
+            logger.warning(f"{e}")
+        finally:
+            self._exit_stack = AsyncExitStack()
+            self._session = None
 
     @asynccontextmanager
     async def connection(self):
@@ -212,7 +249,10 @@ class MCPClient(BaseToolkit):
             await self.connect()
             yield self
         finally:
-            await self.disconnect()
+            try:
+                await self.disconnect()
+            except Exception as e:
+                logger.warning(f"Error: {e}")
 
     async def list_mcp_tools(self) -> Union[str, "ListToolsResult"]:
         r"""Retrieves the list of available tools from the connected MCP
@@ -435,6 +475,7 @@ class MCPClient(BaseToolkit):
         env: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         headers: Optional[Dict[str, str]] = None,
+        mode: Optional[str] = None,
     ) -> "MCPClient":
         r"""Factory method that creates and connects to the MCP server.
 
@@ -452,6 +493,10 @@ class MCPClient(BaseToolkit):
                 (default: :obj:`None`)
             headers (Optional[Dict[str, str]]): Headers for the HTTP request.
                 (default: :obj:`None`)
+            mode (Optional[str]): Connection mode. Can be "sse" for
+                Server-Sent Events, "streamable-http" for
+                streaming HTTP, or None for stdio mode.
+                (default: :obj:`None`)
 
         Returns:
             MCPClient: A fully initialized and connected MCPClient instance.
@@ -465,6 +510,7 @@ class MCPClient(BaseToolkit):
             env=env,
             timeout=timeout,
             headers=headers,
+            mode=mode,
         )
         try:
             await client.connect()
@@ -599,7 +645,6 @@ class MCPToolkit(BaseToolkit):
         if config_dict:
             self.servers.extend(self._load_servers_from_dict(config_dict))
 
-        self._exit_stack = AsyncExitStack()
         self._connected = False
 
     def _load_servers_from_config(
@@ -675,6 +720,7 @@ class MCPToolkit(BaseToolkit):
                 env={**os.environ, **cfg.get("env", {})},
                 timeout=cfg.get("timeout", None),
                 headers=headers,
+                mode=cfg.get("mode", None),
                 strict=strict,
             )
             all_servers.append(server)
@@ -691,7 +737,6 @@ class MCPToolkit(BaseToolkit):
             logger.warning("MCPToolkit is already connected")
             return self
 
-        self._exit_stack = AsyncExitStack()
         try:
             # Sequentially connect to each server
             for server in self.servers:
@@ -712,7 +757,6 @@ class MCPToolkit(BaseToolkit):
         for server in self.servers:
             await server.disconnect()
         self._connected = False
-        await self._exit_stack.aclose()
 
     @asynccontextmanager
     async def connection(self) -> AsyncGenerator["MCPToolkit", None]:

camel/toolkits/page_script.js

@@ -191,35 +191,47 @@ var MultimodalWebSurfer = MultimodalWebSurfer || (function() {
         labelElements(getInteractiveElements());
         let elements = document.querySelectorAll("[__elementId]");
         let results = {};
-        for (let i=0; i<elements.length; i++) {
-           let key = elements[i].getAttribute("__elementId");
-           let rects = elements[i].getClientRects();
-       let ariaRole = getApproximateAriaRole(elements[i]);
-       let ariaName = getApproximateAriaName(elements[i]);
-       let vScrollable = elements[i].scrollHeight - elements[i].clientHeight >= 1;
-  
-       let record = {
-               "tag_name": ariaRole[1],
-           "role": ariaRole[0],
-           "aria-name": ariaName,
-           "v-scrollable": vScrollable,
-           "rects": []
-       };
-  
-           for (const rect of rects) {
-           let x = rect.left + rect.width/2;
-               let y = rect.top + rect.height/2;
-               if (isTopmost(elements[i], x, y)) {
-           record["rects"].push(JSON.parse(JSON.stringify(rect)));
-               }
-           }
-  
-       if (record["rects"].length > 0) {
-               results[key] = record;
-           }
+        let scale = window.devicePixelRatio || 1;
+    
+        for (let i = 0; i < elements.length; i++) {
+            let key = elements[i].getAttribute("__elementId");
+            let rects = elements[i].getClientRects();
+            let ariaRole = getApproximateAriaRole(elements[i]);
+            let ariaName = getApproximateAriaName(elements[i]);
+            let vScrollable = elements[i].scrollHeight - elements[i].clientHeight >= 1;
+    
+            let record = {
+                "tag_name": ariaRole[1],
+                "role": ariaRole[0],
+                "aria-name": ariaName,
+                "v-scrollable": vScrollable,
+                "rects": []
+            };
+    
+            for (const rect of rects) {
+                let x = rect.left + rect.width / 2;
+                let y = rect.top + rect.height / 2;
+                if (isTopmost(elements[i], x, y)) {
+                    record["rects"].push({
+                        x: rect.x * scale,
+                        y: rect.y * scale,
+                        width: rect.width * scale,
+                        height: rect.height * scale,
+                        top: rect.top * scale,
+                        left: rect.left * scale,
+                        right: rect.right * scale,
+                        bottom: rect.bottom * scale
+                    });
+                }
+            }
+    
+            if (record["rects"].length > 0) {
+                results[key] = record;
+            }
         }
+    
         return results;
-    };
+    };    
   
     let getVisualViewport = function() {
         let vv = window.visualViewport;
@@ -373,4 +385,4 @@ var MultimodalWebSurfer = MultimodalWebSurfer || (function() {
          getFocusedElementId: getFocusedElementId,
          getPageMetadata: getPageMetadata,
      };
-  })();
+  })();

camel/toolkits/twitter_toolkit.py

@@ -18,7 +18,6 @@ from http.client import responses
 from typing import Any, Dict, List, Optional, Union
 
 import requests
-from requests_oauthlib import OAuth1
 
 from camel.logger import get_logger
 from camel.toolkits import FunctionTool
@@ -76,6 +75,8 @@ def create_tweet(
     Reference:
         https://developer.x.com/en/docs/x-api/tweets/manage-tweets/api-reference/post-tweets
     """
+    from requests_oauthlib import OAuth1
+
     auth = OAuth1(
         os.getenv("TWITTER_CONSUMER_KEY"),
         os.getenv("TWITTER_CONSUMER_SECRET"),
@@ -160,6 +161,8 @@ def delete_tweet(tweet_id: str) -> str:
     Reference:
         https://developer.x.com/en/docs/x-api/tweets/manage-tweets/api-reference/delete-tweets-id
     """
+    from requests_oauthlib import OAuth1
+
     auth = OAuth1(
         os.getenv("TWITTER_CONSUMER_KEY"),
         os.getenv("TWITTER_CONSUMER_SECRET"),
@@ -263,6 +266,8 @@ def _get_user_info(username: Optional[str] = None) -> str:
     Returns:
         str: A formatted report of the user's Twitter profile information.
     """
+    from requests_oauthlib import OAuth1
+
     oauth = OAuth1(
         os.getenv("TWITTER_CONSUMER_KEY"),
         os.getenv("TWITTER_CONSUMER_SECRET"),