camel-ai 0.2.66__py3-none-any.whl → 0.2.68__py3-none-any.whl

camel/interpreters/docker/Dockerfile

@@ -55,11 +55,8 @@ RUN curl -fsSL https://install.python-poetry.org | python3.10 - && \
 # Upgrade pip and install base Python packages
 RUN python3.10 -m pip install --upgrade pip setuptools wheel
 
-# Install uv
-RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
-    mv /root/.local/bin/uv /usr/local/bin/uv && \
-    mv /root/.local/bin/uvx /usr/local/bin/uvx && \
-    chmod +x /usr/local/bin/uv /usr/local/bin/uvx
+# Install uv using pip instead of the shell script
+RUN pip install uv
 
 # Setup working directory
 WORKDIR /workspace

camel/loaders/firecrawl_reader.py

@@ -98,8 +98,8 @@ class Firecrawl:
     def scrape(
         self,
         url: str,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict:
+        params: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, str]:
         r"""To scrape a single URL. This function supports advanced scraping
         by setting different parameters and returns the full scraped data as a
         dictionary.
@@ -108,11 +108,11 @@ class Firecrawl:
 
         Args:
             url (str): The URL to read.
-            params (Optional[Dict[str, Any]]): Additional parameters for the
+            params (Optional[Dict[str, str]]): Additional parameters for the
                 scrape request.
 
         Returns:
-            Dict: The scraped data.
+            Dict[str, str]: The scraped data.
 
         Raises:
             RuntimeError: If the scrape process fails.

camel/memories/blocks/vectordb_block.py

@@ -89,13 +89,20 @@ class VectorDBBlock(MemoryBlock):
             records (List[MemoryRecord]): Memory records to be added to the
                 memory.
         """
+        # Filter out records with empty message content
+        valid_records = [
+            record
+            for record in records
+            if record.message.content and record.message.content.strip()
+        ]
+
         v_records = [
             VectorRecord(
                 vector=self.embedding.embed(record.message.content),
                 payload=record.to_dict(),
                 id=str(record.uuid),
             )
-            for record in records
+            for record in valid_records
         ]
         self.storage.add(v_records)
 

camel/memories/context_creators/score_based.py

@@ -11,7 +11,7 @@
 # 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
+from typing import Dict, List, Optional, Tuple
 
 from pydantic import BaseModel
 
@@ -74,6 +74,8 @@ class ScoreBasedContextCreator(BaseContextCreator):
         3. Final output maintains chronological order and in history memory,
            the score of each message decreases according to keep_rate. The
            newer the message, the higher the score.
+        4. Tool calls and their responses are kept together to maintain
+           API compatibility
 
         Args:
             records (List[ContextRecord]): List of context records with scores
@@ -126,12 +128,17 @@ class ScoreBasedContextCreator(BaseContextCreator):
             )
 
         # ======================
-        # 3. Token Calculation
+        # 3. Tool Call Relationship Mapping
+        # ======================
+        tool_call_groups = self._group_tool_calls_and_responses(regular_units)
+
+        # ======================
+        # 4. Token Calculation
         # ======================
         total_tokens = system_tokens + sum(u.num_tokens for u in regular_units)
 
         # ======================
-        # 4. Early Return if Within Limit
+        # 5. Early Return if Within Limit
         # ======================
         if total_tokens <= self.token_limit:
             sorted_units = sorted(
@@ -140,7 +147,7 @@ class ScoreBasedContextCreator(BaseContextCreator):
             return self._assemble_output(sorted_units, system_unit)
 
         # ======================
-        # 5. Truncation Logic
+        # 6. Truncation Logic with Tool Call Awareness
         # ======================
         logger.warning(
             f"Context truncation required "
@@ -148,24 +155,12 @@ class ScoreBasedContextCreator(BaseContextCreator):
             f"pruning low-score messages."
         )
 
-        # Sort for truncation: high scores first, older messages first at same
-        # score
-        sorted_for_truncation = sorted(
-            regular_units, key=self._truncation_sort_key
+        remaining_units = self._truncate_with_tool_call_awareness(
+            regular_units, tool_call_groups, system_tokens
         )
 
-        # Reverse to process from lowest score (end of sorted list)
-        remaining_units = []
-        current_total = system_tokens
-
-        for unit in sorted_for_truncation:
-            potential_total = current_total + unit.num_tokens
-            if potential_total <= self.token_limit:
-                remaining_units.append(unit)
-                current_total = potential_total
-
         # ======================
-        # 6. Output Assembly
+        # 7. Output Assembly
         # ======================
 
         # In case system message is the only message in memory when sorted
@@ -180,6 +175,115 @@ class ScoreBasedContextCreator(BaseContextCreator):
         final_units = sorted(remaining_units, key=self._conversation_sort_key)
         return self._assemble_output(final_units, system_unit)
 
+    def _group_tool_calls_and_responses(
+        self, units: List[_ContextUnit]
+    ) -> Dict[str, List[_ContextUnit]]:
+        r"""Groups tool calls with their corresponding responses.
+
+        Args:
+            units (List[_ContextUnit]): List of context units to analyze
+
+        Returns:
+            Dict[str, List[_ContextUnit]]: Mapping from tool_call_id to list of
+                related units (tool call + responses)
+        """
+        tool_call_groups: Dict[str, List[_ContextUnit]] = {}
+
+        for unit in units:
+            message = unit.record.memory_record.message
+            backend_role = unit.record.memory_record.role_at_backend
+
+            # Check if this is a tool call message
+            if hasattr(message, 'func_name') and hasattr(
+                message, 'tool_call_id'
+            ):
+                tool_call_id = getattr(message, 'tool_call_id', None)
+                if tool_call_id:
+                    if tool_call_id not in tool_call_groups:
+                        tool_call_groups[tool_call_id] = []
+                    tool_call_groups[tool_call_id].append(unit)
+
+            # Check if this is a tool response message
+            elif backend_role == OpenAIBackendRole.FUNCTION:
+                tool_call_id = None
+                if hasattr(message, 'tool_call_id'):
+                    tool_call_id = getattr(message, 'tool_call_id', None)
+                elif hasattr(message, 'result') and hasattr(
+                    message, 'tool_call_id'
+                ):
+                    tool_call_id = getattr(message, 'tool_call_id', None)
+
+                if tool_call_id:
+                    if tool_call_id not in tool_call_groups:
+                        tool_call_groups[tool_call_id] = []
+                    tool_call_groups[tool_call_id].append(unit)
+
+        return tool_call_groups
+
+    def _truncate_with_tool_call_awareness(
+        self,
+        regular_units: List[_ContextUnit],
+        tool_call_groups: Dict[str, List[_ContextUnit]],
+        system_tokens: int,
+    ) -> List[_ContextUnit]:
+        r"""Truncates messages while preserving tool call-response pairs.
+
+        Args:
+            regular_units (List[_ContextUnit]): All regular message units
+            tool_call_groups (Dict[str, List[_ContextUnit]]): Grouped tool
+                calls
+            system_tokens (int): Tokens used by system message
+
+        Returns:
+            List[_ContextUnit]: Units that fit within token limit
+        """
+        # Create sets for quick lookup of tool call related units
+        tool_call_unit_ids = set()
+        for group in tool_call_groups.values():
+            for unit in group:
+                tool_call_unit_ids.add(unit.record.memory_record.uuid)
+
+        # Separate tool call groups and standalone units
+        standalone_units = [
+            u
+            for u in regular_units
+            if u.record.memory_record.uuid not in tool_call_unit_ids
+        ]
+
+        # Sort standalone units for truncation (high scores first)
+        standalone_units.sort(key=self._truncation_sort_key)
+
+        # Sort tool call groups by their best (highest) score
+        sorted_tool_groups = []
+        for _tool_call_id, group in tool_call_groups.items():
+            # Use the highest score in the group as the group's score
+            best_score = max(unit.record.score for unit in group)
+            latest_timestamp = max(unit.record.timestamp for unit in group)
+            group_tokens = sum(unit.num_tokens for unit in group)
+            sorted_tool_groups.append(
+                ((-best_score, -latest_timestamp), group, group_tokens)
+            )
+
+        sorted_tool_groups.sort(key=lambda x: x[0])
+
+        # Greedy selection to fit within token limit
+        remaining_units = []
+        current_tokens = system_tokens
+
+        # First, try to include complete tool call groups
+        for _, group, group_tokens in sorted_tool_groups:
+            if current_tokens + group_tokens <= self.token_limit:
+                remaining_units.extend(group)
+                current_tokens += group_tokens
+
+        # Then, include standalone units
+        for unit in standalone_units:
+            if current_tokens + unit.num_tokens <= self.token_limit:
+                remaining_units.append(unit)
+                current_tokens += unit.num_tokens
+
+        return remaining_units
+
     def _extract_system_message(
         self, records: List[ContextRecord]
     ) -> Tuple[Optional[_ContextUnit], List[_ContextUnit]]:

camel/models/__init__.py

@@ -41,6 +41,7 @@ from .openai_compatible_model import OpenAICompatibleModel
 from .openai_model import OpenAIModel
 from .openrouter_model import OpenRouterModel
 from .ppio_model import PPIOModel
+from .qianfan_model import QianfanModel
 from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
@@ -97,5 +98,6 @@ __all__ = [
     'VolcanoModel',
     'LMStudioModel',
     'WatsonXModel',
+    'QianfanModel',
     'CrynuxModel',
 ]

camel/models/aiml_model.py

@@ -46,6 +46,10 @@ class AIMLModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required([("api_key", "AIML_API_KEY")])
@@ -57,6 +61,8 @@ class AIMLModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = AIMLConfig().as_dict()
@@ -73,6 +79,8 @@ class AIMLModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/anthropic_model.py

@@ -12,11 +12,14 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
+
+from openai import AsyncStream, Stream
 
 from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
+from camel.messages import OpenAIMessage
 from camel.models.openai_compatible_model import OpenAICompatibleModel
-from camel.types import ModelType
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     AnthropicTokenCounter,
     BaseTokenCounter,
@@ -25,6 +28,47 @@ from camel.utils import (
 )
 
 
+def strip_trailing_whitespace_from_messages(
+    messages: List[OpenAIMessage],
+) -> List[OpenAIMessage]:
+    r"""Strip trailing whitespace from all message contents in a list of
+    messages. This is necessary because the Anthropic API doesn't allow
+    trailing whitespace in message content.
+
+    Args:
+        messages (List[OpenAIMessage]): List of messages to process
+
+    Returns:
+        List[OpenAIMessage]: The processed messages with trailing whitespace
+            removed
+    """
+    if not messages:
+        return messages
+
+    # Create a deep copy to avoid modifying the original messages
+    processed_messages = [dict(msg) for msg in messages]
+
+    # Process each message
+    for msg in processed_messages:
+        if "content" in msg and msg["content"] is not None:
+            if isinstance(msg["content"], str):
+                msg["content"] = msg["content"].rstrip()
+            elif isinstance(msg["content"], list):
+                # Handle content that's a list of content parts (e.g., for
+                # multimodal content)
+                for i, part in enumerate(msg["content"]):
+                    if (
+                        isinstance(part, dict)
+                        and "text" in part
+                        and isinstance(part["text"], str)
+                    ):
+                        part["text"] = part["text"].rstrip()
+                    elif isinstance(part, str):
+                        msg["content"][i] = part.rstrip()
+
+    return processed_messages  # type: ignore[return-value]
+
+
 class AnthropicModel(OpenAICompatibleModel):
     r"""Anthropic API in a unified OpenAICompatibleModel interface.
 
@@ -46,6 +90,10 @@ class AnthropicModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -62,6 +110,8 @@ class AnthropicModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = AnthropicConfig().as_dict()
@@ -79,8 +129,13 @@ class AnthropicModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
+        # Monkey patch the AnthropicTokenCounter to handle trailing whitespace
+        self._patch_anthropic_token_counter()
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -107,3 +162,68 @@ class AnthropicModel(OpenAICompatibleModel):
                     f"Unexpected argument `{param}` is "
                     "input into Anthropic model backend."
                 )
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        # Strip trailing whitespace from all message contents to prevent
+        # Anthropic API errors
+        processed_messages = strip_trailing_whitespace_from_messages(messages)
+
+        # Call the parent class method
+        return super()._request_chat_completion(processed_messages, tools)
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        # Strip trailing whitespace from all message contents to prevent
+        # Anthropic API errors
+        processed_messages = strip_trailing_whitespace_from_messages(messages)
+
+        # Call the parent class method
+        return await super()._arequest_chat_completion(
+            processed_messages, tools
+        )
+
+    def _patch_anthropic_token_counter(self):
+        r"""Monkey patch the AnthropicTokenCounter class to handle trailing
+        whitespace.
+
+        This patches the count_tokens_from_messages method to strip trailing
+        whitespace from message content before sending to the Anthropic API.
+        """
+        import functools
+
+        from anthropic.types import MessageParam
+
+        from camel.utils import AnthropicTokenCounter
+
+        original_count_tokens = (
+            AnthropicTokenCounter.count_tokens_from_messages
+        )
+
+        @functools.wraps(original_count_tokens)
+        def patched_count_tokens(self, messages):
+            # Process messages to remove trailing whitespace
+            processed_messages = strip_trailing_whitespace_from_messages(
+                messages
+            )
+
+            # Use the processed messages with the original method
+            return self.client.messages.count_tokens(
+                messages=[
+                    MessageParam(
+                        content=str(msg["content"]),
+                        role="user" if msg["role"] == "user" else "assistant",
+                    )
+                    for msg in processed_messages
+                ],
+                model=self.model,
+            ).input_tokens
+
+        # Apply the monkey patch
+        AnthropicTokenCounter.count_tokens_from_messages = patched_count_tokens

camel/models/aws_bedrock_model.py

@@ -50,6 +50,10 @@ class AWSBedrockModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
 
     References:
         https://docs.aws.amazon.com/bedrock/latest/APIReference/welcome.html
@@ -69,6 +73,8 @@ class AWSBedrockModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = BedrockConfig().as_dict()
@@ -84,6 +90,8 @@ class AWSBedrockModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     async def _arun(

camel/models/azure_openai_model.py

@@ -76,7 +76,10 @@ class AzureOpenAIModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
-
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
 
     References:
         https://learn.microsoft.com/en-us/azure/ai-services/openai/
@@ -94,6 +97,8 @@ class AzureOpenAIModel(BaseModelBackend):
         azure_deployment_name: Optional[str] = None,
         azure_ad_token_provider: Optional["AzureADTokenProvider"] = None,
         azure_ad_token: Optional[str] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
@@ -135,7 +140,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
             self._async_client = LangfuseAsyncOpenAI(
                 azure_endpoint=str(self._url),
@@ -145,7 +151,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
         else:
             self._client = AzureOpenAI(
@@ -156,7 +163,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
 
             self._async_client = AsyncAzureOpenAI(
@@ -167,7 +175,8 @@ class AzureOpenAIModel(BaseModelBackend):
                 azure_ad_token=self._azure_ad_token,
                 azure_ad_token_provider=self.azure_ad_token_provider,
                 timeout=self._timeout,
-                max_retries=3,
+                max_retries=max_retries,
+                **kwargs,
             )
 
     @property

camel/models/base_model.py

@@ -71,6 +71,8 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
             :obj:`OpenAITokenCounter` will be used. (default: :obj:`None`)
         timeout (Optional[float], optional): The timeout value in seconds for
             API calls. (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries
+            for API calls. (default: :obj:`3`)
     """
 
     def __init__(
@@ -81,6 +83,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
     ) -> None:
         self.model_type: UnifiedModelType = UnifiedModelType(model_type)
         if model_config_dict is None:
@@ -90,6 +93,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self._url = url
         self._token_counter = token_counter
         self._timeout = timeout
+        self._max_retries = max_retries
         self.check_model_config()
 
     @property

camel/models/cohere_model.py

@@ -76,6 +76,8 @@ class CohereModel(BaseModelBackend):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -91,6 +93,7 @@ class CohereModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        **kwargs: Any,
     ):
         import cohere
 
@@ -105,10 +108,14 @@ class CohereModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = cohere.ClientV2(
-            timeout=self._timeout, api_key=self._api_key
+            timeout=self._timeout,
+            api_key=self._api_key,
+            **kwargs,
         )
         self._async_client = cohere.AsyncClientV2(
-            timeout=self._timeout, api_key=self._api_key
+            timeout=self._timeout,
+            api_key=self._api_key,
+            **kwargs,
         )
 
     def _to_openai_response(self, response: 'ChatResponse') -> ChatCompletion:

camel/models/crynux_model.py

@@ -46,6 +46,10 @@ class CrynuxModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
     """
 
     @api_keys_required(
@@ -61,6 +65,8 @@ class CrynuxModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = CrynuxConfig().as_dict()
@@ -76,6 +82,8 @@ class CrynuxModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def check_model_config(self):

camel/models/deepseek_model.py

@@ -78,6 +78,10 @@ class DeepSeekModel(OpenAICompatibleModel):
             API calls. If not provided, will fall back to the MODEL_TIMEOUT
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
 
     References:
         https://api-docs.deepseek.com/
@@ -96,6 +100,8 @@ class DeepSeekModel(OpenAICompatibleModel):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = DeepSeekConfig().as_dict()
@@ -112,6 +118,8 @@ class DeepSeekModel(OpenAICompatibleModel):
             url=url,
             token_counter=token_counter,
             timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
         )
 
     def _prepare_request(