camel-ai 0.2.75a5__tar.gz → 0.2.75a6__tar.gz

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.75a5
+Version: 0.2.75a6
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -224,18 +224,12 @@ Requires-Dist: tabulate>=0.9.0; extra == 'document-tools'
 Requires-Dist: unstructured==0.16.20; extra == 'document-tools'
 Requires-Dist: xls2xlsx>=0.2.0; extra == 'document-tools'
 Provides-Extra: eigent
-Requires-Dist: aci-sdk>=1.0.0b1; extra == 'eigent'
 Requires-Dist: anthropic<0.50.0,>=0.47.0; extra == 'eigent'
-Requires-Dist: chunkr-ai<0.1.0,>=0.0.50; extra == 'eigent'
-Requires-Dist: chunkr-ai>=0.0.41; extra == 'eigent'
-Requires-Dist: crawl4ai>=0.3.745; extra == 'eigent'
 Requires-Dist: datasets<4,>=3; extra == 'eigent'
 Requires-Dist: docx>=0.2.4; extra == 'eigent'
-Requires-Dist: duckduckgo-search<7,>=6.3.5; extra == 'eigent'
 Requires-Dist: exa-py<2,>=1.10.0; extra == 'eigent'
 Requires-Dist: ffmpeg-python<0.3,>=0.2.0; extra == 'eigent'
 Requires-Dist: google-api-python-client==2.166.0; extra == 'eigent'
-Requires-Dist: html2text>=2024.2.26; extra == 'eigent'
 Requires-Dist: imageio[pyav]<3,>=2.34.2; extra == 'eigent'
 Requires-Dist: markitdown[all]>=0.1.1; extra == 'eigent'
 Requires-Dist: mcp-server-fetch==2025.1.17; extra == 'eigent'
@@ -244,8 +238,6 @@ Requires-Dist: numpy<=2.2,>=1.2; extra == 'eigent'
 Requires-Dist: onnxruntime<=1.19.2; extra == 'eigent'
 Requires-Dist: openpyxl>=3.1.5; extra == 'eigent'
 Requires-Dist: pandas<2,>=1.5.3; extra == 'eigent'
-Requires-Dist: playwright>=1.50.0; extra == 'eigent'
-Requires-Dist: pyautogui<0.10,>=0.9.54; extra == 'eigent'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'eigent'
 Requires-Dist: pylatex>=1.4.2; extra == 'eigent'
 Requires-Dist: pytesseract>=0.3.13; extra == 'eigent'

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.75a5'
+__version__ = '0.2.75a6'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/camel/agents/chat_agent.py

@@ -14,9 +14,11 @@
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import json
 import logging
 import queue
+import random
 import textwrap
 import threading
 import time
@@ -40,6 +42,7 @@ from typing import (
 
 from openai import (
     AsyncStream,
+    RateLimitError,
     Stream,
 )
 from pydantic import BaseModel, ValidationError
@@ -386,6 +389,13 @@ class ChatAgent(BaseAgent):
             usage. When enabled, removes FUNCTION/TOOL role messages and
             ASSISTANT messages with tool_calls after each step.
             (default: :obj:`False`)
+        retry_attempts (int, optional): Maximum number of retry attempts for
+            rate limit errors. (default: :obj:`3`)
+        retry_delay (float, optional): Initial delay in seconds between
+            retries. Uses exponential backoff. (default: :obj:`1.0`)
+        step_timeout (Optional[float], optional): Timeout in seconds for the
+            entire step operation. If None, no timeout is applied.
+            (default: :obj:`None`)
     """
 
     def __init__(
@@ -426,6 +436,9 @@ class ChatAgent(BaseAgent):
         mask_tool_output: bool = False,
         pause_event: Optional[asyncio.Event] = None,
         prune_tool_calls_from_memory: bool = False,
+        retry_attempts: int = 3,
+        retry_delay: float = 1.0,
+        step_timeout: Optional[float] = None,
     ) -> None:
         if isinstance(model, ModelManager):
             self.model_backend = model
@@ -511,6 +524,9 @@ class ChatAgent(BaseAgent):
         self._secure_result_store: Dict[str, Any] = {}
         self.pause_event = pause_event
         self.prune_tool_calls_from_memory = prune_tool_calls_from_memory
+        self.retry_attempts = max(1, retry_attempts)
+        self.retry_delay = max(0.0, retry_delay)
+        self.step_timeout = step_timeout
 
     def reset(self):
         r"""Resets the :obj:`ChatAgent` to its initial state."""
@@ -1365,6 +1381,9 @@ class ChatAgent(BaseAgent):
                 a StreamingChatAgentResponse that behaves like
                 ChatAgentResponse but can also be iterated for
                 streaming updates.
+
+        Raises:
+            TimeoutError: If the step operation exceeds the configured timeout.
         """
 
         stream = self.model_backend.model_config_dict.get("stream", False)
@@ -1374,6 +1393,30 @@ class ChatAgent(BaseAgent):
             generator = self._stream(input_message, response_format)
             return StreamingChatAgentResponse(generator)
 
+        # Execute with timeout if configured
+        if self.step_timeout is not None:
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=1
+            ) as executor:
+                future = executor.submit(
+                    self._step_impl, input_message, response_format
+                )
+                try:
+                    return future.result(timeout=self.step_timeout)
+                except concurrent.futures.TimeoutError:
+                    future.cancel()
+                    raise TimeoutError(
+                        f"Step timed out after {self.step_timeout}s"
+                    )
+        else:
+            return self._step_impl(input_message, response_format)
+
+    def _step_impl(
+        self,
+        input_message: Union[BaseMessage, str],
+        response_format: Optional[Type[BaseModel]] = None,
+    ) -> ChatAgentResponse:
+        r"""Implementation of non-streaming step logic."""
         # Set Langfuse session_id using agent_id for trace grouping
         try:
             from camel.utils.langfuse import set_current_agent_session_id
@@ -1544,6 +1587,10 @@ class ChatAgent(BaseAgent):
                 True, returns an AsyncStreamingChatAgentResponse that can be
                 awaited for the final result or async iterated for streaming
                 updates.
+
+        Raises:
+            asyncio.TimeoutError: If the step operation exceeds the configured
+                timeout.
         """
 
         try:
@@ -1559,9 +1606,22 @@ class ChatAgent(BaseAgent):
             async_generator = self._astream(input_message, response_format)
             return AsyncStreamingChatAgentResponse(async_generator)
         else:
-            return await self._astep_non_streaming_task(
-                input_message, response_format
-            )
+            if self.step_timeout is not None:
+                try:
+                    return await asyncio.wait_for(
+                        self._astep_non_streaming_task(
+                            input_message, response_format
+                        ),
+                        timeout=self.step_timeout,
+                    )
+                except asyncio.TimeoutError:
+                    raise asyncio.TimeoutError(
+                        f"Async step timed out after {self.step_timeout}s"
+                    )
+            else:
+                return await self._astep_non_streaming_task(
+                    input_message, response_format
+                )
 
     async def _astep_non_streaming_task(
         self,
@@ -1776,64 +1836,61 @@ class ChatAgent(BaseAgent):
         tool_schemas: Optional[List[Dict[str, Any]]] = None,
         prev_num_openai_messages: int = 0,
     ) -> ModelResponse:
-        r"""Internal function for agent step model response.
-        Args:
-            openai_messages (List[OpenAIMessage]): The OpenAI
-                messages to process.
-            num_tokens (int): The number of tokens in the context.
-            current_iteration (int): The current iteration of the step.
-            response_format (Optional[Type[BaseModel]]): The response
-                format to use.
-            tool_schemas (Optional[List[Dict[str, Any]]]): The tool
-                schemas to use.
-            prev_num_openai_messages (int): The number of openai messages
-                logged in the previous iteration.
-
-        Returns:
-            ModelResponse: The model response.
-        """
+        r"""Internal function for agent step model response."""
+        last_error = None
 
-        response = None
-        try:
-            response = self.model_backend.run(
-                openai_messages, response_format, tool_schemas or None
-            )
-        except Exception as exc:
-            logger.error(
-                f"An error occurred while running model "
-                f"{self.model_backend.model_type}, "
-                f"index: {self.model_backend.current_model_index}",
-                exc_info=exc,
-            )
-            error_info = str(exc)
-
-        if not response and self.model_backend.num_models > 1:
-            raise ModelProcessingError(
-                "Unable to process messages: none of the provided models "
-                "run successfully."
-            )
-        elif not response:
+        for attempt in range(self.retry_attempts):
+            try:
+                response = self.model_backend.run(
+                    openai_messages, response_format, tool_schemas or None
+                )
+                if response:
+                    break
+            except RateLimitError as e:
+                last_error = e
+                if attempt < self.retry_attempts - 1:
+                    delay = min(self.retry_delay * (2**attempt), 60.0)
+                    delay = random.uniform(0, delay)  # Add jitter
+                    logger.warning(
+                        f"Rate limit hit (attempt {attempt + 1}"
+                        f"/{self.retry_attempts}). Retrying in {delay:.1f}s"
+                    )
+                    time.sleep(delay)
+                else:
+                    logger.error(
+                        f"Rate limit exhausted after "
+                        f"{self.retry_attempts} attempts"
+                    )
+            except Exception:
+                logger.error(
+                    f"Model error: {self.model_backend.model_type}",
+                    exc_info=True,
+                )
+                raise
+        else:
+            # Loop completed without success
             raise ModelProcessingError(
-                f"Unable to process messages: the only provided model "
-                f"did not run successfully. Error: {error_info}"
+                f"Unable to process messages: "
+                f"{str(last_error) if last_error else 'Unknown error'}"
             )
 
-        sanitized_messages = self._sanitize_messages_for_logging(
+        # Log success
+        sanitized = self._sanitize_messages_for_logging(
             openai_messages, prev_num_openai_messages
         )
         logger.info(
-            f"Model {self.model_backend.model_type}, "
-            f"index {self.model_backend.current_model_index}, "
-            f"iteration {current_iteration}, "
-            f"processed these messages: {sanitized_messages}"
+            f"Model {self.model_backend.model_type} "
+            f"[{current_iteration}]: {sanitized}"
         )
+
         if not isinstance(response, ChatCompletion):
             raise TypeError(
-                f"Expected response to be a `ChatCompletion` object, but "
-                f"got {type(response).__name__} instead."
+                f"Expected ChatCompletion, got {type(response).__name__}"
             )
+
         return self._handle_batch_response(response)
 
+    @observe()
     async def _aget_model_response(
         self,
         openai_messages: List[OpenAIMessage],
@@ -1843,62 +1900,59 @@ class ChatAgent(BaseAgent):
         tool_schemas: Optional[List[Dict[str, Any]]] = None,
         prev_num_openai_messages: int = 0,
     ) -> ModelResponse:
-        r"""Internal function for agent async step model response.
-        Args:
-            openai_messages (List[OpenAIMessage]): The OpenAI messages
-                to process.
-            num_tokens (int): The number of tokens in the context.
-            current_iteration (int): The current iteration of the step.
-            response_format (Optional[Type[BaseModel]]): The response
-                format to use.
-            tool_schemas (Optional[List[Dict[str, Any]]]): The tool schemas
-                to use.
-            prev_num_openai_messages (int): The number of openai messages
-                logged in the previous iteration.
+        r"""Internal function for agent async step model response."""
+        last_error = None
 
-        Returns:
-            ModelResponse: The model response.
-        """
-
-        response = None
-        try:
-            response = await self.model_backend.arun(
-                openai_messages, response_format, tool_schemas or None
-            )
-        except Exception as exc:
-            logger.error(
-                f"An error occurred while running model "
-                f"{self.model_backend.model_type}, "
-                f"index: {self.model_backend.current_model_index}",
-                exc_info=exc,
-            )
-            error_info = str(exc)
-
-        if not response and self.model_backend.num_models > 1:
-            raise ModelProcessingError(
-                "Unable to process messages: none of the provided models "
-                "run successfully."
-            )
-        elif not response:
+        for attempt in range(self.retry_attempts):
+            try:
+                response = await self.model_backend.arun(
+                    openai_messages, response_format, tool_schemas or None
+                )
+                if response:
+                    break
+            except RateLimitError as e:
+                last_error = e
+                if attempt < self.retry_attempts - 1:
+                    delay = min(self.retry_delay * (2**attempt), 60.0)
+                    delay = random.uniform(0, delay)  # Add jitter
+                    logger.warning(
+                        f"Rate limit hit (attempt {attempt + 1}"
+                        f"/{self.retry_attempts}). "
+                        f"Retrying in {delay:.1f}s"
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    logger.error(
+                        f"Rate limit exhausted after "
+                        f"{self.retry_attempts} attempts"
+                    )
+            except Exception:
+                logger.error(
+                    f"Model error: {self.model_backend.model_type}",
+                    exc_info=True,
+                )
+                raise
+        else:
+            # Loop completed without success
             raise ModelProcessingError(
-                f"Unable to process messages: the only provided model "
-                f"did not run successfully. Error: {error_info}"
+                f"Unable to process messages: "
+                f"{str(last_error) if last_error else 'Unknown error'}"
             )
 
-        sanitized_messages = self._sanitize_messages_for_logging(
+        # Log success
+        sanitized = self._sanitize_messages_for_logging(
             openai_messages, prev_num_openai_messages
         )
         logger.info(
-            f"Model {self.model_backend.model_type}, "
-            f"index {self.model_backend.current_model_index}, "
-            f"iteration {current_iteration}, "
-            f"processed these messages: {sanitized_messages}"
+            f"Model {self.model_backend.model_type} "
+            f"[{current_iteration}]: {sanitized}"
         )
+
         if not isinstance(response, ChatCompletion):
             raise TypeError(
-                f"Expected response to be a `ChatCompletion` object, but "
-                f"got {type(response).__name__} instead."
+                f"Expected ChatCompletion, got {type(response).__name__}"
             )
+
         return self._handle_batch_response(response)
 
     def _sanitize_messages_for_logging(

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/camel/configs/__init__.py

@@ -26,6 +26,7 @@ from .lmstudio_config import LMSTUDIO_API_PARAMS, LMStudioConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .modelscope_config import MODELSCOPE_API_PARAMS, ModelScopeConfig
 from .moonshot_config import MOONSHOT_API_PARAMS, MoonshotConfig
+from .nebius_config import NEBIUS_API_PARAMS, NebiusConfig
 from .netmind_config import NETMIND_API_PARAMS, NetmindConfig
 from .novita_config import NOVITA_API_PARAMS, NovitaConfig
 from .nvidia_config import NVIDIA_API_PARAMS, NvidiaConfig
@@ -58,6 +59,8 @@ __all__ = [
     'ANTHROPIC_API_PARAMS',
     'GROQ_API_PARAMS',
     'GroqConfig',
+    'NEBIUS_API_PARAMS',
+    'NebiusConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
     'NetmindConfig',

camel_ai-0.2.75a6/camel/configs/nebius_config.py

@@ -0,0 +1,103 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import Optional, Sequence, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class NebiusConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility with Nebius AI Studio.
+
+    Reference: https://nebius.com/docs/ai-studio/api
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`None`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`None`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`None`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`None`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`None`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`None`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`None`)
+        tools (list[FunctionTool], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    response_format: Optional[dict] = None
+    frequency_penalty: Optional[float] = None
+    user: Optional[str] = None
+    tool_choice: Optional[Union[dict[str, str], str]] = None
+
+
+NEBIUS_API_PARAMS = {param for param in NebiusConfig.model_fields.keys()}

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/camel/models/__init__.py

@@ -31,6 +31,7 @@ from .model_factory import ModelFactory
 from .model_manager import ModelManager, ModelProcessingError
 from .modelscope_model import ModelScopeModel
 from .moonshot_model import MoonshotModel
+from .nebius_model import NebiusModel
 from .nemotron_model import NemotronModel
 from .netmind_model import NetmindModel
 from .novita_model import NovitaModel
@@ -87,6 +88,7 @@ __all__ = [
     'QwenModel',
     'AWSBedrockModel',
     'ModelProcessingError',
+    'NebiusModel',
     'DeepSeekModel',
     'FishAudioModel',
     'InternLMModel',

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/camel/models/model_factory.py

@@ -31,6 +31,7 @@ from camel.models.lmstudio_model import LMStudioModel
 from camel.models.mistral_model import MistralModel
 from camel.models.modelscope_model import ModelScopeModel
 from camel.models.moonshot_model import MoonshotModel
+from camel.models.nebius_model import NebiusModel
 from camel.models.netmind_model import NetmindModel
 from camel.models.novita_model import NovitaModel
 from camel.models.nvidia_model import NvidiaModel
@@ -83,6 +84,7 @@ class ModelFactory:
         ModelPlatformType.AZURE: AzureOpenAIModel,
         ModelPlatformType.ANTHROPIC: AnthropicModel,
         ModelPlatformType.GROQ: GroqModel,
+        ModelPlatformType.NEBIUS: NebiusModel,
         ModelPlatformType.LMSTUDIO: LMStudioModel,
         ModelPlatformType.OPENROUTER: OpenRouterModel,
         ModelPlatformType.ZHIPU: ZhipuAIModel,

camel_ai-0.2.75a6/camel/models/nebius_model.py

@@ -0,0 +1,83 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+from typing import Any, Dict, Optional, Union
+
+from camel.configs import NebiusConfig
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    api_keys_required,
+)
+
+
+class NebiusModel(OpenAICompatibleModel):
+    r"""LLM API served by Nebius AI Studio in a unified OpenAICompatibleModel
+    interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`.
+            If:obj:`None`, :obj:`NebiusConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the Nebius AI Studio service. (default: :obj:`None`).
+        url (Optional[str], optional): The url to the Nebius AI Studio service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            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", "NEBIUS_API_KEY")])
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        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 = NebiusConfig().as_dict()
+        api_key = api_key or os.environ.get("NEBIUS_API_KEY")
+        url = url or os.environ.get(
+            "NEBIUS_API_BASE_URL", "https://api.studio.nebius.com/v1"
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type=model_type,
+            model_config_dict=model_config_dict,
+            api_key=api_key,
+            url=url,
+            token_counter=token_counter,
+            timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
+        )

{camel_ai-0.2.75a5 → camel_ai-0.2.75a6}/camel/models/ollama_model.py

@@ -35,8 +35,8 @@ class OllamaModel(OpenAICompatibleModel):
             If:obj:`None`, :obj:`OllamaConfig().as_dict()` will be used.
             (default: :obj:`None`)
         api_key (Optional[str], optional): The API key for authenticating with
-            the model service.  Ollama doesn't need API key, it would be
-            ignored if set. (default: :obj:`None`)
+            the model service. Required for Ollama cloud services. If not
+            provided, defaults to "Not_Provided". (default: :obj:`None`)
         url (Optional[str], optional): The url to the model service.
             (default: :obj:`None`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
@@ -79,7 +79,7 @@ class OllamaModel(OpenAICompatibleModel):
         super().__init__(
             model_type=self._model_type,
             model_config_dict=model_config_dict,
-            api_key="Not_Used",
+            api_key=api_key or "Not_Provided",
             url=self._url,
             token_counter=token_counter,
             timeout=timeout,