camel-ai 0.2.29__py3-none-any.whl → 0.2.31__py3-none-any.whl

camel/messages/func_message.py

@@ -133,7 +133,7 @@ class FunctionCallingMessage(BaseMessage):
                     "type": "function",
                     "function": {
                         "name": self.func_name,
-                        "arguments": json.dumps(self.args),
+                        "arguments": json.dumps(self.args, ensure_ascii=False),
                     },
                 }
             ],

camel/models/cohere_model.py

@@ -176,7 +176,9 @@ class CohereModel(BaseModelBackend):
                 else:
                     arguments = function_call.get("arguments")  # type: ignore[attr-defined]
                     arguments_dict = ast.literal_eval(arguments)
-                    arguments_json = json.dumps(arguments_dict)
+                    arguments_json = json.dumps(
+                        arguments_dict, ensure_ascii=False
+                    )
 
                     assis_tool_call_id = str(uuid.uuid4())
                     tool_call_id = assis_tool_call_id

camel/models/openai_compatible_model.py

@@ -56,8 +56,10 @@ class OpenAICompatibleModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        self.api_key = api_key or os.environ.get("OPENAI_COMPATIBILIY_API_KEY")
-        self.url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
+        self.api_key = api_key or os.environ.get(
+            "OPENAI_COMPATIBILITY_API_KEY"
+        )
+        self.url = url or os.environ.get("OPENAI_COMPATIBILITY_API_BASE_URL")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )

camel/models/samba_model.py

@@ -307,7 +307,8 @@ class SambaModel(BaseModelBackend):
                     {
                         "conversation_id": str(uuid.uuid4()),
                         "messages": messages,
-                    }
+                    },
+                    ensure_ascii=False,
                 ),
                 "params": {
                     "do_sample": {"type": "bool", "value": "true"},
@@ -537,7 +538,8 @@ class SambaModel(BaseModelBackend):
                     {
                         "conversation_id": str(uuid.uuid4()),
                         "messages": messages,
-                    }
+                    },
+                    ensure_ascii=False,
                 ),
                 "params": {
                     "do_sample": {"type": "bool", "value": "true"},

camel/personas/persona.py

@@ -100,4 +100,5 @@ class Persona(BaseModel):
                 ",",
                 ": ",
             ),  # Fine-tune separators for better readability
+            ensure_ascii=False,
         )

camel/runtime/api.py

@@ -80,10 +80,14 @@ for module_function in modules_functions:
                     output = sys.stdout.read()
                     sys.stdout = sys.__stdout__
                     return {
-                        "output": json.dumps(response_data),
+                        "output": json.dumps(
+                            response_data, ensure_ascii=False
+                        ),
                         "stdout": output,
                     }
-                return {"output": json.dumps(response_data)}
+                return {
+                    "output": json.dumps(response_data, ensure_ascii=False)
+                }
 
     except (ImportError, AttributeError) as e:
         logger.error(f"Error importing {module_function}: {e}")

camel/runtime/docker_runtime.py

@@ -271,7 +271,7 @@ class DockerRuntime(BaseRuntime):
             funcs = [funcs]
 
         if arguments is not None:
-            entrypoint += json.dumps(arguments)
+            entrypoint += json.dumps(arguments, ensure_ascii=False)
 
         for func in funcs:
             inner_func = func.func

camel/runtime/remote_http_runtime.py

@@ -100,7 +100,7 @@ class RemoteHttpRuntime(BaseRuntime):
         if not isinstance(funcs, list):
             funcs = [funcs]
         if arguments is not None:
-            entrypoint += json.dumps(arguments)
+            entrypoint += json.dumps(arguments, ensure_ascii=False)
 
         for func in funcs:
             inner_func = func.func

camel/storages/key_value_storages/json.py

@@ -75,7 +75,11 @@ class JsonStorage(BaseKeyValueStorage):
         """
         with self.json_path.open("a") as f:
             f.writelines(
-                [json.dumps(r, cls=_CamelJSONEncoder) + "\n" for r in records]
+                [
+                    json.dumps(r, cls=_CamelJSONEncoder, ensure_ascii=False)
+                    + "\n"
+                    for r in records
+                ]
             )
 
     def load(self) -> List[Dict[str, Any]]:

camel/storages/key_value_storages/redis.py

@@ -133,7 +133,7 @@ class RedisStorage(BaseKeyValueStorage):
         if self._client is None:
             raise ValueError("Redis client is not initialized")
         try:
-            value = json.dumps(records)
+            value = json.dumps(records, ensure_ascii=False)
             if expire:
                 await self._client.setex(self._sid, expire, value)
             else:

camel/toolkits/browser_toolkit.py

@@ -1049,7 +1049,7 @@ check the history actions to avoid the same mistakes.
 - `action_code`: The action code you want to take. It is only one step action 
 code, without any other texts (such as annotation)
 
-Here are an example of the output:
+Here is two example of the output:
 ```json
 {{
     "observation": [IMAGE_DESCRIPTION],
@@ -1057,6 +1057,12 @@ Here are an example of the output:
     "action_code": "fill_input_id([ID], [TEXT])"
 }}
 
+{{
+    "observation":  "The current page is a CAPTCHA verification page on Amazon. It asks the user to ..",
+    "reasoning": "To proceed with the task of searching for products, I need to complete..",
+    "action_code": "fill_input_id(3, 'AUXPMR')"
+}}
+
 Here are some tips for you:
 - Never forget the overall question: **{task_prompt}**
 - Maybe after a certain operation (e.g. click_id), the page content has not 
@@ -1150,6 +1156,58 @@ out the information you need. Sometimes they are extremely useful.
 
             return False
 
+        def _fix_action_code(action_code: str) -> str:
+            r"""Fix potential missing quotes in action code"""
+
+            match = re.match(r'(\w+)\((.*)\)', action_code)
+            if not match:
+                return action_code
+
+            func_name, args_str = match.groups()
+
+            args = []
+            current_arg = ""
+            in_quotes = False
+            quote_char = None
+
+            for char in args_str:
+                if char in ['"', "'"]:
+                    if not in_quotes:
+                        in_quotes = True
+                        quote_char = char
+                        current_arg += char
+                    elif char == quote_char:
+                        in_quotes = False
+                        quote_char = None
+                        current_arg += char
+                    else:
+                        current_arg += char
+                elif char == ',' and not in_quotes:
+                    args.append(current_arg.strip())
+                    current_arg = ""
+                else:
+                    current_arg += char
+
+            if current_arg:
+                args.append(current_arg.strip())
+
+            fixed_args = []
+            for arg in args:
+                if (
+                    (arg.startswith('"') and arg.endswith('"'))
+                    or (arg.startswith("'") and arg.endswith("'"))
+                    or re.match(r'^-?\d+(\.\d+)?$', arg)
+                    or re.match(r'^-?\d+\.?\d*[eE][-+]?\d+$', arg)
+                    or re.match(r'^0[xX][0-9a-fA-F]+$', arg)
+                ):
+                    fixed_args.append(arg)
+
+                else:
+                    fixed_args.append(f"'{arg}'")
+
+            return f"{func_name}({', '.join(fixed_args)})"
+
+        action_code = _fix_action_code(action_code)
         prefix = "self.browser."
         code = f"{prefix}{action_code}"
 

camel/toolkits/file_write_toolkit.py

@@ -219,13 +219,13 @@ class FileWriteToolkit(BaseToolkit):
                 try:
                     # Try parsing as JSON string first
                     data = json.loads(content)
-                    json.dump(data, f)
+                    json.dump(data, f, ensure_ascii=False)
                 except json.JSONDecodeError:
                     # If not valid JSON string, write as is
                     f.write(content)
             else:
                 # If not string, dump as JSON
-                json.dump(content, f)
+                json.dump(content, f, ensure_ascii=False)
         logger.debug(f"Wrote JSON to {file_path} with {encoding} encoding")
 
     def _write_yaml_file(

camel/toolkits/linkedin_toolkit.py

@@ -75,7 +75,9 @@ class LinkedInToolkit(BaseToolkit):
         }
 
         response = requests.post(
-            url, headers=headers, data=json.dumps(post_data)
+            url,
+            headers=headers,
+            data=json.dumps(post_data, ensure_ascii=False),
         )
         if response.status_code == 201:
             post_response = response.json()

camel/toolkits/networkx_toolkit.py

@@ -178,7 +178,7 @@ class NetworkXToolkit(BaseToolkit):
         """
         logger.info("Serializing the graph.")
         nx = self._get_nx()
-        return json.dumps(nx.node_link_data(self.graph))
+        return json.dumps(nx.node_link_data(self.graph), ensure_ascii=False)
 
     def deserialize_graph(self, data: str) -> None:
         r"""Loads a graph from a serialized JSON string.
@@ -199,7 +199,7 @@ class NetworkXToolkit(BaseToolkit):
         logger.info(f"Exporting graph to file: {file_path}")
         nx = self._get_nx()
         with open(file_path, "w") as file:
-            json.dump(nx.node_link_data(self.graph), file)
+            json.dump(nx.node_link_data(self.graph), file, ensure_ascii=False)
 
     def import_from_file(self, file_path: str) -> None:
         r"""Imports a graph from a JSON file.

camel/toolkits/search_toolkit.py

@@ -751,7 +751,8 @@ class SearchToolkit(BaseToolkit):
                 "summary": summary,
                 "count": count,
                 "page": page,
-            }
+            },
+            ensure_ascii=False,
         )
         try:
             response = requests.post(url, headers=headers, data=payload)
@@ -766,6 +767,185 @@ class SearchToolkit(BaseToolkit):
         except requests.exceptions.RequestException as e:
             return {"error": f"Bocha AI search failed: {e!s}"}
 
+    def search_baidu(self, query: str, max_results: int = 5) -> Dict[str, Any]:
+        r"""Search Baidu using web scraping to retrieve relevant search
+        results. This method queries Baidu's search engine and extracts search
+        results including titles, descriptions, and URLs.
+
+        Args:
+            query (str): Search query string to submit to Baidu.
+            max_results (int): Maximum number of results to return.
+                (default: :obj:`5`)
+
+        Returns:
+            Dict[str, Any]: A dictionary containing search results or error
+                message.
+        """
+        from bs4 import BeautifulSoup
+
+        try:
+            url = "https://www.baidu.com/s"
+            headers = {
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/120.0.0.0 Safari/537.36"
+                ),
+                "Referer": "https://www.baidu.com",
+            }
+            params = {"wd": query, "rn": str(max_results)}
+
+            response = requests.get(url, headers=headers, params=params)
+            response.encoding = "utf-8"
+
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            results = []
+            for idx, item in enumerate(soup.select(".result"), 1):
+                title_element = item.select_one("h3 > a")
+                title = (
+                    title_element.get_text(strip=True) if title_element else ""
+                )
+
+                link = title_element["href"] if title_element else ""
+
+                desc_element = item.select_one(".c-abstract, .c-span-last")
+                desc = (
+                    desc_element.get_text(strip=True) if desc_element else ""
+                )
+
+                results.append(
+                    {
+                        "result_id": idx,
+                        "title": title,
+                        "description": desc,
+                        "url": link,
+                    }
+                )
+                if len(results) >= max_results:
+                    break
+
+            if not results:
+                print(
+                    "Warning: No results found. Check "
+                    "if Baidu HTML structure has changed."
+                )
+
+            return {"results": results}
+
+        except Exception as e:
+            return {"error": f"Baidu scraping error: {e!s}"}
+
+    def search_bing(self, query: str, max_results: int = 5) -> Dict[str, Any]:
+        r"""Use Bing search engine to search information for the given query.
+
+        This function queries the Chinese version of Bing search engine (cn.
+        bing.com) using web scraping to retrieve relevant search results. It
+        extracts search results including titles, snippets, and URLs. This
+        function is particularly useful when the query is in Chinese or when
+        Chinese search results are desired.
+
+        Args:
+            query (str): The search query string to submit to Bing. Works best
+                with Chinese queries or when Chinese results are preferred.
+            max_results (int): Maximum number of results to return.
+                (default: :obj:`5`)
+
+        Returns:
+            Dict ([str, Any]): A dictionary containing either:
+                - 'results': A list of dictionaries, each with:
+                    - 'result_id': The index of the result.
+                    - 'snippet': A brief description of the search result.
+                    - 'title': The title of the search result.
+                    - 'link': The URL of the search result.
+                - or 'error': An error message if something went wrong.
+        """
+        from typing import Any, Dict, List, cast
+        from urllib.parse import urlencode
+
+        from bs4 import BeautifulSoup, Tag
+
+        try:
+            query = urlencode({"q": query})
+            url = f'https://cn.bing.com/search?{query}'
+            headers = {
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/120.0.0.0 Safari/537.36"
+                ),
+            }
+            # Add timeout to prevent hanging
+            response = requests.get(url, headers=headers, timeout=10)
+
+            # Check if the request was successful
+            if response.status_code != 200:
+                return {
+                    "error": (
+                        f"Bing returned status code: "
+                        f"{response.status_code}"
+                    )
+                }
+
+            response.encoding = 'utf-8'
+            soup = BeautifulSoup(response.text, 'html.parser')
+
+            b_results_element = soup.find("ol", id="b_results")
+            if b_results_element is None:
+                return {"results": []}
+
+            # Ensure b_results is a Tag and find all li elements
+            b_results_tag = cast(Tag, b_results_element)
+            result_items = b_results_tag.find_all("li")
+
+            results: List[Dict[str, Any]] = []
+            for i in range(min(len(result_items), max_results)):
+                row = result_items[i]
+                if not isinstance(row, Tag):
+                    continue
+
+                h2_element = row.find("h2")
+                if h2_element is None:
+                    continue
+                h2_tag = cast(Tag, h2_element)
+
+                title = h2_tag.get_text().strip()
+
+                link_tag_element = h2_tag.find("a")
+                if link_tag_element is None:
+                    continue
+                link_tag = cast(Tag, link_tag_element)
+
+                link = link_tag.get("href")
+                if link is None:
+                    continue
+
+                content_element = row.find("p", class_="b_algoSlug")
+                content_text = ""
+                if content_element is not None and isinstance(
+                    content_element, Tag
+                ):
+                    content_text = content_element.get_text()
+
+                row_data = {
+                    "result_id": i + 1,
+                    "snippet": content_text,
+                    "title": title,
+                    "link": link,
+                }
+                results.append(row_data)
+
+            if not results:
+                return {
+                    "warning": "No results found. Check if "
+                    "Bing HTML structure has changed."
+                }
+
+            return {"results": results}
+
+        except Exception as e:
+            return {"error": f"Bing scraping error: {e!s}"}
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
         functions in the toolkit.
@@ -783,4 +963,6 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.tavily_search),
             FunctionTool(self.search_brave),
             FunctionTool(self.search_bocha),
+            FunctionTool(self.search_baidu),
+            FunctionTool(self.search_bing),
         ]

camel/toolkits/semantic_scholar_toolkit.py

@@ -238,7 +238,7 @@ class SemanticScholarToolkit(BaseToolkit):
             papers = response.json()
             if save_to_file:
                 with open('recommended_papers.json', 'w') as output:
-                    json.dump(papers, output)
+                    json.dump(papers, output, ensure_ascii=False)
             return papers
         except requests.exceptions.RequestException as e:
             return {"error": str(e)}
@@ -282,7 +282,7 @@ class SemanticScholarToolkit(BaseToolkit):
             response_data = response.json()
             if save_to_file:
                 with open('author_information.json', 'w') as output:
-                    json.dump(response_data, output)
+                    json.dump(response_data, output, ensure_ascii=False)
             return response_data
         except requests.exceptions.RequestException as e:
             return {"error": str(e)}

camel/toolkits/stripe_toolkit.py

@@ -85,7 +85,7 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(f"Retrieving customer with ID: {customer_id}")
             customer = stripe.Customer.retrieve(customer_id)
             self.logger.info(f"Retrieved customer: {customer.id}")
-            json_string = json.dumps(customer)
+            json_string = json.dumps(customer, ensure_ascii=False)
             return json_string
         except Exception as e:
             return self.handle_exception("customer_get", e)
@@ -109,7 +109,9 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(
                 f"Successfully retrieved {len(customers)} customers."
             )
-            return json.dumps([customer for customer in customers])
+            return json.dumps(
+                [customer for customer in customers], ensure_ascii=False
+            )
         except Exception as e:
             return self.handle_exception("customer_list", e)
 
@@ -128,7 +130,7 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(
                 f"Successfully retrieved account balance: {balance}."
             )
-            return json.dumps(balance)
+            return json.dumps(balance, ensure_ascii=False)
         except Exception as e:
             return self.handle_exception("balance_get", e)
 
@@ -154,7 +156,10 @@ class StripeToolkit(BaseToolkit):
                 f"Successfully retrieved {len(transactions)} "
                 "balance transactions."
             )
-            return json.dumps([transaction for transaction in transactions])
+            return json.dumps(
+                [transaction for transaction in transactions],
+                ensure_ascii=False,
+            )
         except Exception as e:
             return self.handle_exception("balance_transaction_list", e)
 
@@ -174,7 +179,7 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(f"Retrieving payment with ID: {payment_id}")
             payment = stripe.PaymentIntent.retrieve(payment_id)
             self.logger.info(f"Retrieved payment: {payment.id}")
-            return json.dumps(payment)
+            return json.dumps(payment, ensure_ascii=False)
         except Exception as e:
             return self.handle_exception("payment_get", e)
 
@@ -197,7 +202,9 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(
                 f"Successfully retrieved {len(payments)} payments."
             )
-            return json.dumps([payment for payment in payments])
+            return json.dumps(
+                [payment for payment in payments], ensure_ascii=False
+            )
         except Exception as e:
             return self.handle_exception("payment_list", e)
 
@@ -217,7 +224,7 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(f"Retrieving refund with ID: {refund_id}")
             refund = stripe.Refund.retrieve(refund_id)
             self.logger.info(f"Retrieved refund: {refund.id}")
-            return json.dumps(refund)
+            return json.dumps(refund, ensure_ascii=False)
         except Exception as e:
             return self.handle_exception("refund_get", e)
 
@@ -238,7 +245,9 @@ class StripeToolkit(BaseToolkit):
             self.logger.info(f"Listing refunds with limit={limit}")
             refunds = stripe.Refund.list(limit=limit).data
             self.logger.info(f"Successfully retrieved {len(refunds)} refunds.")
-            return json.dumps([refund for refund in refunds])
+            return json.dumps(
+                [refund for refund in refunds], ensure_ascii=False
+            )
         except Exception as e:
             return self.handle_exception("refund_list", e)