camel-ai 0.2.3a1__py3-none-any.whl → 0.2.3a2__py3-none-any.whl

camel/models/reka_model.py

@@ -11,10 +11,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import os
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from camel.configs import REKA_API_PARAMS
+from camel.configs import REKA_API_PARAMS, RekaConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -22,6 +21,7 @@ from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
     api_keys_required,
+    dependencies_required,
 )
 
 if TYPE_CHECKING:
@@ -39,40 +39,42 @@ except (ImportError, AttributeError):
 
 
 class RekaModel(BaseModelBackend):
-    r"""Reka API in a unified BaseModelBackend interface."""
-
+    r"""Reka API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of REKA_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`Reka.chat.create()`. If :obj:`None`,
+            :obj:`RekaConfig().as_dict()` will be used. (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Reka service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Reka service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter` will
+            be used. (default: :obj:`None`)
+    """
+
+    @dependencies_required('reka')
     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,
     ) -> None:
-        r"""Constructor for Reka backend.
+        from reka.client import Reka
 
-        Args:
-            model_type (ModelType): Model for which a backend is created,
-                one of REKA_* series.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into `Reka.chat.create`.
-            api_key (Optional[str]): The API key for authenticating with the
-                Reka service. (default: :obj:`None`)
-            url (Optional[str]): The url to the Reka service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter` will be
-                used.
-        """
+        if model_config_dict is None:
+            model_config_dict = RekaConfig().as_dict()
+        api_key = api_key or os.environ.get("REKA_API_KEY")
+        url = url or os.environ.get("REKA_API_BASE_URL")
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._api_key = api_key or os.environ.get("REKA_API_KEY")
-        self._url = url or os.environ.get("REKA_SERVER_URL")
-
-        from reka.client import Reka
-
         self._client = Reka(api_key=self._api_key, base_url=self._url)
-        self._token_counter: Optional[BaseTokenCounter] = None
 
     def _convert_reka_to_openai_response(
         self, response: 'ChatResponse'
@@ -184,7 +186,7 @@ class RekaModel(BaseModelBackend):
 
         response = self._client.chat.create(
             messages=reka_messages,
-            model=self.model_type.value,
+            model=self.model_type,
             **self.model_config_dict,
         )
 
@@ -200,7 +202,7 @@ class RekaModel(BaseModelBackend):
                 prompt_tokens=openai_response.usage.input_tokens,  # type: ignore[union-attr]
                 completion=openai_response.choices[0].message.content,
                 completion_tokens=openai_response.usage.output_tokens,  # type: ignore[union-attr]
-                model=self.model_type.value,
+                model=self.model_type,
             )
             record(llm_event)
 

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