camel-ai 0.1.9__py3-none-any.whl → 0.2.3__py3-none-any.whl

camel/models/samba_model.py

@@ -22,10 +22,11 @@ from openai import OpenAI, Stream
 
 from camel.configs import (
     SAMBA_CLOUD_API_PARAMS,
-    SAMBA_FAST_API_PARAMS,
     SAMBA_VERSE_API_PARAMS,
+    SambaCloudAPIConfig,
 )
 from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
 from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
@@ -38,48 +39,59 @@ from camel.utils import (
     api_keys_required,
 )
 
-
-class SambaModel:
-    r"""SambaNova service interface."""
+try:
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import LLMEvent, record
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    LLMEvent = None
+
+
+class SambaModel(BaseModelBackend):
+    r"""SambaNova service interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a SambaNova backend
+            is created. Supported models via SambaNova Cloud:
+            `https://community.sambanova.ai/t/supported-models/193`.
+            Supported models via SambaVerse API is listed in
+            `https://sambaverse.sambanova.ai/models`.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`SambaCloudAPIConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the SambaNova service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the SambaNova service.
+            Current support SambaVerse API:
+            :obj:`"https://sambaverse.sambanova.ai/api/predict"` and
+            SambaNova Cloud:
+            :obj:`"https://api.sambanova.ai/v1"` (default: :obj:`https://api.
+            sambanova.ai/v1`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+    """
 
     def __init__(
         self,
-        model_type: str,
-        model_config_dict: Dict[str, Any],
+        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,
     ) -> None:
-        r"""Constructor for SambaNova backend.
-
-        Args:
-            model_type (str): Model for which a SambaNova backend is
-                created. Supported models via Fast API: `https://sambanova.ai/
-                fast-api?api_ref=128521`. Supported models via SambaVerse API
-                is listed in `https://sambaverse.sambanova.ai/models`.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into API request.
-            api_key (Optional[str]): The API key for authenticating with the
-                SambaNova service. (default: :obj:`None`)
-            url (Optional[str]): The url to the SambaNova service. Current
-                support SambaNova Fast API: :obj:`"https://fast-api.snova.ai/
-                v1/chat/ completions"`, SambaVerse API: :obj:`"https://
-                sambaverse.sambanova.ai/api/predict"` and SambaNova Cloud:
-                :obj:`"https://api.sambanova.ai/v1"`
-                (default::obj:`"https://fast-api.snova.ai/v1/chat/completions"`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
-        self.model_type = model_type
-        self._api_key = api_key or os.environ.get("SAMBA_API_KEY")
-        self._url = url or os.environ.get(
+        if model_config_dict is None:
+            model_config_dict = SambaCloudAPIConfig().as_dict()
+        api_key = api_key or os.environ.get("SAMBA_API_KEY")
+        url = url or os.environ.get(
             "SAMBA_API_BASE_URL",
-            "https://fast-api.snova.ai/v1/chat/completions",
+            "https://api.sambanova.ai/v1",
+        )
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
         )
-        self._token_counter = token_counter
-        self.model_config_dict = model_config_dict
-        self.check_model_config()
 
         if self._url == "https://api.sambanova.ai/v1":
             self._client = OpenAI(
@@ -109,14 +121,7 @@ class SambaModel:
             ValueError: If the model configuration dictionary contains any
                 unexpected arguments to SambaNova API.
         """
-        if self._url == "https://fast-api.snova.ai/v1/chat/completions":
-            for param in self.model_config_dict:
-                if param not in SAMBA_FAST_API_PARAMS:
-                    raise ValueError(
-                        f"Unexpected argument `{param}` is "
-                        "input into SambaNova Fast API."
-                    )
-        elif self._url == "https://sambaverse.sambanova.ai/api/predict":
+        if self._url == "https://sambaverse.sambanova.ai/api/predict":
             for param in self.model_config_dict:
                 if param not in SAMBA_VERSE_API_PARAMS:
                     raise ValueError(
@@ -159,7 +164,7 @@ class SambaModel:
         else:
             return self._run_non_streaming(messages)
 
-    def _run_streaming(  # type: ignore[misc]
+    def _run_streaming(
         self, messages: List[OpenAIMessage]
     ) -> Stream[ChatCompletionChunk]:
         r"""Handles streaming inference with SambaNova's API.
@@ -175,48 +180,30 @@ class SambaModel:
 
         Raises:
             RuntimeError: If the HTTP request fails.
+            ValueError: If the API doesn't support stream mode.
         """
-
-        # Handle SambaNova's Fast API
-        if self._url == "https://fast-api.snova.ai/v1/chat/completions":
-            headers = {
-                "Authorization": f"Basic {self._api_key}",
-                "Content-Type": "application/json",
-            }
-
-            data = {
-                "messages": messages,
-                "max_tokens": self.token_limit,
-                "stop": self.model_config_dict.get("stop"),
-                "model": self.model_type,
-                "stream": True,
-                "stream_options": self.model_config_dict.get("stream_options"),
-            }
-
-            try:
-                with httpx.stream(
-                    "POST",
-                    self._url,
-                    headers=headers,
-                    json=data,
-                ) as api_response:
-                    stream = Stream[ChatCompletionChunk](
-                        cast_to=ChatCompletionChunk,
-                        response=api_response,
-                        client=OpenAI(api_key="required_but_not_used"),
-                    )
-                    for chunk in stream:
-                        yield chunk
-            except httpx.HTTPError as e:
-                raise RuntimeError(f"HTTP request failed: {e!s}")
-
         # Handle SambaNova's Cloud API
-        elif self._url == "https://api.sambanova.ai/v1":
+        if self._url == "https://api.sambanova.ai/v1":
             response = self._client.chat.completions.create(
                 messages=messages,
                 model=self.model_type,
                 **self.model_config_dict,
             )
+
+            # Add AgentOps LLM Event tracking
+            if LLMEvent:
+                llm_event = LLMEvent(
+                    thread_id=response.id,
+                    prompt=" ".join(
+                        [message.get("content") for message in messages]  # type: ignore[misc]
+                    ),
+                    prompt_tokens=response.usage.prompt_tokens,  # type: ignore[union-attr]
+                    completion=response.choices[0].message.content,
+                    completion_tokens=response.usage.completion_tokens,  # type: ignore[union-attr]
+                    model=self.model_type,
+                )
+                record(llm_event)
+
             return response
 
         elif self._url == "https://sambaverse.sambanova.ai/api/predict":
@@ -224,6 +211,7 @@ class SambaModel:
                 "https://sambaverse.sambanova.ai/api/predict doesn't support"
                 " stream mode"
             )
+        raise RuntimeError(f"Unknown URL: {self._url}")
 
     def _run_non_streaming(
         self, messages: List[OpenAIMessage]
@@ -243,51 +231,28 @@ class SambaModel:
             ValueError: If the JSON response cannot be decoded or is missing
                 expected data.
         """
-
-        # Handle SambaNova's Fast API
-        if self._url == "https://fast-api.snova.ai/v1/chat/completions":
-            headers = {
-                "Authorization": f"Basic {self._api_key}",
-                "Content-Type": "application/json",
-            }
-
-            data = {
-                "messages": messages,
-                "max_tokens": self.token_limit,
-                "stop": self.model_config_dict.get("stop"),
-                "model": self.model_type,
-                "stream": True,
-                "stream_options": self.model_config_dict.get("stream_options"),
-            }
-
-            try:
-                with httpx.stream(
-                    "POST",
-                    self._url,
-                    headers=headers,
-                    json=data,
-                ) as api_response:
-                    samba_response = []
-                    for chunk in api_response.iter_text():
-                        if chunk.startswith('data: '):
-                            chunk = chunk[6:]
-                        if '[DONE]' in chunk:
-                            break
-                        json_data = json.loads(chunk)
-                        samba_response.append(json_data)
-                    return self._fastapi_to_openai_response(samba_response)
-            except httpx.HTTPError as e:
-                raise RuntimeError(f"HTTP request failed: {e!s}")
-            except json.JSONDecodeError as e:
-                raise ValueError(f"Failed to decode JSON response: {e!s}")
-
         # Handle SambaNova's Cloud API
-        elif self._url == "https://api.sambanova.ai/v1":
+        if self._url == "https://api.sambanova.ai/v1":
             response = self._client.chat.completions.create(
                 messages=messages,
                 model=self.model_type,
                 **self.model_config_dict,
             )
+
+            # Add AgentOps LLM Event tracking
+            if LLMEvent:
+                llm_event = LLMEvent(
+                    thread_id=response.id,
+                    prompt=" ".join(
+                        [message.get("content") for message in messages]  # type: ignore[misc]
+                    ),
+                    prompt_tokens=response.usage.prompt_tokens,  # type: ignore[union-attr]
+                    completion=response.choices[0].message.content,
+                    completion_tokens=response.usage.completion_tokens,  # type: ignore[union-attr]
+                    model=self.model_type,
+                )
+                record(llm_event)
+
             return response
 
         # Handle SambaNova's Sambaverse API
@@ -370,56 +335,6 @@ class SambaModel:
             except httpx.HTTPStatusError:
                 raise RuntimeError(f"HTTP request failed: {raw_text}")
 
-    def _fastapi_to_openai_response(
-        self, samba_response: List[Dict[str, Any]]
-    ) -> ChatCompletion:
-        r"""Converts SambaNova Fast API response chunks into an
-            OpenAI-compatible response.
-
-        Args:
-            samba_response (List[Dict[str, Any]]): A list of dictionaries
-                representing partial responses from the SambaNova Fast API.
-
-        Returns:
-            ChatCompletion: A `ChatCompletion` object constructed from the
-                aggregated response data.
-        """
-
-        # Step 1: Combine the content from each chunk
-        full_content = ""
-        for chunk in samba_response:
-            if chunk['choices']:
-                for choice in chunk['choices']:
-                    delta_content = choice['delta'].get('content', '')
-                    full_content += delta_content
-
-        # Step 2: Create the ChatCompletion object
-        # Extract relevant information from the first chunk
-        first_chunk = samba_response[0]
-
-        choices = [
-            dict(
-                index=0,  # type: ignore[index]
-                message={
-                    "role": 'assistant',
-                    "content": full_content.strip(),
-                },
-                finish_reason=samba_response[-1]['choices'][0]['finish_reason']
-                or None,
-            )
-        ]
-
-        obj = ChatCompletion.construct(
-            id=first_chunk['id'],
-            choices=choices,
-            created=first_chunk['created'],
-            model=first_chunk['model'],
-            object="chat.completion",
-            usage=None,
-        )
-
-        return obj
-
     def _sambaverse_to_openai_response(
         self, samba_response: Dict[str, Any]
     ) -> ChatCompletion:
@@ -469,16 +384,6 @@ class SambaModel:
 
         return obj
 
-    @property
-    def token_limit(self) -> int:
-        r"""Returns the maximum token limit for the given model.
-
-        Returns:
-            int: The maximum token limit for the given model.
-        """
-        max_tokens = self.model_config_dict["max_tokens"]
-        return max_tokens
-
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode, which sends partial

camel/models/stub_model.py

@@ -51,8 +51,8 @@ class StubModel(BaseModelBackend):
 
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        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,

camel/models/togetherai_model.py

@@ -17,9 +17,14 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import TOGETHERAI_API_PARAMS
+from camel.configs import TOGETHERAI_API_PARAMS, TogetherAIConfig
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -27,45 +32,50 @@ from camel.utils import (
 )
 
 
-class TogetherAIModel:
+class TogetherAIModel(BaseModelBackend):
     r"""Constructor for Together AI backend with OpenAI compatibility.
-    TODO: Add function calling support
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, supported model can be found here:
+            https://docs.together.ai/docs/chat-models
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`TogetherAIConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Together service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Together AI service.
+            If not provided, "https://api.together.xyz/v1" will be used.
+            (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.
     """
 
     def __init__(
         self,
-        model_type: str,
-        model_config_dict: Dict[str, Any],
+        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,
     ) -> None:
-        r"""Constructor for TogetherAI backend.
-
-        Args:
-            model_type (str): Model for which a backend is created, supported
-                model can be found here: https://docs.together.ai/docs/chat-models
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            api_key (Optional[str]): The API key for authenticating with the
-                Together service. (default: :obj:`None`)
-            url (Optional[str]): The url to the Together AI service. (default:
-                :obj:`"https://api.together.xyz/v1"`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
-        self.model_type = model_type
-        self.model_config_dict = model_config_dict
-        self._token_counter = token_counter
-        self._api_key = api_key or os.environ.get("TOGETHER_API_KEY")
-        self._url = url or os.environ.get("TOGETHER_API_BASE_URL")
+        if model_config_dict is None:
+            model_config_dict = TogetherAIConfig().as_dict()
+        api_key = api_key or os.environ.get("TOGETHER_API_KEY")
+        url = url or os.environ.get(
+            "TOGETHER_API_BASE_URL", "https://api.together.xyz/v1"
+        )
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
 
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
             api_key=self._api_key,
-            base_url=self._url or "https://api.together.xyz/v1",
+            base_url=self._url,
         )
 
     @api_keys_required("TOGETHER_API_KEY")
@@ -130,19 +140,3 @@ class TogetherAIModel:
             bool: Whether the model is in stream mode.
         """
         return self.model_config_dict.get('stream', False)
-
-    @property
-    def token_limit(self) -> int:
-        r"""Returns the maximum token limit for the given model.
-
-        Returns:
-            int: The maximum token limit for the given model.
-        """
-        max_tokens = self.model_config_dict.get("max_tokens")
-        if isinstance(max_tokens, int):
-            return max_tokens
-        print(
-            "Must set `max_tokens` as an integer in `model_config_dict` when"
-            " setting up the model. Using 4096 as default value."
-        )
-        return 4096

camel/models/vllm_model.py

@@ -17,58 +17,66 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import VLLM_API_PARAMS
+from camel.configs import VLLM_API_PARAMS, VLLMConfig
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
 
 # flake8: noqa: E501
-class VLLMModel:
-    r"""vLLM service interface."""
+class VLLMModel(BaseModelBackend):
+    r"""vLLM service 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:`VLLMConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the model service. vLLM doesn't need API key, it would be ignored
+            if set. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service. If not
+            provided, :obj:`"http://localhost:8000/v1"` will be used.
+            (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`)
+
+    References:
+        https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
+    """
 
     def __init__(
         self,
-        model_type: str,
-        model_config_dict: Dict[str, Any],
-        url: Optional[str] = None,
+        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,
     ) -> None:
-        r"""Constructor for vLLM backend with OpenAI compatibility.
-
-        # Reference: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
-
-        Args:
-            model_type (str): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            url (Optional[str]): The url to the model service. (default:
-                :obj:`"http://localhost:8000/v1"`)
-            api_key (Optional[str]): The API key for authenticating with the
-                model service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
-        self.model_type = model_type
-        self.model_config_dict = model_config_dict
-        self._url = (
-            url
-            or os.environ.get("VLLM_BASE_URL")
-            or "http://localhost:8000/v1"
+        if model_config_dict is None:
+            model_config_dict = VLLMConfig().as_dict()
+        url = url or os.environ.get("VLLM_BASE_URL")
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
         )
-        if not url and not os.environ.get("VLLM_BASE_URL"):
+        if not self._url:
             self._start_server()
         # Use OpenAI cilent as interface call vLLM
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
+            api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,
-            api_key=api_key,
         )
-        self._token_counter = token_counter
-        self.check_model_config()
 
     def _start_server(self) -> None:
         r"""Starts the vllm server in a subprocess."""
@@ -78,8 +86,9 @@ class VLLMModel:
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             )
+            self._url = "http://localhost:8000/v1"
             print(
-                f"vllm server started on http://localhost:8000/v1 "
+                f"vllm server started on {self._url} "
                 f"for {self.model_type} model."
             )
         except Exception as e:
@@ -135,22 +144,6 @@ class VLLMModel:
         )
         return response
 
-    @property
-    def token_limit(self) -> int:
-        r"""Returns the maximum token limit for the given model.
-
-        Returns:
-            int: The maximum token limit for the given model.
-        """
-        max_tokens = self.model_config_dict.get("max_tokens")
-        if isinstance(max_tokens, int):
-            return max_tokens
-        print(
-            "Must set `max_tokens` as an integer in `model_config_dict` when"
-            " setting up the model. Using 4096 as default value."
-        )
-        return 4096
-
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode, which sends partial